def testCanGetForObjectReference(self): # Can get version for proxy model proxy_versions = reversion.get_for_object_reference(ReversionTestModel1Proxy, self.proxy.id) self.assertEqual(len(proxy_versions), 2) self.assertEqual(proxy_versions[0].field_dict["name"], self.proxy.name) self.assertEqual(proxy_versions[1].field_dict["name"], self.concrete.name) # Can get the same version for concrete model concrete_versions = reversion.get_for_object_reference(ReversionTestModel1, self.concrete.id) self.assertEqual(list(concrete_versions), list(proxy_versions))
def testCanGetForObjectReference(self): # Test a model with an int pk. versions = reversion.get_for_object_reference(ReversionTestModel1, self.test11.pk) self.assertEqual(len(versions), 2) self.assertEqual(versions[0].field_dict["name"], "model1 instance1 version2") self.assertEqual(versions[1].field_dict["name"], "model1 instance1 version1") # Test a model with a str pk. versions = reversion.get_for_object_reference(ReversionTestModel2, self.test21.pk) self.assertEqual(len(versions), 2) self.assertEqual(versions[0].field_dict["name"], "model2 instance1 version2") self.assertEqual(versions[1].field_dict["name"], "model2 instance1 version1")
def testCanGetForObjectReference(self): # Can get version for proxy model proxy_versions = reversion.get_for_object_reference( ReversionTestModel1Proxy, self.proxy.id) self.assertEqual(len(proxy_versions), 2) self.assertEqual(proxy_versions[0].field_dict["name"], self.proxy.name) self.assertEqual(proxy_versions[1].field_dict["name"], self.concrete.name) # Can get the same version for concrete model concrete_versions = reversion.get_for_object_reference( ReversionTestModel1, self.concrete.id) self.assertEqual(list(concrete_versions), list(proxy_versions))
def get_queryset(self, **kwargs): thisModel = self.kwargs['model'] # thisObject = get_object_or_404(thisModel, pk=self.kwargs['pk']) versions = reversion.get_for_object_reference(thisModel, self.kwargs['pk']) return versions
def get_object(self, queryset=None): """ Returns revision based on edid_pk and revision_pk. """ edid_pk = self.kwargs.get('edid_pk', None) revision_pk = self.kwargs.get('revision_pk', None) # Get version based on edid_pk and revision_pk or return 404. version = reversion.get_for_object_reference(EDID, edid_pk) \ .filter(revision__pk=revision_pk) try: version = version.get() except version.model.DoesNotExist: raise Http404() # Check revision and EDID date # FIXME: Works fine, but tests fail due to milliseconds difference if version.revision.date_created == version.object.modified: return HttpResponseBadRequest( 'You can not revert to the current revision.') self.kwargs['revision'] = version.revision # Return EDID instance return version.object
def add_site_to_revision(sender, **kwargs): revision = kwargs["revision"] versions = kwargs["versions"] sites = [] if revision.versionsites.exists(): # If the sites are already set earlier, don't reset them here return for ver in versions: # Add any sites from the new version if "sites" in ver.field_dict: sites.extend([int(s) for s in ver.field_dict["sites"]]) elif "site" in ver.field_dict: sites.append(int(ver.field_dict["site"])) # Add any sites from the previous version, so we can see that it has # moved try: available_versions = reversion.get_for_object_reference(ver.content_type.model_class(), ver.object_id) prev_ver = available_versions.exclude(id=ver.id).order_by("-id")[0] if "sites" in prev_ver.field_dict: sites.extend([int(s) for s in prev_ver.field_dict["sites"]]) elif "site" in prev_ver.field_dict: sites.append(int(prev_ver.field_dict["site"])) except (IndexError, SerializerDoesNotExist): pass for site_id in set(s.id for s in Site.objects.filter(id__in=sites)): site = Site.objects.get(pk=site_id) # Add meta data didn't work, so do it manually vsite = VersionSite(revision=revision, site=site) vsite.save()
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 get_object(self, queryset=None): """ Returns revision based on edid_pk and revision_pk. """ edid_pk = self.kwargs.get('edid_pk', None) revision_pk = self.kwargs.get('revision_pk', None) # Get version based on edid_pk and revision_pk or return 404. version = reversion.get_for_object_reference(EDID, edid_pk) \ .filter(revision__pk=revision_pk) try: version = version.get() except version.model.DoesNotExist: raise Http404() # Check revision and EDID date # FIXME: Works fine, but tests fail due to milliseconds difference if version.revision.date_created == version.object.modified: return HttpResponseBadRequest( 'You can not revert to the current revision.' ) self.kwargs['revision'] = version.revision # Return EDID instance return version.object
def test_diff_template_has_users_of_changes(self): user1 = User.objects.create(username='******') with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.user = user1 user2 = User.objects.create(username='******') with reversion.revision: instance.content = "changed test content" instance.save() reversion.revision.user = user2 new_version, old_version = reversion.get_for_object_reference(Page, instance.pk) request, context = self._prepare_request(old_version, new_version) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-old .wikify-user:contains('%s')" % user1.username) self.assertHasElement(response, ".wikify-new .wikify-user:contains('%s')" % user2.username)
def _get_version_diff(version): """Get the difference betwee :param version: reversion.Version object :return: tuple (metadata as dict, compared values as dict) """ ident = version.field_dict['id'] model = version.content_type.model_class() # uses the class rather than the instance so that we can also work with deleted objects all_versions = reversion.get_for_object_reference( model, ident).select_related('revision__user') all_versions = list(all_versions) diff = {} diff['object_name'] = model.__name__ fields = {} foreign_keys = {} many_to_manys = {} choices_display = {} # CharField having a list of choices for field in model._meta.fields: fields[field.name] = field if type(field) is django.db.models.fields.related.ForeignKey: foreign_keys[field.name] = field elif type( field) is django.db.models.fields.CharField and field.choices: choices_display[field.name] = field elif type( field) is django.db.models.fields.TextField and field.choices: choices_display[field.name] = field for field in model._meta.many_to_many: fields[field.name] = field if type(field) is django.db.models.fields.related.ManyToManyField: many_to_manys[field.name] = field try: previous_version = all_versions[all_versions.index(version) + 1] diff['has_previous'] = True if previous_version.revision.user: diff['previous_user'] = previous_version.revision.user.email else: diff['previous_user'] = '******' diff['previous_date'] = previous_version.revision.date_created diff['previous_comment'] = previous_version.revision.comment compared = compare_dicts(version.field_dict, previous_version.field_dict) except IndexError: diff['has_previous'] = False compared = compare_dicts(version.field_dict, None) # stores an association between the type of fields # available and the function to transform the value transform_fields = [(foreign_keys, find_user_friendly_rel), (many_to_manys, find_user_friendly_many), (choices_display, find_user_friendly_display_name)] compared_values = _build_compared_values(compared, fields, transform_fields) return diff, compared_values
def _get_version_diff(version): """Get the difference betwee :param version: reversion.Version object :return: tuple (metadata as dict, compared values as dict) """ ident = version.field_dict['id'] model = version.content_type.model_class() # uses the class rather than the instance so that we can also work with deleted objects all_versions = reversion.get_for_object_reference(model, ident).select_related('revision__user') all_versions = list(all_versions) diff = {} diff['object_name'] = model.__name__ fields = {} foreign_keys = {} many_to_manys = {} choices_display = {} # CharField having a list of choices for field in model._meta.fields: fields[field.name] = field if type(field) is django.db.models.fields.related.ForeignKey: foreign_keys[field.name] = field elif type(field) is django.db.models.fields.CharField and field.choices: choices_display[field.name] = field elif type(field) is django.db.models.fields.TextField and field.choices: choices_display[field.name] = field for field in model._meta.many_to_many: fields[field.name] = field if type(field) is django.db.models.fields.related.ManyToManyField: many_to_manys[field.name] = field try: previous_version = all_versions[all_versions.index(version)+1] diff['has_previous'] = True if previous_version.revision.user: diff['previous_user'] = previous_version.revision.user.email else: diff['previous_user'] = '******' diff['previous_date'] = previous_version.revision.date_created diff['previous_comment'] = previous_version.revision.comment compared = compare_dicts(version.field_dict, previous_version.field_dict) except IndexError: diff['has_previous'] = False compared = compare_dicts(version.field_dict, None) # stores an association between the type of fields # available and the function to transform the value transform_fields = [ (foreign_keys, find_user_friendly_rel), (many_to_manys, find_user_friendly_many), (choices_display, find_user_friendly_display_name)] compared_values = _build_compared_values(compared, fields, transform_fields) return diff, compared_values
def test_diff_template_shows_no_previous_if_viewing_first_version(self): with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") new_version = reversion.get_for_object_reference(Page, instance.pk)[0] request, context = self._prepare_request(None, new_version) response = render(request, self.template, context) self.assertHasNoElement(response, "a:contains('previous')")
def get_previous_version(version): thisId = version.object_id thisVersionId = version.pk versions = reversion.get_for_object_reference(version.content_type.model_class(), thisId) try: previousVersions = versions.filter(revision_id__lt=version.revision_id).latest( field_name='revision__date_created') except ObjectDoesNotExist: return False return previousVersions
def test_version_template_has_comment(self): comment = 'test comment' with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.comment = comment version = reversion.get_for_object_reference(Page, instance.pk)[0] request, context = self._prepare_request(version) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-comment:contains('%s')" % comment)
def test_versions_template_has_author(self): user = User.objects.create(username='******') with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.user = user version = reversion.get_for_object_reference(Page, instance.pk)[0] request, context = self._prepare_request(versions=[version]) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-user:contains('%s')" % user.username)
def test_version_template_has_date_of_last_change(self): with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") version = reversion.get_for_object_reference(Page, instance.pk)[0] request, context = self._prepare_request(version) response = render(request, self.template, context) date = defaultfilters.date(version.revision.date_created, settings.DATETIME_FORMAT) self.assertHasElement(response, ".wikify-date:contains('%s')" % date)
def test_versions_template_shows_ip_address(self): ip_address = '127.0.0.1' with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.add_meta(VersionMeta, ip_address=ip_address) version = reversion.get_for_object_reference(Page, instance.pk)[0] request, context = self._prepare_request(versions=[version]) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-user:contains('%s')" % ip_address)
def construct_versions(version_count): assert version_count > 0 with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="content_0") reversion.revision.comment = 'Version 0' versions = [] for i in range(1, version_count): with reversion.revision: instance.content = "content_%s" % i instance.save() reversion.revision.comment = 'Version %s' % i return reversion.get_for_object_reference(Page, instance.pk).order_by("pk")
def get_object(self, queryset=None): """ Returns EDID versioned instance based on edid_pk and revision_pk. Injects timings sets as attributes to EDID object. We can't use RelaltedManager to get versioned timings, instead we store timings in EDID object attributes. """ edid_pk = self.kwargs.get('edid_pk', None) revision_pk = self.kwargs.get('revision_pk', None) # Get version based on edid_pk and revision_pk or return 404. version = reversion.get_for_object_reference(EDID, edid_pk) \ .filter(revision__pk=revision_pk) try: version = version.get() except version.model.DoesNotExist: raise Http404() # Assign EDID instance to edid edid = version.object_version.object # Flag EDID instance as revision edid.is_revision = True # Get set of all versions (related objects) in the revision revision_versions = version.revision.version_set.all() # Split timings by type standardtimings = [] detailedtimings = [] for related_version in revision_versions: timing = related_version.object_version.object if isinstance(timing, StandardTiming): standardtimings.append(timing) elif isinstance(timing, DetailedTiming): detailedtimings.append(timing) edid.standardtimings = standardtimings edid.detailedtimings = detailedtimings # Return EDID instance return edid
def save_model(self, request, obj, form, change): if not hasattr(self, 'model'): raise AttributeError("You need to specify 'model', attr") super().save_model(request, obj, form, change) serialized = serializers.serialize( 'json', [obj.translations.get( language_code=request.GET.get('language') or get_language() )] ) try: revision = reversion.get_for_object_reference( self.model, obj.pk)[0] revision.serialized_data = serialized revision.save() except IndexError: pass
def test_version_view(self): with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") version = reversion.get_for_object_reference(Page, instance.pk)[0] resp = self.client.get('/%s' % instance.pk, {'action': 'version', 'version_id': version.id}) self.assertEquals(resp.status_code, 200) self.assertIn('wikify/version.html', [template.name for template in resp.templates]) self.assertEquals(instance, resp.context['instance']) self.assertEquals(version, resp.context['version']) self.assertEquals(len(resp.context['fields']), 1) _, field_value = resp.context['fields'][0] self.assertEquals(instance.content, field_value)
def test_diff_template_has_content(self): with reversion.revision: instance = Page.objects.create(title="some title", content='abcdefg') with reversion.revision: instance.content = '123456' instance.save() new_version, old_version = reversion.get_for_object_reference(Page, instance.pk) request, context = self._prepare_request(old_version, new_version) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-content del:contains('%s')" % 'abcdefg') self.assertHasElement(response, ".wikify-content ins:contains('%s')" % '123456')
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 test_diff_template_has_comment(self): with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.comment = 'test comment1' with reversion.revision: instance.content = "changed test content" instance.save() reversion.revision.comment = 'test comment2' new_version, old_version = reversion.get_for_object_reference(Page, instance.pk) request, context = self._prepare_request(old_version, new_version) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-old .wikify-comment:contains('%s')" % "test comment1") self.assertHasElement(response, ".wikify-new .wikify-comment:contains('%s')" % "test comment2")
def test_diff_view_for_single_version(self): with reversion.revision: new_instance = Page.objects.create(title=get_unique_page_title(), content="test content") new = reversion.get_for_object_reference(Page, new_instance.pk)[0] resp = self.client.get('/%s' % new_instance.pk, {'action': 'diff', 'version_id': str(new.id)}) self.assertEquals(resp.status_code, 200) self.assertIn('wikify/diff.html', [template.name for template in resp.templates]) self.assertEquals(None, resp.context['old_version']) self.assertEquals(new, resp.context['new_version']) self.assertEquals(None, resp.context['next_version']) self.assertEquals(len(resp.context['fields']), 1) _, old_value, new_value = resp.context['fields'][0] self.assertEquals(None, old_value) self.assertEquals(new_instance.content, new_value)
def test_edit_view_renders_form_for_instance_version(self, get_model_wiki_form): with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") version = reversion.get_for_object_reference(Page, instance.pk)[0] fake_form = "fake form" (get_model_wiki_form.is_callable() .returns_fake().is_callable() .returns(fake_form)) resp = self.client.get('/%s' % instance.pk, {'action': 'edit', 'version_id': version.id}) self.assertEquals(resp.status_code, 200) self.assertIn('wikify/edit.html', [template.name for template in resp.templates]) self.assertEquals(fake_form, resp.context['form']) self.assertEquals(instance.pk, resp.context['object_id']) self.assertEquals(version, resp.context['version'])
def test_diff_template_has_ip_of_changes(self): ip_address = '127.0.0.1' with reversion.revision: instance = Page.objects.create(title=get_unique_page_title(), content="test content") reversion.revision.add_meta(VersionMeta, ip_address=ip_address) with reversion.revision: instance.content = "changed test content" instance.save() reversion.revision.add_meta(VersionMeta, ip_address=ip_address) new_version, old_version = reversion.get_for_object_reference(Page, instance.pk) request, context = self._prepare_request(old_version, new_version) response = render(request, self.template, context) self.assertHasElement(response, ".wikify-old .wikify-user:contains('%s')" % ip_address) self.assertHasElement(response, ".wikify-new .wikify-user:contains('%s')" % ip_address)
def testRevisionSavedOnPost(self): self.assertEqual(ChildTestAdminModel.objects.count(), 0) # Create an instance via the admin. response = self.client.post("/admin/test_reversion/childtestadminmodel/add/", { "parent_name": "parent instance1 version1", "child_name": "child instance1 version1", "_continue": 1, }) self.assertEqual(response.status_code, 302) obj_pk = response["Location"].split("/")[-2] obj = ChildTestAdminModel.objects.get(id=obj_pk) # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 1) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version1") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version1") # Save a new version. response = self.client.post("/admin/test_reversion/childtestadminmodel/%s/" % obj_pk, { "parent_name": "parent instance1 version2", "child_name": "child instance1 version2", "_continue": 1, }) self.assertEqual(response.status_code, 302) # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 2) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version2") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version2") # Check that the versions can be listed. response = self.client.get("/admin/test_reversion/childtestadminmodel/%s/history/" % obj_pk) self.assertContains(response, "child instance1 version2") self.assertContains(response, "child instance1 version1") # Check that version data can be loaded. response = self.client.get("/admin/test_reversion/childtestadminmodel/%s/history/%s/" % (obj_pk, versions[1].pk)) self.assertContains(response, "parent instance1 version1") self.assertContains(response, "child instance1 version1") # Check that loading the version data didn't roll it back! obj = ChildTestAdminModel.objects.get(pk=obj.pk) self.assertEqual(obj.child_name, "child instance1 version2") self.assertEqual(obj.parent_name, "parent instance1 version2") self.assertEqual(reversion.get_for_object(obj).count(), 2) # Check that a version can be rolled back. response = self.client.post("/admin/test_reversion/childtestadminmodel/%s/history/%s/" % (obj_pk, versions[1].pk), { "parent_name": "parent instance1 version3", "child_name": "child instance1 version3", }) self.assertEqual(response.status_code, 302) # Check that the models were rolled back. obj = ChildTestAdminModel.objects.get(pk=obj.pk) self.assertEqual(obj.child_name, "child instance1 version3") self.assertEqual(obj.parent_name, "parent instance1 version3") # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 3) self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version3") self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version3") # Check that a deleted version can be viewed in the list. obj.delete() response = self.client.get("/admin/test_reversion/childtestadminmodel/recover/") self.assertContains(response, "child instance1 version3") # Check that a delete version can be viewed in detail. response = self.client.get("/admin/test_reversion/childtestadminmodel/recover/%s/" % versions[0].pk) self.assertContains(response, "parent instance1 version3") self.assertContains(response, "child instance1 version3") # Check that a deleted version can be recovered. response = self.client.post("/admin/test_reversion/childtestadminmodel/recover/%s/" % versions[0].pk, { "parent_name": "parent instance1 version4", "child_name": "child instance1 version4", }) # Check that the models were rolled back. obj = ChildTestAdminModel.objects.get(pk=obj_pk) self.assertEqual(obj.child_name, "child instance1 version4") self.assertEqual(obj.parent_name, "parent instance1 version4") # Check that a version is created. versions = reversion.get_for_object_reference(ChildTestAdminModel, obj_pk) self.assertEqual(versions.count(), 4) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version4") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version4")
def testRevisionSavedOnPost(self): self.assertEqual(ChildTestAdminModel.objects.count(), 0) # Create an instance via the admin. response = self.client.post( "/admin/test_reversion/childtestadminmodel/add/", { "parent_name": "parent instance1 version1", "child_name": "child instance1 version1", "_continue": 1, }) self.assertEqual(response.status_code, 302) obj_pk = response["Location"].split("/")[-2] obj = ChildTestAdminModel.objects.get(id=obj_pk) # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 1) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version1") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version1") # Save a new version. response = self.client.post( "/admin/test_reversion/childtestadminmodel/%s/" % obj_pk, { "parent_name": "parent instance1 version2", "child_name": "child instance1 version2", "_continue": 1, }) self.assertEqual(response.status_code, 302) # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 2) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version2") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version2") # Check that the versions can be listed. response = self.client.get( "/admin/test_reversion/childtestadminmodel/%s/history/" % obj_pk) self.assertContains(response, "child instance1 version2") self.assertContains(response, "child instance1 version1") # Check that version data can be loaded. response = self.client.get( "/admin/test_reversion/childtestadminmodel/%s/history/%s/" % (obj_pk, versions[1].pk)) self.assertContains(response, "parent instance1 version1") self.assertContains(response, "child instance1 version1") # Check that loading the version data didn't roll it back! obj = ChildTestAdminModel.objects.get(pk=obj.pk) self.assertEqual(obj.child_name, "child instance1 version2") self.assertEqual(obj.parent_name, "parent instance1 version2") self.assertEqual(reversion.get_for_object(obj).count(), 2) # Check that a version can be rolled back. response = self.client.post( "/admin/test_reversion/childtestadminmodel/%s/history/%s/" % (obj_pk, versions[1].pk), { "parent_name": "parent instance1 version3", "child_name": "child instance1 version3", }) self.assertEqual(response.status_code, 302) # Check that the models were rolled back. obj = ChildTestAdminModel.objects.get(pk=obj.pk) self.assertEqual(obj.child_name, "child instance1 version3") self.assertEqual(obj.parent_name, "parent instance1 version3") # Check that a version is created. versions = reversion.get_for_object(obj) self.assertEqual(versions.count(), 3) self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version3") self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version3") # Check that a deleted version can be viewed in the list. obj.delete() response = self.client.get( "/admin/test_reversion/childtestadminmodel/recover/") self.assertContains(response, "child instance1 version3") # Check that a delete version can be viewed in detail. response = self.client.get( "/admin/test_reversion/childtestadminmodel/recover/%s/" % versions[0].pk) self.assertContains(response, "parent instance1 version3") self.assertContains(response, "child instance1 version3") # Check that a deleted version can be recovered. response = self.client.post( "/admin/test_reversion/childtestadminmodel/recover/%s/" % versions[0].pk, { "parent_name": "parent instance1 version4", "child_name": "child instance1 version4", }) # Check that the models were rolled back. obj = ChildTestAdminModel.objects.get(pk=obj_pk) self.assertEqual(obj.child_name, "child instance1 version4") self.assertEqual(obj.parent_name, "parent instance1 version4") # Check that a version is created. versions = reversion.get_for_object_reference(ChildTestAdminModel, obj_pk) self.assertEqual(versions.count(), 4) self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version4") self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version4")