Added test case to check whether celery task executes properly on production.

datacenterlight/tests.py

@@ -1,3 +1,120 @@
 # from django.test import TestCase
 
+from time import sleep
+
+import stripe
+from celery.result import AsyncResult
+from django.conf import settings
+from django.core.management import call_command
 # Create your tests here.
+from django.test import TestCase, override_settings
+from model_mommy import mommy
+
+from datacenterlight.models import VMTemplate
+from datacenterlight.tasks import create_vm_task
+from membership.models import StripeCustomer
+from opennebula_api.serializers import VMTemplateSerializer
+from utils.models import BillingAddress
+from utils.stripe_utils import StripeUtils
+
+
+class CeleryTaskTestCase(TestCase):
+    @override_settings(
+        task_eager_propagates=True,
+        task_always_eager=True,
+    )
+    def setUp(self):
+        self.customer_password = 'test_password'
+        self.customer_email = 'celery-createvm-task-test@ungleich.ch'
+        self.customer_name = "Monty Python"
+        self.user = {
+            'email': self.customer_email,
+            'name': self.customer_name
+        }
+        self.customer = mommy.make('membership.CustomUser')
+        self.customer.set_password(self.customer_password)
+        self.customer.email = self.customer_email
+        self.customer.save()
+        self.stripe_utils = StripeUtils()
+        stripe.api_key = settings.STRIPE_API_PRIVATE_KEY_TEST
+        self.token = stripe.Token.create(
+            card={
+                "number": '4111111111111111',
+                "exp_month": 12,
+                "exp_year": 2022,
+                "cvc": '123'
+            },
+        )
+        # Run fetchvmtemplates so that we have the VM templates from
+        # OpenNebula
+        call_command('fetchvmtemplates')
+
+    def test_create_vm_task(self):
+        """Tests the create vm task."""
+
+        # We create a VM from the first template available to DCL
+        vm_template = VMTemplate.objects.all().first()
+        template_data = VMTemplateSerializer(vm_template).data
+
+        # The specs of VM that we want to create
+        specs = {
+            'cpu': 1,
+            'memory': 2,
+            'disk_size': 10,
+            'price': 15,
+        }
+
+        stripe_customer = StripeCustomer.get_or_create(
+            email=self.customer_email,
+            token=self.token)
+        billing_address = BillingAddress(
+            cardholder_name=self.customer_name,
+            postal_code='1232',
+            country='CH',
+            street_address='Monty\'s Street',
+            city='Hollywood')
+        billing_address.save()
+        billing_address_data = {'cardholder_name': self.customer_name,
+                                'postal_code': '1231',
+                                'country': 'CH',
+                                'token': self.token,
+                                'street_address': 'Monty\'s Street',
+                                'city': 'Hollywood'}
+
+        billing_address_id = billing_address.id
+        vm_template_id = template_data.get('id', 1)
+        final_price = specs.get('price')
+
+        # Make stripe charge to a customer
+        stripe_utils = StripeUtils()
+        charge_response = stripe_utils.make_charge(
+            amount=final_price,
+            customer=stripe_customer.stripe_id)
+
+        # Check if the payment was approved
+        if not charge_response.get(
+                'response_object') and not charge_response.get('paid'):
+            msg = charge_response.get('error')
+            raise Exception("make_charge failed: {}".format(msg))
+
+        charge = charge_response.get('response_object')
+        async_task = create_vm_task.delay(vm_template_id, self.user,
+                                          specs,
+                                          template_data,
+                                          stripe_customer.id,
+                                          billing_address_data,
+                                          billing_address_id,
+                                          charge)
+        new_vm_id = 0
+        res = None
+        for i in range(0, 10):
+            sleep(5)
+            res = AsyncResult(async_task.task_id)
+            if res.result is not None and res.result > 0:
+                new_vm_id = res.result
+                break
+
+        # We expect a VM to be created within 50 seconds
+        self.assertGreater(new_vm_id, 0,
+                           "VM could not be created. res._get_task_meta() = {}"
+                           .format(res._get_task_meta()))