Exemple #1
0
    def test_basic_usage(self):
        for i in xrange(5):
            EnsureCreatedModel.objects.create(pk=i + 1, field1=i)

        with inconsistent_db():
            new_instance = EnsureCreatedModel.objects.create(pk=7, field1=3)

            qs = EnsureCreatedModel.objects.all()
            self.assertEqual(
                5, len(qs))  # Make sure we don't get the new instance
            self.assertEqual(6,
                             len(ensure_instance_included(
                                 qs, new_instance.pk)))  # Make sure we do
            self.assertEqual(
                5, len(ensure_instance_included(qs[:5], new_instance.pk)
                       ))  # Make sure slicing returns the right number
            self.assertEqual(
                3, len(ensure_instance_included(qs[2:5], new_instance.pk)
                       ))  # Make sure slicing returns the right number

            evaled = [
                x for x in ensure_instance_included(qs.order_by("field1"),
                                                    new_instance.pk)
            ]
            self.assertEqual(
                new_instance,
                evaled[4])  # Make sure our instance is correctly positioned

            evaled = [
                x for x in ensure_instance_included(qs.order_by("-field1"),
                                                    new_instance.pk)
            ]
            self.assertEqual(
                new_instance, evaled[1],
                evaled)  # Make sure our instance is correctly positioned

            evaled = [
                x for x in ensure_instance_included(qs.order_by("-field1"),
                                                    new_instance.pk)[:2]
            ]
            self.assertEqual(
                new_instance, evaled[1],
                evaled)  # Make sure our instance is correctly positioned

        # Now we're in consistent land!
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=7)[:1])
        self.assertEqual(6, len(ensure_instance_included(qs, new_instance.pk)))

        # Make sure it's not returned if it was deleted
        new_instance.delete()
        self.assertEqual(5, len(ensure_instance_included(qs, 7)))

        new_instance = EnsureCreatedModel.objects.create(pk=8, field1=8)
        self.assertEqual(
            1,
            list(ensure_instance_included(qs, 8)).count(new_instance))
Exemple #2
0
 def test_ordering_retained(self):
     """ Test that using improve_queryset_consistency still retains the ordering. """
     b = TestModel.objects.create(name='B')
     a = TestModel.objects.create(name='A')
     c = TestModel.objects.create(name='C')
     queryset = TestModel.objects.all().order_by('name')
     # To be sure that we test a query which combines the Datastore result with our cache we
     # include some inconsistent_db stuff here...
     with inconsistent_db():
         d = TestModel.objects.create(name='D')
         queryset = improve_queryset_consistency(queryset)
         self.assertEqual(list(queryset), [a, b, c, d])
Exemple #3
0
 def test_newly_created_objects_returned(self):
     existing = TestModel.objects.create(name='existing')
     queryset = TestModel.objects.all()
     self.assertItemsEqual(queryset.all(), [existing])
     # Add a new object with eventual consistency being slow
     with inconsistent_db():
         new = TestModel.objects.create(name='new')
         # The new object should not yet be returned
         self.assertItemsEqual(queryset.all(), [existing])
         # But using our handy function it should be returned
         consistent = improve_queryset_consistency(queryset)
         self.assertItemsEqual(consistent.all(), [existing, new])
 def test_ordering_retained(self):
     """ Test that using improve_queryset_consistency still retains the ordering. """
     b = TestModel.objects.create(name='B')
     a = TestModel.objects.create(name='A')
     c = TestModel.objects.create(name='C')
     queryset = TestModel.objects.all().order_by('name')
     # To be sure that we test a query which combines the Datastore result with our cache we
     # include some inconsistent_db stuff here...
     with inconsistent_db():
         d = TestModel.objects.create(name='D')
         queryset = improve_queryset_consistency(queryset)
         self.assertEqual(list(queryset), [a, b, c, d])
 def test_newly_created_objects_returned(self):
     existing = TestModel.objects.create(name='existing')
     queryset = TestModel.objects.all()
     self.assertItemsEqual(queryset.all(), [existing])
     # Add a new object with eventual consistency being slow
     with inconsistent_db():
         new = TestModel.objects.create(name='new')
         # The new object should not yet be returned
         self.assertItemsEqual(queryset.all(), [existing])
         # But using our handy function it should be returned
         consistent = improve_queryset_consistency(queryset)
         self.assertItemsEqual(consistent.all(), [existing, new])
Exemple #6
0
    def test_new_user(self):
        with inconsistent_db():
            new_user = get_user_model().objects.create(username="******",
                                                       email="*****@*****.**")

            response = self.client.get((reverse("admin:user-index")))
            self.assertEqual(list(response.context["users"]), [self.user])

            response = self.client.get(
                "%s?new_user=%s" % (reverse("admin:user-index"), new_user.pk))
            self.assertItemsEqual(list(response.context["users"]),
                                  [new_user, self.user])
