tests.test_predicate_str_repr() - Code Metrics - Inspection of "Fix Event.locals." - ionelmc/python-hunter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4e3b27...2dc96c )

by Ionel Cristian

created 2015-12-20 14:53 UTC

tests.test_predicate_str_repr() D

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	21
rs	4.2367
cc	17

How to fix Complexity

from __future__ import print_function

import inspect
import os
import subprocess
import sys

try:
    from StringIO import StringIO
except ImportError:
    from io import StringIO
try:
    from itertools import izip_longest
except ImportError:
    from itertools import zip_longest as izip_longest

import pytest

import hunter
from hunter import And
from hunter import Not
from hunter import Or
from hunter import Q
from hunter import Query
from hunter import stop
from hunter import trace
from hunter import When

from hunter import CodePrinter
from hunter import Debugger
from hunter import VarsPrinter

pytest_plugins = 'pytester',


@pytest.yield_fixture(autouse=True, scope="function")
def auto_stop():
    try:
        yield
    finally:
        stop()


def _get_func_spec(func):
    spec = inspect.getargspec(func)
    return inspect.formatargspec(spec.args, spec.varargs)


def test_pth_activation():
    module_name = os.path.__name__
    expected_module = "{0}.py".format(module_name)
    hunter_env = "module={!r},function=\"join\"".format(module_name)
    func_spec = _get_func_spec(os.path.join)
    expected_call = "call      def join{0}:".format(func_spec)

    output = subprocess.check_output(
        [sys.executable, os.path.join(os.path.dirname(__file__), 'sample.py')],
        env=dict(os.environ, PYTHONHUNTER=hunter_env),
        stderr=subprocess.STDOUT,
    )
    assert expected_module.encode() in output
    assert expected_call.encode() in output


def test_pth_sample4():
    env = dict(os.environ, PYTHONHUNTER="CodePrinter")
    env.pop('COVERAGE_PROCESS_START', None)
    env.pop('COV_CORE_SOURCE', None)
    output = subprocess.check_output(
        [sys.executable, os.path.join(os.path.dirname(__file__), 'sample4.py')],
        env=env,
        stderr=subprocess.STDOUT,
    )
    assert output


def test_pth_sample2(LineMatcher):
    env = dict(os.environ, PYTHONHUNTER="module='__main__'")
    env.pop('COVERAGE_PROCESS_START', None)
    env.pop('COV_CORE_SOURCE', None)
    output = subprocess.check_output(
        [sys.executable, os.path.join(os.path.dirname(__file__), 'sample2.py')],
        env=env,
        stderr=subprocess.STDOUT,
    )
    lm = LineMatcher(output.decode('utf-8').splitlines())
    lm.fnmatch_lines([
        '*tests*sample2.py:* call      if __name__ == "__main__":  #*',
        '*tests*sample2.py:* line      if __name__ == "__main__":  #*',
        '*tests*sample2.py:* line          import functools',
        '*tests*sample2.py:* line          def deco(opt):',
        '*tests*sample2.py:* line          @deco(1)',
        '*tests*sample2.py:* call          def deco(opt):',
        '*tests*sample2.py:* line              def decorator(func):',
        '*tests*sample2.py:* line              return decorator',
        '*tests*sample2.py:* return            return decorator',
        '*                 * ...       return value: <function deco*',
        '*tests*sample2.py:* line          @deco(2)',
        '*tests*sample2.py:* call          def deco(opt):',
        '*tests*sample2.py:* line              def decorator(func):',
        '*tests*sample2.py:* line              return decorator',
        '*tests*sample2.py:* return            return decorator',
        '*                 * ...       return value: <function deco*',
        '*tests*sample2.py:* line          @deco(3)',
        '*tests*sample2.py:* call          def deco(opt):',
        '*tests*sample2.py:* line              def decorator(func):',
        '*tests*sample2.py:* line              return decorator',
        '*tests*sample2.py:* return            return decorator',
        '*                 * ...       return value: <function deco*',
        '*tests*sample2.py:* call              def decorator(func):',
        '*tests*sample2.py:* line                  @functools.wraps(func)',
        '*tests*sample2.py:* line                  return wrapper',
        '*tests*sample2.py:* return                return wrapper',
        '*                 * ...       return value: <function foo *',
        '*tests*sample2.py:* call              def decorator(func):',
        '*tests*sample2.py:* line                  @functools.wraps(func)',
        '*tests*sample2.py:* line                  return wrapper',
        '*tests*sample2.py:* return                return wrapper',
        '*                 * ...       return value: <function foo *',
        '*tests*sample2.py:* call              def decorator(func):',
        '*tests*sample2.py:* line                  @functools.wraps(func)',
        '*tests*sample2.py:* line                  return wrapper',
        '*tests*sample2.py:* return                return wrapper',
        '*                 * ...       return value: <function foo *',
        '*tests*sample2.py:* line          foo(',
        "*tests*sample2.py:* line              'a*',",
        "*tests*sample2.py:* line              'b'",
        '*tests*sample2.py:* call                  @functools.wraps(func)',
        '*                 *    |                  def wrapper(*args):',
        '*tests*sample2.py:* line                      return func(*args)',
        '*tests*sample2.py:* call                  @functools.wraps(func)',
        '*                 *    |                  def wrapper(*args):',
        '*tests*sample2.py:* line                      return func(*args)',
        '*tests*sample2.py:* call                  @functools.wraps(func)',
        '*                 *    |                  def wrapper(*args):',
        '*tests*sample2.py:* line                      return func(*args)',
        '*tests*sample2.py:* call          @deco(1)',
        '*                 *    |          @deco(2)',
        '*                 *    |          @deco(3)',
        '*                 *    |          def foo(*args):',
        '*tests*sample2.py:* line              return args',
        '*tests*sample2.py:* return            return args',
        "*                 * ...       return value: ('a*', 'b')",
        "*tests*sample2.py:* return                    return func(*args)",
        "*                 * ...       return value: ('a*', 'b')",
        "*tests*sample2.py:* return                    return func(*args)",
        "*                 * ...       return value: ('a*', 'b')",
        "*tests*sample2.py:* return                    return func(*args)",
        "*                 * ...       return value: ('a*', 'b')",
        "*tests*sample2.py:* line          try:",
        "*tests*sample2.py:* line              None(",
        "*tests*sample2.py:* line                  'a',",
        "*tests*sample2.py:* line                  'b'",
        "*tests*sample2.py:* exception             'b'",
        "*                 * ...       exception value: *",
        "*tests*sample2.py:* line          except:",
        "*tests*sample2.py:* line              pass",
        "*tests*sample2.py:* return            pass",
        "*                   ...       return value: None",
    ])


