Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

""" generic mechanism for marking and selecting python functions. """ 

import inspect 

 

 

class MarkerError(Exception): 

 

    """Error in use of a pytest marker/attribute.""" 

 

 

def pytest_namespace(): 

    return {'mark': MarkGenerator()} 

 

 

def pytest_addoption(parser): 

    group = parser.getgroup("general") 

    group._addoption( 

        '-k', 

        action="store", dest="keyword", default='', metavar="EXPRESSION", 

        help="only run tests which match the given substring expression. " 

             "An expression is a python evaluatable expression " 

             "where all names are substring-matched against test names " 

             "and their parent classes. Example: -k 'test_method or test " 

             "other' matches all test functions and classes whose name " 

             "contains 'test_method' or 'test_other'. " 

             "Additionally keywords are matched to classes and functions " 

             "containing extra names in their 'extra_keyword_matches' set, " 

             "as well as functions which have names assigned directly to them." 

    ) 

 

    group._addoption( 

        "-m", 

        action="store", dest="markexpr", default="", metavar="MARKEXPR", 

        help="only run tests matching given mark expression.  " 

             "example: -m 'mark1 and not mark2'." 

    ) 

 

    group.addoption( 

        "--markers", action="store_true", 

        help="show markers (builtin, plugin and per-project ones)." 

    ) 

 

    parser.addini("markers", "markers for test functions", 'linelist') 

 

 

def pytest_cmdline_main(config): 

    import _pytest.config 

48    if config.option.markers: 

        config._do_configure() 

        tw = _pytest.config.create_terminal_writer(config) 

        for line in config.getini("markers"): 

            name, rest = line.split(":", 1) 

            tw.write("@pytest.mark.%s:" % name, bold=True) 

            tw.line(rest) 

            tw.line() 

        config._ensure_unconfigure() 

        return 0 

pytest_cmdline_main.tryfirst = True 

 

 

def pytest_collection_modifyitems(items, config): 

    keywordexpr = config.option.keyword 

    matchexpr = config.option.markexpr 

68    if not keywordexpr and not matchexpr: 

        return 

    # pytest used to allow "-" for negating 

    # but today we just allow "-" at the beginning, use "not" instead 

    # we probably remove "-" alltogether soon 

    if keywordexpr.startswith("-"): 

        keywordexpr = "not " + keywordexpr[1:] 

    selectuntil = False 

    if keywordexpr[-1:] == ":": 

        selectuntil = True 

        keywordexpr = keywordexpr[:-1] 

 

    remaining = [] 

    deselected = [] 

    for colitem in items: 

        if keywordexpr and not matchkeyword(colitem, keywordexpr): 

            deselected.append(colitem) 

        else: 

            if selectuntil: 

                keywordexpr = None 

            if matchexpr: 

                if not matchmark(colitem, matchexpr): 

                    deselected.append(colitem) 

                    continue 

            remaining.append(colitem) 

 

    if deselected: 

        config.hook.pytest_deselected(items=deselected) 

        items[:] = remaining 

 

 

class MarkMapping: 

    """Provides a local mapping for markers where item access 

    resolves to True if the marker is present. """ 

    def __init__(self, keywords): 

        mymarks = set() 

        for key, value in keywords.items(): 

            if isinstance(value, MarkInfo) or isinstance(value, MarkDecorator): 

                mymarks.add(key) 

        self._mymarks = mymarks 

 

    def __getitem__(self, name): 

        return name in self._mymarks 

 

 

class KeywordMapping: 

    """Provides a local mapping for keywords. 

    Given a list of names, map any substring of one of these names to True. 

    """ 

    def __init__(self, names): 

        self._names = names 

 

    def __getitem__(self, subname): 

        for name in self._names: 

            if subname in name: 

                return True 

        return False 

 

 

def matchmark(colitem, markexpr): 

    """Tries to match on any marker names, attached to the given colitem.""" 

    return eval(markexpr, {}, MarkMapping(colitem.keywords)) 

 

 

def matchkeyword(colitem, keywordexpr): 

    """Tries to match given keyword expression to given collector item. 

 

    Will match on the name of colitem, including the names of its parents. 

    Only matches names of items which are either a :class:`Class` or a 

    :class:`Function`. 

    Additionally, matches on names in the 'extra_keyword_matches' set of 

    any item, as well as names directly assigned to test functions. 

    """ 

    mapped_names = set() 

 

    # Add the names of the current item and any parent items 

    import pytest 

    for item in colitem.listchain(): 

        if not isinstance(item, pytest.Instance): 

            mapped_names.add(item.name) 

 

    # Add the names added as extra keywords to current or parent items 

    for name in colitem.listextrakeywords(): 

        mapped_names.add(name) 

 

    # Add the names attached to the current function through direct assignment 

    if hasattr(colitem, 'function'): 

        for name in colitem.function.__dict__: 

            mapped_names.add(name) 

 

    mapping = KeywordMapping(mapped_names) 

    if " " not in keywordexpr: 

        # special case to allow for simple "-k pass" and "-k 1.3" 

        return mapping[keywordexpr] 

    elif keywordexpr.startswith("not ") and " " not in keywordexpr[4:]: 

        return not mapping[keywordexpr[4:]] 

    return eval(keywordexpr, {}, mapping) 

 

 

