From 0dfd33ae697a6c9b541097549d6328b0bdc4a918 Mon Sep 17 00:00:00 2001 From: jensens Date: Mon, 10 Oct 2016 00:39:56 +0200 Subject: [PATCH] [fc] Repository: plone.dexterity Branch: refs/heads/master Date: 2016-10-10T00:39:56+02:00 Author: David Glick (davisagli) Commit: https://github.com/plone/plone.dexterity/commit/ea3bc8aed05b38c57515a628dd3cfc8b2f859e0b Remove dependency on plone.mocktestcase and mocker (#62) removing dependency on plone.mocktestcase and mocker with mock * convert test_fti to use mock * make sure all global patches get removed Files changed: A plone/dexterity/tests/case.py M CHANGES.rst M plone/dexterity/tests/schemata.py M plone/dexterity/tests/test.xml M plone/dexterity/tests/test_behavior.py M plone/dexterity/tests/test_content.py M plone/dexterity/tests/test_factory.py M plone/dexterity/tests/test_fti.py M plone/dexterity/tests/test_primary.py M plone/dexterity/tests/test_schema.py M plone/dexterity/tests/test_schema_cache.py M plone/dexterity/tests/test_security.py M plone/dexterity/tests/test_utils.py M plone/dexterity/tests/test_views.py M plone/dexterity/tests/test_webdav.py M setup.py --- last_commit.txt | 4403 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 4095 insertions(+), 308 deletions(-) diff --git a/last_commit.txt b/last_commit.txt index 740f9aa3fa..ec36048581 100644 --- a/last_commit.txt +++ b/last_commit.txt @@ -1,340 +1,4127 @@ -Repository: plone.app.upgrade +Repository: plone.dexterity Branch: refs/heads/master -Date: 2016-09-29T18:30:20-03:00 -Author: Rodrigo Ferreira de Souza (rodfersou) -Commit: https://github.com/plone/plone.app.upgrade/commit/27d85d45d2732093912f03b1cc839ce7fe99f3f5 +Date: 2016-10-10T00:39:56+02:00 +Author: David Glick (davisagli) +Commit: https://github.com/plone/plone.dexterity/commit/ea3bc8aed05b38c57515a628dd3cfc8b2f859e0b -Add sort_on and sort_reverse fields to search controlpanel +Remove dependency on plone.mocktestcase and mocker (#62) + +removing dependency on plone.mocktestcase and mocker with mock + +* convert test_fti to use mock +* make sure all global patches get removed Files changed: +A plone/dexterity/tests/case.py M CHANGES.rst -M plone/app/upgrade/v43/configure.zcml -M plone/app/upgrade/v43/final.py -M plone/app/upgrade/v51/betas.py -M plone/app/upgrade/v51/configure.zcml -M plone/app/upgrade/v51/profiles/to_beta1/registry.xml +M plone/dexterity/tests/schemata.py +M plone/dexterity/tests/test.xml +M plone/dexterity/tests/test_behavior.py +M plone/dexterity/tests/test_content.py +M plone/dexterity/tests/test_factory.py +M plone/dexterity/tests/test_fti.py +M plone/dexterity/tests/test_primary.py +M plone/dexterity/tests/test_schema.py +M plone/dexterity/tests/test_schema_cache.py +M plone/dexterity/tests/test_security.py +M plone/dexterity/tests/test_utils.py +M plone/dexterity/tests/test_views.py +M plone/dexterity/tests/test_webdav.py +M setup.py diff --git a/CHANGES.rst b/CHANGES.rst -index 960a71d..87c22bc 100644 +index 9c3cf6c..b4e5400 100644 --- a/CHANGES.rst +++ b/CHANGES.rst -@@ -10,6 +10,9 @@ Breaking changes: +@@ -11,7 +11,7 @@ Breaking changes: New features: -+- Add sort_on field to search controlpanel. -+ [rodfersou] -+ - - Support sites without ``portal_quickinstaller``. - We use ``get_installer`` in Plone 5.1 migrations. - In earlier version we will keep using the ``portal_quickinstaller``, -diff --git a/plone/app/upgrade/v43/configure.zcml b/plone/app/upgrade/v43/configure.zcml -index d7737b1..84bf895 100644 ---- a/plone/app/upgrade/v43/configure.zcml -+++ b/plone/app/upgrade/v43/configure.zcml -@@ -241,6 +241,7 @@ - description="" - handler="..utils.null_upgrade_step" - /> -+ - - - -+ -+ -+ -+ -+ -+ -+ - - - -diff --git a/plone/app/upgrade/v43/final.py b/plone/app/upgrade/v43/final.py -index b3eb1b1..2cda0ba 100644 ---- a/plone/app/upgrade/v43/final.py -+++ b/plone/app/upgrade/v43/final.py -@@ -324,3 +324,18 @@ def removeFakeKupu(context): - if member_data.getProperty('wysiwyg_editor') == 'Kupu': - member_data._updateProperty('wysiwyg_editor', '') - logger.info('Changed new member wysiwyg_editor to site default.') -+ -+ -+def addSortOnProperty(context): -+ """Add sort_on field to search controlpanel. -+ -+ The default value of this field is relevance. +-- *add item here* ++- Removed test dependency on plone.mocktestcase [davisagli] + + Bug fixes: + +diff --git a/plone/dexterity/tests/case.py b/plone/dexterity/tests/case.py +new file mode 100644 +index 0000000..18abd75 +--- /dev/null ++++ b/plone/dexterity/tests/case.py +@@ -0,0 +1,99 @@ ++# -*- coding: utf-8 -*- ++from mock import Mock ++import gc ++import unittest ++import zope.component ++import zope.component.testing ++ ++ ++class MockTestCase(unittest.TestCase): ++ """Base class for tests using mocks. ++ """ ++ ++ _getToolByName_return_values = None ++ _replaced_globals = None ++ ++ # Ensure that we tear down the CA after each test method ++ ++ def tearDown(self): ++ zope.component.testing.tearDown(self) ++ if self._replaced_globals is not None: ++ for mock, orig in self._replaced_globals.items(): ++ _global_replace(mock, orig) ++ ++ # Helper to create a dummy object with a particular __dict__ ++ ++ def create_dummy(self, **kw): ++ return Dummy(**kw) ++ ++ # Help register mock components. The tear-down method will ++ # wipe the registry each time. ++ ++ def mock_utility(self, mock, provides, name=u""): ++ """Register the mock as a utility providing the given interface ++ """ ++ zope.component.provideUtility( ++ provides=provides, component=mock, name=name) ++ ++ def mock_adapter(self, mock, provides, adapts, name=u""): ++ """Register the mock as an adapter providing the given interface ++ and adapting the given interface(s) ++ """ ++ zope.component.provideAdapter( ++ factory=mock, adapts=adapts, provides=provides, name=name) ++ ++ def mock_subscription_adapter(self, mock, provides, adapts): ++ """Register the mock as a utility providing the given interface ++ """ ++ zope.component.provideSubscriptionAdapter( ++ factory=mock, provides=provides, adapts=adapts) ++ ++ def mock_handler(self, mock, adapts): ++ """Register the mock as a utility providing the given interface ++ """ ++ zope.component.provideHandler(factory=mock, adapts=adapts) ++ ++ def mock_tool(self, mock, name): ++ """Register a mock tool that will be returned when getToolByName() ++ is called. ++ """ ++ if self._getToolByName_return_values is None: ++ self._getToolByName_return_values = return_values = {} ++ ++ def get_return_value(context, name, default=None): ++ return return_values.get(name, default) ++ ++ from Products.CMFCore.utils import getToolByName ++ self.patch_global( ++ getToolByName, side_effect=get_return_value) ++ self._getToolByName_return_values[name] = mock ++ ++ def patch_global(self, orig, mock=None, **kw): ++ if mock is None: ++ mock = Mock(**kw) ++ elif kw: ++ raise Exception( ++ 'Keyword arguments are ignored if a mock instance is passed.') ++ _global_replace(orig, mock) ++ if self._replaced_globals is None: ++ self._replaced_globals = {} ++ self._replaced_globals[mock] = orig ++ return mock ++ ++ ++class Dummy(object): ++ """Dummy object with arbitrary attributes ++ """ ++ ++ def __init__(self, **kw): ++ self.__dict__.update(kw) ++ ++ ++# from mocker ++def _global_replace(remove, install): ++ """Replace object 'remove' with object 'install' on all dictionaries.""" ++ for referrer in gc.get_referrers(remove): ++ if (type(referrer) is dict): ++ for key, value in list(referrer.iteritems()): ++ if value is remove: ++ referrer[key] = install +diff --git a/plone/dexterity/tests/schemata.py b/plone/dexterity/tests/schemata.py +index 5687810..e99ef8a 100644 +--- a/plone/dexterity/tests/schemata.py ++++ b/plone/dexterity/tests/schemata.py +@@ -24,4 +24,4 @@ class ITaggedValueSchema(Interface): + + class IDerivedFromTaggedValueSchema(ITaggedValueSchema): + """Schema used for testing tagged value filenames +- """ +\ No newline at end of file + """ -+ site_properties = getToolByName(context, 'portal_properties').site_properties -+ if not site_properties.hasProperty('sort_on'): -+ if 'sort_on' in site_properties.__dict__: -+ # fix bug if 4.3.1 pending has been tested -+ del site_properties.sort_on -+ site_properties.manage_addProperty('sort_on', 'relevance', 'string') -+ logger.log(logging.INFO, -+ "Added 'sort_on' property to site_properties.") -diff --git a/plone/app/upgrade/v51/betas.py b/plone/app/upgrade/v51/betas.py -index f14fc64..8ba9cf5 100644 ---- a/plone/app/upgrade/v51/betas.py -+++ b/plone/app/upgrade/v51/betas.py -@@ -1,5 +1,9 @@ +diff --git a/plone/dexterity/tests/test.xml b/plone/dexterity/tests/test.xml +index 2803aca..21edb44 100644 +--- a/plone/dexterity/tests/test.xml ++++ b/plone/dexterity/tests/test.xml +@@ -10,4 +10,4 @@ + False + + +- +\ No newline at end of file ++ +diff --git a/plone/dexterity/tests/test_behavior.py b/plone/dexterity/tests/test_behavior.py +index 75d3983..7706ade 100644 +--- a/plone/dexterity/tests/test_behavior.py ++++ b/plone/dexterity/tests/test_behavior.py +@@ -3,9 +3,8 @@ + from plone.dexterity.behavior import DexterityBehaviorAssignable + from plone.dexterity.fti import DexterityFTI + from plone.dexterity.interfaces import IDexterityFTI +-from plone.mocktestcase import MockTestCase + from zope.interface import Interface +-import unittest ++from .case import MockTestCase + + + class IOne(Interface): +@@ -50,8 +49,6 @@ def test_supports(self): + fti.behaviors = [IOne.__identifier__, IFour.__identifier__] + self.mock_utility(fti, IDexterityFTI, name=u"testtype") + +- self.replay() +- + assignable = DexterityBehaviorAssignable(context_dummy) + + self.assertEqual(True, assignable.supports(IOne)) +@@ -73,15 +70,9 @@ def test_enumerate(self): + fti.behaviors = [IOne.__identifier__] + self.mock_utility(fti, IDexterityFTI, name=u"testtype") + +- self.replay() +- + assignable = DexterityBehaviorAssignable(context_dummy) + + self.assertEqual( + [behavior_dummy], + list(assignable.enumerateBehaviors()) + ) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_content.py b/plone/dexterity/tests/test_content.py +index 8b4b495..82c9183 100644 +--- a/plone/dexterity/tests/test_content.py ++++ b/plone/dexterity/tests/test_content.py +@@ -2,6 +2,7 @@ + from DateTime import DateTime + from Products.CMFPlone.interfaces import IConstrainTypes + from datetime import date, datetime ++from mock import Mock + from plone.behavior.interfaces import IBehavior + from plone.behavior.interfaces import IBehaviorAssignable + from plone.behavior.registration import BehaviorRegistration +@@ -14,15 +15,14 @@ + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.schema import SCHEMA_CACHE + from plone.folder.default import DefaultOrdering +-from plone.mocktestcase import MockTestCase + from pytz import timezone + from zope.annotation.attribute import AttributeAnnotations + from zope.component import getUtility + from zope.component import provideAdapter + from zope.interface import Interface + from zope.interface import alsoProvides ++from .case import MockTestCase + +-import unittest + import zope.schema + + +@@ -59,13 +59,10 @@ class IMarker(Interface): + pass + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) ++ fti_mock = Mock(wraps=DexterityFTI('testtype')) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- +- self.replay() +- + self.assertFalse(ISchema.implementedBy(Item)) + + # Schema as looked up in FTI is now provided by item ... +@@ -73,8 +70,9 @@ class IMarker(Interface): + + # If the _v_ attribute cache does not work, then we'd expect to have + # to look up the schema more than once (since we invalidated) +- # the cache. This is not the case, as evidenced by .count(1) above. ++ # the cache. This is not the case: + self.assertTrue(ISchema.providedBy(item)) ++ self.assertEqual(fti_mock.lookupSchema.call_count, 1) + + # We also need to ensure that the _v_ attribute doesn't hide any + # interface set directly on the instance with alsoProvides() or +@@ -116,12 +114,10 @@ class IMarker(Interface): + pass + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema).count(1) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + self.assertFalse(ISchema.implementedBy(MyItem)) + + # Schema as looked up in FTI is now provided by item ... +@@ -129,15 +125,15 @@ class IMarker(Interface): + + # If the _v_ attribute cache does not work, then we'd expect to have + # to look up the schema more than once (since we invalidated) +- # the cache. This is not the case, as evidenced by .count(1) above. ++ # the cache. This is not the case: + self.assertTrue(ISchema.providedBy(item)) ++ self.assertEqual(fti_mock.lookupSchema.call_count, 1) + + # We also need to ensure that the _v_ attribute doesn't hide any + # interface set directly on the instance with alsoProvides() or + # directlyProvides(). This is done by clearing the cache when these + # are invoked. + alsoProvides(item, IMarker) +- + self.assertTrue(IMarker.providedBy(item)) + self.assertTrue(ISchema.providedBy(item)) + +@@ -164,12 +160,10 @@ class IMarker(Interface): + pass + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema).count(1) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + self.assertFalse(ISchema.implementedBy(MyItem)) + + # Schema as looked up in FTI is now provided by item ... +@@ -177,15 +171,15 @@ class IMarker(Interface): + + # If the _v_ attribute cache does not work, then we'd expect to have + # to look up the schema more than once (since we invalidated) +- # the cache. This is not the case, as evidenced by .count(1) above. ++ # the cache. This is not the case: + self.assertTrue(ISchema.providedBy(item)) ++ self.assertEqual(fti_mock.lookupSchema.call_count, 1) + + # We also need to ensure that the _v_ attribute doesn't hide any + # interface set directly on the instance with alsoProvides() or + # directlyProvides(). This is done by clearing the cache when these + # are invoked. + alsoProvides(item, IMarker) +- + self.assertTrue(IMarker.providedBy(item)) + self.assertTrue(ISchema.providedBy(item)) + +@@ -223,9 +217,8 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # Schema is not implemented by class or provided by instance +- # XXX :no assert before replay +- # self.assertFalse(ISchema.implementedBy(MyItem)) +- # self.assertFalse(ISchema.providedBy(item)) ++ self.assertFalse(ISchema.implementedBy(MyItem)) ++ self.assertFalse(ISchema.providedBy(item)) + + # Behaviors - one with a subtype and one without + self.mock_adapter( +@@ -262,15 +255,11 @@ class IMarker2(Interface): + self.mock_utility(behavior2, IBehavior, name="behavior2") + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) ++ fti_mock.behaviors = ['behavior1', 'behavior2'] + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- # expectations +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.expect(fti_mock.behaviors).result(['behavior1', 'behavior2']) +- +- self.replay() +- + # start clean + SCHEMA_CACHE.clear() + +@@ -334,9 +323,8 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # Schema is not implemented by class or provided by instance +- # XXX :no assert before replay +- # self.assertFalse(ISchema.implementedBy(MyItem)) +- # self.assertFalse(ISchema.providedBy(item)) ++ self.assertFalse(ISchema.implementedBy(MyItem)) ++ self.assertFalse(ISchema.providedBy(item)) + + # Behaviors - one with a marker and one without + class IBehavior1(Interface): +@@ -388,25 +376,13 @@ class IMarker3(Interface): + ) + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- +- # twice, since we invalidate +- self.expect(fti_mock.lookupSchema()).result(ISchema).count(2) +- +- # First time around, we have only these behaviors +- self.expect(fti_mock.behaviors).result( +- ['behavior1', 'behavior2']).count(1) +- +- # Second time around, we add another one +- self.expect(fti_mock.behaviors).result( +- ['behavior1', 'behavior2', 'behavior3']).count(1) +- ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + # start clean + SCHEMA_CACHE.invalidate('testtype') ++ fti_mock.behaviors = ['behavior1', 'behavior2'] + + # implementedBy does not look into the fti + self.assertFalse(ISchema.implementedBy(MyItem)) +@@ -423,6 +399,7 @@ class IMarker3(Interface): + # If we now invalidate the schema cache, we should get the + # SECOND set of behaviors (which includes behavior3) + SCHEMA_CACHE.invalidate('testtype') ++ fti_mock.behaviors = ['behavior1', 'behavior2', 'behavior3'] + + # Main schema as looked up in FTI is now provided by item ... + self.assertTrue(ISchema.providedBy(item)) +@@ -452,12 +429,10 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + SCHEMA_CACHE.invalidate('testtype') + + self.assertEqual(u"foo_default", content.foo) +@@ -476,12 +451,10 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + SCHEMA_CACHE.invalidate('testtype') + + self.assertEqual(u"foo_default", content.foo) +@@ -508,12 +481,10 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + SCHEMA_CACHE.invalidate('testtype') + + self.assertEqual(u"id_testtype", content.foo) +@@ -535,12 +506,10 @@ class ISchema(Interface): + bar = zope.schema.TextLine(title=u"bar") + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + SCHEMA_CACHE.invalidate('testtype') + + # Schema field masks contained item +@@ -1000,12 +969,10 @@ class ISchema(Interface): + listfield = zope.schema.List(title=u"listfield", default=[1, 2]) + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema).count(1) ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + # Ensure that the field of foo is not the same field, also attached to + # bar. + self.assertTrue(foo.listfield is not bar.listfield) +@@ -1047,12 +1014,9 @@ def allowedContentTypes(self): + DummyConstrainTypes, IConstrainTypes, (IDexterityContainer, )) + + # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.getId()).result(u"testtype") ++ fti_mock = Mock(wraps=DexterityFTI(u"testtype")) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + folder = Container(id="testfolder") + + self.assertEqual(folder.allowedContentTypes(), [fti_mock]) +@@ -1091,14 +1055,13 @@ def test_verifyObjectPaste_fti_does_not_allow_content(self): + container.manage_permission('View', ('Anonymous',)) + container['test'] = content + content = container['test'] +- fti = self.mocker.mock() +- self.expect(fti.isConstructionAllowed(container)).result(False) +- self.mock_utility(fti, ITypeInformation, name='document') +- pt = self.mocker.mock() +- self.expect(pt.getTypeInfo('document')).result(None) +- self.expect(pt.getTypeInfo(container)).result(None) +- self.mock_tool(pt, 'portal_types') +- self.replay() ++ fti_mock = Mock() ++ fti_mock.isConstructionAllowed = Mock(return_value=False) ++ self.mock_utility(fti_mock, ITypeInformation, name='document') ++ mock_pt = Mock() ++ mock_pt.getTypeInfo = Mock(return_value=None) ++ self.mock_tool(mock_pt, 'portal_types') ++ + self.assertRaises( + ValueError, + container._verifyObjectPaste, +@@ -1120,16 +1083,11 @@ def test_verifyObjectPaste_fti_does_allow_content(self): + container.manage_permission('View', ('Anonymous',)) + container['test'] = content + content = container['test'] +- fti = self.mocker.mock() +- self.expect(fti.isConstructionAllowed(container)).result(True) +- self.mock_utility(fti, ITypeInformation, name='document') +- pt = self.mocker.mock() +- self.expect(pt.getTypeInfo('document')).result(None) +- self.expect(pt.getTypeInfo(container)).result(None) +- self.mock_tool(pt, 'portal_types') +- self.replay() +- container._verifyObjectPaste(content, True) +- ++ mock_fti = Mock() ++ mock_fti.isConstructionAllowed = Mock(return_value=True) ++ self.mock_utility(mock_fti, ITypeInformation, name='document') ++ mock_pt = Mock() ++ mock_pt.getTypeInfo = Mock(return_value=None) ++ self.mock_tool(mock_pt, 'portal_types') + +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) ++ container._verifyObjectPaste(content, True) +diff --git a/plone/dexterity/tests/test_factory.py b/plone/dexterity/tests/test_factory.py +index f84a542..dc78c8e 100644 +--- a/plone/dexterity/tests/test_factory.py ++++ b/plone/dexterity/tests/test_factory.py +@@ -1,9 +1,10 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from plone.dexterity.factory import DexterityFactory + from plone.dexterity.fti import DexterityFTI + from plone.dexterity.interfaces import IDexterityFTI +-from plone.mocktestcase import MockTestCase + from zope.interface import Interface ++from .case import MockTestCase + import unittest + + +@@ -14,32 +15,24 @@ class IDummy(Interface): + class TestFactory(MockTestCase): + + def test_title(self): +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.title).result("Mock type") ++ fti_mock = Mock(spec=DexterityFTI, title='Mock type') + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual("Mock type", factory.title) + + def test_description(self): +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.description).result("Mock type description") ++ fti_mock = Mock(spec=DexterityFTI, description='Mock type description') + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual("Mock type description", factory.description) + + def test_get_interfaces(self): +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.lookupSchema()).result(IDummy) ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.lookupSchema = Mock(return_value=IDummy) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + spec = factory.getInterfaces() + +@@ -56,150 +49,101 @@ def test_get_interfaces(self): + def test_create_with_schema_already_provided_and_portal_type_set(self): + + # Object returned by class +- obj_mock = self.mocker.mock() +- self.expect(obj_mock.portal_type).result(u"testtype") ++ obj_mock = Mock(portal_type=u'testtype') + + # Class set by factory +- klass_mock = self.mocker.mock() +- self.expect(klass_mock()).result(obj_mock) ++ klass_mock = Mock(return_value=obj_mock) + + # Resolver +- resolver_mock = self.mocker.replace( +- "plone.dexterity.utils.resolveDottedName" +- ) +- self.expect( +- resolver_mock("my.mocked.ContentTypeClass") +- ).result(klass_mock) ++ from plone.dexterity.utils import resolveDottedName ++ self.patch_global(resolveDottedName, return_value=klass_mock) + + # FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass") ++ fti_mock = Mock(spec=DexterityFTI, klass='my.mocked.ContentTypeClass') + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual(obj_mock, factory()) + + def test_create_sets_portal_type_if_not_set(self): + + # Object returned by class +- obj_mock = self.mocker.mock() +- self.expect( +- obj_mock.portal_type +- ).throw(AttributeError) # -> need to set portal_type +- +- obj_mock.portal_type = u"testtype" ++ obj_mock = Mock() + + # Class set by factory +- klass_mock = self.mocker.mock() +- self.expect(klass_mock()).result(obj_mock) ++ klass_mock = Mock(return_value=obj_mock) + + # Resolver +- resolver_mock = self.mocker.replace( +- "plone.dexterity.utils.resolveDottedName" +- ) +- self.expect( +- resolver_mock("my.mocked.ContentTypeClass") +- ).result(klass_mock) ++ from plone.dexterity.utils import resolveDottedName ++ self.patch_global(resolveDottedName, return_value=klass_mock) + + # FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass") ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.klass = "my.mocked.ContentTypeClass" + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual(obj_mock, factory()) ++ self.assertEqual(obj_mock.portal_type, u'testtype') + + def test_create_sets_portal_type_if_wrong(self): + + # Object returned by class +- obj_mock = self.mocker.mock() +- self.expect( +- obj_mock.portal_type +- ).result('othertype') # -> need to fix portal_type +- obj_mock.portal_type = u"testtype" ++ obj_mock = Mock(portal_type='othertype') + + # Class set by factory +- klass_mock = self.mocker.mock() +- self.expect(klass_mock()).result(obj_mock) ++ klass_mock = Mock(return_value=obj_mock) + + # Resolver +- resolver_mock = self.mocker.replace( +- "plone.dexterity.utils.resolveDottedName" +- ) +- self.expect( +- resolver_mock("my.mocked.ContentTypeClass") +- ).result(klass_mock) ++ from plone.dexterity.utils import resolveDottedName ++ self.patch_global(resolveDottedName, return_value=klass_mock) + + # FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass") ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.klass = "my.mocked.ContentTypeClass" + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual(obj_mock, factory()) ++ self.assertEqual(obj_mock.portal_type, u'testtype') + + def test_create_initialises_schema_if_not_provided(self): + + # Object returned by class +- obj_mock = self.mocker.mock() +- self.expect(obj_mock.portal_type).result(u"testtype") ++ obj_mock = Mock(portal_type=u'testtype') + + # Class set by factory +- klass_mock = self.mocker.mock() +- self.expect(klass_mock()).result(obj_mock) ++ klass_mock = Mock(return_value=obj_mock) + + # Resolver +- resolver_mock = self.mocker.replace( +- "plone.dexterity.utils.resolveDottedName" +- ) +- self.expect( +- resolver_mock("my.mocked.ContentTypeClass") +- ).result(klass_mock) ++ from plone.dexterity.utils import resolveDottedName ++ self.patch_global(resolveDottedName, return_value=klass_mock) + + # FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass") ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.klass = "my.mocked.ContentTypeClass" + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual(obj_mock, factory()) + + def test_factory_passes_args_and_kwargs(self): + + # Object returned by class +- obj_mock = self.mocker.mock() +- self.expect(obj_mock.portal_type).result(u"testtype") ++ obj_mock = Mock(portal_type=u'testtype') + + # Class set by factory +- klass_mock = self.mocker.mock() +- self.expect(klass_mock(u"id", title=u"title")).result(obj_mock) ++ klass_mock = Mock(return_value=obj_mock) + + # Resolver +- resolver_mock = self.mocker.replace( +- "plone.dexterity.utils.resolveDottedName" +- ) +- self.expect( +- resolver_mock("my.mocked.ContentTypeClass") +- ).result(klass_mock) ++ from plone.dexterity.utils import resolveDottedName ++ self.patch_global(resolveDottedName, return_value=klass_mock) + + # FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass") ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.klass = "my.mocked.ContentTypeClass" + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + factory = DexterityFactory(portal_type=u"testtype") + self.assertEqual(obj_mock, factory(u"id", title=u"title")) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) ++ klass_mock.assert_called_once_with(u'id', title=u'title') +diff --git a/plone/dexterity/tests/test_fti.py b/plone/dexterity/tests/test_fti.py +index 63fce00..3694229 100644 +--- a/plone/dexterity/tests/test_fti.py ++++ b/plone/dexterity/tests/test_fti.py +@@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- - from plone.app.upgrade.utils import loadMigrationProfile -+from plone.registry.interfaces import IRegistry -+from Products.CMFCore.utils import getToolByName -+from Products.CMFPlone.interfaces import ISearchSchema -+from zope.component import getUtility ++from mock import Mock + from Products.CMFCore.interfaces import ISiteRoot + from plone.dexterity import utils + from plone.dexterity.factory import DexterityFactory +@@ -11,7 +12,6 @@ + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.schema import DexteritySchemaPolicy + from plone.dexterity.tests.schemata import ITestSchema +-from plone.mocktestcase import MockTestCase + from plone.supermodel.model import Model + from zope.component import getGlobalSiteManager + from zope.component import queryUtility +@@ -25,11 +25,10 @@ + from zope.lifecycleevent import ObjectModifiedEvent + from zope.lifecycleevent.interfaces import IObjectModifiedEvent + from zope.security.interfaces import IPermission ++from .case import MockTestCase + +-import mocker + import os.path + import plone.dexterity.schema.generated +-import unittest + import zope.schema + + +@@ -102,12 +101,8 @@ def test_lookupModel_from_string(self): + + model_dummy = Model() + +- loadString_mock = self.mocker.replace("plone.supermodel.loadString") +- self.expect( +- loadString_mock(fti.model_source, policy=u"dexterity") +- ).result(model_dummy) +- +- self.replay() ++ from plone.supermodel import loadString ++ self.patch_global(loadString, return_value=model_dummy) + + model = fti.lookupModel() + self.assertIs(model_dummy, model) +@@ -127,15 +122,13 @@ def test_lookupModel_from_file_with_package(self): + "test.xml" + ) - import logging +- loadFile_mock = self.mocker.replace("plone.supermodel.loadFile") +- self.expect( +- loadFile_mock(abs_file, reload=True, policy=u"dexterity") +- ).result(model_dummy) +- +- self.replay() ++ from plone.supermodel import loadFile ++ loadFile_mock = self.patch_global(loadFile, return_value=model_dummy) -@@ -9,3 +13,35 @@ + model = fti.lookupModel() + self.assertIs(model_dummy, model) ++ loadFile_mock.assert_called_once_with( ++ abs_file, reload=True, policy=u"dexterity") - def to51beta1(context): - loadMigrationProfile(context, 'profile-plone.app.upgrade.v51:to51beta1') + def test_lookupModel_from_file_with_absolute_path(self): + +@@ -152,15 +145,13 @@ def test_lookupModel_from_file_with_absolute_path(self): + + model_dummy = Model() + +- loadFile_mock = self.mocker.replace("plone.supermodel.loadFile") +- self.expect( +- loadFile_mock(abs_file, reload=True, policy=u"dexterity") +- ).result(model_dummy) +- +- self.replay() ++ from plone.supermodel import loadFile ++ loadFile_mock = self.patch_global(loadFile, return_value=model_dummy) + + model = fti.lookupModel() + self.assertIs(model_dummy, model) ++ loadFile_mock.assert_called_once_with( ++ abs_file, reload=True, policy=u"dexterity") + + def test_lookupModel_from_file_with_win32_absolute_path(self): + +@@ -171,21 +162,17 @@ def test_lookupModel_from_file_with_win32_absolute_path(self): + + model_dummy = Model() + +- isabs_mock = self.mocker.replace("os.path.isabs") +- self.expect(isabs_mock(fti.model_file)).result(True) +- +- isfile_mock = self.mocker.replace("os.path.isfile") +- self.expect(isfile_mock(fti.model_file)).result(True) +- +- loadFile_mock = self.mocker.replace("plone.supermodel.loadFile") +- self.expect( +- loadFile_mock(fti.model_file, reload=True, policy=u"dexterity") +- ).result(model_dummy) ++ from os.path import isabs, isfile ++ self.patch_global(isabs, return_value=True) ++ self.patch_global(isfile, return_value=True) + +- self.replay() ++ from plone.supermodel import loadFile ++ loadFile_mock = self.patch_global(loadFile, return_value=model_dummy) + + model = fti.lookupModel() + self.assertIs(model_dummy, model) ++ loadFile_mock.assert_called_once_with( ++ fti.model_file, reload=True, policy=u"dexterity") + + def test_lookupModel_with_schema_only(self): + fti = DexterityFTI(u"testtype") +@@ -206,16 +193,15 @@ def test_lookupModel_from_string_with_schema(self): + + model_dummy = Model() + +- loadString_mock = self.mocker.replace("plone.supermodel.loadString") +- self.expect( +- loadString_mock(fti.model_source, policy=u"dexterity") +- ).result(model_dummy) +- +- self.replay() ++ from plone.supermodel import loadString ++ loadString_mock = self.patch_global( ++ loadString, return_value=model_dummy) + + model = fti.lookupModel() + self.assertIs(model_dummy, model) + self.assertIs(ITestSchema, fti.lookupSchema()) ++ loadString_mock.assert_called_once_with( ++ fti.model_source, policy=u'dexterity') + + def test_lookupModel_failure(self): + fti = DexterityFTI(u"testtype") +@@ -231,52 +217,26 @@ def test_fires_modified_event_on_update_property_if_changed(self): + fti.title = u"Old title" + fti.global_allow = False + +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect( +- notify_mock( +- mocker.MATCH( +- lambda x: IObjectModifiedEvent.providedBy(x) +- and len(x.descriptions) == 1 +- and x.descriptions[0].attribute == 'title' +- and x.descriptions[0].oldValue == "Old title" +- ) +- ) +- ) +- +- self.replay() ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + fti._updateProperty('title', "New title") # fires event caught above + fti._updateProperty('allow_discussion', False) # does not fire + ++ event = notify_mock.call_args[0][0] ++ self.assertTrue(IObjectModifiedEvent.providedBy(event)) ++ self.assertEqual(len(event.descriptions), 1) ++ self.assertEqual(event.descriptions[0].attribute, 'title') ++ self.assertEqual(event.descriptions[0].oldValue, 'Old title') + + def test_fires_modified_event_on_change_props_per_changed_property(self): + fti = DexterityFTI(u"testtype") + fti.title = "Old title" + fti.allow_discussion = False + fti.global_allow = True + +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect( +- notify_mock( +- mocker.MATCH( +- lambda x: IObjectModifiedEvent.providedBy(x) +- and len(x.descriptions) == 1 +- and x.descriptions[0].attribute == 'title' +- and x.descriptions[0].oldValue == "Old title" +- ) +- ) +- ) +- +- self.expect( +- notify_mock( +- mocker.MATCH( +- lambda x: IObjectModifiedEvent.providedBy(x) +- and len(x.descriptions) == 1 +- and x.descriptions[0].attribute == 'global_allow' +- and x.descriptions[0].oldValue is True +- ) +- ) +- ) +- self.replay() ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + fti.manage_changeProperties( + title="New title", +@@ -284,6 +244,8 @@ def test_fires_modified_event_on_change_props_per_changed_property(self): + global_allow=False + ) + ++ self.assertEqual(len(notify_mock.call_args_list), 2) + -+def addSortOnProperty(context): -+ """Add sort_on field to search controlpanel. -+ -+ The default value of this field is relevance. -+ """ -+ # get the old site properties -+ portal_properties = getToolByName(context, "portal_properties") -+ site_properties = portal_properties.site_properties -+ # get the new registry -+ registry = getUtility(IRegistry) -+ # XXX: Somehow this code is executed for old migration steps as well -+ # ( < Plone 4 ) and breaks because there is no registry. Looking up the -+ # registry interfaces with 'check=False' will not work, because it will -+ # return a settings object and then fail when we try to access the -+ # attributes. -+ try: -+ settings = registry.forInterface( -+ ISearchSchema, -+ prefix='plone', + def test_checks_permission_in_is_construction_allowed_true(self): + fti = DexterityFTI(u"testtype") + fti.add_permission = "demo.Permission" +@@ -299,21 +261,15 @@ def test_checks_permission_in_is_construction_allowed_true(self): + name=u"demo.Permission" + ) + +- security_manager_mock = self.mocker.mock() +- self.expect( +- security_manager_mock.checkPermission( +- "Some add permission", +- container_dummy) +- ).result(True) +- +- getSecurityManager_mock = self.mocker.replace( +- 'AccessControl.getSecurityManager' +- ) +- self.expect(getSecurityManager_mock()).result(security_manager_mock) +- +- self.replay() ++ security_manager_mock = Mock() ++ security_manager_mock.checkPermission = Mock(return_value=True) ++ from AccessControl import getSecurityManager ++ self.patch_global( ++ getSecurityManager, return_value=security_manager_mock) + + self.assertEqual(True, fti.isConstructionAllowed(container_dummy)) ++ security_manager_mock.checkPermission.assert_called_once_with( ++ 'Some add permission', container_dummy) + + def test_checks_permission_in_is_construction_allowed_false(self): + fti = DexterityFTI(u"testtype") +@@ -330,22 +286,15 @@ def test_checks_permission_in_is_construction_allowed_false(self): + name=u"demo.Permission" + ) + +- security_manager_mock = self.mocker.mock() +- self.expect( +- security_manager_mock.checkPermission( +- "Some add permission", +- container_dummy +- ) +- ).result(False) +- +- getSecurityManager_mock = self.mocker.replace( +- 'AccessControl.getSecurityManager' +- ) +- self.expect(getSecurityManager_mock()).result(security_manager_mock) +- +- self.replay() ++ security_manager_mock = Mock() ++ security_manager_mock.checkPermission = Mock(return_value=False) ++ from AccessControl import getSecurityManager ++ self.patch_global( ++ getSecurityManager, return_value=security_manager_mock) + + self.assertEqual(False, fti.isConstructionAllowed(container_dummy)) ++ security_manager_mock.checkPermission.assert_called_once_with( ++ 'Some add permission', container_dummy) + + def test_no_permission_utility_means_no_construction(self): + fti = DexterityFTI(u"testtype") +@@ -481,40 +430,22 @@ def test_components_registered_on_add(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + +- # We expect that no components are registered , so look for all +- # registrations +- self.expect( +- site_manager_mock.registerUtility( +- fti, +- IDexterityFTI, +- portal_type, +- info='plone.dexterity.dynamic') +- ).passthrough() +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- portal_type, +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() ++ ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId())) + +- self.replay() ++ args1, kwargs1 = site_manager_mock.registerUtility.call_args_list[0] ++ self.assertEqual(args1, (fti, IDexterityFTI, portal_type)) ++ self.assertEqual(kwargs1, {'info': 'plone.dexterity.dynamic'}) + +- ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId())) ++ args2, kwargs2 = site_manager_mock.registerUtility.call_args_list[1] ++ self.assertIsInstance(args2[0], DexterityFactory) ++ self.assertEqual(args2[0].portal_type, portal_type) ++ self.assertEqual(args2[1:], (IFactory, portal_type)) ++ self.assertEqual(kwargs2, {'info': 'plone.dexterity.dynamic'}) + + site_dummy = self.create_dummy( + getSiteManager=lambda: site_manager_mock +@@ -537,13 +468,10 @@ def test_components_not_registered_on_add_if_exist(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Register FTI utility and factory utility + +@@ -557,27 +485,10 @@ def test_components_not_registered_on_add_if_exist(self): + # We expect that all components are registered, so do not expect any + # registrations + +- self.expect( +- site_manager_mock.registerUtility( +- fti, +- IDexterityFTI, +- portal_type +- ) +- ).passthrough().count(0) +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, portal_type +- ) +- ).passthrough().count(0) +- +- self.replay() +- + ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId())) + ++ self.assertFalse(site_manager_mock.registerUtility.called) ++ + def test_components_unregistered_on_delete(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type) +@@ -587,33 +498,10 @@ def test_components_unregistered_on_delete(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) +- +- # We expect to always be able to unregister without error, even if the +- # components do not exists (as here) +- +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IDexterityFTI, +- name=portal_type +- ) +- ).passthrough() +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IFactory, +- name=portal_type +- ) +- ).passthrough() +- +- self.replay() ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # First add the components + ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId())) +@@ -639,26 +527,19 @@ def test_components_unregistered_on_delete_does_not_error_with_no_components(sel + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # We expect to always be able to unregister without error, even if the +- # components do not exists (as here) +- +- self.expect(site_manager_mock.unregisterUtility( +- provided=IDexterityFTI, +- name=portal_type) +- ).passthrough() +- +- self.replay() ++ # components do not exist (as here) + + ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId())) + ++ site_manager_mock.unregisterUtility.assert_called_once_with( ++ provided=IDexterityFTI, name=portal_type) ++ + def test_global_components_not_unregistered_on_delete(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type) +@@ -668,15 +549,10 @@ def test_global_components_not_unregistered_on_delete(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Register FTI utility and factory utility + +@@ -691,15 +567,6 @@ def test_global_components_not_unregistered_on_delete(self): + # component exists. The factory is only unregistered if it was + # registered with info='plone.dexterity.dynamic'. + +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IDexterityFTI, +- name=portal_type +- ) +- ).passthrough() +- +- self.replay() +- + ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId())) + + site_dummy = self.create_dummy( +@@ -723,52 +590,16 @@ def test_components_reregistered_on_rename(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) +- +- # First look for unregistration of all local components +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IDexterityFTI, +- name=portal_type +- ) +- ).passthrough() +- +- # Then look for re-registration of global components +- self.expect( +- site_manager_mock.registerUtility( +- fti, +- IDexterityFTI, +- portal_type, +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- portal_type, +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + self.assertEqual( + 'string:${folder_url}/++add++testtype', + fti.add_view_expr + ) + +- self.replay() +- + ftiRenamed( + fti, + ObjectMovedEvent( +@@ -780,6 +611,14 @@ def test_components_reregistered_on_rename(self): + ) + ) + ++ # First look for unregistration of all local components ++ site_manager_mock.unregisterUtility.assert_called_once_with( ++ provided=IDexterityFTI, name=portal_type + ) -+ except KeyError: -+ settings = False -+ if settings: -+ # migrate the old site properties to the new registry -+ if site_properties.hasProperty('sort_on'): -+ settings.sort_on = site_properties.sort_on -+ else: -+ settings.sort_on = 'relevance' -+ logger.log(logging.INFO, -+ "Added 'sort_on' property to site_properties.") -diff --git a/plone/app/upgrade/v51/configure.zcml b/plone/app/upgrade/v51/configure.zcml -index 4de223a..53b8399 100644 ---- a/plone/app/upgrade/v51/configure.zcml -+++ b/plone/app/upgrade/v51/configure.zcml -@@ -51,6 +51,12 @@ Add new Mockup 2.4.0 relateditems resource url. - handler=".betas.to51beta1" - /> - -+ -+ - - - -diff --git a/plone/app/upgrade/v51/profiles/to_beta1/registry.xml b/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -index fab9c06..9593804 100644 ---- a/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -+++ b/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -@@ -14,4 +14,7 @@ - ++resource++mockup/relateditems - - -+ -+ - - - -Repository: plone.app.upgrade - - -Branch: refs/heads/master -Date: 2016-10-07T15:35:51+02:00 -Author: agitator (agitator) -Commit: https://github.com/plone/plone.app.upgrade/commit/6bac29d2ee3e576528716d5e7ea67a181058bd87 - -Merge pull request #77 from plone/issue_1600 - -Issue 1600 - Add sort_on fields to search controlpanel - -Files changed: -M CHANGES.rst -M plone/app/upgrade/v43/configure.zcml -M plone/app/upgrade/v43/final.py -M plone/app/upgrade/v51/betas.py -M plone/app/upgrade/v51/configure.zcml -M plone/app/upgrade/v51/profiles/to_beta1/registry.xml - -diff --git a/CHANGES.rst b/CHANGES.rst -index 9dac3cb..760d838 100644 ---- a/CHANGES.rst -+++ b/CHANGES.rst -@@ -10,6 +10,9 @@ Breaking changes: ++ ++ # Then look for re-registration of global components ++ self.assertEquals(site_manager_mock.registerUtility.call_count, 2) ++ + site_dummy = self.create_dummy( + getSiteManager=lambda: site_manager_mock + ) +@@ -794,14 +633,14 @@ def test_components_reregistered_on_rename(self): - New features: + def test_dynamic_schema_refreshed_on_modify_model_file(self): + portal_type = u"testtype" +- fti = self.mocker.proxy(DexterityFTI(portal_type)) ++ fti = DexterityFTI(portal_type) -+- Add sort_on field to search controlpanel. -+ [rodfersou] -+ - - Support sites without ``portal_quickinstaller``. - We use ``get_installer`` in Plone 5.1 migrations. - In earlier version we will keep using the ``portal_quickinstaller``, -diff --git a/plone/app/upgrade/v43/configure.zcml b/plone/app/upgrade/v43/configure.zcml -index c0d34b9..23c4469 100644 ---- a/plone/app/upgrade/v43/configure.zcml -+++ b/plone/app/upgrade/v43/configure.zcml -@@ -241,6 +241,7 @@ - description="" - handler="..utils.null_upgrade_step" - /> -+ - - - -+ -+ -+ -+ -+ -+ -+ - - - -diff --git a/plone/app/upgrade/v43/final.py b/plone/app/upgrade/v43/final.py -index b3eb1b1..2cda0ba 100644 ---- a/plone/app/upgrade/v43/final.py -+++ b/plone/app/upgrade/v43/final.py -@@ -324,3 +324,18 @@ def removeFakeKupu(context): - if member_data.getProperty('wysiwyg_editor') == 'Kupu': - member_data._updateProperty('wysiwyg_editor', '') - logger.info('Changed new member wysiwyg_editor to site default.') -+ -+ -+def addSortOnProperty(context): -+ """Add sort_on field to search controlpanel. -+ -+ The default value of this field is relevance. -+ """ -+ site_properties = getToolByName(context, 'portal_properties').site_properties -+ if not site_properties.hasProperty('sort_on'): -+ if 'sort_on' in site_properties.__dict__: -+ # fix bug if 4.3.1 pending has been tested -+ del site_properties.sort_on -+ site_properties.manage_addProperty('sort_on', 'relevance', 'string') -+ logger.log(logging.INFO, -+ "Added 'sort_on' property to site_properties.") -diff --git a/plone/app/upgrade/v51/betas.py b/plone/app/upgrade/v51/betas.py -index f14fc64..8ba9cf5 100644 ---- a/plone/app/upgrade/v51/betas.py -+++ b/plone/app/upgrade/v51/betas.py -@@ -1,5 +1,9 @@ - # -*- coding: utf-8 -*- - from plone.app.upgrade.utils import loadMigrationProfile -+from plone.registry.interfaces import IRegistry -+from Products.CMFCore.utils import getToolByName -+from Products.CMFPlone.interfaces import ISearchSchema -+from zope.component import getUtility + class INew(Interface): + title = zope.schema.TextLine(title=u"title") + + model_dummy = Model({u"": INew}) + +- self.expect(fti.lookupModel()).result(model_dummy) ++ fti.lookupModel = Mock(return_value=model_dummy) + self.create_dummy() + + site_dummy = self.create_dummy( +@@ -812,8 +651,6 @@ class INew(Interface): + class IBlank(Interface): + pass + +- self.replay() +- + # Set source interface + schemaName = utils.portalTypeToSchemaName(fti.getId()) + setattr(plone.dexterity.schema.generated, schemaName, IBlank) +@@ -832,14 +669,14 @@ class IBlank(Interface): + + def test_dynamic_schema_refreshed_on_modify_model_source(self): + portal_type = u"testtype" +- fti = self.mocker.proxy(DexterityFTI(portal_type)) ++ fti = DexterityFTI(portal_type) + + class INew(Interface): + title = zope.schema.TextLine(title=u"title") + + model_dummy = Model({u"": INew}) + +- self.expect(fti.lookupModel()).result(model_dummy) ++ fti.lookupModel = Mock(return_value=model_dummy) + self.create_dummy() + + site_dummy = self.create_dummy( +@@ -850,8 +687,6 @@ class INew(Interface): + class IBlank(Interface): + pass + +- self.replay() +- + # Set source interface + schemaName = utils.portalTypeToSchemaName(fti.getId()) + setattr(plone.dexterity.schema.generated, schemaName, IBlank) +@@ -870,7 +705,7 @@ class IBlank(Interface): + + def test_dynamic_schema_refreshed_on_modify_schema_policy(self): + portal_type = u"testtype" +- fti = self.mocker.proxy(DexterityFTI(portal_type)) ++ fti = DexterityFTI(portal_type) + + class INew(Interface): + title = zope.schema.TextLine(title=u"title") +@@ -890,15 +725,11 @@ def bases(self, schemaName, tree): + name=u"test" + ) + +- self.expect(fti.schema_policy).passthrough().count(0, None) +- + site_dummy = self.create_dummy( + getPhysicalPath=lambda: ('', 'siteid') + ) + self.mock_utility(site_dummy, ISiteRoot) + +- self.replay() +- + # Set source interface + schemaName = utils.portalTypeToSchemaName(fti.getId()) + setattr(plone.dexterity.schema.generated, schemaName, IBlank) +@@ -923,7 +754,7 @@ def bases(self, schemaName, tree): + + def test_concrete_schema_not_refreshed_on_modify_schema(self): + portal_type = u"testtype" +- fti = self.mocker.proxy(DexterityFTI(portal_type)) ++ fti = DexterityFTI(portal_type) + + class IBlank(Interface): + pass +@@ -932,16 +763,13 @@ class INew(Interface): + title = zope.schema.TextLine(title=u"title") + + model_dummy = Model({u"": INew}) +- self.expect(fti.lookupModel()).result(model_dummy).count(0, None) +- self.create_dummy() ++ fti.lookupModel = Mock(return_value=model_dummy) + + site_dummy = self.create_dummy( + getPhysicalPath=lambda: ('', 'siteid') + ) + self.mock_utility(site_dummy, ISiteRoot) + +- self.replay() +- + # Set schema to something so that hasDynamicSchema is false + fti.schema = IBlank.__identifier__ + assert not fti.hasDynamicSchema +@@ -970,15 +798,10 @@ def test_old_factory_unregistered_after_name_changed_if_dynamic(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Pretend like we have a utility registered + +@@ -987,30 +810,8 @@ def test_old_factory_unregistered_after_name_changed_if_dynamic(self): + reg1.name = 'old-factory' + reg1.info = 'plone.dexterity.dynamic' - import logging +- self.expect(site_manager_mock.registeredUtilities()).result([reg1]) +- +- # Expect this to get removed +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IFactory, +- name='old-factory' +- ) +- ) +- +- # And a new one to be created with the new factory name +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- 'new-factory', +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() ++ site_manager_mock.registeredUtilities = Mock(return_value=[reg1]) -@@ -9,3 +13,35 @@ +- self.replay() + fti.factory = 'new-factory' + ftiModified( + fti, +@@ -1020,6 +821,13 @@ def test_old_factory_unregistered_after_name_changed_if_dynamic(self): + ) + ) - def to51beta1(context): - loadMigrationProfile(context, 'profile-plone.app.upgrade.v51:to51beta1') ++ # Expect this to get removed ++ site_manager_mock.unregisterUtility.assert_called_once_with( ++ provided=IFactory, name='old-factory') ++ # And a new one to be created with the new factory name ++ self.assertEqual( ++ site_manager_mock.registerUtility.call_args[0][2], 'new-factory') + + def test_new_factory_not_registered_after_name_changed_if_exists(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type) +@@ -1028,15 +836,10 @@ def test_new_factory_not_registered_after_name_changed_if_exists(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Create a global default for the new name + self.mock_utility( +@@ -1045,20 +848,6 @@ def test_new_factory_not_registered_after_name_changed_if_exists(self): + name='new-factory' + ) + +- # Factory should not be registered again +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- 'new-factory', +- info='plone.dexterity.dynamic' +- ) +- ).passthrough().count(0) +- +- self.replay() + fti.factory = 'new-factory' + ftiModified( + fti, +@@ -1068,6 +857,9 @@ def test_new_factory_not_registered_after_name_changed_if_exists(self): + ) + ) + ++ # Factory should not be registered again ++ self.assertFalse(site_manager_mock.registerUtility.called) + -+def addSortOnProperty(context): -+ """Add sort_on field to search controlpanel. -+ -+ The default value of this field is relevance. -+ """ -+ # get the old site properties -+ portal_properties = getToolByName(context, "portal_properties") -+ site_properties = portal_properties.site_properties -+ # get the new registry -+ registry = getUtility(IRegistry) -+ # XXX: Somehow this code is executed for old migration steps as well -+ # ( < Plone 4 ) and breaks because there is no registry. Looking up the -+ # registry interfaces with 'check=False' will not work, because it will -+ # return a settings object and then fail when we try to access the -+ # attributes. -+ try: -+ settings = registry.forInterface( -+ ISearchSchema, -+ prefix='plone', + def test_old_factory_not_unregistered_if_not_created_by_dexterity(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type) +@@ -1076,15 +868,10 @@ def test_old_factory_not_unregistered_if_not_created_by_dexterity(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Pretend like we have a utility registered + +@@ -1093,30 +880,8 @@ def test_old_factory_not_unregistered_if_not_created_by_dexterity(self): + reg1.name = 'old-factory' + reg1.info = None + +- self.expect(site_manager_mock.registeredUtilities()).result([reg1]) ++ site_manager_mock.registeredUtilities = Mock(return_value=[reg1]) + +- # This should not be removed, since we didn't create it +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IFactory, +- name='old-factory' +- ) +- ).count(0) +- +- # A new one may still be created, however +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- 'new-factory', +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() +- +- self.replay() + fti.factory = 'new-factory' + ftiModified( + fti, +@@ -1126,6 +891,12 @@ def test_old_factory_not_unregistered_if_not_created_by_dexterity(self): + ) + ) + ++ # This should not be removed, since we didn't create it ++ self.assertFalse(site_manager_mock.unregisterUtility.called) ++ # A new one may still be created, however ++ self.assertEqual( ++ site_manager_mock.registerUtility.call_args[0][2], 'new-factory') ++ + def test_renamed_factory_not_unregistered_if_not_unique(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type, factory='common-factory') +@@ -1136,20 +907,13 @@ def test_renamed_factory_not_unregistered_if_not_unique(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Pretend two FTIs are registered, both using common-factory +- self.expect( +- site_manager_mock.registeredUtilities() +- ).result([ ++ site_manager_mock.registeredUtilities = Mock(return_value=[ + self.create_dummy( + provided=IFactory, + name='common-factory', +@@ -1169,28 +933,6 @@ def test_renamed_factory_not_unregistered_if_not_unique(self): + ), + ]) + +- # We shouldn't remove this since fti2 still uses it +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IFactory, +- name='common-factory' +- ) +- ).count(0) +- +- # And a new one to be created with the new factory name +- self.expect( +- site_manager_mock.registerUtility( +- mocker.MATCH( +- lambda x: isinstance(x, DexterityFactory) +- and x.portal_type == portal_type +- ), +- IFactory, +- 'new-factory', +- info='plone.dexterity.dynamic' +- ) +- ).passthrough() +- +- self.replay() + fti.factory = 'new-factory' + ftiModified( + fti, +@@ -1203,6 +945,13 @@ def test_renamed_factory_not_unregistered_if_not_unique(self): + ) + ) + ++ # We shouldn't remove this since fti2 still uses it ++ self.assertFalse(site_manager_mock.unregisterUtility.called) ++ ++ # A new one may still be created, however ++ self.assertEqual( ++ site_manager_mock.registerUtility.call_args[0][2], 'new-factory') ++ + def test_deleted_factory_not_unregistered_if_not_unique(self): + portal_type = u"testtype" + fti = DexterityFTI(portal_type, factory='common-factory') +@@ -1214,22 +963,15 @@ def test_deleted_factory_not_unregistered_if_not_unique(self): + dummy_site = self.create_dummy() + self.mock_utility(dummy_site, ISiteRoot) + +- site_manager_mock = self.mocker.proxy( +- PersistentComponents(bases=(getGlobalSiteManager(),)) +- ) +- getSiteManager_mock = self.mocker.replace( +- 'zope.component.hooks.getSiteManager' +- ) +- self.expect( +- getSiteManager_mock(dummy_site) +- ).result(site_manager_mock).count(1, None) ++ site_manager_mock = Mock( ++ wraps=PersistentComponents(bases=(getGlobalSiteManager(),))) ++ from zope.component.hooks import getSiteManager ++ self.patch_global(getSiteManager, return_value=site_manager_mock) + + # Pretend two FTIs are registered, both using common-factory + # NB: Assuming that "testtype" was already removed when this gets + # called +- self.expect( +- site_manager_mock.registeredUtilities() +- ).result([ ++ site_manager_mock.registeredUtilities = Mock(return_value=[ + self.create_dummy( + provided=IFactory, + name='common-factory', +@@ -1243,25 +985,10 @@ def test_deleted_factory_not_unregistered_if_not_unique(self): + ), + ]) + +- # We shouldn't remove this since fti2 still uses it +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IFactory, +- name='common-factory' +- ) +- ).count(0) +- +- # The type itself should be removed though +- self.expect( +- site_manager_mock.unregisterUtility( +- provided=IDexterityFTI, +- name=u"testtype" +- ) +- ).count(1) +- +- self.replay() + ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId())) + +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) ++ # We shouldn't remove this since fti2 still uses it ++ # The type itself should be removed though ++ site_manager_mock.unregisterUtility.assert_called_once_with( ++ provided=IDexterityFTI, name=u'testtype' + ) -+ except KeyError: -+ settings = False -+ if settings: -+ # migrate the old site properties to the new registry -+ if site_properties.hasProperty('sort_on'): -+ settings.sort_on = site_properties.sort_on -+ else: -+ settings.sort_on = 'relevance' -+ logger.log(logging.INFO, -+ "Added 'sort_on' property to site_properties.") -diff --git a/plone/app/upgrade/v51/configure.zcml b/plone/app/upgrade/v51/configure.zcml -index 4de223a..53b8399 100644 ---- a/plone/app/upgrade/v51/configure.zcml -+++ b/plone/app/upgrade/v51/configure.zcml -@@ -51,6 +51,12 @@ Add new Mockup 2.4.0 relateditems resource url. - handler=".betas.to51beta1" - /> - -+ -+ - - - -diff --git a/plone/app/upgrade/v51/profiles/to_beta1/registry.xml b/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -index fab9c06..9593804 100644 ---- a/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -+++ b/plone/app/upgrade/v51/profiles/to_beta1/registry.xml -@@ -14,4 +14,7 @@ - ++resource++mockup/relateditems - - -+ -+ - +diff --git a/plone/dexterity/tests/test_primary.py b/plone/dexterity/tests/test_primary.py +index 930c7be..a9d6831 100644 +--- a/plone/dexterity/tests/test_primary.py ++++ b/plone/dexterity/tests/test_primary.py +@@ -1,15 +1,14 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from plone.dexterity.content import Item + from plone.dexterity.fti import DexterityFTI + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.primary import PrimaryFieldInfo +-from plone.mocktestcase import MockTestCase + from plone.rfc822.interfaces import IPrimaryField + from zope import schema + from zope.interface import Interface + from zope.interface import alsoProvides +- +-import unittest ++from .case import MockTestCase + + + class PrimaryFieldInfoTestCase(MockTestCase): +@@ -20,11 +19,10 @@ class ITest(Interface): + body = schema.Text() + alsoProvides(ITest['body'], IPrimaryField) + +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ITest).count(0, None) +- self.expect(fti_mock.behaviors).result([]).count(0, None) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock(return_value=ITest) ++ fti.behaviors = [] ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + item = Item('item') + item.portal_type = 'testtype' +@@ -34,7 +32,3 @@ class ITest(Interface): + assert info.fieldname == 'body' + assert info.field == ITest['body'] + assert info.value == 'body text' +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_schema.py b/plone/dexterity/tests/test_schema.py +index 4c34c1e..20715ae 100644 +--- a/plone/dexterity/tests/test_schema.py ++++ b/plone/dexterity/tests/test_schema.py +@@ -1,4 +1,5 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from pkg_resources import get_distribution + from plone.dexterity import schema + from plone.dexterity.fti import DexterityFTI +@@ -7,11 +8,11 @@ + from plone.dexterity.interfaces import IDexteritySchema + from plone.dexterity.schema import invalidate_cache + from plone.dexterity.schema import SCHEMA_CACHE +-from plone.mocktestcase import MockTestCase + from plone.supermodel.model import Model + from Products.CMFCore.interfaces import ISiteRoot + from zope.interface import Interface + from zope.interface.interface import InterfaceClass ++from .case import MockTestCase + + import unittest + import zope.schema +@@ -44,13 +45,10 @@ class IDummy(Interface): + mock_model = Model({u"": IDummy}) + + # Mock FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- fti_mock.lookupModel() +- self.mocker.result(mock_model) ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.lookupModel = Mock(return_value=mock_model) + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + +- self.mocker.replay() +- + factory = schema.SchemaModuleFactory() + + schemaName = schema.portalTypeToSchemaName('testtype', prefix='site') +@@ -75,13 +73,10 @@ class INamedDummy(Interface): + u"named": INamedDummy}) + + # Mock FTI +- fti_mock = self.mocker.mock(DexterityFTI) +- fti_mock.lookupModel() +- self.mocker.result(mock_model) ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.lookupModel = Mock(return_value=mock_model) + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + +- self.mocker.replay() +- + factory = schema.SchemaModuleFactory() + + schemaName = schema.portalTypeToSchemaName( +@@ -132,13 +127,10 @@ class IDummy(Interface): + dummy = zope.schema.TextLine(title=u"Dummy") + mock_model = Model({u"": IDummy}) + +- fti_mock = self.mocker.mock(DexterityFTI) +- fti_mock.lookupModel() +- self.mocker.result(mock_model) ++ fti_mock = Mock(spec=DexterityFTI) ++ fti_mock.lookupModel = Mock(return_value=mock_model) + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + +- self.mocker.replay() +- + klass = factory(schemaName, schema.generated) + + self.assertTrue(isinstance(klass, InterfaceClass)) +@@ -166,14 +158,10 @@ def test_portalTypeToSchemaName_with_schema_and_prefix(self): + + @unittest.skipIf(has_zope4, 'Broken with zope4, see https://community.plone.org/t/problems-with-mocktestcase-in-plone-dexterity/1484') # noqa + def test_portalTypeToSchemaName_looks_up_portal_for_prefix(self): +- portal_mock = self.mocker.mock() +- self.expect( +- portal_mock.getPhysicalPath() +- ).result(('', 'foo', 'portalid')) ++ portal_mock = Mock() ++ portal_mock.getPhysicalPath = Mock(return_value=['', 'foo', 'portalid']) + self.mock_utility(portal_mock, ISiteRoot) + +- self.replay() +- + self.assertEqual( + 'foo_4_portalid_0_type', + schema.portalTypeToSchemaName('type') +@@ -218,7 +206,3 @@ def test_invalidate_cache(self): + invalidate_cache(fti) + self.assertNotIn('_v_schema_behavior_schema_interfaces', + fti.__dict__.keys()) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_schema_cache.py b/plone/dexterity/tests/test_schema_cache.py +index e477ae3..d326781 100644 +--- a/plone/dexterity/tests/test_schema_cache.py ++++ b/plone/dexterity/tests/test_schema_cache.py +@@ -1,9 +1,10 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from plone.dexterity.fti import DexterityFTI + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.schema import SCHEMA_CACHE +-from plone.mocktestcase import MockTestCase + from zope.interface import Interface ++from .case import MockTestCase + + import unittest + +@@ -18,13 +19,10 @@ def test_repeated_get_lookup(self): + class ISchema(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +- self.replay() +- + schema1 = SCHEMA_CACHE.get(u"testtype") + schema2 = SCHEMA_CACHE.get(u"testtype") + +@@ -32,14 +30,13 @@ class ISchema(Interface): + + def test_repeated_behavior_registration_lookup(self): + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") ++ fti = DexterityFTI(u"testtype") ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + # Mock a test behavior + class ITestBehavior(Interface): + pass +- self.expect(fti_mock.behaviors).result([ITestBehavior.__identifier__]) ++ fti.behaviors = [ITestBehavior.__identifier__] + from plone.behavior.registration import BehaviorRegistration + registration = BehaviorRegistration( + title=u"Test Behavior", +@@ -55,8 +52,6 @@ class ITestBehavior(Interface): + ITestBehavior.__identifier__ + ) + +- self.replay() +- + r1 = SCHEMA_CACHE.behavior_registrations(u'testtype') + r2 = SCHEMA_CACHE.behavior_registrations(u'testtype') + +@@ -64,9 +59,8 @@ class ITestBehavior(Interface): + + def test_repeated_subtypes_lookup(self): + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") ++ fti = DexterityFTI(u"testtype") ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + # Mock a test behavior + class ITestSchema(Interface): +@@ -74,7 +68,7 @@ class ITestSchema(Interface): + + class ITestMarker(Interface): + pass +- self.expect(fti_mock.behaviors).result([ITestSchema.__identifier__]) ++ fti.behaviors = [ITestSchema.__identifier__] + from plone.behavior.registration import BehaviorRegistration + registration = BehaviorRegistration( + title=u"Test Behavior", +@@ -90,8 +84,6 @@ class ITestMarker(Interface): + ITestSchema.__identifier__ + ) + +- self.replay() +- + s1 = SCHEMA_CACHE.subtypes(u"testtype") + s2 = SCHEMA_CACHE.subtypes(u"testtype") + +@@ -105,13 +97,9 @@ class ISchema1(Interface): + class ISchema2(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema1) +- self.expect(fti_mock.lookupSchema()).result(ISchema2).count(0, None) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock(side_effect=[ISchema1, ISchema2]) ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + schema1 = SCHEMA_CACHE.get(u"testtype") + schema2 = SCHEMA_CACHE.get(u"testtype") +@@ -126,13 +114,9 @@ class ISchema1(Interface): + class ISchema2(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema1) +- self.expect(fti_mock.lookupSchema()).result(ISchema2).count(0, None) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock(side_effect=[ISchema1, ISchema2]) ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + schema1 = SCHEMA_CACHE.get(u"testtype") + SCHEMA_CACHE.invalidate(u"testtype") +@@ -146,13 +130,9 @@ def test_none_not_cached(self): + class ISchema1(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(None) +- self.expect(fti_mock.lookupSchema()).result(ISchema1).count(2) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock(side_effect=[None, ISchema1, ISchema1]) ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + SCHEMA_CACHE.invalidate('testtype') + schema1 = SCHEMA_CACHE.get(u"testtype") +@@ -171,14 +151,10 @@ def test_attribute_and_value_error_not_cached(self): + class ISchema1(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).throw(AttributeError) +- self.expect(fti_mock.lookupSchema()).throw(ValueError) +- self.expect(fti_mock.lookupSchema()).result(ISchema1) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock( ++ side_effect=[AttributeError, ValueError, ISchema1]) ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + schema1 = SCHEMA_CACHE.get(u"testtype") + +@@ -197,12 +173,9 @@ def test_unknown_type_not_cached(self): + class ISchema1(Interface): + pass + +- # FTI mock +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema1) +- self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") +- +- self.replay() ++ fti = DexterityFTI(u"testtype") ++ fti.lookupSchema = Mock(return_value=ISchema1) ++ self.mock_utility(fti, IDexterityFTI, name=u"testtype") + + schema1 = SCHEMA_CACHE.get(u"othertype") + schema2 = SCHEMA_CACHE.get(u"testtype") +@@ -215,16 +188,14 @@ def test_clear_all_caches(self): + + class ISchema1(Interface): + pass +- # FTI mock +- fti_mock1 = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock1.lookupSchema()).result(ISchema1).count(2) +- self.mock_utility(fti_mock1, IDexterityFTI, name=u"testtype1") + +- fti_mock2 = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock2.lookupSchema()).result(ISchema1).count(2) +- self.mock_utility(fti_mock2, IDexterityFTI, name=u"testtype2") ++ fti1 = DexterityFTI(u"testtype") ++ fti1.lookupSchema = Mock(return_value=ISchema1) ++ self.mock_utility(fti1, IDexterityFTI, name=u"testtype1") + +- self.replay() ++ fti2 = DexterityFTI(u"testtype") ++ fti2.lookupSchema = Mock(return_value=ISchema1) ++ self.mock_utility(fti2, IDexterityFTI, name=u"testtype2") + + # reset schemacache counter + SCHEMA_CACHE.invalidations = 0 +@@ -245,7 +216,3 @@ class ISchema1(Interface): + schema1 = SCHEMA_CACHE.get(u"testtype1") + schema2 = SCHEMA_CACHE.get(u"testtype2") + self.assertTrue(schema1 is schema2 is ISchema1) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_security.py b/plone/dexterity/tests/test_security.py +index 2fe5312..852bfb8 100644 +--- a/plone/dexterity/tests/test_security.py ++++ b/plone/dexterity/tests/test_security.py +@@ -1,17 +1,17 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from plone.autoform.interfaces import READ_PERMISSIONS_KEY + from plone.dexterity.content import Item + from plone.dexterity.content import Container + from plone.dexterity.fti import DexterityFTI + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.schema import SCHEMA_CACHE +-from plone.mocktestcase import MockTestCase + from zope.interface import Interface + from zope.interface import provider + from zope.security.interfaces import IPermission + from zope.security.permission import Permission ++from .case import MockTestCase + +-import unittest + import zope.schema + + +@@ -67,7 +67,9 @@ class ITestBehavior(Interface): + ) + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.behaviors = () ++ fti_mock.lookupSchema = Mock(return_value=ITestSchema) + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + + # Mock permissions +@@ -89,83 +91,51 @@ class ITestBehavior(Interface): + item.foo = u"bar" + + # mock security manager +- securityManager_mock = self.mocker.mock() +- getSecurityManager_mock = self.mocker.replace( +- 'AccessControl.getSecurityManager' +- ) +- +- # expectations +- # run 1 +- # lookupSchema is always called twice: cache and __providedBy__ +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- self.expect( +- securityManager_mock.checkPermission("View", item) +- ).result(False) +- +- # run 2 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- self.expect( +- securityManager_mock.checkPermission("View foo", item) +- ).result(True) +- +- # run 3 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- +- # # run 4 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result([ITestBehavior.__identifier__]) +- self.expect( +- securityManager_mock.checkPermission("View", item) +- ).result(True) +- +- # # run 5 +- self.expect(fti_mock.lookupSchema()).result(None) +- self.expect(fti_mock.behaviors).result([ITestBehavior.__identifier__]) +- self.expect( +- securityManager_mock.checkPermission("View", item) +- ).result(True) +- +- # for all 5 runs +- self.expect( +- getSecurityManager_mock() +- ).result( +- securityManager_mock +- ).count(4) +- +- self.mocker.replay() ++ security_manager_mock = Mock() ++ from AccessControl import getSecurityManager ++ self.patch_global( ++ getSecurityManager, return_value=security_manager_mock) + + # run 1: schema and no behavior access to schema protected attribute ++ security_manager_mock.checkPermission = Mock(return_value=False) + SCHEMA_CACHE.clear() + self.assertFalse( + item.__allow_access_to_unprotected_subobjects__('test', u"foo") + ) ++ security_manager_mock.checkPermission.assert_called_with('View', item) + +- # # run 2: schema and no behavior access to known non schema attribute ++ # run 2: schema and no behavior access to known non schema attribute ++ security_manager_mock.checkPermission = Mock(return_value=True) + SCHEMA_CACHE.clear() + self.assertTrue( + item.__allow_access_to_unprotected_subobjects__('foo', u"bar") + ) ++ security_manager_mock.checkPermission.assert_called_with( ++ 'View foo', item) + +- # # run 3: schema and no behavior, unknown attributes are allowed ++ # run 3: schema and no behavior, unknown attributes are allowed + SCHEMA_CACHE.clear() + self.assertTrue( + item.__allow_access_to_unprotected_subobjects__('random', u"stuff") + ) + +- # # run 4: schema and behavior ++ # run 4: schema and behavior ++ security_manager_mock.checkPermission = Mock(return_value=True) ++ fti_mock.behaviors = [ITestBehavior.__identifier__] + SCHEMA_CACHE.clear() + self.assertTrue( + item.__allow_access_to_unprotected_subobjects__('test2', u"foo2") + ) ++ security_manager_mock.checkPermission.assert_called_with('View', item) + + # run 5: no schema but behavior ++ security_manager_mock.checkPermission = Mock(return_value=True) ++ fti_mock.lookupSchema = Mock(return_value=None) + SCHEMA_CACHE.clear() + self.assertTrue( + item.__allow_access_to_unprotected_subobjects__('test2', u"foo2") + ) ++ security_manager_mock.checkPermission.assert_called_with('View', item) + + def test_container(self): + +@@ -214,7 +184,9 @@ class ITestBehavior(Interface): + ) + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ITestSchema) ++ fti_mock.behaviors = () + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + + # Mock permissions +@@ -236,55 +208,13 @@ class ITestBehavior(Interface): + container.foo = u"bar" + + # mock security manager +- securityManager_mock = self.mocker.mock() +- getSecurityManager_mock = self.mocker.replace( +- 'AccessControl.getSecurityManager' +- ) +- +- # expectations +- # run 1 +- # lookupSchema is always called twice: cache and __providedBy__ +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- self.expect( +- securityManager_mock.checkPermission("View", container) +- ).result(False) +- +- # run 2 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- self.expect( +- securityManager_mock.checkPermission("View foo", container) +- ).result(True) +- +- # run 3 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) +- +- # # run 4 +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result([ITestBehavior.__identifier__]) +- self.expect( +- securityManager_mock.checkPermission("View", container) +- ).result(True) +- +- # # run 5 +- self.expect(fti_mock.lookupSchema()).result(None) +- self.expect(fti_mock.behaviors).result([ITestBehavior.__identifier__]) +- self.expect( +- securityManager_mock.checkPermission("View", container) +- ).result(True) +- +- # for all 5 runs +- self.expect( +- getSecurityManager_mock() +- ).result( +- securityManager_mock +- ).count(4) +- +- self.mocker.replay() ++ security_manager_mock = Mock() ++ from AccessControl import getSecurityManager ++ self.patch_global( ++ getSecurityManager, return_value=security_manager_mock) + + # run 1: schema and no behavior access to schema protected attribute ++ security_manager_mock.checkPermission = Mock(return_value=False) + SCHEMA_CACHE.clear() + self.assertFalse( + container.__allow_access_to_unprotected_subobjects__( +@@ -292,8 +222,11 @@ class ITestBehavior(Interface): + u"foo" + ) + ) ++ security_manager_mock.checkPermission.assert_called_with( ++ 'View', container) + +- # # run 2: schema and no behavior access to known non schema attribute ++ # run 2: schema and no behavior access to known non schema attribute ++ security_manager_mock.checkPermission = Mock(return_value=True) + SCHEMA_CACHE.clear() + self.assertTrue( + container.__allow_access_to_unprotected_subobjects__( +@@ -301,8 +234,10 @@ class ITestBehavior(Interface): + u"bar" + ) + ) ++ security_manager_mock.checkPermission.assert_called_with( ++ 'View foo', container) + +- # # run 3: schema and no behavior, unknown attributes are allowed ++ # run 3: schema and no behavior, unknown attributes are allowed + SCHEMA_CACHE.clear() + self.assertTrue( + container.__allow_access_to_unprotected_subobjects__( +@@ -311,7 +246,9 @@ class ITestBehavior(Interface): + ) + ) + +- # # run 4: schema and behavior ++ # run 4: schema and behavior ++ security_manager_mock.checkPermission = Mock(return_value=True) ++ fti_mock.behaviors = [ITestBehavior.__identifier__] + SCHEMA_CACHE.clear() + self.assertTrue( + container.__allow_access_to_unprotected_subobjects__( +@@ -319,8 +256,12 @@ class ITestBehavior(Interface): + u"foo2" + ) + ) ++ security_manager_mock.checkPermission.assert_called_with( ++ 'View', container) + + # run 5: no schema but behavior ++ fti_mock.lookupSchema = Mock(return_value=None) ++ security_manager_mock.checkPermission = Mock(return_value=True) + SCHEMA_CACHE.clear() + self.assertTrue( + container.__allow_access_to_unprotected_subobjects__( +@@ -328,6 +269,8 @@ class ITestBehavior(Interface): + u"foo2" + ) + ) ++ security_manager_mock.checkPermission.assert_called_with( ++ 'View', container) + + def test_no_tagged_value(self): + +@@ -336,9 +279,9 @@ class ITestSchema(Interface): + test = zope.schema.TextLine(title=u"Test") + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ITestSchema) ++ fti_mock.behaviors = () + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + + # Content item +@@ -347,8 +290,6 @@ class ITestSchema(Interface): + item.test = u"foo" + item.foo = u"bar" + +- self.mocker.replay() +- + SCHEMA_CACHE.clear() + + # Everything allowed +@@ -372,9 +313,9 @@ class ITestSchema(Interface): + ITestSchema.setTaggedValue(READ_PERMISSIONS_KEY, dict(foo='foo.View')) + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ITestSchema) +- self.expect(fti_mock.behaviors).result(tuple()) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ITestSchema) ++ fti_mock.behaviors = () + + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + +@@ -390,18 +331,11 @@ class ITestSchema(Interface): + item.foo = u"bar" + + # Check permission +- securityManager_mock = self.mocker.mock() +- self.expect( +- securityManager_mock.checkPermission("View foo", item) +- ).result(True) +- getSecurityManager_mock = self.mocker.replace( +- 'AccessControl.getSecurityManager' +- ) +- self.expect( +- getSecurityManager_mock() +- ).result(securityManager_mock).count(1) +- +- self.mocker.replay() ++ security_manager_mock = Mock() ++ security_manager_mock.checkPermission = Mock(return_value=True) ++ from AccessControl import getSecurityManager ++ self.patch_global( ++ getSecurityManager, return_value=security_manager_mock) + + SCHEMA_CACHE.clear() + +@@ -420,9 +354,9 @@ class ITestSchema(Interface): + def test_no_schema(self): + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(None) +- self.expect(fti_mock.behaviors).result(tuple()) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=None) ++ fti_mock.behaviors = () + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + + # Content item +@@ -431,8 +365,6 @@ def test_no_schema(self): + item.test = u"foo" + item.foo = u"bar" + +- self.mocker.replay() +- + SCHEMA_CACHE.clear() + + self.assertTrue( +@@ -448,10 +380,9 @@ def test_no_schema(self): + def test_schema_exception(self): + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- +- self.expect(fti_mock.lookupSchema()).throw(AttributeError) +- self.expect(fti_mock.behaviors).result(tuple()) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(side_effect=AttributeError) ++ fti_mock.behaviors = () + + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + +@@ -461,8 +392,6 @@ def test_schema_exception(self): + item.test = u"foo" + item.foo = u"bar" + +- self.mocker.replay() +- + SCHEMA_CACHE.clear() + + self.assertTrue( +@@ -478,23 +407,15 @@ def test_schema_exception(self): + def test_empty_name(self): + + # Mock FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).count(0) +- self.expect(fti_mock.behaviors).count(0) ++ fti_mock = DexterityFTI(u"testtype") + self.mock_utility(fti_mock, IDexterityFTI, u'testtype') + + # Content item + item = Item('test') + item.portal_type = u"testtype" + +- self.mocker.replay() +- + SCHEMA_CACHE.clear() + + self.assertTrue( + item.__allow_access_to_unprotected_subobjects__('', u"foo") + ) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_utils.py b/plone/dexterity/tests/test_utils.py +index 9213fbb..9ca7664 100644 +--- a/plone/dexterity/tests/test_utils.py ++++ b/plone/dexterity/tests/test_utils.py +@@ -1,8 +1,9 @@ + # -*- coding: utf-8 -*- ++from mock import Mock + from pkg_resources import get_distribution + from plone.dexterity import utils + from plone.dexterity.fti import DexterityFTI +-from plone.mocktestcase import MockTestCase ++from .case import MockTestCase + + import unittest + +@@ -26,27 +27,16 @@ class IBehaviorInterface(Interface): + class IBehaviorSchema(Interface): + pass + +- behavior_mock = self.mocker.mock() +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- provider_mock = self.mocker.mock() ++ behavior_mock = Mock() ++ fti_mock = DexterityFTI(u'testtype') + + portal_type = 'prefix_0_type_0_schema' + behavior_name = 'behavior_0' + +- self.expect( +- fti_mock.behaviors +- ).result( +- (behavior_name, ) +- ) +- +- self.expect( +- behavior_mock.interface +- ).result( +- IBehaviorInterface +- ).count(2) ++ fti_mock.behaviors = (behavior_name,) ++ behavior_mock.interface = IBehaviorInterface + +- provider_mock(IBehaviorInterface) +- self.mocker.result(IBehaviorSchema) ++ provider_mock = Mock(return_value=IBehaviorSchema) + + self.mock_utility(behavior_mock, IBehavior, behavior_name) + self.mock_utility(fti_mock, IDexterityFTI, portal_type) +@@ -57,8 +47,6 @@ class IBehaviorSchema(Interface): + (providedBy(IBehaviorInterface), ) + ) + +- self.replay() +- + generator = utils.getAdditionalSchemata(None, portal_type) + schematas = tuple(generator) + +@@ -127,7 +115,3 @@ class IIFace2(Interface): + utils.all_merged_tagged_values_dict((IIFace1, IIFace2), 'foo'), + {'a': 13, 'b': 14} + ) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_views.py b/plone/dexterity/tests/test_views.py +index 0ea4b56..2f1984e 100644 +--- a/plone/dexterity/tests/test_views.py ++++ b/plone/dexterity/tests/test_views.py +@@ -1,5 +1,6 @@ + # -*- coding: utf-8 -*- + from AccessControl import Unauthorized ++from mock import Mock + from Products.statusmessages.interfaces import IStatusMessage + from plone.autoform.interfaces import IFormFieldProvider + from plone.behavior.interfaces import IBehaviorAssignable +@@ -18,7 +19,6 @@ + from plone.dexterity.interfaces import IEditCancelledEvent + from plone.dexterity.interfaces import IEditFinishedEvent + from plone.dexterity.schema import SCHEMA_CACHE +-from plone.mocktestcase import MockTestCase + from plone.z3cform.interfaces import IDeferSecurityCheck + from z3c.form.action import Actions + from z3c.form.field import FieldWidgets +@@ -31,9 +31,7 @@ + from zope.interface import implementer + from zope.interface import provider + from zope.publisher.browser import TestRequest as TestRequestBase +- +-import mocker +-import unittest ++from .case import MockTestCase + + + class TestRequest(TestRequestBase): +@@ -99,8 +97,8 @@ def test_form_create(self): + + # FTI - returns dummy factory name + +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.factory).result(u"testfactory") ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.factory = u'testfactory' + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # The form we're testing +@@ -112,13 +110,11 @@ def test_form_create(self): + obj_dummy = Item(id="dummy") + data_dummy = {u"foo": u"bar"} + +- createObject_mock = self.mocker.replace('zope.component.createObject') +- self.expect(createObject_mock(u"testfactory")).result(obj_dummy) +- +- applyChanges_mock = self.mocker.replace('z3c.form.form.applyChanges') +- self.expect(applyChanges_mock(form, obj_dummy, data_dummy)) ++ from zope.component import createObject ++ self.patch_global(createObject, return_value=obj_dummy) + +- self.replay() ++ from z3c.form.form import applyChanges ++ self.patch_global(applyChanges) + + self.assertEqual(obj_dummy, form.create(data_dummy)) + self.assertEqual("testtype", obj_dummy.portal_type) +@@ -126,37 +122,33 @@ def test_form_create(self): + def test_add(self): + + # Container, new object, and request +- container = self.mocker.mock() +- obj = self.mocker.mock() ++ container = Mock() ++ obj = Mock() + request = TestRequest() + +- self.expect(container._setObject(u"newid", obj)).result(u"newid") +- self.expect(container._getOb(u"newid")).result(obj) +- self.expect( +- container.absolute_url() +- ).result("http://nohost/plone/container") ++ container._setObject = Mock(return_value=u'newid') ++ container._getOb = Mock(return_value=obj) ++ container.absolute_url = Mock( ++ return_value="http://nohost/plone/container") + + obj.id = u"newid" +- +- self.expect(obj.id).result(u"newid") +- self.expect(obj.id).result(u"newid") +- self.expect(obj.portal_type).result("testtype").count(0, None) ++ obj.portal_type = 'testtype' + + # New object's FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.isConstructionAllowed(container)).result(True) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.isConstructionAllowed = Mock(return_value=True) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # Container FTI +- container_fti_mock = self.mocker.proxy(DexterityFTI(u"containertype")) +- self.expect(container_fti_mock.allowType(u"testtype")).result(True) ++ container_fti_mock = DexterityFTI(u"containertype") ++ container_fti_mock.allowType = Mock(return_value=True) + self.mock_utility( + container_fti_mock, + IDexterityFTI, + name=u"containertype" + ) + +- self.expect(container.getTypeInfo()).result(container_fti_mock) ++ container.getTypeInfo = Mock(return_value=container_fti_mock) + + # Name chooser + @implementer(INameChooser) +@@ -170,34 +162,29 @@ def chooseName(self, name, object): + + self.mock_adapter(NameChooser, INameChooser, (Interface,)) + +- self.replay() +- + form = DefaultAddForm(container, request) + form.portal_type = u"testtype" + form.add(obj) + + def test_add_raises_unauthorized_if_construction_not_allowed(self): + # Container, new object, and request +- container = self.mocker.mock() +- obj = self.mocker.mock() ++ container = Mock() ++ obj = Mock() + request = TestRequest() + + # New object's FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.isConstructionAllowed(container)).result(False) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.isConstructionAllowed = Mock(return_value=False) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # Container FTI +- container_fti_mock = self.mocker.proxy(DexterityFTI(u"containertype")) ++ container_fti_mock = DexterityFTI(u"containertype") + self.mock_utility( + container_fti_mock, IDexterityFTI, name=u"containertype" + ) + +- self.expect(container.getTypeInfo()).result(container_fti_mock) +- +- self.expect(obj.portal_type).result("testtype").count(0, None) +- +- self.replay() ++ container.getTypeInfo = Mock(return_value=container_fti_mock) ++ obj.portal_type = 'testtype' + + form = DefaultAddForm(container, request) + form.portal_type = u"testtype" +@@ -206,29 +193,27 @@ def test_add_raises_unauthorized_if_construction_not_allowed(self): + + def test_add_raises_value_error_if_type_not_addable(self): + # Container, new object, and request +- container = self.mocker.mock() +- obj = self.mocker.mock() ++ container = Mock() ++ obj = Mock() + request = TestRequest() + +- self.expect(obj.portal_type).result("testtype").count(0, None) ++ obj.portal_type = 'testtype' + + # New object's FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.isConstructionAllowed(container)).result(True) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.isConstructionAllowed = Mock(return_value=True) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # Container FTI +- container_fti_mock = self.mocker.proxy(DexterityFTI(u"containertype")) +- self.expect(container_fti_mock.allowType(u"testtype")).result(False) ++ container_fti_mock = DexterityFTI(u"containertype") ++ container_fti_mock.allowType = Mock(return_value=False) + self.mock_utility( + container_fti_mock, + IDexterityFTI, + name=u"containertype" + ) + +- self.expect(container.getTypeInfo()).result(container_fti_mock) +- +- self.replay() ++ container.getTypeInfo = Mock(return_value=container_fti_mock) + + form = DefaultAddForm(container, request) + form.portal_type = u"testtype" +@@ -241,21 +226,19 @@ def test_label(self): + + # Context and request + +- context_mock = self.mocker.mock() +- request_mock = self.mocker.proxy(TestRequest()) ++ context_mock = Mock() ++ request_mock = TestRequest() + + request_mock.form['disable_border'] = True + + # FTI + +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.Title()).result(u"Test title") ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.Title = Mock(return_value=u'Test title') + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # Form + +- self.replay() +- + addform = DefaultAddForm(context_mock, request_mock) + addform.portal_type = u"testtype" + +@@ -266,22 +249,16 @@ def test_label(self): + def test_schema_lookup_add(self): + + # Context and request +- + context_mock = self.create_dummy(portal_type=u'testtype') + request_mock = TestRequest() + + # FTI +- +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.expect( +- fti_mock.behaviors +- ).result( +- ( +- IBehaviorOne.__identifier__, +- IBehaviorTwo.__identifier__, +- IBehaviorThree.__identifier__ +- ) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) ++ fti_mock.behaviors = ( ++ IBehaviorOne.__identifier__, ++ IBehaviorTwo.__identifier__, ++ IBehaviorThree.__identifier__ + ) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -324,9 +301,6 @@ def test_schema_lookup_add(self): + IBehaviorThree.__identifier__ + ) + +- # start testing +- self.replay() +- + # Form + view = DefaultAddForm(context_mock, request_mock) + view.portal_type = u"testtype" +@@ -356,17 +330,14 @@ def test_schema_lookup_add(self): + def test_fires_add_begun_event(self): + + # Context and request +- + context_mock = self.create_dummy( + portal_type=u'testtype', + allowedContentTypes=lambda: [self.create_dummy(getId=lambda: 'testtype')]) + request_mock = TestRequest() + + # FTI +- +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.mocker.count(0, 100) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + self.mock_adapter( +@@ -378,34 +349,28 @@ def test_fires_add_begun_event(self): + self.mock_adapter(Actions, IActions, (Interface, Interface, Interface)) + + # mock notify +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect(notify_mock(mocker.MATCH( +- lambda x: IAddBegunEvent.providedBy(x) +- ))) ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + # Form +- +- self.replay() +- + view = DefaultAddForm(context_mock, request_mock) + view.portal_type = fti_mock.getId() + view.update() + ++ self.assertTrue(notify_mock.called) ++ self.assertTrue(IAddBegunEvent.providedBy(notify_mock.call_args[0][0])) + + def test_update_checks_allowed_types(self): + + # Context and request +- + context_mock = self.create_dummy( + portal_type=u'testtype', + allowedContentTypes=lambda: []) + request_mock = TestRequest() + + # FTI +- +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.mocker.count(0, 100) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + self.mock_adapter( +@@ -417,8 +382,6 @@ def test_update_checks_allowed_types(self): + self.mock_adapter(Actions, IActions, (Interface, Interface, Interface)) + + # Form +- self.mocker.replay() +- + view = DefaultAddForm(context_mock, request_mock) + view.portal_type = fti_mock.getId() + self.assertRaises(ValueError, view.update) +@@ -426,7 +389,6 @@ def test_update_checks_allowed_types(self): + def test_update_ignores_type_check_if_security_check_deferred(self): + + # Context and request +- + context_mock = self.create_dummy( + portal_type=u'testtype', + allowedContentTypes=lambda: []) +@@ -434,10 +396,8 @@ def test_update_ignores_type_check_if_security_check_deferred(self): + alsoProvides(request_mock, IDeferSecurityCheck) + + # FTI +- +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.mocker.count(0, 100) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + self.mock_adapter( +@@ -449,8 +409,6 @@ def test_update_ignores_type_check_if_security_check_deferred(self): + self.mock_adapter(Actions, IActions, (Interface, Interface, Interface)) + + # Form +- self.mocker.replay() +- + view = DefaultAddForm(context_mock, request_mock) + view.portal_type = fti_mock.getId() + try: +@@ -462,7 +420,6 @@ def test_update_ignores_type_check_if_security_check_deferred(self): + def test_fires_add_cancelled_event(self): + + # Context and request +- + context_mock = self.create_dummy(portal_type=u'testtype') + context_mock.absolute_url = \ + lambda *a, **kw: 'http://127.0.0.1/plone/item' +@@ -480,17 +437,17 @@ def addStatusMessage(self, msg, type=''): + self.mock_adapter(StatusMessage, IStatusMessage, (Interface,)) + + # mock notify +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect(notify_mock(mocker.MATCH( +- lambda x: IAddCancelledEvent.providedBy(x) +- ))) ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + # Form +- self.replay() +- + view = DefaultAddForm(context_mock, request_mock) + view.handleCancel(view, {}) + ++ self.assertTrue(notify_mock.called) ++ self.assertTrue( ++ IAddCancelledEvent.providedBy(notify_mock.call_args[0][0])) ++ + + class TestEditView(MockTestCase): + +@@ -508,14 +465,11 @@ def test_label(self): + + # FTI + +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.Title()).result(u"Test title") ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.Title = Mock(return_value=u'Test title') + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + # Form +- +- self.replay() +- + editview = DefaultEditForm(context_mock, request_mock) + + # emulate update() +@@ -536,16 +490,12 @@ class IMarker(IDexterityContent): + request_mock = TestRequest() + + # FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.expect( +- fti_mock.behaviors +- ).result( +- ( +- IBehaviorOne.__identifier__, +- IBehaviorTwo.__identifier__, +- IBehaviorThree.__identifier__ +- ) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) ++ fti_mock.behaviors = ( ++ IBehaviorOne.__identifier__, ++ IBehaviorTwo.__identifier__, ++ IBehaviorThree.__identifier__ + ) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -588,9 +538,6 @@ class IMarker(IDexterityContent): + IBehaviorThree.__identifier__ + ) + +- # start testing +- self.replay() +- + # Form + view = DefaultEditForm(context_mock, request_mock) + view.portal_type = u"testtype" +@@ -616,15 +563,12 @@ class IMarker(IDexterityContent): + def test_fires_edit_begun_event(self): + + # Context and request +- + context_mock = self.create_dummy(portal_type=u'testtype') + request_mock = TestRequest() + + # FTI +- +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.mocker.count(0, 100) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + + self.mock_adapter( +@@ -635,23 +579,20 @@ def test_fires_edit_begun_event(self): + self.mock_adapter(Actions, IActions, (Interface, Interface, Interface)) + + # mock notify +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect(notify_mock(mocker.MATCH( +- lambda x: IEditBegunEvent.providedBy(x) +- ))) ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + # Form +- + view = DefaultEditForm(context_mock, request_mock) +- +- self.replay() +- + view.update() + ++ self.assertTrue(notify_mock.called) ++ self.assertTrue( ++ IEditBegunEvent.providedBy(notify_mock.call_args[0][0])) ++ + def test_fires_edit_cancelled_event(self): + + # Context and request +- + context_mock = self.create_dummy(portal_type=u'testtype', title=u'foo') + context_mock.absolute_url = \ + lambda *a, **kw: 'http://127.0.0.1/plone/item' +@@ -669,21 +610,20 @@ def addStatusMessage(self, msg, type=''): + self.mock_adapter(StatusMessage, IStatusMessage, (Interface,)) + + # mock notify +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect(notify_mock(mocker.MATCH( +- lambda x: IEditCancelledEvent.providedBy(x) +- ))) ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + # Form +- self.replay() +- + view = DefaultEditForm(context_mock, request_mock) + view.handleCancel(view, {}) + ++ self.assertTrue(notify_mock.called) ++ self.assertTrue( ++ IEditCancelledEvent.providedBy(notify_mock.call_args[0][0])) ++ + def test_fires_edit_finished_event(self): + + # Context and request +- + context_mock = self.create_dummy(portal_type=u'testtype', title=u'foo') + context_mock.absolute_url = \ + lambda *a, **kw: 'http://127.0.0.1/plone/item' +@@ -701,19 +641,20 @@ def addStatusMessage(self, msg, type=''): + self.mock_adapter(StatusMessage, IStatusMessage, (Interface,)) + + # mock notify +- notify_mock = self.mocker.replace('zope.event.notify') +- self.expect(notify_mock(mocker.MATCH( +- lambda x: IEditFinishedEvent.providedBy(x) +- ))) ++ from zope.event import notify ++ notify_mock = self.patch_global(notify) + + # Form + view = DefaultEditForm(context_mock, request_mock) +- view.widgets = self.create_dummy() +- view.widgets.extract = lambda *a, **kw: ({'title': u'foo'}, []) +- self.replay() +- ++ view.widgets = Mock() ++ view.widgets.extract = Mock(return_value=({'title': u'foo'}, [])) ++ view.applyChanges = Mock() + view.handleApply(view, {}) + ++ self.assertTrue(notify_mock.called) ++ self.assertTrue( ++ IEditFinishedEvent.providedBy(notify_mock.call_args[0][0])) ++ + + class TestDefaultView(MockTestCase): + +@@ -728,16 +669,12 @@ class IMarker(IDexterityContent): + request_mock = TestRequest() + + # FTI +- fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) +- self.expect(fti_mock.lookupSchema()).result(ISchema) +- self.expect( +- fti_mock.behaviors +- ).result( +- ( +- IBehaviorOne.__identifier__, +- IBehaviorTwo.__identifier__, +- IBehaviorThree.__identifier__ +- ) ++ fti_mock = DexterityFTI(u"testtype") ++ fti_mock.lookupSchema = Mock(return_value=ISchema) ++ fti_mock.behaviors = ( ++ IBehaviorOne.__identifier__, ++ IBehaviorTwo.__identifier__, ++ IBehaviorThree.__identifier__ + ) + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -780,9 +717,6 @@ class IMarker(IDexterityContent): + IBehaviorThree.__identifier__ + ) + +- # start testing +- self.replay() +- + # Form + view = DefaultView(context_mock, request_mock) + view.portal_type = u"testtype" +@@ -804,7 +738,3 @@ class IMarker(IDexterityContent): + ) + additionalSchemata = tuple(view.additionalSchemata) + self.assertEqual(tuple(), tuple(additionalSchemata)) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/plone/dexterity/tests/test_webdav.py b/plone/dexterity/tests/test_webdav.py +index 0b69ed3..db71a2a 100644 +--- a/plone/dexterity/tests/test_webdav.py ++++ b/plone/dexterity/tests/test_webdav.py +@@ -5,7 +5,7 @@ + from ZPublisher.HTTPResponse import HTTPResponse + from ZPublisher.Iterators import IStreamIterator + from email.Message import Message +-from mocker import ANY ++from mock import Mock + from plone.autoform.interfaces import IFormFieldProvider + from plone.behavior.interfaces import IBehaviorAssignable + from plone.dexterity.browser.traversal import DexterityPublishTraverse +@@ -20,8 +20,6 @@ + from plone.dexterity.interfaces import DAV_FOLDER_DATA_ID + from plone.dexterity.interfaces import IDexterityFTI + from plone.dexterity.schema import SCHEMA_CACHE +-from plone.mocktestcase import MockTestCase +-from plone.mocktestcase.dummy import Dummy + from plone.rfc822.interfaces import IPrimaryField + from webdav.NullResource import NullResource + from zExceptions import Forbidden +@@ -39,9 +37,10 @@ + from zope.lifecycleevent.interfaces import IObjectModifiedEvent + from zope.publisher.browser import TestRequest + from zope.size.interfaces import ISized ++from .case import Dummy ++from .case import MockTestCase + + import re +-import unittest + + + class ITestBehavior(Interface): +@@ -78,8 +77,6 @@ class TestWebZope2DAVAPI(MockTestCase): + def test_get_size_no_adapter(self): + item = Item('test') + +- self.replay() +- + self.assertEqual(0, item.get_size()) + + def test_get_size_wrong_adapter(self): +@@ -95,8 +92,6 @@ def sizeForDisplay(self): + self.mock_adapter(SizedAdapter, ISized, (Item,)) + item = Item('test') + +- self.replay() +- + self.assertEqual(0, item.get_size()) + + def test_get_size_right_adapter(self): +@@ -112,15 +107,11 @@ def sizeForDisplay(self): + self.mock_adapter(SizedAdapter, ISized, (Item,)) + item = Item('test') + +- self.replay() +- + self.assertEqual(10, item.get_size()) + + def test_content_type_no_adapter(self): + item = Item('test') + +- self.replay() +- + self.assertEqual(None, item.content_type()) + self.assertEqual(None, item.Format()) + +@@ -133,16 +124,12 @@ def __init__(self, context): + self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item,)) + item = Item('test') + +- self.replay() +- + self.assertEqual('text/foo', item.content_type()) + self.assertEqual('text/foo', item.Format()) + + def test_get_no_adapter(self): + item = Item('test') + +- self.replay() +- + self.assertEqual('', item.manage_DAVget()) + + def test_get_simple_adapter(self): +@@ -164,8 +151,6 @@ def read(self, size=None): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + self.assertEqual('1234567890', item.manage_DAVget()) + self.assertEqual( + 'text/foo; charset="latin1"', +@@ -192,8 +177,6 @@ def read(self, size=None): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + self.assertEqual('1234567890', item.manage_DAVget()) + self.assertEqual(None, request.response.getHeader('Content-Type')) + self.assertEqual(None, request.response.getHeader('Content-Length')) +@@ -224,8 +207,6 @@ def factory(context): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + self.assertEqual(adapterInstance, item.manage_DAVget()) + + def test_put_no_adapter(self): +@@ -234,8 +215,6 @@ def test_put_no_adapter(self): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + self.assertRaises(MethodNotAllowed, item.PUT) + + def test_put_no_body(self): +@@ -244,8 +223,6 @@ def test_put_no_body(self): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + self.assertRaises(MethodNotAllowed, item.PUT) + + def test_put_no_content_type_header(self): +@@ -275,8 +252,6 @@ def factory(context): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + item.PUT() + self.assertEqual(None, adapterInstance.mimeType) + self.assertEqual(None, adapterInstance.encoding) +@@ -321,8 +296,6 @@ def handler(event): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + item.PUT() + self.assertEqual('text/foo', adapterInstance.mimeType) + self.assertEqual(None, adapterInstance.encoding) +@@ -368,8 +341,6 @@ def handler(event): + item = Item('item') + item.REQUEST = request + +- self.replay() +- + item.PUT() + self.assertEqual('text/foo', adapterInstance.mimeType) + self.assertEqual('latin1', adapterInstance.encoding) +@@ -379,7 +350,6 @@ def handler(event): + + def test_mkcol_no_adapter(self): + container = Container('container') +- self.replay() + self.assertRaises(MethodNotAllowed, container.MKCOL_handler, 'test') + + def test_mkcol_simple_adapter(self): +@@ -394,13 +364,11 @@ def __call__(self, id): + self.mock_adapter(DirectoryFactory, IDirectoryFactory, (Container,)) + + container = Container('container') +- self.replay() + container.MKCOL_handler('test') + self.assertEqual(['test'], created) + + def test_put_factory_no_adapter(self): + container = Container('container') +- self.replay() + self.assertEqual( + None, + container.PUT_factory('test', 'text/foo', 'body') +@@ -417,7 +385,6 @@ def __call__(self, name, contentType, body): + return instance + self.mock_adapter(FileFactory, IFileFactory, (Container,)) + container = Container('container') +- self.replay() + self.assertEqual( + instance, + container.PUT_factory('test', 'text/foo', 'body') +@@ -431,7 +398,6 @@ def listFolderContents(self, filter=None): + return [] + + container = DummyContainer('container') +- self.replay() + + objects = container.listDAVObjects() + self.assertEqual(1, len(objects)) +@@ -447,7 +413,6 @@ def listFolderContents(self, filter=None): + return [Item('foo')] + + container = DummyContainer('container') +- self.replay() + + objects = container.listDAVObjects() + self.assertEqual(2, len(objects)) +@@ -463,8 +428,6 @@ def test_getId(self): + container = Container('container') + r = FolderDataResource('fdata', container) + +- self.replay() +- + self.assertEqual('fdata', r.getId()) + self.assertEqual(container, r.__parent__) + +@@ -486,8 +449,6 @@ def content_type(self): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.HEAD(request, request.response)) + self.assertEqual(200, response.getStatus()) + self.assertEqual( +@@ -514,8 +475,6 @@ def content_type(self): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.OPTIONS(request, request.response)) + self.assertEqual( + 'close', +@@ -543,8 +502,6 @@ def content_type(self): + environ={'URL': 'http://example.org/site/container'} + ) + +- self.replay() +- + self.assertRaises(MethodNotAllowed, r.TRACE, request, request.response) + + def test_PROPFIND(self): +@@ -565,8 +522,6 @@ def content_type(self): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.PROPFIND(request, response)) + + self.assertEqual( +@@ -656,8 +611,6 @@ def content_type(self): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.PROPPATCH(request, response)) + + self.assertEqual('New title', container.getProperty('title')) +@@ -707,8 +660,6 @@ def LOCK(self, request, response): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.LOCK(request, response)) + self.assertEqual((request, response), container._locked) + +@@ -728,8 +679,6 @@ def UNLOCK(self, request, response): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.UNLOCK(request, response)) + self.assertEqual((request, response), container._unlocked) + +@@ -748,8 +697,6 @@ def PUT(self, request, response): + ) + response = request.response + +- self.replay() +- + self.assertEqual(response, r.PUT(request, response)) + self.assertEqual((request, response), container._put) + +@@ -757,8 +704,6 @@ def test_MKCOL(self): + container = Container('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + request = DAVTestRequest( + environ={'URL': 'http://example.org/site/container'} + ) +@@ -770,8 +715,6 @@ def test_DELETE(self): + container = Container('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + request = DAVTestRequest( + environ={'URL': 'http://example.org/site/container'} + ) +@@ -783,8 +726,6 @@ def test_COPY(self): + container = Container('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + request = DAVTestRequest( + environ={'URL': 'http://example.org/site/container'} + ) +@@ -796,8 +737,6 @@ def test_MOVE(self): + container = Container('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + request = DAVTestRequest( + environ={'URL': 'http://example.org/site/container'} + ) +@@ -814,8 +753,6 @@ def manage_DAVget(self): + container = TestContainer('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + self.assertEqual('data', r.manage_DAVget()) + + def test_manage_FTPget(self): +@@ -827,16 +764,12 @@ def manage_FTPget(self): + container = TestContainer('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + self.assertEqual('data', r.manage_FTPget()) + + def test_listDAVObjects(self): + container = Container('container') + r = FolderDataResource('fdata', container).__of__(container) + +- self.replay() +- + self.assertEqual([], r.listDAVObjects()) + + +@@ -854,8 +787,6 @@ def manage_addFolder(self, name): + container = TestContainer('container') + factory = DefaultDirectoryFactory(container) + +- self.replay() +- + factory('foo') + self.assertEqual('foo', container._added) + +@@ -863,8 +794,6 @@ def test_file_factory_finder_cruft(self): + container = Container('container') + factory = DefaultFileFactory(container) + +- self.replay() +- + self.assertRaises( + Unauthorized, + factory, +@@ -883,80 +812,42 @@ def test_file_factory_finder_cruft(self): + def test_file_factory_no_ctr(self): + container = Container('container') + +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- self.expect( +- getToolByName_mock( +- container, 'content_type_registry', None +- ) +- ).result(None) ++ from Products.CMFCore.utils import getToolByName ++ self.patch_global(getToolByName, return_value=None) + + factory = DefaultFileFactory(container) + +- self.replay() +- + self.assertEqual(None, factory('test.html', 'text/html', '')) + + def test_file_factory_no_fti(self): + container = Container('container') + +- ctr_mock = self.mocker.mock() +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result(None) ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value=None) ++ self.mock_tool(ctr_mock, 'content_type_registry') + + factory = DefaultFileFactory(container) + +- self.replay() +- + self.assertEqual(None, factory('test.html', 'text/html', '')) + + def test_file_factory_not_allowed(self): + container = Container('container') + container.portal_type = 'containertype' + +- child_fti_mock = self.mocker.mock() +- container_fti_mock = self.mocker.mock() +- ctr_mock = self.mocker.mock() +- pt_mock = self.mocker.mock() +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- self.expect( +- getToolByName_mock( +- container, 'portal_types')).result(pt_mock) +- +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result('childtype') +- +- self.expect(pt_mock.getTypeInfo('childtype')).result(child_fti_mock) +- self.expect(pt_mock.getTypeInfo(container)).result(container_fti_mock) +- +- self.expect(child_fti_mock.product).result(None) +- +- self.expect(container_fti_mock.allowType('childtype')).result(False) ++ child_fti_mock = Mock() ++ child_fti_mock.product = None ++ container_fti_mock = Mock() ++ container_fti_mock.allowType = Mock(return_value=False) ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value='childtype') ++ pt_mock = Mock() ++ pt_mock.getTypeInfo = Mock( ++ side_effect=[child_fti_mock, container_fti_mock]) ++ self.mock_tool(ctr_mock, 'content_type_registry') ++ self.mock_tool(pt_mock, 'portal_types') + + factory = DefaultFileFactory(container) + +- self.replay() +- + self.assertRaises( + Unauthorized, + factory, +@@ -969,41 +860,21 @@ def test_file_factory_construction_not_allowed(self): + container = Container('container') + container.portal_type = 'containertype' + +- child_fti_mock = self.mocker.mock() +- container_fti_mock = self.mocker.mock() +- ctr_mock = self.mocker.mock() +- pt_mock = self.mocker.mock() +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- self.expect( +- getToolByName_mock( +- container, 'portal_types')).result(pt_mock) +- +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result('childtype') +- +- self.expect(pt_mock.getTypeInfo('childtype')).result(child_fti_mock) +- self.expect(pt_mock.getTypeInfo(container)).result(container_fti_mock) +- +- self.expect(child_fti_mock.product).result(None) +- +- self.expect(container_fti_mock.allowType('childtype')).result(True) +- self.expect( +- child_fti_mock.isConstructionAllowed(container) +- ).result(False) ++ child_fti_mock = Mock() ++ child_fti_mock.product = None ++ child_fti_mock.isConstructionAllowed = Mock(return_value=False) ++ container_fti_mock = Mock() ++ container_fti_mock.allowType = Mock(return_value=True) ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value='childtype') ++ pt_mock = Mock() ++ pt_mock.getTypeInfo = Mock( ++ side_effect=[child_fti_mock, container_fti_mock]) ++ self.mock_tool(ctr_mock, 'content_type_registry') ++ self.mock_tool(pt_mock, 'portal_types') + + factory = DefaultFileFactory(container) + +- self.replay() +- + self.assertRaises( + Unauthorized, + factory, +@@ -1013,97 +884,43 @@ def test_file_factory_construction_not_allowed(self): + ) + + def test_file_factory_factory_method(self): +- +- container_mock = self.mocker.mock() +- child_fti_mock = self.mocker.mock() +- ctr_mock = self.mocker.mock() +- pt_mock = self.mocker.mock() +- + result_dummy = self.create_dummy() +- +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container_mock, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- self.expect( +- getToolByName_mock( +- container_mock, 'portal_types')).result(pt_mock) +- +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result('childtype') +- +- self.expect( +- pt_mock.getTypeInfo('childtype') +- ).result(child_fti_mock) +- +- self.expect(child_fti_mock.product).result('FooProduct') +- self.expect( +- container_mock.invokeFactory('childtype', 'test.html') +- ).result('test-1.html') +- +- self.expect(container_mock._getOb('test-1.html')).result(result_dummy) +- self.expect(container_mock._delObject('test-1.html')) ++ container_mock = Mock() ++ container_mock.invokeFactory = Mock(return_value='test-1.html') ++ container_mock._getOb = Mock(return_value=result_dummy) ++ container_mock._delObject = Mock() ++ child_fti_mock = Mock() ++ child_fti_mock.product = 'FooProduct' ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value='childtype') ++ pt_mock = Mock() ++ pt_mock.getTypeInfo = Mock(return_value=child_fti_mock) ++ self.mock_tool(ctr_mock, 'content_type_registry') ++ self.mock_tool(pt_mock, 'portal_types') + + factory = DefaultFileFactory(container_mock) + +- self.replay() +- + self.assertEqual( + result_dummy, + factory('test.html', 'text/html', '') + ) + + def test_file_factory_factory_utility(self): +- container_mock = self.mocker.mock() +- child_fti_mock = self.mocker.mock() +- container_fti_mock = self.mocker.mock() +- ctr_mock = self.mocker.mock() +- pt_mock = self.mocker.mock() +- + result_dummy = self.create_dummy(id='test.html') +- +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container_mock, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- +- self.expect( +- getToolByName_mock( +- container_mock, 'portal_types')).result(pt_mock) +- +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result('childtype') +- +- self.expect( +- pt_mock.getTypeInfo('childtype') +- ).result(child_fti_mock) +- +- self.expect( +- pt_mock.getTypeInfo(container_mock) +- ).result(container_fti_mock) +- +- self.expect( +- container_fti_mock.allowType('childtype') +- ).result(True) +- +- self.expect( +- child_fti_mock.isConstructionAllowed(container_mock) +- ).result(True) +- +- self.expect(child_fti_mock.product).result(None) +- self.expect(child_fti_mock.factory).result('childtype-factory') ++ container_mock = Mock() ++ child_fti_mock = Mock() ++ child_fti_mock.isConstructionAllowed = Mock(return_value=True) ++ child_fti_mock.product = None ++ child_fti_mock.factory = 'childtype-factory' ++ container_fti_mock = Mock() ++ container_fti_mock.allowType = Mock(return_value=True) ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value='childtype') ++ pt_mock = Mock() ++ pt_mock.getTypeInfo = Mock( ++ side_effect=[child_fti_mock, container_fti_mock]) ++ self.mock_tool(ctr_mock, 'content_type_registry') ++ self.mock_tool(pt_mock, 'portal_types') + + def factory(*args, **kwargs): + return result_dummy +@@ -1111,8 +928,6 @@ def factory(*args, **kwargs): + + factory = DefaultFileFactory(container_mock) + +- self.replay() +- + self.assertEqual( + result_dummy, + factory('test.html', 'text/html', '') +@@ -1120,52 +935,21 @@ def factory(*args, **kwargs): + self.assertEqual(result_dummy.Title(), 'test.html') + + def test_file_factory_content_type_factory_utility(self): +- container_mock = self.mocker.mock() +- child_fti_mock = self.mocker.mock() +- container_fti_mock = self.mocker.mock() +- ctr_mock = self.mocker.mock() +- pt_mock = self.mocker.mock() +- +- getToolByName_mock = self.mocker.replace( +- 'Products.CMFCore.utils.getToolByName' +- ) +- +- self.expect( +- getToolByName_mock( +- container_mock, 'content_type_registry', None +- ) +- ).result(ctr_mock) +- +- self.expect( +- getToolByName_mock( +- container_mock, 'portal_types')).result(pt_mock) +- +- self.expect( +- ctr_mock.findTypeName('test.html', 'text/html', '') +- ).result('childtype') +- +- self.expect( +- pt_mock.getTypeInfo('childtype') +- ).result(child_fti_mock) +- +- self.expect( +- pt_mock.getTypeInfo(container_mock) +- ).result(container_fti_mock) +- +- self.expect( +- container_fti_mock.allowType('childtype') +- ).result(True) +- +- self.expect( +- child_fti_mock.isConstructionAllowed(container_mock) +- ).result(True) +- +- self.expect( +- child_fti_mock.getId() +- ).result('childtype') +- +- self.expect(child_fti_mock.product).result(None) +- self.expect(child_fti_mock.factory).result('childtype-factory') ++ container_mock = Mock() ++ child_fti_mock = Mock() ++ child_fti_mock.isConstructionAllowed = Mock(return_value=True) ++ child_fti_mock.getId = Mock(return_value='childtype') ++ child_fti_mock.product = None ++ child_fti_mock.factory = 'childtype-factory' ++ container_fti_mock = Mock() ++ container_fti_mock.allowType = Mock(return_value=True) ++ ctr_mock = Mock() ++ ctr_mock.findTypeName = Mock(return_value='childtype') ++ pt_mock = Mock() ++ pt_mock.getTypeInfo = Mock( ++ side_effect=[child_fti_mock, container_fti_mock]) ++ self.mock_tool(ctr_mock, 'content_type_registry') ++ self.mock_tool(pt_mock, 'portal_types') + + def factory(*args, **kwargs): + return Item(*args, **kwargs) +@@ -1173,8 +957,6 @@ def factory(*args, **kwargs): + + factory = DefaultFileFactory(container_mock) + +- self.replay() +- + item = factory('test.html', 'text/html', '') + + self.assertEqual('test.html', item.id) +@@ -1184,10 +966,10 @@ def test_readfile_mimetype_no_message_no_fields(self): + class ITest(Interface): + pass + +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) + SCHEMA_CACHE.clear() +- self.expect(fti_mock.lookupSchema()).result(ITest) +- self.expect(fti_mock.behaviors).result([]) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) ++ fti_mock.behaviors = [] + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -1196,8 +978,6 @@ class ITest(Interface): + + readfile = DefaultReadFile(item) + +- self.replay() +- + self.assertEqual('text/plain', readfile.mimeType) + + def test_readfile_mimetype_no_message_no_primary_field(self): +@@ -1206,9 +986,9 @@ class ITest(Interface): + title = schema.TextLine() + + SCHEMA_CACHE.clear() +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest) +- self.expect(fti_mock.behaviors).result([]) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) ++ fti_mock.behaviors = [] + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -1217,8 +997,6 @@ class ITest(Interface): + + readfile = DefaultReadFile(item) + +- self.replay() +- + self.assertEqual('text/plain', readfile.mimeType) + + def test_readfile_mimetype_no_message_single_primary_field(self): +@@ -1229,9 +1007,9 @@ class ITest(Interface): + alsoProvides(ITest['body'], IPrimaryField) + + SCHEMA_CACHE.clear() +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest) +- self.expect(fti_mock.behaviors).result([]) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) ++ fti_mock.behaviors = [] + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -1240,8 +1018,6 @@ class ITest(Interface): + + readfile = DefaultReadFile(item) + +- self.replay() +- + self.assertEqual('text/plain', readfile.mimeType) + + def test_readfile_mimetype_no_message_multiple_primary_fields(self): +@@ -1254,8 +1030,8 @@ class ITest(Interface): + alsoProvides(ITest['stuff'], IPrimaryField) + + SCHEMA_CACHE.clear() +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + item = Item('item') +@@ -1263,8 +1039,6 @@ class ITest(Interface): + + readfile = DefaultReadFile(item) + +- self.replay() +- + self.assertEqual('message/rfc822', readfile.mimeType) + + def test_readfile_mimetype_additional_schemata(self): +@@ -1292,9 +1066,10 @@ def __init__(self, context): + + def enumerateBehaviors(self): + yield MockBehavior(ITestAdditional) ++ + SCHEMA_CACHE.clear() +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) + + self.mock_adapter(MockBehaviorAssignable, IBehaviorAssignable, + (Item, )) +@@ -1304,8 +1079,6 @@ def enumerateBehaviors(self): + + readfile = DefaultReadFile(item) + +- self.replay() +- + self.assertEqual('message/rfc822', readfile.mimeType) + + def test_readfile_operations(self): +@@ -1315,11 +1088,9 @@ class ITest(Interface): + body = schema.Text() + alsoProvides(ITest['body'], IPrimaryField) + +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest).count(0, None) +- self.expect( +- fti_mock.behaviors +- ).result([ITestBehavior.__identifier__]).count(0, None) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) ++ fti_mock.behaviors = [ITestBehavior.__identifier__] + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -1334,14 +1105,8 @@ class ITest(Interface): + message['bar'] = 'xyz' + message.set_payload('

