feat(scheduler): add scheduler tests that do not go through normal api tests (#965)

This expands the scheduler test suite and can run outside of the API setup. Brings is simple testing per resource type.

Also fixes a few mock and scheduler discrepencies that were discovered in the testing

Author: helgi

rootfs/api/tests/test_utils.py

@@ -4,34 +4,42 @@
 
 class TestUtils(unittest.TestCase):
     """Test utils functions"""
+    def test_dict_merge_not_dict(self):
+        """
+        second item is not a dict, which dict_merge will just return
+        """
+        a = {'key': 'value'}
+        b = 'somethig'
+        c = utils.dict_merge(a, b)
+        self.assertEqual(c, b)
 
     def test_dict_merge_simple(self):
         a = {'key': 'value'}
         b = {'key': 'value'}
 
         c = utils.dict_merge(a, b)
-        assert c == {'key': 'value'}
+        self.assertEqual(c, {'key': 'value'})
 
         a = {'key': 'value'}
         b = {'key2': 'value'}
 
         c = utils.dict_merge(a, b)
-        assert c == {'key': 'value', 'key2': 'value'}
+        self.assertEqual(c, {'key': 'value', 'key2': 'value'})
 
     def test_dict_merge_deeper(self):
         a = {'key': 'value', 'here': {'without': 'you'}}
         b = {'this': 'that', 'here': {'with': 'me'}, 'other': {'magic', 'unicorn'}}
 
         c = utils.dict_merge(a, b)
-        assert c == {
+        self.assertEqual(c, {
             'key': 'value',
             'this': 'that',
             'here': {
                 'with': 'me',
                 'without': 'you'
             },
             'other': {'magic', 'unicorn'}
-        }
+        })
 
     def test_dict_merge_even_deeper(self):
         a = {
@@ -48,7 +56,7 @@ def test_dict_merge_even_deeper(self):
         }
 
         c = utils.dict_merge(a, b)
-        assert c == {
+        self.assertEqual(c, {
             'key': 'value',
             'this': 'that',
             'here': {'with': 'me', 'without': 'you'},
@@ -60,19 +68,28 @@ def test_dict_merge_even_deeper(self):
                     'char3': 'Cox'
                 }
             }
-        }
+        })
 
     def test_dict_merge_with_list(self):
         a = {'key': 'value', 'names': ['bob', 'kyle', 'kenny', 'jimbo']}
         b = {'key': 'value', 'names': ['kenny', 'cartman', 'stan']}
 
         c = utils.dict_merge(a, b)
-        assert c == {'key': 'value', 'names': ['bob', 'kyle', 'kenny', 'jimbo', 'cartman', 'stan']}
+        self.assertEqual(c, {'key': 'value', 'names': ['bob', 'kyle', 'kenny',
+                                                       'jimbo', 'cartman', 'stan']})
+
+        a = {'key': 'value', 'names': ['bob', 'kyle', 'kenny', 'jimbo']}
+        b = {'key': 'value', 'last_names': ['kenny', 'cartman', 'stan']}
+
+        c = utils.dict_merge(a, b)
+        self.assertEqual(c, {'key': 'value',
+                             'names': ['bob', 'kyle', 'kenny', 'jimbo'],
+                             'last_names': ['kenny', 'cartman', 'stan']})
 
     def test_dict_merge_bad_merge(self):
         """Returns b because it isn't a dict"""
         a = {'key': 'value'}
         b = 'duh'
 
         c = utils.dict_merge(a, b)
-        assert c == b
+        self.assertEqual(c, b)

rootfs/scheduler/__init__.py

@@ -31,11 +31,10 @@ def __init__(self, response, errmsg, *args, **kwargs):
         self.response = response
 
         msg = errmsg.format(*args)
