improve code coverage on api views/models

Author: Gabriel Monroy

api/models.py

@@ -7,6 +7,7 @@
 # pylint: disable=R0903,W0232
 
 from __future__ import unicode_literals
+import importlib
 import os
 import subprocess
 
@@ -19,18 +20,16 @@
 from django.dispatch.dispatcher import Signal
 from django.utils.encoding import python_2_unicode_compatible
 
-from api import fields
+from api import fields, tasks
 from provider import import_provider_module
 
+# import user-defined configuration management module
+CM = importlib.import_module(settings.CM_MODULE)
+
 
 # define custom signals
 release_signal = Signal(providing_args=['user', 'app'])
 
-# define custom exceptions
-
-
-class ScalingError(Exception):
-    pass
 
 # base models
 
@@ -90,7 +89,7 @@ def seed(self, user, **kwargs):
         """
         Seeds the database with Providers for clouds supported by Deis.
         """
-        providers = (('ec2', 'ec2'), ('mock', 'mock'))
+        providers = [(p, p) for p in settings.PROVIDER_MODULES]
         for p_id, p_type in providers:
             self.create(owner=user, id=p_id, type=p_type, creds='{}')
 
@@ -120,19 +119,14 @@ class Meta:
     def __str__(self):
         return "{}-{}".format(self.id, self.get_type_display())
 
-    def flat(self):
-        return {'id': self.id,
-                'type': self.type,
-                'creds': dict(self.creds)}
-
 
 @python_2_unicode_compatible
 class FlavorManager(models.Manager):
     """Manage database interactions for :class:`Flavor`."""
 
     def seed(self, user, **kwargs):
         """Seed the database with default Flavors for each cloud region."""
-        for provider_type in ('mock', 'ec2'):
+        for provider_type in settings.PROVIDER_MODULES:
             provider = import_provider_module(provider_type)
             flavors = provider.seed_flavors()
             p = Provider.objects.get(owner=user, id=provider_type)
@@ -162,48 +156,13 @@ class Meta:
     def __str__(self):
         return self.id
 
-    def flat(self):
-        return {'id': self.id,
-                'creds': dict(self.provider.creds),
-                'provider': self.provider.id,
-                'params': self.params}
-
-
-@python_2_unicode_compatible
-class FormationManager(models.Manager):
-    """Manage database interactions for :class:`Formation`."""
-
-    def next_container_node(self, formation, container_type, reverse=False):
-        count = []
-        layers = formation.layer_set.filter(runtime=True)
-        runtime_nodes = []
-        for l in layers:
-            runtime_nodes.extend(Node.objects.filter(
-                formation=formation, layer=l).order_by('created'))
-        container_map = {n: [] for n in runtime_nodes}
-        containers = list(Container.objects.filter(
-            formation=formation, type=container_type).order_by('created'))
-        for c in containers:
-            container_map[c.node].append(c)
-        for n in container_map.keys():
-            # (2, node3), (2, node2), (3, node1)
-            count.append((len(container_map[n]), n))
-        if not count:
-            raise ScalingError('No nodes available for containers')
-        count.sort()
-        # reverse means order by greatest # of containers, otherwise fewest
-        if reverse:
-            count.reverse()
-        return count[0][1]
-
 
 @python_2_unicode_compatible
 class Formation(UuidAuditedModel):
 
     """
     Formation of nodes used to host applications
     """
-    objects = FormationManager()
 
     owner = models.ForeignKey(settings.AUTH_USER_MODEL)
     id = models.SlugField(max_length=64, unique=True)
@@ -381,6 +340,29 @@ def scale(self, formation, structure, **kwargs):
             return formation.converge()
         return formation.calculate()
 
+    def next_runtime_node(self, formation, container_type, reverse=False):
+        count = []
+        layers = formation.layer_set.filter(runtime=True)
+        runtime_nodes = []
+        for l in layers:
+            runtime_nodes.extend(Node.objects.filter(
+                formation=formation, layer=l).order_by('created'))
+        container_map = {n: [] for n in runtime_nodes}
+        containers = list(Container.objects.filter(
+            formation=formation, type=container_type).order_by('created'))
+        for c in containers:
+            container_map[c.node].append(c)
+        for n in container_map.keys():
+            # (2, node3), (2, node2), (3, node1)
+            count.append((len(container_map[n]), n))
+        if not count:
+            raise EnvironmentError('No nodes available for containers')
+        count.sort()
+        # reverse means order by greatest # of containers, otherwise fewest
+        if reverse:
+            count.reverse()
+        return count[0][1]
+
 
 @python_2_unicode_compatible
 class Node(UuidAuditedModel):
@@ -555,7 +537,7 @@ def scale(self, app, structure, **kwargs):
             changed = True
             while diff < 0:
                 # get the next node with the most containers
