Example #1
0
    def test_get_for_object(self):
        c1 = DataContext()
        c1.save()
        r1 = Revision.objects.create_revision(c1, fields=['name'])

        c2 = DataContext()
        c2.save()
        r2 = Revision.objects.create_revision(c2, fields=['name'])

        # Standard, model extracted from instance
        self.assertEqual(Revision.objects.get_for_object(c1)[0], r1)

        # Explicity pass model
        self.assertEqual(
            Revision.objects.get_for_object(c1, model=DataContext)[0], r1)

        # Pass queryset containing target object
        queryset = DataContext.objects.filter(pk=c1.pk)
        self.assertEqual(
            Revision.objects.get_for_object(c1, model=queryset)[0], r1)

        # Pass queryset *not* containing target object
        queryset = DataContext.objects.filter(pk=c2.pk)
        self.assertEqual(
            list(Revision.objects.get_for_object(c1, model=queryset)), [])
Example #2
0
    def get_context(self, request):
        params = self.get_params(request)
        context = params.get('context')

        # Explicit request to not use a context
        if context != 'null':
            kwargs = {
                'archived': False,
            }
            if hasattr(request, 'user') and request.user.is_authenticated():
                kwargs['user'] = request.user
            else:
                if request.session.session_key is None:
                    return DataContext()
                kwargs['session_key'] = request.session.session_key

            # Assume it is a primary key and fallback to the sesssion
            try:
                kwargs['pk'] = int(context)
            except (ValueError, TypeError):
                kwargs['session'] = True

            try:
                return DataContext.objects.get(**kwargs)
            except DataContext.DoesNotExist:
                pass

        return DataContext()
