def tearDown(self):
     """Deletes the versioned site model."""
     reversion.unregister(Site)
     self.site.delete()
     Version.objects.all().delete()
     
     

 def check_deregistration(self, test_model):
     # Unregister the model and text.
     reversion.unregister(test_model)
     self.assertFalse(reversion.is_registered(test_model))
     self.assertRaises(RegistrationError, lambda: reversion.unregister(test_model))
     self.assertTrue(test_model not in reversion.get_registered_models())
     self.assertRaises(RegistrationError, lambda: isinstance(reversion.get_adapter(test_model)))

 def tearDown(self):
     super(AdminRegisterInlineTest, self).tearDown()
     if reversion.is_registered(TestModelInline):
         reversion.unregister(TestModelInline)
     if reversion.is_registered(TestModelGenericInline):
         reversion.unregister(TestModelGenericInline)
     admin.site.unregister(TestModelParent)

 def setUp(self):
     # Unregister all registered models.
     self.initial_registered_models = []
     for registered_model in reversion.get_registered_models():
         self.initial_registered_models.append((registered_model, reversion.get_adapter(registered_model).__class__))
         reversion.unregister(registered_model)
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(
         name = "model1 instance1 version1",
     )
     self.test12 = ReversionTestModel1.objects.create(
         name = "model1 instance2 version1",
     )
     self.test21 = ReversionTestModel2.objects.create(
         name = "model2 instance1 version1",
     )
     self.test22 = ReversionTestModel2.objects.create(
         name = "model2 instance2 version1",
     )
     self.user = User()
     if CUSTOM_USER_MODEL:
         setattr(self.user, User.USERNAME_FIELD, '1')
     else:
         self.user.username = "user1"

 def tearDown(self):
     """Tears down the tests."""
     # Unregister the model.
     reversion.unregister(TestModel)
     # Clear the database.
     Version.objects.all().delete()
     TestModel.objects.all().delete()

 def setUp(self):
     # Unregister all registered models.
     self.initial_registered_models = []
     for registered_model in reversion.get_registered_models():
         self.initial_registered_models.append((registered_model, reversion.get_adapter(registered_model).__class__))
         reversion.unregister(registered_model)
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     reversion.register(ReversionTestModel3, eager_signals=[pre_delete])
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(
         name = "model1 instance1 version1",
     )
     self.test12 = ReversionTestModel1.objects.create(
         name = "model1 instance2 version1",
     )
     self.test21 = ReversionTestModel2.objects.create(
         name = "model2 instance1 version1",
     )
     self.test22 = ReversionTestModel2.objects.create(
         name = "model2 instance2 version1",
     )
     self.test31 = ReversionTestModel3.objects.create(
         name = "model3 instance1 version1",
     )
     self.test32 = ReversionTestModel3.objects.create(
         name = "model3 instance2 version1",
     )
     self.user = User.objects.create(
         username = "user1",
     )

 def setUp(self):
     super(FollowModelsTest, self).setUp()
     reversion.unregister(ReversionTestModel1)
     reversion.register(ReversionTestModel1, follow=("testfollowmodel_set",))
     reversion.register(TestFollowModel, follow=("test_model_1", "test_model_2s"))
     self.follow1 = TestFollowModel.objects.create(name="related instance1 version 1", test_model_1=self.test11)
     self.follow1.test_model_2s.add(self.test21, self.test22)

 def testCreateRevisionIgnoreDuplicates(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, ignore_duplicates=True)
     with reversion.create_revision():
         obj = TestModel.objects.create()
     with reversion.create_revision():
         obj.save()
     self.assertSingleRevision((obj,))

 def testCreateRevisionFollow(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, follow=("related_instances",))
     obj_2 = TestModel.objects.create()
     with reversion.create_revision():
         obj_1 = TestModel.objects.create()
         obj_1.related_instances.add(obj_2)
     self.assertSingleRevision((obj_1, obj_2))

 def testCanUnregisterModel(self):
     """Tests that a model can be unregistered."""
     reversion.unregister(TestModel)
     self.assertFalse(reversion.is_registered(TestModel))
     # Check that duplicate unregistration is disallowed.
     self.assertRaises(RegistrationError, lambda: reversion.unregister(TestModel))
     # Re-register the model.
     reversion.register(TestModel)

 def testFieldDictFieldFields(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, fields=("name",))
     with reversion.create_revision():
         obj = TestModel.objects.create()
     self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, {
         "name": "v1",
     })

 def testFieldDictFieldExclude(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, exclude=("name",))
     with reversion.create_revision():
         obj = TestModel.objects.create()
     self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, {
         "id": obj.pk,
         "related_instances": [],
     })

 def tearDown(self):
     """Tears down the tests."""
     # Unregister the model.
     reversion.unregister(self.model)
     # Clear the database.
     Revision.objects.all().delete()
     self.model.objects.all().delete()
     # Clear references.
     del self.test

    def setUp(self):
        reversion.unregister(Car)
        reversion.unregister(Factory)
        reversion.register(Factory, follow=["cars"])
        reversion.register(Car)
        super(FactoryCarReverseRelationModelTest, self).setUp()

        test_data = TestData(verbose=False)
        self.factory = test_data.create_Factory_reverse_relation_data()
        queryset = get_for_object(self.factory)
        self.version_ids = queryset.values_list("pk", flat=True)

 def testRegistration(self):
     # Register the model and test.
     reversion.register(ReversionTestModel1)
     self.assertTrue(reversion.is_registered(ReversionTestModel1))
     self.assertRaises(RegistrationError, lambda: reversion.register(ReversionTestModel1))
     self.assertTrue(ReversionTestModel1 in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(ReversionTestModel1), reversion.VersionAdapter))
     # Unregister the model and text.
     reversion.unregister(ReversionTestModel1)
     self.assertFalse(reversion.is_registered(ReversionTestModel1))
     self.assertRaises(RegistrationError, lambda: reversion.unregister(ReversionTestModel1))
     self.assertTrue(ReversionTestModel1 not in reversion.get_registered_models())
     self.assertRaises(RegistrationError, lambda: isinstance(reversion.get_adapter(ReversionTestModel1)))

 def testInlineAdmin(self):
     self.assertTrue(reversion.is_registered(InlineTestParentModel))
     # make sure model is following the child FK
     self.assertTrue('children' in reversion.get_adapter(InlineTestParentModel).follow)
     self.createInlineObjects()
     # unregister model
     reversion.unregister(InlineTestParentModel)
     self.assertFalse(reversion.is_registered(InlineTestParentModel))
     # re-register without following
     reversion.register(InlineTestParentModel)
     self.assertTrue(reversion.is_registered(InlineTestParentModel))
     # make sure model is NOT following the child FK
     self.assertFalse('children' in reversion.get_adapter(InlineTestParentModel).follow)
     self.createInlineObjects()

 def tearDown(self):
     # Unregister the test models.
     reversion.unregister(ReversionTestModel1)
     reversion.unregister(ReversionTestModel2)
     reversion.unregister(ReversionTestModel3)
     # Delete the test models.
     ReversionTestModel1.objects.all().delete()
     ReversionTestModel2.objects.all().delete()
     ReversionTestModel3.objects.all().delete()
     User.objects.all().delete()
     del self.test11
     del self.test12
     del self.test21
     del self.test22
     del self.test31
     del self.test32
     del self.user
     # Delete the revisions index.
     Revision.objects.all().delete()
     # Unregister all remaining models.
     for registered_model in reversion.get_registered_models():
         reversion.unregister(registered_model)
     # Re-register initial registered models.
     for initial_model, adapter in self.initial_registered_models:
         reversion.register(initial_model, adapter_cls=adapter)
     del self.initial_registered_models

 def testRevertDelete(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, follow=("related_instances",))
     with reversion.create_revision():
         obj_1 = TestModel.objects.create()
     obj_2 = TestModel.objects.create()
     with reversion.create_revision():
         obj_1.related_instances.add(obj_2)
         obj_1.name = "v2"
         obj_1.save()
     Version.objects.get_for_object(obj_1)[1].revision.revert(delete=True)
     obj_1.refresh_from_db()
     self.assertEqual(obj_1.name, "v1")
     self.assertFalse(TestModel.objects.filter(pk=obj_2.pk).exists())

 def tearDown(self):
     # Unregister the test models.
     reversion.unregister(ReversionTestModel1)
     reversion.unregister(ReversionTestModel2)
     # Delete the test models.
     ReversionTestModel1.objects.all().delete()
     ReversionTestModel2.objects.all().delete()
     User.objects.all().delete()
     del self.test11
     del self.test12
     del self.test21
     del self.test22
     del self.user
     # Delete the revisions index.
     Revision.objects.all().delete()

 def testEagerRegistration(self):
     # Register the model and test.
     reversion.register(ReversionTestModel3, eager_signals=[pre_delete])
     self.assertTrue(reversion.is_registered(ReversionTestModel3))
     self.assertRaises(RegistrationError, lambda: reversion.register(ReversionTestModel3, eager_signals=[pre_delete]))
     self.assertTrue(ReversionTestModel3 in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(ReversionTestModel3), reversion.VersionAdapter))
     self.assertEquals([], reversion.default_revision_manager._signals[ReversionTestModel3])
     self.assertEquals([pre_delete], reversion.default_revision_manager._eager_signals[ReversionTestModel3])
     # Unregister the model and text.
     reversion.unregister(ReversionTestModel3)
     self.assertFalse(reversion.is_registered(ReversionTestModel3))
     self.assertRaises(RegistrationError, lambda: reversion.unregister(ReversionTestModel3))
     self.assertTrue(ReversionTestModel3 not in reversion.get_registered_models())
     self.assertRaises(RegistrationError, lambda: isinstance(reversion.get_adapter(ReversionTestModel3)))
     self.assertFalse(ReversionTestModel3 in reversion.default_revision_manager._signals)
     self.assertFalse(ReversionTestModel3 in reversion.default_revision_manager._eager_signals)