def testPloneSurveyQuestion(self):
assert verifyClass(IPloneSurveyQuestion, SurveyMatrixQuestion)
assert IPloneSurveyQuestion.implementedBy(SurveyMatrixQuestion)
assert verifyClass(IPloneSurveyQuestion, SurveySelectQuestion)
assert IPloneSurveyQuestion.implementedBy(SurveySelectQuestion)
assert verifyClass(IPloneSurveyQuestion, SurveyTextQuestion)
assert IPloneSurveyQuestion.implementedBy(SurveyTextQuestion)
def test_interfaces(self):
from Products.PluginIndexes.interfaces import ITopicIndex
from Products.PluginIndexes.interfaces import IPluggableIndex
from zope.interface.verify import verifyClass
verifyClass(ITopicIndex, TopicIndex)
verifyClass(IPluggableIndex, TopicIndex)
def test_implements(self):
from zope.interface.verify import verifyClass
from repoze.who.interfaces import IIdentifier
from repoze.who.interfaces import IChallenger
klass = self._getTargetClass()
verifyClass(IIdentifier, klass)
verifyClass(IChallenger, klass)
def test(self):
field = Text(title=u"Foo thing")
class I(Interface):
getFoo, setFoo = accessors(field)
class Bad(object):
implements(I)
class Good(object):
implements(I)
def __init__(self):
self.set = 0
def getFoo(self):
return u"foo"
def setFoo(self, v):
self.set += 1
names = I.names()
names.sort()
self.assertEqual(names, ['getFoo', 'setFoo'])
self.assertEqual(I['getFoo'].field, field)
self.assertEqual(I['getFoo'].__name__, 'getFoo')
self.assertEqual(I['getFoo'].__doc__, u'get Foo thing')
self.assertEqual(I['getFoo'].__class__, FieldReadAccessor)
self.assertEqual(I['getFoo'].writer, I['setFoo'])
# test some field attrs
for attr in ('title', 'description', 'readonly'):
self.assertEqual(getattr(I['getFoo'], attr), getattr(field, attr))
self.assert_(IText.providedBy(I['getFoo']))
self.assert_(IMethod.providedBy(I['getFoo']))
self.assert_(IMethod.providedBy(I['setFoo']))
self.assertEqual(I['setFoo'].field, field)
self.assertEqual(I['setFoo'].__name__, 'setFoo')
self.assertEqual(I['setFoo'].__doc__, u'set Foo thing')
self.assertEqual(I['setFoo'].__class__, FieldWriteAccessor)
self.assertRaises(Exception, verifyClass, I, Bad)
self.assertRaises(Exception, verifyObject, I, Bad())
self.assertEquals(I['getFoo'].query(Bad(), 42), 42)
self.assertRaises(AttributeError, I['getFoo'].get, Bad())
verifyClass(I, Good)
verifyObject(I, Good())
self.assertEquals(I['getFoo'].query(Good(), 42), u'foo')
self.assertEquals(I['getFoo'].get(Good()), u'foo')
instance = Good()
I['getFoo'].set(instance, u'whatever')
self.assertEquals(instance.set, 1)
def test_z3interfaces(self):
from zope.interface.verify import verifyClass
from Products.CMFDefault.interfaces import ILink
from Products.CMFDefault.interfaces import IMutableLink
verifyClass(ILink, self._getTargetClass())
verifyClass(IMutableLink, self._getTargetClass())
def test_z2interfaces(self):
from Interface.Verify import verifyClass
from Products.CMFCore.ActionInformation import ActionInfo
from Products.CMFCore.interfaces.portal_actions \
import ActionInfo as IActionInfo
verifyClass(IActionInfo, ActionInfo)
def test_UserManagerInterfaces(self):
"""Tests user manager plugin respects interfaces."""
from Products.PluggableAuthService.interfaces.plugins import\
IAuthenticationPlugin, IUserEnumerationPlugin
from Products.ERP5Security.ERP5UserManager import ERP5UserManager
verifyClass(IAuthenticationPlugin, ERP5UserManager)
verifyClass(IUserEnumerationPlugin, ERP5UserManager)
def test_ILoginPasswordHostExtractionPlugin_conformance( self ):
from Products.PluggableAuthService.interfaces.plugins \
import ILoginPasswordHostExtractionPlugin
verifyClass( ILoginPasswordHostExtractionPlugin
, self._getTargetClass() )
def test_interfaces(self):
from Products.CMFCore.interfaces import IContentish
from Products.CMFCore.interfaces import IDynamicType
from Products.CMFCore.PortalContent import PortalContent
verifyClass(IContentish, PortalContent)
verifyClass(IDynamicType, PortalContent)
def test_z2interfaces(self):
from Interface.Verify import verifyClass
from Products.CMFCore.CachingPolicyManager import CachingPolicyManager
from Products.CMFCore.interfaces.CachingPolicyManager \
import CachingPolicyManager as ICachingPolicyManager
verifyClass(ICachingPolicyManager, CachingPolicyManager)
def test_z3interfaces(self):
from Products.PluginIndexes.interfaces import IPluggableIndex
from Products.ZCTextIndex.interfaces import IZCTextIndex
from zope.interface.verify import verifyClass
verifyClass(IPluggableIndex, ZCTextIndex)
verifyClass(IZCTextIndex, ZCTextIndex)
def _load_entry(self, entry):
# pylint: disable=W0703
if self._check_extras:
try:
entry.require()
except Exception as err:
raise PluginDBError('Requirements are not satisfied '
'for %s:%s: %s' % (self._group,
entry.name,
str(err)))
try:
result = entry.load()
except Exception as err:
# log full traceback of the bad entry to help support
traceback.print_exc()
raise PluginDBError('Unable to load %s:%s: %s' %
(self._group, entry.name, str(err)))
if self._interface:
try:
verifyClass(self._interface, result)
except Invalid as err:
raise PluginDBError('Plugin %s:%s does not implement %s: %s' %
(self._group, entry.name,
self._interface.__name__, str(err)))
return result
def test_interface_conformance(self):
from zope.interface.verify import verifyClass, verifyObject
from ..interfaces import IShadowTreeTool
verifyClass(IShadowTreeTool, self._get_target_class())
util = self._make_one()
verifyObject(IShadowTreeTool, util)
IShadowTreeTool.validateInvariants(util)
def test_alias_class_implements(self):
from zope.interface.verify import verifyClass
from pyramid.events import AfterTraversal
from pyramid.interfaces import IAfterTraversal
from pyramid.interfaces import IContextFound
verifyClass(IAfterTraversal, AfterTraversal)
verifyClass(IContextFound, AfterTraversal)
def test_interfaces(self):
from Products.CMFCore.MemberDataTool import MemberDataFactory
from Products.CMFCore.interfaces import IMemberData
from zope.component import IFactory
verifyClass(IFactory, MemberDataFactory)
verifyClass(IMemberData, MemberDataFactory)
def test_interfaces(self):
from Products.CMFCore.interfaces import IActionProvider
from Products.CMFCore.interfaces import IURLTool
from Products.CMFCore.URLTool import URLTool
verifyClass(IActionProvider, URLTool)
verifyClass(IURLTool, URLTool)
def test_alias_class_implements(self):
from pyramid.events import WSGIApplicationCreatedEvent
from pyramid.interfaces import IWSGIApplicationCreatedEvent
from pyramid.interfaces import IApplicationCreated
from zope.interface.verify import verifyClass
verifyClass(IWSGIApplicationCreatedEvent, WSGIApplicationCreatedEvent)
verifyClass(IApplicationCreated, WSGIApplicationCreatedEvent)
def test_interfaces(self):
from OFS.interfaces import IWriteLock
from webdav.interfaces import IDAVResource
from zope.interface.verify import verifyClass
verifyClass(IDAVResource, self._getTargetClass())
verifyClass(IWriteLock, self._getTargetClass())
def test_sauropod_backend(self):
try:
from appsync.storage.sauropod import SauropodDatabase
except ImportError:
pass
else:
verifyClass(IAppSyncDatabase, SauropodDatabase)
def test_interfaces(self):
from Products.CMFCore.interfaces import IActionProvider
from Products.CMFCore.interfaces import ITypesTool
from Products.CMFCore.TypesTool import TypesTool
verifyClass(IActionProvider, TypesTool)
verifyClass(ITypesTool, TypesTool)
def test_z3interfaces(self):
from zope.interface.verify import verifyClass
from Products.CMFCalendar.interfaces import IEvent
from Products.CMFCalendar.interfaces import IMutableEvent
verifyClass(IEvent, self._getTargetClass())
verifyClass(IMutableEvent, self._getTargetClass())
def test_xml_generator_implements(self):
self.replay()
self.assertTrue(i.IMopageEventXMLGenerator.implementedBy(
xml_generator.MopageEventXMLGenerator))
verifyClass(i.IMopageEventXMLGenerator, xml_generator.MopageEventXMLGenerator)
def test_interfaces(self):
from Products.CMFCore.DiscussionTool import DiscussionTool
from Products.CMFCore.interfaces import IActionProvider
from Products.CMFCore.interfaces import IOldstyleDiscussionTool
verifyClass(IActionProvider, DiscussionTool)
verifyClass(IOldstyleDiscussionTool, DiscussionTool)
def add_metadata_field(config, metadata_cls):
verifyClass(IMetadata, metadata_cls)
for ar in config.registry.registeredAdapters():
if ar.provided == IMetadata and ar.name == metadata_cls.name: #pragma : no coverage
logger.warn("Metadata adapter %r already registered with name %r. "
"Registering %r might override it." % (ar.factory, ar.name, metadata_cls))
config.registry.registerAdapter(metadata_cls, name = metadata_cls.name)
def test_z3interfaces(self):
from Products.PluginIndexes.interfaces import IPathIndex
from Products.PluginIndexes.interfaces import IUniqueValueIndex
from zope.interface.verify import verifyClass
verifyClass(IPathIndex, PathIndex)
verifyClass(IUniqueValueIndex, PathIndex)
def test_conformance(self):
from zope.interface.verify import verifyClass
from zope.interface.verify import verifyObject
from pyramid.interfaces import IIntrospectable
verifyClass(IIntrospectable, self._getTargetClass())
verifyObject(IIntrospectable, self._makeOnePopulated())
def test_class_conforms_to_IWriteLock(self):
from zope.interface.verify import verifyClass
try:
from OFS.interfaces import IWriteLock
except ImportError:
from webdav.interfaces import IWriteLock
verifyClass(IWriteLock, PythonScript)
def test_data_provider_implements(self):
self.replay()
self.assertTrue(i.IMopageEventDataProvider.implementedBy(
data_provider.MopageEventDataProvider))
verifyClass(i.IMopageEventObjectLookup, object_lookup.MopageEventObjectLookup)
def test_interfaces(self):
from ..interfaces import IContentish
from ..interfaces import IDynamicType
from ..PortalContent import PortalContent
verifyClass(IContentish, PortalContent)
verifyClass(IDynamicType, PortalContent)
def test_implements_interface(self):
self.replay()
utility = getUtility(IBridgeRequest)
klass = type(utility)
self.assertTrue(IBridgeRequest.implementedBy(klass))
verifyClass(IBridgeRequest, klass)
def test_class_conforms_to_ICredentialsUpdatedEvent(self):
from zope.interface.verify import verifyClass
from Products.PluggableAuthService.interfaces.events \
import ICredentialsUpdatedEvent
verifyClass(ICredentialsUpdatedEvent, self._getTargetClass())
def test_class_conforms_to_IQuip(self):
from zope.interface.verify import verifyClass
from karl.models.interfaces import IQuip
verifyClass(IQuip, self._getTargetClass())
def test_verify(self):
assert verifyClass(
IAuthenticationPolicy,
auth_policy.SessionAuthenticationPolicy,
)
def test_verify(self):
assert verifyClass(
IAuthenticationPolicy,
auth_policy.BasicAuthAuthenticationPolicy,
)
def test_interface(self):
from zope.interface.verify import verifyClass
verifyClass(IMembershipTool, MembershipTool)
def test_verify_class(self):
self.assertTrue(verifyClass(IPoll, self._cut))
def testInterfacesVerify(self):
for interface in implementedBy(ZopePublication):
verifyClass(interface, TestPublication)
def test_implements(self):
from who_ldap import LDAPAttributesPlugin
from zope.interface.verify import verifyClass
from repoze.who.interfaces import IMetadataProvider
verifyClass(IMetadataProvider, LDAPAttributesPlugin, tentative=True)
def test_implements_interface(self):
verifyClass(IUpgradeStep, UpgradeStep)
def test_class_conforms_to_IPrincipalDeletedEvent(self):
from zope.interface.verify import verifyClass
from Products.PluggableAuthService.interfaces.events \
import IPrincipalDeletedEvent
verifyClass(IPrincipalDeletedEvent, self._getTargetClass())
def test_class_conforms_to_IPackageOverrides(self):
from zope.interface.verify import verifyClass
from pyramid.interfaces import IPackageOverrides
verifyClass(IPackageOverrides, self._getTargetClass())
def test_implements(self):
from zope.interface.verify import verifyClass
from repoze.who.interfaces import IAuthenticator
from who_ldap import LDAPAuthenticatorPlugin
verifyClass(IAuthenticator, LDAPAuthenticatorPlugin, tentative=True)
def test_interfaces(self):
verifyClass(IComponent, Service)
def test_class_conforms_to_IPEP302Loader(self):
from zope.interface.verify import verifyClass
from pyramid.interfaces import IPEP302Loader
verifyClass(IPEP302Loader, self._getTargetClass())
def test_verify_service(self):
assert verifyClass(IUserService, services.DatabaseUserService)
def test_class_conforms_to_IPermission(self):
from zope.interface.verify import verifyClass
from zope.security.interfaces import IPermission
verifyClass(IPermission, self._getTargetClass())
def test_verify_service(self):
assert verifyClass(IPasswordBreachedService,
services.HaveIBeenPwnedPasswordBreachedService)
def test_verify_service(self):
assert verifyClass(ITokenService, services.TokenService)
def test_conforms_to_IMemCacheSessionDataContainer(self):
from zope.interface.verify import verifyClass
from ..interfaces import IMemCacheSessionDataContainer
verifyClass(IMemCacheSessionDataContainer, self._getTargetClass())
def test_verify_service(self):
assert verifyClass(IPasswordBreachedService,
services.NullPasswordBreachedService)
def test_verify_implemented_interfaces(self):
verifyClass(IBumblebeeOverlay, BumblebeeMailOverlay)
def test_class_conforms_to_IZCLexicon(self):
from Products.ZCTextIndex.interfaces import IZCLexicon
from zope.interface.verify import verifyClass
verifyClass(IZCLexicon, self._getTargetClass())
def test_interfaces(self):
from Products.CMFCore.interfaces import ICookieCrumbler
verifyClass(ICookieCrumbler, self._getTargetClass())
def testInterfaceComplete(self):
self.assertTrue(
verifyClass(IContentListingObject, FlareContentListingObject))
def test_class_conforms_to_IWriteLock(self):
from zope.interface.verify import verifyClass
from webdav.interfaces import IWriteLock
verifyClass(IWriteLock, self._getTargetClass())
def _guessComparisonOperator(self, value):
if isinstance(value, basestring) and '%' in value:
operator = 'like'
else:
operator = SearchKey._guessComparisonOperator(self, value)
return operator
def _renderValueAsSearchText(self, value, operator):
return operator.asSearchText(value)
def buildSearchTextExpression(self, operator, value, column=None):
operator_text = operator.getOperator()
if column is None:
column = self.getColumn()
if operator_text == 'like':
assert isinstance(value, basestring)
assert '%' in value
result = self._renderValueAsSearchText(value, operator)
if len(column):
result = '%s:%s' % (column, result)
else:
result = SearchKey.buildSearchTextExpression(self,
operator,
value,
column=column)
return result
verifyClass(ISearchKey, DefaultKey)
def test_interfaces(self):
from Products.CMFCore.interfaces import ICallableOpaqueItemEvents
from Products.CMFCore.interfaces import IDiscussable
verifyClass(ICallableOpaqueItemEvents, self._getTargetClass())
verifyClass(IDiscussable, self._getTargetClass())
return self.wrapped_query._asSearchTextExpression(sql_catalog,
column=column)
def asSearchTextExpression(self, sql_catalog, column=None):
if self.wrapped_query is None:
self._createWrappedQuery(sql_catalog)
return self.wrapped_query.asSearchTextExpression(sql_catalog,
column=column)
def asSQLExpression(self, sql_catalog, column_map, only_group_columns):
if self.wrapped_query is None:
self._createWrappedQuery(sql_catalog)
return self.wrapped_query.asSQLExpression(
sql_catalog, column_map, only_group_columns=only_group_columns)
def registerColumnMap(self, sql_catalog, column_map):
if self.wrapped_query is None:
self._createWrappedQuery(sql_catalog)
return self.wrapped_query.registerColumnMap(sql_catalog, column_map)
def __repr__(self):
if self.wrapped_query is None:
result = '<%s(operator=%r, **%r) at %s>' % (
self.__class__.__name__, self.operator, self.kw, id(self))
else:
result = '<%s %r>' % (self.__class__.__name__, self.wrapped_query)
return result
verifyClass(IQuery, AutoQuery)
def test_interfaces(self):
from Products.CMFCore.interfaces import ICatalogableDublinCore
from Products.CMFCore.interfaces import IContentish
from Products.CMFCore.interfaces import IDiscussionResponse
from Products.CMFCore.interfaces import IDublinCore
from Products.CMFCore.interfaces import IDynamicType
from Products.CMFCore.interfaces import IMutableDublinCore
from Products.CMFDefault.DiscussionItem import DiscussionItem
verifyClass(ICatalogableDublinCore, DiscussionItem)
verifyClass(IContentish, DiscussionItem)
verifyClass(IDiscussionResponse, DiscussionItem)
verifyClass(IDublinCore, DiscussionItem)
verifyClass(IDynamicType, DiscussionItem)
verifyClass(IMutableDublinCore, DiscussionItem)
def test_interfaces(self):
from Products.CMFCore.DiscussionTool import OldDiscussable
from Products.CMFCore.interfaces import IOldstyleDiscussable
verifyClass(IOldstyleDiscussable, OldDiscussable)