Exemple #7
0
    def test_basic_usage(self):
        for i in range(5):
            EnsureCreatedModel.objects.create(
                pk=i + 1,
                field1=i
            )

        with inconsistent_db():
            new_instance = EnsureCreatedModel.objects.create(
                pk=7,
                field1=3
            )

            qs = EnsureCreatedModel.objects.all()
            self.assertEqual(5, len(qs)) # Make sure we don't get the new instance
            self.assertEqual(6, len(ensure_instance_consistent(qs, new_instance.pk))) # Make sure we do
            self.assertEqual(5, len(ensure_instance_consistent(qs[:5], new_instance.pk))) # Make sure slicing returns the right number
            self.assertEqual(3, len(ensure_instance_consistent(qs[2:5], new_instance.pk))) # Make sure slicing returns the right number

            evaled = [ x for x in ensure_instance_consistent(qs.order_by("field1"), new_instance.pk) ]
            self.assertEqual(new_instance, evaled[4]) # Make sure our instance is correctly positioned

            evaled = [ x for x in ensure_instance_consistent(qs.order_by("-field1"), new_instance.pk) ]
            self.assertEqual(new_instance, evaled[1], evaled) # Make sure our instance is correctly positioned

            evaled = [ x for x in ensure_instance_consistent(qs.order_by("-field1"), new_instance.pk)[:2] ]
            self.assertEqual(new_instance, evaled[1], evaled) # Make sure our instance is correctly positioned

            another_instance = EnsureCreatedModel.objects.create(
                pk=8,
                field1=3
            )

            self.assertEqual(5, len(qs)) # Make sure we don't get the new instance
            self.assertEqual(7, len(ensure_instances_consistent(qs, [new_instance.pk, another_instance.pk]))) # Make sure we do

            instance_id = another_instance.pk
            another_instance.delete()

            self.assertEqual(6, len(ensure_instances_consistent(qs, [new_instance.pk, instance_id]))) # Make sure we do

        # Now we're in consistent land!
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=7)[:1])
        self.assertEqual(6, len(ensure_instance_consistent(qs, new_instance.pk)))

        # Make sure it's not returned if it was deleted
        new_instance.delete()
        self.assertEqual(5, len(ensure_instance_consistent(qs, 7)))

        new_instance = EnsureCreatedModel.objects.create(pk=8, field1=8)
        self.assertEqual(1, list(ensure_instance_consistent(qs, 8)).count(new_instance))
Exemple #8
0
 def test_deleted_objects_not_returned(self):
     """ When an object is deleted, improve_queryset_consistency should ensure that it is not
         returned.
     """
     obj = TestModel.objects.create(name='A')
     queryset = TestModel.objects.filter(name='A')
     self.assertItemsEqual(queryset.all(), [obj])
     with inconsistent_db():
         obj.delete()
         # The object no longer exists, but the inconsistent db will still return it
         self.assertItemsEqual(queryset.all(), [obj])
         # improve_queryset_consistency to the rescue!
         consistent = improve_queryset_consistency(queryset)
         self.assertEqual(consistent.count(), 0)
 def test_deleted_objects_not_returned(self):
     """ When an object is deleted, improve_queryset_consistency should ensure that it is not
         returned.
     """
     obj = TestModel.objects.create(name='A')
     queryset = TestModel.objects.filter(name='A')
     self.assertItemsEqual(queryset.all(), [obj])
     with inconsistent_db():
         obj.delete()
         # The object no longer exists, but the inconsistent db will still return it
         self.assertItemsEqual(queryset.all(), [obj])
         # improve_queryset_consistency to the rescue!
         consistent = improve_queryset_consistency(queryset)
         self.assertEqual(consistent.count(), 0)
Exemple #10
0
 def test_newly_modified_objects_returned(self):
     """ If an object which previously did not match the query is modified to now match it, then
         improve_queryset_consistency should include it even when the DB hasn't caught up yet.
     """
     obj = TestModel.objects.create(name='A')
     queryset = TestModel.objects.filter(name='B')
     self.assertEqual(queryset.all().count(), 0)
     with inconsistent_db():
         obj.name = 'B'
         obj.save()
         # The DB is inconsistent, so the queryset should still return nothing
         self.assertEqual(queryset.all().count(), 0)
         # But improve_queryset_consistency should include the object
         consistent = improve_queryset_consistency(queryset)
         self.assertEqual(consistent.all().count(), 1)
 def test_newly_modified_objects_returned(self):
     """ If an object which previously did not match the query is modified to now match it, then
         improve_queryset_consistency should include it even when the DB hasn't caught up yet.
     """
     obj = TestModel.objects.create(name='A')
     queryset = TestModel.objects.filter(name='B')
     self.assertEqual(queryset.all().count(), 0)
     with inconsistent_db():
         obj.name = 'B'
         obj.save()
         # The DB is inconsistent, so the queryset should still return nothing
         self.assertEqual(queryset.all().count(), 0)
         # But improve_queryset_consistency should include the object
         consistent = improve_queryset_consistency(queryset)
         self.assertEqual(consistent.all().count(), 1)
