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 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")
