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
|
# Authors:
# Petr Viktorin <pviktori@redhat.com>
#
# Copyright (C) 2013 Red Hat
# see file 'COPYING' for use and warranty information
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""A Nose plugin that allows ordered test cases"""
import os
import unittest
import inspect
from nose.plugins import Plugin
import nose.loader
import nose.util
def ordered(cls):
"""Decorator that marks a test class as ordered
Methods within the marked class will be executed in definition order
(or more strictly, in ordered by the line number where they're defined).
Subclasses of unittest.TestCase can not be ordered.
Generator methods will not be ordered by this plugin.
"""
cls._order_plugin__ordered = True
assert not isinstance(cls, unittest.TestCase), (
"A unittest.TestCase may not be ordered.")
return cls
class OrderTests(Plugin):
name = 'ordered-tests'
def options(self, parser, env=os.environ):
super(OrderTests, self).options(parser, env=env)
def configure(self, options, conf):
super(OrderTests, self).configure(options, conf)
if not self.enabled:
return
def loadTestsFromTestClass(self, cls):
"""Sort methods of ordered test cases by co_firstlineno"""
if not getattr(cls, '_order_plugin__ordered', False):
return
loader = nose.loader.TestLoader()
def wanted(attr):
item = getattr(cls, attr, None)
if not inspect.ismethod(item):
return False
if nose.util.isgenerator(item.im_func):
return False
return loader.selector.wantMethod(item)
def sort_with_respect_to_overriding(func):
"""
Sorts the methods in respect with the parent classes.
The methods are sorted with respect to the inheritance chain,
methods that were defined in the same class are sorted by the line
number on which they were defined.
"""
# Check each *ordered* class in MRO for definition of func method
for i, parent_class in enumerate(reversed(cls.mro())):
if getattr(parent_class, '_order_plugin__ordered', False):
method = getattr(parent_class, func.__name__, None)
if method:
# This sorts methods as tuples (position of the class
# in the inheritance chain, position of the method
# within that class)
return 0, i, method.func_code.co_firstlineno
# Weird case fallback
# Method name not in any of the classes in MRO, run it last
return 1, func.func_code.co_firstlineno
methods = [getattr(cls, case) for case in dir(cls) if wanted(case)]
methods.sort(key=sort_with_respect_to_overriding)
cases = [loader.makeTest(m, cls) for m in methods]
return cases
def wantMethod(self, method):
"""Hide non-TestCase methods from the normal loader"""
im_class = getattr(method, 'im_class', None)
if im_class and getattr(im_class, '_order_plugin__ordered', False):
if nose.util.isgenerator(method.im_func):
return True
return False
|
