← Back to branch summary

~ubuntu-branches/ubuntu/wily/nose2/wily

« back to all changes in this revision

Viewing changes to nose2/tests/unit/test_layers_plugin.py

  • Committer: Package Import Robot
  • Author(s): Barry Warsaw
  • Date: 2013-09-09 22:14:45 UTC
  • Revision ID: package-import@ubuntu.com-20130909221445-zdvvvebxfucvavw5
Tags: upstream-0.4.7
Import upstream version 0.4.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
nose2/tests/unit/test_layers_plugin.py
 
1
from nose2.compat import unittest
 
2
from nose2.plugins import layers
 
3
from nose2 import events, loader, session
 
4
from nose2.tests._common import TestCase
 
5
 
 
6
 
 
7
class TestLayers(TestCase):
 
8
    tags = ['unit']
 
9
 
 
10
    def setUp(self):
 
11
        self.session = session.Session()
 
12
        self.loader = loader.PluggableTestLoader(session=self.session)
 
13
        self.session.testLoader = self.loader
 
14
        self.plugin = layers.Layers(session=self.session)
 
15
 
 
16
    def test_simple_layer_inheritance(self):
 
17
        class L1(object):
 
18
            pass
 
19
 
 
20
        class L2(L1):
 
21
            pass
 
22
 
 
23
        class T1(unittest.TestCase):
 
24
            layer = L1
 
25
 
 
26
            def test(self):
 
27
                pass
 
28
 
 
29
        class T2(unittest.TestCase):
 
30
            layer = L2
 
31
 
 
32
            def test(self):
 
33
                pass
 
34
 
 
35
        suite = unittest.TestSuite([T2('test'), T1('test')])
 
36
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
37
        self.plugin.startTestRun(event)
 
38
        expect = [['test (nose2.tests.unit.test_layers_plugin.T1)',
 
39
                   ['test (nose2.tests.unit.test_layers_plugin.T2)']]]
 
40
        self.assertEqual(self.names(event.suite), expect)
 
41
 
 
42
    def test_multiple_inheritance(self):
 
43
        class L1(object):
 
44
            pass
 
45
 
 
46
        class L2(L1):
 
47
            pass
 
48
 
 
49
        class L3(L1):
 
50
            pass
 
51
 
 
52
        class T1(unittest.TestCase):
 
53
            layer = L1
 
54
 
 
55
            def test(self):
 
56
                pass
 
57
 
 
58
        class T2(unittest.TestCase):
 
59
            layer = L2
 
60
 
 
61
            def test(self):
 
62
                pass
 
63
 
 
64
        class T3(unittest.TestCase):
 
65
            layer = L3
 
66
 
 
67
            def test(self):
 
68
                pass
 
69
 
 
70
        suite = unittest.TestSuite([T2('test'), T1('test'), T3('test')])
 
71
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
72
        self.plugin.startTestRun(event)
 
73
        expect = [['test (nose2.tests.unit.test_layers_plugin.T1)',
 
74
                   ['test (nose2.tests.unit.test_layers_plugin.T2)'],
 
75
                   ['test (nose2.tests.unit.test_layers_plugin.T3)']]]
 
76
        self.assertEqual(self.names(event.suite), expect)
 
77
 
 
78
    def test_deep_inheritance(self):
 
79
        class L1(object):
 
80
            pass
 
81
 
 
82
        class L2(L1):
 
83
            pass
 
84
 
 
85
        class L3(L1):
 
86
            pass
 
87
 
 
88
        class L4(L2, L1):
 
89
            pass
 
90
 
 
91
        class L5(L4):
 
92
            pass
 
93
 
 
94
        class T1(unittest.TestCase):
 
95
            layer = L1
 
96
 
 
97
            def test(self):
 
98
                pass
 
99
 
 
100
        class T2(unittest.TestCase):
 
101
            layer = L2
 
102
 
 
103
            def test(self):
 
104
                pass
 
105
 
 
106
        class T3(unittest.TestCase):
 
107
            layer = L3
 
108
 
 
109
            def test(self):
 
110
                pass
 
111
 
 
112
        class T4(unittest.TestCase):
 
113
            layer = L4
 
114
 
 
115
            def test(self):
 
116
                pass
 
117
 
 
118
        class T5(unittest.TestCase):
 
119
            layer = L5
 
120
 
 
121
            def test(self):
 
122
                pass
 
123
 
 
124
        suite = unittest.TestSuite([T2('test'), T1('test'), T3('test'),
 
125
                                    T4('test'), T5('test')])
 
126
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
127
        self.plugin.startTestRun(event)
 
128
        expect = [['test (nose2.tests.unit.test_layers_plugin.T1)',
 
129
                   ['test (nose2.tests.unit.test_layers_plugin.T2)',
 
130
                    ['test (nose2.tests.unit.test_layers_plugin.T4)',
 
131
                     ['test (nose2.tests.unit.test_layers_plugin.T5)']]],
 
132
                   ['test (nose2.tests.unit.test_layers_plugin.T3)']]]
 
133
        self.assertEqual(self.names(event.suite), expect)
 
134
 
 
135
    def test_mixed_layers_no_layers(self):
 
136
        class L1(object):
 
137
            pass
 
138
 
 
139
        class L2(L1):
 
140
            pass
 
141
 
 
142
        class T1(unittest.TestCase):
 
143
            layer = L1
 
144
 
 
145
            def test(self):
 
