def setUp(self):
spec_catalog = SpecCatalog()
for spec in self.getSpecs():
spec_catalog.register_spec(spec, 'test.yaml')
self.namespace = SpecNamespace(
'a test namespace', CORE_NAMESPACE, [{'source': 'test.yaml'}], catalog=spec_catalog)
self.vmap = ValidatorMap(self.namespace)
class TestObjectMapper(unittest.TestCase):
def setUp(self):
self.setUpBarSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_map(Bar, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.bar_spec)
def setUpBarSpec(self):
raise unittest.SkipTest('setUpBarSpec not implemented')
def test_default_mapping(self):
attr_map = self.mapper.get_attr_names(self.bar_spec)
keys = set(attr_map.keys())
for key in keys:
with self.subTest(key=key):
self.assertIs(attr_map[key], self.mapper.get_attr_spec(key))
self.assertIs(attr_map[key], self.mapper.get_carg_spec(key))
class TestBase(unittest.TestCase):
def setUp(self):
self.foo_spec = GroupSpec(
'A test group specification with a data type',
data_type_def='Foo',
datasets=[
DatasetSpec('an example dataset',
'int',
name='my_data',
attributes=[
AttributeSpec('attr2',
'an example integer attribute',
'int')
])
],
attributes=[
AttributeSpec('attr1', 'an example string attribute', 'text')
])
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.foo_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
self.type_map.register_map(Foo, ObjectMapper)
self.manager = BuildManager(self.type_map)
class TestDataMap(unittest.TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace', CORE_NAMESPACE, [{'source': 'test.yaml'}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec('an Baz type', 'int', name='MyBaz', data_type_def='Baz',
attributes=[AttributeSpec('baz_attr', 'an example string attribute', 'text')])
def test_build(self):
''' Test default mapping functionality when no attributes are nested '''
container = Baz('my_baz', list(range(10)), 'abcdefghijklmnopqrstuvwxyz')
builder = self.mapper.build(container, self.manager)
expected = DatasetBuilder('my_baz', list(range(10)), attributes={'baz_attr': 'abcdefghijklmnopqrstuvwxyz'})
self.assertDictEqual(builder, expected)
def setUp(self):
self.bar_spec = GroupSpec(
'A test group specification with a data type', data_type_def='Bar')
spec_catalog = SpecCatalog()
spec_catalog.register_spec(self.bar_spec, 'test.yaml')
namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=spec_catalog)
namespace_catalog = NamespaceCatalog()
namespace_catalog.add_namespace(CORE_NAMESPACE, namespace)
self.type_map = TypeMap(namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
class TestTypeMap(unittest.TestCase):
def setUp(self):
self.bar_spec = GroupSpec(
'A test group specification with a data type', data_type_def='Bar')
self.foo_spec = GroupSpec(
'A test group specification with data type Foo',
data_type_def='Foo')
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.spec_catalog.register_spec(self.foo_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
# self.build_manager = BuildManager(self.type_map)
def test_get_map_unique_mappers(self):
self.type_map.register_map(Bar, ObjectMapper)
self.type_map.register_map(Foo, ObjectMapper)
bar_inst = Bar('my_bar', list(range(10)), 'value1', 10)
foo_inst = Foo()
bar_mapper = self.type_map.get_map(bar_inst)
foo_mapper = self.type_map.get_map(foo_inst)
self.assertIsNot(bar_mapper, foo_mapper)
def test_get_map(self):
self.type_map.register_map(Bar, ObjectMapper)
container_inst = Bar('my_bar', list(range(10)), 'value1', 10)
mapper = self.type_map.get_map(container_inst)
self.assertIsInstance(mapper, ObjectMapper)
self.assertIs(mapper.spec, self.bar_spec)
mapper2 = self.type_map.get_map(container_inst)
self.assertIs(mapper, mapper2)
def test_get_map_register(self):
class MyMap(ObjectMapper):
pass
self.type_map.register_map(Bar, MyMap)
container_inst = Bar('my_bar', list(range(10)), 'value1', 10)
mapper = self.type_map.get_map(container_inst)
self.assertIs(mapper.spec, self.bar_spec)
self.assertIsInstance(mapper, MyMap)
class SpecCatalogTest(unittest.TestCase):
def setUp(self):
self.catalog = SpecCatalog()
self.attributes = [
AttributeSpec('attribute1', 'my first attribute', 'text'),
AttributeSpec('attribute2', 'my second attribute', 'text')
]
self.spec = DatasetSpec('my first dataset',
'int',
name='dataset1',
dimension=(None, None),
attributes=self.attributes,
linkable=False,
namespace='core',
data_type_def='EphysData')
def test_register_spec(self):
self.catalog.register_spec(self.spec, 'test.yaml')
result = self.catalog.get_spec('EphysData')
self.assertIs(result, self.spec)
def test_hierarchy(self):
spikes_spec = DatasetSpec('my extending dataset',
'int',
namespace='core',
data_type_inc='EphysData',
data_type_def='SpikeData')
lfp_spec = DatasetSpec('my second extending dataset',
'int',
namespace='core',
data_type_inc='EphysData',
data_type_def='LFPData')
self.catalog.register_spec(self.spec, 'test.yaml')
self.catalog.register_spec(spikes_spec, 'test.yaml')
self.catalog.register_spec(lfp_spec, 'test.yaml')
spike_hierarchy = self.catalog.get_hierarchy('SpikeData')
lfp_hierarchy = self.catalog.get_hierarchy('LFPData')
ephys_hierarchy = self.catalog.get_hierarchy('EphysData')
self.assertTupleEqual(spike_hierarchy, ('SpikeData', 'EphysData'))
self.assertTupleEqual(lfp_hierarchy, ('LFPData', 'EphysData'))
self.assertTupleEqual(ephys_hierarchy, ('EphysData', ))
def test_get_spec_source_file(self):
spikes_spec = GroupSpec('test group',
namespace='core',
data_type_def='SpikeData')
source_file_path = '/test/myt/test.yaml'
self.catalog.auto_register(spikes_spec, source_file_path)
recorded_source_file_path = self.catalog.get_spec_source_file(
'SpikeData')
self.assertEqual(recorded_source_file_path, source_file_path)
class TestDynamicContainer(unittest.TestCase):
def setUp(self):
self.bar_spec = GroupSpec(
'A test group specification with a data type',
data_type_def='Bar',
datasets=[
DatasetSpec('an example dataset',
'int',
name='data',
attributes=[
AttributeSpec('attr2',
'an example integer attribute',
'int')
])
],
attributes=[
AttributeSpec('attr1', 'an example string attribute', 'str')
])
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_map(Bar, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.bar_spec)
def test_dynamic_container_creation(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
expected_args = {'name', 'data', 'attr1', 'attr2', 'attr3', 'attr4'}
received_args = set()
for x in get_docval(cls.__init__):
received_args.add(x['name'])
with self.subTest(name=x['name']):
self.assertNotIn('default', x)
self.assertSetEqual(expected_args, received_args)
self.assertEqual(cls.__name__, 'Baz')
self.assertTrue(issubclass(cls, Bar))
def test_dynamic_container_creation_defaults(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
expected_args = {'name', 'data', 'attr1', 'attr2', 'attr3', 'attr4'}
received_args = set(map(lambda x: x['name'], get_docval(cls.__init__)))
self.assertSetEqual(expected_args, received_args)
self.assertEqual(cls.__name__, 'Baz')
self.assertTrue(issubclass(cls, Bar))
def test_dynamic_container_constructor(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
# TODO: test that constructor works!
inst = cls('My Baz', [1, 2, 3, 4],
'string attribute',
1000,
attr3=98.6,
attr4=1.0)
self.assertEqual(inst.name, 'My Baz')
self.assertEqual(inst.data, [1, 2, 3, 4])
self.assertEqual(inst.attr1, 'string attribute')
self.assertEqual(inst.attr2, 1000)
self.assertEqual(inst.attr3, 98.6)
self.assertEqual(inst.attr4, 1.0)
