def test_insert_method(self):
woqlObject = WOQLQuery().insert("v:Bike_URL", "Bicycle")
woqlObjectDB = WOQLQuery().insert("v:Bike_URL", "Bicycle", "myDB")
jsonObj = {"add_triple": ['v:Bike_URL', 'rdf:type', 'scm:Bicycle']}
jsonObjDB = {
"add_quad": ['v:Bike_URL', 'rdf:type', 'scm:Bicycle', 'db:myDB']
}
assert woqlObject.json() == jsonObj
assert woqlObjectDB.json() == jsonObjDB
def test_chained_property_method(self):
woqlObject = WOQLQuery().doctype("Journey")
woqlObject = woqlObject.property("start_station",
"Station").label("Start Station")
woqlObject2 = WOQLQuery().doctype("Journey")
woqlObject2.property("start_station", "Station").label("Start Station")
assert woqlObject.json() == woqlObject2.json()
def test_when_method(self):
woqlObject = WOQLQuery().when(True, WOQLQuery().add_class("id"))
woqlObjectChain = WOQLQuery().when(True).add_class("id")
jsonObj = {
'when': [{
"true": []
}, {
'add_quad': ['scm:id', 'rdf:type', 'owl:Class', 'db:schema']
}]
}
assert woqlObject.json() == jsonObj
assert woqlObjectChain.json() == jsonObj
def test_add_property_methof(self):
woqlObject = WOQLQuery().add_property("some_property", "string")
jsonObj = {
'and': [{
'add_quad': [
'scm:some_property', 'rdf:type', 'owl:DatatypeProperty',
'db:schema'
]
}, {
'add_quad':
['scm:some_property', 'rdfs:range', 'xsd:string', 'db:schema']
}]
}
print(woqlObject.json())
assert woqlObject.json() == jsonObj
def test_cardinality_method(self):
woqlObject = WOQLQuery().add_property("P", "string").cardinality(3)
jsonObj = {
"and": [{
"add_quad":
["scm:P", "rdf:type", "owl:DatatypeProperty", "db:schema"]
}, {
"add_quad": ["scm:P", "rdfs:range", "xsd:string", "db:schema"]
}, {
"add_quad": [
"scm:P_cardinality", "rdf:type", "owl:Restriction",
"db:schema"
]
}, {
"add_quad":
["scm:P_cardinality", "owl:onProperty", "scm:P", "db:schema"]
}, {
"add_quad": [
"scm:P_cardinality", "owl:cardinality", {
"@value": 3,
"@type": "xsd:nonNegativeInteger"
}, "db:schema"
]
}]
}
assert woqlObject.json() == jsonObj
def test_cast_method(self):
woqlObject = WOQLQuery().cast("v:Duration", "xsd:integer",
"v:Duration_Cast")
jsonObj = {
"typecast": ["v:Duration", "xsd:integer", "v:Duration_Cast"]
}
assert woqlObject.json() == jsonObj
def test_chained_insert_method(self):
woqlObject = WOQLQuery().insert("v:Node_ID", "v:Type").\
label("v:Label").\
description("v:Description").\
property("prop", "v:Prop").\
property("prop", "v:Prop2").\
entity().parent("hello")
jsonObj = {
'and': [{
'add_triple': ["v:Node_ID", "rdf:type", "v:Type"]
}, {
'add_triple': ["v:Node_ID", "rdfs:label", "v:Label"]
}, {
'add_triple': ["v:Node_ID", "rdfs:comment", "v:Description"]
}, {
'add_triple': ["v:Node_ID", "scm:prop", "v:Prop"]
}, {
'add_triple': ["v:Node_ID", "scm:prop", "v:Prop2"]
}, {
'add_triple': ["v:Node_ID", "rdfs:subClassOf", "tcs:Entity"]
}, {
'add_triple': ["v:Node_ID", "rdfs:subClassOf", "scm:hello"]
}]
}
assert woqlObject.json() == jsonObj
def test_relationship_method(self):
woqlObject = WOQLQuery().node("doc:x", "add_quad").relationship()
jsonObj = {
'add_quad':
['doc:x', 'rdfs:subClassOf', 'tcs:Entity', 'db:schema']
}
assert woqlObject.json() == jsonObj
def test_woql_not_method(self):
woqlObject = WOQLQuery().woql_not(WOQLQuery().triple("a", "b", "c"))
woqlObjectChain = WOQLQuery().woql_not().triple("a", "b", "c")
jsonObj = {
'not': [{
'triple':
["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]
}]
}
print(woqlObject.json())
assert woqlObject.json() == jsonObj
assert woqlObjectChain.json() == jsonObj
def test_label_method(self):
woqlObject = WOQLQuery().node("doc:x",
"add_quad").label("my label", "en")
woqlObject2 = WOQLQuery().node("doc:x", "add_quad").label("v:label")
jsonObj = {
'add_quad': [
'doc:x', 'rdfs:label', {
'@value': 'my label',
'@language': 'en'
}, 'db:schema'
]
}
jsonObj2 = {
'add_quad': ['doc:x', 'rdfs:label', "v:label", 'db:schema']
}
assert woqlObject.json() == jsonObj
assert woqlObject2.json() == jsonObj2
def test_woql_as_method(self):
woqlObject = WOQLQuery().woql_as("Source", "Target")
woqlObject2 = WOQLQuery().woql_as("Source", "Target").woql_as(
"Source2", "Target2")
jsonObj = [{'as': [{'@value': 'Source'}, 'v:Target']}]
jsonObj2 = [{
'as': [{
'@value': 'Source'
}, 'v:Target']
}, {
'as': [{
'@value': 'Source2'
}, 'v:Target2']
}]
assert woqlObject.json() == jsonObj
assert woqlObject2.json() == jsonObj2
def test_woql_from_method(self):
woql_original = WOQLQuery().limit(10)
woqlObject = WOQLQuery().woql_from("http://dburl", woql_original)
woqlObjectChain = WOQLQuery().woql_from("http://dburl").limit(10)
jsonObj = {'from': ['http://dburl', {'limit': [10, {}]}]}
#assert woqlObject.json() == jsonObj
assert woqlObjectChain.json() == jsonObj
def test_join_method(self):
woqlObject = WOQLQuery().join(["v:A_obj", "v:B_obj"], ", ", "v:output")
jsonObj = {
'join': [['v:A_obj', 'v:B_obj'], {
'@value': ', ',
'@type': 'xsd:string'
}, 'v:output']
}
assert woqlObject.json() == jsonObj
def test_star_method(self):
woqlObject = WOQLQuery().limit(10).star()
jsonObj = {
'limit':
[10, {
"triple": ["v:Subject", "v:Predicate", "v:Object"]
}]
}
assert woqlObject.json() == jsonObj
def test_triple_method(self):
woqlObject = WOQLQuery().triple("a", "b", "c")
jsonObj = {
'triple': ["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]
}
assert woqlObject.json() == jsonObj
def test_idgen_method(self):
woqlObject = WOQLQuery().idgen("doc:Station", ["v:Start_ID"],
"v:Start_Station_URL")
jsonObj = {
"idgen":
['doc:Station', {
"list": ["v:Start_ID"]
}, 'v:Start_Station_URL']
}
assert woqlObject.json() == jsonObj
def test_comment_method(self):
woqlObject = WOQLQuery().node("doc:x",
"add_quad").comment("my comment")
jsonObj = {
"comment": [{
"@language": "en",
"@value": "my comment"
}, {}]
}
assert woqlObject.json() == jsonObj
def test_group_by_method(self):
woqlObject = WOQLQuery().group_by(["v:A", "v:B"], ["v:C"], "v:New")
jsonObj = {
"group_by": [{
"list": ['v:A', "v:B"]
}, {
"list": ["v:C"]
}, {}, "v:New"]
}
assert woqlObject.json() == jsonObj
def test_add_quad_method(self):
woqlObject = WOQLQuery().add_quad("a", "b", "c", "d")
jsonObj = {
'add_quad':
["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}, "db:d"]
}
assert woqlObject.json() == jsonObj
def test_re_method(self):
woqlObject = WOQLQuery().re(".*", "v:string", "v:formated")
jsonObj = {
're': [{
'@value': '.*',
'@type': 'xsd:string'
}, 'v:string', {
'list': ["v:formated"]
}]
}
assert woqlObject.json() == jsonObj
def test_again_add_class_method(self):
woqlObject = WOQLQuery().add_class("NewClass").description(
"A new class object.").entity()
jsonObj = {
"and": [{
"add_quad":
['scm:NewClass', 'rdf:type', "owl:Class", 'db:schema']
}, {
"add_quad": [
'scm:NewClass', 'rdfs:comment', {
'@value': "A new class object.",
'@language': 'en'
}, 'db:schema'
]
}, {
"add_quad":
['scm:NewClass', 'rdfs:subClassOf', "tcs:Entity", 'db:schema']
}]
}
print(woqlObject.json())
assert woqlObject.json() == jsonObj
def test_delete_property_method(self):
woqlObject = WOQLQuery().delete_property("some_property", "string")
jsonObj = {
'and': [{
'delete_quad':
['scm:some_property', 'v:All', 'v:Al2', 'xsd:string']
}, {
'delete_quad':
['v:Al3', 'v:Al4', 'scm:some_property', 'xsd:string']
}]
}
assert woqlObject.json() == jsonObj
def test_split_method(self):
woqlObject = WOQLQuery().split("A, B, C", ", ", "v:list_obj")
jsonObj = {
'split': [{
'@value': 'A, B, C',
'@type': 'xsd:string'
}, {
"@type": "xsd:string",
"@value": ", "
}, "v:list_obj"]
}
assert woqlObject.json() == jsonObj
def test_property_method(self):
woqlObject = WOQLQuery().node("doc:x",
"add_quad").property("myprop", "value")
jsonObj = {
'add_quad': [
'doc:x', 'scm:myprop', {
'@value': 'value',
'@language': 'en'
}, 'db:schema'
]
}
assert woqlObject.json() == jsonObj
def test_eq_method(self):
woqlObject = WOQLQuery().eq("a", "b")
jsonObj = {
'eq': [{
"@language": "en",
"@value": "a"
}, {
"@language": "en",
"@value": "b"
}]
}
assert woqlObject.json() == jsonObj
def test_delete_class_method(self):
woqlObject = WOQLQuery().delete_class("id")
jsonObj = {
'and': [{
'delete_quad': ['scm:id', 'v:All', 'v:Al2', 'db:schema']
}, {
'opt': [{
'delete_quad': ['v:Al3', 'v:Al4', 'scm:id', 'db:schema']
}]
}]
}
assert woqlObject.json() == jsonObj
def test_concat_method(self):
woqlObject = WOQLQuery().concat("v:Duration yo v:Duration_Cast", "x")
jsonObj = {
"concat": [{
"list": [
"v:Duration", {
"@value": " yo ",
"@type": "xsd:string"
}, "v:Duration_Cast"
]
}, "v:x"]
}
assert woqlObject.json() == jsonObj
def test_doctype_method(self):
woqlObject = WOQLQuery().doctype("Station")
jsonObj = {
"and": [{
"add_quad":
["scm:Station", "rdf:type", "owl:Class", "db:schema"]
}, {
"add_quad": [
"scm:Station", "rdfs:subClassOf", "tcs:Document",
"db:schema"
]
}]
}
assert woqlObject.json() == jsonObj
def test_select_method(self):
woqlObject = WOQLQuery().select("V1",
WOQLQuery().triple("a", "b", "c"))
woqlObjectMultiple = WOQLQuery().select(
"V1", "V2",
WOQLQuery().triple("a", "b", "c"))
woqlObjectChain = WOQLQuery().select("V1").triple("a", "b", "c")
woqlObjectChainMultiple = WOQLQuery().select("V1", "V2").triple(
"a", "b", "c")
jsonObj = {
'select': [
'V1', {
'triple':
["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]
}
]
}
jsonObjMultiple = {
'select': [
'V1', 'V2', {
'triple':
["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]
}
]
}
assert woqlObject.json() == jsonObj
assert woqlObjectChain.json() == jsonObj
assert woqlObjectMultiple.json() == jsonObjMultiple
assert woqlObjectChainMultiple.json() == jsonObjMultiple
def test_delete_method(self):
woqlObject = WOQLQuery().delete(
{'triple': ["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]})
jsonObj = {
'delete': [{
'triple':
["doc:a", "scm:b", {
"@language": "en",
"@value": "c"
}]
}]
}
assert woqlObject.json() == jsonObj
