def test_minimal_model(self): """ Test to make the absolute minimal model work """ YAMLGenerator(env.input_path('issue_tccm', 'minimalmodel.yaml'), mergeimports=False, log_level=logging.INFO).serialize(validateonly=True) env.make_testing_directory(env.expected_path('issue_tccm')) for generator in Generator.__subclasses__(): if not generator.__module__.startswith('linkml.generators'): pass elif not generator.directory_output: env.generate_single_file( [ 'issue_tccm', 'minimalmodel.' + generator.valid_formats[0] ], lambda: generator(env.input_path('issue_tccm', 'minimalmodel.yaml'), importmap=env.import_map, mergeimports=False, emit_metadata=False).serialize(), value_is_returned=True) else: env.generate_directory( ['issue_tccm', generator.__name__], lambda d: generator( env.input_path('issue_tccm', 'minimalmodel.yaml'), importmap=env.import_map, mergeimports=False, emit_metadata=False).serialize(directory=d))
def test_issue_50(self): env.generate_single_file( 'issue_84.py', lambda: PythonGenerator(env.input_path('issue_84.yaml')).serialize( ), comparator=compare_python, value_is_returned=True)
def test_multiple_postinit(self): """ Generate postinit code for a multi-occurring element """ env.generate_single_file( 'issue_44.py', lambda: PythonGenerator(env.input_path('issue_44.yaml'), emit_metadata=False).serialize(), value_is_returned=True)
def test_contained_constructor(self): test_name = 'issue_355' """ Make sure that types are generated as part of the output """ env.generate_single_file(f'{test_name}.py', lambda: PythonGenerator(env.input_path(f'{test_name}.yaml')).serialize(), comparator=lambda exp, act: compare_python(exp, act, self.env.expected_path(f'{test_name}.py')), value_is_returned=True) module = compile_python(env.expected_path(f'{test_name}.py')) c = module.Container(module.Containee('11111', "Glaubner's disease")) self.assertEqual('''entry: '11111': id: '11111' value: Glaubner's disease''', as_yaml(c).strip()) c = module.Container({'22222': dict(id='22222', value='Phrenooscopy')}) self.assertEqual('''entry: '22222': id: '22222' value: Phrenooscopy''', as_yaml(c).strip()) alt_object = YAMLRoot() alt_object.id = '33333' alt_object.value = 'test' c = module.Container(alt_object) self.assertEqual('''entry: '33333': id: '33333' value: test''', as_yaml(c).strip()) c = module.Container([dict(id='44444', value="Gracken's curse")]) self.assertEqual('''entry: '44444': id: '44444' value: Gracken's curse''', as_yaml(c).strip())
def test_inverse_mismatch(self): """ Test error detection when inverses don't match """ with self.assertRaises(ValueError) as e: env.generate_single_file('issue_18_error1.yaml', lambda: as_yaml(SchemaLoader(env.input_path('issue_18_error1.yaml')).resolve()), value_is_returned=True) self.assertEqual('Slot s1.inverse (s2) does not match slot s2.inverse (s3)', str(e.exception).strip())
def test_issue_167b_json(self): env.generate_single_file( 'issue_167b.json', lambda: JSONLDGenerator(env.input_path('issue_167b.yaml'), importmap=env.import_map).serialize(), filtr=json_metadata_filter, value_is_returned=True)
def test_issue_121(self): """ Make sure that types are generated as part of the output """ env.generate_single_file('issue_121.py', lambda: PythonGenerator(env.input_path('issue_121.yaml')).serialize(), comparator=compare_python, value_is_returned=True) with open(env.expected_path('issue_121.py')) as f: python= f.read() has_includes = False for line in python.split("\n"): if line.startswith("from includes.types"): assert line == "from includes.types import String" has_includes = True assert has_includes module = compile_python(env.expected_path('issue_121.py')) example = module.Biosample(depth="test") assert hasattr(example, "depth") assert example.depth == "test" example2 = module.ImportedClass() def output_generator(dirname) -> None: with open(os.path.join(dirname, 'issue_121_1.json'), 'w') as f: f.write(as_json(example)) with open(os.path.join(dirname, 'issue_121_2.json'), 'w') as f: f.write(as_json(example2)) env.generate_directory('issue_121', lambda dirname: output_generator(dirname))
def test_issue_80(self): """ Make sure that types are generated as part of the output """ env.generate_single_file( 'issue_80.py', lambda: PythonGenerator(env.input_path('issue_80.yaml')).serialize( ), comparator=lambda exp, act: compare_python( exp, act, self.env.expected_path('issue_80.py')), value_is_returned=True) module = compile_python(env.expected_path('issue_80.py')) example = module.Person("http://example.org/person/17", "Fred Jones", 43) # Create output for various forms def output_generator(dirname) -> None: with open(os.path.join(dirname, 'issue_80.json'), 'w') as f: f.write(as_json(example)) context = os.path.join(dirname, 'issue_80.context.jsonld') with open(context, 'w') as f: f.write( ContextGenerator( env.input_path('issue_80.yaml')).serialize()) with open(os.path.join(dirname, 'issue_80.ttl'), 'w') as f: f.write( as_rdf( example, contexts=context).serialize(format="turtle").decode()) env.generate_directory('issue_80', lambda dirname: output_generator(dirname))
def test_issue_113(self): """ Make sure that types are generated as part of the output """ env.generate_single_file( 'issue_113.py', lambda: PythonGenerator(env.input_path('issue_113.yaml') ).serialize(), comparator=lambda exp, act: compare_python(exp, act, 'issue_113.py' ), value_is_returned=True) module = compile_python(env.expected_path('issue_113.py')) example = module.TestClass(test_attribute_2="foo") assert hasattr(example, "test_attribute_2") assert hasattr(example, "test_attribute_1") example.wiible = "foo" example.test_attribute_1 = "foo" example.test_attribute_2 = "foo" env.generate_single_file( 'issue_113.json', lambda: PythonGenerator(env.input_path('issue_113.yaml') ).serialize(), comparator=lambda exp, act: compare_python(exp, act, 'issue_113.py' ), value_is_returned=True) def output_generator(dirname) -> None: with open(os.path.join(dirname, 'issue_113.json'), 'w') as f: f.write(as_json(example)) env.generate_directory('issue_113', lambda dirname: output_generator(dirname))
def test_no_inverse_domain(self): with self.assertRaises(ValueError) as e: env.generate_single_file('issue_18_error3.yaml', lambda: as_yaml(SchemaLoader(env.input_path('issue_18_error3.yaml')).resolve()), value_is_returned=True) self.assertEqual("Unable to determine the range of slot `s1'. Its inverse (s2) has no declared domain", str(e.exception).strip())
def test_issue_167b_rdf(self): env.generate_single_file( 'issue_167b.ttl', lambda: RDFGenerator(env.input_path('issue_167b.yaml'), importmap=env.import_map).serialize(), comparator=compare_rdf, value_is_returned=True)
def _do_test(self, tfn): env.generate_single_file(f'{tfn}.yaml', lambda: YAMLGenerator(env.input_path(f'{tfn}.yaml'), log_level=INFO).serialize(), filtr=yaml_filter, value_is_returned=True) env.generate_single_file(f'{tfn}.context.jsonld', lambda: ContextGenerator(env.input_path(f'{tfn}.yaml')).serialize(), filtr=ldcontext_metadata_filter, value_is_returned=True)
def test_issue_18(self): """ Make sure that inverses are automatically generated """ env.generate_single_file( 'issue_18.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_18.yaml')).resolve()), filtr=yaml_filter, value_is_returned=True)
def test_prefix(self): env.generate_single_file( 'issue_107.py', lambda: PythonGenerator(env.input_path('issue_107.yaml') ).serialize(), comparator=lambda exp, act: compare_python( exp, act, self.env.expected_path('issue_107.py')), value_is_returned=True)
def test_issue_177_dup(self): env.generate_single_file( 'issue_177_error.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_177_error.yaml')).resolve() ), value_is_returned=True, filtr=yaml_filter)
def test_namespace(self): context = "https://biolink.github.io/biolink-model/context.jsonld" env.generate_single_file( 'issue_namespace.ttl', lambda: RDFGenerator(env.input_path('issue_namespace.yaml') ).serialize(context=context), comparator=compare_rdf, value_is_returned=True)
def test_multi_domains(self): with self.redirect_logstream() as logger: env.generate_single_file('issue_18_warning1.yaml', lambda: as_yaml(SchemaLoader(env.input_path('issue_18_warning1.yaml'), logger=logger).resolve()), filtr=yaml_filter, value_is_returned=True) self.assertIn('Slot s2.inverse (s1), has multi domains (c1, c2) Multi ranges not yet implemented', logger.result)
def test_issue_167b_python(self): """ Annotations python example """ env.generate_single_file( 'issue_167b.py', lambda: PythonGenerator(env.input_path('issue_167b.yaml'), importmap=env.import_map).serialize(), comparator=compare_python, value_is_returned=True)
def test_issue_167(self): """ Test extensions to the four basic types """ env.generate_single_file( 'issue_167.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_167.yaml')).resolve()), value_is_returned=True, filtr=yaml_filter)
def test_issue_167b_yaml(self): """ Annotations yaml example """ env.generate_single_file( 'issue_167b.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_167b.yaml'), importmap=env.import_map).resolve()), value_is_returned=True, filtr=yaml_filter)
def test_local_imports(self): """ Make sure there is a '.' on a local import in python """ env.generate_single_file('importee.py', lambda: PythonGenerator(env.input_path('issue_tccm', 'importee.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True) env.generate_single_file('importer.py', lambda: PythonGenerator(env.input_path('issue_tccm', 'importer.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True)
def test_inheritence(self): env.generate_single_file('issue_14.py', lambda: PythonGenerator(env.input_path('issue_14.yaml')).serialize(), comparator=lambda exp, act: compare_python(exp, act, self.env.expected_path('issue_14.py')), filtr=metadata_filter, value_is_returned=True) # Added test for issue #183, where sex_qualifier disappeared from MixinOwner class module = compile_python(env.expected_path('issue_14.py')) subject = module.SubjectRange1(id='sr1',name="SubjectRange1", subject='thing1', object='thing2') mixin_owner = module.MixinOwner(id='mo1', subject='sr1', name='MixinOwner1', object='thing2', sex_qualifier="ntx")
def test_prefix(self): env.generate_single_file( 'issue112.yuml', lambda: YumlGenerator(env.input_path('issue_112.yaml')).serialize( ), value_is_returned=True) with open(env.expected_path('issue112.yuml')) as f: url = f.read() resp = requests.get(url) self.assertTrue(resp.ok)
def test_missing_inverse(self): with self.assertRaises(ValueError) as e: env.generate_single_file( 'issue_18_error2.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_18_error2.yaml')). resolve()), value_is_returned=True) self.assertEqual('Slot s1.inverse (s2) is not defined', str(e.exception).strip())
def test_issue_58(self): """ Reject non NSNAME model names""" with self.assertRaises(ValueError) as ve: env.generate_single_file( 'issue_58_error1.yaml', lambda: as_yaml( SchemaLoader(env.input_path('issue_58_error1.yaml')). resolve()), value_is_returned=True) self.assertIn('issue 58: Not a valid NCName', str(ve.exception))
def test_slot_usage_only(self): """ Slot_usages without parents don't generate slots period. """ env.generate_single_file( 'issue_ttcm_1.py', lambda: PythonGenerator(env.input_path('issue_tccm', 'resourcedescription.yaml'), importmap=env.import_map, mergeimports=True).serialize(), comparator=lambda exp, act: compare_python( exp, act, env.expected_path('issue_ttcm_1.py')), value_is_returned=True)
def test_pattern_1(self): """ Test the pattern ehnancement """ file = "pattern_1" env.generate_single_file(f'{self.testdir}/{file}.py', lambda: PythonGenerator(env.input_path(self.testdir, f'{file}.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=lambda exp, act: compare_python(exp, act, self.env.expected_path(f'{self.testdir}/{file}.py')), value_is_returned=True) module = compile_python(env.expected_path(self.testdir, f"{file}.py")) d1 = yaml.load(StringIO(d1_test), yaml.loader.SafeLoader) dev1 = module.DiskDevice(**d1) print("HERE")
def test_issue_167b_python(self): """ Annotations python example """ env.generate_single_file('issue_167b.py', lambda: PythonGenerator(env.input_path('issue_167b.yaml'), importmap=env.import_map, emit_metadata=False).serialize(), comparator=lambda exp, act: compare_python(exp, act, self.env.expected_path('issue_167b.py')), value_is_returned=True) env.generate_single_file('issue_167b2.py', lambda: PythonGenerator(env.input_path('issue_167b.yaml'), importmap=env.import_map, mergeimports=False, emit_metadata=False).serialize(), comparator=lambda exp, act: compare_python(exp, act, self.env.expected_path('issue_167b_nomerged.py')), value_is_returned=True)
def test_local_imports(self): """ Check the local import behavior """ dir = 'issue_260' # Useful to have an __init__.py available init_path = env.actual_path(dir, '__init__.py') if not os.path.exists(init_path): with open(init_path, 'w'): pass env.generate_single_file('issue_260/issue_260a.py', lambda: PythonGenerator(env.input_path(dir, 'issue_260a.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True) env.generate_single_file('issue_260/issue_260b.py', lambda: PythonGenerator(env.input_path(dir, 'issue_260b.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True) env.generate_single_file('issue_260/issue_260c.py', lambda: PythonGenerator(env.input_path(dir, 'issue_260c.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True) env.generate_single_file('issue_260/issue_260.py', lambda: PythonGenerator(env.input_path(dir, 'issue_260.yaml'), importmap=env.import_map, mergeimports=False).serialize(), comparator=compare_python, value_is_returned=True)
def test_issue_120(self): """ Courses not inlining """ env.generate_single_file( 'issue_120.py', lambda: PythonGenerator(env.input_path('issue_120.yaml') ).serialize(), value_is_returned=True, comparator=compare_python) env.generate_single_file( 'issue_120.json', lambda: JsonSchemaGenerator(env.input_path('issue_120.yaml') ).serialize(), value_is_returned=True)