-                node = Formation.objects.next_container_node(
+                node = Node.objects.next_runtime_node(
                     formation, container_type, reverse=True)
                 # delete a container attached to that node
                 for c in containers:
@@ -566,7 +548,7 @@ def scale(self, app, structure, **kwargs):
                         break
             while diff > 0:
                 # get the next node with the fewest containers
-                node = Formation.objects.next_container_node(formation, container_type)
+                node = Node.objects.next_runtime_node(formation, container_type)
                 c = Container.objects.create(owner=app.owner,
                                              formation=formation,
                                              node=node,
@@ -836,11 +818,3 @@ def _publish_user_to_cm(**kwargs):
 post_save.connect(_publish_to_cm, sender=App, dispatch_uid='api.models')
 post_save.connect(_publish_to_cm, sender=Formation, dispatch_uid='api.models')
 post_save.connect(_publish_user_to_cm, sender=User, dispatch_uid='api.models')
-
-
-# now that we've defined models that may be imported by celery tasks
-# import tasks and user-defined config management module
-from api import tasks
-
-import importlib
-CM = importlib.import_module(settings.CM_MODULE)

api/tests/auth.py

@@ -7,9 +7,9 @@
 from __future__ import unicode_literals
 
 import json
+import urllib
 
 from django.test import TestCase
-import urllib
 
 
 class AuthTest(TestCase):
@@ -56,11 +56,11 @@ def test_auth(self):
         url = '/api/providers'
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.data['count'], 2)
+        self.assertEqual(response.data['count'], 1)
         url = '/api/flavors'
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.data['count'], 10)
+        self.assertEqual(response.data['count'], 2)
         # test logout and login
         url = '/api/auth/logout/'
         response = self.client.post(url, content_type='application/json')

api/tests/container.py

@@ -115,6 +115,17 @@ def test_container_scale(self):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data['containers'], json.dumps(body))
 
