def test_chaining(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'rows',
'data': {
'fields': ['a', 'b'],
'rows': [{
'a': 1,
'b': 2
}]
}
},
'b': {
'format': 'rows',
'data': {
'fields': ['a', 'b'],
'rows': [{
'a': 3,
'b': 4
}]
}
}
},
outputs={'c': {
'format': 'rows'
}})
outputs = run(self.analysis,
inputs={
'a': outputs['c'],
'b': {
'format': 'rows',
'data': {
'fields': ['a', 'b'],
'rows': [{
'a': 5,
'b': 6
}]
}
}
},
outputs={'c': {
'format': 'rows'
}})
self.assertEqual(outputs['c']['format'], 'rows')
self.assertEqual(
outputs['c']['data'], {
'fields': ['a', 'b'],
'rows': [{
'a': 1,
'b': 2
}, {
'a': 3,
'b': 4
}, {
'a': 5,
'b': 6
}]
})
def test_r(self):
outputs = run(self.analysis_r,
inputs={'a': {
'format': 'newick',
'data': self.newick
}},
outputs={'b': {
'format': 'newick'
}})
self.assertEqual(outputs['b']['format'], 'newick')
self.assertEqual(outputs['b']['data'], self.newick)
outputs = run(self.analysis_r,
inputs={'a': {
'format': 'nexus',
'data': self.nexus
}},
outputs={'b': {
'format': 'nexus'
}})
self.assertEqual(outputs['b']['format'], 'nexus')
# Ignore spaces vs. tabs, and skip timestamp comment on line 2
out = '\n'.join(outputs['b']['data'].splitlines()[2:])
out = ' '.join(out.split())
expected = '\n'.join(self.nexus.splitlines()[2:])
expected = ' '.join(expected.split())
self.assertEqual(out, expected)
def test_kwargs_debug(self):
"""Runs the table json test but with asserts for kwarg debugging"""
global _tmpfiles
run(self.analysis, self.inputs, self.outputs, write_script=True)
# Should have generated serveral files ()
self.assertGreater(len(_tmpfiles), 1)
def test_kwargs_debug(self):
"""Runs the table json test but with asserts for kwarg debugging"""
global _tmpfiles
run(
self.analysis, self.inputs, self.outputs, write_script=True)
# Should have generated serveral files ()
self.assertGreater(len(_tmpfiles), 1)
def test_function(self):
outputs = run(
self.function_out,
inputs={},
outputs={'output': {'format': 'object'}})
self.assertEqual(outputs['output']['data'](3)[0], 9)
outputs = run(
self.function_in, inputs={'input': outputs['output']})
self.assertEqual(outputs['output']['data'], 16)
def test_analysis_debug(self):
"""Runs the table json test but with asserts for analysis debugging"""
global _tmpfiles
run(dict(self.analysis.items() + [('write_script', 1)]),
inputs=self.inputs,
outputs=self.outputs)
# Should have generated just one debug file
self.assertEquals(len(_tmpfiles), 1)
# File contents equals script
with open(_tmpfiles[0], 'r') as fh:
self.assertEquals(fh.read(), self.script)
def test_array(self):
outputs = run(
self.array_out,
inputs={},
outputs={'output': {'format': 'serialized'}})
self.assertEqual('\n'.join(outputs['output']['data'].split('\n')[3:]),
'131840\n14\n3\n1\n2\n3\n')
outputs = run(
self.array_in,
inputs={'input': outputs['output']},
outputs={'output': {'format': 'serialized'}})
self.assertEqual('\n'.join(outputs['output']['data'].split('\n')[3:]),
'131840\n14\n5\n1\n2\n3\n4\n5\n')
def test_analysis_debug(self):
"""Runs the table json test but with asserts for analysis debugging"""
global _tmpfiles
run(
dict(self.analysis.items() + [('write_script', 1)]),
inputs=self.inputs, outputs=self.outputs)
# Should have generated just one debug file
self.assertEquals(len(_tmpfiles), 1)
# File contents equals script
with open(_tmpfiles[0], 'r') as fh:
self.assertEquals(fh.read(), self.script)
def test_pgls(self):
pgls = load(os.path.join(self.arbor_path, 'pgls.json'))
tree_file = os.path.join('data', 'anolis.phy')
table_file = os.path.join('data', 'anolisDataAppended.csv')
run(
pgls,
{
'tree': {'format': 'newick', 'url': 'file://' + tree_file},
'table': {'format': 'csv', 'url': 'file://' + table_file},
'correlation': {'format': 'text', 'data': 'BM'},
'ind_variable': {'format': 'text', 'data': 'SVL'},
'dep_variable': {'format': 'text', 'data': 'PCI_limbs'}
}
)
def test_pgls(self):
pgls = load(os.path.join(self.arbor_path, 'pgls.json'))
tree_file = os.path.join('data', 'anolis.phy')
table_file = os.path.join('data', 'anolisDataAppended.csv')
run(
pgls,
{
'tree': {'format': 'newick', 'url': 'file://' + tree_file},
'table': {'format': 'csv', 'url': 'file://' + table_file},
'correlation': {'format': 'text', 'data': 'BM'},
'ind_variable': {'format': 'text', 'data': 'SVL'},
'dep_variable': {'format': 'text', 'data': 'PCI_limbs'}
}
)
def test_cont2disc(self):
cont2disc = load(
os.path.join(self.arbor_path, 'continuous_to_discrete.json'))
table_file = os.path.join('data', 'anolisDataAppended.csv')
run(
cont2disc,
{
'table': {'format': 'csv', 'url': 'file://' + table_file},
'column': {'format': 'text', 'data': 'SVL'},
'thresh': {'format': 'number', 'data': 3.5}
},
{
'newtable': {'format': 'rows'}
}
)
def test_cont2disc(self):
cont2disc = load(
os.path.join(self.arbor_path, 'continuous_to_discrete.json'))
table_file = os.path.join('data', 'anolisDataAppended.csv')
run(
cont2disc,
{
'table': {'format': 'csv', 'url': 'file://' + table_file},
'column': {'format': 'text', 'data': 'SVL'},
'thresh': {'format': 'number', 'data': 3.5}
},
{
'newtable': {'format': 'rows'}
}
)
def testCreateTgz(self):
task = {
'inputs': [{
'id': 'myArchive',
'type': 'directory',
'format': 'tgz'
}],
'outputs': [{
'id': 'output',
'type': 'string',
'format': 'text'
}],
'script': 'output = myArchive',
'mode': 'python'
}
outputs = run(task, inputs={
'myArchive': {
'format': 'path',
'data': self.createFromDir
}
})
path = outputs['output']['data']
self.assertEqual(path, os.path.join(DATA_DIR, 'shapefile.tgz'))
self.assertTrue(os.path.isfile(path))
with tarfile.open(path, 'r') as tf:
names = tf.getnames()
self.assertTrue('shapefile/shapefile.cpg' in names)
self.assertTrue('shapefile/shapefile.prj' in names)
def testCreateZip(self):
task = {
'inputs': [{
'id': 'myArchive',
'type': 'directory',
'format': 'zip'
}],
'outputs': [{
'id': 'output',
'type': 'string',
'format': 'text'
}],
'script': 'output = myArchive',
'mode': 'python'
}
outputs = run(task,
inputs={
'myArchive': {
'format': 'path',
'data': self.createFromDir
}
})
path = outputs['output']['data']
self.assertEqual(path, os.path.join(DATA_DIR, 'shapefile.zip'))
self.assertTrue(os.path.isfile(path))
with zipfile.ZipFile(path, 'r') as zf:
names = zf.namelist()
self.assertTrue('shapefile/shapefile.cpg' in names)
self.assertTrue('shapefile/shapefile.prj' in names)
def testSparkRddToJson(self):
analysis = {
'name': 'map',
'inputs': [
{'name': 'a', 'type': 'collection', 'format': 'spark.rdd'}
],
'outputs': [
{'name': 'b', 'type': 'collection', 'format': 'spark.rdd'}
],
'mode': 'spark.python',
'spark_conf': {
'spark.app.name': 'test_square',
'spark.master': os.environ['SPARK_TEST_MASTER_URL']
}
}
with open('data/spark_square_script.py', 'r') as fp:
script = fp.read()
analysis['script'] = script
outputs = run(analysis,
{'a': {'format': 'json',
'data': '[1,2,3,4,5,6,7,8,9]'}},
{'b': {'format': 'json'}})
expected = {
'b': {
'data': '[1, 4, 9, 16, 25, 36, 49, 64, 81]',
'format': 'json'
}
}
self.assertEqual(outputs, expected)
def testJsonToSparkRdd(self):
analysis = {
'name': 'reduce',
'inputs': [
{'name': 'a', 'type': 'collection', 'format': 'spark.rdd'}
],
'outputs': [
{'name': 'b', 'type': 'number', 'format': 'number'}
],
'mode': 'spark.python',
'spark_conf': {
'spark.app.name': 'test_add',
'spark.master': os.environ['SPARK_TEST_MASTER_URL']
}
}
with open('data/spark_add_script.py', 'r') as fp:
script = fp.read()
analysis['script'] = script
outputs = run(
analysis, {
'a': {
'format': 'json',
'data': '[1,2,3,4,5,6,7,8,9]'
}
}, {
'b': {'format': 'number'}
})
expected = {'b': {'data': 45, 'format': 'number'}}
self.assertEqual(outputs, expected)
def test_sniffer(self):
output = convert(
'table',
{
'format': 'csv',
'url': 'file://' + os.path.join('data', 'test.csv')
},
{'format': 'rows'}
)
self.assertEqual(len(output['data']['fields']), 32)
self.assertEqual(output['data']['fields'][:3], [
'FACILITY', 'ADDRESS', 'DATE OF INSPECTION'
])
self.assertEqual(len(output['data']['rows']), 14)
flu = load(os.path.join(
self.analysis_path, 'xdata', 'flu.json'))
output = run(
flu,
inputs={},
outputs={'data': {'type': 'table', 'format': 'rows'}}
)
self.assertEqual(output['data']['data']['fields'][:3], [
'Date', 'United States', 'Alabama'
])
def testCreateTgz(self):
task = {
'inputs': [{
'id': 'myArchive',
'type': 'directory',
'format': 'tgz'
}],
'outputs': [{
'id': 'output',
'type': 'string',
'format': 'text'
}],
'script': 'output = myArchive',
'mode': 'python'
}
outputs = run(task,
inputs={
'myArchive': {
'format': 'path',
'data': self.createFromDir
}
})
path = outputs['output']['data']
self.assertEqual(path, os.path.join(DATA_DIR, 'shapefile.tgz'))
self.assertTrue(os.path.isfile(path))
with tarfile.open(path, 'r') as tf:
names = tf.getnames()
self.assertTrue('shapefile/shapefile.cpg' in names)
self.assertTrue('shapefile/shapefile.prj' in names)
def testCreateZip(self):
task = {
'inputs': [{
'id': 'myArchive',
'type': 'directory',
'format': 'zip'
}],
'outputs': [{
'id': 'output',
'type': 'string',
'format': 'text'
}],
'script': 'output = myArchive',
'mode': 'python'
}
outputs = run(task, inputs={
'myArchive': {
'format': 'path',
'data': self.createFromDir
}
})
path = outputs['output']['data']
self.assertEqual(path, os.path.join(DATA_DIR, 'shapefile.zip'))
self.assertTrue(os.path.isfile(path))
with zipfile.ZipFile(path, 'r') as zf:
names = zf.namelist()
self.assertTrue('shapefile/shapefile.cpg' in names)
self.assertTrue('shapefile/shapefile.prj' in names)
def test_bson(self):
import pymongo
outputs = run(
self.analysis,
inputs={
'a': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'a'
},
'b': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'b'
}
},
outputs={
'c': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'temp'
}
})
self.assertEqual(outputs['c']['format'], 'objectlist.bson')
coll = pymongo.MongoClient('mongodb://localhost')['test']['temp']
self.assertEqual([d for d in coll.find()], [self.aobj, self.bobj])
def test_bson(self):
import pymongo
outputs = run(self.analysis,
inputs={
'a': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'a'
},
'b': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'b'
}
},
outputs={
'c': {
'format': 'objectlist.bson',
'mode': 'mongodb',
'db': 'test',
'collection': 'temp'
}
})
self.assertEqual(outputs['c']['format'], 'objectlist.bson')
coll = pymongo.MongoClient('mongodb://localhost')['test']['temp']
self.assertEqual([d for d in coll.find()], [self.aobj, self.bobj])
def test_r_dataframe(self):
outputs = run(self.analysis_r,
inputs={
'a': {
'format': 'rows',
'data': {
'fields': ['aa', 'bb'],
'rows': [{
'aa': 1,
'bb': 2
}]
}
}
},
outputs={'b': {
'format': 'rows'
}})
self.assertEqual(outputs['b']['format'], 'rows')
self.assertEqual(outputs['b']['data'], {
'fields': ['aa', 'bb'],
'rows': [{
'aa': 1,
'bb': 2
}]
})
def test_newick(self):
outputs = run(
self.analysis,
inputs={'a': {'format': 'newick', 'data': self.newick}},
outputs={'b': {'format': 'newick'}}
)
self.assertEqual(outputs['b']['format'], 'newick')
self.assertEqual(outputs['b']['data'], self.newick)
def testExtractTgz(self):
outputs = run(self.extractTask, inputs={"myDir": {"format": "tgz", "data": self.tarFile}})
self.assertEqual(set(outputs["files"]["data"]), set(("provision.retry", "site.retry")))
self.assertEqual(outputs["myDir"]["data"], self.tarDir)
self.assertTrue(os.path.isdir(self.tarDir))
self.assertTrue(os.path.isfile(os.path.join(self.tarDir, "site.retry")))
self.assertTrue(os.path.isfile(os.path.join(self.tarDir, "provision.retry")))
def test_numeric(self):
outputs = run(
self.analysis,
inputs={"a": {"format": "number_list", "data": [1, 2]}, "b": {"format": "number_list", "data": [3, 4]}},
outputs={"c": {"format": "number_list"}},
)
self.assertEqual(outputs["c"]["format"], "number_list")
self.assertEqual(outputs["c"]["data"], [1, 2, 3, 4])
def test_json(self):
outputs = run(
self.analysis,
inputs={"a": {"format": "json", "data": "[1, 2]"}, "b": {"format": "json", "data": "[3, 4]"}},
outputs={"c": {"format": "json"}},
)
self.assertEqual(outputs["c"]["format"], "json")
self.assertEqual(outputs["c"]["data"], "[1, 2, 3, 4]")
def test_workflow(self):
outputs = run(
self.workflow,
inputs={
'x': {'format': 'json', 'data': '1'},
'y': {'format': 'number', 'data': 2}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (1+3)*(2+2))
# Test using the default value for x (10).
outputs = run(
self.workflow,
inputs={
'y': {'format': 'number', 'data': 2}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (10+3)*(2+2))
def test_multi_input(self):
outputs = run(
self.multi_input,
inputs={
'x': {'format': 'number', 'data': 2},
'y': {'format': 'number', 'data': 3}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (2*2)+(3*3))
def test_workflow(self):
outputs = run(
self.workflow,
inputs={
'x': {'format': 'json', 'data': '1'},
'y': {'format': 'number', 'data': 2}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (1+3)*(2+2))
# Test using the default value for x (10).
outputs = run(
self.workflow,
inputs={
'y': {'format': 'number', 'data': 2}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (10+3)*(2+2))
def test_multi_input(self):
outputs = run(
self.multi_input,
inputs={
'x': {'format': 'number', 'data': 2},
'y': {'format': 'number', 'data': 3}
})
self.assertEqual(outputs['result']['format'], 'number')
self.assertEqual(outputs['result']['data'], (2*2)+(3*3))
def test_json(self):
outputs = run(self.analysis,
inputs=self.test_input,
outputs={'c': {
'format': 'rows.json'
}})
self.assertEqual(outputs['c']['format'], 'rows.json')
self.assertEqual(
outputs['c']['data'], '{"fields": ["aa", "bb"], '
'"rows": [{"aa": 1, "bb": 2}, {"aa": 3, "bb": 4}]}')
def test_r_apetree(self):
outputs = run(
self.analysis,
inputs={'a': {'format': 'newick', 'data': self.newick}},
outputs={'b': {'format': 'r.apetree'}}
)
self.assertEqual(outputs['b']['format'], 'r.apetree')
self.assertEqual(
str(outputs['b']['data'])[:52],
'\nPhylogenetic tree with 3 tips and 2 internal nodes.')
def test_base64(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'png.base64',
'data': self.image
},
})
self.assertEqual(outputs['pixels']['format'], 'number')
self.assertEqual(outputs['pixels']['data'], 256)
def test_json(self):
outputs = run(self.analysis,
inputs={'a': {
'format': 'newick',
'data': self.newick
}},
outputs={'b': {
'format': 'nested'
}})
self.assertEqual(outputs['b']['format'], 'nested')
expected = {
'edge_fields': ['weight'],
'node_fields': ['node name', 'node weight'],
'node_data': {
'node name': '',
'node weight': 0.0
},
'children': [{
'node_data': {
'node name': '',
'node weight': 2.0
},
'edge_data': {
'weight': 2.0
},
'children': [{
'node_data': {
'node name': 'ahli',
'node weight': 2.0
},
'edge_data': {
'weight': 0.0
}
}, {
'node_data': {
'node name': 'allogus',
'node weight': 3.0
},
'edge_data': {
'weight': 1.0
}
}]
}, {
'node_data': {
'node name': 'rubribarbus',
'node weight': 3.0
},
'edge_data': {
'weight': 3.0
}
}]
}
self.assertEqual(outputs['b']['data'], expected)
def test_float(self):
outputs = run(
self.analysis,
inputs={
"a": {"format": "number_list", "data": [1.5, 2.5]},
"b": {"format": "number_list", "data": [3.5, 4.5]},
},
outputs={"c": {"format": "number_list"}},
)
self.assertEqual(outputs["c"]["format"], "number_list")
self.assertEqual(outputs["c"]["data"], [1.5, 2.5, 3.5, 4.5])
def test_newick(self):
outputs = run(self.analysis,
inputs={'a': {
'format': 'newick',
'data': self.newick
}},
outputs={'b': {
'format': 'newick'
}})
self.assertEqual(outputs['b']['format'], 'newick')
self.assertEqual(outputs['b']['data'], self.newick)
def test_json(self):
outputs = run(
self.analysis,
inputs=self.test_input,
outputs={
'c': {'format': 'rows.json'}
})
self.assertEqual(outputs['c']['format'], 'rows.json')
self.assertEqual(
outputs['c']['data'],
'{"fields": ["aa", "bb"], '
'"rows": [{"aa": 1, "bb": 2}, {"aa": 3, "bb": 4}]}')
def test_json(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'json', 'data': '1'},
'b': {'format': 'json', 'data': '2'}
},
outputs={
'c': {'format': 'json'}
})
self.assertEqual(outputs['c']['format'], 'json')
self.assertEqual(outputs['c']['data'], '3')
def test_cone(self):
outputs = run(
self.cone,
inputs={
'resolution': {'format': 'number', 'data': 100},
'radius': {'format': 'number', 'data': 1}
})
self.assertEqual(outputs['cone']['format'], 'vtkpolydata')
cone = outputs['cone']['data']
self.assertTrue(isinstance(cone, vtk.vtkPolyData))
self.assertEqual(cone.GetNumberOfCells(), 101)
self.assertEqual(cone.GetNumberOfPoints(), 101)
def test_string(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'string_list', 'data': ['a', 'b']},
'b': {'format': 'string_list', 'data': ['c', 'd']}
},
outputs={
'c': {'format': 'string_list'}
})
self.assertEqual(outputs['c']['format'], 'string_list')
self.assertEqual(outputs['c']['data'], ['a', 'b', 'c', 'd'])
def test_integer(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'integer', 'data': 1},
'b': {'format': 'integer', 'data': 2}
},
outputs={
'c': {'format': 'integer'}
})
self.assertEqual(outputs['c']['format'], 'integer')
self.assertEqual(outputs['c']['data'], 3)
def test_json(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'json', 'data': '["a", "b"]'},
'b': {'format': 'json', 'data': '["c", "d"]'}
},
outputs={
'c': {'format': 'json'}
})
self.assertEqual(outputs['c']['format'], 'json')
self.assertEqual(outputs['c']['data'], '["a", "b", "c", "d"]')
def test_integer(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'integer_list', 'data': [1, 2]},
'b': {'format': 'integer_list', 'data': [3, 4]}
},
outputs={
'c': {'format': 'integer_list'}
})
self.assertEqual(outputs['c']['format'], 'integer_list')
self.assertEqual(outputs['c']['data'], [1, 2, 3, 4])
def test_string(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'string', 'data': 'hi, '},
'b': {'format': 'text', 'data': 'there'}
},
outputs={
'c': {'format': 'text'}
})
self.assertEqual(outputs['c']['format'], 'text')
self.assertEqual(outputs['c']['data'], 'hi, there')
def test_float(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'number', 'data': 1.5},
'b': {'format': 'number', 'data': 2.5}
},
outputs={
'c': {'format': 'number'}
})
self.assertEqual(outputs['c']['format'], 'number')
self.assertEqual(outputs['c']['data'], 4)
def test_numeric(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'number', 'data': 1},
'b': {'format': 'number', 'data': 2}
},
outputs={
'c': {'format': 'number'}
})
self.assertEqual(outputs['c']['format'], 'number')
self.assertEqual(outputs['c']['data'], 3)
def test_json(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'json', 'data': '1'},
'b': {'format': 'json', 'data': '2'}
},
outputs={
'c': {'format': 'json'}
})
self.assertEqual(outputs['c']['format'], 'json')
self.assertEqual(outputs['c']['data'], '3')
def test_json(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'json', 'data': '["a", "b"]'},
'b': {'format': 'json', 'data': '["c", "d"]'}
},
outputs={
'c': {'format': 'json'}
})
self.assertEqual(outputs['c']['format'], 'json')
self.assertEqual(outputs['c']['data'], '["a", "b", "c", "d"]')
def test_string(self):
outputs = run(
self.analysis,
inputs={
'a': {'format': 'string_list', 'data': ['a', 'b']},
'b': {'format': 'string_list', 'data': ['c', 'd']}
},
outputs={
'c': {'format': 'string_list'}
})
self.assertEqual(outputs['c']['format'], 'string_list')
self.assertEqual(outputs['c']['data'], ['a', 'b', 'c', 'd'])
def test_r(self):
outputs = run(
self.analysis_r,
inputs={'a': {'format': 'newick', 'data': self.newick}},
outputs={'b': {'format': 'newick'}}
)
self.assertEqual(outputs['b']['format'], 'newick')
self.assertEqual(outputs['b']['data'], self.newick)
outputs = run(
self.analysis_r,
inputs={'a': {'format': 'nexus', 'data': self.nexus}},
outputs={'b': {'format': 'nexus'}}
)
self.assertEqual(outputs['b']['format'], 'nexus')
# Ignore spaces vs. tabs, and skip timestamp comment on line 2
out = '\n'.join(outputs['b']['data'].splitlines()[2:])
out = ' '.join(out.split())
expected = '\n'.join(self.nexus.splitlines()[2:])
expected = ' '.join(expected.split())
self.assertEqual(out, expected)
def test_r_apetree(self):
outputs = run(self.analysis,
inputs={'a': {
'format': 'newick',
'data': self.newick
}},
outputs={'b': {
'format': 'r.apetree'
}})
self.assertEqual(outputs['b']['format'], 'r.apetree')
self.assertEqual(
str(outputs['b']['data'])[:52],
'\nPhylogenetic tree with 3 tips and 2 internal nodes.')
def test_file(self):
tmp = tempfile.mktemp()
outputs = run(
self.analysis,
inputs=self.test_input,
outputs={'c': {
'format': 'csv',
'path': tmp,
'mode': 'local'
}})
with open(tmp, 'r') as fp:
output = fp.read()
os.remove(tmp)
self.assertEqual(outputs['c']['format'], 'csv')
self.assertEqual(output.splitlines(), ['aa,bb', '1,2', '3,4'])
def testExtractTgz(self):
outputs = run(
self.extractTask,
inputs={'myDir': {
'format': 'tgz',
'data': self.tarFile
}})
self.assertEqual(set(outputs['files']['data']),
set(('provision.retry', 'site.retry')))
self.assertEqual(outputs['myDir']['data'], self.tarDir)
self.assertTrue(os.path.isdir(self.tarDir))
self.assertTrue(os.path.isfile(os.path.join(self.tarDir,
'site.retry')))
self.assertTrue(
os.path.isfile(os.path.join(self.tarDir, 'provision.retry')))
def test_float(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'number',
'data': 1.5
},
'b': {
'format': 'number',
'data': 2.5
}
},
outputs={'c': {
'format': 'number'
}})
self.assertEqual(outputs['c']['format'], 'number')
self.assertEqual(outputs['c']['data'], 4)
def test_float(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'number_list',
'data': [1.5, 2.5]
},
'b': {
'format': 'number_list',
'data': [3.5, 4.5]
}
},
outputs={'c': {
'format': 'number_list'
}})
self.assertEqual(outputs['c']['format'], 'number_list')
self.assertEqual(outputs['c']['data'], [1.5, 2.5, 3.5, 4.5])
def test_string(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'string',
'data': 'hi, '
},
'b': {
'format': 'text',
'data': 'there'
}
},
outputs={'c': {
'format': 'text'
}})
self.assertEqual(outputs['c']['format'], 'text')
self.assertEqual(outputs['c']['data'], 'hi, there')
def test_unicode(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'text',
'data': u'hi, '
},
'b': {
'format': 'text',
'data': u'there'
}
},
outputs={'c': {
'format': 'text'
}})
self.assertEqual(outputs['c']['format'], 'text')
self.assertEqual(outputs['c']['data'], u'hi, there')
self.assertIsInstance(outputs['c']['data'], unicode)
def test_singlerow(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'csv',
'data': 'A,one,two'
},
'b': {
'format': 'csv',
'data': 'A,three,four'
}
},
outputs={'c': {
'format': 'csv'
}})
self.assertEqual(outputs['c']['format'], 'csv')
# Only the 'header' of the first input is preserved.
self.assertEqual(outputs['c']['data'].splitlines(), ['A,one,two'])
def test_tsv(self):
outputs = run(self.analysis,
inputs={
'a': {
'format': 'csv',
'data': 'a,b,c\n1,2,3'
},
'b': {
'format': 'tsv',
'data': 'a\tb\tc\n4\t5\t6'
}
},
outputs={'c': {
'format': 'tsv'
}})
self.assertEqual(outputs['c']['format'], 'tsv')
self.assertEqual(outputs['c']['data'].splitlines(),
['a\tb\tc', '1\t2\t3', '4\t5\t6'])
