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)