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 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 check_registration(self, test_model):
     # Register the model and test.
     reversion.register(test_model)
     self.assertTrue(reversion.is_registered(test_model))
     self.assertRaises(RegistrationError, lambda: reversion.register(test_model))
     self.assertTrue(test_model in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(test_model), reversion.VersionAdapter))

 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 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 test_file_persistence(self):
        content = b'content1'
        with reversion.create_revision():
            # add a file instance
            file1 = FileModel()
            file1.test_file.save('file1.txt', SimpleUploadedFile('file1.txt', content), False)
            file1.save()
            # manually add a revision because we use the explicit way
            # django-cms uses too.
            adapter = reversion.get_adapter(FileModel)
            if hasattr(reversion.models, 'VERSION_CHANGE'):
                reversion.revision_context_manager.add_to_context(
                    reversion.default_revision_manager, file1,
                    adapter.get_version_data(file1, VERSION_CHANGE))
            else:
                reversion.revision_context_manager.add_to_context(
                    reversion.default_revision_manager, file1,
                    adapter.get_version_data(file1))
                # reload the instance from db
        file2 = FileModel.objects.all()[0]
        # delete the instance.
        file2.delete()

        # revert the old version
        file_version = reversion.get_for_object(file1)[0]
        file_version.revert()

        # reload the reverted instance and check for its content
        file1 = FileModel.objects.all()[0]
        self.assertEqual(file1.test_file.file.read(), content)

 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)

 def testInlineProxyAdmin(self):
     self.assertTrue(reversion.is_registered(InlineTestParentModelProxy))
     # make sure model is following the child FK
     self.assertTrue('children' in reversion.get_adapter(InlineTestParentModelProxy).follow)
     parent_pk = self.createInlineProxyObjects()
     # Check that the current version includes the inlines.
     versions = list(reversion.get_for_object_reference(InlineTestParentModelProxy, parent_pk))
     response = self.client.get(reverse(
         "admin:test_app_inlinetestparentmodelproxy_revision",
         args=(parent_pk, versions[0].pk),
     ))
     self.assertContains(response, "parent version2")  # Check parent model.
     self.assertContains(response, "non-generic child version 1")  # Check inline child model.
     # Check that the first version does not include the inlines.
     response = self.client.get(reverse(
         "admin:test_app_inlinetestparentmodelproxy_revision",
         args=(parent_pk, versions[1].pk),
     ))
     self.assertContains(response, "parent version1")  # Check parent model.
     self.assertNotContains(response, "non-generic child version 1")  # Check inline child model.

    def __init__(self, field, field_name, obj, version1, version2):
        self.field = field
        self.field_name = field_name
        self.obj = obj

        model = self.obj.__class__
        self.has_int_pk = has_int_pk(model)
        self.adapter = get_adapter(model)  # VersionAdapter instance

        # is a related field (ForeignKey, ManyToManyField etc.)
        self.is_related = self.field.rel is not None

        if not self.is_related:
            self.follow = None
        elif self.field_name in self.adapter.follow:
            self.follow = True
        else:
            self.follow = False

        self.compare_obj1 = CompareObject(field, field_name, obj, version1, self.has_int_pk, self.adapter)
        self.compare_obj2 = CompareObject(field, field_name, obj, version2, self.has_int_pk, self.adapter)

        self.value1 = self.compare_obj1.value
        self.value2 = self.compare_obj2.value

    def _hack_inline_formset_initial(self, FormSet, formset, obj, version, revert, recover):
        """Hacks the given formset to contain the correct initial data."""

        # if the FK this inline formset represents is not being followed, don't process data for it.
        # see https://github.com/etianen/django-reversion/issues/222
        if formset.rel_name not in reversion.get_adapter(self.model).follow:
            return

        # Now we hack it to push in the data from the revision!
        initial = []
        related_versions = self.get_related_versions(obj, version, FormSet)
        formset.related_versions = related_versions
        for related_obj in formset.queryset:
            if force_text(related_obj.pk) in related_versions:
                initial.append(related_versions.pop(force_text(related_obj.pk)).field_dict)
            else:
                initial_data = model_to_dict(related_obj)
                initial_data["DELETE"] = True
                initial.append(initial_data)
        for related_version in related_versions.values():
            initial_row = related_version.field_dict
            pk_name = ContentType.objects.get_for_id(related_version.content_type_id).model_class()._meta.pk.name
            del initial_row[pk_name]
            initial.append(initial_row)
        # Reconstruct the forms with the new revision data.
        formset.initial = initial
        formset.forms = [formset._construct_form(n) for n in range(len(initial))]
        # Hack the formset to force a save of everything.
        def get_changed_data(form):
            return [field.name for field in form.fields]
        for form in formset.forms:
            form.has_changed = lambda: True
            form._get_changed_data = partial(get_changed_data, form=form)
        def total_form_count_hack(count):
            return lambda: count
        formset.total_form_count = total_form_count_hack(len(initial))