Example #1
0
class TestTask(TestCase):

    def test_defaults(self):
        t = Thing.create_thing(sim_class=TestSim2)
        t.save()
        self.task = Task(thing=t, name='foo')
        self.task.save()
        id = self.task.id

        task2 = Task.objects.get(id=id)
        self.assertEquals(task2.thing, t)
        self.assertEquals(task2.kwargs, {})
        self.assertEquals(task2.result, None)
        self.assertEquals(task2.name, 'foo')
        self.assert_(task2.authorization)
        self.assertEquals(len(task2.authorization), 64)
        self.assertEquals(task2.result, None)
        self.assertEquals(task2.status, 'REQUESTED')

    def test_call_method(self):
        self.test_defaults()
        task2 = Task.objects.get(id=self.task.id)
        self.assertEquals(task2.result, None)
        self.assertEquals(task2.status, 'REQUESTED')
        task2.call_sim_method()
        task3 = Task.objects.get(id=self.task.id)
        self.assertEquals(task3.result, 'foo')
        self.assertEquals(task3.status, 'COMPLETED')
Example #2
0
 def test_sim_task_call(self):
     sim = Thing.create_sim(HelloRobot)
     task = Task(thing=Thing.objects.get(uuid=sim.uuid), name='hello')
     task.save()
     task2 = Task.objects.get(id=task.id)
     self.assertEquals(task2.status, 'REQUESTED')
     self.assertEquals(call_sim_task_method(sim.uuid, task.id, 'sim_task_hello'), 'Hello')
     task2 = Task.objects.get(id=task.id)
     self.assertEquals(task2.status, 'COMPLETED')
Example #3
0
    def setUp(self):
        super(TestTaskResource, self).setUp()

        # Create a user.
        self.username = '******'
        self.password = '******'
        self.user = User.objects.create_user(self.username, '*****@*****.**', self.password)

        self.robot = Thing.create_thing(sim_class=TestSim2)
        self.robot.save()
        self.task = Task(thing=self.robot, name='foo')
        self.task.save()

        # We also build a detail URI, since we will be using it all over.
        # DRY, baby. DRY.
        self.detail_url = '/leaf_api/v1/task/{0}/'.format(self.task.pk)

        # The data we'll send on POST requests. Again, because we'll use it
        # frequently (enough).
        self.post_data = {
            'robot': self.robot.uuid,
            'name': 'foo',
        }

        self.task_args = dict(format='json', authentication=self.get_credentials(), HTTP_AUTHORIZATION_KEY=self.task.authorization)
        self.robot_args = dict(format='json', authentication=self.get_credentials(), HTTP_AUTHORIZATION_KEY=self.robot.authorization)
Example #4
0
    def test_defaults(self):
        t = Thing.create_thing(sim_class=TestSim2)
        t.save()
        self.task = Task(thing=t, name='foo')
        self.task.save()
        id = self.task.id

        task2 = Task.objects.get(id=id)
        self.assertEquals(task2.thing, t)
        self.assertEquals(task2.kwargs, {})
        self.assertEquals(task2.result, None)
        self.assertEquals(task2.name, 'foo')
        self.assert_(task2.authorization)
        self.assertEquals(len(task2.authorization), 64)
        self.assertEquals(task2.result, None)
        self.assertEquals(task2.status, 'REQUESTED')
