def test_errors(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) for t in ("test_schema/test1.cwl", "test_schema/test2.cwl", "test_schema/test3.cwl", "test_schema/test4.cwl", "test_schema/test5.cwl", "test_schema/test6.cwl", "test_schema/test7.cwl", "test_schema/test8.cwl", "test_schema/test9.cwl", "test_schema/test10.cwl", "test_schema/test11.cwl", "test_schema/test12.cwl", "test_schema/test13.cwl", "test_schema/test14.cwl", "test_schema/test15.cwl"): with self.assertRaises(ValidationException): try: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/"+t)), True) except ValidationException as e: print("\n", e) raise
def main(): parser = argparse.ArgumentParser() parser.add_argument("swagger") parser.add_argument("annotations") parser.add_argument("url") parser.add_argument("--print-rdf", action="store_true", default=False) parser.add_argument("--serve", action="store_true", default=False) parser.add_argument("--fuseki-path", type=str, default=".") args = parser.parse_args() warnings.simplefilter('ignore', yaml.error.UnsafeLoaderWarning) with open(args.annotations) as f2: annotations = yaml.load(f2) with open(args.swagger) as f: sld = swg2salad.swg2salad(yaml.load(f), annotations) sld["$base"] = "http://ga4gh.org/schemas/tool-registry-schemas" sld["name"] = "file://" + os.path.realpath(args.swagger) document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( cmap(sld)) txt = document_loader.fetch_text( urlparse.urljoin( "file://" + os.getcwd() + "/", args.url)) r = yaml.load(txt) validate_doc(avsc_names, r, document_loader, True) sys.stderr.write("API returned valid response\n") toolreg = Namespace("http://ga4gh.org/schemas/tool-registry-schemas#") td = Namespace( "http://ga4gh.org/schemas/tool-registry-schemas#ToolDescriptor/") if args.print_rdf or args.serve: g = jsonld_context.makerdf(args.url, r, document_loader.ctx) for s, _, o in g.triples((None, td["type"], Literal("CWL"))): for _, _, d in g.triples((s, toolreg["descriptor"], None)): expand_cwl(d, unicode(s), g) if args.print_rdf: print(g.serialize(format="turtle")) if args.serve: t = tempfile.NamedTemporaryFile(suffix=".ttl") g.serialize(t, format="turtle") t.flush() subprocess.check_call( ["./fuseki-server", "--file=" + t.name, "/tools"], cwd=args.fuseki_path)
def get_schema(version): # type: (Text) -> Tuple[Loader, Union[schema.Names, schema.SchemaParseException], Dict[Text,Any], Loader] if version in SCHEMA_CACHE: return SCHEMA_CACHE[version] cache = {} # type: Dict[Text, Union[bytes, Text]] version = version.split("#")[-1] if '.dev' in version: version = ".".join(version.split(".")[:-1]) for f in cwl_files: try: res = resource_stream(__name__, 'schemas/%s/%s' % (version, f)) cache["https://w3id.org/cwl/" + f] = res.read() res.close() except IOError: pass for f in salad_files: try: res = resource_stream( __name__, 'schemas/{}/salad/schema_salad/metaschema/{}'.format( version, f)) cache["https://w3id.org/cwl/salad/schema_salad/metaschema/" + f] = res.read() res.close() except IOError: pass if version in custom_schemas: cache[custom_schemas[version][0]] = custom_schemas[version][1] SCHEMA_CACHE[version] = schema.load_schema( custom_schemas[version][0], cache=cache) else: SCHEMA_CACHE[version] = schema.load_schema( "https://w3id.org/cwl/CommonWorkflowLanguage.yml", cache=cache) return SCHEMA_CACHE[version]
def test_error_message3(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml") ) t = "test_schema/test3.cwl" match = r""" ^.+test3\.cwl:5:1: checking field\s+`outputs` .+test3\.cwl:6:3: checking object\s+`.+test3\.cwl#bar` \s+Field `type`\s+references\s+unknown\s+identifier\s+`xstring`,\s+tried \s+file://.+/tests/test_schema/test3\.cwl#xstring$"""[ 1: ] with pytest.raises(ValidationException, match=match): load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True )
def test_error_message1(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml") ) t = "test_schema/test1.cwl" match = ( r"""^.+test1\.cwl:2:1: Object\s+`.+test1\.cwl`\s+is\s+not valid """ + r"""because\s+tried `Workflow`\s+but \s+\* missing\s+required\s+field\s+`inputs` \s+\* missing\s+required\s+field\s+`outputs` \s+\* missing\s+required\s+field\s+`steps`$""" ) with pytest.raises(ValidationException, match=match): load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True )
def dotnet_codegen(file_uri: str, target: Path, examples: Optional[Path] = None) -> None: document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( file_uri) schema_raw_doc = metaschema_loader.fetch(file_uri) schema_doc, schema_metadata = metaschema_loader.resolve_all( schema_raw_doc, file_uri) codegen.codegen( "dotnet", cast(List[Dict[str, Any]], schema_doc), schema_metadata, document_loader, package="DotnetTest", target=str(target), examples=str(examples) if examples else None, )
def test_error_message11(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml") ) t = "test_schema/test11.cwl" match = r""" ^.+test11\.cwl:7:1: checking field\s+`steps` .+test11\.cwl:8:3: checking object\s+`.+test11\.cwl#step1` .+test11\.cwl:9:5: Field `run`\s+contains\s+undefined\s+reference to \s+`file://.+/tests/test_schema/blub\.cwl`$"""[ 1: ] with pytest.raises(ValidationException, match=match): load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True )
def test_fp() -> None: path = get_data("tests/test_schema/CommonWorkflowLanguage.yml") assert path document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( path) assert isinstance(avsc_names, Names) for t in ( "foreign/foreign_prop1.cwl", "foreign/foreign_prop2.cwl", "foreign/foreign_prop3.cwl", "foreign/foreign_prop4.cwl", "foreign/foreign_prop5.cwl", "foreign/foreign_prop6.cwl", "foreign/foreign_prop7.cwl", ): path2 = get_data("tests/" + t) assert path2 load_and_validate( document_loader, avsc_names, path2, True, strict_foreign_properties=False, ) for t in ( "foreign/foreign_prop1.cwl", "foreign/foreign_prop2.cwl", "foreign/foreign_prop4.cwl", "foreign/foreign_prop5.cwl", ): path3 = get_data("tests/" + t) assert path3 with pytest.raises(ValidationException): try: print(t) load_and_validate( document_loader, avsc_names, path3, True, strict_foreign_properties=True, ) except ValidationException as e: print("\n", e) raise
def test_error_message8(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml") ) t = "test_schema/test8.cwl" match = r""" ^.+test8\.cwl:7:1: checking field\s+`steps` .+test8\.cwl:8:3: checking object\s+`.+test8\.cwl#step1` .+test8\.cwl:9:5: Field\s+`scatterMethod`\s+contains\s+undefined\s+reference\s+to \s+`file:///.+/tests/test_schema/abc`$"""[ 1: ] with pytest.raises(ValidationException, match=match): load_and_validate( document_loader, avsc_names, str(get_data("tests/" + t)), True )
def test_errors(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( u"schema_salad/tests/test_schema/CommonWorkflowLanguage.yml") avsc_names = cast(Names, avsc_names) for t in ("test_schema/test1.cwl", "test_schema/test2.cwl", "test_schema/test3.cwl", "test_schema/test4.cwl", "test_schema/test5.cwl", "test_schema/test6.cwl", "test_schema/test7.cwl", "test_schema/test8.cwl", "test_schema/test9.cwl", "test_schema/test10.cwl", "test_schema/test11.cwl"): with self.assertRaises(ValidationException): try: load_and_validate(document_loader, avsc_names, unicode("schema_salad/tests/" + t), True) except ValidationException as e: print "\n", e raise
def test_error_message1() -> None: path = get_data("tests/test_schema/CommonWorkflowLanguage.yml") assert path document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( path) assert isinstance(avsc_names, Names) t = "test_schema/test1.cwl" match = ( r"""^.+test1\.cwl:2:1: Object\s+`.+test1\.cwl`\s+is\s+not valid """ + r"""because\s+tried `Workflow`\s+but \s+\* missing\s+required\s+field\s+`inputs` \s+\* missing\s+required\s+field\s+`outputs` \s+\* missing\s+required\s+field\s+`steps`$""") path2 = get_data("tests/" + t) assert path2 with pytest.raises(ValidationException, match=match): load_and_validate(document_loader, avsc_names, path2, True)
def test_errors(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) for t in ("test_schema/test1.cwl", "test_schema/test2.cwl", "test_schema/test3.cwl", "test_schema/test4.cwl", "test_schema/test5.cwl", "test_schema/test6.cwl", "test_schema/test7.cwl", "test_schema/test8.cwl", "test_schema/test9.cwl", "test_schema/test10.cwl", "test_schema/test11.cwl", "test_schema/test15.cwl"): with self.assertRaises(ValidationException): try: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True) except ValidationException as e: print("\n", e) raise
def test_error_message10(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test10.cwl" match = r""" ^.+test10\.cwl:2:1: Object\s+`.+test10\.cwl`\s+is not valid because \s+tried `Workflow`\s+but .+test10\.cwl:7:1: the `steps`\s+field\s+is\s+not\s+valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test10\.cwl:8:3: item is\s+invalid\s+because \s+\* missing\s+required\s+field\s+`run` .+test10\.cwl:9:5: \* the\s+`scatterMethod`\s+field\s+is\s+not\s+valid\s+because \s+value\s+is\s+a\s+CommentedSeq,\s+expected\s+null\s+or\s+ScatterMethod$"""[ 1:] with pytest.raises(ValidationException, match=match): load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True)
def test_error_message5(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test5.cwl" with self.assertRaises(ValidationException) as e: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True) self.assertTrue( re.match( r''' ^.+test5\.cwl:2:1: Object\s+`.+test5\.cwl`\s+is\s+not valid because \s+tried `Workflow`\s+but .+test5\.cwl:7:1: the `steps`\s+field\s+is\s+not valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test5\.cwl:7:9: item is\s+invalid because \s+is not a\s+dict$'''[1:], str(e.exception)), str(e.exception) + ' is not matched.')
def test_errors_previously_defined_dict_key(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml") ) for t in ( "test_schema/test12.cwl", "test_schema/test13.cwl", "test_schema/test14.cwl", ): with pytest.raises(ValidationException): try: load_and_validate( document_loader, avsc_names, str(get_data("tests/" + t)), True, ) except ValidationException as e: print("\n", e) raise
def setup_class(cls) -> None: #filepath = pathlib.Path(__file__).resolve().parent print("here i am {}".format(os.getcwd())) #filepath = "schema_salad/tests/test_schema/" #/"+test_dir_name filepath = "." tf = tarfile.open(os.path.join(filepath, "v1.2.0.tar.gz")) tf.extractall(os.path.join(filepath)) #this becomes cwl-v1.2-1.2.0 path = get_data( os.path.join(filepath, "cwl-v1.2-1.2.0/CommonWorkflowLanguage.yml")) assert path ( cls.document_loader, cls.avsc_names, schema_metadata, metaschema_loader, ) = load_schema(path)
def test_error_message5() -> None: path = get_data("tests/test_schema/CommonWorkflowLanguage.yml") assert path document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( path) assert isinstance(avsc_names, Names) t = "test_schema/test5.cwl" match = r""" ^.+test5\.cwl:2:1: Object\s+`.+test5\.cwl`\s+is\s+not valid because \s+tried `Workflow`\s+but .+test5\.cwl:7:1: the `steps`\s+field\s+is\s+not\s+valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test5\.cwl:7:9: item is\s+invalid\s+because \s+is not a\s+dict$"""[1:] with pytest.raises(ValidationException, match=match): load_and_validate(document_loader, avsc_names, str(get_data("tests/" + t)), True)
def test_error_message7(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test7.cwl" match = ( r"""^.+test7\.cwl:2:1: Object\s+`.+test7\.cwl`\s+is\s+not valid because \s+tried `Workflow`\s+but .+test7\.cwl:7:1: the `steps`\s+field\s+is\s+not\s+valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test7\.cwl:8:3: item is\s+invalid\s+because \s+\* missing\s+required\s+field\s+`run` .+test7\.cwl:9:5: \* invalid\s+field\s+`scatter_method`,\s+expected\s+one """ + r"""of:\s+'id',\s+'in', 'out',\s+'requirements',\s+'hints',\s+""" + r"""'label',\s+'doc',\s+'run',\s+'scatter',\s+'scatterMethod'$""") with pytest.raises(ValidationException, match=match): load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True)
def test_print_oneline_for_invalid_yaml(self): # Issue #137 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) src = "test16.cwl" with self.assertRaises(RuntimeError): try: load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/test_schema/" + src)), True) except RuntimeError as e: msg = reformat_yaml_exception_message( strip_dup_lineno(six.text_type(e))) msg = to_one_line_messages(msg) self.assertTrue( msg.endswith(src + ":10:1: could not find expected \':\'")) print("\n", e) raise
def test_print_oneline_for_invalid_yaml(): # Issue #137 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml")) src = "test16.cwl" with pytest.raises(ValidationException): try: load_and_validate( document_loader, avsc_names, str(get_data("tests/test_schema/" + src)), True, ) except ValidationException as e: msg = to_one_line_messages(e) assert msg.endswith(src + ":11:1: could not find expected ':'") print("\n", e) raise
def test_for_invalid_yaml2(self): # Issue 143 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) src = "test19.cwl" with self.assertRaises(RuntimeError): try: load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/test_schema/" + src)), True) except RuntimeError as e: msg = reformat_yaml_exception_message( strip_dup_lineno(six.text_type(e))) self.assertTrue( msg.endswith(src + ":1:1: expected <block end>, but found ':'")) print("\n", e) raise
def test_print_oneline_for_errors_in_resolve_ref(): # Issue #141 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml")) src = "test18.cwl" fullpath = normpath(get_data("tests/test_schema/" + src)) with pytest.raises(ValidationException): try: load_and_validate(document_loader, avsc_names, str(fullpath), True) except ValidationException as e: msg = to_one_line_messages(e) # convert Windows path to Posix path if "\\" in fullpath: fullpath = "/" + fullpath.lower().replace("\\", "/") print("\n", e) assert msg.endswith( src + ":14:5: Field `type` references unknown identifier " "`Filea`, tried file://%s#Filea" % (fullpath)) raise
def test_error_message7(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test7.cwl" with self.assertRaises(ValidationException) as e: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True) self.assertTrue( re.match( r''' ^.+test7\.cwl:2:1: Object\s+`.+test7\.cwl`\s+is\s+not valid because \s+tried `Workflow`\s+but .+test7\.cwl:7:1: the `steps`\s+field\s+is\s+not valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test7\.cwl:8:3: item is\s+invalid because \s+\* missing\s+required\s+field `run` .+test7\.cwl:9:5: \* invalid\s+field\s+`scatter_method`,\s+expected one of:\s+'id', 'in', 'out',\s+'requirements',\s+'hints', 'label',\s+'doc',\s+'run',\s+'scatter',\s+'scatterMethod'$'''[ 1:], str(e.exception)), str(e.exception) + ' is not matched.')
def test_fp(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml") ) for t in ( "foreign/foreign_prop1.cwl", "foreign/foreign_prop2.cwl", "foreign/foreign_prop3.cwl", "foreign/foreign_prop4.cwl", "foreign/foreign_prop5.cwl", "foreign/foreign_prop6.cwl", "foreign/foreign_prop7.cwl", ): load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True, strict_foreign_properties=False, ) for t in ( "foreign/foreign_prop1.cwl", "foreign/foreign_prop2.cwl", "foreign/foreign_prop4.cwl", "foreign/foreign_prop5.cwl", ): with pytest.raises(ValidationException): try: print (t) load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True, strict_foreign_properties=True, ) except ValidationException as e: print ("\n", e) raise
def python_codegen( file_uri: str, target: Path, parser_info: Optional[str] = None, package: Optional[str] = None, ) -> None: document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( file_uri) assert isinstance(avsc_names, Names) schema_raw_doc = metaschema_loader.fetch(file_uri) schema_doc, schema_metadata = metaschema_loader.resolve_all( schema_raw_doc, file_uri) codegen.codegen( "python", cast(List[Dict[str, Any]], schema_doc), schema_metadata, document_loader, target=str(target), parser_info=parser_info, package=package, )
def test_error_message15(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test15.cwl" with self.assertRaises(ValidationException) as e: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True) self.assertTrue( re.match( r''' ^.+test15\.cwl:3:1:\s+Object\s+`.+test15\.cwl`\s+is not valid because \s+tried\s+`CommandLineTool`\s+but .+test15\.cwl:6:1:\s+the `inputs`\s+field\s+is not valid\s+because .+test15\.cwl:7:3:\s+item is\s+invalid\s+because .+test15\.cwl:9:5:\s+the\s+`inputBinding`\s+field is not\s+valid\s+because .+tried\s+CommandLineBinding\s+but .+test15\.cwl:11:7: \*\s+invalid field\s+`invalid_field`,\s+expected one\s+of:\s+'loadContents',\s+'position',\s+'prefix',\s+'separate',\s+'itemSeparator',\s+'valueFrom',\s+'shellQuote' .+test15\.cwl:12:7: \*\s+invalid field\s+`another_invalid_field`,\s+expected one\s+of:\s+'loadContents',\s+'position',\s+'prefix',\s+'separate',\s+'itemSeparator',\s+'valueFrom',\s+'shellQuote'$'''[ 1:], str(e.exception)), str(e.exception) + ' is not matched.')
def test_error_message10(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) t = "test_schema/test10.cwl" with self.assertRaises(ValidationException) as e: load_and_validate(document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True) self.assertTrue( re.match( r''' ^.+test10\.cwl:2:1: Object\s+`.+test10\.cwl`\s+is not valid because \s+tried `Workflow`\s+but .+test10\.cwl:7:1: the `steps`\s+field is\s+not valid\s+because \s+tried array\s+of\s+<WorkflowStep>\s+but .+test10\.cwl:8:3: item is\s+invalid because \s+\* missing\s+required\s+field `run` .+test10\.cwl:9:5: \* the\s+`scatterMethod`\s+field is\s+not valid\s+because \s+value\s+is a\s+CommentedSeq,\s+expected\s+null\s+or\s+ScatterMethod$'''[1:], str(e.exception)), str(e.exception) + ' is not matched.')
def test_for_invalid_yaml2(): # Issue 143 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml")) src = "test19.cwl" with pytest.raises(ValidationException): try: load_and_validate( document_loader, avsc_names, str(get_data("tests/test_schema/" + src)), True, ) except ValidationException as e: msg = str(e) assert (msg.endswith("expected <block end>, but found ':'") or msg.endswith("expected <block end>, but found u':'") or re.search(r"mapping with\s+implicit\s+null key$", msg, re.M)) print("\n", e) raise
def test_for_invalid_yaml1(): # Issue 143 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data("tests/test_schema/CommonWorkflowLanguage.yml")) src = "test16.cwl" with pytest.raises(ValidationException): try: load_and_validate( document_loader, avsc_names, str(get_data("tests/test_schema/" + src)), True, ) except ValidationException as e: msg = str(e) assert re.search(src + r":10:7: while scanning a\s+simple\s+key", msg, re.M) assert re.search( src + r":11:1: could not\s+find\s+expected ':'$", msg, re.M) print("\n", e) raise
def test_errors(self): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( u"schema_salad/tests/test_schema/CommonWorkflowLanguage.yml") avsc_names = cast(Names, avsc_names) for t in ("test_schema/test1.cwl", "test_schema/test2.cwl", "test_schema/test3.cwl", "test_schema/test4.cwl", "test_schema/test5.cwl", "test_schema/test6.cwl", "test_schema/test7.cwl", "test_schema/test8.cwl", "test_schema/test9.cwl", "test_schema/test10.cwl", "test_schema/test11.cwl"): with self.assertRaises(ValidationException): try: load_and_validate(document_loader, avsc_names, unicode("schema_salad/tests/"+t), True) except ValidationException as e: print "\n", e raise
def test_print_oneline_for_errors_in_resolve_ref(self): # Issue #141 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) src = "test18.cwl" fullpath = normpath(get_data("tests/test_schema/" + src)) with self.assertRaises(ValidationException): try: load_and_validate(document_loader, avsc_names, six.text_type(fullpath), True) except ValidationException as e: msgs = to_one_line_messages( str(strip_dup_lineno(six.text_type(e)))).splitlines() # convert Windows path to Posix path if '\\' in fullpath: fullpath = '/' + fullpath.lower().replace('\\', '/') self.assertEqual(len(msgs), 1) print("\n", e) assert msgs[0].endswith( src + ':13:5: Field `type` references unknown identifier ' '`Filea`, tried file://%s#Filea' % (fullpath)) raise
def test_print_oneline_for_errors_in_the_same_line(self): # Issue #136 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) src = "test17.cwl" with self.assertRaises(ValidationException): try: load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/test_schema/" + src)), True) except ValidationException as e: msgs = to_one_line_messages(str(e)).splitlines() self.assertEqual(len(msgs), 2) self.assertTrue( msgs[0].endswith(src + ":13:5: missing required field `id`")) self.assertTrue(msgs[1].endswith( src + ":13:5: invalid field `aa`, expected one of: 'label', 'secondaryFiles', 'format', 'streamable', 'doc', 'id', 'outputBinding', 'type'" )) print("\n", e) raise
def test_error_message15(): document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml") ) t = "test_schema/test15.cwl" match = ( r"""^.+test15\.cwl:3:1:\s+Object\s+`.+test15\.cwl`\s+is not valid because \s+tried\s+`CommandLineTool`\s+but .+test15\.cwl:6:1:\s+the `inputs`\s+field\s+is not valid\s+because .+test15\.cwl:7:3:\s+item is\s+invalid\s+because .+test15\.cwl:9:5:\s+the\s+`inputBinding`\s+field is not\s+valid\s+because .+tried\s+CommandLineBinding\s+but .+test15\.cwl:11:7: \*\s+invalid field\s+`invalid_field`,\s+expected """ + r"""one\s+of:\s+'loadContents',\s+'position',\s+'prefix',\s+'separate',""" + r"""\s+'itemSeparator',\s+'valueFrom',\s+'shellQuote' .+test15\.cwl:12:7: \*\s+invalid field\s+`another_invalid_field`,""" + r"""\s+expected one\s+of:\s+'loadContents',\s+'position',\s+'prefix',""" + r"""\s+'separate',\s+'itemSeparator',\s+'valueFrom',\s+'shellQuote'$""" ) with pytest.raises(ValidationException, match=match): load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/" + t)), True )
def test_for_invalid_yaml1(self): # Issue 143 document_loader, avsc_names, schema_metadata, metaschema_loader = load_schema( get_data(u"tests/test_schema/CommonWorkflowLanguage.yml")) src = "test16.cwl" with self.assertRaises(RuntimeError): try: load_and_validate( document_loader, avsc_names, six.text_type(get_data("tests/test_schema/" + src)), True) except RuntimeError as e: msg = reformat_yaml_exception_message( strip_dup_lineno(six.text_type(e))) msgs = msg.splitlines() self.assertEqual(len(msgs), 2) self.assertTrue( msgs[0].endswith(src + ":9:7: while scanning a simple key")) self.assertTrue( msgs[1].endswith(src + ":10:1: could not find expected ':'")) print("\n", e) raise