From 4269e077d1dd53413d2c61948e36ef748a3fdcf4 Mon Sep 17 00:00:00 2001 From: Filipe Waitman Date: Tue, 9 Jan 2018 12:42:23 -0200 Subject: [PATCH] Fix tests --- aldryn_reversion/admin.py | 200 ++++++ .../aldryn_reversion/confirm_recover.html | 9 - aldryn_reversion/tests/test_admin_views.py | 56 -- aldryn_reversion/tests/test_forms.py | 25 +- aldryn_reversion/tests/test_placeholders.py | 646 ------------------ aldryn_reversion/tests/test_utils.py | 105 +-- 6 files changed, 217 insertions(+), 824 deletions(-) delete mode 100644 aldryn_reversion/tests/test_placeholders.py diff --git a/aldryn_reversion/admin.py b/aldryn_reversion/admin.py index a71010a..784337d 100644 --- a/aldryn_reversion/admin.py +++ b/aldryn_reversion/admin.py @@ -2,21 +2,44 @@ from __future__ import unicode_literals from cms.admin.placeholderadmin import PlaceholderAdminMixin +from django.core.exceptions import PermissionDenied +from django.core.urlresolvers import reverse, NoReverseMatch +from django.contrib import messages +try: + from django.contrib.admin.utils import unquote +except ImportError: + # Django<=1.6 + import warnings + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + from django.contrib.admin.util import unquote +from django.contrib.admin.templatetags.admin_urls import add_preserved_filters +from django.db import transaction +from django.http import HttpResponseRedirect +from django.shortcuts import get_object_or_404, render +from django.utils.encoding import force_text from django.utils.translation import ugettext as _ from reversion import VERSION as REVERSION_VERSION from reversion.admin import VersionAdmin +from reversion.models import Version +from .forms import RecoverObjectWithTranslationForm from .utils import ( build_obj_repr, object_is_translation, get_translation_info_message, + get_conflict_fks_versions, + RecursiveRevisionConflictResolver ) REVERSION_1_9_OR_HIGHER = REVERSION_VERSION >= (1, 9) class VersionedPlaceholderAdminMixin(PlaceholderAdminMixin, VersionAdmin): + revision_confirmation_template = 'aldryn_reversion/confirm_reversion.html' + recover_confirmation_template = 'aldryn_reversion/confirm_recover.html' + def log_addition(self, request, obj, change_message=None): """ Override reversion.VersionAdmin log addition to provide useful message. @@ -83,3 +106,180 @@ def log_deletion(self, request, obj, object_repr): 'object_repr': build_obj_repr(obj.master), 'lang_code': obj.language_code.upper()} self.log_change(request, obj.master, message, deletion=True) + + @transaction.atomic + def revision_view(self, request, object_id, version_id, + extra_context=None): + if not self.has_change_permission(request): + raise PermissionDenied() + + obj = get_object_or_404(self.model, pk=unquote(object_id)) + version = get_object_or_404(Version, pk=unquote(version_id), + object_id=force_text(obj.pk)) + revision = version.revision + + if request.method == "POST": + revision.revert() + + opts = self.model._meta + pk_value = obj._get_pk_val() + preserved_filters = self.get_preserved_filters(request) + + msg_dict = { + 'name': force_text(opts.verbose_name), + 'obj': force_text(obj) + } + msg = _('The %(name)s "%(obj)s" was successfully reverted. ' + 'You may edit it again below.') % msg_dict + self.message_user(request, msg, messages.SUCCESS) + redirect_url = reverse( + 'admin:%s_%s_change' % (opts.app_label, opts.model_name), + args=(pk_value,), + current_app=self.admin_site.name + ) + redirect_url = add_preserved_filters({ + 'preserved_filters': preserved_filters, + 'opts': opts, + }, redirect_url) + return HttpResponseRedirect(redirect_url) + else: + context = { + 'object': obj, + 'version': version, + 'revision': revision, + 'revision_date': revision.date_created, + 'versions': revision.version_set.order_by( + 'content_type__model', 'object_id_int').all, + 'object_name': force_text(self.model._meta.verbose_name), + 'app_label': self.model._meta.app_label, + 'opts': self.model._meta, + 'add': False, + 'change': True, + 'save_as': False, + 'has_add_permission': self.has_add_permission(request), + 'has_change_permission': self.has_change_permission( + request, obj), + 'has_delete_permission': self.has_delete_permission( + request, obj), + 'has_file_field': True, + 'has_absolute_url': False, + 'original': obj, + } + return render(request, self.revision_confirmation_template, context) + + @transaction.atomic + def recover_view(self, request, version_id, extra_context=None): + if not self.has_change_permission(request): + raise PermissionDenied() + + version = get_object_or_404(Version, pk=unquote(version_id)) + obj = version.object_version.object + revision = version.revision + + # check for conflicts, it is better that user would solve them + conflict_fks_versions = get_conflict_fks_versions( + obj, version, revision) + + # build urls to point user onto restore links for conflicts + opts = self.model._meta + non_reversible_by_user = [] + conflicts_links_to_restore = [] + for fk_version in conflict_fks_versions: + # try to point user to conflict recover views + try: + link = reverse( + 'admin:{0}_{1}_recover'.format( + opts.app_label, + fk_version.object_version.object._meta.model_name), + args=[fk_version.pk]) + link_dict = { + 'version': fk_version, + 'link': link + } + except NoReverseMatch: + # if there is exception either model is not registered + # with VersionedPlaceholderAdminMixin or there is no admin + # for that model. In both cases we need to revert this object + # to avoid conflicts / integrity errors + non_reversible_by_user.append(fk_version) + else: + conflicts_links_to_restore.append(link_dict) + + # if there are conflicts that cannot be resolved manually by the user + # rely on resolver. + if len(non_reversible_by_user) > 0: + non_reversible_by_user = RecursiveRevisionConflictResolver( + non_reversible_by_user[0], non_reversible_by_user[1:]).resolve() + + # prepare form kwargs + restore_form_kwargs = { + 'revision': revision, + 'obj': obj, + 'version': version, + 'resolve_conflicts': non_reversible_by_user, + } + + if request.method == "POST": + form = RecoverObjectWithTranslationForm(request.POST, + **restore_form_kwargs) + # form.is_valid would perform validation against foreign keys + if form.is_valid(): + # form save will restore desired versions for object and its + # translations + form.save() + # FIXME: optimize response + opts = self.model._meta + pk_value = obj._get_pk_val() + preserved_filters = self.get_preserved_filters(request) + + msg_dict = { + 'name': force_text(opts.verbose_name), + 'obj': force_text(obj) + } + msg = _('The %(name)s "%(obj)s" was successfully recovered. ' + 'You may edit it again below.') % msg_dict + self.message_user(request, msg, messages.SUCCESS) + redirect_url = reverse( + 'admin:%s_%s_change' % (opts.app_label, opts.model_name), + args=(pk_value,), + current_app=self.admin_site.name + ) + # TODO: Check if there is next parameter and redirect to + # next, for cases of conflict solving. + redirect_url = add_preserved_filters({ + 'preserved_filters': preserved_filters, + 'opts': opts, + }, redirect_url) + return HttpResponseRedirect(redirect_url) + else: + # populate form with regular data + form = RecoverObjectWithTranslationForm(**restore_form_kwargs) + + context = { + 'object': obj, + 'version': version, + 'revision': revision, + 'revision_date': revision.date_created, + 'conflict_links': conflicts_links_to_restore, + 'non_resolvable_conflicts': non_reversible_by_user, + 'versions': revision.version_set.order_by( + 'content_type__name', 'object_id_int').all, + 'object_name': force_text(self.model._meta.verbose_name), + 'app_label': self.model._meta.app_label, + 'opts': self.model._meta, + 'add': False, + 'change': True, + 'save_as': False, + 'has_add_permission': self.has_add_permission(request), + 'has_change_permission': self.has_change_permission( + request, obj), + 'has_delete_permission': self.has_delete_permission( + request, obj), + 'has_file_field': True, + 'has_absolute_url': False, + 'original': obj, + } + # if there is no conflicts - add form to context. + if not conflicts_links_to_restore: + context['restore_form'] = form + return render(request, self.recover_confirmation_template, context) diff --git a/aldryn_reversion/templates/aldryn_reversion/confirm_recover.html b/aldryn_reversion/templates/aldryn_reversion/confirm_recover.html index 041661e..bd315b7 100644 --- a/aldryn_reversion/templates/aldryn_reversion/confirm_recover.html +++ b/aldryn_reversion/templates/aldryn_reversion/confirm_recover.html @@ -21,15 +21,6 @@ {% endblocktrans %}