Exemple #12
0
    def test_add_many_instances(self):
        for i in range(5):
            EnsureCreatedModel.objects.create(pk=i + 1, field1=i + 5)

        with inconsistent_db():
            new_instances = []
            for i in range(3):
                instance = EnsureCreatedModel.objects.create(pk=i + 7,
                                                             field1=i)
                new_instances.append(instance)

            new_instance_pks = [i.pk for i in new_instances]

            qs = EnsureCreatedModel.objects.all()
            self.assertEqual(
                5, len(qs))  # Make sure we don't get the new instance
            self.assertEqual(
                8, len(ensure_instances_consistent(qs, new_instance_pks)))

            evaled = [
                x for x in ensure_instances_consistent(qs.order_by("field1"),
                                                       new_instance_pks)
            ]
            self.assertEqual(
                new_instances[0],
                evaled[0])  # Make sure our instance is correctly positioned
            self.assertEqual(
                new_instances[1],
                evaled[1])  # Make sure our instance is correctly positioned
            self.assertEqual(
                new_instances[2],
                evaled[2])  # Make sure our instance is correctly positioned

        # Now we're in consistent land!
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=7)[:1])
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=8)[:1])
        self.assertEqual(
            8, len(ensure_instances_consistent(qs, new_instance_pks)))

        # Make sure it's not returned if it was deleted
        for instance in new_instances:
            instance.delete()
        self.assertEqual(
            5, len(ensure_instances_consistent(qs, new_instance_pks)))
Exemple #13
0
    def test_delete_many_instances(self):
        for i in range(5):
            EnsureCreatedModel.objects.create(pk=i + 1, field1=i + 5)

        instances_to_delete = []
        for i in range(3):
            instance = EnsureCreatedModel.objects.create(pk=i + 7,
                                                         field1=i + 1)
            instances_to_delete.append(instance)

        instances_to_delete_pks = [i.pk for i in instances_to_delete]

        qs = EnsureCreatedModel.objects.all()
        self.assertEqual(
            8, len(ensure_instances_consistent(qs, instances_to_delete_pks)))
        with inconsistent_db():
            # Make sure it's not returned if it was deleted
            for instance in instances_to_delete:
                instance.delete()
            self.assertEqual(
                5, len(ensure_instances_consistent(qs,
                                                   instances_to_delete_pks)))
Exemple #14
0
    def test_add_many_instances(self):
        for i in range(5):
            EnsureCreatedModel.objects.create(
                pk=i + 1,
                field1=i + 5
            )

        with inconsistent_db():
            new_instances = []
            for i in range(3):
                instance = EnsureCreatedModel.objects.create(
                    pk=i + 7,
                    field1=i
                )
                new_instances.append(instance)

            new_instance_pks = [i.pk for i in new_instances]

            qs = EnsureCreatedModel.objects.all()
            self.assertEqual(5, len(qs))  # Make sure we don't get the new instance
            self.assertEqual(8, len(ensure_instances_consistent(qs, new_instance_pks)))

            evaled = [ x for x in ensure_instances_consistent(qs.order_by("field1"), new_instance_pks) ]
            self.assertEqual(new_instances[0], evaled[0])  # Make sure our instance is correctly positioned
            self.assertEqual(new_instances[1], evaled[1])  # Make sure our instance is correctly positioned
            self.assertEqual(new_instances[2], evaled[2])  # Make sure our instance is correctly positioned

        # Now we're in consistent land!
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=7)[:1])
        self.assertTrue(EnsureCreatedModel.objects.filter(pk=8)[:1])
        self.assertEqual(8, len(ensure_instances_consistent(qs, new_instance_pks)))

        # Make sure it's not returned if it was deleted
        for instance in new_instances:
            instance.delete()
        self.assertEqual(5, len(ensure_instances_consistent(qs, new_instance_pks)))
Exemple #15
0
    def test_delete_many_instances(self):
        for i in range(5):
            EnsureCreatedModel.objects.create(
                pk=i + 1,
                field1=i + 5
            )

        instances_to_delete = []
        for i in range(3):
            instance = EnsureCreatedModel.objects.create(
                pk=i + 7,
                field1=i + 1
            )
            instances_to_delete.append(instance)

        instances_to_delete_pks = [i.pk for i in instances_to_delete]

        qs = EnsureCreatedModel.objects.all()
        self.assertEqual(8, len(ensure_instances_consistent(qs, instances_to_delete_pks)))
        with inconsistent_db():
            # Make sure it's not returned if it was deleted
            for instance in instances_to_delete:
                instance.delete()
            self.assertEqual(5, len(ensure_instances_consistent(qs, instances_to_delete_pks)))
Exemple #16
0
 def test_bucket_new_inconsistent(self):
     with inconsistent_db():
         bucket = BucketFactory(title='Cheese', user=self.user)
         response = self.client.get(
             reverse('bucket', kwargs={'bucket': bucket.pk}))
         self.assertEqual(response.status_code, 200)