def test_ingestion_simple(self):
self.simple_system()
self.bsg.finalize()
procedural = sorted(self.bsg.specs.keys())
second = BuildSystemGenerator(self.bsg.funcs)
second.ingest(self.simple_jobs)
second.finalize()
ingested = sorted(second.specs.keys())
self.assertEqual(procedural, ingested)
def test_ingestion_simple(self):
self.simple_system()
self.bsg.finalize()
procedural = sorted(self.bsg.specs.keys())
second = BuildSystemGenerator(self.bsg.funcs)
second.ingest(self.simple_jobs)
second.finalize()
ingested = sorted(second.specs.keys())
self.assertEqual(procedural, ingested)
class TestBuildSystemGeneratorFinalize(TestCase):
@classmethod
def setUp(self):
self.bsg = BuildSystemGenerator()
def test_add_tasks_to_stage_invalid(self):
self.assertEqual(
None,
self.bsg._add_tasks_to_stage(False, 1, 3, {'a': 'b'}, ['a', 'b']))
def test_finalize_on_empty(self):
self.assertFalse(self.bsg._final)
self.assertEqual(None, self.bsg.system)
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_finalize_second_time(self):
self.bsg._final = True
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_finalize_with_non_clean_system(self):
self.assertFalse(self.bsg._final)
self.assertEqual(None, self.bsg.system)
self.bsg.system = True
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_final_toggles_final_state(self):
self.assertFalse(self.bsg._final)
self.bsg._process_job({
'stage': 'test0',
'dir': '/tmp',
'cmd': 'touch',
'args': ['a', 'b']
})
self.bsg.finalize()
self.assertTrue(self.bsg._final)
def test_final_creates_build_system_object(self):
self.assertFalse(self.bsg._final)
self.bsg._process_job({
'stage': 'test0',
'dir': '/tmp',
'cmd': 'touch',
'args': ['a', 'b']
})
self.bsg.finalize()
self.assertTrue(isinstance(self.bsg.system, BuildSystem))
class TestBuildSystemGeneratorFinalize(TestCase):
@classmethod
def setUp(self):
self.bsg = BuildSystemGenerator()
def test_add_tasks_to_stage_invalid(self):
self.assertEqual(None, self.bsg._add_tasks_to_stage(False, 1, 3, {'a': 'b'}, ['a', 'b']))
def test_finalize_on_empty(self):
self.assertFalse(self.bsg._final)
self.assertEqual(None, self.bsg.system)
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_finalize_second_time(self):
self.bsg._final = True
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_finalize_with_non_clean_system(self):
self.assertFalse(self.bsg._final)
self.assertEqual(None, self.bsg.system)
self.bsg.system = True
with self.assertRaises(InvalidSystem):
self.bsg.finalize()
def test_final_toggles_final_state(self):
self.assertFalse(self.bsg._final)
self.bsg._process_job({
'stage': 'test0',
'dir': '/tmp',
'cmd': 'touch',
'args': ['a', 'b']
})
self.bsg.finalize()
self.assertTrue(self.bsg._final)
def test_final_creates_build_system_object(self):
self.assertFalse(self.bsg._final)
self.bsg._process_job({
'stage': 'test0',
'dir': '/tmp',
'cmd': 'touch',
'args': ['a', 'b']
})
self.bsg.finalize()
self.assertTrue(isinstance(self.bsg.system, BuildSystem))
def stages(jobs, stages, file, check):
"""
Main public function to generate and run a
:class:`~system.BuildSystemGenerator()` build system.
"""
if os.path.isdir('buildc') or os.path.exists('buildc.py'):
try:
from buildc import functions
except ImportError:
from buildc import funcs as functions
else:
functions = None
else:
functions = None
strings = _import_strings()
bsg = BuildSystemGenerator(functions)
bsg.check_method = check
if functions is None:
logger.info('no python functions pre-loaded')
for fn in file:
if fn.endswith('json'):
bsg.ingest_json(fn, strings)
elif fn.endswith('yaml') or fn.endswith('yml'):
bsg.ingest_yaml(fn, strings)
else:
logger.warning('format of {0} is unclear, not parsing'.format(fn))
bsg.finalize()
bsg.system.workers(jobs)
if not stages:
bsg.system.run()
else:
bsg = narrow_buildsystem(stages, bsg.system)
bsg.system.workers(jobs)
bsg.run()
def stages(jobs, stages, file, check):
"""
Main public function to generate and run a
:class:`~system.BuildSystemGenerator()` build system.
"""
if os.path.isdir('buildc') or os.path.exists('buildc.py'):
try:
from buildc import functions
except ImportError:
from buildc import funcs as functions
else:
functions = None
else:
functions = None
strings = _import_strings()
bsg = BuildSystemGenerator(functions)
bsg.check_method = check
if functions is None:
logger.info('no python functions pre-loaded')
for fn in file:
if fn.endswith('json'):
bsg.ingest_json(fn, strings)
elif fn.endswith('yaml') or fn.endswith('yml'):
bsg.ingest_yaml(fn, strings)
else:
logger.warning('format of {0} is unclear, not parsing'.format(fn))
bsg.finalize()
bsg.system.workers(jobs)
if not stages:
bsg.system.run()
else:
bsg = narrow_buildsystem(stages, bsg.system)
bsg.system.workers(jobs)
bsg.run()
class TestBuildSystemGeneratorFunctional(TestCase):
@classmethod
def setUp(self):
self.funcs = {
'dumb': dummy_function,
'dump_new': dump_args_to_json_file_with_newlines,
'dump': dump_args_to_json_file,
'shell': subprocess.call
}
self.bsg = BuildSystemGenerator(self.funcs)
self.bsg.check_method = 'force'
self.complex_jobs = [{
'target': 'a',
'dep': ['b', 'f', 'r'],
'job': 'dumb',
'args': [None, None]
}, {
'target': 'b',
'dep': ['c', 'l'],
'job': 'dumb',
'args': [None, None]
}, {
'target': 'c',
'dep': ['r', 'l'],
'job': 'dumb',
'args': [None, None]
}, {
'target': 'r',
'dep': [],
'job': 'dumb',
'args': [None, None]
}, {
'target': 'f',
'dep': [],
'job': 'dumb',
'args': [None, None]
}, {
'target': 'l',
'dep': [],
'job': 'dumb',
'args': [None, None]
}]
self.simple_jobs = [{
'target': 'a',
'dep': 'b',
'job': 'dumb',
'args': [None, None]
}, {
'target': 'b',
'dep': 'c',
'job': 'dumb',
'args': [None, None]
}, {
'target': 'c',
'dep': [],
'job': 'dumb',
'args': [None, None]
}]
def simple_system(self):
for i in self.simple_jobs:
self.bsg._process_job(i)
def complex_system(self):
for i in self.complex_jobs:
self.bsg._process_job(i)
def test_dependency_ordering_one(self):
self.simple_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process, ['a', 'b', 'c'])
def test_graph_assemblage_simple_comp(self):
self.simple_system()
self.bsg.finalize()
self.assertTrue('a' in self.bsg._process_tree)
self.assertTrue('b' in self.bsg._process_tree)
self.assertTrue('c' in self.bsg._process_tree)
def test_graph_assemblage_simple_comp(self):
self.simple_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process_tree['a'], ['b'])
self.assertEqual(self.bsg._process_tree['b'], ['c'])
self.assertEqual(self.bsg._process_tree['c'], [])
def test_dependency_ordering_complex(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process, ['a', 'f', 'b', 'c', 'l', 'r'])
def test_dependency_ordering_complex_comp(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process_tree['a'], ['b', 'f', 'r'])
self.assertEqual(self.bsg._process_tree['b'], ['c', 'l'])
self.assertEqual(self.bsg._process_tree['c'], ['r', 'l'])
self.assertEqual(self.bsg._process_tree['r'], [])
self.assertEqual(self.bsg._process_tree['f'], [])
self.assertEqual(self.bsg._process_tree['l'], [])
def test_job_grouping(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg.system._stages[0], 'r')
job = (self.funcs['dumb'], (None, None))
for i in self.bsg.system.stages['r'].stage:
self.assertEqual(i, job)
def test_run_without_errors_complex(self):
self.complex_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_run_without_errors_simple(self):
self.simple_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_run_without_errors_combined(self):
self.complex_system()
self.simple_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_ingestion_simple(self):
self.simple_system()
self.bsg.finalize()
procedural = sorted(self.bsg.specs.keys())
second = BuildSystemGenerator(self.bsg.funcs)
second.ingest(self.simple_jobs)
second.finalize()
ingested = sorted(second.specs.keys())
self.assertEqual(procedural, ingested)
def test_buildsystem_narrowing_complex(self):
self.complex_system()
self.bsg.finalize()
new_bsg = narrow_buildsystem('c', self.bsg)
for i in ['c', 'r', 'l']:
self.assertTrue(i in new_bsg._process_tree)
self.assertTrue(len(new_bsg._process_tree) == 3)
class TestBuildSystemGeneratorFunctional(TestCase):
@classmethod
def setUp(self):
self.funcs = {
'dumb': dummy_function,
'dump_new': dump_args_to_json_file_with_newlines,
'dump': dump_args_to_json_file,
'shell': subprocess.call }
self.bsg = BuildSystemGenerator(self.funcs)
self.bsg.check_method = 'force'
self.complex_jobs = [
{
'target': 'a',
'dep': ['b', 'f', 'r'],
'job': 'dumb',
'args': [None, None]
},
{
'target': 'b',
'dep': ['c', 'l'],
'job': 'dumb',
'args': [None, None]
},
{
'target': 'c',
'dep': ['r', 'l'],
'job': 'dumb',
'args': [None, None]
},
{
'target': 'r',
'dep': [],
'job': 'dumb',
'args': [None, None]
},
{
'target': 'f',
'dep': [],
'job': 'dumb',
'args': [None, None]
},
{
'target': 'l',
'dep': [],
'job': 'dumb',
'args': [None, None]
}
]
self.simple_jobs = [
{
'target': 'a',
'dep': 'b',
'job': 'dumb',
'args': [None, None]
},
{
'target': 'b',
'dep': 'c',
'job': 'dumb',
'args': [None, None]
},
{
'target': 'c',
'dep': [],
'job': 'dumb',
'args': [None, None]
}
]
def simple_system(self):
for i in self.simple_jobs:
self.bsg._process_job(i)
def complex_system(self):
for i in self.complex_jobs:
self.bsg._process_job(i)
def test_dependency_ordering_one(self):
self.simple_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process, ['a', 'b', 'c'])
def test_graph_assemblage_simple_comp(self):
self.simple_system()
self.bsg.finalize()
self.assertTrue('a' in self.bsg._process_tree)
self.assertTrue('b' in self.bsg._process_tree)
self.assertTrue('c' in self.bsg._process_tree)
def test_graph_assemblage_simple_comp(self):
self.simple_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process_tree['a'], ['b'])
self.assertEqual(self.bsg._process_tree['b'], ['c'])
self.assertEqual(self.bsg._process_tree['c'], [])
def test_dependency_ordering_complex(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process, ['a', 'f', 'b', 'c', 'l', 'r'])
def test_dependency_ordering_complex_comp(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg._process_tree['a'], ['b', 'f', 'r'])
self.assertEqual(self.bsg._process_tree['b'], ['c', 'l'])
self.assertEqual(self.bsg._process_tree['c'], ['r', 'l'])
self.assertEqual(self.bsg._process_tree['r'], [])
self.assertEqual(self.bsg._process_tree['f'], [])
self.assertEqual(self.bsg._process_tree['l'], [])
def test_job_grouping(self):
self.complex_system()
self.bsg.finalize()
self.assertEqual(self.bsg.system._stages[0], 'r')
job = (self.funcs['dumb'], (None, None))
for i in self.bsg.system.stages['r'].stage:
self.assertEqual(i, job)
def test_run_without_errors_complex(self):
self.complex_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_run_without_errors_simple(self):
self.simple_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_run_without_errors_combined(self):
self.complex_system()
self.simple_system()
self.bsg.finalize()
self.assertTrue(self.bsg.system.run())
def test_ingestion_simple(self):
self.simple_system()
self.bsg.finalize()
procedural = sorted(self.bsg.specs.keys())
second = BuildSystemGenerator(self.bsg.funcs)
second.ingest(self.simple_jobs)
second.finalize()
ingested = sorted(second.specs.keys())
self.assertEqual(procedural, ingested)
def test_buildsystem_narrowing_complex(self):
self.complex_system()
self.bsg.finalize()
new_bsg = narrow_buildsystem('c', self.bsg)
for i in ['c', 'r', 'l']:
self.assertTrue(i in new_bsg._process_tree)
self.assertTrue(len(new_bsg._process_tree) == 3)