Example #5
0
class TestTaskResource(ResourceTestCase):

    maxDiff = None

    def setUp(self):
        super(TestTaskResource, self).setUp()

        # Create a user.
        self.username = '******'
        self.password = '******'
        self.user = User.objects.create_user(self.username, '*****@*****.**', self.password)

        self.robot = Thing.create_thing(sim_class=TestSim2)
        self.robot.save()
        self.task = Task(thing=self.robot, name='foo')
        self.task.save()

        # We also build a detail URI, since we will be using it all over.
        # DRY, baby. DRY.
        self.detail_url = '/leaf_api/v1/task/{0}/'.format(self.task.pk)

        # The data we'll send on POST requests. Again, because we'll use it
        # frequently (enough).
        self.post_data = {
            'robot': self.robot.uuid,
            'name': 'foo',
        }

        self.task_args = dict(format='json', authentication=self.get_credentials(), HTTP_AUTHORIZATION_KEY=self.task.authorization)
        self.robot_args = dict(format='json', authentication=self.get_credentials(), HTTP_AUTHORIZATION_KEY=self.robot.authorization)

    def get_credentials(self):
        return self.create_basic(username=self.username, password=self.password)

    def test_get_list_unauthorzied(self):
        self.assertHttpUnauthorized(self.api_client.get('/leaf_api/v1/task/', format='json'))

    def test_get_list_json(self):
        resp = self.api_client.get('/leaf_api/v1/task/', **self.task_args)
        self.assertValidJSONResponse(resp)

        # Scope out the data for correctness.
        data = self.deserialize(resp)
        self.assertEqual(len(data['objects']), 1)
        # Here, we're checking an entire structure for the expected data.
        self.assertEqual(data['objects'][0], {
            u'task': str(self.task.pk),
            u'authorization': self.task.authorization,
            u'kwargs': u'{}',
            u'id': self.task.pk,
            u'name': u'foo',
            u'result': None,
            u'status': u'REQUESTED',
            u'robot': self.task.thing.uuid,
            u'resource_uri': '/leaf_api/v1/task/{0}/'.format(self.task.pk),
            u'task': str(self.task.pk),
        })

    def test_get_detail_unauthenticated(self):
        self.assertHttpUnauthorized(self.api_client.get(self.detail_url, format='json'))

    def test_get_detail_unauthorized(self):
        self.assertHttpUnauthorized(self.api_client.get(self.detail_url, format='json', authentication=self.get_credentials()))

    def test_get_detail_json(self):
        resp = self.api_client.get(self.detail_url, **self.task_args)
        self.assertValidJSONResponse(resp)

        data = self.deserialize(resp)

        # We use ``assertKeys`` here to just verify the keys, not all the data.
        self.assertKeys(data, [u'authorization',
                                                 u'id',
                                                 u'kwargs',
                                                 u'name',
                                                 u'resource_uri',
                                                 u'result',
                                                 u'status',
                                                 u'task',
                                                 u'robot'])
        self.assertEqual(data['name'], 'foo')
        self.assertEqual(data['authorization'], self.task.authorization)
        self.assertEqual(data['resource_uri'], self.detail_url)
        self.assertEqual(data['result'], None)
        self.assertEqual(data['status'], u'REQUESTED')
        self.assertEqual(data['robot'], self.task.thing.uuid)

    def test_post_list_unauthenticated(self):
        self.assertHttpUnauthorized(self.api_client.post('/leaf_api/v1/task/', format='json', data=self.post_data))

    def test_post_list_unauthorized(self):
        self.assertHttpUnauthorized(self.api_client.post('/leaf_api/v1/task/', format='json', data=self.post_data, authentication=self.get_credentials()))

    def test_post_list(self):
        # Check how many are there first.
        self.assertEqual(Task.objects.count(), 1)
        resp = self.api_client.post('/leaf_api/v1/task/', data=self.post_data, **self.robot_args)
        new_task = Task.objects.all()[1]
        url = urlparse(resp._headers['location'][1]).path
        self.assertHttpCreated(resp)
        # Verify a new one has been added.
        self.assertEqual(Task.objects.count(), 2)
        resp = self.api_client.get(url, **self.robot_args)
        self.assertValidJSONResponse(resp)
        data = self.deserialize(resp)
        self.assertEqual(data['name'], 'foo')
        self.assertEqual(data['authorization'], self.robot.authorization)
        self.assertEqual(data['resource_uri'], '/leaf_api/v1/task/{0}/'.format(new_task.id))
        self.assertEqual(data['result'], 'foo')
        self.assertEqual(data['status'], u'COMPLETED')
        self.assertEqual(data['robot'], self.task.thing.uuid)

    def test_put_detail_unauthenticated(self):
        self.assertHttpUnauthorized(self.api_client.put(self.detail_url, format='json', data={}))

    def test_put_detail_unauthorized(self):
        self.assertHttpUnauthorized(self.api_client.put(self.detail_url, format='json', data={}, authentication=self.get_credentials()))

    @skip('')
    def test_put_detail(self):
        # Grab the current data & modify it slightly.
        original_data = self.deserialize(self.api_client.get(self.detail_url, format='json', authentication=self.get_credentials()))
        return
        new_data = original_data.copy()
        new_data['title'] = 'Updated: First Post'
        new_data['created'] = '2012-05-01T20:06:12'

        self.assertEqual(Task.objects.count(), 5)
        self.assertHttpAccepted(self.api_client.put(self.detail_url, format='json', data=new_data, authentication=self.get_credentials()))
        # Make sure the count hasn't changed & we did an update.
        self.assertEqual(Task.objects.count(), 5)
        # Check for updated data.
        self.assertEqual(Task.objects.get(pk=25).title, 'Updated: First Post')
        self.assertEqual(Task.objects.get(pk=25).slug, 'first-post')
        self.assertEqual(Task.objects.get(pk=25).created, datetime.datetime(2012, 3, 1, 13, 6, 12))

    def test_delete_detail_unauthenticated(self):
        self.assertHttpUnauthorized(self.api_client.delete(self.detail_url, format='json'))

    @skip('')
    def test_delete_detail(self):
        self.assertEqual(Task.objects.count(), 1)
        self.assertHttpAccepted(self.api_client.delete(self.detail_url, **self.task_args))
        self.assertEqual(Task.objects.count(), 0)