def test_edit_plugin_directly(self):
job_opening = self.create_default_job_opening()
# revision 1
content_en_1 = self.plugin_values_raw['en'].format(1)
self.create_revision(job_opening, content=content_en_1)
self.assertEqual(len(get_for_object(job_opening)), 1)
# revision 2
content_en_2 = self.plugin_values_raw['en'].format(2)
with transaction.atomic():
language = job_opening.get_current_language()
plugins = job_opening.content.get_plugins().filter(
language=language)
plugin = plugins[0].get_plugin_instance()[0]
plugin.body = content_en_2
plugin.save()
aldryn_create_revision(job_opening)
self.assertEqual(len(get_for_object(job_opening)), 2)
with switch_language(job_opening, 'en'):
url = job_opening.get_absolute_url()
response = self.client.get(url)
self.assertContains(response, content_en_2)
self.assertNotContains(response, content_en_1)
self.revert_to(job_opening, 1)
job_opening = JobOpening.objects.get(pk=job_opening.pk)
response = self.client.get(job_opening.get_absolute_url())
self.assertContains(response, content_en_1)
self.assertNotContains(response, content_en_2)
def test_job_application_revision_is_reverted(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
# revert to 1
self.revert_to(application, 1)
application = JobApplication.objects.get(pk=application.pk)
# add initial job_opening to values list to be checked
new_values_1['job_opening'] = job_opening
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
def testCanRevertRevisionWithDeletedVersions(self):
self.assertEqual(ReversionTestModel1.objects.count(), 2)
self.assertEqual(ReversionTestModel2.objects.count(), 2)
with create_revision():
self.test11.name = "model1 instance1 version3"
self.test11.save()
self.test12.delete()
self.test21.name = "model2 instance1 version3"
self.test21.save()
self.test22.delete()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
with create_revision():
self.test11.name = "model1 instance1 version4"
self.test11.save()
self.test21.name = "model2 instance1 version4"
self.test21.save()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
# Revert to a revision where some deletes were logged.
get_for_object(self.test11)[1].revision.revert()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
self.assertEqual(ReversionTestModel1.objects.get(id=self.test11.id).name, "model1 instance1 version3")
self.assertEqual(ReversionTestModel2.objects.get(id=self.test21.id).name, "model2 instance1 version3")
# Revert the a revision before the deletes were logged.
get_for_object(self.test11)[2].revision.revert()
self.assertEqual(ReversionTestModel1.objects.count(), 2)
self.assertEqual(ReversionTestModel2.objects.count(), 2)
def test_edit_plugin_directly(self):
job_opening = self.create_default_job_opening()
# revision 1
content_en_1 = self.plugin_values_raw['en'].format(1)
self.create_revision(job_opening, content=content_en_1)
self.assertEqual(len(get_for_object(job_opening)), 1)
# revision 2
content_en_2 = self.plugin_values_raw['en'].format(2)
with transaction.atomic():
language = job_opening.get_current_language()
plugins = job_opening.content.get_plugins().filter(
language=language)
plugin = plugins[0].get_plugin_instance()[0]
plugin.body = content_en_2
plugin.save()
aldryn_create_revision(job_opening)
self.assertEqual(len(get_for_object(job_opening)), 2)
with switch_language(job_opening, 'en'):
url = job_opening.get_absolute_url()
response = self.client.get(url)
self.assertContains(response, content_en_2)
self.assertNotContains(response, content_en_1)
self.revert_to(job_opening, 1)
job_opening = JobOpening.objects.get(pk=job_opening.pk)
response = self.client.get(job_opening.get_absolute_url())
self.assertContains(response, content_en_1)
self.assertNotContains(response, content_en_2)
def test_job_application_revision_is_reverted_if_fk_obj_was_deleted(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
# delete initial opening
with transaction.atomic():
job_opening.delete()
# revert to 1
self.revert_to(application, 1)
application = JobApplication.objects.get(pk=application.pk)
self.assertEqual(JobOpening.objects.all().count(), 2)
# get restored job opening
job_opening = JobOpening.objects.all().exclude(pk=new_opening.pk).get()
# add initial job_opening to values list to be checked
new_values_1['job_opening'] = job_opening
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
def test_edit_plugin_directly(self):
content1 = 'Content 1 text'
content2 = 'Content 2 text'
with force_language('en'):
event = self.create_default_event()
# revision 1
self.create_event_revision(event, content1)
self.assertEqual(len(get_for_object(event)), 1)
# revision 2
with transaction.atomic():
plugins = event.description.get_plugins().filter(
language=event.get_current_language())
plugin = plugins[0].get_plugin_instance()[0]
plugin.body = content2
plugin.save()
aldryn_create_revision(event)
self.assertEqual(len(get_for_object(event)), 2)
response = self.client.get(event.get_absolute_url())
self.assertContains(response, content2)
self.assertNotContains(response, content1)
self.revert_to(event, 1)
event = Event.objects.get(pk=event.pk)
response = self.client.get(event.get_absolute_url())
self.assertContains(response, content1)
self.assertNotContains(response, content2)
def test_post_revision(self, expected, updates):
self.client.login(username="******", password="******")
post_data = {"location": 1, "time_block": 1, "time_slot": 1}
game = Game()
modify_game(game)
game.user = User.objects.get(username="******")
game.location = Location.objects.get(id=post_data["location"])
game.time_block = TimeBlock.objects.get(id=post_data["time_block"])
game.time_slot = TimeSlot.objects.get(id=post_data["time_slot"])
game.last_modified = timezone.now()
game.save()
post_data["id"] = game.id
self.assertEquals(len(reversion.get_for_object(game)), 0)
post_data.update(updates)
self.client.post(self.url, post_data)
versions = reversion.get_for_object(game)
self.assertEquals(len(versions), 1)
self.assertEquals(versions[0].revision.comment,
"AJAX Schedule Submission - %s Changed" % expected)
def test_edit_plugin_directly(self):
content1 = 'Content 1 text'
content2 = 'Content 2 text'
with force_language('en'):
event = self.create_default_event()
# revision 1
self.create_event_revision(event, content1)
self.assertEqual(len(get_for_object(event)), 1)
# revision 2
with transaction.atomic():
plugins = event.description.get_plugins().filter(
language=event.get_current_language())
plugin = plugins[0].get_plugin_instance()[0]
plugin.body = content2
plugin.save()
aldryn_create_revision(event)
self.assertEqual(len(get_for_object(event)), 2)
response = self.client.get(event.get_absolute_url())
self.assertContains(response, content2)
self.assertNotContains(response, content1)
self.revert_to(event, 1)
event = Event.objects.get(pk=event.pk)
response = self.client.get(event.get_absolute_url())
self.assertContains(response, content1)
self.assertNotContains(response, content2)
def test_job_application_revision_is_reverted_if_fk_obj_was_deleted(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
# delete initial opening
with transaction.atomic():
job_opening.delete()
# revert to 1
self.revert_to(application, 1)
application = JobApplication.objects.get(pk=application.pk)
self.assertEqual(JobOpening.objects.all().count(), 2)
# get restored job opening
job_opening = JobOpening.objects.all().exclude(pk=new_opening.pk).get()
# add initial job_opening to values list to be checked
new_values_1['job_opening'] = job_opening
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
def testCanRevertRevisionWithDeletedVersions(self):
self.assertEqual(ReversionTestModel1.objects.count(), 2)
self.assertEqual(ReversionTestModel2.objects.count(), 2)
with create_revision():
self.test11.name = "model1 instance1 version3"
self.test11.save()
self.test12.delete()
self.test21.name = "model2 instance1 version3"
self.test21.save()
self.test22.delete()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
with create_revision():
self.test11.name = "model1 instance1 version4"
self.test11.save()
self.test21.name = "model2 instance1 version4"
self.test21.save()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
# Revert to a revision where some deletes were logged.
get_for_object(self.test11)[1].revision.revert()
self.assertEqual(ReversionTestModel1.objects.count(), 1)
self.assertEqual(ReversionTestModel2.objects.count(), 1)
self.assertEqual(
ReversionTestModel1.objects.get(id=self.test11.id).name,
"model1 instance1 version3")
self.assertEqual(
ReversionTestModel2.objects.get(id=self.test21.id).name,
"model2 instance1 version3")
# Revert the a revision before the deletes were logged.
get_for_object(self.test11)[2].revision.revert()
self.assertEqual(ReversionTestModel1.objects.count(), 2)
self.assertEqual(ReversionTestModel2.objects.count(), 2)
def test_job_application_revision_is_reverted(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
# revert to 1
self.revert_to(application, 1)
application = JobApplication.objects.get(pk=application.pk)
# add initial job_opening to values list to be checked
new_values_1['job_opening'] = job_opening
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
def test_job_application_contains_latest_values(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
application = JobApplication.objects.get(pk=application.pk)
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
application = JobApplication.objects.get(pk=application.pk)
for prop in new_values_2.keys():
self.assertEqual(getattr(application, prop), new_values_2[prop])
def test_job_application_contains_latest_values(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening,
**self.application_default_values)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
application = JobApplication.objects.get(pk=application.pk)
for prop in new_values_1.keys():
self.assertEqual(getattr(application, prop), new_values_1[prop])
# revision 2
new_values_2 = self.make_new_values(self.application_values_raw, 2)
new_opening = JobOpening.objects.create(
category=self.default_category,
**self.make_new_values(self.opening_values_raw['en'], 2))
new_values_2['job_opening'] = new_opening
self.create_revision(application, **new_values_2)
self.assertEqual(len(get_for_object(application)), 2)
application = JobApplication.objects.get(pk=application.pk)
for prop in new_values_2.keys():
self.assertEqual(getattr(application, prop), new_values_2[prop])
def test_page_versions(self):
self.client.login(username="******", password="******")
page = Page(name="Test Name", url="test-url", content="Content goes here")
with reversion.create_revision():
reversion.set_comment("initial")
page.save()
versions = reversion.get_for_object(page)
self.assertEquals(len(versions), 1)
self.assertEquals(versions[0].revision.comment, "initial")
url = reverse("admin:page_page_change", args=[page.id])
self.client.post(url, {"name": "2nd name", "url": "test-url", "content": "New content"})
page = Page.objects.get(id=page.id)
self.assertEquals(page.name, "2nd name")
self.assertEquals(page.content, "New content")
versions = map(lambda x: x, reversion.get_for_object(page))
self.assertEquals(len(versions), 2)
self.assertEquals(versions[0].revision.comment, "Changed name and content.")
actual_initial = json.loads(versions[1].serialized_data)[0]
self.assertEquals(actual_initial["fields"]["name"], "Test Name")
self.assertEquals(actual_initial["fields"]["url"], "test-url")
self.assertEquals(actual_initial["fields"]["content"], "Content goes here")
actual_final = json.loads(versions[0].serialized_data)[0]
self.assertEquals(actual_final["fields"]["name"], "2nd name")
self.assertEquals(actual_final["fields"]["url"], "test-url")
self.assertEquals(actual_final["fields"]["content"], "New content")
def test_job_opening_revision_is_created(self):
job_opening = self.create_default_job_opening()
self.assertEqual(len(get_for_object(job_opening)), 0)
new_values_en_1 = self.make_new_values(self.default_job_values['en'],
1)
self.create_revision(job_opening, **new_values_en_1)
self.assertEqual(len(get_for_object(job_opening)), 1)
def test_category_revision_is_created(self):
category = JobCategory.objects.create(app_config=self.app_config,
**self.category_values_raw['en'])
self.assertEqual(len(get_for_object(category)), 0)
new_values_en_1 = self.make_new_values(self.category_values_raw['en'],
1)
self.create_revision(category, **new_values_en_1)
self.assertEqual(len(get_for_object(category)), 1)
def testCanRevertVersion(self):
self.assertEqual(
ReversionTestModel1.objects.get(pk=self.concrete.pk).name,
self.proxy.name)
get_for_object(self.proxy)[1].revert()
self.assertEqual(
ReversionTestModel1.objects.get(pk=self.concrete.pk).name,
self.concrete.name)
def test_job_opening_revision_is_created(self):
job_opening = self.create_default_job_opening()
self.assertEqual(len(get_for_object(job_opening)), 0)
new_values_en_1 = self.make_new_values(
self.default_job_values['en'], 1)
self.create_revision(job_opening, **new_values_en_1)
self.assertEqual(len(get_for_object(job_opening)), 1)
def test_category_revision_is_created(self):
category = JobCategory.objects.create(
app_config=self.app_config,
**self.category_values_raw['en'])
self.assertEqual(len(get_for_object(category)), 0)
new_values_en_1 = self.make_new_values(
self.category_values_raw['en'], 1)
self.create_revision(category, **new_values_en_1)
self.assertEqual(len(get_for_object(category)), 1)
def testCanGetForObject(self):
# Can get version for proxy model
proxy_versions = get_for_object(self.proxy)
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 = get_for_object(self.concrete)
self.assertEqual(list(concrete_versions), list(proxy_versions))
def setUp(self):
super(CBViewTest, self).setUp()
test_data = TestData(verbose=False)
self.item1, self.item2 = test_data.create_Simple_data()
queryset = get_for_object(self.item1)
self.version_ids1 = queryset.values_list("pk", flat=True)
queryset = get_for_object(self.item2)
self.version_ids2 = queryset.values_list("pk", flat=True)
def testCanGetUnique(self):
with create_revision():
self.test11.save()
self.test21.save()
# Test a model with an int pk.
self.assertEqual(get_for_object(self.test11).count(), 3)
self.assertEqual(len(list(get_for_object(self.test11).get_unique())), 2)
# Test a model with a str pk.
self.assertEqual(get_for_object(self.test21).count(), 3)
self.assertEqual(len(list(get_for_object(self.test21).get_unique())), 2)
def test_job_application_revision_is_created(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening, **self.application_default_values)
self.assertEqual(len(get_for_object(application)), 0)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
def testCanGetUniqueForObject(self):
with create_revision():
self.test11.save()
self.test21.save()
# Test a model with an int pk.
self.assertEqual(get_for_object(self.test11).count(), 3)
self.assertEqual(len(get_unique_for_object(self.test11)), 2)
# Test a model with a str pk.
self.assertEqual(get_for_object(self.test21).count(), 3)
self.assertEqual(len(get_unique_for_object(self.test21)), 2)
def test_attendance_post_not_registered_revision(self):
self.client.login(username="******", password="******")
self.client.post(self.url, self.create_block_dict())
registration = Registration.objects.get(user=User.objects.get(username="******"))
reg_versions = reversion.get_for_object(registration)
self.assertEquals(len(reg_versions), 1)
self.assertEquals(reg_versions[0].revision.comment, "Form Submission - Initial")
for block_reg in BlockRegistration.objects.filter(registration=registration):
block_versions = reversion.get_for_object(block_reg)
self.assertEquals(len(block_versions), 1)
self.assertEquals(block_versions[0].revision, reg_versions[0].revision)
def testCanGetForObject(self):
# Can get version for proxy model
proxy_versions = get_for_object(self.proxy)
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 = get_for_object(self.concrete)
self.assertEqual(list(concrete_versions), list(proxy_versions))
def test_job_application_revision_is_created(self):
job_opening = self.create_default_job_opening()
application = JobApplication.objects.create(
job_opening=job_opening,
**self.application_default_values)
self.assertEqual(len(get_for_object(application)), 0)
# revision 1
new_values_1 = self.make_new_values(self.application_values_raw, 1)
self.create_revision(application, **new_values_1)
self.assertEqual(len(get_for_object(application)), 1)
def testReverseFollowRevertWithDelete(self):
with create_revision():
follow2 = TestFollowModel.objects.create(
name = "related instance2 version 1",
test_model_1 = self.test11,
)
# Test that a revert with delete works.
follow2_pk = follow2.pk
get_for_object(self.test11)[1].revision.revert(delete=True)
self.assertEqual(TestFollowModel.objects.count(), 1)
self.assertRaises(TestFollowModel.DoesNotExist, lambda: TestFollowModel.objects.get(id=follow2_pk))
def testCanGetForObject(self):
# Test a model with an int pk.
versions = get_for_object(self.test11)
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 = get_for_object(self.test21)
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 testReverseFollowRevertWithDelete(self):
with create_revision():
follow2 = TestFollowModel.objects.create(
name="related instance2 version 1",
test_model_1=self.test11,
)
# Test that a revert with delete works.
follow2_pk = follow2.pk
get_for_object(self.test11)[1].revision.revert(delete=True)
self.assertEqual(TestFollowModel.objects.count(), 1)
self.assertRaises(TestFollowModel.DoesNotExist,
lambda: TestFollowModel.objects.get(id=follow2_pk))
def test_revert_document(self):
document = Document.objects.get()
versions = revisions.get_for_object(document)
self.assertEqual(len(versions), 2)
# second step try to revert to old version
response = self.app.post(reverse('documents:revert'), {'id': versions[1].pk, 'url_title': document.url_title}, user=self.user, xhr=True)
self.assertEqual(response.status_code, 200)
versions = revisions.get_for_object(document)
self.assertEqual(len(versions), 3)
self.assertEqual(versions[0].object.text, "text")
self.assertEqual(versions[0].revision.comment, 'reverted to revision "test version"')
def test_attendance_post_registered_revision(self):
registration = Registration.objects.get(user=User.objects.get(username="******"))
for block_reg in BlockRegistration.objects.filter(registration=registration):
block_reg.attendance = BlockRegistration.ATTENDANCE_YES
block_reg.save()
self.client.post(self.url, self.create_block_dict())
reg_versions = map(lambda x: x, reversion.get_for_object(registration))
self.assertEquals(len(reg_versions), 1)
self.assertEquals(reg_versions[0].revision.comment, "Form Submission - Update")
for block_reg in BlockRegistration.objects.filter(registration=registration):
block_versions = map(lambda x: x, reversion.get_for_object(block_reg))
self.assertEquals(block_versions[0].revision, reg_versions[0].revision)
def testCanRevertRevision(self):
get_for_object(self.test11)[1].revision.revert()
self.assertEqual(
ReversionTestModel1.objects.get(id=self.test11.pk).name,
"model1 instance1 version1")
self.assertEqual(
ReversionTestModel1.objects.get(id=self.test12.pk).name,
"model1 instance2 version1")
self.assertEqual(
ReversionTestModel2.objects.get(id=self.test22.pk).name,
"model2 instance2 version1")
self.assertEqual(
ReversionTestModel2.objects.get(id=self.test22.pk).name,
"model2 instance2 version1")
def test_initial_state(self):
self.assertTrue(reversion.is_registered(SimpleModel))
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(SimpleModel.objects.all()[0].text, "version two")
self.assertEqual(reversion.get_for_object(self.item1).count(), 2)
self.assertEqual(reversion.get_for_object(self.item2).count(), 5)
self.assertEqual(Revision.objects.all().count(), 7)
self.assertEqual(Version.objects.all().count(), 7)
# query.ValuesListQuerySet() -> list():
self.assertEqual(list(self.version_ids1), [2, 1])
self.assertEqual(list(self.version_ids2), [7, 6, 5, 4, 3])
def test_revert_poll_no_votes(self):
poll = Poll.objects.get()
self.assertTrue(poll.can_be_reverted)
versions = revisions.get_for_object(poll)
self.assertEqual(len(versions), 2)
response = self.app.post(reverse('documents:revert'), {'id': versions[1].pk, 'url_title': poll.url_title}, user=self.user, xhr=True)
self.assertEqual(response.status_code, 200)
versions = revisions.get_for_object(poll)
self.assertEqual(len(versions), 3)
response = self.app.get(reverse('versions', args=[poll.url_title]), user=self.user)
self.assertEqual(response.status_code, 200)
self.assertNotIn('This Document can not be reverted!', response.body.decode('utf-8'))
def test_comment_edit_versioning(john_doe_api_client, default_hearing, lookup_field):
url = get_main_comments_url(default_hearing, lookup_field)
response = john_doe_api_client.post(url, data={"content": "THIS SERVICE SUCKS"})
data = get_data_from_response(response, 201)
comment_id = data["id"]
comment = SectionComment.objects.get(pk=comment_id)
assert comment.content.isupper() # Oh my, all that screaming :(
assert not revisions.get_for_object(comment) # No revisions
response = john_doe_api_client.patch('%s%s/' % (url, comment_id), data={
"content": "Never mind, it's nice :)"
})
data = get_data_from_response(response, 200)
comment = SectionComment.objects.get(pk=comment_id)
assert not comment.content.isupper() # Screaming is gone
assert len(revisions.get_for_object(comment)) == 1 # One old revision
def testCanGetForObject(self):
# Test a model with an int pk.
versions = get_for_object(self.test11)
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 = get_for_object(self.test21)
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 test_opening_is_reverted_if_fk_object_was_deleted(self):
opening = self.create_default_job_opening(translated=True)
self.assertEqual(len(get_for_object(opening)), 0)
# revision 1: en 1, de 0
category_1 = self.default_category
new_values_en_1 = self.make_new_values(self.opening_values_raw['en'],
1)
with switch_language(opening, 'en'):
self.create_revision(opening, **new_values_en_1)
# revision 2: en 1, de 1
new_values_de_1 = self.make_new_values(self.opening_values_raw['de'],
1)
# update category
category_2 = JobCategory.objects.create(
app_config=self.app_config,
**self.make_new_values(self.category_values_raw['en'], 2))
new_values_de_1['category'] = category_2
with switch_language(opening, 'de'):
self.create_revision(opening, **new_values_de_1)
# delete category_1
with transaction.atomic():
category_1.delete()
self.assertEqual(JobCategory.objects.all().count(), 1)
# revert to 1
self.revert_to(opening, 1)
opening = JobOpening.objects.get(pk=opening.pk)
self.assertNotEqual(opening.category, category_2)
self.assertEqual(JobCategory.objects.all().count(), 2)
def test_deleted_objects(self):
"""
for:
https://github.com/jedie/django-reversion-compare/commit/ba22008130f4c16a32eeb900381c2d82ca6fdd9e
https://travis-ci.org/jedie/django-reversion-compare/builds/72317520
"""
with reversion.create_revision():
factory1 = Factory.objects.create(name="factory one")
car = Car.objects.create(
name="car",
manufacturer=factory1
)
with reversion.create_revision():
factory2 = Factory.objects.create(name="factory two")
car.manufacturer=factory2
car.save()
with reversion.create_revision():
factory1.delete()
queryset = get_for_object(car)
version_ids = queryset.values_list("pk", flat=True) # [3, 2]
# print("\n", version_ids)
# response = self.client.get("/admin/tests/car/%s/history/" % car.pk)
# debug_response(response) # from django-tools
response = self.client.get(
"/admin/tests/car/%s/history/compare/" % car.pk,
data={"version_id2":version_ids[0], "version_id1":version_ids[1]}
)
def edit(request, title, new_autosaved_pages=None, initial=None):
document = Document.objects.get(url_title=title)
content_type = ContentType.objects.get_for_model(document)
check_permissions(document, request.user, [document.edit_permission_name])
# if the edit form has a formset we will initialize it here
formset_factory = document.Form.get_formset_factory()
formset = formset_factory(request.POST or None, instance=document) if formset_factory is not None else None
if formset is not None:
template_name = "{app}_edit.html".format(app=content_type.app_label)
else:
template_name = "documents_edit.html"
success, form = handle_edit(request, document, formset, initial)
__, attachment_form, __ = handle_attachment(request, document)
if success:
messages.success(request, _("Successfully saved changes"))
return HttpResponseRedirect(reverse('documents:view', args=[document.url_title]))
else:
return render(request, template_name, {
'document': document,
'form': form,
'attachment_form': attachment_form,
'active_page': 'edit',
'creation': (len(revisions.get_for_object(document)) == 0),
'new_autosaved_pages': new_autosaved_pages,
'permission_warning': permission_warning(request.user, content_type, document),
'supported_image_types': settings.SUPPORTED_IMAGE_TYPES,
'formset': formset,
})
def get_history(com, viewdate=None):
available_versions = list(reversion.get_for_object(com).get_unique())
available_versions.reverse()
prev = available_versions[0]
print(prev.revision.date_created, viewdate)
if cmp_time(prev.revision.date_created, viewdate):
current = True
else:
current = False
history = [{'date': prev.revision.date_created, 'user': prev.revision.user, 'changes': None, 'current': current}]
prev = prev.field_dict
for rev in available_versions[1:]:
changes = diff(prev, rev.field_dict)
print(rev.revision.date_created, viewdate)
if cmp_time(rev.revision.date_created, viewdate):
current = True
else:
current = False
if changes:
history.append({'user': rev.revision.user, 'changes': changes, 'date': rev.revision.date_created,
'current': current})
prev = rev.field_dict
history[-1]['latest'] = True
history.reverse()
return history
def __init__(self, *args, **kwargs):
if (kwargs.get('asset', None) is not None
and 'asset_version_id' not in kwargs):
asset = kwargs.get('asset')
kwargs['asset_version_id'] = reversion.get_for_object(
asset).last().pk
return super(AssetSnapshot, self).__init__(*args, **kwargs)
def createInlineProxyObjects(self):
# Create an instance via the admin without a child.
response = self.client.post(
reverse("admin:test_reversion_inlinetestparentmodelproxy_add"), {
"name": "parent version1",
"children-TOTAL_FORMS": "0",
"children-INITIAL_FORMS": "0",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
parent_pk = resolve(response["Location"].replace(
"http://testserver", "")).args[0]
parent = InlineTestParentModelProxy.objects.get(id=parent_pk)
# Update instance via the admin to add a child
response = self.client.post(
reverse("admin:test_reversion_inlinetestparentmodelproxy_change",
args=(parent_pk, )), {
"name": "parent version2",
"children-TOTAL_FORMS": "1",
"children-INITIAL_FORMS": "0",
"children-0-name": "non-generic child version 1",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
children = InlineTestChildModelProxy.objects.filter(parent=parent_pk)
self.assertEqual(children.count(), 1)
# get list of versions
version_list = get_for_object(parent)
self.assertEqual(len(version_list), 2)
# All done!
return parent_pk
def setUp(self):
super(OneToOneFieldTest, self).setUp()
test_data = TestData(verbose=False)
self.person, self.item = test_data.create_PersonIdentity_data()
queryset = get_for_object(self.person)
self.version_ids = queryset.values_list("pk", flat=True)
def test_revision_is_created_on_job_category_object_create(self):
with transaction.atomic():
with create_revision():
job_category = JobCategory.objects.create(
app_config=self.app_config,
**self.category_values_raw['en'])
self.assertEqual(len(get_for_object(job_category)), 1)
def test_revision_is_created_on_job_category_object_create(self):
with transaction.atomic():
with create_revision():
job_category = JobCategory.objects.create(
app_config=self.app_config,
**self.category_values_raw['en'])
self.assertEqual(len(get_for_object(job_category)), 1)
def testCanSaveIgnoringDuplicates(self):
with create_revision():
self.test11.save()
self.test12.save()
self.test21.save()
self.test22.save()
self.assertFalse(get_ignore_duplicates())
set_ignore_duplicates(True)
self.assertTrue(get_ignore_duplicates())
self.assertEqual(get_for_object(self.test11).count(), 2)
# Save a non-duplicate revision.
with create_revision():
self.test11.save()
self.assertFalse(get_ignore_duplicates())
set_ignore_duplicates(True)
self.assertEqual(get_for_object(self.test11).count(), 3)
def test_revision_is_created_on_job_opening_object_created(self):
with transaction.atomic():
with create_revision():
job_opening = JobOpening.objects.create(
category=self.default_category,
**self.opening_values_raw['en'])
self.assertEqual(len(get_for_object(job_opening)), 1)
def test_revision_is_created_on_job_opening_object_created(self):
with transaction.atomic():
with create_revision():
job_opening = JobOpening.objects.create(
category=self.default_category,
**self.opening_values_raw['en'])
self.assertEqual(len(get_for_object(job_opening)), 1)
def history(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
mark_set = SheetAPI.get_marks_for_sheet(sheet).values()
history_items_list = []
for marks in mark_set:
for mark in marks:
for revision in reversion.get_for_object(mark).all():
history_items_list.append(revision)
history_items_list.sort(key=lambda item: item.revision.date_created, reverse=True)
history_items_list = [
history_item.revision.comment + timezone.localtime(history_item.revision.date_created).strftime(
'(%y-%m-%d %H:%m:%S)') for
history_item in history_items_list]
paginator = Paginator(history_items_list, 5)
page = request.GET.get('page')
try:
history_items = paginator.page(page)
except PageNotAnInteger:
history_items = paginator.page(1)
except EmptyPage:
history_items = paginator.page(paginator.num_pages)
return render(request, 'history.html', {
'history_items': history_items
})
def get_marks(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
sheet_marks = SheetAPI.get_marks_for_sheet(sheet)
mark_sets_json_dict = list()
for student, students_marks in sheet_marks.items():
marks_json_dict = list()
for mark in students_marks:
mark_json = mark.as_json_dict
versions = reversion.get_for_object(mark)[:2]
if versions.count() >= 2:
first_revision = versions[0].revision
second_revision = versions[1].revision
if (
second_revision.user == request.user
and first_revision.user != second_revision.user
and (first_revision.date_created - second_revision.date_created).seconds < 10
):
mark_json["warning"] = True
marks_json_dict.append(mark_json)
if mark.user_with_lock:
now = timezone.now()
time_delta = now - mark.user_with_lock.profile.last_activity
if time_delta.total_seconds() > 15:
mark.set_user_with_lock(None)
mark_sets_json_dict.append(dict(student=UserAPI.as_json_dict(student, sheet), marks=marks_json_dict))
mark_sets_json_dict = sorted(mark_sets_json_dict, key=lambda item: item["student"]["fullName"].split(" ")[1])
return JsonResponse(mark_sets_json_dict, safe=False)
def testCanSaveIgnoringDuplicates(self):
with create_revision():
self.test11.save()
self.test12.save()
self.test21.save()
self.test22.save()
self.assertFalse(get_ignore_duplicates())
set_ignore_duplicates(True)
self.assertTrue(get_ignore_duplicates())
self.assertEqual(get_for_object(self.test11).count(), 2)
# Save a non-duplicate revision.
with create_revision():
self.test11.save()
self.assertFalse(get_ignore_duplicates())
set_ignore_duplicates(True)
self.assertEqual(get_for_object(self.test11).count(), 3)
def test_opening_is_reverted_if_fk_object_was_deleted(self):
opening = self.create_default_job_opening(translated=True)
self.assertEqual(len(get_for_object(opening)), 0)
# revision 1: en 1, de 0
category_1 = self.default_category
new_values_en_1 = self.make_new_values(self.opening_values_raw['en'], 1)
with switch_language(opening, 'en'):
self.create_revision(opening, **new_values_en_1)
# revision 2: en 1, de 1
new_values_de_1 = self.make_new_values(self.opening_values_raw['de'], 1)
# update category
category_2 = JobCategory.objects.create(
app_config=self.app_config,
**self.make_new_values(self.category_values_raw['en'], 2))
new_values_de_1['category'] = category_2
with switch_language(opening, 'de'):
self.create_revision(opening, **new_values_de_1)
# delete category_1
with transaction.atomic():
category_1.delete()
self.assertEqual(JobCategory.objects.all().count(), 1)
# revert to 1
self.revert_to(opening, 1)
opening = JobOpening.objects.get(pk=opening.pk)
self.assertNotEqual(opening.category, category_2)
self.assertEqual(JobCategory.objects.all().count(), 2)
def test_overrides(self):
# Try to render a page from a nonexistent template override
# and make sure it doesn't exist
self.expect_template_error('BLAARG.NOTANACTUALTEMPLATE')
# Create a template override and make sure you can see it
with reversion.create_revision():
to = TemplateOverride(name='BLAARG.TEMPLATEOVERRIDE',
content='Hello')
to.save()
self.assertTrue(
self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') ==
'Hello')
# Save an update to the template override and make sure you see that too
with reversion.create_revision():
to.content = 'Goodbye'
to.save()
self.assertTrue(
self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') ==
'Goodbye')
# Revert the update to the template and make sure you see the old version
list(reversion.get_for_object(to).get_unique())[1].revert()
self.assertTrue(
self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') ==
'Hello')
# Delete the original template override and make sure you see nothing
TemplateOverride.objects.filter(
name='BLAARG.TEMPLATEOVERRIDE').delete()
self.expect_template_error('BLAARG.TEMPLATEOVERRIDE')
def createInlineObjects(self):
# Create an instance via the admin without a child.
response = self.client.post(reverse("admin:test_reversion_inlinetestparentmodel_add"), {
"name": "parent version1",
"children-TOTAL_FORMS": "0",
"children-INITIAL_FORMS": "0",
"test_reversion-inlinetestchildgenericmodel-content_type-object_id-TOTAL_FORMS": "0",
"test_reversion-inlinetestchildgenericmodel-content_type-object_id-INITIAL_FORMS": "0",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
parent_pk = resolve(response["Location"].replace("http://testserver", "")).args[0]
parent = InlineTestParentModel.objects.get(id=parent_pk)
# Update instance via the admin to add a child
response = self.client.post(reverse("admin:test_reversion_inlinetestparentmodel_change", args=(parent_pk,)), {
"name": "parent version1",
"children-TOTAL_FORMS": "1",
"children-INITIAL_FORMS": "0",
"children-0-name": "child version 1",
"test_reversion-inlinetestchildgenericmodel-content_type-object_id-TOTAL_FORMS": "1",
"test_reversion-inlinetestchildgenericmodel-content_type-object_id-INITIAL_FORMS": "0",
"test_reversion-inlinetestchildgenericmodel-content_type-object_id-0-name": "generic child version 1",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
children = InlineTestChildModel.objects.filter(parent=parent_pk)
self.assertEqual(children.count(), 1)
generic_children = parent.generic_children.all()
self.assertEqual(generic_children.count(), 1)
# get list of versions
version_list = get_for_object(parent)
self.assertEqual(len(version_list), 2)
def post_revision_commit(sender, **kwargs):
"""Custom post-revision hook.
We want to track all creations and modifications of admin. objects
(alias, mailbox, user, domain, domain alias, etc.) so we use
django-reversion for that.
"""
from modoboa.lib.signals import get_request
current_user = get_request().user.username
logger = logging.getLogger("modoboa.admin")
for version in kwargs["versions"]:
if version.object is None:
continue
prev_revisions = reversion.get_for_object(version.object)
if prev_revisions.count() == 1:
action = _("added")
level = "info"
else:
action = _("modified")
level = "warning"
message = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": unicode(version.content_type).capitalize(),
"name": version.object_repr, "action": action,
"user": current_user
}
getattr(logger, level)(message)
def test_it_creates_revisions_on_update(self, api_client):
ActionFactory(name='foo', implementation='original')
res = api_client.patch('/api/v1/action/foo/', {'implementation': 'changed'})
assert res.status_code == 200
action = Action.objects.all()[0]
assert len(reversion.get_for_object(action)) == 1
def revert_to(self, object_with_revision, revision_number):
"""
Revert <object with revision> to revision number.
"""
# get by position, since reversion_id is not reliable,
version = list(reversed(
get_for_object(object_with_revision)))[revision_number - 1]
version.revision.revert()
def test_comment_edit_versioning(john_doe_api_client, default_hearing,
lookup_field):
url = get_main_comments_url(default_hearing, lookup_field)
response = john_doe_api_client.post(url,
data={"content": "THIS SERVICE SUCKS"})
data = get_data_from_response(response, 201)
comment_id = data["id"]
comment = SectionComment.objects.get(pk=comment_id)
assert comment.content.isupper() # Oh my, all that screaming :(
assert not revisions.get_for_object(comment) # No revisions
response = john_doe_api_client.patch(
'%s%s/' % (url, comment_id),
data={"content": "Never mind, it's nice :)"})
data = get_data_from_response(response, 200)
comment = SectionComment.objects.get(pk=comment_id)
assert not comment.content.isupper() # Screaming is gone
assert len(revisions.get_for_object(comment)) == 1 # One old revision
