def setUp(self): self.portal = self.layer['portal'] self.browser = Browser(self.layer['app']) setRoles(self.portal, TEST_USER_ID, ['Manager']) # Invalidate schema cache SCHEMA_CACHE.invalidate('Audio') SCHEMA_CACHE.invalidate('OGG Audio File')
def test_getattr_on_container_returns_children(self): content = Container() content.id = u"id" content.portal_type = u"testtype" content['foo'] = Item('foo') content['quux'] = Item('quux') class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # FTI mock fti_mock = Mock(wraps=DexterityFTI(u"testtype")) fti_mock.lookupSchema = Mock(return_value=ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") SCHEMA_CACHE.invalidate('testtype') # Schema field masks contained item self.assertEqual(u"foo_default", content.foo) # But we can still obtain an item self.assertTrue(isinstance(content['foo'], Item)) self.assertEqual('foo', content['foo'].id) # And if the item isn't masked by an attribute, we can still getattr it self.assertTrue(isinstance(content['quux'], Item)) self.assertEqual('quux', content['quux'].id) self.assertTrue(isinstance(getattr(content, 'quux'), Item)) self.assertEqual('quux', getattr(content, 'quux').id)
def test_getattr_consults_schema_item_default_factory_with_context(self): content = Item() content.id = u"id" content.portal_type = u"testtype" from zope.interface import provider from zope.schema.interfaces import IContextAwareDefaultFactory @provider(IContextAwareDefaultFactory) def defaultFactory(context): return u"{0:s}_{1:s}".format(context.id, context.portal_type) class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", defaultFactory=defaultFactory) bar = zope.schema.TextLine(title=u"bar") # FTI mock fti_mock = Mock(wraps=DexterityFTI(u"testtype")) fti_mock.lookupSchema = Mock(return_value=ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") SCHEMA_CACHE.invalidate('testtype') self.assertEqual(u"id_testtype", content.foo) self.assertEqual(None, content.bar) self.assertEqual(u"id", content.id) self.assertRaises(AttributeError, getattr, content, 'baz')
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() schema1 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate('testtype') schema2 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate('testtype') schema3 = SCHEMA_CACHE.get(u"testtype") self.assertTrue(schema1 is None) self.assertTrue(schema2 is None) self.assertTrue(schema3 is ISchema1)
def inactivate_filing_number(portal): unregister_layer('opengever.dossier.filing') portal_types = getToolByName(portal, 'portal_types') fti = portal_types.get('opengever.dossier.businesscasedossier') fti.behaviors = [behavior for behavior in fti.behaviors if not behavior.endswith('IFilingNumber')] SCHEMA_CACHE.invalidate('opengever.dossier.businesscasedossier')
def setUp(self): self.portal = self.layer['portal'] setRoles(self.portal, TEST_USER_ID, ['Manager']) self.portal.invokeFactory('Folder', 'test-folder') # Invalidate schema cache SCHEMA_CACHE.invalidate('Person') setRoles(self.portal, TEST_USER_ID, ['Member']) self.folder = self.portal['test-folder'] self.setup_content(self.folder)
def setUp(self): self.portal = self.layer["portal"] setRoles(self.portal, TEST_USER_ID, ["Manager"]) self.portal.invokeFactory("Folder", "test-folder") # Invalidate schema cache SCHEMA_CACHE.invalidate("Audio") SCHEMA_CACHE.invalidate("OGG Audio File") self.folder = self.portal["test-folder"] audio_id = self.folder.invokeFactory("Audio", "my-audio") self.audio = self.folder[audio_id] self.setup_content_data() self.audio.invokeFactory("OGG Audio File", "file.ogg") self.ogg_audio = self.audio["file.ogg"]
def setUp(self): self.portal = self.layer['portal'] with api.env.adopt_roles([ 'Manager', ]): self.folder = api.content.create(type='Folder', container=self.portal, id='test-folder') # Invalidate schema cache SCHEMA_CACHE.invalidate('ExternalContent') self.content = api.content.create(type='ExternalContent', container=self.folder, id='external') self.setup_content_data()
def setUp(self): self.portal = self.layer['portal'] # Invalidate schema cache SCHEMA_CACHE.invalidate('ExternalContent') with api.env.adopt_roles(['Manager', ]): self.folder = api.content.create( type='Folder', container=self.portal, id='test-folder' ) self.content = api.content.create( type='ExternalContent', container=self.folder, id='external' )
def test_repeated_lookup_with_changed_schema_and_invalidation(self): class ISchema1(Interface): pass class ISchema2(Interface): pass 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") schema2 = SCHEMA_CACHE.get(u"testtype") self.assertTrue(schema1 is ISchema1) self.assertTrue(schema2 is ISchema2)
def setUp(self): self.portal = self.layer["portal"] self.request = self.layer["request"] self.portal.invokeFactory( "Document", id="doc1", ) fti = queryUtility(IDexterityFTI, name="Plone Site") if fti is not None: behavior_list = [a for a in fti.behaviors] behavior_list.append("volto.blocks") fti.behaviors = tuple(behavior_list) # Invalidating the cache is required for the FTI to be applied # on the existing object SCHEMA_CACHE.invalidate("Plone Site")
def setUp(self): self.portal = self.layer['portal'] setRoles(self.portal, TEST_USER_ID, ['Manager']) # Invalidate schema cache SCHEMA_CACHE.invalidate('Audio') SCHEMA_CACHE.invalidate('OGG Audio File') self.folder = api.content.create(type='Folder', container=self.portal, id='test-folder') self.audio = api.content.create(type='Audio', container=self.folder, id='my-audio') self.setup_content_data() self.ogg_audio = api.content.create(type='OGG Audio File', container=self.audio, id='file.ogg') self.ogg_audio.file = self.ogg self.ogg_audio.reindexObject()
def test_attribute_and_value_error_not_cached(self): class ISchema1(Interface): pass 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") SCHEMA_CACHE.invalidate('testtype') schema2 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate('testtype') schema3 = SCHEMA_CACHE.get(u"testtype") self.assertTrue(schema1 is None) self.assertTrue(schema2 is None) self.assertTrue(schema3 is ISchema1)
def test_repeated_lookup_with_changed_schema_and_invalidation(self): class ISchema1(Interface): pass 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() schema1 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate(u"testtype") schema2 = SCHEMA_CACHE.get(u"testtype") self.assertTrue(schema1 is ISchema1) self.assertTrue(schema2 is ISchema2)
def test_getattr_consults_schema_container(self): content = Container() content.id = u"id" content.portal_type = u"testtype" class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # FTI mock fti_mock = Mock(wraps=DexterityFTI(u"testtype")) fti_mock.lookupSchema = Mock(return_value=ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") SCHEMA_CACHE.invalidate('testtype') self.assertEqual(u"foo_default", content.foo) self.assertEqual(None, content.bar) self.assertEqual(u"id", content.id) self.assertRaises(AttributeError, getattr, content, 'baz')
def test_repeated_lookup_with_changed_schema_and_invalidation(self): class ISchema1(Interface): pass 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() schema1 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate(u"testtype") schema2 = SCHEMA_CACHE.get(u"testtype") self.failUnless(schema1 is ISchema1) self.failUnless(schema2 is ISchema2)
def test_getattr_consults_schema_item(self): content = Item() content.id = u"id" content.portal_type = u"testtype" class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # FTI mock fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) self.expect(fti_mock.lookupSchema()).result(ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") self.replay() SCHEMA_CACHE.invalidate('testtype') self.assertEqual(u"foo_default", content.foo) self.assertEqual(None, content.bar) self.assertEqual(u"id", content.id) self.assertRaises(AttributeError, getattr, content, 'baz')
def setUp(self): self.portal = self.layer['portal'] setRoles(self.portal, TEST_USER_ID, ['Manager']) # Invalidate schema cache SCHEMA_CACHE.invalidate('Audio') SCHEMA_CACHE.invalidate('OGG Audio File') self.folder = api.content.create( type='Folder', container=self.portal, id='test-folder' ) self.audio = api.content.create( type='Audio', container=self.folder, id='my-audio' ) self.setup_content_data() self.ogg_audio = api.content.create( type='OGG Audio File', container=self.audio, id='file.ogg' ) self.ogg_audio.file = self.ogg self.ogg_audio.reindexObject()
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() SCHEMA_CACHE.invalidate('testtype') schema1 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate('testtype') schema2 = SCHEMA_CACHE.get(u"testtype") SCHEMA_CACHE.invalidate('testtype') schema3 = SCHEMA_CACHE.get(u"testtype") self.assertTrue(schema1 is None) self.assertTrue(schema2 is schema3 is ISchema1)
def test_provided_by_behavior_subtype_invalidation(self): # Dummy type class MyItem(Item): pass # Fake data manager class FauxDataManager(object): def setstate(self, obj): pass def oldstate(self, obj, tid): pass def register(self, obj): pass # Dummy instance item = MyItem(id=u'id') item.portal_type = 'testtype' # Without a persistence jar, the _p_changed check doesn't work. In # this case, the cache is a bit slower. item._p_jar = FauxDataManager() # Dummy schema class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # Schema is not implemented by class or provided by instance self.assertEquals(False, ISchema.implementedBy(MyItem)) self.assertEquals(False, ISchema.providedBy(item)) # Behaviors - one with a subtype and one without class IBehavior1(Interface): pass class IBehavior2(Interface): pass class IBehavior3(Interface): pass class ISubtype1(Interface): pass class ISubtype2(Interface): pass behavior1 = BehaviorRegistration(u"Behavior1", "", IBehavior1, None, None) behavior2 = BehaviorRegistration(u"Behavior2", "", IBehavior2, ISubtype1, None) behavior3 = BehaviorRegistration(u"Behavior3", "", IBehavior3, ISubtype2, None) self.mock_utility(behavior1, IBehavior, name="behavior1") self.mock_utility(behavior2, IBehavior, name="behavior2") self.mock_utility(behavior3, IBehavior, name="behavior3") # FTI mock fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) self.expect(fti_mock.lookupSchema()).result(ISchema).count( 2) # twice, since we invalidate # 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) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") self.replay() self.assertEquals(False, ISchema.implementedBy(MyItem)) # Schema as looked up in FTI is now provided by item ... self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(False, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # 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. self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(False, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # If we now invalidate the schema cache, we should get the second set # of behaviors SCHEMA_CACHE.invalidate('testtype') # Schema as looked up in FTI is now provided by item ... self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(True, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # 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. self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(True, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item))
def test_provided_by_behavior_subtype_invalidation(self): # Dummy type class MyItem(Item): pass # Fake data manager class FauxDataManager(object): def setstate(self, obj): pass def oldstate(self, obj, tid): pass def register(self, obj): pass # Dummy instance item = MyItem(id=u'id') item.portal_type = 'testtype' # Without a persistence jar, the _p_changed check doesn't work. In # this case, the cache is a bit slower. item._p_jar = FauxDataManager() # Dummy schema class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # Schema is not implemented by class or provided by instance self.assertFalse(ISchema.implementedBy(MyItem)) self.assertFalse(ISchema.providedBy(item)) # Behaviors - one with a marker and one without class IBehavior1(Interface): pass behavior1 = BehaviorRegistration( u"Behavior1", "", IBehavior1, None, None ) self.mock_utility(behavior1, IBehavior, name="behavior1") class IBehavior2(Interface): pass class IMarker2(Interface): pass behavior2 = BehaviorRegistration( u"Behavior2", "", IBehavior2, IMarker2, None ) self.mock_utility(behavior2, IBehavior, name="behavior2") class IBehavior3(Interface): pass class IMarker3(Interface): pass behavior3 = BehaviorRegistration( u"Behavior3", "", IBehavior3, IMarker3, None ) self.mock_utility(behavior3, IBehavior, name="behavior3") self.mock_adapter( DexterityBehaviorAssignable, IBehaviorAssignable, (IDexterityContent,) ) # FTI mock fti_mock = Mock(wraps=DexterityFTI(u"testtype")) fti_mock.lookupSchema = Mock(return_value=ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") # start clean SCHEMA_CACHE.invalidate('testtype') fti_mock.behaviors = ['behavior1', 'behavior2'] # implementedBy does not look into the fti self.assertFalse(ISchema.implementedBy(MyItem)) # Main schema as looked up in FTI is now provided by item ... self.assertTrue(ISchema.providedBy(item)) # Behaviors with its behavior or if provided merker as looked up in # FTI is now provided by item ... self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertFalse(IMarker3.providedBy(item)) # 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)) # Behaviors with its behavior or if provided merker as looked up in # FTI is now provided by item ... self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertTrue(IMarker3.providedBy(item)) # 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. self.assertTrue(ISchema.providedBy(item)) self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertTrue(IMarker3.providedBy(item))
def test_provided_by_behavior_subtype_invalidation(self): # Dummy type class MyItem(Item): pass # Fake data manager class FauxDataManager(object): def setstate(self, obj): pass def oldstate(self, obj, tid): pass def register(self, obj): pass # Dummy instance item = MyItem(id=u'id') item.portal_type = 'testtype' # Without a persistence jar, the _p_changed check doesn't work. In # this case, the cache is a bit slower. item._p_jar = FauxDataManager() # Dummy schema class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # Schema is not implemented by class or provided by instance self.assertEquals(False, ISchema.implementedBy(MyItem)) self.assertEquals(False, ISchema.providedBy(item)) # Behaviors - one with a subtype and one without class IBehavior1(Interface): pass class IBehavior2(Interface): pass class IBehavior3(Interface): pass class ISubtype1(Interface): pass class ISubtype2(Interface): pass behavior1 = BehaviorRegistration(u"Behavior1", "", IBehavior1, None, None) behavior2 = BehaviorRegistration(u"Behavior2", "", IBehavior2, ISubtype1, None) behavior3 = BehaviorRegistration(u"Behavior3", "", IBehavior3, ISubtype2, None) self.mock_utility(behavior1, IBehavior, name="behavior1") self.mock_utility(behavior2, IBehavior, name="behavior2") self.mock_utility(behavior3, IBehavior, name="behavior3") # FTI mock fti_mock = self.mocker.proxy(DexterityFTI(u"testtype")) self.expect(fti_mock.lookupSchema()).result(ISchema).count(2) # twice, since we invalidate # 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) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") self.replay() self.assertEquals(False, ISchema.implementedBy(MyItem)) # Schema as looked up in FTI is now provided by item ... self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(False, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # 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. self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(False, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # If we now invalidate the schema cache, we should get the second set # of behaviors SCHEMA_CACHE.invalidate('testtype') # Schema as looked up in FTI is now provided by item ... self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(True, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item)) # 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. self.assertEquals(True, ISubtype1.providedBy(item)) self.assertEquals(True, ISubtype2.providedBy(item)) self.assertEquals(True, ISchema.providedBy(item))
def test_provided_by_behavior_subtype_invalidation(self): # Dummy type class MyItem(Item): pass # Fake data manager class FauxDataManager(object): def setstate(self, obj): pass def oldstate(self, obj, tid): pass def register(self, obj): pass # Dummy instance item = MyItem(id=u'id') item.portal_type = 'testtype' # Without a persistence jar, the _p_changed check doesn't work. In # this case, the cache is a bit slower. item._p_jar = FauxDataManager() # Dummy schema class ISchema(Interface): foo = zope.schema.TextLine(title=u"foo", default=u"foo_default") bar = zope.schema.TextLine(title=u"bar") # Schema is not implemented by class or provided by instance self.assertFalse(ISchema.implementedBy(MyItem)) self.assertFalse(ISchema.providedBy(item)) # Behaviors - one with a marker and one without class IBehavior1(Interface): pass behavior1 = BehaviorRegistration(u"Behavior1", "", IBehavior1, None, None) self.mock_utility(behavior1, IBehavior, name="behavior1") class IBehavior2(Interface): pass class IMarker2(Interface): pass behavior2 = BehaviorRegistration(u"Behavior2", "", IBehavior2, IMarker2, None) self.mock_utility(behavior2, IBehavior, name="behavior2") class IBehavior3(Interface): pass class IMarker3(Interface): pass behavior3 = BehaviorRegistration(u"Behavior3", "", IBehavior3, IMarker3, None) self.mock_utility(behavior3, IBehavior, name="behavior3") self.mock_adapter(DexterityBehaviorAssignable, IBehaviorAssignable, (IDexterityContent, )) # FTI mock fti_mock = Mock(wraps=DexterityFTI(u"testtype")) fti_mock.lookupSchema = Mock(return_value=ISchema) self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype") # start clean SCHEMA_CACHE.invalidate('testtype') fti_mock.behaviors = ['behavior1', 'behavior2'] # implementedBy does not look into the fti self.assertFalse(ISchema.implementedBy(MyItem)) # Main schema as looked up in FTI is now provided by item ... self.assertTrue(ISchema.providedBy(item)) # Behaviors with its behavior or if provided merker as looked up in # FTI is now provided by item ... self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertFalse(IMarker3.providedBy(item)) # 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)) # Behaviors with its behavior or if provided merker as looked up in # FTI is now provided by item ... self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertTrue(IMarker3.providedBy(item)) # 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. self.assertTrue(ISchema.providedBy(item)) self.assertFalse(IBehavior1.providedBy(item)) self.assertTrue(IMarker2.providedBy(item)) self.assertTrue(IMarker3.providedBy(item))