def test_version_number_for_multiple_sources_created_versions(self):
"""
Different objects being updated at similar times makes no difference to the version numbers
P1 and P2 checks are mixed because versions can be created for different groupers at different times
"""
poll_1 = factories.PollFactory()
poll_2 = factories.PollFactory()
language = "en"
p1_version_1 = factories.PollVersionFactory(content__poll=poll_1,
content__language=language)
p1_version_2 = factories.PollVersionFactory(content__poll=poll_1,
content__language=language)
p2_version_1 = factories.PollVersionFactory(content__poll=poll_2,
content__language=language)
p1_version_3 = factories.PollVersionFactory(content__poll=poll_1,
content__language=language)
p2_version_2 = factories.PollVersionFactory(content__poll=poll_2,
content__language=language)
p1_version_4 = factories.PollVersionFactory(content__poll=poll_1,
content__language=language)
# Poll 1 checks
self.assertEqual(p1_version_1.number, 1)
self.assertEqual(p1_version_2.number, 2)
self.assertEqual(p1_version_3.number, 3)
self.assertEqual(p1_version_4.number, 4)
# Poll 2 checks
self.assertEqual(p2_version_1.number, 1)
self.assertEqual(p2_version_2.number, 2)
def test_add_plugins_from_placeholder(self):
version = factories.PageVersionFactory()
source_placeholder = factories.PlaceholderFactory(source=version.content)
target_placeholder = factories.PlaceholderFactory(source=version.content)
poll = factories.PollFactory()
plugin = add_plugin(
source_placeholder, "PollPlugin", version.content.language, poll=poll
)
dt = datetime(2016, 6, 6, tzinfo=timezone.utc)
with freeze_time(dt):
endpoint = self.get_copy_plugin_uri(plugin)
data = {
"source_language": version.content.language,
"source_placeholder_id": source_placeholder.pk,
"target_language": version.content.language,
"target_placeholder_id": target_placeholder.pk,
}
with self.login_user_context(self.get_superuser()):
response = self.client.post(endpoint, data)
self.assertEqual(response.status_code, 200)
version = Version.objects.get(pk=version.pk)
self.assertEqual(version.modified, dt)
def test_cut_plugin(self):
version = factories.PageVersionFactory()
placeholder = factories.PlaceholderFactory(source=version.content)
poll = factories.PollFactory()
user_settings = UserSettings.objects.create(
language=version.content.language,
user=self.get_superuser(),
clipboard=Placeholder.objects.create(slot="clipboard"),
)
plugin = add_plugin(
placeholder, "PollPlugin", version.content.language, poll=poll
)
dt = datetime(2016, 6, 6, tzinfo=timezone.utc)
with freeze_time(dt):
endpoint = self.get_move_plugin_uri(plugin)
data = {
"plugin_id": plugin.pk,
"target_language": version.content.language,
"placeholder_id": user_settings.clipboard_id,
}
with self.login_user_context(self.get_superuser()):
response = self.client.post(endpoint, data)
self.assertEqual(response.status_code, 200)
version = Version.objects.get(pk=version.pk)
self.assertEqual(version.modified, dt)
def test_new_published_version_doesnt_change_status_of_versions_with_other_states(
self
):
"""When versions relating to the same grouper have non-published
states, these should not change upon creating a new published version
"""
poll = factories.PollFactory()
factories.PollVersionFactory(
state=constants.DRAFT, content__poll=poll, content__language="en"
)
factories.PollVersionFactory(
state=constants.ARCHIVED, content__poll=poll, content__language="en"
)
user = factories.UserFactory()
version = factories.PollVersionFactory(
state=constants.DRAFT, content__poll=poll, content__language="en"
)
version.publish(user)
# Nothing has an unpublished state cause there were no published versions
self.assertEqual(
Version.objects.exclude(pk=version.pk)
.filter(state=constants.UNPUBLISHED)
.count(),
0,
)
def test_new_published_version_causes_old_published_versions_to_change_to_unpublished(
self
):
"""When versions relating to the same grouper have a new published
version created, all old published version should be marked unpublished
"""
poll = factories.PollFactory()
factories.PollVersionFactory.create_batch(
3, state=constants.PUBLISHED, content__poll=poll, content__language="en"
)
user = factories.UserFactory()
version = factories.PollVersionFactory(
state=constants.DRAFT, content__poll=poll, content__language="en"
)
version.publish(user)
# Only one published version
self.assertEqual(Version.objects.filter(state=constants.PUBLISHED).count(), 1)
# Everything other than the last published version has status unpublished
self.assertEqual(
Version.objects.exclude(pk=version.pk)
.filter(state=constants.UNPUBLISHED)
.count(),
3,
)
def test_version_number_for_multiple_sources_created_versions_with_languages(
self):
"""
The same object with different laguages being updated at similar times
makes no difference to the version numbers
"""
poll_1 = factories.PollFactory()
language_1 = "en"
language_2 = "it"
lang1_version_1 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_1)
lang1_version_2 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_1)
lang2_version_1 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_2)
lang1_version_3 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_1)
lang2_version_2 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_2)
lang1_version_4 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_1)
# Language 1 checks
self.assertEqual(lang1_version_1.number, 1)
self.assertEqual(lang1_version_2.number, 2)
self.assertEqual(lang1_version_3.number, 3)
self.assertEqual(lang1_version_4.number, 4)
# Language 2 checks
self.assertEqual(lang2_version_1.number, 1)
self.assertEqual(lang2_version_2.number, 2)
def test_archive_signals_fired(self):
"""
When a version is changed to archived the correct signals are fired!
"""
poll = factories.PollFactory()
version = factories.PollVersionFactory(
state=constants.DRAFT, content__poll=poll
)
with signal_tester(pre_version_operation, post_version_operation) as env:
version.archive(self.superuser)
self.assertEqual(env.call_count, 2)
pre_call_kwargs = env.calls[0][1]
post_call_kwargs = env.calls[1][1]
# pre call
self.assertTrue(pre_call_kwargs["token"] == post_call_kwargs["token"])
self.assertEqual(pre_call_kwargs["operation"], constants.OPERATION_ARCHIVE)
self.assertEqual(
pre_call_kwargs["sender"], version.content_type.model_class()
)
self.assertEqual(pre_call_kwargs["obj"], version)
# post call
self.assertTrue("token" in post_call_kwargs)
self.assertEqual(post_call_kwargs["operation"], constants.OPERATION_ARCHIVE)
self.assertEqual(
post_call_kwargs["sender"], version.content_type.model_class()
)
self.assertEqual(post_call_kwargs["obj"], version)
def test_filter_by_grouper(self):
poll = factories.PollFactory()
versions = factories.PollVersionFactory.create_batch(
2, content__poll=poll) # same grouper
factories.PollVersionFactory() # different grouper
versions_for_grouper = Version.objects.filter_by_grouper(poll)
self.assertQuerysetEqual(versions_for_grouper,
[versions[0].pk, versions[1].pk],
transform=lambda o: o.pk,
ordered=False)
def test_add_plugin(self):
version = factories.PageVersionFactory()
placeholder = factories.PlaceholderFactory(source=version.content)
poll = factories.PollFactory()
dt = datetime(2016, 6, 6, tzinfo=timezone.utc)
with freeze_time(dt):
endpoint = self.get_add_plugin_uri(
placeholder=placeholder,
plugin_type="PollPlugin",
language=version.content.language,
)
data = {"poll": poll.pk}
with self.login_user_context(self.get_superuser()):
response = self.client.post(endpoint, data)
self.assertEqual(response.status_code, 200)
version = Version.objects.get(pk=version.pk)
self.assertEqual(version.modified, dt)
def test_new_draft_doesnt_change_status_of_drafts_with_other_states(self):
"""When versions relating to the same grouper have non-draft
states, these should not change upon creating a new draft
"""
poll = factories.PollFactory()
factories.PollVersionFactory(state=constants.UNPUBLISHED,
content__poll=poll)
factories.PollVersionFactory(state=constants.PUBLISHED,
content__poll=poll)
version = Version.objects.create(
content=factories.PollContentFactory(poll=poll),
created_by=factories.UserFactory(),
state=constants.DRAFT)
# Nothing has an archived state cause there were no drafts
self.assertEqual(
Version.objects.exclude(pk=version.pk).filter(
state=constants.ARCHIVED).count(), 0)
def test_version_number_for_sequentially_created_versions(self):
"""
An object being updated in sequential order without any other object versions
increments for each version
"""
poll_1 = factories.PollFactory()
p1_version_1 = factories.PollVersionFactory(content__poll=poll_1,
content__language="en")
p1_version_2 = factories.PollVersionFactory(content__poll=poll_1,
content__language="en")
p1_version_3 = factories.PollVersionFactory(content__poll=poll_1,
content__language="en")
p1_version_4 = factories.PollVersionFactory(content__poll=poll_1,
content__language="en")
self.assertEqual(p1_version_1.number, 1)
self.assertEqual(p1_version_2.number, 2)
self.assertEqual(p1_version_3.number, 3)
self.assertEqual(p1_version_4.number, 4)
def test_new_draft_causes_old_drafts_to_change_to_archived(self):
"""When versions relating to the same grouper have a new draft
created, all old drafts should be marked archived
"""
poll = factories.PollFactory()
factories.PollVersionFactory.create_batch(3,
state=constants.DRAFT,
content__poll=poll)
version = Version.objects.create(
content=factories.PollContentFactory(poll=poll),
created_by=factories.UserFactory(),
state=constants.DRAFT)
# Only one draft
self.assertEqual(
Version.objects.filter(state=constants.DRAFT).count(), 1)
# Everything other than the last draft we created has status archived
self.assertEqual(
Version.objects.exclude(pk=version.pk).filter(
state=constants.ARCHIVED).count(), 3)
def test_deleting_last_version_deletes_grouper_as_well(self):
"""
Deleting the last version deletes the grouper as well.
"""
poll_1 = factories.PollFactory()
language_1 = "en"
language_2 = "it"
lang1_version_1 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_1)
lang2_version_1 = factories.PollVersionFactory(
content__poll=poll_1, content__language=language_2)
first_delete = lang1_version_1.delete()
poll_exists = Poll.objects.filter(pk=poll_1.pk).exists()
second_delete = lang2_version_1.delete()
poll_removed = not Poll.objects.filter(pk=poll_1.pk).exists()
self.assertEqual(first_delete[1]['last'], False)
self.assertEqual(second_delete[1]['last'], True)
self.assertEqual(poll_exists, True)
self.assertEqual(poll_removed, True)
