def test_raises_error_if_trying_to_register_a_factory__that_is_already_registered_as_a_definition( self): library = MockLibrary() library.definitions = {'ciao': {'producer': 'int'}} factory = lambda random_funcs, config: 10 with self.assertRaises(ValueError): library.register_factory('ciao', factory)
def test_can_register_a_variable(self): library = MockLibrary() library.register_variable('ciao', 1.0, SimpleType('float')) expected_env = { 'ciao': 1.0, '::types::': { 'ciao': SimpleType('float') } } self.assertEqual(expected_env, library.env())
def test_can_register_a_function(self): library = MockLibrary() library.register_function('ciao', float, [SimpleType('int')], SimpleType('float')) expected_func_env = { 'ciao': float, '::types::': { 'ciao': ([SimpleType('int')], SimpleType('float')) } } self.assertEqual(expected_func_env, library.func_env())
def test_can_register_multiple_definitions(self): library = MockLibrary() factory_int = lambda random_funcs, config: 1 factory_float = lambda random_funcs, config: 2.0 library.register_factory('int', factory_int) library.register_factory('float', factory_float) library.register_definitions({ 'perc': { 'producer': 'int' }, 'other': { 'producer': 'float' } }) self.assertEqual(1, library.make_producer('perc', {})) self.assertEqual(2.0, library.make_producer('other', {}))
def test_can_make_schema_with_transformers(self): schema = make_schema_cmdline([('A', '@bob'), ('B', '%int')], [('bob', '%int')], show_header=True, library=MockLibrary()) self.assertTrue(schema.show_header) self.assertEqual(('A', 'B'), schema.columns) producers = sorted(schema.producers, key=lambda x: x.name) self.assertEqual(2, len(producers)) self.assertEqual(SimpleNamespace(name='producer#0', type='int', config={}), producers[0]) self.assertEqual(SimpleNamespace(name='producer#1', type='int', config={}), producers[1]) self.assertEqual(5, len(schema.transformers)) expected_transformer_bob = SimpleNamespace(name='transformer#0', inputs=['producer#0'], outputs=['bob'], transformer=IdentityTransformer(1)) expected_transformer_A = SimpleNamespace(name='transformer#1', inputs=['producer#0'], outputs=['A'], transformer=IdentityTransformer(1)) expected_transformer_B = SimpleNamespace(name='transformer#2', inputs=['producer#1'], outputs=['B'], transformer=IdentityTransformer(1)) expected_transformer_A_copy = SimpleNamespace(name='transformer#3', inputs=['producer#0'], outputs=['A'], transformer=IdentityTransformer(1)) expected_transformer_B_copy = SimpleNamespace(name='transformer#4', inputs=['producer#1'], outputs=['B'], transformer=IdentityTransformer(1)) self.assertEqual(expected_transformer_bob, schema.transformers[0]) self.assertEqual(expected_transformer_A, schema.transformers[1]) self.assertEqual(expected_transformer_B, schema.transformers[2]) self.assertEqual(expected_transformer_A_copy, schema.transformers[3]) self.assertEqual(expected_transformer_B_copy, schema.transformers[4])
def test_can_make_schema_with_a_single_column(self): schema = make_schema_expr('%int', ['A'], show_header=True, library=MockLibrary()) self.assertTrue(schema.show_header) self.assertEqual(('A',), schema.columns) self.assertEqual(1, len(schema.producers)) self.assertEqual(SimpleNamespace(name='producer#0', type='int', config={}), schema.producers[0]) self.assertEqual(1, len(schema.transformers)) expected_transformer = SimpleNamespace(name='transformer#0', inputs=['producer#0'], outputs=['A'], transformer=IdentityTransformer(1)) self.assertEqual(expected_transformer, schema.transformers[0])
def test_raises_error_when_creating_library_if_name_has_multiple_definitions( self): with self.assertRaises(ValueError): MockLibrary(factories={'a': (lambda x: 1)}, definitions={'a': None})
def test_can_lookup_definitions(self): library = MockLibrary() factory = lambda random_funcs, config: 1 library.register_factory('int', factory) library.register_definition('perc', {'producer': 'int'}) self.assertEqual(1, library.make_producer('perc', {}))
def test_raises_error_if_trying_to_unknown_producer(self): library = MockLibrary() with self.assertRaises(LookupError): library.make_producer('ciao', {})
def test_compatibility(self): compat = MockLibrary().compatibility() self.assertEqual( SimpleType('a'), compat.get_upperbound(SimpleType('a'), SimpleType('b')))
def test_raises_error_if_trying_to_register_a_factory_multiple_times(self): library = MockLibrary() factory = lambda random_funcs, config: 10 library.register_factory('ciao', factory) with self.assertRaises(ValueError): library.register_factory('ciao', factory)
def test_can_register_a_definition(self): library = MockLibrary() factory = lambda random_funcs, config: 10 library.register_factory('int', factory) library.register_definition('ciao', {'producer': 'int', 'config': {}}) self.assertEqual(10, library.make_producer('ciao', {}))
def test_can_register_a_factory(self): library = MockLibrary() factory = lambda random_funcs, config: 10 library.register_factory('ciao', factory) self.assertEqual(factory, library.get_producer_factory('ciao'))
def test_func_env(self): self.assertEqual({}, MockLibrary().func_env())
def test_can_make_schema_with_multiple_columns(self): schema = make_schema_expr('%int . %int', ['A', 'B'], show_header=True, library=MockLibrary()) self.assertTrue(schema.show_header) self.assertEqual(('A', 'B'), schema.columns) producers = sorted(schema.producers, key=lambda x: x.name) self.assertEqual(2, len(producers)) self.assertEqual(SimpleNamespace(name='producer#0', type='int', config={}), producers[0]) self.assertEqual(SimpleNamespace(name='producer#1', type='int', config={}), producers[1]) self.assertEqual(2, len(schema.transformers)) expected_transformer_A = SimpleNamespace(name='transformer#0', inputs=['producer#0'], outputs=['A'], transformer=IdentityTransformer(1)) expected_transformer_B = SimpleNamespace(name='transformer#1', inputs=['producer#1'], outputs=['B'], transformer=IdentityTransformer(1)) self.assertEqual(expected_transformer_A, schema.transformers[0]) self.assertEqual(expected_transformer_B, schema.transformers[1])