def testEvalQueryTestModelMin(self): """ Evaluate RO against minimal Minim description using just QueryTestRules """ self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) self.populateTestRo(testbase, rodir) rometa = ro_metadata(ro_config, rodir) (g, evalresult) = ro_eval_minim.evaluate(rometa, "Minim-UserRequirements2-min.rdf", # Minim file "data/UserRequirements-astro.ods", # Target resource "create") # Purpose log.debug("ro_eval_minim.evaluate result:\n----\n%s"%(repr(evalresult))) self.assertIn(MINIM.fullySatisfies, evalresult['summary']) self.assertIn(MINIM.nominallySatisfies, evalresult['summary']) self.assertIn(MINIM.minimallySatisfies, evalresult['summary']) self.assertEquals(evalresult['missingMust'], []) self.assertEquals(evalresult['missingShould'], []) self.assertEquals(evalresult['missingMay'], []) self.assertEquals(evalresult['rouri'], rometa.getRoUri()) self.assertEquals(evalresult['minimuri'], rometa.getComponentUri("Minim-UserRequirements2-min.rdf")) self.assertEquals(evalresult['target'], "data/UserRequirements-astro.ods") self.assertEquals(evalresult['purpose'], "create") self.assertEquals(evalresult['constrainturi'], rometa.getComponentUriAbs("Minim-UserRequirements2-min.rdf#create/data/UserRequirements-astro.ods")) self.assertEquals(evalresult['modeluri'], rometa.getComponentUriAbs("Minim-UserRequirements2-min.rdf#runnableRO")) self.deleteTestRo(rodir) return
def testEvalQueryTestChemboxFail(self): """ Test for failing chembox requirement """ self.setupConfig() rodir = self.createTestRo(testbase, "test-chembox", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) self.populateTestRo(testbase, rodir) rometa = ro_metadata(ro_config, rodir) resuri = rometa.getComponentUriAbs("http://purl.org/net/chembox/Ethane") rometa.addGraphAnnotation(resuri, "Ethane.ttl") # Now run evaluation against test RO (g, evalresult) = ro_eval_minim.evaluate(rometa, "Minim-chembox.ttl", # Minim file resuri, # Target resource "fail") # Purpose log.debug("ro_eval_minim.evaluate result:\n----\n%s"%(repr(evalresult))) self.assertNotIn(MINIM.fullySatisfies, evalresult['summary']) self.assertNotIn(MINIM.nominallySatisfies, evalresult['summary']) self.assertNotIn(MINIM.minimallySatisfies, evalresult['summary']) self.assertEquals(len(evalresult['missingMust']), 1) self.assertEquals(evalresult['missingMust'][0][0]['seq'], 'This test should fail') self.assertEquals(evalresult['missingShould'], []) self.assertEquals(evalresult['missingMay'], []) self.assertEquals(evalresult['rouri'], rometa.getRoUri()) self.assertEquals(evalresult['minimuri'], rometa.getComponentUri("Minim-chembox.ttl")) self.assertEquals(evalresult['target'], resuri) self.assertEquals(evalresult['purpose'], "fail") self.deleteTestRo(rodir) return
def testChecklistEvalExcel(self): """ Test checklist evaluation with generated Minim file from Excel source """ self.setupConfig() rodir = self.createTestRo(testbase, "testro", "RO for testMkMinim", "ro-testMkMinim") self.populateTestRo(testbase, rodir) self.annotateResource(testbase, rodir, "", "FileAnnotations.ttl") rouri = ro_manifest.getRoUri(rodir) # Create minim graph from CSV file gridname = "TestMkMinim.xls" griduri = ro_manifest.getComponentUri(rodir, gridname) gridxls = os.path.join(rodir, gridname) gridbase = "http://example.org/base/" grid = GridExcel(gridxls, baseuri=gridbase) (status, minimgr) = mkminim.mkminim(grid, baseuri=grid.resolveUri("")) self.assertEquals(status, 0) # Write Minim minimname = "TestMkMinim_minim.ttl" with open(rodir + "/" + minimname, "w") as minimfile: minimgr.serialize(minimfile, format="turtle") # Evaluate checklist minimuri = ro_manifest.getComponentUri(rodir, minimname) minimpurpose = "test1" args = ["ro", "evaluate", "checklist", "-a", "-d", rodir + "/", minimname, minimpurpose, "."] self.outstr.seek(0) with StdoutContext.SwitchStdout(self.outstr): status = ro.runCommand( os.path.join(testbase, TestConfig.ro_test_config.CONFIGDIR), os.path.join(testbase, TestConfig.ro_test_config.ROBASEDIR), args, ) outtxt = self.outstr.getvalue() assert status == 0, "Status %d, outtxt: %s" % (status, outtxt) log.debug("status %d, outtxt: %s" % (status, outtxt)) # Check response returned # filelist = [ unicode(ro_manifest.getComponentUri(rodir, f)) # for f in ["File1.txt", "File2.txt", "File3.txt"] ] filelist = ValueList( [str(ro_manifest.getComponentUri(rodir, f)) for f in ["File1.txt", "File2.txt", "File3.txt"]] ) expect = [ "Research Object file://%s/:" % (rodir), "Fully complete for test1 of resource .", "Satisfied requirements:", " At least 3 file as part values are present", " At most 3 file as part values are present", " All part resource files %s are aggregated in RO" % (filelist), " All file as part resources are accessible (live)", " Python 2.7.x present", " Files as part are partOf some indicated whole", " File exists as a part", "Research object URI: %s" % (rouri), "Minimum information URI: %s" % (minimuri), ] self.outstr.seek(0) for line in self.outstr: self.assertIn(str(line)[:-1], expect) self.deleteTestRo(rodir) return
def testMkMinim(self): self.setupConfig() rodir = self.createTestRo(testbase, "testro", "RO for testMkMinim", "ro-testMkMinim") rouri = ro_manifest.getRoUri(rodir) # Create minim graph from CSV file # NOTE: a base URI may be specoified when decoding the grid or when constructing the minim # graph. The Minim graph uses its own relative references, so for consistency it may # be necessary to pass the grid base URI to mkminim. The code below does this. gridname = "TestMkMinim.csv" griduri = ro_manifest.getComponentUri(rodir, gridname) gridcsv = os.path.join(rodir, gridname) gridbase = "http://example.org/base/" with open(gridcsv, "rU") as gridfile: grid = GridCSV(gridfile, baseuri=gridbase, dialect=csv.excel) (status, minimgr) = mkminim.mkminim(grid, baseuri=grid.resolveUri("")) self.assertEquals(status, 0) # Read expected graph graphname = os.path.join(rodir, "TestMkMinim.ttl") expectgr = rdflib.Graph() with open(graphname) as expectfile: expectgr.parse(file=expectfile, publicID=gridbase, format="turtle") # Check content of minim graph ###minimgr.serialize(sys.stdout, format="turtle") self.checkTargetGraph(minimgr.graph(), expectgr, msg="Not found in constructed minim graph") self.deleteTestRo(rodir) return
def testRemoveGetRoAnnotations(self): rodir = self.createTestRo(testbase, "data/ro-test-1", "Test remove RO annotation", "ro-testRoAnnotate") roresource = "." # Remove some anotations for RO ro_annotation._removeSimpleAnnotation(ro_config, rodir, roresource, "type", "Research Object") ro_annotation._removeSimpleAnnotation(ro_config, rodir, roresource, "title", "Test remove RO annotation") ro_annotation._removeSimpleAnnotation(ro_config, rodir, roresource, "description", None) ro_annotation._removeSimpleAnnotation(ro_config, rodir, roresource, "note", "Research object created for annotation testing") ro_annotation._removeSimpleAnnotation(ro_config, rodir, roresource, "created", None) # Retrieve the anotations annotations = ro_annotation._getRoAnnotations(rodir) rouri = ro_manifest.getRoUri(rodir) expected_annotations = ( [ (rouri, DCTERMS.creator, rdflib.Literal('Test User')) , (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate')) , (rouri, RDF.type, RO.ResearchObject) ]) for i in range(4): next = annotations.next() #log.debug("Next %s"%(repr(next))) if ( next not in expected_annotations and next[1] != DCTERMS.created and next[1] != ORE.aggregates ): self.assertTrue(False, "Not expected (%d) %s"%(i, repr(next))) self.assertRaises(StopIteration, annotations.next) self.deleteTestRo(rodir) return
def testLinkWithNotExistentGraph(self): rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test annotation", "ro-testRoAnnotate") rofile = rodir+"/"+"subdir1/subdir1-file.txt" # Apply non-exietent graph annotation annotation_graph_filename = os.path.join(os.path.abspath(rodir), "annotate-none.rdf") rouri = ro_manifest.getRoUri(rodir) args = ["ro", "annotate", rodir+"/", "-g", annotation_graph_filename ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) outtxt = self.outstr.getvalue() assert status == 0, outtxt # Read manifest and check for annotation annotations = ro_annotation.getAllAnnotations(rodir) expected_annotations = ( [ ( rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate') ) , ( rouri, DCTERMS.description, rdflib.Literal('RO test annotation') ) , ( rouri, DCTERMS.title, rdflib.Literal('RO test annotation') ) , ( rouri, DCTERMS.creator, rdflib.Literal('Test User') ) , ( rouri, RDF.type, RO.ResearchObject ) ]) count = 0 for next in list(annotations): if ( # not isinstance(next[2], rdflib.BNode) and not next[1] in [ORE.aggregates, DCTERMS.created] and not next[1] == DCTERMS.created ): log.debug("- next %s"%(str(next[0])) ) log.debug(" - (%s, %s)"%(str(next[1]),str(next[2])) ) if next in expected_annotations: count += 1 else: self.assertTrue(False, "Not expected (%d) %s"%(count, repr(next))) self.assertEqual(count,5) # Clean up self.deleteTestRo(rodir) return
def testGetRequirements(self): def compare_reqs(req_expect, req_found): for k in req_expect: if not k in req_found: log.debug("- not found: %s"%(k)) return False elif isinstance(req_expect[k], dict) and isinstance(req_found[k], dict): if not compare_reqs(req_expect[k], req_found[k]): return False elif req_found[k] != req_expect[k]: log.debug("- not found: %s: %s != %s "%(k,req_expect[k],req_found[k])) return False return True self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements2.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRO") minimgraph = ro_minim.readMinimGraph(minimbase) requirements = ro_minim.getRequirements(minimgraph, model) r1 = ( { 'level': "MUST" , 'label': rdflib.Literal("aggregates data/UserRequirements-astro.ods") , 'querytestrule': { 'query': rdflib.Literal("?ro a ro:ResearchObject") , 'resultmod': None , 'aggregates_t': rdflib.Literal("data/UserRequirements-astro.ods") } , 'uri': ro_minim.getElementUri(minimbase, "#isAggregated/data/UserRequirements-astro.ods") }) r2 = ( { 'level': "MUST" , 'label': rdflib.Literal("accessible data/UserRequirements-astro.ods") , 'querytestrule': { 'query': rdflib.Literal("?ro a ro:ResearchObject") , 'resultmod': None , 'islive_t': rdflib.Literal("data/UserRequirements-astro.ods") } , 'uri': ro_minim.getElementUri(minimbase, "#isAccessible/data/UserRequirements-astro.ods") }) r3 = ( { 'level': "MUST" , 'label': rdflib.Literal("labeled data/UserRequirements-astro.ods") , 'querytestrule': { 'query': rdflib.Literal("?ro a ro:ResearchObject") , 'resultmod': rdflib.Literal("ORDER BY ?ro") , 'exists': rdflib.Literal("<data/UserRequirements-astro.ods> rdfs:label ?label") } , 'uri': ro_minim.getElementUri(minimbase, "#isLabeled/data/UserRequirements-astro.ods") }) r1_found = r2_found = r3_found = False for r in requirements: log.debug("requirement: %s"%(repr(r))) if compare_reqs(r1, r): r1_found = True if compare_reqs(r2, r): r2_found = True if compare_reqs(r3, r): r3_found = True self.assertTrue(r1_found, "Expected requirement(1) not found in minim") self.assertTrue(r2_found, "Expected requirement(2) not found in minim") self.assertTrue(r3_found, "Expected requirement(3) not found in minim") return
def testGetRequirements(self): def compare_reqs(req_expect, req_found): for k in req_expect: if not k in req_found: log.debug("- not found: %s"%(k)) return False elif isinstance(req_expect[k], dict) and isinstance(req_found[k], dict): if not compare_reqs(req_expect[k], req_found[k]): return False elif req_found[k] != req_expect[k]: log.debug("- not found: %s: %s != %s "%(k,req_expect[k],req_found[k])) return False return True self.setupConfig() rodir = self.createTestRo(testbase, "test-data-1", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRequirementRO") minimgraph = ro_minim.readMinimGraph(minimbase) requirements = ro_minim.getRequirements(minimgraph, model) expected_found = False r1 = ( { 'level': "MUST" , 'label': rdflib.Literal("Python 2.7") , 'softwarerule': { 'command': rdflib.Literal("python -V") , 'response': rdflib.Literal("Python 2.7") , 'derives': ro_minim.getElementUri(minimbase, "#environment-software/python-27") } , 'uri': ro_minim.getElementUri(minimbase, "#environment-software/python-27") }) r2 = ( { 'level': "MUST" , 'label': rdflib.Literal("aggregates data/UserRequirements-astro.ods") , 'datarule': { 'aggregates': ro_manifest.getComponentUri(rodir, "data/UserRequirements-astro.ods") , 'derives': ro_minim.getElementUri(minimbase, "#isPresent/data/UserRequirements-astro.ods") } , 'uri': ro_minim.getElementUri(minimbase, "#isPresent/data/UserRequirements-astro.ods") }) r3 = ( { 'level': "SHOULD" , 'label': rdflib.Literal("aggregates docs/reqs.css") , 'datarule': { 'aggregates': ro_manifest.getComponentUri(rodir, "docs/reqs.css") , 'derives': ro_minim.getElementUri(minimbase, "#isPresent/docs/reqs.css") } , 'uri': ro_minim.getElementUri(minimbase, "#isPresent/docs/reqs.css") }) r1_found = r2_found = r3_found = False for r in requirements: log.debug("requirement: %s"%(repr(r))) if compare_reqs(r1, r): r1_found = True if compare_reqs(r2, r): r2_found = True if compare_reqs(r3, r): r3_found = True self.assertTrue(r1_found, "Expected requirement(1) not found in minim") self.assertTrue(r2_found, "Expected requirement(2) not found in minim") self.assertTrue(r3_found, "Expected requirement(3) not found in minim") return
def testGetModel(self): self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements2.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRO") minimgraph = ro_minim.readMinimGraph(minimbase) m = ro_minim.getModel(minimgraph, model) self.assertEquals(m['label'], rdflib.Literal("Runnable RO")) self.assertEquals(m['uri'], model) return
def testGetRoUri(self): self.assertEquals(ro_manifest.getRoUri("/example/ro/dir"), rdflib.URIRef("file:///example/ro/dir/")) self.assertEquals(ro_manifest.getRoUri("/example/ro/dir/"), rdflib.URIRef("file:///example/ro/dir/")) self.assertEquals(ro_manifest.getRoUri("ro/dir"), rdflib.URIRef("file://%s/ro/dir/"%(cwd))) self.assertEquals(ro_manifest.getRoUri("ro/dir/"), rdflib.URIRef("file://%s/ro/dir/"%(cwd))) self.assertEquals(ro_manifest.getRoUri(robase+"/ro/dir"), rdflib.URIRef("file://%s/ro/dir/"%(robase_abs))) self.assertEquals(ro_manifest.getRoUri(robase+"/ro/dir/"), rdflib.URIRef("file://%s/ro/dir/"%(robase_abs))) return
def testGridRead(self): """ Basic test that Minim test file can be read """ self.setupConfig() rodir = self.createTestRo(testbase, "testro", "RO for Minim creation test", "ro-testMkMinim") rouri = ro_manifest.getRoUri(rodir) gridname = "TestMkMinim.csv" griduri = ro_manifest.getComponentUri(rodir, gridname) gridcsv = os.path.join(rodir, gridname) with open(gridcsv, "rU") as gridfile: grid = GridCSV(gridfile, baseuri=griduri, dialect=csv.excel) self.assertEqual(grid[0][0], "Minim definition for MkMinim testing") self.deleteTestRo(rodir) return
def testGetConstraint(self): self.setupConfig() rodir = self.createTestRo(testbase, "test-data-1", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRequirementRO") constraint = ro_minim.getElementUri(minimbase, "#create/docs/UserRequirements-astro.csv") minimgraph = ro_minim.readMinimGraph(minimbase) c = ro_minim.getConstraint(minimgraph, rodir, "docs/UserRequirements-astro.csv", r"create.*UserRequirements-astro\.csv") self.assertEquals(c['target'], ro_manifest.getComponentUri(rodir, "docs/UserRequirements-astro.csv")) self.assertEquals(c['purpose'], rdflib.Literal("create UserRequirements-astro.csv")) self.assertEquals(c['model'], model) self.assertEquals(c['uri'], constraint) return
def testGetModels(self): self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements2.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRO") minimgraph = ro_minim.readMinimGraph(minimbase) models = ro_minim.getModels(minimgraph) expected_found = False for m in models: if ( m['label'] == rdflib.Literal("Runnable RO") and m['uri'] == model ) : expected_found = True break self.assertTrue(expected_found, "Expected model not found in minim") return
def testAnnotateWildcardPattern2(self): """ Same as previous test, but includes filenames with spaces and hashes """ rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test annotation", "ro-testRoAnnotate") self.populateTestRo(testbase, rodir) # Apply annotation to filename pattern rouri = ro_manifest.getRoUri(rodir) args = ["ro", "annotate" ,"-d", rodir+"/" , "-w", "\\.txt$" , "dcterms:description", "pattern annotation" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) outtxt = self.outstr.getvalue() assert status == 0, outtxt # Read manifest and check for annotation annotations = ro_annotation.getAllAnnotations(rodir) res_spc_uri = ro_manifest.getComponentUriAbs(rodir, "filename%20with%20spaces.txt") res_hsh_uri = ro_manifest.getComponentUriAbs(rodir, "filename%23with%23hashes.txt") resource1uri = ro_manifest.getComponentUriAbs(rodir, "subdir1/subdir1-file.txt") resource2uri = ro_manifest.getComponentUriAbs(rodir, "subdir2/subdir2-file.txt") expected_annotations = ( [ ( rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate') ) , ( rouri, DCTERMS.description, rdflib.Literal('RO test annotation') ) , ( rouri, DCTERMS.title, rdflib.Literal('RO test annotation') ) , ( rouri, DCTERMS.creator, rdflib.Literal('Test User') ) , ( rouri, RDF.type, RO.ResearchObject ) , ( res_spc_uri, DCTERMS.description, rdflib.Literal('pattern annotation') ) , ( res_hsh_uri, DCTERMS.description, rdflib.Literal('pattern annotation') ) , ( resource1uri, DCTERMS.description, rdflib.Literal('pattern annotation') ) , ( resource2uri, DCTERMS.description, rdflib.Literal('pattern annotation') ) ]) count = 0 for next in list(annotations): if ( not isinstance(next[2], rdflib.BNode) and not next[1] in [ORE.aggregates, DCTERMS.created] ): log.debug("- next %s"%(str(next[0])) ) log.debug(" - (%s, %s)"%(str(next[1]),str(next[2])) ) if next in expected_annotations: count += 1 else: self.assertTrue(False, "Not expected (%d) %s"%(count, repr(next))) self.assertEqual(count,9) # Clean up #self.deleteTestRo(rodir) return
def testAddGetAllAnnotations(self): rodir = self.createTestRo(testbase, "data/ro-test-1", "Test get all annotations", "ro-testRoAnnotate") roresource = "subdir1/subdir1-file.txt" # Add anotations for file ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "type", "Test file") ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "description", "File in test research object") ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "note", "Research object file created for annotation testing") ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "title", "Test file in RO") ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "created", "2011-12-07") ro_annotation._addSimpleAnnotation(ro_config, rodir, roresource, "rdf:type", ROTERMS.resource) # Retrieve the file anotations annotations = ro_annotation.getAllAnnotations(rodir) rouri = ro_manifest.getRoUri(rodir) resourceuri = ro_manifest.getComponentUri(rodir, roresource) log.debug("resourceuri: %s"%(resourceuri)) expected_annotations = ( [ (rouri, DCTERMS.description, rdflib.Literal('Test get all annotations')) , (rouri, DCTERMS.title, rdflib.Literal('Test get all annotations')) , (rouri, DCTERMS.created, rdflib.Literal('unknown')) , (rouri, DCTERMS.creator, rdflib.Literal('Test User')) , (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate')) , (rouri, RDF.type, RO.ResearchObject) , (resourceuri, DCTERMS.type, rdflib.Literal('Test file')) , (resourceuri, DCTERMS.description, rdflib.Literal('File in test research object')) , (resourceuri, ROTERMS.note, rdflib.Literal('Research object file created for annotation testing')) , (resourceuri, DCTERMS.title, rdflib.Literal('Test file in RO')) , (resourceuri, DCTERMS.created, rdflib.Literal('2011-12-07')) , (resourceuri, RDF.type, ROTERMS.resource) ]) for i in range(12+1+6): # Annotations + aggregations next = annotations.next() #log.debug("Next %s"%(repr(next))) if ( next not in expected_annotations and next[1] != DCTERMS.created and next[1] != ORE.aggregates ): self.assertTrue(False, "Not expected (%d) %s"%(i, repr(next))) self.assertRaises(StopIteration, annotations.next) self.deleteTestRo(rodir) return
def testEvaluateRDF(self): self.setupConfig() rodir = self.createTestRo(testbase, "test-chembox", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) self.populateTestRo(testbase, rodir) rometa = ro_metadata(ro_config, rodir) resuri = rometa.getComponentUriAbs("http://purl.org/net/chembox/Ethane") reslabel = "Ethane" rometa.addGraphAnnotation(resuri, "Ethane.ttl") # Now run evaluation against test RO (minimgr, evalresult) = ro_eval_minim.evaluate(rometa, "Minim-chembox.ttl", # Minim file resuri, # Target resource "complete") # Purpose resultgr = ro_eval_minim.evalResultGraph(minimgr, evalresult) log.debug("------ resultgr:\n%s\n----"%(resultgr.serialize(format='turtle'))) # pretty-xml ## print "------ resultgr:\n%s\n----"%(resultgr.serialize(format='turtle')) # Check response returned modeluri = rdflib.URIRef('http://example.com/chembox-samples/minim_model') prefixes = make_sparql_prefixes() probequeries = ( [ '''ASK { _:r minim:testedRO <%s> ; minim:minimUri <%s> }'''% (rouri, rometa.getComponentUri("Minim-chembox.ttl")) , '''ASK { _:r minim:testedRO <%s> ; minim:testedModel <%s> }'''% (rouri, modeluri) , '''ASK { _:r minim:testedTarget <%s> ; minim:satisfied [ minim:tryMessage "%s" ] }'''% (resuri, "InChI identifier is present") , '''ASK { _:r minim:testedTarget <%s> ; minim:satisfied [ minim:tryMessage "%s" ] }'''% (resuri, "ChemSpider identifier is present") , '''ASK { _:r minim:testedTarget <%s> ; minim:missingMay [ minim:tryMessage "%s" ] }'''% (resuri, "No synomym is present") , '''ASK { _:r minim:testedTarget <%s> ; minim:nominallySatisfies <%s> }'''% (resuri, modeluri) , '''ASK { _:r minim:testedTarget <%s> ; minim:minimallySatisfies <%s> }'''% (resuri, modeluri) , '''ASK { <%s> rdfs:label "%s" }'''% (resuri, reslabel) ]) for q in probequeries: r = resultgr.query(prefixes+q) self.assertEqual(r.type, 'ASK', "Result type %s for: %s"%(r.type, q)) self.assertTrue(r.askAnswer, "Failed query: %s"%(q)) self.deleteTestRo(rodir) return
def testLinkWithGraph(self): rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test annotation", "ro-testRoAnnotate") rofile = rodir+"/"+"subdir1/subdir1-file.txt" define_annotations = ( [ {"atypename": "type", "avalue":"atype", "atypeuri":DCTERMS.type, "aexpect":"atype" } , {"atypename": "keywords", "avalue":"asubj", "atypeuri":DCTERMS.subject, "aexpect":"asubj" } , {"atypename": "description", "avalue":"adesc", "atypeuri":DCTERMS.description, "aexpect":"adesc" } , {"atypename": "format", "avalue":"aformat", "atypeuri":DCTERMS.format, "aexpect":"aformat" } , {"atypename": "title", "avalue":"atitle", "atypeuri":DCTERMS.title, "aexpect":"atitle" } , {"atypename": "created", "avalue":"acreated", "atypeuri":DCTERMS.created, "aexpect":"acreated" } ]) # Create annotation graph file and apply annotations annotation_graph = rdflib.Graph() resourceuri = ro_manifest.getComponentUri(rodir, "subdir1/subdir1-file.txt") for ann in define_annotations: annotation_graph.add( (resourceuri, ann["atypeuri"], rdflib.Literal(ann["aexpect"])) ) annotation_graph_filename = os.path.join(os.path.abspath(rodir), "annotate-subdir1-file.txt.rdf") annotation_graph.serialize(annotation_graph_filename, format='xml', base=ro_manifest.getRoUri(rodir), xml_base="") args = ["ro", "annotate", rofile, "-g", annotation_graph_filename ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) outtxt = self.outstr.getvalue() assert status == 0, outtxt # Read manifest and check for annotation annotations = ro_annotation._getFileAnnotations(rodir, "subdir1/subdir1-file.txt") expected_annotations = ( [ (resourceuri, a["atypeuri"], rdflib.Literal(a["aexpect"])) for a in define_annotations ]) count = 0 for next in list(annotations): log.debug("- next %s"%(str(next[0])) ) log.debug(" - (%s, %s)"%(str(next[1]),str(next[2])) ) if next in expected_annotations: count += 1 else: self.assertTrue(False, "Not expected (%d) %s"%(count, repr(next))) self.assertEqual(count,6) # Clean up self.deleteTestRo(rodir) return
def testGetConstraints(self): self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements2.rdf") model = ro_minim.getElementUri(minimbase, "#runnableRO") constraint = ro_minim.getElementUri(minimbase, "#create/data/UserRequirements-astro.ods") # Read Minim as graph, scan constraints and look for expected value minimgraph = ro_minim.readMinimGraph(minimbase) constraints = ro_minim.getConstraints(minimgraph) expected_found = False for c in constraints: if ( c['target'] == ro_manifest.getComponentUri(rodir, "data/UserRequirements-astro.ods") and c['purpose'] == rdflib.Literal("create UserRequirements-astro.ods") and c['model'] == model and c['uri'] == constraint ) : expected_found = True break self.assertTrue(expected_found, "Expected constraint not found in minim") return
def testEvalQueryTestReportList(self): """ Test QueryTestRules reporting list of failed query probes """ self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) self.populateTestRo(testbase, rodir) rometa = ro_metadata(ro_config, rodir) resuri = rometa.getComponentUriAbs("data/NoSuchResource") rometa.addSimpleAnnotation(resuri, "rdfs:label", "Test label") # Now run evaluation against test RO (g, evalresult) = ro_eval_minim.evaluate(rometa, "Minim-UserRequirements2.rdf", # Minim file "data/NoSuchResource", # Target resource "report list") # Purpose log.debug("ro_eval_minim.evaluate result:\n----\n%s"%(repr(evalresult))) self.assertNotIn(MINIM.fullySatisfies, evalresult['summary']) self.assertNotIn(MINIM.nominallySatisfies, evalresult['summary']) self.assertIn(MINIM.minimallySatisfies, evalresult['summary']) self.assertEquals(evalresult['missingMust'], []) self.assertEquals(len(evalresult['missingShould']), 1) self.assertEquals(evalresult['missingShould'][0][0]['seq'], '04 - aggregates data/NoSuchResource') self.assertEquals(evalresult['missingMay'], []) self.assertEquals(evalresult['rouri'], rometa.getRoUri()) self.assertEquals(evalresult['minimuri'], rometa.getComponentUri("Minim-UserRequirements2.rdf")) self.assertEquals(evalresult['target'], "data/NoSuchResource") self.assertEquals(evalresult['purpose'], "report list") self.assertEquals(evalresult['constrainturi'], rometa.getComponentUriAbs("Minim-UserRequirements2.rdf#report/data/NoSuchResource")) self.assertEquals(evalresult['modeluri'], rometa.getComponentUriAbs("Minim-UserRequirements2.rdf#reportList")) # Check result bindings returned self.assertEquals(evalresult['missingShould'][0][1]['_count'], 1) self.assertEquals(evalresult['missingShould'][0][1]['_fileuri'], rometa.getComponentUri("data/NoSuchResource")) self.assertEquals(evalresult['missingShould'][0][1]['targetres'], rometa.getComponentUri("data/NoSuchResource")) self.assertEquals(evalresult['missingShould'][0][1]['ro'], str(rometa.getRoUri())) self.assertEquals(evalresult['missingShould'][0][1]['ro_list'], [str(rometa.getRoUri())]) # Clean up self.deleteTestRo(rodir) return
def testMinimRead(self): """ Basic test that Minim test file can be read """ self.setupConfig() rodir = self.createTestRo(testbase, "test-data-2", "RO test minim", "ro-testMinim") rouri = ro_manifest.getRoUri(rodir) minimbase = ro_manifest.getComponentUri(rodir, "Minim-UserRequirements2.rdf") target = ro_manifest.getComponentUri(rodir, "data/UserRequirements-astro.ods") constraint = ro_minim.getElementUri(minimbase, "#create/data/UserRequirements-astro.ods") model = ro_minim.getElementUri(minimbase, "#runnableRO") g = ro_minim.readMinimGraph(minimbase) expected_minim = ( [ (target, MINIM.hasChecklist, constraint ) , (constraint, MINIM.forPurpose, rdflib.Literal('create UserRequirements-astro.ods') ) , (constraint, MINIM.toModel, model ) , (model, RDF.type, MINIM.Model ) ]) self.checkTargetGraph(g, expected_minim, msg="Not found in Minim") self.deleteTestRo(rodir) return
def testGetInitialRoAnnotations(self): rodir = self.createTestRo(testbase, "data/ro-test-1", "Test init RO annotation", "ro-testRoAnnotate") roresource = "." # Retrieve the anotations annotations = ro_annotation._getRoAnnotations(rodir) rouri = ro_manifest.getRoUri(rodir) expected_annotations = ( [ (rouri, DCTERMS.description, rdflib.Literal('Test init RO annotation')) , (rouri, DCTERMS.title, rdflib.Literal('Test init RO annotation')) , (rouri, DCTERMS.created, rdflib.Literal('unknown')) , (rouri, DCTERMS.creator, rdflib.Literal('Test User')) , (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate')) , (rouri, RDF.type, RO.ResearchObject) ]) for i in range(6+1): # Annotations + aggregations next = annotations.next() #log.debug("Next %s"%(repr(next))) if ( next not in expected_annotations and next[1] != DCTERMS.created and next[1] != ORE.aggregates ): self.assertTrue(False, "Not expected (%d) %s"%(i, repr(next))) self.assertRaises(StopIteration, annotations.next) self.deleteTestRo(rodir) return
def testUri(rodir, uristring): self.assertEquals(ro_manifest.getRoUri(rodir), rdflib.URIRef(uristring)) return
def testGridMatch(self): self.setupConfig() rodir = self.createTestRo(testbase, "testro", "RO for Minim creation test", "ro-testMkMinim") rouri = ro_manifest.getRoUri(rodir) gridname = "TestMkMinim.csv" gridcsv = os.path.join(rodir, gridname) gridbase = "" with open(gridcsv, "rU") as gridfile: grid = GridCSV(gridfile, baseuri=gridbase, dialect=csv.excel) self.assertEqual(grid[0][0], "Minim definition for MkMinim testing") (d, (r, c)) = checklist_template.checklist.match(grid, 0, 0) self.assertEquals(r, 86, "newrow (%d)" % (r)) self.assertEquals(c, 1, "newcol (%d)" % (c)) ### print repr(d) self.assertEquals(d["matchtemplate"], "checklist", "matchtemplate") self.assertEquals(d["prefixes"]["ro"], "http://purl.org/wf4ever/ro#", "Prefix 'ro'") self.assertEquals(d["prefixes"]["minim"], "http://purl.org/minim/minim#", "Prefix 'minim'") self.assertEquals(d["prefixes"]["ao"], "http://purl.org/ao/", "Prefix 'ao'") self.assertEquals(d["prefixes"]["ex"], "http://example.org/", "Prefix 'ex'") self.assertEquals(len(d["checklists"]), 2, "Checklist count") self.assertEquals(d["checklists"][0]["model"], "#model_test1", "Checklist[1] model") self.assertEquals(d["checklists"][0]["target_urit"], "{+targetro}", "Checklist[1] uri") self.assertEquals(d["checklists"][0]["purpose"], "test1", "Checklist[1] purpose") self.assertEquals(d["checklists"][1]["model"], "#model_test2", "Checklist[2] model") self.assertEquals(d["checklists"][1]["target_urit"], "{+targetro}", "Checklist[2] uri") self.assertEquals(d["checklists"][1]["purpose"], "test2", "Checklist[2] purpose") self.assertEquals(len(d["models"]), 2, "Model count") self.assertEquals(d["models"][0]["modelid"], "#model_test1", "Model[1] id") self.assertEquals(len(d["models"][0]["items"]), 7, "Model[1] item count") self.assertEquals(d["models"][1]["modelid"], "#model_test2", "Model[2] id") self.assertEquals(len(d["models"][1]["items"]), 5, "Model[2] item count") self.assertEquals(len(d["requirements"]), 7, "Requirement count (%d found)" % (len(d["requirements"]))) self.assertEquals(d["requirements"][0]["reqid"], "#req_exists") self.assertEquals(d["requirements"][0]["exists"], "?file rdf:type ex:Part") self.assertEquals(d["requirements"][0]["pass"], "File exists as a part") self.assertEquals(d["requirements"][0]["fail"], "File as part does not exist") self.assertEquals(d["requirements"][0].get("miss"), None) self.assertEquals(d["requirements"][1]["reqid"], "#req_foreach_exists") self.assertEquals(d["requirements"][1]["foreach"], "?file rdf:type ex:Part") self.assertEquals(d["requirements"][1]["result_mod"], "ORDER BY ?file") self.assertEquals(d["requirements"][1]["exists"], "?file ex:partOf [ rdf:type ex:Whole ]") self.assertEquals(d["requirements"][1]["pass"], "Files as part are partOf some indicated whole") self.assertEquals(d["requirements"][1]["fail"], "File as part %(file)s is not part of some whole") self.assertEquals(d["requirements"][2]["reqid"], "#req_foreach_aggregated") self.assertEquals(d["requirements"][2]["foreach"], "?file rdf:type ex:Part") self.assertEquals(d["requirements"][2]["aggregates"], "{+file}") self.assertEquals(d["requirements"][2]["pass"], "All part resource files %(file_list)s are aggregated in RO") self.assertEquals(d["requirements"][2]["fail"], "File as part %(file)s is not aggregated in RO") self.assertEquals(d["requirements"][2]["miss"], "No file as part definitions are present") self.assertEquals(len(d["requirements"][2]["collectall"]), 1) self.assertEquals(d["requirements"][2]["collectall"][0]["collectvar"], "?file") self.assertEquals(d["requirements"][2]["collectall"][0]["collectlist"], "?file_list") self.assertEquals(d["requirements"][6]["reqid"], "#req_python") self.assertEquals(d["requirements"][6]["command"], "python --version") self.assertEquals(d["requirements"][6]["response"], "^Python 2\.7.*$") self.assertEquals(d["requirements"][6]["pass"], "Python 2.7.x present") self.assertEquals(d["requirements"][6]["fail"], "Python 2.7.x not present") self.deleteTestRo(rodir) return