aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/python/pytest/py2/_pytest/assertion/__init__.py
blob: f5e0972876cde101e08b9c7be27f83518f77d5bb (plain) (blame)
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
# -*- coding: utf-8 -*-
""" 
support for presenting detailed information in failing assertions. 
""" 
from __future__ import absolute_import 
from __future__ import division 
from __future__ import print_function 
 
import sys 
 
import six 
 
from _pytest.assertion import rewrite 
from _pytest.assertion import truncate 
from _pytest.assertion import util 
 
 
def pytest_addoption(parser): 
    group = parser.getgroup("debugconfig") 
    group.addoption( 
        "--assert", 
        action="store", 
        dest="assertmode", 
        choices=("rewrite", "plain"), 
        default="rewrite", 
        metavar="MODE", 
        help="""Control assertion debugging tools.  'plain' 
                            performs no assertion debugging.  'rewrite' 
                            (the default) rewrites assert statements in 
                            test modules on import to provide assert 
                            expression information.""", 
    ) 
 
 
def register_assert_rewrite(*names): 
    """Register one or more module names to be rewritten on import. 
 
    This function will make sure that this module or all modules inside 
    the package will get their assert statements rewritten. 
    Thus you should make sure to call this before the module is 
    actually imported, usually in your __init__.py if you are a plugin 
    using a package. 
 
    :raise TypeError: if the given module names are not strings. 
    """ 
    for name in names: 
        if not isinstance(name, str): 
            msg = "expected module names as *args, got {0} instead" 
            raise TypeError(msg.format(repr(names))) 
    for hook in sys.meta_path: 
        if isinstance(hook, rewrite.AssertionRewritingHook): 
            importhook = hook 
            break 
    else: 
        importhook = DummyRewriteHook() 
    importhook.mark_rewrite(*names) 
 
 
class DummyRewriteHook(object): 
    """A no-op import hook for when rewriting is disabled.""" 
 
    def mark_rewrite(self, *names): 
        pass 
 
 
class AssertionState(object): 
    """State for the assertion plugin.""" 
 
    def __init__(self, config, mode): 
        self.mode = mode 
        self.trace = config.trace.root.get("assertion") 
        self.hook = None 
 
 
def install_importhook(config): 
    """Try to install the rewrite hook, raise SystemError if it fails.""" 
    # Jython has an AST bug that make the assertion rewriting hook malfunction. 
    if sys.platform.startswith("java"): 
        raise SystemError("rewrite not supported") 
 
    config._assertstate = AssertionState(config, "rewrite") 
    config._assertstate.hook = hook = rewrite.AssertionRewritingHook(config) 
    sys.meta_path.insert(0, hook) 
    config._assertstate.trace("installed rewrite import hook") 
 
    def undo(): 
        hook = config._assertstate.hook 
        if hook is not None and hook in sys.meta_path: 
            sys.meta_path.remove(hook) 
 
    config.add_cleanup(undo) 
    return hook 
 
 
def pytest_collection(session): 
    # this hook is only called when test modules are collected 
    # so for example not in the master process of pytest-xdist 
    # (which does not collect test modules) 
    assertstate = getattr(session.config, "_assertstate", None) 
    if assertstate: 
        if assertstate.hook is not None: 
            assertstate.hook.set_session(session) 
 
 
def pytest_runtest_setup(item): 
    """Setup the pytest_assertrepr_compare hook 
 
    The newinterpret and rewrite modules will use util._reprcompare if 
    it exists to use custom reporting via the 
    pytest_assertrepr_compare hook.  This sets up this custom 
    comparison for the test. 
    """ 
 
    def callbinrepr(op, left, right): 
        """Call the pytest_assertrepr_compare hook and prepare the result 
 
        This uses the first result from the hook and then ensures the 
        following: 
        * Overly verbose explanations are truncated unless configured otherwise 
          (eg. if running in verbose mode). 
        * Embedded newlines are escaped to help util.format_explanation() 
          later. 
        * If the rewrite mode is used embedded %-characters are replaced 
          to protect later % formatting. 
 
        The result can be formatted by util.format_explanation() for 
        pretty printing. 
        """ 
        hook_result = item.ihook.pytest_assertrepr_compare( 
            config=item.config, op=op, left=left, right=right 
        ) 
        for new_expl in hook_result: 
            if new_expl: 
                new_expl = truncate.truncate_if_required(new_expl, item) 
                new_expl = [line.replace("\n", "\\n") for line in new_expl] 
                res = six.text_type("\n~").join(new_expl) 
                if item.config.getvalue("assertmode") == "rewrite": 
                    res = res.replace("%", "%%") 
                return res 
 
    util._reprcompare = callbinrepr 
 
 
def pytest_runtest_teardown(item): 
    util._reprcompare = None 
 
 
def pytest_sessionfinish(session): 
    assertstate = getattr(session.config, "_assertstate", None) 
    if assertstate: 
        if assertstate.hook is not None: 
            assertstate.hook.set_session(None) 
 
 
# Expose this plugin's implementation for the pytest_assertrepr_compare hook 
pytest_assertrepr_compare = util.assertrepr_compare