def test_predicate_str_repr():
    assert repr(Q(module='a')).endswith("predicates.Query: query={'module': 'a'}>")
    assert str(Q(module='a')) == "Query(module='a')"

    assert "predicates.When: condition=<hunter." in repr(Q(module='a', action='foo'))
    assert "predicates.Query: query={'module': 'a'}>, actions=['foo']>" in repr(Q(module='a', action='foo'))
    assert str(Q(module='a', action='foo')) == "When(Query(module='a'), 'foo')"

    assert "predicates.Not: predicate=<hunter." in repr(~Q(module='a'))
    assert "predicates.Query: query={'module': 'a'}>>" in repr(~Q(module='a'))
    assert str(~Q(module='a')) == "Not(Query(module='a'))"

    assert "predicates.Or: predicates=(<hunter." in repr(Q(module='a') | Q(module='b'))
    assert "predicates.Query: query={'module': 'a'}>, " in repr(Q(module='a') | Q(module='b'))
    assert repr(Q(module='a') | Q(module='b')).endswith("predicates.Query: query={'module': 'b'}>)>")
    assert str(Q(module='a') | Q(module='b')) == "Or(Query(module='a'), Query(module='b'))"

    assert "predicates.And: predicates=(<hunter." in repr(Q(module='a') & Q(module='b'))
    assert "predicates.Query: query={'module': 'a'}>," in repr(Q(module='a') & Q(module='b'))
    assert repr(Q(module='a') & Q(module='b')).endswith("predicates.Query: query={'module': 'b'}>)>")
    assert str(Q(module='a') & Q(module='b')) == "And(Query(module='a'), Query(module='b'))"


def test_predicate_q_nest_1():
    assert repr(Q(Q(module='a'))).endswith("predicates.Query: query={'module': 'a'}>")


def test_predicate_q_expansion():
    assert Q(1, 2, module=3) == Or(1, 2, Q(module=3))
    assert Q(1, 2, module=3, action=4) == When(Or(1, 2, Q(module=3)), 4)
    assert Q(1, 2, module=3, actions=[4, 5]) == When(Or(1, 2, Q(module=3)), 4, 5)


def test_predicate_and():
    assert And(1, 2) == And(1, 2)
    assert Q(module=1) & Q(module=2) == And(Q(module=1), Q(module=2))
    assert Q(module=1) & Q(module=2) & Q(module=3) == And(Q(module=1), Q(module=2), Q(module=3))

    assert (Q(module=1) & Q(module=2))({'module': 3}) == False
    assert (Q(module=1) & Q(function=2))({'module': 1, 'function': 2}) == True

    assert And(1, 2) | 3 == Or(And(1, 2), 3)


def test_predicate_or():
    assert Q(module=1) | Q(module=2) == Or(Q(module=1), Q(module=2))
    assert Q(module=1) | Q(module=2) | Q(module=3) == Or(Q(module=1), Q(module=2), Q(module=3))

    assert (Q(module=1) | Q(module=2))({'module': 3}) == False
    assert (Q(module=1) | Q(module=2))({'module': 2}) == True

    assert Or(1, 2) & 3 == And(Or(1, 2), 3)


def test_tracing_bare(LineMatcher):
    lines = StringIO()
    with trace(CodePrinter(stream=lines)):
        def a():
            return 1

        b = a()
        b = 2
        try:
            raise Exception("BOOM!")
        except Exception:
            pass
    print(lines.getvalue())
    lm = LineMatcher(lines.getvalue().splitlines())
    lm.fnmatch_lines([
        "* ...       return value: <hunter.*tracer.Tracer *",
        "*test_hunter.py* call              def a():",
        "*test_hunter.py* line                  return 1",
        "*test_hunter.py* return                return 1",
        "* ...       return value: 1",
    ])


