def testTrafficlightJSON(self):
"""
Test report generating traffic-light JSON (per data/mockup.json)
"""
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
RdfReport.generate_report(TrafficLightReports.EvalChecklistJson, rdfgraph, {}, outstr)
# Test the non-item output only. The previous test checks itemized output.
expected = (
[ ''''''
, '''{ "rouri": "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"'''
, ''', "roid": "simple-requirements"'''
, ''', "title": "A simple test RO"'''
, ''', "description": "A simple RO used for testing traffic light display."'''
, ''', "checklisturi": "file:///usr/workspace/wf4ever-ro-manager/Checklists/runnable-wf-trafficlight/checklist.rdf#Runnable_model"'''
, ''', "checklistpurpose": "Runnable"'''
, ''', "checklisttarget": "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"'''
, ''', "checklisttargetid": "simple-requirements"'''
, ''', "checklisttargetlabel": "simple-requirements"'''
, ''', "evalresult": "http://purl.org/minim/minim#minimallySatisfies"'''
, ''', "evalresultlabel": "minimally satisfies"'''
, ''', "evalresultclass": ["fail", "should"]'''
])
result = outstr.getvalue()
log.debug("---- JSON result\n%s\n----"%(result))
resultlines = result.split('\n')
for i in range(len(expected)):
self.assertEqual(expected[i], resultlines[i].strip())
# Check that output is valid JSON
resultdict = json.loads(result)
self.assertEqual(resultdict['rouri'],
"file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/")
return
def testReportEvalItemHTML(self):
"""
Test report of a textual status summary of a checklist match
"""
rouristr = "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
checklist = "file:///usr/workspace/wf4ever-ro-manager/Checklists/runnable-wf-trafficlight/checklist.rdf"
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
initvars = (
{ 'result': rdfgraph.value(predicate=RDF.type, object=MINIM.Result)
, 'rouri': rdflib.URIRef(rouristr)
, 'modeluri': rdflib.URIRef(checklist+"#Runnable_model")
, 'itemuri': rdflib.URIRef(checklist+"#workflow_inputs_accessible")
, 'itemlevel': rdflib.URIRef("http://purl.org/minim/minim#missingShould")
})
outstr = StringIO.StringIO()
RdfReport.generate_report(TrafficLightReports.EvalItemHtml, rdfgraph, initvars, outstr)
expected = (
[ ''
, '''<tr class="sub_result">'''
, '''<td></td>'''
, '''<td class="trafficlight small fail should"><div/></td>'''
, '''<td>Workflow %sdocs/mkjson.sh input %sdata/UserRequirements-bio.ods is not accessible</td>'''%
(rouristr, rouristr)
, '''</tr>'''
])
result = outstr.getvalue()
#print "\n-----"
#print result
#print "-----"
resultlines = result.split('\n')
for i in range(len(expected)):
self.assertEqual(expected[i], resultlines[i].strip())
return
def testReportEvalResultUri(self):
"""
Test report that selects one of the following test result status URIs from:
http://purl.org/minim/minim#fullySatifies
http://purl.org/minim/minim#nominallySatifies
http://purl.org/minim/minim#minimallySatifies
http://purl.org/minim/minim#potentiallySatisfies
"""
rouristr = "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
checklist = "file:///usr/workspace/wf4ever-ro-manager/Checklists/runnable-wf-trafficlight/checklist.rdf"
initvars = (
{ 'target': rdflib.URIRef(rouristr)
, 'minim': rdflib.URIRef(checklist+"#Runnable_model")
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
RdfReport.generate_report(TrafficLightReports.EvalTargetResultUri, rdfgraph, initvars, outstr)
expected = "http://purl.org/minim/minim#minimallySatisfies"
result = outstr.getvalue()
# print "\n-----"
# print result
# print "-----"
self.assertEqual(expected, result)
return
def evaluate_trafficlight_html(request):
"""
Return HTML page for trafficlight display of checklist evaluation
Request parameters as as for checklist evaluation.
"""
resultgraph = evaluate(request)
outstr = StringIO.StringIO()
RdfReport.generate_report(
TrafficLightReports.EvalChecklistHtml, resultgraph, {}, outstr, RdfReport.escape_html)
return Response(outstr.getvalue(), content_type="text/html", vary=['accept'])
def evaluate_trafficlight_json(request):
"""
Return JSON data for trafficlight display of checklist evaluation
Request parameters as as for checklist evaluation.
"""
resultgraph = evaluate(request)
outstr = StringIO.StringIO()
RdfReport.generate_report(
TrafficLightReports.EvalChecklistJson, resultgraph, {}, outstr, RdfReport.escape_json)
return Response(outstr.getvalue(), content_type="application/json", vary=['accept'])
def testHelloWorld(self):
"""
Test just about the simplest possible report
"""
report = (
{ 'report':
{ 'output': "Hello world" }
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
self.assertEqual("Hello world", outstr.getvalue())
return
def testSimpleQuotedHtml(self):
"""
Test HTML quoting in simple report
"""
report = (
{ 'report':
{ 'query': prefixes+"SELECT * WHERE { ?s ex:quoteme ?quoteme }"
, 'output': "Hello %(quoteme_esc)s" }
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr, RdfReport.escape_html)
self.assertEqual("""Hello <"Graham">""", outstr.getvalue())
return
def testSimpleQuery(self):
"""
Test a simple query report
"""
report = (
{ 'report':
{ 'query': prefixes+"SELECT * WHERE { ?s dcterms:creator ?creator }"
, 'output': "Hello %(creator)s" }
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
self.assertEqual("Hello Graham", outstr.getvalue())
return
def testQueryResultMerge(self):
"""
Test a simple query merged with existing results
"""
report = (
{ 'report':
{ 'query': prefixes+"SELECT * WHERE { ?s dcterms:creator ?creator }"
, 'output': "Hello %(creator)s and %(name)s"
}
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {'name': 'anyone'}, outstr)
self.assertEqual("Hello Graham and anyone", outstr.getvalue())
return
def testNesting(self):
"""
Test a report with a nested sub-report
"""
report = (
{ 'report':
[ { 'query': prefixes+
"SELECT ?s ?title ?label WHERE { ?s dcterms:title ?title; rdfs:label ?label } "+
"ORDER BY DESC(?label)"
, 'output': "\nFound %(title)s:"
, 'report':
[ {'output': "\nTags for %(label)s: " }
, { 'query': prefixes+"SELECT * WHERE { ?s ex:tag ?tag } ORDER BY ?tag"
, 'output': "%(tag)s"
, 'sep': ", "
, 'alt': "none"
}
, { 'output': "." }
, { 'output': "\nFinished %(title)s." }
]
}
, { 'output': "\nFinished all." }
]
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
expected = ("\n"+
"Found Simple test data:\n"+
"Tags for simple-test-data: tag1, tag2, tag3, tag4.\n"+
"Finished Simple test data.\n"+
"Found More test data:\n"+
"Tags for more-test-data: more1, more2.\n"+
"Finished More test data.\n"+
"Finished all."+
"")
result = outstr.getvalue()
# print "\n-----"
# print result
# print "-----"
self.assertEqual(expected, result)
return
def testAlternativeMissing(self):
"""
Test an alterantive (query not matched) report with no alternative given
"""
report = (
{ 'report':
[ { 'output': "Foreword: " }
, { 'query': prefixes+"SELECT * WHERE { ?s ex:notfound ?creator }"
, 'output': "Hello %(creator)s; "
}
, { 'output': "afterword." }
]
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {'name': "anyone"}, outstr)
self.assertEqual("Foreword: afterword.", outstr.getvalue())
return
def testSequence(self):
"""
Test a sequence report
"""
report = (
{ 'report':
[ { 'output': "Foreword: " }
, { 'query': prefixes+"SELECT * WHERE { ?s dcterms:creator ?creator }"
, 'output': "Hello %(creator)s; "
}
, { 'output': "afterword." }
]
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
self.assertEqual("Foreword: Hello Graham; afterword.", outstr.getvalue())
return
def testQueryResultPreBinding(self):
"""
Test a simple query with pre-bound result value
"""
report = (
{ 'report':
{ 'query': prefixes+"SELECT * WHERE { ?s dcterms:creator ?creator; rdfs:label ?label }"
, 'output': "Hello %(creator)s"
}
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
self.assertEqual("Hello Graham", outstr.getvalue())
outstr = StringIO.StringIO()
RdfReport.generate_report(report, rdfgraph, {'label': rdflib.Literal('simple-test-data')}, outstr)
self.assertEqual("Hello Graham", outstr.getvalue())
return
def testTrafficlightHTML(self):
"""
Test report generating traffic-light HTML (per data/mockup.html)
"""
rouristr = "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
RdfReport.generate_report(TrafficLightReports.EvalChecklistHtml, rdfgraph, {}, outstr)
# Test the non-item output only. The previous test checks itemized output.
expected = (
[ '''<title>Research Object Runnable evaluation - simple-requirements</title>'''
, '''</head>'''
, '''<body>'''
, '''<div class="Container">'''
, '''<div class="header">'''
, '''A simple test RO'''
, '''</div>'''
, '''<div class="content">'''
, '''<div class="sub_header">A simple RO used for testing traffic light display.</div>'''
, '''<div class="body">'''
, '''<table>'''
, '''<thead>'''
, '''<tr class="main_result">'''
, '''<th class="trafficlight large fail should"><div/></th>'''
, '''<th colspan="2">Target <span class="target">'''
, '''<a href="%s">simple-requirements</a></span>'''%(rouristr)
, '''<span class="testresult">minimally satisfies</span> checklist for'''
, '''<span class="testpurpose">Runnable</span>.'''
# , '''<p>This Research Object @@TODO.</p>'''
, '''</th>'''
, '''</tr>'''
])
result = outstr.getvalue()
#print "\n-----"
#print result
#print "-----"
resultlines = result.split('\n')
for i in range(len(expected)):
# Skip 1st 8 lines of generated HTML:
self.assertEqual(expected[i], resultlines[i+8].strip())
return
def testRepetition(self):
"""
Test a report with a repeated match
"""
report = (
{ 'report':
[ { 'output': "Tags: " }
, { 'query': prefixes+"SELECT * WHERE { ?s dcterms:creator ?creator; ex:tag ?tag } ORDER BY ?tag"
, 'output': "%(tag)s"
, 'sep': ", "
}
, { 'output': "." }
]
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(simple_test_data)
RdfReport.generate_report(report, rdfgraph, {}, outstr)
self.assertEqual("Tags: tag1, tag2, tag3, tag4.", outstr.getvalue())
return
def testReportEvalResultClass(self):
"""
Test report of a textual status summary of a checklist match
"""
rouristr = "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
checklist = "file:///usr/workspace/wf4ever-ro-manager/Checklists/runnable-wf-trafficlight/checklist.rdf"
initvars = (
{ 'target': rdflib.URIRef(rouristr)
, 'minim': rdflib.URIRef(checklist+"#Runnable_model")
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
RdfReport.generate_report(TrafficLightReports.EvalTargetResultClass, rdfgraph, initvars, outstr)
expected = '"fail", "should"'
result = outstr.getvalue()
# print "\n-----"
# print result
# print "-----"
self.assertEqual(expected, result)
return
def testReportEvalResultLabel(self):
"""
Test report that selects a result label string
"""
rouristr = "file:///usr/workspace/wf4ever-ro-catalogue/v0.1/simple-requirements/"
checklist = "file:///usr/workspace/wf4ever-ro-manager/Checklists/runnable-wf-trafficlight/checklist.rdf"
initvars = (
{ 'target': rdflib.URIRef(rouristr)
, 'minim': rdflib.URIRef(checklist+"#Runnable_model")
})
outstr = StringIO.StringIO()
rdfgraph = rdflib.Graph()
rdfgraph.parse(trafficlight_test_data)
RdfReport.generate_report(TrafficLightReports.EvalTargetResultLabel, rdfgraph, initvars, outstr)
expected = "minimally satisfies"
result = outstr.getvalue()
# print "\n-----"
# print result
# print "-----"
self.assertEqual(expected, result)
return
def testEscapeJSON(self):
s = []
for i in range(0,128):
s.append(unichr(i))
s = "".join(s)
s_esc = RdfReport.escape_json(s)
e_esc = ( u'\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007'+
u'\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f'+
u'\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017'+
u'\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f'+
u' !\\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`'+
u'abcdefghijklmnopqrstuvwxyz{|}~\\u007f')
# print "----"
# print repr(s_esc)
# print repr(e_esc)
self.assertEqual(s_esc, e_esc)
s_loads = json.loads('"'+s_esc+'"')
self.assertEqual(s_loads, s)
return
