Hide keyboard shortcuts

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

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

import inspect 

import warnings 

from collections import namedtuple 

from operator import attrgetter 

 

import attr 

import six 

 

from ..compat import ascii_escaped 

from ..compat import getfslineno 

from ..compat import MappingMixin 

from ..compat import NOTSET 

from _pytest.outcomes import fail 

 

 

EMPTY_PARAMETERSET_OPTION = "empty_parameter_set_mark" 

 

 

def alias(name, warning=None): 

getter = attrgetter(name) 

 

def warned(self): 

warnings.warn(warning, stacklevel=2) 

return getter(self) 

 

return property(getter if warning is None else warned, doc="alias for " + name) 

 

 

def istestfunc(func): 

return ( 

hasattr(func, "__call__") 

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

) 

 

 

def get_empty_parameterset_mark(config, argnames, func): 

from ..nodes import Collector 

 

requested_mark = config.getini(EMPTY_PARAMETERSET_OPTION) 

if requested_mark in ("", None, "skip"): 

mark = MARK_GEN.skip 

elif requested_mark == "xfail": 

mark = MARK_GEN.xfail(run=False) 

elif requested_mark == "fail_at_collect": 

f_name = func.__name__ 

_, lineno = getfslineno(func) 

raise Collector.CollectError( 

"Empty parameter set in '%s' at line %d" % (f_name, lineno) 

) 

else: 

raise LookupError(requested_mark) 

fs, lineno = getfslineno(func) 

reason = "got empty parameter set %r, function %s at %s:%d" % ( 

argnames, 

func.__name__, 

fs, 

lineno, 

) 

return mark(reason=reason) 

 

 

class ParameterSet(namedtuple("ParameterSet", "values, marks, id")): 

@classmethod 

def param(cls, *values, **kw): 

marks = kw.pop("marks", ()) 

if isinstance(marks, MarkDecorator): 

marks = (marks,) 

else: 

assert isinstance(marks, (tuple, list, set)) 

 

id_ = kw.pop("id", None) 

if id_ is not None: 

if not isinstance(id_, six.string_types): 

raise TypeError( 

"Expected id to be a string, got {}: {!r}".format(type(id_), id_) 

) 

id_ = ascii_escaped(id_) 

return cls(values, marks, id_) 

 

@classmethod 

def extract_from(cls, parameterset, force_tuple=False): 

""" 

:param parameterset: 

a legacy style parameterset that may or may not be a tuple, 

and may or may not be wrapped into a mess of mark objects 

 

:param force_tuple: 

enforce tuple wrapping so single argument tuple values 

don't get decomposed and break tests 

""" 

 

if isinstance(parameterset, cls): 

return parameterset 

if force_tuple: 

return cls.param(parameterset) 

else: 

return cls(parameterset, marks=[], id=None) 

 

@classmethod 

def _for_parametrize(cls, argnames, argvalues, func, config, function_definition): 

if not isinstance(argnames, (tuple, list)): 

argnames = [x.strip() for x in argnames.split(",") if x.strip()] 

force_tuple = len(argnames) == 1 

else: 

force_tuple = False 

parameters = [ 

ParameterSet.extract_from(x, force_tuple=force_tuple) for x in argvalues 

] 

del argvalues 

 

if parameters: 

# check all parameter sets have the correct number of values 

for param in parameters: 

if len(param.values) != len(argnames): 

msg = ( 

'{nodeid}: in "parametrize" the number of names ({names_len}):\n' 

" {names}\n" 

"must be equal to the number of values ({values_len}):\n" 

" {values}" 

) 

fail( 

msg.format( 

nodeid=function_definition.nodeid, 

values=param.values, 

names=argnames, 

names_len=len(argnames), 

values_len=len(param.values), 

), 

pytrace=False, 

) 

else: 

# empty parameter set (likely computed at runtime): create a single 

# parameter set with NOSET values, with the "empty parameter set" mark applied to it 

mark = get_empty_parameterset_mark(config, argnames, func) 

parameters.append( 

ParameterSet(values=(NOTSET,) * len(argnames), marks=[mark], id=None) 

) 

return argnames, parameters 

 

 

@attr.s(frozen=True) 

class Mark(object): 

#: name of the mark 

name = attr.ib(type=str) 

#: positional arguments of the mark decorator 

args = attr.ib() # List[object] 

#: keyword arguments of the mark decorator 

kwargs = attr.ib() # Dict[str, object] 

 

def combined_with(self, other): 

