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
|
#!/usr/bin/env python
from jToolkit import prefs
from jToolkit.data import dates
from jToolkit.demo import helloworld
from jToolkit.web import server
from jToolkit.web import session
from jToolkit.web import simplewebserver
sessioncache = session.SessionCache()
def mixedmethod(m):
"""returns a method that can be called either as a class method or as an instance method"""
def internal(*args, **kwargs):
sorc = args[0]
print sorc
return m(*args, **kwargs)
return staticmethod(internal)
def isclassmethod(cls, method):
"""returns whether the given method (accessed as a class attribute) is a classmethod"""
return method.im_self == cls
class ApplicationTester(object):
"""Defines a framework for constructing Application Tests.
Requires staticmethods for setup_ and teardown_ methods
These methods can then be used either ClassWise or MethodWise (see below)
"""
SessionClass = session.Session
@staticmethod
def setup_testframe(self_or_cls):
"""sets up a webserver and application server for this object or class"""
self_or_cls.webserver = self_or_cls.setup_webserver(self_or_cls)
self_or_cls.prefs = self_or_cls.setup_prefs(self_or_cls)
self_or_cls.server = self_or_cls.setup_application(self_or_cls)
if type(self_or_cls) == type:
self_or_cls.server.name = self_or_cls.__name__
else:
self_or_cls.server.name = self_or_cls.__class__.__name__
self_or_cls.instance = self_or_cls.server.instance
self_or_cls.session = self_or_cls.setup_session(self_or_cls)
@staticmethod
def teardown_testframe(self_or_cls):
"""tears down the webserver and application server..."""
self_or_cls.prefs = None
self_or_cls.server = None
self_or_cls.instance = None
self_or_cls.session = None
self_or_cls.webserver = None
@staticmethod
def setup_webserver(self_or_cls):
"""setup the webserver that will be used for the tests"""
return simplewebserver.DummyServer()
@staticmethod
def setup_application(self_or_cls):
"""Returns the application server object"""
raise NotImplemented
@staticmethod
def teardown_application(self_or_cls):
"""tears down the application server object"""
raise NotImplemented
@staticmethod
def setup_session(self_or_cls):
"""sets up the session for the test"""
test_session = self_or_cls.SessionClass(sessioncache, self_or_cls.server)
timestamp = dates.formatdate(dates.currentdate(), '%Y%m%d%H%M%S')
# test_session.create("admin","",timestamp,'en')
test_session.remote_ip = "unit tests..."
return session
@staticmethod
def setup_prefs(self_or_cls):
"""returns a prefs file object"""
return prefs.PrefsParser()
class TestApplicationClassWise:
"""a test class to run tests on a jToolkit application"""
def setup_class(cls):
"""sets up a webserver and application server for this class"""
cls.setup_testframe(cls)
def teardown_class(cls):
"""tears down the webserver and application server..."""
cls.teardown_testframe(cls)
class TestApplicationMethodWise:
"""don't reuse webserver objects between methods"""
def setup_method(self, method):
"""sets up a webserver and jlogbookserver for this method"""
self.setup_testframe(self)
def teardown_method(self, method):
"""sets up a webserver and jlogbookserver for this method"""
self.setup_testframe(self)
def CreateApplicationTester(ApplicationTesterClass, serverperclass):
"""sets up an application tester. If serverperclass is True, uses one server per class, otherwise one per method"""
if serverperclass:
class TestApplication(ApplicationTesterClass, TestApplicationClassWise):
pass
# setup_webserver = classmethod(ApplicationTesterClass.setup_webserver)
# setup_application = classmethod(ApplicationTesterClass.setup_application)
# teardown_application = classmethod(ApplicationTesterClass.teardown_application)
# setup_session = classmethod(ApplicationTesterClass.setup_session)
# setup_prefs = classmethod(ApplicationTesterClass.setup_prefs)
print TestApplication.setup_webserver, ApplicationTesterClass.setup_webserver
TestApplication.setup_webserver(TestApplication)
else:
class TestApplication(ApplicationTesterClass, TestApplicationMethodWise):
pass
return TestApplication
class DemoAppTester(ApplicationTester):
@staticmethod
def setup_application(self_or_cls):
return helloworld.HelloWorldServer(self_or_cls.prefs, self_or_cls.webserver)
def test_demo(self):
assert isinstance(self.server, server.AppServer)
TestDemoAppClassWise = CreateApplicationTester(DemoAppTester, serverperclass=True)
TestDemoAppMethodWise = CreateApplicationTester(DemoAppTester, serverperclass=False)
|
