def test_file_token(self):
base_path = __file__.replace(os.path.sep, '/')
if base_path.endswith('.pyc'):
base_path = base_path[:-1]
my_dir = os.path.dirname(base_path)
os.chdir(my_dir)
test_stage = Session().load_file(filepath='FileTokenSub.nxt')
comp_layer = test_stage.build_stage()
fake_path = os.path.join(my_dir, 'notafile.txt')
fake_path = fake_path.replace(os.path.sep, '/')
real_path = os.path.join(my_dir, 'real_file.txt')
real_path = real_path.replace(os.path.sep, '/')
test_node = test_stage.top_layer.lookup('/tokens')
file_fake = test_stage.get_node_attr_value(test_node,
'file_fake',
comp_layer,
resolved=True)
self.assertEqual('', file_fake)
file_real = test_stage.get_node_attr_value(test_node,
'file_real',
comp_layer,
resolved=True)
self.assertEqual(real_path, file_real)
path_fake = test_stage.get_node_attr_value(test_node,
'path_fake',
comp_layer,
resolved=True)
self.assertEqual(fake_path, path_fake)
path_real = test_stage.get_node_attr_value(test_node,
'path_real',
test_stage.top_layer,
resolved=True)
self.assertEqual(real_path, path_real)
def spec_test(self):
stage = Session().load_file(filepath=filename)
r = LayerReturnTypes.Node
for input_node in stage.top_layer.descendants(return_type=r):
# Only concerned with test input nodes
name = getattr(input_node, INTERNAL_ATTRS.NAME)
if not name.startswith('test'):
continue
if not name.endswith('input'):
continue
input_path = stage.top_layer.get_node_path(input_node)
rt_layer = stage.execute(input_path)
# Gather expectations
expected_resolve_path = input_path.replace('input', 'resolved')
expected_resolve_node = stage.top_layer.lookup(
expected_resolve_path)
expected_cache_path = input_path.replace('input', 'cached')
expected_cache_node = stage.top_layer.lookup(expected_cache_path)
cached_node = rt_layer.lookup(input_path)
# Assert computes are equal
resolved_code = stage.get_node_code_string(
input_node,
layer=stage.top_layer,
data_state=DATA_STATE.RESOLVED)
expected_resolve_code = stage.get_node_code_string(
expected_resolve_node,
layer=stage.top_layer.lookup,
data_state=DATA_STATE.RAW)
self.assertEqual(expected_resolve_code, resolved_code)
cached_code = getattr(cached_node, INTERNAL_ATTRS.CACHED_CODE)
expected_cached_code = stage.get_node_code_string(
expected_cache_node, layer=rt_layer, data_state=DATA_STATE.RAW)
self.assertEqual(expected_cached_code, cached_code)
# Assert attrs are equal
for attr_name in stage.get_node_attr_names(input_node):
resolved_attr_val = stage.get_node_attr_value(input_node,
attr_name,
stage.top_layer,
resolved=True)
excpected_resolve_attr_val = stage.get_node_attr_value(
expected_resolve_node,
attr_name,
stage.top_layer,
resolved=False)
self.assertEqual(excpected_resolve_attr_val, resolved_attr_val)
cached_attr_val = getattr(cached_node, attr_name)
expected_cached_attr_val = stage.get_node_attr_value(
expected_cache_node, attr_name, stage.top_layer)
self.assertEqual(expected_cached_attr_val, cached_attr_val)
def test_sibling_path(self):
"""Test that resolution of a filename only returns a file next to it.
NOTE: this test depends on the test folder structure. It is using a
test graph `TokenSiblingTest.nxt` that must be a direct sibling
to this test file. The contents of that file are also depended on.
If you find one of these files without the other, something is wrong.
"""
base_path = __file__.replace(os.path.sep, '/')
if base_path.endswith('.pyc'):
base_path = base_path[:-1]
base_name = os.path.basename(base_path)
in_val = '${file::' + base_name + '}'
expected = base_path
test_attr = 'my_file'
my_dir = os.path.dirname(base_path)
os.chdir(my_dir)
test_stage = Session().load_file(filepath='TokenSiblingTest.nxt')
comp_layer = test_stage.build_stage()
test_node = test_stage.top_layer.lookup('/tester')
test_stage.add_node_attr(test_node, test_attr, {'value': in_val},
test_stage.top_layer)
result = test_stage.get_node_attr_value(test_node, test_attr,
comp_layer)
self.assertEqual(expected, result)
class SubGraphs(unittest.TestCase):
def setUp(self):
os.chdir(os.path.dirname(__file__))
self.stage = Session().load_file(filepath="test_sub_graph.nxt")
def test_basic_run(self):
"""Test that a sub graph is run. The node that is run calls a sub-graph
that creates a file. If that file is there, we can assert the garph has
run.
"""
expected_file = os.path.join(os.path.dirname(__file__),
'sub_graph_file.txt')
# The file must not exist if we are going to believe the graph made it.
if os.path.isfile(expected_file):
os.remove(expected_file)
self.assertFalse(os.path.isfile(expected_file))
self.stage.execute(start='/basic_file')
self.assertTrue(os.path.isfile(expected_file))
# Clean up after the test
os.remove(expected_file)
def test_parameters(self):
"""Test that local attributes of a node that calls a sub graph are
pushed to the sub graph world node, and that resulting attributes of
the sub graph world node are pulled back into the calling node.
"""
target_path = '/specific_file'
comp_layer = self.stage.build_stage()
specific_node = comp_layer.lookup(target_path)
expected_file = self.stage.get_node_attr_value(specific_node,
'location', comp_layer)
# The file must not exist if we are going to believe the graph made it.
if os.path.isfile(expected_file):
os.remove(expected_file)
self.assertFalse(os.path.isfile(expected_file))
self.stage.execute(start=target_path)
self.assertTrue(os.path.isfile(expected_file))
# Clean up after the test
os.remove(expected_file)