# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt """Tests for context support.""" import inspect import os.path import coverage from coverage import env from coverage.context import qualname_from_frame from coverage.data import CoverageData from coverage.misc import CoverageException from tests.coveragetest import CoverageTest class StaticContextTest(CoverageTest): """Tests of the static context.""" def setUp(self): super(StaticContextTest, self).setUp() self.skip_unless_data_storage_is("sql") def test_no_context(self): self.make_file("main.py", "a = 1") cov = coverage.Coverage() self.start_import_stop(cov, "main") data = cov.get_data() self.assertCountEqual(data.measured_contexts(), [""]) def test_static_context(self): self.make_file("main.py", "a = 1") cov = coverage.Coverage(context="gooey") self.start_import_stop(cov, "main") data = cov.get_data() self.assertCountEqual(data.measured_contexts(), ["gooey"]) SOURCE = """\ a = 1 if a > 2: a = 3 assert a == 1 """ LINES = [1, 2, 4] ARCS = [(-1, 1), (1, 2), (2, 4), (4, -1)] def run_red_blue(self, **options): """Run red.py and blue.py, and return their CoverageData objects.""" self.make_file("red.py", self.SOURCE) red_cov = coverage.Coverage(context="red", data_suffix="r", source=["."], **options) self.start_import_stop(red_cov, "red") red_cov.save() red_data = red_cov.get_data() self.make_file("blue.py", self.SOURCE) blue_cov = coverage.Coverage(context="blue", data_suffix="b", source=["."], **options) self.start_import_stop(blue_cov, "blue") blue_cov.save() blue_data = blue_cov.get_data() return red_data, blue_data def test_combining_line_contexts(self): red_data, blue_data = self.run_red_blue() for datas in [[red_data, blue_data], [blue_data, red_data]]: combined = CoverageData(suffix="combined") for data in datas: combined.update(data) self.assertEqual(combined.measured_contexts(), {'red', 'blue'}) full_names = {os.path.basename(f): f for f in combined.measured_files()} self.assertCountEqual(full_names, ['red.py', 'blue.py']) fred = full_names['red.py'] fblue = full_names['blue.py'] self.assertEqual(combined.lines(fred, context='red'), self.LINES) self.assertEqual(combined.lines(fred, context='blue'), []) self.assertEqual(combined.lines(fblue, context='red'), []) self.assertEqual(combined.lines(fblue, context='blue'), self.LINES) def test_combining_arc_contexts(self): red_data, blue_data = self.run_red_blue(branch=True) for datas in [[red_data, blue_data], [blue_data, red_data]]: combined = CoverageData(suffix="combined") for data in datas: combined.update(data) self.assertEqual(combined.measured_contexts(), {'red', 'blue'}) full_names = {os.path.basename(f): f for f in combined.measured_files()} self.assertCountEqual(full_names, ['red.py', 'blue.py']) fred = full_names['red.py'] fblue = full_names['blue.py'] self.assertEqual(combined.lines(fred, context='red'), self.LINES) self.assertEqual(combined.lines(fred, context='blue'), []) self.assertEqual(combined.lines(fblue, context='red'), []) self.assertEqual(combined.lines(fblue, context='blue'), self.LINES) self.assertEqual(combined.arcs(fred, context='red'), self.ARCS) self.assertEqual(combined.arcs(fred, context='blue'), []) self.assertEqual(combined.arcs(fblue, context='red'), []) self.assertEqual(combined.arcs(fblue, context='blue'), self.ARCS) class DynamicContextTest(CoverageTest): """Tests of dynamically changing contexts.""" def setUp(self): super(DynamicContextTest, self).setUp() self.skip_unless_data_storage_is("sql") if not env.C_TRACER: self.skipTest("Only the C tracer supports dynamic contexts") SOURCE = """\ def helper(lineno): x = 2 def test_one(): a = 5 helper(6) def test_two(): a = 9 b = 10 if a > 11: b = 12 assert a == (13-4) assert b == (14-4) helper(15) test_one() x = 18 helper(19) test_two() """ OUTER_LINES = [1, 4, 8, 17, 18, 19, 2, 20] TEST_ONE_LINES = [5, 6, 2] TEST_TWO_LINES = [9, 10, 11, 13, 14, 15, 2] def test_dynamic_alone(self): self.make_file("two_tests.py", self.SOURCE) cov = coverage.Coverage(source=["."]) cov.set_option("run:dynamic_context", "test_function") self.start_import_stop(cov, "two_tests") data = cov.get_data() full_names = {os.path.basename(f): f for f in data.measured_files()} fname = full_names["two_tests.py"] self.assertCountEqual(data.measured_contexts(), ["", "test_one", "test_two"]) self.assertCountEqual(data.lines(fname, ""), self.OUTER_LINES) self.assertCountEqual(data.lines(fname, "test_one"), self.TEST_ONE_LINES) self.assertCountEqual(data.lines(fname, "test_two"), self.TEST_TWO_LINES) def test_static_and_dynamic(self): self.make_file("two_tests.py", self.SOURCE) cov = coverage.Coverage(context="stat", source=["."]) cov.set_option("run:dynamic_context", "test_function") self.start_import_stop(cov, "two_tests") data = cov.get_data() full_names = {os.path.basename(f): f for f in data.measured_files()} fname = full_names["two_tests.py"] self.assertCountEqual(data.measured_contexts(), ["stat", "stat:test_one", "stat:test_two"]) self.assertCountEqual(data.lines(fname, "stat"), self.OUTER_LINES) self.assertCountEqual(data.lines(fname, "stat:test_one"), self.TEST_ONE_LINES) self.assertCountEqual(data.lines(fname, "stat:test_two"), self.TEST_TWO_LINES) class DynamicContextWithPythonTracerTest(CoverageTest): """The Python tracer doesn't do dynamic contexts at all.""" run_in_temp_dir = False def test_python_tracer_fails_properly(self): if env.C_TRACER: self.skipTest("This test is specifically about the Python tracer.") cov = coverage.Coverage() cov.set_option("run:dynamic_context", "test_function") msg = r"Can't support dynamic contexts with PyTracer" with self.assertRaisesRegex(CoverageException, msg): cov.start() def get_qualname(): """Helper to return qualname_from_frame for the caller.""" stack = inspect.stack()[1:] if any(sinfo[0].f_code.co_name == "get_qualname" for sinfo in stack): # We're calling outselves recursively, maybe because we're testing # properties. Return an int to try to get back on track. return 17 caller_frame = stack[0][0] return qualname_from_frame(caller_frame) class Parent(object): # pylint: disable=missing-docstring def meth(self): # pylint: disable=missing-docstring return get_qualname() @property def a_property(self): # pylint: disable=missing-docstring return get_qualname() class Child(Parent): # pylint: disable=missing-docstring pass class SomethingElse(object): # pylint: disable=missing-docstring pass class MultiChild(SomethingElse, Child): # pylint: disable=missing-docstring pass def no_arguments(): # pylint: disable=missing-docstring return get_qualname() def plain_old_function(a, b): # pylint: disable=missing-docstring, unused-argument return get_qualname() def fake_out(self): # pylint: disable=missing-docstring, unused-argument return get_qualname() def patch_meth(self): # pylint: disable=missing-docstring, unused-argument return get_qualname() class QualnameTest(CoverageTest): """Tests of qualname_from_frame.""" # Pylint gets confused about meth() below. # pylint: disable=no-value-for-parameter run_in_temp_dir = False def test_method(self): self.assertEqual(Parent().meth(), "Parent.meth") def test_inherited_method(self): self.assertEqual(Child().meth(), "Parent.meth") def test_mi_inherited_method(self): self.assertEqual(MultiChild().meth(), "Parent.meth") def test_no_arguments(self): self.assertEqual(no_arguments(), "no_arguments") def test_plain_old_function(self): self.assertEqual(plain_old_function(0, 1), "plain_old_function") def test_fake_out(self): self.assertEqual(fake_out(0), "fake_out") def test_property(self): # I'd like this to be "Parent.a_property", but this might be ok too. self.assertEqual(Parent().a_property, "a_property") def test_changeling(self): c = Child() c.meth = patch_meth self.assertEqual(c.meth(c), "patch_meth")