146
                pass
 
147
 
 
148
        class T2(unittest.TestCase):
 
149
            layer = L2
 
150
 
 
151
            def test(self):
 
152
                pass
 
153
 
 
154
        class T3(unittest.TestCase):
 
155
 
 
156
            def test(self):
 
157
                pass
 
158
 
 
159
        suite = unittest.TestSuite([T2('test'), T1('test'), T3('test')])
 
160
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
161
        self.plugin.startTestRun(event)
 
162
        expect = ['test (nose2.tests.unit.test_layers_plugin.T3)',
 
163
                  ['test (nose2.tests.unit.test_layers_plugin.T1)',
 
164
                   ['test (nose2.tests.unit.test_layers_plugin.T2)']]]
 
165
        self.assertEqual(self.names(event.suite), expect)
 
166
 
 
167
    def test_ordered_layers(self):
 
168
        class L1(object):
 
169
            pass
 
170
 
 
171
        class L2(L1):
 
172
            position = 1
 
173
 
 
174
        class L3(L1):
 
175
            position = 2
 
176
 
 
177
        class L4(L1):
 
178
            position = 3
 
179
 
 
180
        class L5(L2):
 
181
            position = 4
 
182
 
 
183
        class T1(unittest.TestCase):
 
184
            layer = L1
 
185
 
 
186
            def test(self):
 
187
                pass
 
188
 
 
189
        class T2(unittest.TestCase):
 
190
            layer = L2
 
191
 
 
192
            def test(self):
 
193
                pass
 
194
 
 
195
        class T3(unittest.TestCase):
 
196
            layer = L3
 
197
 
 
198
            def test(self):
 
199
                pass
 
200
 
 
201
        class T4(unittest.TestCase):
 
202
            layer = L4
 
203
 
 
204
            def test(self):
 
205
                pass
 
206
 
 
207
        class T5(unittest.TestCase):
 
208
            layer = L5
 
209
 
 
210
            def test(self):
 
211
                pass
 
212
        suite = unittest.TestSuite([T2('test'), T1('test'),
 
213
                                    T3('test'), T4('test'), T5('test')])
 
214
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
215
        self.plugin.startTestRun(event)
 
216
        expect = [['test (nose2.tests.unit.test_layers_plugin.T1)',
 
217
                   ['test (nose2.tests.unit.test_layers_plugin.T2)',
 
218
                    ['test (nose2.tests.unit.test_layers_plugin.T5)', ]],
 
219
                   ['test (nose2.tests.unit.test_layers_plugin.T3)', ],
 
220
                   ['test (nose2.tests.unit.test_layers_plugin.T4)', ]]]
 
221
        self.assertEqual(self.names(event.suite), expect)
 
222
 
 
223
    def test_mixin_inheritance(self):
 
224
        class L1(object):
 
225
            pass
 
226
 
 
227
        class L2(object):  # a mixin, doesn't share a base w/L1
 
228
            pass
 
229
 
 
230
        class L3(L1):
 
231
            pass
 
232
 
 
233
        class L4(L3):
 
234
            pass
 
235
 
 
236
        class L5(L4):
 
237
            pass
 
238
 
 
239
        class L6(L2):
 
240
            mixins = (L4,)
 
241
 
 
242
        class T1(unittest.TestCase):
 
243
            layer = L1
 
244
 
 
245
            def test(self):
 
246
                pass
 
247
 
 
248
        class T3(unittest.TestCase):
 
249
            layer = L3
 
250
 
 
251
            def test(self):
 
252
                pass
 
253
 
 
254
        class T4(unittest.TestCase):
 
255
            layer = L4
 
256
 
 
257
            def test(self):
 
258
                pass
 
259
 
 
260
        class T5(unittest.TestCase):
 
261
            layer = L5
 
262
 
 
263
            def test(self):
 
264
                pass
 
265
 
 
266
        class T6(unittest.TestCase):
 
267
            layer = L6
 
268
 
 
269
            def test(self):
 
270
                pass
 
271
        suite = unittest.TestSuite([T6('test'), T1('test'),
 
272
                                    T3('test'), T4('test'), T5('test')])
 
273
        event = events.StartTestRunEvent(None, suite, None, 0, None)
 
274
        self.plugin.startTestRun(event)
 
275
        expect = [['test (nose2.tests.unit.test_layers_plugin.T1)',
 
276
                   ['test (nose2.tests.unit.test_layers_plugin.T3)',
 
277
                    ['test (nose2.tests.unit.test_layers_plugin.T4)',
 
278
                     [['test (nose2.tests.unit.test_layers_plugin.T6)']],
 
279
                 ['test (nose2.tests.unit.test_layers_plugin.T5)', ]]]]]
 
280
        self.assertEqual(self.names(event.suite), expect)
 
281
 
 
282
    def names(self, suite):
 
283
        return [n for n in self.iternames(suite)]
 
284
 
 
285
    def iternames(self, suite):
 
286
        for t in suite:
 
287
            if isinstance(t, unittest.TestCase):
 
288
                yield str(t)
 
289
            else:
 
290
                yield [n for n in self.iternames(t)]
 
291
 
 
292
    def _listset(self, l):
 
293
        n = set([])
 
294
        for t in l:
 
295
            if isinstance(t, list):
 
296
                n.add(self._listset(t))
 
297
            else:
 
298
                n.add(t)
 
299
        return frozenset(n)