+    def test_container_scale_errors(self):
+        url = '/api/apps'
+        body = {'formation': 'autotest'}
+        response = self.client.post(url, json.dumps(body), content_type='application/json')
+        self.assertEqual(response.status_code, 201)
+        app_id = response.data['id']
+        url = "/api/apps/{app_id}/scale".format(**locals())
+        body = {'web': 'not_an_int'}
+        response = self.client.post(url, json.dumps(body), content_type='application/json')
+        self.assertContains(response, 'Invalid scaling format', status_code=400)
+
     def test_container_scale_single_layer(self):
         # create & scale a single layer formation
         response = self.client.post('/api/formations', json.dumps(

api/tests/node.py

@@ -140,22 +140,28 @@ def test_node_scale(self):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data['nodes'], json.dumps(body))
 
-    def test_node_no_creds(self):
-        url = '/api/providers/autotest'
-        body = {'creds': json.dumps({})}
-        response = self.client.patch(url, json.dumps(body), content_type='application/json')
-        self.assertEqual(response.status_code, 200)
-        # try to scale and a formation
+    def test_node_scale_errors(self):
         url = '/api/formations'
-        body = {'id': 'autotest', 'domain': 'localhost.localdomain'}
+        body = {'id': 'autotest'}
         response = self.client.post(url, json.dumps(body), content_type='application/json')
         self.assertEqual(response.status_code, 201)
         formation_id = response.data['id']  # noqa
+        url = '/api/formations/{formation_id}/scale'.format(**locals())
+        body = {'runtime': 'not_an_int'}
+        response = self.client.post(url, json.dumps(body), content_type='application/json')
+        self.assertContains(response, 'Invalid scaling format', status_code=400)
+        body = {'runtime': '1'}
+        response = self.client.post(url, json.dumps(body), content_type='application/json')
+        self.assertContains(response, 'Layer matching query does not exist', status_code=400)
+        url = '/api/providers/autotest'
+        body = {'creds': json.dumps({})}
+        response = self.client.patch(url, json.dumps(body), content_type='application/json')
+        self.assertEqual(response.status_code, 200)
         url = '/api/formations/{formation_id}/layers'.format(**locals())
         body = {'id': 'runtime', 'flavor': 'autotest', 'run_list': 'recipe[deis::runtime]'}
         response = self.client.post(url, json.dumps(body), content_type='application/json')
         self.assertEqual(response.status_code, 201)
         url = '/api/formations/{formation_id}/scale'.format(**locals())
         body = {'runtime': 1}
         response = self.client.post(url, json.dumps(body), content_type='application/json')
-        self.assertEqual(response.status_code, 400)
+        self.assertContains(response, 'No provider credentials available', status_code=400)

api/tests/provider.py

@@ -27,8 +27,8 @@ def test_provider(self):
         environment variables
         """
         url = '/api/providers'
-        creds = {'secret_key': 'x'*64, 'access_key': 1*20}
-        body = {'id': 'autotest', 'type': 'ec2', 'creds': json.dumps(creds)}
+        creds = {'secret_key': 'x' * 64, 'access_key': 1 * 20}
+        body = {'id': 'autotest', 'type': 'mock', 'creds': json.dumps(creds)}
         response = self.client.post(url, json.dumps(body), content_type='application/json')
         self.assertEqual(response.status_code, 201)
         provider_id = response.data['id']
@@ -39,10 +39,10 @@ def test_provider(self):
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
         new_creds = {'access_key': 'new', 'secret_key': 'new'}
-        body = {'type': 'ec2', 'creds': json.dumps(new_creds)}
+        body = {'type': 'mock', 'creds': json.dumps(new_creds)}
         response = self.client.patch(url, json.dumps(body), content_type='application/json')
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data['creds'], json.dumps(new_creds))
-        self.assertEqual(response.data['type'], 'ec2')
+        self.assertEqual(response.data['type'], 'mock')
         response = self.client.delete(url)
         self.assertEqual(response.status_code, 204)

api/views.py

@@ -9,7 +9,6 @@
 from Crypto.PublicKey import RSA
 from celery.canvas import group
 from django.contrib.auth.models import AnonymousUser, User
-from django.db.utils import IntegrityError
 from django.utils import timezone
 from rest_framework import permissions, status, viewsets
 from rest_framework.authentication import BaseAuthentication
@@ -128,18 +127,6 @@ class FormationViewSet(OwnerViewSet):
     serializer_class = serializers.FormationSerializer
     lookup_field = 'id'
 
-    def create(self, request, **kwargs):
-        request._data = request.DATA.copy()
-        try:
-            return OwnerViewSet.create(self, request, **kwargs)
-        except EnvironmentError as e:
-            return Response(str(e), status=HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if 'violates unique constraint' in str(e).lower():
-                return Response('Formation with this Id already exists.',
-                                status=HTTP_400_BAD_REQUEST)
-            raise e
-
     def post_save(self, formation, created=False, **kwargs):
         if created:
             formation.build()
@@ -160,8 +147,6 @@ def scale(self, request, **kwargs):
         formation = self.get_object()
         try:
             databag = models.Node.objects.scale(formation, new_structure)
-        except models.ScalingError as e:
-            return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
         except models.Layer.DoesNotExist as e:
             return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
         return Response(databag, status=status.HTTP_200_OK,
@@ -187,10 +172,7 @@ def converge(self, request, **kwargs):
 
     def destroy(self, request, **kwargs):
         formation = self.get_object()
-        try:
-            formation.destroy()
-        except EnvironmentError as e:
-            return Response(str(e), status=HTTP_400_BAD_REQUEST)
+        formation.destroy()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -225,11 +207,7 @@ def create(self, request, **kwargs):
             key = RSA.generate(2048)
             request.DATA['ssh_private_key'] = key.exportKey('PEM')
             request.DATA['ssh_public_key'] = key.exportKey('OpenSSH')
-        try:
-            return OwnerViewSet.create(self, request, **kwargs)
-        except IntegrityError:
-            return Response("Layer with this Id already exists",
-                            status=HTTP_400_BAD_REQUEST)
+        return OwnerViewSet.create(self, request, **kwargs)
 
     def post_save(self, layer, created=False, **kwargs):
         if created:
@@ -254,10 +232,7 @@ def get_object(self, *args, **kwargs):
 
     def destroy(self, request, **kwargs):
         node = self.get_object()
-        try:
-            node.destroy()
-        except EnvironmentError as e:
-            return Response(str(e), status=HTTP_400_BAD_REQUEST)
+        node.destroy()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -275,16 +250,6 @@ class AppViewSet(OwnerViewSet):
     serializer_class = serializers.AppSerializer
     lookup_field = 'id'
 
-    def create(self, request, **kwargs):
-        request._data = request.DATA.copy()
-        try:
-            return OwnerViewSet.create(self, request, **kwargs)
-        except IntegrityError:
-            return Response('App with this Id already exists.',
-                            status=HTTP_400_BAD_REQUEST)
-        except EnvironmentError as e:
-            return Response(str(e), status=HTTP_400_BAD_REQUEST)
-
     def post_save(self, app, created=False, **kwargs):
         if created:
             app.build()
@@ -300,11 +265,9 @@ def scale(self, request, **kwargs):
             return Response('Invalid scaling format', status=HTTP_400_BAD_REQUEST)
         app = self.get_object()
         try:
-            changed = models.Container.objects.scale(app, new_structure)
-        except models.ScalingError as e:
+            models.Container.objects.scale(app, new_structure)
+        except EnvironmentError as e:
             return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
-        if not changed:
-            return Response(status=status.HTTP_204_NO_CONTENT)
         # save new structure now that scaling was successful
         app.containers.update(new_structure)
         app.save()

deis/settings.py

@@ -275,6 +275,9 @@
 CM_MODULE = 'cm.mock'
 TEMPDIR = tempfile.mkdtemp(prefix='deis')
 
+# default providers, typically overriden in local_settings to include ec2, etc.
+PROVIDER_MODULES = ('mock',)
+
 # Create a file named "local_settings.py" to contain sensitive settings data
 # such as database configuration, admin email, or passwords and keys. It
 # should also be used for any settings which differ between development

provider/__init__.py

@@ -5,8 +5,5 @@ def import_provider_module(provider_type):
     """
     Return the module for a provider.
     """
-    try:
-        tasks = importlib.import_module('provider.' + provider_type)
-    except ImportError as e:
-        raise e
+    tasks = importlib.import_module('provider.' + provider_type)
     return tasks