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