def pytest_configure(config): 

    import pytest 

165    if config.option.strict: 

        pytest.mark._config = config 

 

 

class MarkGenerator: 

    """ Factory for :class:`MarkDecorator` objects - exposed as 

    a ``pytest.mark`` singleton instance.  Example:: 

 

         import pytest 

         @pytest.mark.slowtest 

         def test_function(): 

            pass 

 

    will set a 'slowtest' :class:`MarkInfo` object 

    on the ``test_function`` object. """ 

 

    def __getattr__(self, name): 

        if name[0] == "_": 

            raise AttributeError("Marker name must NOT start with underscore") 

184        if hasattr(self, '_config'): 

            self._check(name) 

        return MarkDecorator(name) 

 

    def _check(self, name): 

        try: 

            if name in self._markers: 

                return 

        except AttributeError: 

            pass 

        self._markers = l = set() 

        for line in self._config.getini("markers"): 

            beginning = line.split(":", 1) 

            x = beginning[0].split("(", 1)[0] 

            l.add(x) 

        if name not in self._markers: 

            raise AttributeError("%r not a registered marker" % (name,)) 

 

def istestfunc(func): 

    return hasattr(func, "__call__") and \ 

        getattr(func, "__name__", "<lambda>") != "<lambda>" 

 

class MarkDecorator: 

    """ A decorator for test functions and test classes.  When applied 

    it will create :class:`MarkInfo` objects which may be 

    :ref:`retrieved by hooks as item keywords <excontrolskip>`. 

    MarkDecorator instances are often created like this:: 

 

        mark1 = pytest.mark.NAME              # simple MarkDecorator 

        mark2 = pytest.mark.NAME(name1=value) # parametrized MarkDecorator 

 

    and can then be applied as decorators to test functions:: 

 

        @mark2 

        def test_function(): 

            pass 

 

    When a MarkDecorator instance is called it does the following: 

      1. If called with a single class as its only positional argument and no 

         additional keyword arguments, it attaches itself to the class so it 

         gets applied automatically to all test cases found in that class. 

      2. If called with a single function as its only positional argument and 

         no additional keyword arguments, it attaches a MarkInfo object to the 

         function, containing all the arguments already stored internally in 

         the MarkDecorator. 

      3. When called in any other case, it performs a 'fake construction' call, 

         i.e. it returns a new MarkDecorator instance with the original 

         MarkDecorator's content updated with the arguments passed to this 

         call. 

 

    Note: The rules above prevent MarkDecorator objects from storing only a 

    single function or class reference as their positional argument with no 

    additional keyword or positional arguments. 

 

    """ 

    def __init__(self, name, args=None, kwargs=None): 

        self.name = name 

        self.args = args or () 

        self.kwargs = kwargs or {} 

 

    @property 

    def markname(self): 

        return self.name # for backward-compat (2.4.1 had this attr) 

 

    def __repr__(self): 

        d = self.__dict__.copy() 

        name = d.pop('name') 

        return "<MarkDecorator %r %r>" % (name, d) 

 

    def __call__(self, *args, **kwargs): 

        """ if passed a single callable argument: decorate it with mark info. 

            otherwise add *args/**kwargs in-place to mark information. """ 

280        if args and not kwargs: 

            func = args[0] 

            is_class = inspect.isclass(func) 

280            if len(args) == 1 and (istestfunc(func) or is_class): 

260                if is_class: 

                    if hasattr(func, 'pytestmark'): 

                        mark_list = func.pytestmark 

                        if not isinstance(mark_list, list): 

                            mark_list = [mark_list] 

                        # always work on a copy to avoid updating pytestmark 

                        # from a superclass by accident 

                        mark_list = mark_list + [self] 

                        func.pytestmark = mark_list 

                    else: 

                        func.pytestmark = [self] 

                else: 

                    holder = getattr(func, self.name, None) 

278                    if holder is None: 

                        holder = MarkInfo( 

                            self.name, self.args, self.kwargs 

                        ) 

                        setattr(func, self.name, holder) 

                    else: 

                        holder.add(self.args, self.kwargs) 

                return func 

        kw = self.kwargs.copy() 

        kw.update(kwargs) 

        args = self.args + args 

        return self.__class__(self.name, args=args, kwargs=kw) 

 

 

class MarkInfo: 

    """ Marking object created by :class:`MarkDecorator` instances. """ 

    def __init__(self, name, args, kwargs): 

        #: name of attribute 

        self.name = name 

        #: positional argument list, empty if none specified 

        self.args = args 

        #: keyword argument dictionary, empty if nothing specified 

        self.kwargs = kwargs.copy() 

        self._arglist = [(args, kwargs.copy())] 

 

    def __repr__(self): 

        return "<MarkInfo %r args=%r kwargs=%r>" % ( 

            self.name, self.args, self.kwargs 

        ) 

 

    def add(self, args, kwargs): 

        """ add a MarkInfo with the given args and kwargs. """ 

        self._arglist.append((args, kwargs)) 

        self.args += args 

        self.kwargs.update(kwargs) 

 

    def __iter__(self): 

        """ yield MarkInfo objects each relating to a marking-call. """ 

        for args, kwargs in self._arglist: 

            yield MarkInfo(self.name, args, kwargs)