Merge pull request #143 from Mirantis/parameters-flow

Provisioner parameters and cluster metadata

kqueen/blueprints/api/generic_views.py

@@ -60,7 +60,7 @@ def dispatch_request(self, *args, **kwargs):
         self.check_access()
 
         if not request.json:
-            abort(400)
+            abort(400, description='JSON data expected')
 
         data = request.json
         if not isinstance(data, dict):
@@ -106,7 +106,7 @@ def dispatch_request(self, *args, **kwargs):
         self.check_access()
 
         if not request.json:
-            abort(400)
+            abort(400, description='JSON data expected')
         else:
             cls = self.get_class()
 
@@ -121,6 +121,6 @@ def dispatch_request(self, *args, **kwargs):
                 self.after_save()
             except Exception as e:
                 current_app.logger.error(e)
-                abort(500)
+                abort(500, description='Creation failed with: {}'.format(e))
 
             return super(CreateView, self).dispatch_request(*args, **kwargs)

kqueen/engines/test_manual.py

@@ -1,33 +1,54 @@
 from .manual import ManualEngine
+from flask import url_for
+from kqueen.conftest import auth_header
+from kqueen.conftest import user
 from kqueen.models import Cluster
 from kqueen.models import Provisioner
-from kqueen.conftest import user
 
-import yaml
+import json
 import pytest
+import yaml
+
+CLUSTER_METADATA = {
+    'minion_count': 10,
+    'cluster_type': 'ha',
+}
+
+PROVISIONER_PARAMETERS = {
+    'credentials': 'username:password',
+}
 
 
-class TestManualEngine:
+@pytest.mark.usefixtures('client_class')
+class ManualEngineBase:
     def setup(self):
         _user = user()
         create_kwargs_provisioner = {
             'name': 'Testing manual',
-            'engine': 'kqueen.engines.ManualEngine'
+            'engine': 'kqueen.engines.ManualEngine',
+            'parameters': PROVISIONER_PARAMETERS,
         }
 
         prov = Provisioner(_user.namespace, **create_kwargs_provisioner)
         prov.save(check_status=False)
 
-        create_kwargs_cluster = {
+        self.create_kwargs_cluster = {
             'name': 'Testing cluster for manual provisioner',
             'provisioner': prov,
             'state': 'deployed',
             'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()),
+            'metadata': CLUSTER_METADATA,
         }
 
-        self.cluster = Cluster.create(_user.namespace, **create_kwargs_cluster)
+        self.cluster = Cluster.create(_user.namespace, **self.create_kwargs_cluster)
         self.engine = ManualEngine(cluster=self.cluster)
 
+        # client setup
+        self.auth_header = auth_header(self.client)
+        self.namespace = self.auth_header['X-Test-Namespace']
+
+
+class TestClusterAction(ManualEngineBase):
     def test_initialization(self):
         assert self.engine.cluster == self.cluster
 
@@ -58,3 +79,58 @@ def test_engine_status(self):
 
     def test_parameter_schema(self):
         assert self.engine.get_parameter_schema() == {}
+
+
+class TestCreateOverAPI(ManualEngineBase):
+    def test_create_over_api(self):
+        """Verify Cluster is created over API and kubeconfig is set"""
+
+        url = url_for('api.cluster_list')
+        data = self.create_kwargs_cluster
+        data['provisioner'] = 'Provisioner:{}'.format(data['provisioner'].id)
+
+        # create
+        response = self.client.post(
+            url,
+            data=json.dumps(data),
+            headers=self.auth_header,
+            content_type='application/json'
+        )
+
+        assert response.status_code == 200
+
+        # load
+        cluster_id = response.json['id']
+        obj = Cluster.load(self.namespace, cluster_id)
+        assert obj.validate()
+
+        # check parameters
+        assert obj.kubeconfig == data['kubeconfig']
+
+        return obj
+
+    @pytest.mark.parametrize('metadata_name', list(CLUSTER_METADATA.keys()))
+    def test_metadata_parameters_direct(self, metadata_name):
+        assert metadata_name in self.cluster.metadata
+        assert self.cluster.metadata[metadata_name] == CLUSTER_METADATA[metadata_name]
+
+    @pytest.mark.parametrize('metadata_name', list(CLUSTER_METADATA.keys()))
+    def test_metadata_parameters_api(self, metadata_name):
+        obj = self.test_create_over_api()
+
+        assert metadata_name in obj.metadata
+        assert obj.metadata[metadata_name] == CLUSTER_METADATA[metadata_name]
+
+    @pytest.mark.parametrize('param_name', list(CLUSTER_METADATA.keys()) + list(PROVISIONER_PARAMETERS.keys()))
+    def test_engine_gets_parameters(self, param_name, monkeypatch):
+        obj = self.test_create_over_api()
+
+        def fake_init(self, cluster, **kwargs):
+            self.cluster = cluster
+            self.test_kwargs = kwargs
+
+        monkeypatch.setattr(ManualEngine, '__init__', fake_init)
+
+        engine = obj.engine
+
+        assert param_name in engine.test_kwargs

kqueen/models.py

@@ -52,7 +52,11 @@ def engine(self):
         if self.provisioner:
             _class = self.provisioner.get_engine_cls()
             if _class:
-                parameters = self.provisioner.parameters or {}
+                parameters = {}
+                for i in [self.provisioner.parameters, self.metadata]:
+                    if isinstance(i, dict):
+                        parameters.update(i)
+
                 return _class(self, **parameters)
         return None
 
@@ -312,6 +316,7 @@ def alive(self):
     def save(self, check_status=True):
         if check_status:
             self.state = self.engine_status(save=False)
+
         return super(Provisioner, self).save()