1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
|
#
# interface testing suite
#
import os, sys
if __name__ == '__main__':
execfile(os.path.join(sys.path[0], 'framework.py'))
from Testing import ZopeTestCase
import traceback
from types import TupleType, TypeType, ClassType
from zope.interface.interface import InterfaceClass
from ExtensionClass import ExtensionClass
from Interface.Implements import getImplementsOfInstances
from Interface.Implements import getImplements, flattenInterfaces
from Interface.Verify import verifyClass, verifyObject
from Interface.Exceptions import BrokenImplementation, DoesNotImplement
from Interface.Exceptions import BrokenMethodImplementation
###############################################################################
### import classes and interfaces for testing ###
###############################################################################
from Products.CMFPlone.ActionIconsTool import ActionIconsTool
from Products.CMFPlone.ActionsTool import ActionsTool
from Products.CMFPlone.CalendarTool import CalendarTool
from Products.CMFPlone.CatalogTool import CatalogTool
from Products.CMFPlone.CustomizationPolicy import DefaultCustomizationPolicy
from Products.CMFPlone.DiscussionTool import DiscussionTool
from Products.CMFPlone.FactoryTool import FactoryTool, TempFolder
from Products.CMFPlone.GroupDataTool import GroupDataTool
from Products.CMFPlone.GroupsTool import GroupsTool
from Products.CMFPlone.InterfaceTool import InterfaceTool
from Products.CMFPlone.LargePloneFolder import LargePloneFolder
from Products.CMFPlone.MemberDataTool import MemberDataTool, MemberData
from Products.CMFPlone.MembershipTool import MembershipTool
from Products.CMFPlone.MetadataTool import MetadataTool
from Products.CMFPlone.MigrationTool import MigrationTool
from Products.CMFPlone.PloneContent import PloneContent
from Products.CMFPlone.PloneControlPanel import PloneControlPanel, PloneConfiglet
from Products.CMFPlone.PloneFolder import OrderedContainer, BasePloneFolder, PloneFolder
from Products.CMFPlone.PloneTool import PloneTool
from Products.CMFPlone.Portal import PloneSite
from Products.CMFPlone.PropertiesTool import PropertiesTool, SimpleItemWithProperties
from Products.CMFPlone.QuickInstallerTool import QuickInstallerTool
from Products.CMFPlone.RegistrationTool import RegistrationTool
from Products.CMFPlone.SkinsTool import SkinsTool
from Products.CMFPlone.SyndicationTool import SyndicationTool
from Products.CMFPlone.TypesTool import TypesTool
from Products.CMFPlone.UndoTool import UndoTool
from Products.CMFPlone.URLTool import URLTool
from Products.CMFPlone.WorkflowTool import WorkflowTool
def className(klass):
""" get the short class name """
if not isinstance(klass, (TypeType, ClassType,
ExtensionClass, InterfaceClass)):
# Looks like an instance, get it's class.
if hasattr(klass, '__class__'):
klass = klass.__class__
return klass.__name__
def dottedName(klass):
return "%s.%s" % (klass.__module__, klass.__name__)
# list of tests
tests = []
class InterfaceTest(ZopeTestCase.ZopeTestCase):
"""general interface testing class
klass - the class object to test
forcedImpl - a list of interface class objects that the class klass
*must* implement to fullfil this test
This test class doesn't implement a test* method so you have to provide
a test method in your implementation. See above for two examples. One
example uses the special magic of setattr::
setattr(MyClass, MyMethodName, lambda self: self._testStuff())
"""
_setup_fixture = 0 # No default fixture
klass = None # test this class
instance = None # test this instance
forcedImpl = () # class must implement this tuple of interfaces
def interfaceImplementedByInstanceOf(self, klass, interface):
""" tests if the klass implements the interface in the right way """
from Interface.Verify import verifyClass
from Interface.Exceptions import BrokenImplementation, DoesNotImplement
from Interface.Exceptions import BrokenMethodImplementation
# is the class really implemented by the given interface?
self.failUnless(interface.isImplementedByInstancesOf(klass),
'The class %s does not implement %s' % (dottedName(klass),
dottedName(interface)))
# verify if the implementation is correct
try:
verifyClass(interface, klass)
except (BrokenImplementation, DoesNotImplement,
BrokenMethodImplementation), errmsg:
self.fail('The class %s does not implement %s correctly: \n%s'
% (dottedName(klass), dottedName(interface), errmsg))
except AttributeError, errmsg:
self.fail('There was a problem while checking the implementation of '
'class %s and interface %s: \nAttributeError %s\n%s'
% (dottedName(klass), dottedName(interface), errmsg,
''.join(traceback.format_tb(sys.exc_traceback))))
def interfaceImplementedBy(self, instance, interface):
""" tests if the instance implements the interface in the right way """
from Interface.Verify import verifyObject
from Interface.Exceptions import BrokenImplementation, DoesNotImplement
from Interface.Exceptions import BrokenMethodImplementation
# is the class really implemented by the given interface?
self.failUnless(interface.isImplementedBy(instance),
'The instance of %s does not implement %s' % (dottedName(instance),
dottedName(interface)))
# verify if the implementation is correct
try:
verifyObject(interface, instance)
except (BrokenImplementation, DoesNotImplement,
BrokenMethodImplementation), errmsg:
self.fail('The instance of %s does not implement %s correctly: \n%s'
% (dottedName(instance), dottedName(interface), errmsg))
def getImplementsOfInstanceOf(self, klass):
""" returns the interfaces implemented by the klass (flat)"""
from Interface.Implements import getImplementsOfInstances, flattenInterfaces
impl = getImplementsOfInstances(klass)
if type(impl) is not TupleType:
impl = (impl,)
if impl:
return flattenInterfaces(impl)
def getImplementsOf(self, instance):
""" returns the interfaces implemented by the instance (flat)"""
from Interface.Implements import getImplements, flattenInterfaces
impl = getImplements(instance)
if type(impl) is not TupleType:
impl = (impl,)
if impl:
return flattenInterfaces(impl)
def doesImplementByInstanceOf(self, klass, interfaces):
""" make sure that the klass implements at least these interfaces"""
if type(interfaces) is not TupleType:
interfaces = (interfaces)
impl = self.getImplementsOfInstanceOf(klass)
for interface in interfaces:
self.failUnless(
interface in impl,
'The class %s does not implement %s' % (dottedName(klass),
dottedName(interface)))
def doesImplementBy(self, instance, interfaces):
""" make sure that the klass implements at least these interfaces"""
if type(interfaces) is not TupleType:
interfaces = (interfaces)
impl = self.getImplementsOf(instance)
for interface in interfaces:
self.failUnless(
interface in impl,
'The instance of %s does not implement %s' % (dottedName(instance),
dottedName(interface)))
def _testStuff(self):
""" test self.klass and self.instance """
if self.klass:
if self.forcedImpl:
self.doesImplementByInstanceOf(self.klass, self.forcedImpl)
for iface in self.getImplementsOfInstanceOf(self.klass):
self.interfaceImplementedByInstanceOf(self.klass, iface)
if self.instance:
if self.forcedImpl:
self.doesImplementBy(self.instance, self.forcedImpl)
for iface in self.getImplementsOf(self.instance):
self.interfaceImplementedBy(self.instance, iface)
class zope_interface_test(ZopeTestCase.ZopeTestCase):
"""general zope.interface testing class
klass - the class object to test
forcedImpl - a list of interface class objects that the class klass
*must* implement to fullfil this test
This test class doesn't implement a test* method so you have to provide
a test method in your implementation. See above for two examples. One
example uses the special magic of setattr::
setattr(MyClass, MyMethodName, lambda self: self._testStuff())
"""
_setup_fixture = 0 # No default fixture
klass = None # test this class
instance = None # test this instance
forcedImpl = () # class must implement this tuple of interfaces
def interfaceImplementedBy(self, klass, interface):
""" tests if the klass implements the interface in the right way """
from zope.interface.verify import verifyClass
from zope.interface.exceptions import BrokenImplementation, DoesNotImplement
from zope.interface.exceptions import BrokenMethodImplementation
# is the class really implemented by the given interface?
self.failUnless(interface.implementedBy(klass),
'The class %s does not implement %s' % (dottedName(klass),
dottedName(interface)))
# verify if the implementation is correct
try:
verifyClass(interface, klass)
except (BrokenImplementation, DoesNotImplement,
BrokenMethodImplementation), errmsg:
self.fail('The class %s does not implement %s correctly: \n%s'
% (dottedName(klass), dottedName(interface), errmsg))
except AttributeError, errmsg:
self.fail('There was a problem while checking the implementation of '
'class %s and interface %s: \nAttributeError %s\n%s'
% (dottedName(klass), dottedName(interface), errmsg,
''.join(traceback.format_tb(sys.exc_traceback))))
def interfaceProvidedBy(self, instance, interface):
""" tests if the instance implements the interface in the right way """
from zope.interface.verify import verifyObject
from zope.interface.exceptions import BrokenImplementation, DoesNotImplement
from zope.interface.exceptions import BrokenMethodImplementation
# is the class really implemented by the given interface?
self.failUnless(interface.providedBy(instance),
'The instance of %s does not provide %s' % (dottedName(instance),
dottedName(interface)))
# verify if the implementation is correct
try:
verifyObject(interface, instance)
except (BrokenImplementation, DoesNotImplement,
BrokenMethodImplementation), errmsg:
self.fail('The instance of %s does not provide %s correctly: \n%s'
% (dottedName(instance), dottedName(interface), errmsg))
def getImplementedBy(self, klass):
""" returns the interfaces implemented by the klass (flat)"""
from zope.interface import implementedBy
return implementedBy(klass)
def getProvidedBy(self, instance):
""" returns the interfaces implemented by the instance (flat)"""
from zope.interface import providedBy
return providedBy(instance)
def doesImplementedBy(self, klass, interfaces):
""" make sure that the klass implements at least these interfaces"""
impl = self.getImplementedBy(klass)
for interface in interfaces:
self.failUnless(
interface in impl,
'The class %s does not implement %s' % (dottedName(klass),
dottedName(interface)))
def doesProvidedBy(self, instance, interfaces):
""" make sure that the klass implements at least these interfaces"""
impl = self.getProvidedBy(instance)
for interface in interfaces:
self.failUnless(
interface in impl,
'The instance of %s does not provide %s' % (dottedName(instance),
dottedName(interface)))
def _testStuff(self):
""" test self.klass and self.instance """
if self.klass:
if self.forcedImpl:
self.doesImplementedBy(self.klass, self.forcedImpl)
for iface in self.getImplementedBy(self.klass):
self.interfaceImplementedBy(self.klass, iface)
if self.instance:
if self.forcedImpl:
self.doesProvidedBy(self.instance, self.forcedImpl)
for iface in self.getProvidedBy(self.instance):
self.interfaceProvidedBy(self.instance, iface)
###############################################################################
### testing starts here ###
###############################################################################
# format: (class object, (list interface objects))
testClasses = [
(ActionIconsTool, ()),
(ActionsTool, ()),
(CalendarTool, ()),
(CatalogTool, ()),
(DefaultCustomizationPolicy, ()),
(DiscussionTool, ()),
(FactoryTool, ()), (TempFolder, ()),
(GroupDataTool, ()),
(GroupsTool, ()),
(InterfaceTool, ()),
(LargePloneFolder, ()),
(MemberDataTool, ()), (MemberData, ()),
(MembershipTool, ()),
(MetadataTool, ()),
(MigrationTool, ()),
(PloneContent, ()),
(PloneControlPanel, ()), (PloneConfiglet, ()),
(OrderedContainer, ()), (BasePloneFolder, ()), (PloneFolder, ()),
(PloneTool, ()),
(PloneSite, ()),
(PropertiesTool, ()), (SimpleItemWithProperties, ()),
(QuickInstallerTool, ()),
(RegistrationTool, ()),
(SkinsTool, ()),
(SyndicationTool, ()),
(TypesTool, ()),
(UndoTool, ()),
(URLTool, ()),
(WorkflowTool, ()),
]
# format: (instance object, (list interface objects))
# take care: you must provide an instance, not a class!
testInstances = [
# (, ()),
]
for testClass in testClasses:
klass, forcedImpl = testClass
name = className(klass)
funcName = 'test%sInterface' % name
class KlassInterfaceTest(InterfaceTest):
""" implementation for %s """ % name
klass = klass
forcedImpl = forcedImpl
# add the testing method to the class to get a nice name
setattr(KlassInterfaceTest, funcName, lambda self: self._testStuff())
tests.append(KlassInterfaceTest)
class KlassInterfaceTest(zope_interface_test):
""" implementation for %s """ % name
klass = klass
forcedImpl = forcedImpl
# add the testing method to the class to get a nice name
setattr(KlassInterfaceTest, funcName, lambda self: self._testStuff())
tests.append(KlassInterfaceTest)
for testInstance in testInstances:
instance, forcedImpl = testInstance
name = className(instance)
funcName = 'test%sInterface' % name
class InstanceInterfaceTest(InterfaceTest):
""" implementation for %s """ % name
instance = instance
forcedImpl = forcedImpl
# add the testing method to the class to get a nice name
setattr(InstanceInterfaceTest, funcName, lambda self: self._testStuff())
tests.append(InstanceInterfaceTest)
class InstanceInterfaceTest(zope_interface_test):
""" implementation for %s """ % name
instance = instance
forcedImpl = forcedImpl
import unittest
def test_suite():
suite = unittest.TestSuite()
for test in tests:
suite.addTest(unittest.makeSuite(test))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
|
