def combine(outfile, *infiles):
combined = ExecutionRecorder()
for filename in infiles:
store = ResultStore(os.path.dirname(filename), None,
os.path.basename(filename))
single = store.load()
combined.merge(single)
combined_store = ResultStore(os.path.dirname(outfile), None,
os.path.basename(outfile))
combined_store.save(combined)
def _run_test(self, *args, **kwargs):
from instrumental import api
from instrumental.recorder import ExecutionRecorder
ExecutionRecorder.reset()
c = api.Coverage(self.config, '.')
modname = kwargs.pop('modname', 'instrumental.test.samples.robust')
c.start([modname], [])
if modname in sys.modules:
testmod = sys.modules[modname]
reload(testmod)
else:
testmod = __import__(modname, fromlist=modname.split('.')[:-1])
testmod.test_func(*args, **kwargs)
c.stop()
return c.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_construct_with_literal(self):
recorder = ExecutionRecorder.get()
node = ast.BoolOp(op=ast.Or(),
values=[ast.Name(id="foo"),
ast.Str(s='""')],
lineno=1,
col_offset=0)
recorder.add_BoolOp('somemodule', '1.1', node, [], None)
def test_roundtrip(self):
from instrumental.storage import JSONSerializer
node = ast.BoolOp(op=ast.Or(),
values=[ast.Name(id='a'), ast.Name(id='b')],
lineno=4)
construct = LogicalOr('somemodule', '4.2', node, [])
construct.conditions = {0: set(), 1: set(['X']),
2: set([UnreachableCondition])}
metadata = ModuleMetadata('somemodule', 'somesource', [])
metadata.lines = {1: False, 2: False, 4: True}
metadata.constructs = {'4.2': construct}
recorder = ExecutionRecorder()
recorder.add_metadata(metadata)
f = StringIO()
JSONSerializer.dump(recorder, f)
f.seek(0)
got_recorder = JSONSerializer.load(f)
got_metadata = got_recorder.metadata['somemodule']
assert got_metadata.modulename == 'somemodule'
assert got_metadata.source == 'somesource'
assert got_metadata.lines == {1: False, 2: False, 4: True},(
got_metadata.lines)
got_construct = got_metadata.constructs['4.2']
assert got_construct.modulename == 'somemodule'
assert got_construct.label == '4.2'
assert got_construct.conditions == {0: set(),
1: set(['X']),
2: set([UnreachableCondition])}
got_node = got_construct.node
assert isinstance(got_node.op, ast.Or)
assert isinstance(got_node.values[0], ast.Name)
assert got_node.values[0].id == 'a'
assert isinstance(got_node.values[1], ast.Name)
assert got_node.values[1].id == 'b'
assert got_node.lineno == 4
def test_add_a_non_BoolOp(self):
recorder = ExecutionRecorder.get()
node = ast.BoolOp(op=4,
values=[ast.Name(id="foo"),
ast.Str(s='""')],
lineno=1,
col_offset=0)
try:
recorder.add_BoolOp('somemodule', node, [], None)
except TypeError as exc:
assert "BoolOp" in str(exc), exc
def test_roundtrip(self):
from instrumental.storage import ResultStore
node = ast.BoolOp(op=ast.Or(),
values=[ast.Name(id='a'), ast.Name(id='b')],
lineno=4)
construct = LogicalOr('somemodule', '4.2', node, [])
construct.conditions = {0: set(), 1: set(['X']),
2: set([UnreachableCondition])}
metadata = ModuleMetadata('somemodule', 'somesource', [])
metadata.lines = {1: False, 2: False, 4: True}
metadata.constructs = {'4.2': construct}
recorder = ExecutionRecorder()
recorder.add_metadata(metadata)
store = self._makeOne('.', 'testing', None)
store.save(recorder)
got_recorder = store.load()
os.remove(store.filename)
got_metadata = got_recorder.metadata['somemodule']
assert got_metadata.modulename == 'somemodule'
assert got_metadata.source == 'somesource'
assert got_metadata.lines == {1: False, 2: False, 4: True},(
got_metadata.lines)
got_construct = got_metadata.constructs['4.2']
assert got_construct.modulename == 'somemodule'
assert got_construct.label == '4.2'
assert got_construct.conditions == {0: set(),
1: set(['X']),
2: set([UnreachableCondition])}
got_node = got_construct.node
assert isinstance(got_node.op, ast.Or)
assert isinstance(got_node.values[0], ast.Name)
assert got_node.values[0].id == 'a'
assert isinstance(got_node.values[1], ast.Name)
assert got_node.values[1].id == 'b'
assert got_node.lineno == 4
def test_Encode_ExecutionRecorder(self):
from instrumental.storage import ObjectEncoder as OE
node = ast.BoolOp(op=ast.Or(),
values=[ast.Name(id='a'), ast.Name(id='b')],
lineno=4)
construct = LogicalOr('somemodule', '4.2', node, [])
construct.conditions = {0: set(), 1: set(['X']), 2: set()}
metadata = ModuleMetadata('somemodule', 'somesource', [])
metadata.lines = {1: False, 2: False, 4: True}
metadata.constructs = {'4.2': construct}
recorder = ExecutionRecorder()
recorder.add_metadata(metadata)
result = OE().encode(recorder)
expected_construct = {'__python_class__': 'LogicalOr',
'modulename': 'somemodule',
'label': '4.2',
'node': {'__python_class__': 'BoolOp',
'op': {'__python_class__': 'Or'},
'values': [{'__python_class__': 'Name',
'id': 'a'},
{'__python_class__': 'Name',
'id': 'b'}],
'lineno': 4,
},
'conditions': {0: [], 1: ['X'], 2: []},
}
expected_metadata = {'__python_class__': 'ModuleMetadata',
'modulename': 'somemodule',
'source': 'somesource',
'lines': {1: False, 2: False, 4: True},
'constructs': {'4.2': expected_construct},
}
expected = {'__python_class__': 'ExecutionRecorder',
'metadata': {'somemodule': expected_metadata},
}
assert result == expected, (result, expected)
def test_load_non_target_module(self):
from instrumental.instrument import AnnotatorFactory
from instrumental.monkey import load_module_factory
from instrumental.recorder import ExecutionRecorder
recorder = ExecutionRecorder.get()
visitor_factory = AnnotatorFactory(self.config, recorder)
load_module = load_module_factory([], [], visitor_factory)
import instrumental.test.samples
samples_directory = os.path.dirname(instrumental.test.samples.__file__)
simple_name = 'instrumental.test.samples.simple'
simple_path = os.path.join(samples_directory, 'simple.py')
simple_fh = open(simple_path, 'r')
load_module(simple_name, simple_fh, simple_path,
('.py', 'r', imp.PY_SOURCE))
assert simple_name in sys.modules
def setup(self):
self.config = DummyConfig()
ExecutionRecorder.reset()
ExecutionRecorder.get().start()
def decode_ExecutionRecorder(self, d):
recorder = ExecutionRecorder()
for modulename in d['metadata']:
md = self.decode_ModuleMetadata(d['metadata'][modulename])
recorder.add_metadata(md)
return recorder
def __setup_recorder(): # pragma: no cover
from instrumental.recorder import ExecutionRecorder
_xxx_recorder_xxx_ = ExecutionRecorder.get()
def setup(self):
# Reset recorder
ExecutionRecorder.reset()
def setup(self):
from instrumental.recorder import ExecutionRecorder
ExecutionRecorder.reset()
self._pre_test_modules = sys.modules.keys()
self.config = DummyConfig()
def setup(self):
# First clear out the recorder so that we'll create a new one
ExecutionRecorder.reset()
self.recorder = ExecutionRecorder.get()
self.config = DummyConfig()
def teardown(self):
ExecutionRecorder.get().stop()
def recorder(self):
return ExecutionRecorder.get()
def setup(self):
# First clear out the recorder so that we'll create a new one
ExecutionRecorder.reset()
self.recorder = ExecutionRecorder.get()
self.recorder.start()