""" 

:param other: the mark to combine with 

:type other: Mark 

:rtype: Mark 

 

combines by appending aargs and merging the mappings 

""" 

assert self.name == other.name 

return Mark( 

self.name, self.args + other.args, dict(self.kwargs, **other.kwargs) 

) 

 

 

@attr.s 

class MarkDecorator(object): 

""" 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. 

 

""" 

 

mark = attr.ib(validator=attr.validators.instance_of(Mark)) 

 

name = alias("mark.name") 

args = alias("mark.args") 

kwargs = alias("mark.kwargs") 

 

@property 

def markname(self): 

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

 

def __eq__(self, other): 

return self.mark == other.mark if isinstance(other, MarkDecorator) else False 

 

def __repr__(self): 

return "<MarkDecorator %r>" % (self.mark,) 

 

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

""" return a MarkDecorator with extra arguments added 

 

unlike call this can be used even if the sole argument is a callable/class 

 

:return: MarkDecorator 

""" 

 

mark = Mark(self.name, args, kwargs) 

return self.__class__(self.mark.combined_with(mark)) 

 

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. """ 

if args and not kwargs: 

func = args[0] 

is_class = inspect.isclass(func) 

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

store_mark(func, self.mark) 

return func 

return self.with_args(*args, **kwargs) 

 

 

def get_unpacked_marks(obj): 

""" 

obtain the unpacked marks that are stored on an object 

""" 

mark_list = getattr(obj, "pytestmark", []) 

if not isinstance(mark_list, list): 

mark_list = [mark_list] 

return normalize_mark_list(mark_list) 

 

 

def normalize_mark_list(mark_list): 

""" 

normalizes marker decorating helpers to mark objects 

 

:type mark_list: List[Union[Mark, Markdecorator]] 

:rtype: List[Mark] 

""" 

extracted = [ 

getattr(mark, "mark", mark) for mark in mark_list 

] # unpack MarkDecorator 

for mark in extracted: 

if not isinstance(mark, Mark): 

raise TypeError("got {!r} instead of Mark".format(mark)) 

return [x for x in extracted if isinstance(x, Mark)] 

 

 

def store_mark(obj, mark): 

"""store a Mark on an object 

this is used to implement the Mark declarations/decorators correctly 

""" 

assert isinstance(mark, Mark), mark 

# always reassign name to avoid updating pytestmark 

# in a reference that was only borrowed 

obj.pytestmark = get_unpacked_marks(obj) + [mark] 

 

 

class MarkGenerator(object): 

""" 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. """ 

 

_config = None 

 

def __getattr__(self, name): 

if name[0] == "_": 

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

if self._config is not None: 

self._check(name) 

return MarkDecorator(Mark(name, (), {})) 

 

def _check(self, name): 

try: 

if name in self._markers: 

return 

except AttributeError: 

pass 

self._markers = values = set() 

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

marker = line.split(":", 1)[0] 

marker = marker.rstrip() 

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

values.add(x) 

if name not in self._markers: 

fail("{!r} not a registered marker".format(name), pytrace=False) 

 

 

MARK_GEN = MarkGenerator() 

 

 

class NodeKeywords(MappingMixin): 

def __init__(self, node): 

self.node = node 

self.parent = node.parent 

self._markers = {node.name: True} 

 

def __getitem__(self, key): 

try: 

return self._markers[key] 

except KeyError: 

if self.parent is None: 

raise 

return self.parent.keywords[key] 

 

def __setitem__(self, key, value): 

self._markers[key] = value 

 

def __delitem__(self, key): 

raise ValueError("cannot delete key in keywords dict") 

 

def __iter__(self): 

seen = self._seen() 

return iter(seen) 

 

def _seen(self): 

seen = set(self._markers) 

if self.parent is not None: 

seen.update(self.parent.keywords) 

return seen 

 

def __len__(self): 

return len(self._seen()) 

 

def __repr__(self): 

return "<NodeKeywords for node %s>" % (self.node,) 

 

 

@attr.s(cmp=False, hash=False) 

class NodeMarkers(object): 

""" 

internal structure for storing marks belonging to a node 

 

..warning:: 

 

unstable api 

 

""" 

 

own_markers = attr.ib(default=attr.Factory(list)) 

 

def update(self, add_markers): 

"""update the own markers 

""" 

self.own_markers.extend(add_markers) 

 

def find(self, name): 

""" 

find markers in own nodes or parent nodes 

needs a better place 

""" 

for mark in self.own_markers: 

if mark.name == name: 

yield mark 

 

def __iter__(self): 

return iter(self.own_markers)