-        msg = "failed to {}: {} {}\n{}".format(
+        msg = "failed to {}: {} {}".format(
             msg,
             response.status_code,
-            response.reason,
-            response.json()
+            response.reason
         )
         KubeException.__init__(self, msg, *args, **kwargs)
 
@@ -110,30 +109,21 @@ def deploy(self, namespace, name, image, entrypoint, command, **kwargs):  # noqa
                 return
         except KubeException:
             # create the initial deployment object (and the first revision)
-            self.create_deployment(namespace,
-                                   name,
-                                   image,
-                                   entrypoint,
-                                   command,
-                                   **kwargs)
+            self.create_deployment(
+                namespace, name, image, entrypoint, command, **kwargs
+            )
         else:
             try:
                 # kick off a new revision of the deployment
-                self.update_deployment(namespace,
-                                       name,
-                                       image,
-                                       entrypoint,
-                                       command,
-                                       **kwargs)
+                self.update_deployment(
+                    namespace, name, image, entrypoint, command, **kwargs
+                )
             except KubeException as e:
                 # rollback to the previous Deployment
                 kwargs['rollback'] = True
-                self.update_deployment(namespace,
-                                       name,
-                                       image,
-                                       entrypoint,
-                                       command,
-                                       **kwargs)
+                self.update_deployment(
+                    namespace, name, image, entrypoint, command, **kwargs
+                )
 
                 raise KubeException(
                     'There was a problem while deploying {} of {}-{}. '
@@ -307,7 +297,13 @@ def scale(self, namespace, name, image, entrypoint, command, **kwargs):
                 try:
                     self.create_deployment(namespace, name, image, entrypoint, command, **kwargs)
                 except KubeException:
-                    self.delete_deployment(namespace, name)
+                    # see if the deployment got created
+                    try:
+                        self.get_deployment(namespace, name)
+                    except KubeHTTPException as e:
+                        if e.response.status_code != 404:
+                            self.delete_deployment(namespace, name)
+
                     raise
 
         # let the scale failure bubble up
@@ -819,9 +815,7 @@ def create_namespace(self, namespace):
     def delete_namespace(self, namespace):
         url = self._api("/namespaces/{}", namespace)
         response = self.session.delete(url)
-        if response.status_code == 404:
-            logger.warn('delete Namespace "{}": not found'.format(namespace))
-        elif response.status_code != 200:
+        if unhealthy(response.status_code):
             raise KubeHTTPException(response, 'delete Namespace "{}"', namespace)
 
         return response
@@ -1176,7 +1170,7 @@ def get_secret(self, namespace, name):
                 secrets['data'][key] = ""
                 continue
             value = base64.b64decode(value)
-            value = value if isinstance(value, bytes) else bytes(value, 'UTF-8')
+            value = value if isinstance(value, bytes) else bytes(str(value), 'UTF-8')
             secrets['data'][key] = value.decode(encoding='UTF-8')
 
         # tell python-requests it actually hasn't consumed the data
@@ -1216,7 +1210,11 @@ def _build_secret_manifest(self, namespace, name, data, secret_type='Opaque', la
         manifest['metadata']['labels'].update(labels)
 
         for key, value in data.items():
-            value = value if isinstance(value, bytes) else bytes(value, 'UTF-8')
+            if value is None:
+                manifest['data'].update({key: ''})
+                continue
+
+            value = value if isinstance(value, bytes) else bytes(str(value), 'UTF-8')
             item = base64.b64encode(value).decode(encoding='UTF-8')
             manifest['data'].update({key: item})
 
@@ -1279,13 +1277,13 @@ def get_services(self, namespace, **kwargs):
 
         return response
 
-    def create_service(self, namespace, name, data={}, **kwargs):
+    def create_service(self, namespace, name, **kwargs):
         # Ports and app type will be overwritten as required
         manifest = {
             'kind': 'Service',
             'apiVersion': 'v1',
             'metadata': {
-                'name': namespace,
+                'name': name,
                 'labels': {
                     'app': namespace,
                     'heritage': 'deis'
@@ -1306,7 +1304,7 @@ def create_service(self, namespace, name, data={}, **kwargs):
             }
         }
 
-        data = dict_merge(manifest, data)
+        data = dict_merge(manifest, kwargs.get('data', {}))
         url = self._api("/namespaces/{}/services", namespace)
         response = self.session.post(url, json=data)
         if unhealthy(response.status_code):
@@ -1841,6 +1839,10 @@ def _build_deployment_manifest(self, namespace, name, image, entrypoint, command
         return manifest
 
     def _scale_deployment(self, namespace, name, image, entrypoint, command, **kwargs):
+        """
+        A convenience wrapper around Deployment update that does a little bit of introspection
+        to determine if scale level is already where it needs to be
+        """
         deployment = self.get_deployment(namespace, name).json()
         desired = int(kwargs.get('replicas'))
         current = int(deployment['spec']['replicas'])

rootfs/scheduler/mock.py

@@ -1,3 +1,4 @@
+import copy
 from datetime import datetime, timedelta
 import json
 import random
@@ -360,7 +361,7 @@ def manage_replicasets(deployment, url):
     rs_url = url.replace('_deployments_', '_replicasets_')
 
     # create new RS
-    rs = deployment.copy()
+    rs = copy.deepcopy(deployment)
     rs['kind'] = 'ReplicaSet'
     # fix up the name
     rs['metadata']['name'] = rs['metadata']['name'] + '-' + pod_hash
@@ -553,13 +554,21 @@ def post(request, context):
     """Process a POST request to the kubernetes API"""
     data = request.json()
     url = cache_key(request.url + '/' + data['metadata']['name'] + '/')
+    resource_type = get_type(request.url)
+    # check if the namespace being posted to exists
+    if resource_type != 'namespaces':
+        namespace, _ = url.split('_{}_'.format(resource_type))
+        namespace = namespace.replace('apis_extensions_v1beta1', 'api_v1')
+        if cache.get(namespace) is None:
+            context.status_code = 404
+            context.reason = 'Not Found'
+            return {}
+
     if cache.get(url) is not None:
         context.status_code = 409
         context.reason = 'Conflict'
         return {}
 
-    resource_type = get_type(request.url)
-
     # fill in generic data
     timestamp = str(datetime.utcnow().strftime(settings.DEIS_DATETIME_FORMAT))
     data['metadata']['creationTimestamp'] = timestamp
@@ -598,6 +607,17 @@ def post(request, context):
 def put(request, context):
     """Process a PUT request to the kubernetes API"""
     url = cache_key(request.url)
+    # type is the second last element
+    resource_type = get_type(request.url, -2)
+    # check if the namespace being posted to exists
+    if resource_type != 'namespaces':
+        namespace, _ = url.split('_{}_'.format(resource_type))
+        namespace = namespace.replace('apis_extensions_v1beta1', 'api_v1')
+        if cache.get(namespace) is None:
+            context.status_code = 404
+            context.reason = 'Not Found'
+            return {}
+
     item = cache.get(url)
     if item is None:
         context.status_code = 404
@@ -606,9 +626,6 @@ def put(request, context):
 
     data = request.json()
 
-    # type is the second last element
-    resource_type = get_type(request.url, -2)
-
     # merge new data into old but keep labels separate in case they changed
     labels = data['metadata'].pop('labels')
     item['metadata'].update(data['metadata'])

rootfs/scheduler/tests/__init__.py

@@ -0,0 +1,36 @@
+from django.core.cache import cache
+from django.test import TestCase as DjangoTestCase
+
+from scheduler import mock
+from scheduler.utils import generate_random_name
+
+
+class TestCase(DjangoTestCase):
+    def setUp(self):
+        self.scheduler = mock.MockSchedulerClient()
+        # have a namespace available at all times
+        self.namespace = self.create_namespace()
+
+    def tearDown(self):
+        # make sure every test has a clean slate for k8s mocking
+        cache.clear()
+
+    def create_namespace(self):
+        namespace = generate_random_name()
+        response = self.scheduler.create_namespace(namespace)
+        self.assertEqual(response.status_code, 201, response.json())
+        # assert minimal amount data
+        data = response.json()
+        self.assertEqual(data['apiVersion'], 'v1')
+        self.assertEqual(data['kind'], 'Namespace')
+        self.assertDictContainsSubset(
+            {
+                'name': namespace,
+                'labels': {
+                    'heritage': 'deis'
+                }
+            },
+            data['metadata']
+        )
+
+        return namespace