Example #3
0
    def test_delete(self):
        ctx1 = DataContext(user=self.user, name='Context 1')
        ctx1.save()
        ctx2 = DataContext(user=self.user, name='Context 2')
        ctx2.save()
        ctx3 = DataContext(user=self.user, name='Context 3', session=True)
        ctx3.save()

        response = self.client.get('/api/contexts/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertEqual(len(json.loads(response.content)), 3)

        response = self.client.delete('/api/contexts/{0}/'.format(ctx1.pk))
        self.assertEqual(response.status_code, codes.no_content)

        response = self.client.get('/api/contexts/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertEqual(len(json.loads(response.content)), 2)

        # Cannot delete the session
        response = self.client.delete('/api/contexts/{0}/'.format(ctx3.pk))
        self.assertEqual(response.status_code, codes.bad_request)

        response = self.client.get('/api/contexts/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertEqual(len(json.loads(response.content)), 2)
Example #4
0
 def test_multiple_contexts(self):
     cxt1 = DataContext(session=True, user=self.user)
     cxt1.save()
     cxt2 = DataContext(user=self.user, session=True)
     cxt2.save()
     response = self.client.get('/api/data/preview/',
                                HTTP_ACCEPT='application/json')
     self.assertEqual(response.status_code, codes.ok)
Example #5
0
    def setUp(self):
        c1 = DataContext({'field': 1, 'operator': 'exact', 'value': 30})
        c1.save()
        Revision.objects.create_revision(c1, fields=['json'])

        c2 = DataContext({'field': 2, 'operator': 'in', 'value': [1, 2]})
        c2.save()
        Revision.objects.create_revision(c2, fields=['json'])

        self.c1 = c1
        self.c2 = c2
Example #6
0
    def test_clean(self):
        # Save a default template
        cxt = DataContext(template=True, default=True)
        cxt.save()

        # Save new template (not default)
        cxt2 = DataContext(template=True)
        cxt2.save()

        # Try changing it to default
        cxt2.default = True
        self.assertRaises(ValidationError, cxt2.save)

        cxt.save()
Example #7
0
 def test_multiple_context_and_view(self):
     # Create two Contexts and views, an illegal action that
     # Our base resource should handle
     cxt3 = DataContext(session=True, user=self.user)
     cxt3.save()
     cxt4 = DataContext(user=self.user, session=True)
     cxt4.save()
     dv3 = DataView(session=True, user=self.user)
     dv3.save()
     dv4 = DataView(session=True, user=self.user)
     dv4.save()
     response = self.client.get('/api/data/preview/',
                                HTTP_ACCEPT='application/json')
     self.assertTrue(response.content)
     self.assertEqual(response.status_code, codes.ok)
Example #8
0
    def test_put(self):
        # Add a context so we can try to update it later.
        ctx = DataContext(user=self.user, name='Context 1')
        ctx.save()
        response = self.client.get('/api/contexts/{0}/'.format(ctx.pk),
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertTrue(response.content)

        # Attempt to update the name via a PUT request.
        response = self.client.put('/api/contexts/{0}/'.format(ctx.pk),
                                   data=u'{"name":"New Name"}',
                                   content_type='application/json')
        self.assertEqual(response.status_code, codes.ok)

        # Make sure our changes from the PUT request are persisted.
        response = self.client.get('/api/contexts/{0}/'.format(ctx.pk),
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertTrue(response.content)
        self.assertEqual(json.loads(response.content)['name'], 'New Name')

        # Make a PUT request with invalid JSON and make sure we get an
        # unprocessable status code back.
        response = self.client.put('/api/contexts/{0}/'.format(ctx.pk),
                                   data=u'{"json":"]]]"}',
                                   content_type='application/json')
        self.assertEqual(response.status_code, codes.unprocessable_entity)
Example #9
0
    def test_create_revision(self):
        c = DataContext(name='Test', json={})
        c.save()

        revision = Revision.objects.create_revision(
            c, fields=['name', 'description', 'json'])

        self.assertEqual(revision.data, {
            'name': 'Test',
            'description': None,
            'json': {}
        })

        revisions = Revision.objects.get_for_object(c)
        self.assertEqual(revisions.count(), 1)

        self.assertFalse(Revision.objects.object_has_changed(c))
        self.assertEqual(
            revisions[0].changes, {
                'name': {
                    'new_value': 'Test'
                },
                'description': {
                    'new_value': None
                },
                'json': {
                    'new_value': {}
                }
            })
Example #10
0
    def test_change(self):
        c = DataContext()
        c.save()

        revisions = Revision.objects.get_for_object(c)
        self.assertEqual(revisions.count(), 1)

        latest_revision = Revision.objects.latest_for_object(c)
        self.assertFalse('old_value' in latest_revision.changes)
        self.assertEqual(
            latest_revision.changes, {
                'json': {
                    'new_value': {}
                },
                'name': {
                    'new_value': None
                },
                'description': {
                    'new_value': None
                }
            })

        c.name = "New Name"
        c.save()

        revisions = Revision.objects.get_for_object(c)
        self.assertEqual(revisions.count(), 2)

        latest_revision = Revision.objects.latest_for_object(c)
        self.assertEqual(
            latest_revision.changes,
            {'name': {
                'old_value': None,
                'new_value': 'New Name'
            }})
Example #11
0
 def test_init(self):
     json = {
         'field': 'tests.title.salary',
         'operator': 'gt',
         'value': '1000'
     }
     cxt = DataContext(json)
     self.assertEqual(cxt.json, json)
Example #12
0
    def test_session(self):
        cxt = DataContext(session=True, user=self.user)
        cxt.save()

        response = self.client.get('/api/contexts/session/stats/',
                                   HTTP_ACCEPT='application/json')

        self.assertEqual(json.loads(response.content)['count'], 6)
Example #13
0
    def test_get(self):
        ctx = DataContext(user=self.user)
        ctx.save()

        response = self.client.get('/api/contexts/revisions/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertEqual(len(json.loads(response.content)), 1)
Example #14
0
    def __init__(self, *args, **kwargs):
        kwargs['context'] = DataContext(json={
            'field': 'tests.title.salary',
            'operator': 'lt',
            'value': 20000,
        })

        super(UnderTwentyThousandQueryProcessor, self)\
            .__init__(*args, **kwargs)
Example #15
0
    def __init__(self, *args, **kwargs):
        kwargs['context'] = DataContext(
            json={
                'field': 'tests.employee.is_manager',
                'operator': 'exact',
                'value': True,
            })

        super(ManagerQueryProcessor, self).__init__(*args, **kwargs)
Example #16
0
    def test_nochange(self):
        c = DataContext()
        c.save()

        revisions = Revision.objects.get_for_object(c)
        self.assertEqual(revisions.count(), 1)

        # No changes, no new revision
        c.save()
        self.assertEqual(revisions.count(), 1)
Example #17
0
    def test_count(self):
        json = {
            'field': 'tests.title.salary',
            'operator': 'gt',
            'value': '10000'
        }
        ctx = DataContext(json)

        self.assertEqual(ctx.count(), 6)
        self.assertEqual(ctx.count(tree='office'), 1)
Example #18
0
    def test_deleted_revision(self):
        c = DataContext(name='Test', json={})
        c.save()
        fields = ['name', 'description', 'json']

        revision = Revision.objects.create_revision(
            c, fields=fields, deleted=True)

        self.assertEqual(revision.data, None)
        self.assertEqual(revision.changes, None)
Example #19
0
 def test_export_type(self):
     context = DataContext()
     view = DataView()
     export_type = 'json'
     query_options = {
         'export_type': export_type,
     }
     result = utils.get_result_rows(context, view, query_options)
     self.assertEqual(len(list(result['rows'])), Employee.objects.count())
     self.assertEqual(result['export_type'], export_type)
Example #20
0
 def test_processor(self):
     context = DataContext()
     view = DataView()
     processor = 'manager'
     query_options = {
         'processor': processor,
     }
     result = utils.get_result_rows(context, view, query_options)
     self.assertEqual(len(list(result['rows'])),
                      Employee.objects.filter(is_manager=True).count())
     self.assertTrue(isinstance(result['processor'], ManagerQueryProcessor))
Example #21
0
 def test_limit(self):
     context = DataContext()
     view = DataView()
     limit = 2
     query_options = {
         'limit': limit,
         'page': 1,
     }
     result = utils.get_result_rows(context, view, query_options)
     self.assertEqual(len(list(result['rows'])), limit)
     self.assertEqual(result['limit'], limit)
Example #22
0
    def test_apply(self):
        c = DataContext({'field': 1, 'operator': 'exact', 'value': 30})
        c.save()

        revision = Revision.objects.create_revision(c, fields=['json'])

        c.json['value'] = 50
        c.save()

        revision.apply(c)
        self.assertEqual(c.json['value'], 30)
Example #23
0
    def test_get_rows(self):
        context = DataContext()
        view = DataView()

        # Unless we tell the function to evaluate the rows, it should return
        # rows as a generator so we need to exclicitly evaluate it here.
        result = utils.get_result_rows(context, view, {})
        self.assertEqual(len(list(result['rows'])), Employee.objects.count())

        # Now, have the method evaluate the rows.
        result = utils.get_result_rows(context, view, {}, evaluate_rows=True)
        self.assertEqual(len(result['rows']), Employee.objects.count())
Example #24
0
    def test_processor(self):
        cxt = DataContext(session=True, user=self.user)
        cxt.save()

        response = self.client.get('/api/contexts/{0}/stats/'.format(cxt.pk),
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(json.loads(response.content)['count'], 6)

        response = self.client.get(
            '/api/contexts/{0}/stats/?processor=manager'.format(cxt.pk),
            HTTP_ACCEPT='application/json')
        self.assertEqual(json.loads(response.content)['count'], 1)
Example #25
0
    def test_get_order_only(self):
        field = DataField.objects.get(field_name='salary')
        concept = field.concepts.all()[0]

        context = DataContext()
        view = DataView(json=[{
            'concept': concept.pk,
            'visible': False,
            'sort': 'desc',
        }])
        result = utils.get_result_rows(context, view, {})
        self.assertEqual(len(list(result['rows'])), Employee.objects.count())
Example #26
0
    def test_invalid_job_result(self):
        context = DataContext()
        view = DataView()
        query_options = {
            'page': 0,
        }

        job_id = utils.async_get_result_rows(context, view, query_options)
        self.assertTrue(async_utils.get_job_count(), 1)
        async_utils.run_jobs()
        time.sleep(1)
        self.assertEqual(async_utils.get_job_result(job_id), None)
        self.assertEqual(async_utils.get_job(job_id).status, JobStatus.FAILED)
Example #27
0
 def test_get_object_data(self):
     c = DataContext()
     fields = history.utils.get_model_fields(DataContext)
     data = history.utils.get_object_data(c, fields=fields)
     self.assertEqual(data, {
         'default': False,
         'description': None,
         'json': {},
         'keywords': None,
         'name': None,
         'session': False,
         'session_key': None,
         'template': False,
     })
Example #28
0
    def test_pages(self):
        context = DataContext()
        view = DataView()
        query_options = {
            'page': 1,
            'stop_page': 10,
        }
        result = utils.get_result_rows(context, view, query_options)
        self.assertEqual(len(list(result['rows'])), Employee.objects.count())

        query_options = {
            'page': 1,
            'stop_page': 1,
        }
        result = utils.get_result_rows(context, view, query_options)
        self.assertEqual(len(list(result['rows'])), Employee.objects.count())
Example #29
0
    def test_get_session(self):
        context = DataContext(user=self.user,
                              name='Session Context',
                              session=True)
        context.save()

        response = self.client.get('/api/contexts/session/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertTrue(response.content)

        context.session = False
        context.save()

        response = self.client.get('/api/contexts/session/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.not_found)
Example #30
0
    def test_get(self):
        ctx = DataContext(user=self.user)
        ctx.save()
        response = self.client.get('/api/contexts/{0}/'.format(ctx.pk),
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.ok)
        self.assertTrue(response.content)
        content = json.loads(response.content)
        self.assertEqual(content['object_name'], 'employee')
        self.assertLess(ctx.accessed,
                        DataContext.objects.get(pk=ctx.pk).accessed)

        # Make sure that accessing a non-existent context returns a 404 error
        # indicating that it wasn't found.
        response = self.client.get('/api/contexts/999/',
                                   HTTP_ACCEPT='application/json')
        self.assertEqual(response.status_code, codes.not_found)