def test_tracing_printing_failures(LineMatcher):
    lines = StringIO()
    with trace(CodePrinter(stream=lines), VarsPrinter("x", stream=lines)):
        class Bad(Exception):
            def __repr__(self):
                raise RuntimeError("I'm a bad class!")

        def a():
            x = Bad()
            return x

        def b():
            x = Bad()
            raise x

        a()
        try:
            b()
        except Exception as exc:
            pass
    lm = LineMatcher(lines.getvalue().splitlines())
    lm.fnmatch_lines([
        """* ...       return value: <hunter.*tracer.Tracer *""",
        """*tests*test_hunter.py:* call              class Bad(Exception):""",
        """*tests*test_hunter.py:* line              class Bad(Exception):""",
        """*tests*test_hunter.py:* line                  def __repr__(self):""",
        """*tests*test_hunter.py:* return                def __repr__(self):""",
        """* ...       return value: *""",
        """*tests*test_hunter.py:* call              def a():""",
        """*tests*test_hunter.py:* line                  x = Bad()""",
        """*tests*test_hunter.py:* line                  return x""",
        """* vars      x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """*tests*test_hunter.py:* return                return x""",
        """* ...       return value: !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """* vars      x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """*tests*test_hunter.py:* call              def b():""",
        """*tests*test_hunter.py:* line                  x = Bad()""",
        """*tests*test_hunter.py:* line                  raise x""",
        """* vars      x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """*tests*test_hunter.py:* exception             raise x""",
        """* ...       exception value: !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """* vars      x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
        """*tests*test_hunter.py:* return                raise x""",
        """* ...       return value: None""",
        """* vars      x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
    ])


def test_tracing_vars(LineMatcher):
    lines = StringIO()
    with trace(actions=[VarsPrinter('b', stream=lines), CodePrinter(stream=lines)]):
        def a():
            b = 1
            b = 2
            return 1

        b = a()
        b = 2
        try:
            raise Exception("BOOM!")
        except Exception:
            pass
    print(lines.getvalue())
    lm = LineMatcher(lines.getvalue().splitlines())
    lm.fnmatch_lines([
        "* ...       return value: <hunter.*tracer.Tracer *",
        "*test_hunter.py* call              def a():",
        "*test_hunter.py* line                  b = 1",
        "* vars      b => 1",
        "*test_hunter.py* line                  b = 2",
        "* vars      b => 2",
        "*test_hunter.py* line                  return 1",
        "* vars      b => 2",
        "*test_hunter.py* return                return 1",
        "* ...       return value: 1",
    ])


def test_trace_merge():
    trace(function="a")
    trace(function="b")
    assert trace(function="c")._handler == When(Q(function="c"), CodePrinter)


def test_trace_api_expansion():
    # simple use
    with trace(function="foobar") as t:
        assert t._handler == When(Q(function="foobar"), CodePrinter)

    # "or" by expression
    with trace(module="foo", function="foobar") as t:
        assert t._handler == When(Q(module="foo", function="foobar"), CodePrinter)

    # pdb.set_trace
    with trace(function="foobar", action=Debugger) as t:
        assert t._handler == When(Q(function="foobar"), Debugger)

    # pdb.set_trace on any hits
    with trace(module="foo", function="foobar", action=Debugger) as t:
        assert t._handler == When(Q(module="foo", function="foobar"), Debugger)

    # pdb.set_trace when function is foobar, otherwise just print when module is foo
    with trace(Q(function="foobar", action=Debugger), module="foo") as t:
        assert t._handler == When(Or(
            When(Q(function="foobar"), Debugger),
            Q(module="foo")
        ), CodePrinter)

    # dumping variables from stack
    with trace(Q(function="foobar", action=VarsPrinter("foobar")), module="foo") as t:
        assert t._handler == When(Or(
            When(Q(function="foobar"), VarsPrinter("foobar")),
            Q(module="foo"),
        ), CodePrinter)

    with trace(Q(function="foobar", action=VarsPrinter("foobar", "mumbojumbo")), module="foo") as t:
        assert t._handler == When(Or(
            When(Q(function="foobar"), VarsPrinter("foobar", "mumbojumbo")),
            Q(module="foo"),
        ), CodePrinter)

    # multiple actions
    with trace(Q(function="foobar", actions=[VarsPrinter("foobar"), Debugger]), module="foo") as t:
        assert t._handler == When(Or(
            When(Q(function="foobar"), VarsPrinter("foobar"), Debugger),
            Q(module="foo"),
        ), CodePrinter)

    # customization
    assert trace(lambda event: event.locals.get("node") == "Foobar",
                 module="foo", function="foobar")
    assert trace(Q(lambda event: event.locals.get("node") == "Foobar",
                   function="foobar", actions=[VarsPrinter("foobar"), Debugger]), module="foo", )
    assert trace(Q(function="foobar", actions=[VarsPrinter("foobar"),
                                               lambda event: print("some custom output")]), module="foo", )


def test_trace_with_class_actions():
    with trace(CodePrinter):
        def a():
            pass

        a()


def test_predicate_no_inf_recursion():
    assert Or(And(1)) == 1
    assert Or(Or(1)) == 1
    assert And(Or(1)) == 1
    assert And(And(1)) == 1
    predicate = Q(Q(lambda ev: 1, module='wat'))
    print('predicate:', predicate)
    predicate('foo')


def test_predicate_compression():
    assert Or(Or(1, 2), And(3)) == Or(1, 2, 3)
    assert Or(Or(1, 2), 3) == Or(1, 2, 3)
    assert Or(1, Or(2, 3), 4) == Or(1, 2, 3, 4)
    assert And(1, 2, Or(3, 4)).predicates == (1, 2, Or(3, 4))

    assert repr(Or(Or(1, 2), And(3))) == repr(Or(1, 2, 3))
    assert repr(Or(Or(1, 2), 3)) == repr(Or(1, 2, 3))
    assert repr(Or(1, Or(2, 3), 4)) == repr(Or(1, 2, 3, 4))


def test_predicate_not():
    assert Not(1).predicate == 1
    assert ~Or(1, 2) == Not(Or(1, 2))
    assert ~And(1, 2) == Not(And(1, 2))

    assert ~Not(1) == 1

    assert ~Query(module=1) | ~Query(module=2) == Not(And(Query(module=1), Query(module=2)))
    assert ~Query(module=1) & ~Query(module=2) == Not(Or(Query(module=1), Query(module=2)))

    assert ~Query(module=1) | Query(module=2) == Or(Not(Query(module=1)), Query(module=2))
    assert ~Query(module=1) & Query(module=2) == And(Not(Query(module=1)), Query(module=2))

    assert ~(Query(module=1) & Query(module=2)) == Not(And(Query(module=1), Query(module=2)))
    assert ~(Query(module=1) | Query(module=2)) == Not(Or(Query(module=1), Query(module=2)))

    assert repr(~Or(1, 2)) == repr(Not(Or(1, 2)))
    assert repr(~And(1, 2)) == repr(Not(And(1, 2)))

    assert repr(~Query(module=1) | ~Query(module=2)) == repr(Not(And(Query(module=1), Query(module=2))))
    assert repr(~Query(module=1) & ~Query(module=2)) == repr(Not(Or(Query(module=1), Query(module=2))))

    assert repr(~(Query(module=1) & Query(module=2))) == repr(Not(And(Query(module=1), Query(module=2))))
    assert repr(~(Query(module=1) | Query(module=2))) == repr(Not(Or(Query(module=1), Query(module=2))))

    assert Not(Q(module=1))({'module': 1}) == False


def test_predicate_query_allowed():
    pytest.raises(TypeError, Query, 1)
    pytest.raises(TypeError, Query, a=1)


def test_predicate_when_allowed():
    pytest.raises(TypeError, When, 1)


@pytest.mark.parametrize('expr,inp,expected', [
    ({'module': "abc"}, {'module': "abc"}, True),
    ({'module': "abcd"}, {'module': "abc"}, False),
    ({'module': "abcd"}, {'module': "abce"}, False),
    ({'module': "abc"}, {'module': "abcd"}, False),
    ({'module': ("abc", "xyz")}, {'module': "abc"}, True),
    ({'module': ("abc", "xyz")}, {'module': "abcd"}, True),
    ({'module': ("abc", "xyz")}, {'module': "xyzw"}, True),
    ({'module': ("abc", "xyz")}, {'module': "fooabc"}, False),
    ({'module': ("abc", "xyz")}, {'module': 1}, False),

    ({'module': ["abc", "xyz"]}, {'module': "abc"}, True),
    ({'module': ["abc", "xyz"]}, {'module': "abcd"}, True),
    ({'module': ["abc", "xyz"]}, {'module': "xyzw"}, True),
    ({'module': ["abc", "xyz"]}, {'module': "fooabc"}, False),
    ({'module': ["abc", "xyz"]}, {'module': 1}, False),

    ({'module': {"abc", "xyz"}}, {'module': "abc"}, True),
    ({'module': {"abc", "xyz"}}, {'module': "abcd"}, True),
    ({'module': {"abc", "xyz"}}, {'module': "xyzw"}, True),
    ({'module': {"abc", "xyz"}}, {'module': "fooabc"}, False),
    ({'module': {"abc", "xyz"}}, {'module': 1}, False),

    ({'module': "abc"}, {'module': 1}, False),
])
def test_predicate_matching(expr, inp, expected):
    assert Query(**expr)(inp) == expected


def test_predicate_when():
    called = []
    assert When(Q(module=1), lambda ev: called.append(ev))({'module': 2}) == False
    assert called == []

    assert When(Q(module=1), lambda ev: called.append(ev))({'module': 1}) == True
    assert called == [{'module': 1}]

    called = []
    assert Q(module=1, action=lambda ev: called.append(ev))({'module': 1}) == True
    assert called == [{'module': 1}]

    called = [[], []]
    predicate = (
        Q(module=1, action=lambda ev: called[0].append(ev)) |
        Q(module=2, action=lambda ev: called[1].append(ev))
    )
    assert predicate({'module': 1}) == True
    assert called == [[{'module': 1}], []]

    assert predicate({'module': 2}) == True
    assert called == [[{'module': 1}], [{'module': 2}]]

    called = [[], []]
    predicate = (
        Q(module=1, action=lambda ev: called[0].append(ev)) &
        Q(function=2, action=lambda ev: called[1].append(ev))
    )
    assert predicate({'module': 2}) == False
    assert called == [[], []]

    assert predicate({'module': 1, 'function': 2}) == True
    assert called == [[{'module': 1, 'function': 2}], [{'module': 1, 'function': 2}]]


def test_proper_backend():
    if os.environ.get('PUREPYTHONTRACER'):
        assert repr(hunter._TRACER).startswith('<hunter.tracer.Tracer')
    else:
        assert repr(hunter._TRACER).startswith('<hunter._tracer.Tracer')


1			from __future__ import print_function
2
3			import inspect
4			import os
5			import subprocess
6			import sys
7
8			try:
9			from StringIO import StringIO
10			except ImportError:
11			from io import StringIO
12			try:
13			from itertools import izip_longest
14			except ImportError:
15			from itertools import zip_longest as izip_longest
16
17			import pytest
18
19			import hunter
20			from hunter import And
21			from hunter import Not
22			from hunter import Or
23			from hunter import Q
24			from hunter import Query
25			from hunter import stop
26			from hunter import trace
27			from hunter import When
28
29			from hunter import CodePrinter
30			from hunter import Debugger
31			from hunter import VarsPrinter
32
33			pytest_plugins = 'pytester',
34
35
36			@pytest.yield_fixture(autouse=True, scope="function")
37			def auto_stop():
38			try:
39			yield
40			finally:
41			stop()
42
43
44			def _get_func_spec(func):
45			spec = inspect.getargspec(func)
46			return inspect.formatargspec(spec.args, spec.varargs)
47
48
49			def test_pth_activation():
50			module_name = os.path.__name__
51			expected_module = "{0}.py".format(module_name)
52			hunter_env = "module={!r},function=\"join\"".format(module_name)
53			func_spec = _get_func_spec(os.path.join)
54			expected_call = "call def join{0}:".format(func_spec)
55
56			output = subprocess.check_output(
57			[sys.executable, os.path.join(os.path.dirname(__file__), 'sample.py')],
58			env=dict(os.environ, PYTHONHUNTER=hunter_env),
59			stderr=subprocess.STDOUT,
60			)
61			assert expected_module.encode() in output
62			assert expected_call.encode() in output
63
64
65			def test_pth_sample4():
66			env = dict(os.environ, PYTHONHUNTER="CodePrinter")
67			env.pop('COVERAGE_PROCESS_START', None)
68			env.pop('COV_CORE_SOURCE', None)
69			output = subprocess.check_output(
70			[sys.executable, os.path.join(os.path.dirname(__file__), 'sample4.py')],
71			env=env,
72			stderr=subprocess.STDOUT,
73			)
74			assert output
75
76
77			def test_pth_sample2(LineMatcher):
78			env = dict(os.environ, PYTHONHUNTER="module='__main__'")
79			env.pop('COVERAGE_PROCESS_START', None)
80			env.pop('COV_CORE_SOURCE', None)
81			output = subprocess.check_output(
82			[sys.executable, os.path.join(os.path.dirname(__file__), 'sample2.py')],
83			env=env,
84			stderr=subprocess.STDOUT,
85			)
86			lm = LineMatcher(output.decode('utf-8').splitlines())
87			lm.fnmatch_lines([
88			'testssample2.py:* call if __name__ == "__main__": #*',
89			'testssample2.py:* line if __name__ == "__main__": #*',
90			'testssample2.py:* line import functools',
91			'testssample2.py:* line def deco(opt):',
92			'testssample2.py:* line @deco(1)',
93			'testssample2.py:* call def deco(opt):',
94			'testssample2.py:* line def decorator(func):',
95			'testssample2.py:* line return decorator',
96			'testssample2.py:* return return decorator',
97			'* * ... return value: <function deco*',
98			'testssample2.py:* line @deco(2)',
99			'testssample2.py:* call def deco(opt):',
100			'testssample2.py:* line def decorator(func):',
101			'testssample2.py:* line return decorator',
102			'testssample2.py:* return return decorator',
103			'* * ... return value: <function deco*',
104			'testssample2.py:* line @deco(3)',
105			'testssample2.py:* call def deco(opt):',
106			'testssample2.py:* line def decorator(func):',
107			'testssample2.py:* line return decorator',
108			'testssample2.py:* return return decorator',
109			'* * ... return value: <function deco*',
110			'testssample2.py:* call def decorator(func):',
111			'testssample2.py:* line @functools.wraps(func)',
112			'testssample2.py:* line return wrapper',
113			'testssample2.py:* return return wrapper',
114			'* * ... return value: <function foo *',
115			'testssample2.py:* call def decorator(func):',
116			'testssample2.py:* line @functools.wraps(func)',
117			'testssample2.py:* line return wrapper',
118			'testssample2.py:* return return wrapper',
119			'* * ... return value: <function foo *',
120			'testssample2.py:* call def decorator(func):',
121			'testssample2.py:* line @functools.wraps(func)',
122			'testssample2.py:* line return wrapper',
123			'testssample2.py:* return return wrapper',
124			'* * ... return value: <function foo *',
125			'testssample2.py:* line foo(',
126			"testssample2.py:* line 'a*',",
127			"testssample2.py:* line 'b'",
128			'testssample2.py:* call @functools.wraps(func)',
129			'* * \| def wrapper(*args):',
130			'testssample2.py:* line return func(*args)',
131			'testssample2.py:* call @functools.wraps(func)',
132			'* * \| def wrapper(*args):',
133			'testssample2.py:* line return func(*args)',
134			'testssample2.py:* call @functools.wraps(func)',
135			'* * \| def wrapper(*args):',
136			'testssample2.py:* line return func(*args)',
137			'testssample2.py:* call @deco(1)',
138			'* * \| @deco(2)',
139			'* * \| @deco(3)',
140			'* * \| def foo(*args):',
141			'testssample2.py:* line return args',
142			'testssample2.py:* return return args',
143			"* * ... return value: ('a*', 'b')",
144			"testssample2.py:* return return func(*args)",
145			"* * ... return value: ('a*', 'b')",
146			"testssample2.py:* return return func(*args)",
147			"* * ... return value: ('a*', 'b')",
148			"testssample2.py:* return return func(*args)",
149			"* * ... return value: ('a*', 'b')",
150			"testssample2.py:* line try:",
151			"testssample2.py:* line None(",
152			"testssample2.py:* line 'a',",
153			"testssample2.py:* line 'b'",
154			"testssample2.py:* exception 'b'",
155			"* * ... exception value: *",
156			"testssample2.py:* line except:",
157			"testssample2.py:* line pass",
158			"testssample2.py:* return pass",
159			"* ... return value: None",
160			])
161
162
163			def test_predicate_str_repr():
164			assert repr(Q(module='a')).endswith("predicates.Query: query={'module': 'a'}>")
165			assert str(Q(module='a')) == "Query(module='a')"
166
167			assert "predicates.When: condition=<hunter." in repr(Q(module='a', action='foo'))
168			assert "predicates.Query: query={'module': 'a'}>, actions=['foo']>" in repr(Q(module='a', action='foo'))
169			assert str(Q(module='a', action='foo')) == "When(Query(module='a'), 'foo')"
170
171			assert "predicates.Not: predicate=<hunter." in repr(~Q(module='a'))
172			assert "predicates.Query: query={'module': 'a'}>>" in repr(~Q(module='a'))
173			assert str(~Q(module='a')) == "Not(Query(module='a'))"
174
175			assert "predicates.Or: predicates=(<hunter." in repr(Q(module='a') \| Q(module='b'))
176			assert "predicates.Query: query={'module': 'a'}>, " in repr(Q(module='a') \| Q(module='b'))
177			assert repr(Q(module='a') \| Q(module='b')).endswith("predicates.Query: query={'module': 'b'}>)>")
178			assert str(Q(module='a') \| Q(module='b')) == "Or(Query(module='a'), Query(module='b'))"
179
180			assert "predicates.And: predicates=(<hunter." in repr(Q(module='a') & Q(module='b'))
181			assert "predicates.Query: query={'module': 'a'}>," in repr(Q(module='a') & Q(module='b'))
182			assert repr(Q(module='a') & Q(module='b')).endswith("predicates.Query: query={'module': 'b'}>)>")
183			assert str(Q(module='a') & Q(module='b')) == "And(Query(module='a'), Query(module='b'))"
184
185
186			def test_predicate_q_nest_1():
187			assert repr(Q(Q(module='a'))).endswith("predicates.Query: query={'module': 'a'}>")
188
189
190			def test_predicate_q_expansion():
191			assert Q(1, 2, module=3) == Or(1, 2, Q(module=3))
192			assert Q(1, 2, module=3, action=4) == When(Or(1, 2, Q(module=3)), 4)
193			assert Q(1, 2, module=3, actions=[4, 5]) == When(Or(1, 2, Q(module=3)), 4, 5)
194
195
196			def test_predicate_and():
197			assert And(1, 2) == And(1, 2)
198			assert Q(module=1) & Q(module=2) == And(Q(module=1), Q(module=2))
199			assert Q(module=1) & Q(module=2) & Q(module=3) == And(Q(module=1), Q(module=2), Q(module=3))
200
201			assert (Q(module=1) & Q(module=2))({'module': 3}) == False
202			assert (Q(module=1) & Q(function=2))({'module': 1, 'function': 2}) == True
203
204			assert And(1, 2) \| 3 == Or(And(1, 2), 3)
205
206
207			def test_predicate_or():
208			assert Q(module=1) \| Q(module=2) == Or(Q(module=1), Q(module=2))
209			assert Q(module=1) \| Q(module=2) \| Q(module=3) == Or(Q(module=1), Q(module=2), Q(module=3))
210
211			assert (Q(module=1) \| Q(module=2))({'module': 3}) == False
212			assert (Q(module=1) \| Q(module=2))({'module': 2}) == True
213
214			assert Or(1, 2) & 3 == And(Or(1, 2), 3)
215
216
217			def test_tracing_bare(LineMatcher):
218			lines = StringIO()
219			with trace(CodePrinter(stream=lines)):
220			def a():
221			return 1
222
223			b = a()
224			b = 2
225			try:
226			raise Exception("BOOM!")
227			except Exception:
228			pass
229			print(lines.getvalue())
230			lm = LineMatcher(lines.getvalue().splitlines())
231			lm.fnmatch_lines([
232			"* ... return value: <hunter.tracer.Tracer ",
233			"test_hunter.py call def a():",
234			"test_hunter.py line return 1",
235			"test_hunter.py return return 1",
236			"* ... return value: 1",
237			])
238
239
240			def test_tracing_printing_failures(LineMatcher):
241			lines = StringIO()
242			with trace(CodePrinter(stream=lines), VarsPrinter("x", stream=lines)):
243			class Bad(Exception):
244			def __repr__(self):
245			raise RuntimeError("I'm a bad class!")
246
247			def a():
248			x = Bad()
249			return x
250
251			def b():
252			x = Bad()
253			raise x
254
255			a()
256			try:
257			b()
258			except Exception as exc:
259			pass
260			lm = LineMatcher(lines.getvalue().splitlines())
261			lm.fnmatch_lines([
262			"""* ... return value: <hunter.tracer.Tracer """,
263			"""teststest_hunter.py:* call class Bad(Exception):""",
264			"""teststest_hunter.py:* line class Bad(Exception):""",
265			"""teststest_hunter.py:* line def __repr__(self):""",
266			"""teststest_hunter.py:* return def __repr__(self):""",
267			"""* ... return value: *""",
268			"""teststest_hunter.py:* call def a():""",
269			"""teststest_hunter.py:* line x = Bad()""",
270			"""teststest_hunter.py:* line return x""",
271			"""* vars x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
272			"""teststest_hunter.py:* return return x""",
273			"""* ... return value: !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
274			"""* vars x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
275			"""teststest_hunter.py:* call def b():""",
276			"""teststest_hunter.py:* line x = Bad()""",
277			"""teststest_hunter.py:* line raise x""",
278			"""* vars x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
279			"""teststest_hunter.py:* exception raise x""",
280			"""* ... exception value: !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
281			"""* vars x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
282			"""teststest_hunter.py:* return raise x""",
283			"""* ... return value: None""",
284			"""* vars x => !!! FAILED REPR: RuntimeError("I'm a bad class!",)""",
285			])
286
287
288			def test_tracing_vars(LineMatcher):
289			lines = StringIO()
290			with trace(actions=[VarsPrinter('b', stream=lines), CodePrinter(stream=lines)]):
291			def a():
292			b = 1
293			b = 2
294			return 1
295
296			b = a()
297			b = 2
298			try:
299			raise Exception("BOOM!")
300			except Exception:
301			pass
302			print(lines.getvalue())
303			lm = LineMatcher(lines.getvalue().splitlines())
304			lm.fnmatch_lines([
305			"* ... return value: <hunter.tracer.Tracer ",
306			"test_hunter.py call def a():",
307			"test_hunter.py line b = 1",
308			"* vars b => 1",
309			"test_hunter.py line b = 2",
310			"* vars b => 2",
311			"test_hunter.py line return 1",
312			"* vars b => 2",
313			"test_hunter.py return return 1",
314			"* ... return value: 1",
315			])
316
317
318			def test_trace_merge():
319			trace(function="a")
320			trace(function="b")
321			assert trace(function="c")._handler == When(Q(function="c"), CodePrinter)
322
323
324			def test_trace_api_expansion():
325			# simple use
326			with trace(function="foobar") as t:
327			assert t._handler == When(Q(function="foobar"), CodePrinter)
328
329			# "or" by expression
330			with trace(module="foo", function="foobar") as t:
331			assert t._handler == When(Q(module="foo", function="foobar"), CodePrinter)
332
333			# pdb.set_trace
334			with trace(function="foobar", action=Debugger) as t:
335			assert t._handler == When(Q(function="foobar"), Debugger)
336
337			# pdb.set_trace on any hits
338			with trace(module="foo", function="foobar", action=Debugger) as t:
339			assert t._handler == When(Q(module="foo", function="foobar"), Debugger)
340
341			# pdb.set_trace when function is foobar, otherwise just print when module is foo
342			with trace(Q(function="foobar", action=Debugger), module="foo") as t:
343			assert t._handler == When(Or(
344			When(Q(function="foobar"), Debugger),
345			Q(module="foo")
346			), CodePrinter)
347
348			# dumping variables from stack
349			with trace(Q(function="foobar", action=VarsPrinter("foobar")), module="foo") as t:
350			assert t._handler == When(Or(
351			When(Q(function="foobar"), VarsPrinter("foobar")),
352			Q(module="foo"),
353			), CodePrinter)
354
355			with trace(Q(function="foobar", action=VarsPrinter("foobar", "mumbojumbo")), module="foo") as t:
356			assert t._handler == When(Or(
357			When(Q(function="foobar"), VarsPrinter("foobar", "mumbojumbo")),
358			Q(module="foo"),
359			), CodePrinter)
360
361			# multiple actions
362			with trace(Q(function="foobar", actions=[VarsPrinter("foobar"), Debugger]), module="foo") as t:
363			assert t._handler == When(Or(
364			When(Q(function="foobar"), VarsPrinter("foobar"), Debugger),
365			Q(module="foo"),
366			), CodePrinter)
367
368			# customization
369			assert trace(lambda event: event.locals.get("node") == "Foobar",
370			module="foo", function="foobar")
371			assert trace(Q(lambda event: event.locals.get("node") == "Foobar",
372			function="foobar", actions=[VarsPrinter("foobar"), Debugger]), module="foo", )
373			assert trace(Q(function="foobar", actions=[VarsPrinter("foobar"),
374			lambda event: print("some custom output")]), module="foo", )
375
376
377			def test_trace_with_class_actions():
378			with trace(CodePrinter):
379			def a():
380			pass
381
382			a()
383
384
385			def test_predicate_no_inf_recursion():
386			assert Or(And(1)) == 1
387			assert Or(Or(1)) == 1
388			assert And(Or(1)) == 1
389			assert And(And(1)) == 1
390			predicate = Q(Q(lambda ev: 1, module='wat'))
391			print('predicate:', predicate)
392			predicate('foo')
393
394
395			def test_predicate_compression():
396			assert Or(Or(1, 2), And(3)) == Or(1, 2, 3)
397			assert Or(Or(1, 2), 3) == Or(1, 2, 3)
398			assert Or(1, Or(2, 3), 4) == Or(1, 2, 3, 4)
399			assert And(1, 2, Or(3, 4)).predicates == (1, 2, Or(3, 4))
400
401			assert repr(Or(Or(1, 2), And(3))) == repr(Or(1, 2, 3))
402			assert repr(Or(Or(1, 2), 3)) == repr(Or(1, 2, 3))
403			assert repr(Or(1, Or(2, 3), 4)) == repr(Or(1, 2, 3, 4))
404
405
406			def test_predicate_not():
407			assert Not(1).predicate == 1
408			assert ~Or(1, 2) == Not(Or(1, 2))
409			assert ~And(1, 2) == Not(And(1, 2))
410
411			assert ~Not(1) == 1
412
413			assert ~Query(module=1) \| ~Query(module=2) == Not(And(Query(module=1), Query(module=2)))
414			assert ~Query(module=1) & ~Query(module=2) == Not(Or(Query(module=1), Query(module=2)))
415
416			assert ~Query(module=1) \| Query(module=2) == Or(Not(Query(module=1)), Query(module=2))
417			assert ~Query(module=1) & Query(module=2) == And(Not(Query(module=1)), Query(module=2))
418
419			assert ~(Query(module=1) & Query(module=2)) == Not(And(Query(module=1), Query(module=2)))
420			assert ~(Query(module=1) \| Query(module=2)) == Not(Or(Query(module=1), Query(module=2)))
421
422			assert repr(~Or(1, 2)) == repr(Not(Or(1, 2)))
423			assert repr(~And(1, 2)) == repr(Not(And(1, 2)))
424
425			assert repr(~Query(module=1) \| ~Query(module=2)) == repr(Not(And(Query(module=1), Query(module=2))))
426			assert repr(~Query(module=1) & ~Query(module=2)) == repr(Not(Or(Query(module=1), Query(module=2))))
427
428			assert repr(~(Query(module=1) & Query(module=2))) == repr(Not(And(Query(module=1), Query(module=2))))
429			assert repr(~(Query(module=1) \| Query(module=2))) == repr(Not(Or(Query(module=1), Query(module=2))))
430
431			assert Not(Q(module=1))({'module': 1}) == False
432
433
434			def test_predicate_query_allowed():
435			pytest.raises(TypeError, Query, 1)
436			pytest.raises(TypeError, Query, a=1)
437
438
439			def test_predicate_when_allowed():
440			pytest.raises(TypeError, When, 1)
441
442
443			@pytest.mark.parametrize('expr,inp,expected', [
444			({'module': "abc"}, {'module': "abc"}, True),
445			({'module': "abcd"}, {'module': "abc"}, False),
446			({'module': "abcd"}, {'module': "abce"}, False),
447			({'module': "abc"}, {'module': "abcd"}, False),
448			({'module': ("abc", "xyz")}, {'module': "abc"}, True),
449			({'module': ("abc", "xyz")}, {'module': "abcd"}, True),
450			({'module': ("abc", "xyz")}, {'module': "xyzw"}, True),
451			({'module': ("abc", "xyz")}, {'module': "fooabc"}, False),
452			({'module': ("abc", "xyz")}, {'module': 1}, False),
453
454			({'module': ["abc", "xyz"]}, {'module': "abc"}, True),
455			({'module': ["abc", "xyz"]}, {'module': "abcd"}, True),
456			({'module': ["abc", "xyz"]}, {'module': "xyzw"}, True),
457			({'module': ["abc", "xyz"]}, {'module': "fooabc"}, False),
458			({'module': ["abc", "xyz"]}, {'module': 1}, False),
459
460			({'module': {"abc", "xyz"}}, {'module': "abc"}, True),
461			({'module': {"abc", "xyz"}}, {'module': "abcd"}, True),
462			({'module': {"abc", "xyz"}}, {'module': "xyzw"}, True),
463			({'module': {"abc", "xyz"}}, {'module': "fooabc"}, False),
464			({'module': {"abc", "xyz"}}, {'module': 1}, False),
465
466			({'module': "abc"}, {'module': 1}, False),
467			])
468			def test_predicate_matching(expr, inp, expected):
469			assert Query(**expr)(inp) == expected
470
471
472			def test_predicate_when():
473			called = []
474			assert When(Q(module=1), lambda ev: called.append(ev))({'module': 2}) == False
475			assert called == []
476
477			assert When(Q(module=1), lambda ev: called.append(ev))({'module': 1}) == True
478			assert called == [{'module': 1}]
479
480			called = []
481			assert Q(module=1, action=lambda ev: called.append(ev))({'module': 1}) == True
482			assert called == [{'module': 1}]
483
484			called = [[], []]
485			predicate = (
486			Q(module=1, action=lambda ev: called[0].append(ev)) \|
487			Q(module=2, action=lambda ev: called[1].append(ev))
488			)
489			assert predicate({'module': 1}) == True
490			assert called == [[{'module': 1}], []]
491
492			assert predicate({'module': 2}) == True
493			assert called == [[{'module': 1}], [{'module': 2}]]
494
495			called = [[], []]
496			predicate = (
497			Q(module=1, action=lambda ev: called[0].append(ev)) &
498			Q(function=2, action=lambda ev: called[1].append(ev))
499			)
500			assert predicate({'module': 2}) == False
501			assert called == [[], []]
502
503			assert predicate({'module': 1, 'function': 2}) == True
504			assert called == [[{'module': 1, 'function': 2}], [{'module': 1, 'function': 2}]]
505
506
507			def test_proper_backend():
508			if os.environ.get('PUREPYTHONTRACER'):
509			assert repr(hunter._TRACER).startswith('<hunter.tracer.Tracer')
510			else:
511			assert repr(hunter._TRACER).startswith('<hunter._tracer.Tracer')
512

ionelmc / python-hunter

Push — master ( 4e3b27...2dc96c )

tests.test_predicate_str_repr() D

Complexity

Size

Duplication

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like