body

') + +- constructMessageFromSchemata_mock = self.mocker.replace( +- 'plone.rfc822.constructMessageFromSchemata' +- ) +- self.expect( +- constructMessageFromSchemata_mock(item, ANY) +- ).result(message) +- +- self.replay() ++ from plone.rfc822 import constructMessageFromSchemata ++ self.patch_global(constructMessageFromSchemata, return_value=message) + + body = """\ + title: Test title +@@ -1393,11 +1158,9 @@ class ITest(Interface): + body = schema.Text() + alsoProvides(ITest['body'], IPrimaryField) + +- fti_mock = self.mocker.proxy(DexterityFTI(u'testtype')) +- self.expect(fti_mock.lookupSchema()).result(ITest).count(0, None) +- self.expect( +- fti_mock.behaviors +- ).result([ITestBehavior.__identifier__]).count(0, None) ++ fti_mock = DexterityFTI(u'testtype') ++ fti_mock.lookupSchema = Mock(return_value=ITest) ++ fti_mock.behaviors = [ITestBehavior.__identifier__] + + self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") + +@@ -1418,19 +1181,8 @@ class ITest(Interface): + +

body

""" + +- initializeObjectFromSchemata_mock = self.mocker.replace( +- 'plone.rfc822.initializeObjectFromSchemata' +- ) +- self.expect( +- initializeObjectFromSchemata_mock( +- item, +- ANY, +- self.match_type(Message), +- 'latin1' +- ) +- ) +- +- self.replay() ++ from plone.rfc822 import initializeObjectFromSchemata ++ self.patch_global(initializeObjectFromSchemata) + + writefile.mimeType = 'text/plain' + self.assertEqual('text/plain', writefile.mimeType) +@@ -1481,8 +1233,6 @@ def test_no_acquire_dav(self): + request + ) + +- self.replay() +- + r = traversal.publishTraverse(request, 'item') + + self.assertTrue(isinstance(r, NullResource)) +@@ -1502,8 +1252,6 @@ def test_acquire_without_dav(self): + + traversal = DexterityPublishTraverse(container.__of__(outer), request) + +- self.replay() +- + r = traversal.publishTraverse(request, 'item') + + self.assertEqual(r.aq_base, outer['item'].aq_base) +@@ -1518,8 +1266,6 @@ def test_folder_data_traversal_dav(self): + + traversal = DexterityPublishTraverse(container, request) + +- self.replay() +- + r = traversal.publishTraverse(request, DAV_FOLDER_DATA_ID) + + self.assertEqual(DAV_FOLDER_DATA_ID, r.__name__) +@@ -1535,8 +1281,6 @@ def test_folder_data_traversal_without_dav(self): + + traversal = DexterityPublishTraverse(container, request) + +- self.replay() +- + self.assertRaises( + Forbidden, + traversal.publishTraverse, +@@ -1558,8 +1302,6 @@ def __browser_default__(self, request): + + traversal = DexterityPublishTraverse(container, request) + +- self.replay() +- + self.assertEqual((container, (),), traversal.browserDefault(request)) + + def test_browser_default_dav_get(self): +@@ -1576,8 +1318,6 @@ def __browser_default__(self, request): + + traversal = DexterityPublishTraverse(container, request) + +- self.replay() +- + self.assertEqual( + (container, ('foo',),), + traversal.browserDefault(request) +@@ -1597,13 +1337,7 @@ def __browser_default__(self, request): + + traversal = DexterityPublishTraverse(container, request) + +- self.replay() +- + self.assertEqual( + (container, ('foo',),), + traversal.browserDefault(request) + ) +- +- +-def test_suite(): +- return unittest.defaultTestLoader.loadTestsFromName(__name__) +diff --git a/setup.py b/setup.py +index c2d7c6c..173c3e2 100644 +--- a/setup.py ++++ b/setup.py +@@ -71,7 +71,6 @@ + ], + extras_require={ + 'test': [ +- 'plone.mocktestcase>=1.0b3', + 'plone.testing', + 'mock', + ]