def testEvaluateChecklistRemoteFail(self):
# Config remote testing
remotehost = "http://andros.zoo.ox.ac.uk"
remoterobase = "/aleix/ro-catalogue/v0.1/"
remoteroname = "wf74-repeat-fail/"
remoteminim = "simple-requirements-minim.rdf"
#self.setupConfig()
rouri = remotehost+remoterobase+remoteroname
rometa = ro_metadata(ro_config, rouri)
minimuri = rometa.getComponentUri(remoteminim)
# create rometa object
rometa = ro_metadata(ro_config, rouri)
# invoke evaluation service
# ro_eval_minim.evaluate(rometa, minim, target, purpose)
evalresult = ro_eval_minim.evaluate(rometa, minimuri, rouri, "Repeatable")
self.assertEqual(evalresult['rouri'], rdflib.URIRef(rouri))
self.assertEqual(evalresult['minimuri'], rdflib.URIRef(minimuri))
self.assertEqual(evalresult['target'], rouri)
self.assertEqual(evalresult['purpose'], "Repeatable")
self.assertEqual(evalresult['constrainturi'],
rometa.getComponentUri("simple-requirements-minim.rdf#repeatable_RO"))
self.assertEqual(evalresult['modeluri'],
rometa.getComponentUri("simple-requirements-minim.rdf#repeatable_RO_model"))
self.assertNotIn(MINIM.fullySatisfies, evalresult['summary'])
self.assertNotIn(MINIM.nominallySatisfies, evalresult['summary'])
self.assertNotIn(MINIM.minimallySatisfies, evalresult['summary'])
self.assertEqual(len(evalresult['missingMust']), 1)
self.assertEqual(len(evalresult['missingShould']), 0)
self.assertEqual(len(evalresult['missingMay']), 0)
self.assertEqual(len(evalresult['satisfied']), 4)
return
def testGetInitialRoAnnotations(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test init RO annotation", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "."
# Retrieve the anotations
annotations = romd.getRoAnnotations()
rouri = romd.getRoUri()
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 real_evaluate(request):
# From: http://tools.ietf.org/html/rfc3986#section-2.1
# gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
# sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
# / "*" / "+" / "," / ";" / "="
quotesafe = ":/?#[]@!$&'()*+,;=" + "%"
# isolate parameters (keep invalid URI characters %-encoded)
RO = urllib.quote(request.params["RO"], quotesafe)
minim = urllib.quote(request.params["minim"], quotesafe)
target = urllib.quote(request.params.get("target","."), quotesafe)
purpose = request.params["purpose"]
log.info("Evaluate RO %s, minim %s, target %s, purpose %s"%(RO,minim,target,purpose))
# create rometa object
# @@TODO: use proper configuration and credentials
ROparse = urlparse.urlparse(RO)
rosrs_uri = (ROparse.scheme or "http") + "://" + (ROparse.netloc or "localhost:8000") + "/"
ro_config = {
"annotationTypes": annotationTypes,
"annotationPrefixes": annotationPrefixes,
"rosrs_uri": rosrs_uri,
#"rosrs_uri": target,
#"rosrs_uri": "http://sandbox.wf4ever-project.org/rodl/ROs/",
#"rosrs_access_token": "ac14dd1a-ab59-40ec-b510-ffdb01a85473",
"rosrs_access_token": None,
}
rometa = ro_metadata(ro_config, RO)
log.info("rometa.rouri: %s"%(rometa.rouri) )
# invoke evaluation service
(graph, evalresult) = ro_eval_minim.evaluate(rometa, minim, target, purpose)
log.debug("evaluate:results: \n"+json.dumps(evalresult, indent=2))
# Assemble graph of results
graph = ro_eval_minim.evalResultGraph(graph, evalresult)
return graph
def testEvalShouldMissing(self):
"""
Evaluate complete RO against Minim description
"""
self.setupConfig()
rodir = self.createTestRo(testbase, "test-data-1", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
minimbase = rometa.getComponentUri("Minim-UserRequirements.rdf")
modeluri = ro_minim.getElementUri(minimbase, "#missingShouldRequirement")
(g,evalresult) = ro_eval_minim.evaluate(rometa,
"Minim-UserRequirements.rdf", # Minim file
"docs/UserRequirements-bio.html", # Target resource
"create") # Purpose
missing_should = (
{ 'level': "SHOULD"
, 'model': modeluri
, 'label': rdflib.Literal("aggregates docs/missing.css")
, 'datarule':
{ 'aggregates': rometa.getComponentUri("docs/missing.css")
, 'show': None
, 'showpass': None
, 'showfail': None
, 'derives': ro_minim.getElementUri(minimbase, "#isPresent/docs/missing.css")
}
, 'uri': ro_minim.getElementUri(minimbase, "#isPresent/docs/missing.css")
})
self.maxDiff=None
self.assertEquals(evalresult['summary'], [MINIM.minimallySatisfies])
self.assertEquals(evalresult['missingMust'], [] )
self.assertEquals(evalresult['missingShould'], [(missing_should,{})] )
self.assertEquals(evalresult['missingMay'], [] )
self.deleteTestRo(rodir)
return
def testAddGetAnnotationValues(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test get annotation values", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
romd.addSimpleAnnotation(roresource, "type", "Test file")
romd.addSimpleAnnotation(roresource, "description", "File in test research object")
romd.addSimpleAnnotation(roresource, "rdf:type", ROTERMS.resource)
# Retrieve the anotations
values = romd.getAnnotationValues(".", "title")
self.assertEquals(values.next(), rdflib.Literal('Test get annotation values'))
self.assertRaises(StopIteration, values.next)
values = romd.getAnnotationValues(".", "rdf:type")
self.assertEquals(values.next(), RO.ResearchObject)
self.assertRaises(StopIteration, values.next)
values = romd.getAnnotationValues(roresource, "type")
self.assertEquals(values.next(), rdflib.Literal('Test file'))
self.assertRaises(StopIteration, values.next)
values = romd.getAnnotationValues(roresource, "description")
self.assertEquals(values.next(), rdflib.Literal('File in test research object'))
self.assertRaises(StopIteration, values.next)
values = romd.getAnnotationValues(roresource, "rdf:type")
self.assertEquals(values.next(), ROTERMS.resource)
self.assertRaises(StopIteration, values.next)
# Clean up
self.deleteTestRo(rodir)
return
def testRemoveGetFileAnnotations(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test remove file annotation", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
romd.addSimpleAnnotation(roresource, "type", "Test file")
romd.addSimpleAnnotation(roresource, "description", "File in test research object")
romd.addSimpleAnnotation(roresource, "note", "Research object file created for annotation testing")
romd.addSimpleAnnotation(roresource, "title", "Test file in RO")
romd.addSimpleAnnotation(roresource, "created", "2011-12-07")
romd.addSimpleAnnotation(roresource, "rdf:type", ROTERMS.resource)
# Remove annotations
romd.removeSimpleAnnotation(roresource, "description", "File in test research object")
romd.removeSimpleAnnotation(roresource, "note", None)
# Retrieve the file anotations
annotations = romd.getFileAnnotations(roresource)
resourceuri = romd.getComponentUri(roresource)
log.debug("resourceuri: %s"%(resourceuri))
expected_annotations = (
[ (resourceuri, DCTERMS.type, rdflib.Literal('Test file'))
, (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(4):
next = annotations.next()
#log.debug("Next %s"%(repr(next)))
if ( next not in expected_annotations):
self.assertTrue(False, "Not expected (%d) %s"%(i, repr(next)))
self.assertRaises(StopIteration, annotations.next)
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 testGetInitialRoAnnotations(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
# Retrieve the anotations
annotations = romd.getRoAnnotations()
rouri = romd.getRoUri()
expected_annotations = (
[ (rouri, RDF.type, RO.ResearchObject)
, (rouri, RDF.type, ROEVO.LiveRO)
, (rouri, ORE.isDescribedBy, romd.getComponentUriAbs(ro_test_config.ROMANIFESTPATH))
#, (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'))
])
count = 0
for next in list(annotations):
if ( not isinstance(next[2], rdflib.BNode) and
not next[1] in [ORE.aggregates, DCTERMS.created, DCTERMS.creator] ):
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,3)
return
def testReplaceGetRoAnnotations(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test replace RO annotation", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "."
# Replace anotations for RO
romd.replaceSimpleAnnotation(roresource, "type", "Research Object")
romd.replaceSimpleAnnotation(roresource, "description", "Replacement description")
romd.replaceSimpleAnnotation(roresource, "note", "Research object for annotation replacement testing")
romd.replaceSimpleAnnotation(roresource, "title", "Replacement title")
romd.replaceSimpleAnnotation(roresource, "created", "2011-12-07")
# Retrieve the anotations
annotations = romd.getRoAnnotations()
rouri = romd.getRoUri()
expected_annotations = (
[ (rouri, DCTERMS.type, rdflib.Literal('Research Object'))
, (rouri, DCTERMS.title, rdflib.Literal('Replacement title'))
, (rouri, DCTERMS.description, rdflib.Literal('Replacement description'))
, (rouri, ROTERMS.note, rdflib.Literal('Research object for annotation replacement testing'))
, (rouri, DCTERMS.created, rdflib.Literal('2011-12-07'))
, (rouri, DCTERMS.creator, rdflib.Literal('Test User'))
, (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate'))
, (rouri, RDF.type, RO.ResearchObject)
])
for i in range(8+1): # Annotations + aggregations
next = annotations.next()
#log.debug("Next %s"%(repr(next)))
if ( next not in expected_annotations 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 testGetAggregatedResources(self):
"""
Test function that enumerates aggregated resources to a research object manifest
"""
rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test aggregation", "ro-testRoAggregation")
romd = ro_metadata.ro_metadata(ro_config, rodir)
romd.addAggregatedResources(rodir, recurse=True)
def URIRef(path):
return romd.getComponentUriAbs(path)
resources = (
[ URIRef("README-ro-test-1")
, URIRef("minim.rdf")
, URIRef("subdir1/subdir1-file.txt")
, URIRef("subdir2/subdir2-file.txt")
, URIRef("filename%20with%20spaces.txt")
, URIRef("filename%23with%23hashes.txt")
])
c = 0
for r in romd.getAggregatedResources():
if not romd.hasResourceType(r, RO.AggregatedAnnotation):
c += 1
self.assertIn(r, resources)
self.assertEqual(c, len(resources))
self.deleteTestRo(rodir)
return
def testEvalAllPresent(self):
"""
Evaluate complete RO against Minim description
"""
self.setupConfig()
rodir = self.createTestRo(testbase, "test-data-1", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
(g,evalresult) = ro_eval_minim.evaluate(rometa,
"Minim-UserRequirements.rdf", # Minim file
"docs/UserRequirements-astro.csv", # Target resource
"create") # Purpose
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-UserRequirements.rdf"))
self.assertEquals(evalresult['target'], "docs/UserRequirements-astro.csv")
self.assertEquals(evalresult['purpose'], "create")
self.assertEquals(evalresult['constrainturi'],
rometa.getComponentUriAbs("Minim-UserRequirements.rdf#create/docs/UserRequirements-astro.csv"))
self.assertEquals(evalresult['modeluri'],
rometa.getComponentUriAbs("Minim-UserRequirements.rdf#runnableRequirementRO"))
self.deleteTestRo(rodir)
return
def testCreateGraphRoUri2(self):
ro_config["rosrs_uri"] = "http://localhost:8000/rovserver/"
ro_uri = "http://localhost:8000/rovserver/ROs/0d8b454f/"
rosrs_uri = ro_config["rosrs_uri"]
romd = ro_metadata.ro_metadata(ro_config, ro_uri)
self.assertEquals(romd.rouri, rdflib.URIRef(ro_uri))
return
def testQueryAnnotationsWithMissingGraph(self):
"""
This test is included to ensure that queries still work as expected when
the manifest contains a reference to a non-existent manifest graph
"""
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test query annotations", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
romd.addSimpleAnnotation(roresource, "type", "Test file")
romd.addSimpleAnnotation(roresource, "description", "File in test research object")
romd.addSimpleAnnotation(roresource, "note", "Research object file created for annotation testing")
romd.addSimpleAnnotation(roresource, "title", "Test file in RO")
romd.addSimpleAnnotation(roresource, "created", "2011-12-07")
romd.addSimpleAnnotation(roresource, "rdf:type", ROTERMS.resource)
# Apply non-exietent graph annotation
annotation_graph_filename = os.path.join(os.path.abspath(rodir), "annotate-none.rdf")
romd.addGraphAnnotation(roresource, annotation_graph_filename)
# Query the file anotations
query = (make_sparql_prefixes() +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test User" .
?file rdf:type roterms:resource ;
dcterms:type "Test file" ;
dcterms:created "2011-12-07" .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s")
self.deleteTestRo(rodir)
return
def testEvaluateMissingRDF(self):
# repeat previous test case, but with RDF output
self.setupConfig()
rodir = self.createTestRo(testbase, "test-simple-wf", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
self.annotateWfRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
minimuri = rometa.getComponentUri("simple-wf-minim.rdf")
# Evaluate
args = [ "ro", "evaluate", "checklist"
, "-a"
, "-d", rodir+"/"
, "-o", "rdfxml"
, "simple-wf-minim.rdf"
, "Missing"
, "."
]
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: \n--------\n%s----"%(status, outtxt))
# Check response returned
self.outstr.seek(0)
outgraph = rdflib.Graph()
outgraph.parse(self.outstr)
prefixes = make_sparql_prefixes()
rouri = rometa.getRoUri()
modeluri = rometa.getComponentUriAbs("simple-wf-minim.rdf#missing_RO_model")
log.debug("------ outgraph:\n%s\n----"%(outgraph.serialize(format='turtle')))
probequeries = (
[ "ASK { _:r minim:testedRO <%s> ; minim:minimUri <%s> }"%
(rouri, minimuri)
, "ASK { _:r minim:testedRO <%s> ; minim:testedModel <%s> }"%
(rouri, modeluri)
, """ASK
{ _:r minim:testedRO <%(rouri)s> ;
minim:testedPurpose "Missing" ;
minim:missingMust
[ minim:tryMessage "No workflow present with hens tooth" ;
result:binding [ result:variable "_count" ; result:value 0 ]
]
}"""% { 'rouri': rouri }
, '''ASK { _:r minim:testedRO <%s> ; minim:missingMust [ minim:tryMessage "%s" ] }'''%
(rouri, "No workflow present with hens tooth")
, '''ASK { _:r minim:testedRO <%s> ; minim:testedTarget <%s> }'''%
(rouri, rouri)
, '''ASK { <%s> rdfs:label "%s" }'''%
(rouri, rdflib.Literal("RO test minim"))
])
for q in probequeries:
r = outgraph.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 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 testEvaluateWfInputsRDF(self):
# repeat previous test case, but with RDF output
self.setupConfig()
rodir = self.createTestRo(testbase, "test-simple-wf", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
self.annotateWfRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
minimuri = rometa.getComponentUri("simple-wf-minim.rdf")
# Evaluate
args = [ "ro", "evaluate", "checklist"
, "-a"
, "-d", rodir+"/"
, "-o", "rdfxml"
, "simple-wf-minim.rdf"
, "Runnable"
, "."
]
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: \n--------\n%s----"%(status, outtxt))
# Check response returned
self.outstr.seek(0)
outgraph = rdflib.Graph()
outgraph.parse(self.outstr)
prefixes = make_sparql_prefixes()
rouri = rometa.getRoUri()
modeluri = rometa.getComponentUriAbs("simple-wf-minim.rdf#runnable_RO_model")
probequeries = (
[ '''ASK { _:r minim:testedRO <%s> ; minim:minimUri <%s> }'''%
(rouri, minimuri)
, '''ASK { _:r minim:testedRO <%s> ; minim:testedModel <%s> }'''%
(rouri, modeluri)
, '''ASK { _:r minim:testedRO <%s> ; minim:satisfied [ minim:tryMessage "%s" ] }'''%
(rouri, "Workflow instance or template found")
, '''ASK { _:r minim:testedRO <%s> ; minim:satisfied [ minim:tryMessage "%s" ] }'''%
(rouri, "All workflow inputs referenced or present")
, '''ASK { _:r minim:testedRO <%s> ; minim:fullySatisfies <%s> }'''%
(rouri, modeluri)
, '''ASK { _:r minim:testedRO <%s> ; minim:nominallySatisfies <%s> }'''%
(rouri, modeluri)
, '''ASK { _:r minim:testedRO <%s> ; minim:minimallySatisfies <%s> }'''%
(rouri, modeluri)
, '''ASK { <%s> rdfs:label "%s" }'''%
(rouri, rdflib.Literal("RO test minim"))
])
for q in probequeries:
log.debug("- query %s"%(q))
r = outgraph.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 testQueryAnnotations(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test query annotations", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
romd.addSimpleAnnotation(roresource, "type", "Test file")
romd.addSimpleAnnotation(roresource, "description", "File in test research object")
romd.addSimpleAnnotation(roresource, "note", "Research object file created for annotation testing")
romd.addSimpleAnnotation(roresource, "title", "Test file in RO")
romd.addSimpleAnnotation(roresource, "created", "2011-12-07")
romd.addSimpleAnnotation(roresource, "rdf:type", ROTERMS.resource)
# Query the file anotations
queryprefixes = make_sparql_prefixes()
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test User" .
?file rdf:type roterms:resource ;
dcterms:type "Test file" ;
dcterms:created "2011-12-07" .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s"%(query))
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Not user" .
}
""")
resp = romd.queryAnnotations(query)
self.assertFalse(resp, "Expected 'False' result for query: %s"%(query))
query = (queryprefixes +
"""
SELECT * WHERE
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test User" .
?file rdf:type roterms:resource ;
dcterms:type "Test file" ;
dcterms:created ?date .
}
""")
rouri = romd.getRoUri()
resourceuri = romd.getComponentUri(roresource)
resp = romd.queryAnnotations(query)
self.assertEqual(resp[0]['ro'], rouri)
self.assertEqual(resp[0]['file'], romd.getComponentUri(roresource))
self.assertEqual(resp[0]['date'], rdflib.Literal("2011-12-07"))
self.deleteTestRo(rodir)
return
def testQueryAnnotations(self):
(status, reason, rouri, manifest) = self.createTestRO("testQueryAnnotations")
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE)
resref = Config.TEST_RESOURCE
(status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref)
self.assertEqual(status, 201)
# Query the file anotations
queryprefixes = make_sparql_prefixes()
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator ?user .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s"%(query))
query = (queryprefixes +
"""
ASK
{
<%(resuri)s> dcterms:title ?title .
}
"""%{"resuri": str(resuri)})
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s"%(query))
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Not user" .
}
""")
resp = romd.queryAnnotations(query)
self.assertFalse(resp, "Expected 'False' result for query: %s"%(query))
query = (queryprefixes +
"""
SELECT * WHERE
{
?ro rdf:type ro:ResearchObject ;
ore:aggregates ?file .
?file dcterms:title ?title .
}
""")
rouri = romd.getRoUri()
resp = romd.queryAnnotations(query)
self.assertEqual(resp[0]['ro'], rouri)
self.assertEqual(resp[0]['file'], resuri)
self.assertEqual(resp[0]['title'], rdflib.Literal("Title for %s"%(Config.TEST_RESOURCE)))
return
def testQueryAnnotationsRemote(self):
romd = ro_metadata.ro_metadata(
ro_config,
"http://andros.zoo.ox.ac.uk/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
)
# Query the file anotations
queryprefixes = """
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ro: <http://purl.org/wf4ever/ro#>
PREFIX ore: <http://www.openarchives.org/ore/terms/>
PREFIX ao: <http://purl.org/ao/>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX roterms: <http://ro.example.org/ro/terms/>
"""
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test user" ;
ore:aggregates ?file .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s")
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Not user" .
}
""")
resp = romd.queryAnnotations(query)
self.assertFalse(resp, "Expected 'False' result for query: %s")
query = (queryprefixes +
"""
SELECT * WHERE
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test user" ;
ore:aggregates ?file .
}
""")
rouri = romd.getRoUri()
resourceuri = romd.getComponentUri("README")
resp = romd.queryAnnotations(query)
self.assertEqual(resp[0]['ro'], rouri)
aggs = [ respn['file'] for respn in resp ]
self.assertIn( resourceuri, aggs, repr(aggs))
return
def real_evaluate(request):
# isolate parameters
RO = request.params["RO"]
minim = request.params["minim"]
target = request.params.get("target",".")
purpose = request.params["purpose"]
# create rometa object
# @@TODO: use proper configuration and credentials
ro_config = {
"annotationTypes": annotationTypes,
"annotationPrefixes": annotationPrefixes,
#"rosrs_uri": target,
"rosrs_uri": "http://sandbox.wf4ever-project.org/rodl/ROs/",
"rosrs_access_token": "32801fc0-1df1-4e34-b",
}
rometa = ro_metadata(ro_config, RO)
# invoke evaluation service
# ro_eval_minim.evaluate(rometa, minim, target, purpose)
log.info("Evaluate RO %s, minim %s, target %s, purpose %s"%(RO,minim,target,purpose))
(graph, evalresult) = ro_eval_minim.evaluate(rometa, minim, target, purpose)
log.debug("evaluate:results: \n"+json.dumps(evalresult, indent=2))
# Assemble graph of results
#graph = rdflib.Graph() // start with minim graph
graph.bind("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
graph.bind("result", "http://www.w3.org/2001/sw/DataAccess/tests/result-set#")
graph.bind("minim", "http://purl.org/minim/minim#")
rouri = rdflib.URIRef(evalresult['rouri'])
graph.add( (rouri, MINIM.testedConstraint, rdflib.URIRef(evalresult['constrainturi'])) )
graph.add( (rouri, MINIM.testedPurpose, rdflib.Literal(evalresult['purpose'])) )
graph.add( (rouri, MINIM.testedTarget, rdflib.Literal(evalresult['target'])) )
graph.add( (rouri, MINIM.minimUri, rdflib.URIRef(evalresult['minimuri'])) )
graph.add( (rouri, MINIM.modelUri, rdflib.URIRef(evalresult['modeluri'])) )
for level in evalresult['summary']:
log.info("RO %s, level %s, model %s"%(rouri,level,evalresult['modeluri']))
graph.add( (rouri, level, rdflib.URIRef(evalresult['modeluri'])) )
# Add details for all rules tested...
def addRequirementsDetail(results, satlevel):
for (req, binding) in results:
b = rdflib.BNode()
graph.add( (rouri, satlevel, b) )
graph.add( (b, MINIM.tryRequirement, req['uri']) )
for k in binding:
b2 = rdflib.BNode()
graph.add( (b, RESULT.binding, b2) )
graph.add( (b2, RESULT.variable, rdflib.Literal(k)) )
graph.add( (b2, RESULT.value, rdflib.Literal(binding[k])) )
addRequirementsDetail(evalresult['satisfied'], MINIM.satisfied)
addRequirementsDetail(evalresult['missingMay'], MINIM.missingMay)
addRequirementsDetail(evalresult['missingShould'], MINIM.missingShould)
addRequirementsDetail(evalresult['missingMust'], MINIM.missingMust)
return graph
def testReadRoAnnotationBody(self):
"""
Test function to create & read a simple annotation body on an RO
"""
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE)
resref = Config.TEST_RESOURCE
(status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref)
self.assertEqual(status, 201)
# Retrieve annotations
anns = list(romd.getFileAnnotations(Config.TEST_RESOURCE))
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for "+Config.TEST_RESOURCE)), anns)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), anns)
return
def testEvalMayMissing(self):
"""
Evaluate complete RO against Minim description
"""
self.setupConfig()
rodir = self.createTestRo(testbase, "test-data-1", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
minimbase = rometa.getComponentUri("Minim-UserRequirements.rdf")
modeluri = ro_minim.getElementUri(minimbase, "#missingMayRequirement")
(g,evalresult) = ro_eval_minim.evaluate(rometa,
"Minim-UserRequirements.rdf", # Minim file
"docs/UserRequirements-bio.pdf", # Target resource
"create") # Purpose
missing_may = (
{ 'level': "MAY"
, 'model': modeluri
, 'label': rdflib.Literal("aggregates docs/missing.css")
, 'datarule':
{ 'aggregates': rometa.getComponentUri("docs/missing.css")
, 'show': rdflib.Literal("05 - aggregates docs/missing.css")
, 'showpass': None
, 'showfail': None
, 'showmiss': None
, 'list': []
, 'listpass': []
, 'listfail': []
}
, 'uri': ro_minim.getElementUri(minimbase, "#isPresent/docs/missing.css")
, 'ruleuri': evalresult['missingMay'][0][0]['ruleuri']
, 'seq': "05 - aggregates docs/missing.css"
})
self.maxDiff=None
self.assertEquals(evalresult['summary'], [MINIM.nominallySatisfies, MINIM.minimallySatisfies])
self.assertEquals(evalresult['missingMust'], [] )
self.assertEquals(evalresult['missingShould'], [] )
self.assertEquals(evalresult['missingMay'], [(missing_may,{})] )
self.assertEquals(evalresult['rouri'], rometa.getRoUri())
self.assertEquals(evalresult['minimuri'], rometa.getComponentUri("Minim-UserRequirements.rdf"))
self.assertEquals(evalresult['target'], "docs/UserRequirements-bio.pdf")
self.assertEquals(evalresult['purpose'], "create")
self.assertEquals(evalresult['constrainturi'],
rometa.getComponentUriAbs("Minim-UserRequirements.rdf#create/docs/UserRequirements-bio.pdf"))
self.assertEquals(evalresult['modeluri'],
rometa.getComponentUriAbs("Minim-UserRequirements.rdf#missingMayRequirement"))
self.deleteTestRo(rodir)
return
def testQueryAnnotationsRemote(self):
romd = ro_metadata.ro_metadata(
ro_config,
"http://andros.zoo.ox.ac.uk/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
)
# Query the file anotations
queryprefixes = make_sparql_prefixes()
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test user" ;
ore:aggregates ?file .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s")
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Not user" .
}
""")
resp = romd.queryAnnotations(query)
self.assertFalse(resp, "Expected 'False' result for query: %s")
query = (queryprefixes +
"""
SELECT * WHERE
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test user" ;
ore:aggregates ?file .
}
""")
rouri = romd.getRoUri()
resourceuri = romd.getComponentUri("README")
resp = romd.queryAnnotations(query)
self.assertEqual(resp[0]['ro'], rouri)
aggs = [ respn['file'] for respn in resp ]
self.assertIn( resourceuri, aggs, repr(aggs))
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 testQueryAnnotationsWithMissingGraph(self):
"""
This test is included to ensure that queries still work as expected when
the manifest contains a reference to a non-existent manifest graph
"""
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test query annotations", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
romd.addSimpleAnnotation(roresource, "type", "Test file")
romd.addSimpleAnnotation(roresource, "description", "File in test research object")
romd.addSimpleAnnotation(roresource, "note", "Research object file created for annotation testing")
romd.addSimpleAnnotation(roresource, "title", "Test file in RO")
romd.addSimpleAnnotation(roresource, "created", "2011-12-07")
romd.addSimpleAnnotation(roresource, "rdf:type", ROTERMS.resource)
# Apply non-exietent graph annotation
annotation_graph_filename = os.path.join(os.path.abspath(rodir), "annotate-none.rdf")
romd.addGraphAnnotation(roresource, annotation_graph_filename)
# Query the file anotations
queryprefixes = """
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ro: <http://purl.org/wf4ever/ro#>
PREFIX ore: <http://www.openarchives.org/ore/terms/>
PREFIX ao: <http://purl.org/ao/>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX roterms: <http://ro.example.org/ro/terms/>
"""
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Test User" .
?file rdf:type roterms:resource ;
dcterms:type "Test file" ;
dcterms:created "2011-12-07" .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s")
self.deleteTestRo(rodir)
return
def testCreateReadRoAnnotationBody(self):
"""
Test function to create & read a simple annotation body on an RO
"""
rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test annotation", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "."
attrdict = {
"type": rdflib.Literal("Research Object"),
# @@TODO: handle lists "keywords": ["test", "research", "object"],
"description": rdflib.Literal("Test research object"),
"format": rdflib.Literal("application/vnd.wf4ever.ro"),
"note": rdflib.Literal("Research object created for annotation testing"),
"title": rdflib.Literal("Test research object"),
"created": rdflib.Literal("2011-12-07")
}
annotationfile = romd._createAnnotationBody(roresource, attrdict)
# Ann-%04d%02d%02d-%04d-%s.rdf
self.assertRegexpMatches(annotationfile,
r"^\.ro/Ann-\d\d\d\d\d\d\d\d-\d+-RO_test_annotation\.rdf",
msg="Unexpected filename form for annotation: "+annotationfile)
annotationgraph = romd._readAnnotationBody(annotationfile)
attrpropdict = {
"type": DCTERMS.type,
# @@TODO "keywords": DCTERMS.subject,
"description": DCTERMS.description,
"format": DCTERMS.format,
"note": ROTERMS.note,
"title": DCTERMS.title,
"created": DCTERMS.created
}
s = romd.getComponentUri(roresource)
log.debug("annotation subject %s"%repr(s))
for k in attrpropdict:
p = attrpropdict[k]
log.debug("annotation predicate %s"%repr(p))
v = attrdict[k]
a = annotationgraph.value(s, p, None)
log.debug("annotation value %s"%repr(a))
#self.assertEqual(len(a), 1, "Singleton result expected")
self.assertEqual(a, v)
self.deleteTestRo(rodir)
return
def testEvaluateWfInputs(self):
# Test cases using content match rule
# Also tests constraint that is not directly linked to RO,
# and use of designated target resource in probe query
self.setupConfig()
rodir = self.createTestRo(testbase, "test-simple-wf", "RO test minim", "ro-testMinim")
self.populateTestRo(testbase, rodir)
self.annotateWfRo(testbase, rodir)
rometa = ro_metadata(ro_config, rodir)
minimuri = rometa.getComponentUri("simple-wf-minim.rdf")
# Evaluate
args = [ "ro", "evaluate", "checklist"
, "-a"
, "-d", rodir+"/"
, "simple-wf-minim.rdf"
, "Runnable"
, "."
]
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
expect = (
[ "Research Object file://%s/:"%(rodir)
, "Fully complete for Runnable of resource ."
, "Satisfied requirements:"
, " Workflow instance or template found"
, " All workflow inputs referenced or present"
, "Research object URI: %s"%(rometa.getRoUri())
, "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 testAddAggregatedResourcesWithDirs(self):
"""
Test function that adds aggregated resources to a research object manifest
"""
rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test aggregation", "ro-testRoAggregation")
romd = ro_metadata.ro_metadata(ro_config, rodir)
romd.addAggregatedResources(rodir, recurse=True, includeDirs=True)
def URIRef(path):
return romd.getComponentUri(path)
s = romd.getRoUri()
g = rdflib.Graph()
g.add( (s, RDF.type, RO.ResearchObject ) )
g.add( (s, ORE.aggregates, URIRef("README-ro-test-1") ) )
g.add( (s, ORE.aggregates, URIRef("subdir1/") ) )
g.add( (s, ORE.aggregates, URIRef("subdir1/subdir1-file.txt") ) )
g.add( (s, ORE.aggregates, URIRef("subdir2/") ) )
g.add( (s, ORE.aggregates, URIRef("subdir2/subdir2-file.txt") ) )
self.checkManifestGraph(rodir, g)
self.deleteTestRo(rodir)
return
def testAddRoAnnotationIsAggregated(self):
rodir = self.createTestRo(testbase, "data/ro-test-1",
"Test add RO annotation", "ro-testRoAnnotate")
romd = ro_metadata.ro_metadata(ro_config, rodir)
roresource = "."
# Add anotations for RO
romd.addSimpleAnnotation(roresource, "note", "Research object for annotation testing")
# Retrieve the anotations
rouri = romd.getRoUri()
addedannotation = (rouri, ROTERMS.note, rdflib.Literal('Research object for annotation testing'))
annotations = romd.getRoAnnotations()
self.assertIn(addedannotation, annotations)
for (a, p) in romd.manifestgraph.subject_predicates(object=rouri):
if p in [AO.annotatesResource, RO.annotatesAggregatedResource]:
b = romd.manifestgraph.value(subject=a, predicate=AO.body)
if str(romd.getComponentUriRel(b)) != ro_test_config.ROMANIFESTPATH:
aggregate_annbody = (rouri, ORE.aggregates, b)
self.assertIn(aggregate_annbody, romd.manifestgraph)
self.deleteTestRo(rodir)
return
def testPush(self):
"""
Push a Research Object to ROSRS.
ro push <zip> | -d <dir> [ -f ] [ -r <rosrs_uri> ] [ -t <access_token> ]
"""
rodir = self.createTestRo(testbase, "data/ro-test-1", "RO test ro push", "ro-testRoPush")
localRo = ro_metadata.ro_metadata(ro_config, rodir)
localRo.addAggregatedResources(rodir, recurse=True)
roresource = "subdir1/subdir1-file.txt"
# Add anotations for file
localRo.addSimpleAnnotation(roresource, "type", "Test file")
localRo.addSimpleAnnotation(roresource, "description", "File in test research object")
args = [
"ro", "push",
"-d", rodir,
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
httpsession = ROSRS_Session(ro_test_config.ROSRS_URI,
accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
ro_remote_metadata.deleteRO(httpsession, urlparse.urljoin(httpsession.baseuri(), "RO_test_ro_push/"))
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
self.assertEqual(self.outstr.getvalue().count("Resource uploaded:"), 8)
self.assertEqual(self.outstr.getvalue().count("Resource deleted in ROSRS:"), 0)
self.assertEqual(self.outstr.getvalue().count("Annotation pushed:"), 3)
self.assertEqual(self.outstr.getvalue().count("Annotation deleted in ROSRS:"), 0)
# Clean up
self.deleteTestRo(rodir)
httpsession = ROSRS_Session(ro_test_config.ROSRS_URI,
accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
for line in self.outstr.getvalue().splitlines():
if "Created RO:" in line:
createdRO = line.split("Created RO:")[1].strip()
ro_remote_metadata.deleteRO(httpsession, createdRO)
return
