def create(self, modulename, module_source):
if modulename not in self.recorder.metadata:
pragmas = PragmaFinder().find_pragmas(module_source)
self.recorder.metadata[modulename] = (
MetadataGatheringVisitor.analyze(self.config, modulename,
module_source, pragmas))
return CoverageAnnotator(self.config, modulename, self.recorder)
def test_load_package(self):
from instrumental.instrument import AnnotatorFactory
from instrumental.metadata import MetadataGatheringVisitor
from instrumental.monkey import load_module_factory
from instrumental.pragmas import PragmaFinder
from instrumental.recorder import ExecutionRecorder
import instrumental.test.samples
samples_directory = os.path.dirname(instrumental.test.samples.__file__)
simple_name = 'instrumental.test.samples.package'
simple_path = os.path.join(samples_directory, 'package')
source = open(os.path.join(simple_path, '__init__.py'), "r").read()
pragmas = PragmaFinder().find_pragmas(source)
metadata = MetadataGatheringVisitor.analyze(self.config, simple_name,
source, pragmas)
recorder = ExecutionRecorder.get()
recorder.add_metadata(metadata)
visitor_factory = AnnotatorFactory(self.config, recorder)
load_module = load_module_factory(
['instrumental.test.samples.package'], [], visitor_factory)
load_module(simple_name, None, simple_path,
(None, None, imp.PKG_DIRECTORY))
assert simple_name in sys.modules
def test_Module_with_docstring_and_future_import(self):
from instrumental.instrument import CoverageAnnotator
from instrumental.metadata import MetadataGatheringVisitor
from instrumental.pragmas import PragmaFinder
source = """'a docstring am I'
from __future__ import with_statement
if u:
return u
else:
return 'else'
"""
module = ast.parse(source)
pragmas = PragmaFinder().find_pragmas(source)
config = DummyConfig()
metadata = MetadataGatheringVisitor.analyze(config, 'somemodule',
source, pragmas)
self.recorder.add_metadata(metadata)
transformer = CoverageAnnotator(config, 'somemodule', self.recorder)
inst_module = transformer.visit(module)
assert isinstance(inst_module.body[1], ast.ImportFrom)
assert module.body[1].module == '__future__'
assert isinstance(module.body[1].names[0], ast.alias)
assert module.body[1].names[0].name == 'with_statement'
self._assert_recorder_setup(inst_module, 2)
def _instrument_module(self, module_func):
from instrumental.metadata import MetadataGatheringVisitor
from instrumental.pragmas import PragmaFinder
module, source = load_module(module_func)
pragmas = PragmaFinder().find_pragmas(source)
metadata = MetadataGatheringVisitor.analyze(self.config,
module_func.__name__,
source, pragmas)
self.recorder.add_metadata(metadata)
transformer = CoverageAnnotator(self.config, module_func.__name__,
self.recorder)
inst_module = transformer.visit(module)
# print renderer.render(inst_module)
return inst_module
def _load_and_compile_module(self, module_func):
module, source = load_module(module_func)
from instrumental.pragmas import PragmaFinder
pragmas = PragmaFinder().find_pragmas(source)
from instrumental.metadata import MetadataGatheringVisitor
config = DummyConfig()
self.recorder.add_metadata(
MetadataGatheringVisitor.analyze(config, module_func.__name__,
source, pragmas))
# self.recorder.add_source(module_func.__name__, source)
transformer = CoverageAnnotator(config, module_func.__name__,
self.recorder)
inst_module = transformer.visit(module)
sys.stdout.write(renderer.render(inst_module) + "\n")
code = compile(inst_module, '<string>', 'exec')
return code
def gather_metadata(config, recorder, targets, ignores):
finder = SourceFinder(sys.path)
if config.use_metadata_cache:
metadata_cache = FileBackedMetadataCache()
else:
metadata_cache = DummyMetadataCache()
for target in targets:
for source_spec in finder.find(target, ignores):
filepath, modulename = source_spec
metadata = metadata_cache.fetch(filepath)
if not metadata:
source = open(filepath, "r").read()
pragmas = PragmaFinder().find_pragmas(source)
metadata = MetadataGatheringVisitor.analyze(
config, modulename, source, pragmas)
metadata_cache.store(filepath, metadata)
recorder.add_metadata(metadata)
def setup(self):
from instrumental.pragmas import PragmaFinder
self.finder = PragmaFinder()
class TestPragmaFinder(object):
def setup(self):
from instrumental.pragmas import PragmaFinder
self.finder = PragmaFinder()
def test_pragma_no_cover(self):
from instrumental.pragmas import PragmaNoCover
source = """
acc = 1
acc += 2
if add_three:
acc += 3 # pragma: no cover
acc += 4
"""
pragmas = self.finder.find_pragmas(source)
assert 6 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert not pragmas[4]
assert pragmas[5], pragmas
assert isinstance(list(pragmas[5])[0], PragmaNoCover)
assert not pragmas[6]
def test_pragma_nocover(self):
from instrumental.pragmas import PragmaNoCover
source = """
acc = 1
acc += 2
if add_three:
acc += 3 # pragma: nocover
acc += 4
"""
pragmas = self.finder.find_pragmas(source)
assert 6 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert not pragmas[4]
assert pragmas[5], pragmas
assert isinstance(list(pragmas[5])[0], PragmaNoCover)
assert not pragmas[6]
def test_pragma_no_cover_on_FunctionDefn(self):
from instrumental.pragmas import PragmaNoCover
source = """
def somefunc(args): # pragma: nocover
return 'howdy'
"""
pragmas = self.finder.find_pragmas(source)
assert 3 == len(pragmas), pragmas
assert not pragmas[1]
assert pragmas[2], pragmas
assert isinstance(list(pragmas[2])[0], PragmaNoCover)
assert pragmas[3], pragmas
assert isinstance(list(pragmas[3])[0], PragmaNoCover)
def test_pragma_no_cond_T(self):
from instrumental.pragmas import PragmaNoCondition
source = """
acc = 1
acc += 2
if add_three: # pragma: no cond(T)
acc += 3
acc += 4
"""
pragmas = self.finder.find_pragmas(source)
assert 6 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert 1 == len(pragmas[4])
pragma_4 = list(pragmas[4])[0]
assert isinstance(pragma_4, PragmaNoCondition)
assert pragma_4.conditions == ['T']
assert not pragmas[5]
assert not pragmas[6]
def test_pragma_no_cond_T_F(self):
from instrumental.pragmas import PragmaNoCondition
source = """
acc = 1
acc += 2
if add_three and add_four: # pragma: no cond(T F)
acc += 3
acc += 4
"""
pragmas = self.finder.find_pragmas(source)
assert 6 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert 1 == len(pragmas[4])
pragma_4 = list(pragmas[4])[0]
assert isinstance(pragma_4, PragmaNoCondition)
assert pragma_4.conditions == ['T F']
assert not pragmas[5]
assert not pragmas[6]
def test_pragma_no_cond_multiple_conditions(self):
from instrumental.pragmas import PragmaNoCondition
source = """
acc = 1
acc += 2
if add_three and add_four: # pragma: no cond(T F,F T)
acc += 3
acc += 4
"""
pragmas = self.finder.find_pragmas(source)
assert 6 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert 1 == len(pragmas[4])
pragma_4 = list(pragmas[4])[0]
assert isinstance(pragma_4, PragmaNoCondition)
assert sorted(pragma_4.conditions) == ['F T', 'T F']
assert not pragmas[5]
assert not pragmas[6]
def test_pragma_no_cond_with_condition_selector(self):
from instrumental.pragmas import PragmaNoCondition
source = """
acc = 1
acc += 2
tot, err = a and b, c or d # pragma: no cond[.2](T F)
assert tot or err
"""
pragmas = self.finder.find_pragmas(source)
assert 5 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert 1 == len(pragmas[4])
pragma_4_2 = list(pragmas[4])[0]
assert isinstance(pragma_4_2, PragmaNoCondition)
assert pragma_4_2.conditions == ['T F']
assert not pragmas[5]
def test_pragma_no_cond_with_full_selector(self):
from instrumental.pragmas import PragmaNoCondition
source = """# pragma: no cond[4.2](T F)
acc = 1
acc += 2
tot, err = a and b, c or d
assert tot or err
"""
pragmas = self.finder.find_pragmas(source)
assert 5 == len(pragmas), pragmas
assert not pragmas[1]
assert not pragmas[2]
assert not pragmas[3]
assert 1 == len(pragmas[4])
pragma_4_2 = list(pragmas[4])[0]
assert isinstance(pragma_4_2, PragmaNoCondition)
assert pragma_4_2.selector == '2'
assert pragma_4_2.conditions == ['T F']
assert not pragmas[5]
def _get_pragmas(self, source):
from instrumental.pragmas import PragmaFinder
finder = PragmaFinder()
return finder.find_pragmas(source)