- {% if placeholders_to_restore %} -

{% trans 'The following placeholders were deleted and will be restored:' %}

- - {% endif %} - {% if conflict_links %}

{% trans 'Warning there are conflicts' %}

{% trans 'Please restore required related objects first:' %}

diff --git a/aldryn_reversion/tests/test_admin_views.py b/aldryn_reversion/tests/test_admin_views.py index d734e31..3e55619 100644 --- a/aldryn_reversion/tests/test_admin_views.py +++ b/aldryn_reversion/tests/test_admin_views.py @@ -377,59 +377,3 @@ def test_admin_create_obj_view(self): response = client.post(url, data={'position': position}, follow=True) self.assertEqual(obj_count, SimpleRegistered.objects.count() - 1) self.assertContains(response, position) - - -class AdminUtilsMethodsTestCase(AdminUtilsMixin, - CMSRequestBasedMixin, - HelperModelsObjectsSetupMixin, - ReversionBaseTestCase): - - def test_create_aldryn_revision(self): - # would be used to get admin instance - with_placeholder_version = get_version_for_object( - self.with_placeholder) - - admin_instance = self.get_admin_instance_for_object( - with_placeholder_version) - plugin = api.add_plugin(self.with_placeholder.content, - 'TextPlugin', language='en') - plugin.body = 'Initial text' - plugin.save() - # ensure there was no versions for plugin before - self.assertEqual( - default_revision_manager.get_for_object(plugin).count(), 0) - with transaction.atomic(): - with revision_context_manager.create_revision(): - admin_instance._create_aldryn_revision( - plugin.placeholder, - comment='New aldryn revision with initial plugin') - # ensure there is at least one version after create aldryn revision - self. assertEqual( - default_revision_manager.get_for_object(plugin).count(), 1) - new_plugin_text = 'test plugin content was changed' - plugin.body = new_plugin_text - plugin.save() - with transaction.atomic(): - with revision_context_manager.create_revision(): - admin_instance._create_aldryn_revision( - plugin.placeholder, - comment='New aldryn revision with initial plugin') - - # ensure there is at least one version after create aldryn revision - self. assertEqual( - default_revision_manager.get_for_object(plugin).count(), 2) - latest_plugin = plugin._meta.model.objects.get(pk=plugin.pk) - - # ensure text is latest - self.assertEqual(latest_plugin.body, new_plugin_text) - # ensure text is initial if reverted to previous revision - prev_version = default_revision_manager.get_for_object( - self.with_placeholder)[1] - prev_version.revision.revert() - # refresh from db - latest_plugin = plugin._meta.model.objects.get(pk=plugin.pk) - # ensure plugin text was chagned. Note however that there might be - # different paths to ensure that text is chagned for CMSPlugin - # This only checks that plugin content (which is text plugin not the cms - # is reverted, so be careful. - self.assertEqual(latest_plugin.body, 'Initial text') diff --git a/aldryn_reversion/tests/test_forms.py b/aldryn_reversion/tests/test_forms.py index 8210f76..ecf8e0d 100644 --- a/aldryn_reversion/tests/test_forms.py +++ b/aldryn_reversion/tests/test_forms.py @@ -10,14 +10,9 @@ ) from ..forms import RecoverObjectWithTranslationForm -from ..utils import ( - RecursiveRevisionConflictResolver, get_deleted_placeholders_for_object, -) +from ..utils import RecursiveRevisionConflictResolver -from .base import ( - ReversionBaseTestCase, HelperModelsObjectsSetupMixin, - get_version_for_object -) +from .base import ReversionBaseTestCase, HelperModelsObjectsSetupMixin, get_version_for_object class FormsTestCase(HelperModelsObjectsSetupMixin, ReversionBaseTestCase): @@ -30,7 +25,6 @@ def build_form_kwargs(self, obj): 'obj': obj, 'version': version, 'resolve_conflicts': [], - 'placeholders': [], } def build_unbound_form(self, args_dict): @@ -160,30 +154,25 @@ def test_recover_form_save(self): self.assertEqual(SimpleNoAdmin.objects.count(), 1) # test reverts object and deleted placeholders - with_placeholder_version = default_revision_manager.get_for_object( - self.with_placeholder)[0] placeholder_pk = self.with_placeholder.content.pk self.with_placeholder.content.delete() # check that placeholder was actually deleted. self.assertEqual( Placeholder.objects.filter(pk=placeholder_pk).count(), 0) - placeholder_versions = get_deleted_placeholders_for_object( - self.with_placeholder, with_placeholder_version.revision) form_with_placeholders_kwargs = self.build_form_kwargs( self.with_placeholder) self.with_placeholder.delete() self.assertEqual(WithPlaceholder.objects.count(), 0) - form_with_placeholders_kwargs['placeholders'] = placeholder_versions - form_with_placeholder = self.build_bound_form( - form_with_placeholders_kwargs) + form_with_placeholder = self.build_bound_form(form_with_placeholders_kwargs) self.assertTrue(form_with_placeholder.is_valid()) form_with_placeholder.save() + self.assertEqual(WithPlaceholder.objects.count(), 1) - # check that placeholder was restored - self.assertEqual( - Placeholder.objects.filter(pk=placeholder_pk).count(), 1) + + # We don't deal with placeholder reversion anymore + self.assertFalse(Placeholder.objects.filter(pk=placeholder_pk).exists()) # TODO: review this logic # test reverts object and translations form_translated_kwargs = self.build_form_kwargs(self.with_translation) diff --git a/aldryn_reversion/tests/test_placeholders.py b/aldryn_reversion/tests/test_placeholders.py deleted file mode 100644 index ed6a0a5..0000000 --- a/aldryn_reversion/tests/test_placeholders.py +++ /dev/null @@ -1,646 +0,0 @@ -# -*- coding: utf-8 -*- - -from __future__ import unicode_literals -from distutils.version import LooseVersion -import sys -import json - -from django.contrib import admin -from django.contrib.contenttypes.models import ContentType -from django.http.request import QueryDict -from django.utils.encoding import force_text -from django.utils.http import urlencode - -from reversion.models import Version, Revision - -import cms -from cms.api import create_page, add_plugin -from cms.models import Placeholder, Page, StaticPlaceholder - -from aldryn_reversion.test_helpers.project.test_app.models import ( - WithPlaceholder, -) - -from .base import ( - HelperModelsObjectsSetupMixin, - CMSRequestBasedMixin, - ReversionBaseTestCase, -) - -if sys.version_info < (2, 7): - import unittest2 as unittest -else: - import unittest - -# CMS 3.2.1 introduced several fixes for reversions. -# We count on these fixes in some tests. -CMS_3_2_1 = LooseVersion(cms.__version__) >= LooseVersion('3.2.1') -CMS_3_3 = LooseVersion(cms.__version__) >= LooseVersion('3.3') - - -class ReversionRevisionAdminTestCase(CMSRequestBasedMixin, - HelperModelsObjectsSetupMixin, - ReversionBaseTestCase): - - def get_post_request(self, data=None): - return self.get_su_request(post_data=data) - - def get_example_admin(self): - admin.autodiscover() - return admin.site._registry[WithPlaceholder] - - def get_page_admin(self): - admin.autodiscover() - return admin.site._registry[Page] - - def get_staticplaceholder_admin(self): - admin.autodiscover() - return admin.site._registry[StaticPlaceholder] - - def get_placeholder_c_type(self): - return ContentType.objects.get_for_model(Placeholder) - - def get_placeholder_versions(self): - placeholder_c_type = self.get_placeholder_c_type() - return Version.objects.filter(content_type=placeholder_c_type) - - def get_plugin_id_from_response(self, response, path): - # Expects response to be a JSON response - # with a structure like so: - # {'path.1': { - # 'path.2': '/en/admin/app/example1/edit-plugin/3/'} - # } - # path is used to access nested keys - - data = json.loads(response.content.decode('utf-8')) - keys = path.split('.') - - for key in keys: - data = data[key] - return data.split('/')[-2] - - def move_a_copy(self, admin, placeholder_id, plugin_id): - request = self.get_post_request({ - 'placeholder_id': placeholder_id, - 'plugin_id': plugin_id, - 'plugin_order': ['__COPY__'], - 'move_a_copy': 'true', - }) - return admin.move_plugin(request) - - def test_revision_on_placeholder_clear(self): - placeholder_versions = self.get_placeholder_versions() - - example = WithPlaceholder.objects.create() - m_pl = example.content - m_pl_admin = self.get_example_admin() - m_pl_versions = placeholder_versions.filter(object_id_int=m_pl.pk) - m_pl_versions_initial_count = m_pl_versions.count() - m_pl_revisions = Revision.objects.filter(version__in=m_pl_versions) - - data = { - 'placeholder': m_pl, - 'plugin_type': 'TextPlugin', - 'language': 'en', - } - - # Add plugin to manual placeholder - add_plugin(**data) - - # assert there's only one plugin in placeholder - self.assertEqual(m_pl.cmsplugin_set.count(), 1) - - # Clear the placeholder - request = self.get_post_request(data={'post': 'yes'}) - m_pl_admin.clear_placeholder(request, m_pl.pk) - - # assert placeholder has no plugins - self.assertEqual(m_pl.cmsplugin_set.count(), 0) - - # assert a new version for the native placeholder has been created - self.assertEqual( - m_pl_versions.count(), - m_pl_versions_initial_count + 1, - ) - - # assert revision comment was set correctly - self.assertEqual( - m_pl_revisions.latest('pk').comment, - 'All plugins in the placeholder "%s" ' - 'were deleted.' % force_text(m_pl), - ) - - @unittest.skipUnless(CMS_3_2_1, "CMS 3.2.1+ fixed reversion support.") - def test_revision_on_plugin_move(self): - from cms.plugin_pool import plugin_pool - - # Begin rant - # The code below is a great example of why limiting to 80 - # characters is a bad idea. - # The variable names are cryptic without any context or guide. - # End rant - - pl_versions = self.get_placeholder_versions() - - TextPluginModel = plugin_pool.get_plugin('TextPlugin').model - text_plugin_c_type = ContentType.objects.get_for_model(TextPluginModel) - - # three placeholder types - # native - native CMS placeholder (created using a placeholder tag) - # manual - Manual placeholder (created using a PlaceholderField) - # static - Static placeholder (created using the staticplaceholder tag) - - n_pl_page = create_page('test page', 'simple.html', u'en') - n_pl = n_pl_page.placeholders.get(slot='content_1') - n_pl_pk = n_pl.pk - n_pl_admin = self.get_page_admin() - n_pl_versions = pl_versions.filter(object_id_int=n_pl_pk) - n_pl_versions_initial_count = n_pl_versions.count() - n_pl_revisions = Revision.objects.filter(version__in=n_pl_versions) - - example = WithPlaceholder.objects.create() - m_pl = example.content - m_pl_admin = self.get_example_admin() - m_pl_versions = pl_versions.filter(object_id_int=m_pl.pk) - m_pl_versions_initial_count = m_pl_versions.count() - m_pl_revisions = Revision.objects.filter(version__in=m_pl_versions) - - static_placeholder_obj = StaticPlaceholder.objects.create( - name='static', - code='static', - site_id=1, - ) - static_placeholder = static_placeholder_obj.draft - static_placeholder_admin = self.get_staticplaceholder_admin() - - data = { - 'placeholder': n_pl, - 'plugin_type': 'TextPlugin', - 'language': 'en', - } - - # Add plugin to native placeholder - text_plugin = add_plugin(**data) - text_plugin_pk = text_plugin.pk - text_plugin_versions = Version.objects.filter( - content_type=text_plugin_c_type, - object_id_int=text_plugin_pk, - ) - text_plugin_versions_initial_count = text_plugin_versions.count() - - # move plugin to manual placeholder - request = self.get_post_request({ - 'placeholder_id': m_pl.pk, - 'plugin_id': text_plugin_pk, - }) - response = n_pl_admin.move_plugin(request) - self.assertEqual(response.status_code, 200) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 1, - ) - - # assert revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(m_pl), - ) - - # assert a new version for the manual placeholder has been created - self.assertEqual( - m_pl_versions.count(), - m_pl_versions_initial_count + 1, - ) - - # assert revision comment was set correctly - self.assertEqual( - m_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(m_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.count(), - text_plugin_versions_initial_count + 1, - ) - - # move plugin back to native - request = self.get_post_request({ - 'placeholder_id': n_pl_pk, - 'plugin_id': text_plugin_pk, - }) - response = m_pl_admin.move_plugin(request) - self.assertEqual(response.status_code, 200) - - # assert a new version for the manual placeholder has been created - self.assertEqual( - m_pl_versions.count(), - m_pl_versions_initial_count + 2, - ) - - # assert manual placeholder revision comment was set correctly - self.assertEqual( - m_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(n_pl), - ) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 2, - ) - - # assert native placeholder revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(n_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.count(), - text_plugin_versions_initial_count + 2, - ) - - # move plugin to static placeholder - request = self.get_post_request({ - 'placeholder_id': static_placeholder.pk, - 'plugin_id': text_plugin_pk, - }) - response = n_pl_admin.move_plugin(request) - self.assertEqual(response.status_code, 200) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 3, - ) - - # assert native placeholder revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(static_placeholder), - ) - - # move plugin back to native - request = self.get_post_request({ - 'placeholder_id': n_pl_pk, - 'plugin_id': text_plugin_pk, - }) - response = static_placeholder_admin.move_plugin(request) - self.assertEqual(response.status_code, 200) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 4, - ) - - # assert native placeholder revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Moved plugins to %s' % force_text(n_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.count(), - text_plugin_versions_initial_count + 3, - ) - - @unittest.skipUnless(CMS_3_2_1, "CMS 3.2.1+ fixed reversion support.") - def test_revision_on_plugin_move_a_copy(self): - from cms.plugin_pool import plugin_pool - - pl_versions = self.get_placeholder_versions() - - TextPluginModel = plugin_pool.get_plugin('TextPlugin').model - text_plugin_c_type = ContentType.objects.get_for_model(TextPluginModel) - - # three placeholder types - # native - native CMS placeholder (created using a placeholder tag) - # manual - Manual placeholder (created using a PlaceholderField) - # static - Static placeholder (created using the staticplaceholder tag) - - n_pl_page = create_page('test page', 'simple.html', u'en') - n_pl = n_pl_page.placeholders.get(slot='content_1') - n_pl_pk = n_pl.pk - n_pl_admin = self.get_page_admin() - n_pl_versions = pl_versions.filter(object_id_int=n_pl_pk) - n_pl_revisions = Revision.objects.filter(version__in=n_pl_versions) - n_pl_versions_initial_count = n_pl_versions.count() - - example = WithPlaceholder.objects.create() - m_pl = example.content - m_pl_admin = self.get_example_admin() - m_pl_versions = pl_versions.filter(object_id_int=m_pl.pk) - m_pl_revisions = Revision.objects.filter(version__in=m_pl_versions) - m_pl_versions_initial_count = m_pl_versions.count() - - static_placeholder_obj = StaticPlaceholder.objects.create( - name='static', - code='static', - site_id=1, - ) - static_placeholder = static_placeholder_obj.draft - static_placeholder_admin = self.get_staticplaceholder_admin() - - data = { - 'placeholder': n_pl, - 'plugin_type': 'TextPlugin', - 'language': 'en', - } - - # Add plugin to native placeholder - text_plugin = add_plugin(**data) - text_plugin_pk = text_plugin.pk - text_plugin_versions = Version.objects.filter( - content_type=text_plugin_c_type, - ) - - # copy plugin from native to manual placeholder - response = self.move_a_copy( - admin=n_pl_admin, - placeholder_id=m_pl.pk, - plugin_id=text_plugin_pk, - ) - - self.assertEqual(response.status_code, 200) - - # Point to the newly created text plugin - text_plugin_pk = self.get_plugin_id_from_response( - response, - path='urls.edit_plugin', - ) - - # assert native placeholder version count remains the same - self.assertEqual( - n_pl_versions.count(), - # We use 2 because there's two placeholders - # in the native placeholder page - n_pl_versions_initial_count, - ) - - # assert a new version for the manual placeholder has been created - self.assertEqual( - m_pl_versions.count(), - m_pl_versions_initial_count + 1, - ) - - # assert revision comment was set correctly - self.assertEqual( - m_pl_revisions.latest('pk').comment, - 'Copied plugins to %s' % force_text(m_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.filter(object_id_int=text_plugin_pk).count(), - 1, - ) - - # copy plugin from manual to native placeholder - response = self.move_a_copy( - admin=m_pl_admin, - placeholder_id=n_pl.pk, - plugin_id=text_plugin_pk, - ) - - self.assertEqual(response.status_code, 200) - - # Point to the newly created text plugin - text_plugin_pk = self.get_plugin_id_from_response( - response, - path='urls.edit_plugin', - ) - - # assert manual placeholder version count remains the same - self.assertEqual( - m_pl_versions.count(), - # We use 2 because there's two placeholders - # in the native placeholder page - m_pl_versions_initial_count + 1, - ) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 1, - ) - - # assert native placeholder revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Copied plugins to %s' % force_text(n_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.filter(object_id_int=text_plugin_pk).count(), - 1, - ) - - # copy plugin from native to static placeholder - response = self.move_a_copy( - admin=n_pl_admin, - placeholder_id=static_placeholder.pk, - plugin_id=text_plugin_pk, - ) - - self.assertEqual(response.status_code, 200) - - # Point to the newly created text plugin - text_plugin_pk = self.get_plugin_id_from_response( - response, - path='urls.edit_plugin', - ) - - # assert native placeholder version count remains the same - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 1, - ) - - # copy plugin from static to native placeholder - response = self.move_a_copy( - admin=static_placeholder_admin, - placeholder_id=n_pl.pk, - plugin_id=text_plugin_pk, - ) - - self.assertEqual(response.status_code, 200) - - # Point to the newly created text plugin - text_plugin_pk = self.get_plugin_id_from_response( - response, - path='urls.edit_plugin', - ) - - # assert a new version for the native placeholder has been created - self.assertEqual( - n_pl_versions.count(), - n_pl_versions_initial_count + 2, - ) - - # assert native placeholder revision comment was set correctly - self.assertEqual( - n_pl_revisions.latest('pk').comment, - 'Copied plugins to %s' % force_text(n_pl), - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - text_plugin_versions.filter(object_id_int=text_plugin_pk).count(), - 1, - ) - - def test_revision_view_reverts_object_to_selected_state(self): - from cms.plugin_pool import plugin_pool - - SamplePluginModel = plugin_pool.get_plugin('SamplePlugin').model - s_plugin_c_type = ContentType.objects.get_for_model(SamplePluginModel) - - example_obj = WithPlaceholder.objects.create() - - m_pl = example_obj.content - m_pl_admin = self.get_example_admin() - - example_obj_versions = ( - m_pl_admin - .revision_manager - .get_for_object(example_obj) - .order_by("-pk") - ) - - data = { - 'plugin_type': 'SamplePlugin', - 'placeholder_id': m_pl.pk, - 'plugin_language': 'en', - } - - if CMS_3_3: - request = self.get_su_request(post_data={}) - request.GET = QueryDict(urlencode(data)) - request._dont_enforce_csrf_checks = True - else: - request = self.get_post_request(data) - - # first plugin - response = m_pl_admin.add_plugin(request) - - self.assertEqual(response.status_code, 200) - self.assertEqual(m_pl.cmsplugin_set.count(), 1) - - # First version for example obj - example_obj_v1 = example_obj_versions[0] - - # Point to the newly created sample plugin - sample_plugin_pk = m_pl.cmsplugin_set.get().pk - - sample_plugin_versions = ( - example_obj_v1.revision.version_set.all() - .filter( - content_type=s_plugin_c_type, - object_id_int=sample_plugin_pk - ).count() - ) - - # assert a new version for the sample plugin has been created - self.assertEqual( - sample_plugin_versions, - 1, - ) - - # second plugin - response = m_pl_admin.add_plugin(request) - - self.assertEqual(response.status_code, 200) - self.assertEqual(m_pl.cmsplugin_set.count(), 2) - - # Second version for example obj - example_obj_v2 = example_obj_versions[0] - - # Point to the newly created sample plugin - sample_plugin_pk = m_pl.cmsplugin_set.latest('id').pk - - sample_plugin_versions = ( - example_obj_v2.revision.version_set.all() - .filter( - content_type=s_plugin_c_type, - object_id_int=sample_plugin_pk - ).count() - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - sample_plugin_versions, - 1, - ) - - # third plugin - response = m_pl_admin.add_plugin(request) - - self.assertEqual(response.status_code, 200) - self.assertEqual(m_pl.cmsplugin_set.count(), 3) - - # third version for example obj - example_obj_v3 = example_obj_versions[0] - - # Point to the newly created sample plugin - sample_plugin_pk = m_pl.cmsplugin_set.latest('id').pk - - sample_plugin_versions = ( - example_obj_v3.revision.version_set.all() - .filter( - content_type=s_plugin_c_type, - object_id_int=sample_plugin_pk - ).count() - ) - - # assert a new version for the text plugin has been created - self.assertEqual( - sample_plugin_versions, - 1, - ) - - self.assertEqual(m_pl.cmsplugin_set.count(), 3) - - request = self.get_post_request(data={}) - - # revert to the example object's version 1 - m_pl_admin.revision_view( - request, - str(example_obj.pk), - str(example_obj_v1.pk), - ) - - self.assertEqual(response.status_code, 200) - - # assert that only one plugin is present - self.assertEqual(m_pl.cmsplugin_set.count(), 1) - - # revert to the example object's version 3 - m_pl_admin.revision_view( - request, - str(example_obj.pk), - str(example_obj_v3.pk), - ) - - self.assertEqual(response.status_code, 200) - - # assert that all three plugin is present - self.assertEqual(m_pl.cmsplugin_set.count(), 3) - - # revert to the example object's version 2 - m_pl_admin.revision_view( - request, - str(example_obj.pk), - str(example_obj_v2.pk), - ) - - self.assertEqual(response.status_code, 200) - - # assert that only two plugin is present - self.assertEqual(m_pl.cmsplugin_set.count(), 2) diff --git a/aldryn_reversion/tests/test_utils.py b/aldryn_reversion/tests/test_utils.py index f4e7e4a..b510671 100644 --- a/aldryn_reversion/tests/test_utils.py +++ b/aldryn_reversion/tests/test_utils.py @@ -7,11 +7,11 @@ from cms.models import Placeholder from ..utils import ( - object_is_translation, object_has_placeholders, - get_placeholder_fields_names, get_fk_models, - get_translations_versions_for_object, get_deleted_objects_versions, - get_conflict_fks_versions, get_deleted_placeholders, - get_deleted_placeholders_for_object, + object_is_translation, + get_fk_models, + get_translations_versions_for_object, + get_deleted_objects_versions, + get_conflict_fks_versions, RecursiveRevisionConflictResolver, ) @@ -34,20 +34,6 @@ def test_object_is_translation(self): translation = self.with_translation.translations.all()[0] self.assertTrue(object_is_translation(translation)) - def test_object_has_placeholders(self): - self.assertFalse(object_has_placeholders(self.with_translation)) - self.assertTrue(object_has_placeholders(self.with_placeholder)) - - def test_get_placeholder_fields_names(self): - placeholder_name = 'content' - result = get_placeholder_fields_names(self.with_placeholder) - self.assertEqual(len(result), 1) - self.assertIn(placeholder_name, result) - - # check that calling function for second time doesn't changes result - result = get_placeholder_fields_names(self.with_placeholder) - self.assertEqual(len(result), 1) - def test_get_fk_models(self): # all fk's, blankness in models shouldn't affect the result result_all = get_fk_models(self.simple_fk) @@ -201,77 +187,6 @@ def test_get_conflict_fks_versions_with_blank_fk_no_fk(self): new_blank_fk, new_blank_fk_version, new_blank_fk_version.revision) self.assertEqual(len(result), 0) - def test_get_deleted_placeholders(self): - with_placeholder_version = default_revision_manager.get_for_object( - self.with_placeholder)[0] - # test returns nothing if there are no deleted placeholders - result = get_deleted_placeholders(with_placeholder_version.revision) - self.assertEqual(len(result), 0) - - # delete placeholder - placeholder_pk = self.with_placeholder.content.pk - self.with_placeholder.content.delete() - # check that placeholder was actually deleted. - self.assertEqual(self.with_placeholder._meta.model.objects.filter( - pk=placeholder_pk).count(), 0) - - result = get_deleted_placeholders(with_placeholder_version.revision) - self.assertEqual(len(result), 1) - - # test with revision that has more then one deleted placeholder - # (misc objects) - complex_one_fk_version = default_revision_manager.get_for_object( - self.complex_one_fk)[0] - other_placeholder_pk = self.complex_one_fk.complex_content.pk - self.complex_one_fk.complex_content.delete() - self.assertEqual(self.with_placeholder._meta.model.objects.filter( - pk__in=[placeholder_pk, other_placeholder_pk]).count(), 0) - result = get_deleted_placeholders(complex_one_fk_version.revision) - self.assertEqual(len(result), 2) - - def test_get_deleted_placeholders_for_object(self): - # test that it not fails with object that has no placeholders - simple_no_admin_version = default_revision_manager.get_for_object( - self.simple_no_admin)[0] - result = get_deleted_placeholders_for_object( - self.with_placeholder, simple_no_admin_version.revision) - self.assertEqual(len(result), 0) - - # test if no placeholders were deleted - with_placeholder_version = default_revision_manager.get_for_object( - self.with_placeholder)[0] - result = get_deleted_placeholders_for_object( - self.with_placeholder, with_placeholder_version.revision) - self.assertEqual(len(result), 0) - - # test if placeholder was deleted for this object - # delete placeholder - placeholder_pk = self.with_placeholder.content.pk - self.with_placeholder.content.delete() - # check that placeholder was actually deleted. - self.assertEqual(self.with_placeholder._meta.model.objects.filter( - pk=placeholder_pk).count(), 0) - - result = get_deleted_placeholders_for_object( - self.with_placeholder, with_placeholder_version.revision) - self.assertEqual(len(result), 1) - - # test if placeholder was deleted for not related object (no result) - complex_one_fk_version = default_revision_manager.get_for_object( - self.complex_one_fk)[0] - other_placeholder_pk = self.complex_one_fk.complex_content.pk - self.complex_one_fk.complex_content.delete() - self.assertEqual(self.with_placeholder._meta.model.objects.filter( - pk__in=[placeholder_pk, other_placeholder_pk]).count(), 0) - - result = get_deleted_placeholders_for_object( - self.with_placeholder, with_placeholder_version.revision) - self.assertEqual(len(result), 1) - - result = get_deleted_placeholders_for_object( - self.complex_one_fk, complex_one_fk_version.revision) - self.assertEqual(len(result), 1) - def test_recursive_resolver_resolve_conflicts(self): # test with no conflicts # * no translations, placeholders, fks @@ -327,8 +242,8 @@ def test_recursive_resolver_resolve_conflicts(self): self.assertEqual(WithPlaceholder.objects.count(), 0) self.assertEqual(ComplexOneFK.objects.count(), 0) result = RecursiveRevisionConflictResolver(complex_fk_version).resolve() - # 2 for translations, 2 for placeholders, 2 for deleted objects. - self.assertEqual(len(result), 6) + # 2 for translations, 0 for placeholders (we don't keep them anymore), 2 for deleted objects. + self.assertEqual(len(result), 4) # TODO: review this logic # test with version and prepared to resolve. # for second and third if clauses. @@ -340,13 +255,13 @@ def test_recursive_resolver_resolve_conflicts(self): # expecting: # [, , # , , , - # , , + # , # , ] - self.assertEqual(len(result), 9) + self.assertEqual(len(result), 7) # test with duplicates in to_resolve. use results from # resolving_conflicts for one of the dependencies. result = RecursiveRevisionConflictResolver( multi_level_fk_version, RecursiveRevisionConflictResolver(simple_fk_version).resolve() ).resolve() - self.assertEqual(len(result), 9) + self.assertEqual(len(result), 7)