def testAdmin(self):
headers, body = getRequest(self.portNumber, "/login", parse='lxml')
cookie = parseHeaders(headers)['Set-Cookie']
headers, body = postRequest(self.portNumber, '/login.action', urlencode(dict(username="******", password="******", formUrl='/login')), parse='lxml', additionalHeaders={'Cookie': cookie})
self.assertTrue('302' in headers, headers)
self.assertEquals('/', parseHeaders(headers)['Location'])
headers, body = getRequest(self.portNumber, "/index", parse='lxml', additionalHeaders={'Cookie': cookie})
self.assertEquals(['Logged in as: admin | ', ' | ', ' | ', ' | '], xpath(body, '//div[@id="loginbar"]/p/text()'))
headers, body = getRequest(self.portNumber, "/changepassword", parse='lxml', additionalHeaders={'Cookie': cookie})
self.assertEquals(['admin'], xpath(body, '/html/body/div[@id="content"]/div[@id="login"]/form/input[@type="hidden" and @name="username"]/@value'), tostring(body))
self.assertEquals(['oldPassword', 'newPassword', 'retypedPassword'], xpath(body, '/html/body/div[@id="content"]/div[@id="login"]/form/dl/dd/input[@type="password"]/@name'), tostring(body))
self.assertEquals(['/login.action/changepassword'], xpath(body, '/html/body/div[@id="content"]/div[@id="login"]/form/@action'))
headers, body = postRequest(self.portNumber, '/login.action/changepassword', urlencode(dict(username="******", oldPassword="******", newPassword="******", retypedPassword="******", formUrl="/changepassword")), parse='lxml', additionalHeaders={'Cookie': cookie})
self.assertTrue('302' in headers, headers)
self.assertEquals('/', parseHeaders(headers)['Location'])
# Test new password
headers, body = getRequest(self.portNumber, "/login", parse='lxml')
newcookie = parseHeaders(headers)['Set-Cookie']
headers, body = postRequest(self.portNumber, '/login.action', urlencode(dict(username="******", password="******", formUrl='/login')), parse='lxml', additionalHeaders={'Cookie': newcookie})
self.assertTrue('302' in headers, headers)
self.assertEquals('/login', parseHeaders(headers)['Location'])
headers, body = postRequest(self.portNumber, '/login.action', urlencode(dict(username="******", password="******", formUrl='/login')), parse='lxml', additionalHeaders={'Cookie': newcookie})
self.assertTrue('302' in headers, headers)
self.assertEquals('/', parseHeaders(headers)['Location'])
def testFacets(self):
data = JsonList(
[
{"type": "TextField", "name": "fieldname", "value": "value"},
{"type": "FacetField", "name": "fieldname", "path": ["value"]},
]
).dumps()
header, body = postRequest(self.luceneServerPort, self._path + "/update/?identifier=id1", data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(
self.luceneServerPort,
self._path + "/query/",
data=JsonDict(
query=dict(type="MatchAllDocsQuery"), facets=[{"fieldname": "fieldname", "maxTerms": 10}]
).dumps(),
parse=False,
)
self.assertTrue("200 OK" in header.upper(), header)
jsonResponse = loads(body)
self.assertEqual(1, jsonResponse["total"])
self.assertEqual(
[{"path": [], "fieldname": "fieldname", "terms": [{"count": 1, "term": "value"}]}],
jsonResponse["drilldownData"],
)
self.assertTrue("facetTime" in jsonResponse["times"])
def testAddAndQueryDocument(self):
data = JsonList([{"type": "TextField", "name": "fieldname", "value": "value"}]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + "/update/?identifier=id1", data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(
self.luceneServerPort,
self._path + "/query/",
data=JsonDict(query=dict(type="MatchAllDocsQuery")).dumps(),
parse=False,
)
self.assertTrue("200 OK" in header.upper(), header)
response = loads(body)
self.assertEqual(1, response["total"])
self.assertEqual([{"id": "id1", "score": 1.0}], response["hits"])
header, body = postRequest(
self.luceneServerPort,
self._path + "/query/",
data=JsonDict(query=dict(type="TermQuery", term=dict(field="fieldname", value="value"))).dumps(),
parse=False,
)
self.assertTrue("200 OK" in header.upper(), header)
response = loads(body)
self.assertEqual(1, response["total"])
self.assertTrue("queryTime" in response)
self.assertTrue("times" in response)
self.assertEqual([{"id": "id1", "score": 0.28768208622932434}], response["hits"])
def testAddDelete(self):
postRequest(self.httpPort, '/update_main', ADD_RECORD, parse=False)
sleep(1.1)
self.assertEquals(1, self.numberOfRecords(query='__id__ exact "testrecord:1"'))
postRequest(self.httpPort, '/update_main', DELETE_RECORD, parse=False)
sleep(1.1)
self.assertEquals(0, self.numberOfRecords(query='__id__ exact "testrecord:1"'))
def testNumerate(self):
header, body = postRequest(self.luceneServerPort, "/numerate/", data="id0", parse=False)
self.assertTrue("200 OK" in header.upper(), header)
header, body2 = postRequest(self.luceneServerPort, "/numerate/", data="id0", parse=False)
self.assertTrue("200 OK" in header.upper(), header)
self.assertEquals(body2, body)
header, body3 = postRequest(self.luceneServerPort, "/numerate/", data="id1", parse=False)
self.assertNotEquals(body3, body)
def testNumerate(self):
header, body = postRequest(self.luceneServerPort, '/numerate/', data='id0', parse=False)
self.assertTrue("200 OK" in header.upper(), header)
header, body2 = postRequest(self.luceneServerPort, '/numerate/', data='id0', parse=False)
self.assertTrue("200 OK" in header.upper(), header)
self.assertEquals(body2, body)
header, body3 = postRequest(self.luceneServerPort, '/numerate/', data='id1', parse=False)
self.assertNotEquals(body3, body)
def testNumerate(self):
header, body = postRequest(self.numerateServerPort, '/numerate', data='id0', parse=False)
self.assertTrue("200 OK" in header.upper(), header)
header, body2 = postRequest(self.numerateServerPort, '/numerate', data='id0', parse=False)
self.assertTrue("200 OK" in header.upper(), header)
self.assertEquals(body2, body)
header, body3 = postRequest(self.numerateServerPort, '/numerate', data='id1', parse=False)
self.assertNotEquals(body3, body)
def testAddDelete(self):
postRequest(self.httpPort, '/update_main', ADD_RECORD, parse=False)
sleep(1.1)
try:
self.assertEquals(1, self.numberOfRecords(query='__id__ exact "testrecord:1"'))
finally:
postRequest(self.httpPort, '/update_main', DELETE_RECORD, parse=False)
sleep(1.1)
self.assertEquals(0, self.numberOfRecords(query='__id__ exact "testrecord:1"'))
def testAddUnicodeChars(self):
postRequest(self.graphdbPort, "/add?identifier=uri:unicode:chars", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdf:Description rdf:about="uri:unicode:chars">
<rdfs:label>Ittzés, Gergely</rdfs:label>
</rdf:Description>
</rdf:RDF>""", parse=False)
self.commit()
json = self.query('SELECT ?label WHERE {<uri:unicode:chars> ?x ?label}')
self.assertEquals(1, len(json['results']['bindings']))
self.assertEqual('Ittzés, Gergely', json['results']['bindings'][0]['label']['value'])
def testAddNulls(self):
data = """{
"key": 1,
"values": ["harry"], "types": [null], "creators": [null]
}"""
try:
header, body = postRequest(self.suggestionServerPort, '/add?identifier=id1', data=data, parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
finally:
postRequest(self.suggestionServerPort, '/delete?identifier=id1', data=None, parse=False)
postRequest(self.suggestionServerPort, '/commit', data=None, parse=False)
def testAddNulls(self):
data = """{
"key": 1,
"values": ["harry"], "types": [null], "creators": [null]
}"""
try:
header, body = postRequest(self.suggestionServerPort, '/add?identifier=id1', data=data, parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
finally:
postRequest(self.suggestionServerPort, '/delete?identifier=id1', data=None, parse=False)
postRequest(self.suggestionServerPort, '/commit', data=None, parse=False)
def testSuggestionRequest(self):
data = JsonList([
{"type": "TextField", "name": "field", "value": "value"},
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', parse=False, data=JsonDict(query=dict(type="MatchAllDocsQuery"), suggestionRequest=dict(field="field", count=1, suggests=['valeu'])).dumps())
jsonResponse = loads(body)
self.assertEqual({'valeu': ['value']}, jsonResponse["suggestions"])
self.assertTrue("suggestionTime" in jsonResponse["times"])
def testPrefixSearch(self):
data = JsonList([
{"type": "TextField", "name": "prefixField", "value": "value0"},
{"type": "TextField", "name": "prefixField", "value": "value1"},
{"type": "TextField", "name": "prefixField", "value": "value2"},
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/prefixSearch/?fieldname=prefixField&prefix=val', parse=False)
self.assertEqual([['value0', 1], ['value1', 1], ['value2', 1]], loads(body))
def testSuggestionRequest(self):
data = JsonList([
{"type": "TextField", "name": "field", "value": "value"},
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', parse=False, data=JsonDict(query=dict(type="MatchAllDocsQuery"), suggestionRequest=dict(field="field", count=1, suggests=['valeu'])).dumps())
jsonResponse = loads(body)
self.assertEqual({'valeu': ['value']}, jsonResponse["suggestions"])
self.assertTrue("suggestionTime" in jsonResponse["times"])
def testPrefixSearch(self):
data = JsonList([
{"type": "TextField", "name": "prefixField", "value": "value0"},
{"type": "TextField", "name": "prefixField", "value": "value1"},
{"type": "TextField", "name": "prefixField", "value": "value2"},
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/prefixSearch/?fieldname=prefixField&prefix=val', parse=False)
self.assertEqual([['value0', 1], ['value1', 1], ['value2', 1]], loads(body))
def testIndexingState(self):
header, body = getRequest(self.suggestionServerPort, '/indexingState', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertEqual("{}", body)
postRequest(self.suggestionServerPort, '/createSuggestionNGramIndex', data=None, parse=False)
header, body = getRequest(self.suggestionServerPort, '/indexingState', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertNotEqual("{}", body)
self.assertTrue("started" in loads(body), body)
self.assertTrue("count" in loads(body), body)
def testKillTripleStoreSavesState(self):
postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:testKillTripleStoreSavesState</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
json = self.query('SELECT ?x WHERE {?x ?y "uri:testKillTripleStoreSavesState"}')
self.assertEquals(1, len(json['results']['bindings']))
self.restartSesameServer()
json = self.query('SELECT ?x WHERE {?x ?y "uri:testKillTripleStoreSavesState"}')
self.assertEquals(1, len(json['results']['bindings']))
def testIndexingState(self):
header, body = getRequest(self.suggestionServerPort, '/indexingState', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertEqual("{}", body)
postRequest(self.suggestionServerPort, '/createSuggestionNGramIndex', data=None, parse=False)
header, body = getRequest(self.suggestionServerPort, '/indexingState', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertNotEqual("{}", body)
self.assertTrue("started" in loads(body), body)
self.assertTrue("count" in loads(body), body)
def testFacets(self):
data = JsonList([
{"type": "TextField", "name": "fieldname", "value": "value"},
{"type": "FacetField", "name": "fieldname", "path": ["value"]}
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', data=JsonDict(query=dict(type="MatchAllDocsQuery"), facets=[{"fieldname": "fieldname", "maxTerms": 10}]).dumps(), parse=False)
self.assertTrue("200 OK" in header.upper(), header)
jsonResponse = loads(body)
self.assertEqual(1, jsonResponse['total'])
self.assertEqual([{'path': [], 'fieldname': 'fieldname', 'terms': [{'count': 1, 'term': 'value'}]}], jsonResponse['drilldownData'])
self.assertTrue("facetTime" in jsonResponse["times"])
def testFacets(self):
data = JsonList([
{"type": "TextField", "name": "fieldname", "value": "value"},
{"type": "FacetField", "name": "fieldname", "path": ["value"]}
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', data=JsonDict(query=dict(type="MatchAllDocsQuery"), facets=[{"fieldname": "fieldname", "maxTerms": 10}]).dumps(), parse=False)
self.assertTrue("200 OK" in header.upper(), header)
jsonResponse = loads(body)
self.assertEqual(1, jsonResponse['total'])
self.assertEqual([{'path': [], 'fieldname': 'fieldname', 'terms': [{'count': 1, 'term': 'value'}]}], jsonResponse['drilldownData'])
self.assertTrue("facetTime" in jsonResponse["times"])
def testAddAndRemoveTriple(self):
json = self.query('SELECT ?obj WHERE { <uri:subject> <uri:predicate> ?obj }')
self.assertEquals(0, len(json['results']['bindings']))
header, body = postRequest(self.sesamePort, "/addTriple", "uri:subject|uri:predicate|uri:object", parse=False)
self.assertTrue("200" in header, header)
json = self.query('SELECT ?obj WHERE { <uri:subject> <uri:predicate> ?obj }')
self.assertEquals(1, len(json['results']['bindings']))
header, body = postRequest(self.sesamePort, "/removeTriple", "uri:subject|uri:predicate|uri:object", parse=False)
self.assertTrue("200" in header, header)
json = self.query('SELECT ?obj WHERE { <uri:subject> <uri:predicate> ?obj }')
self.assertEquals(0, len(json['results']['bindings']))
def testDeleteRecord(self):
postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:testDelete</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDelete"}')
self.assertEquals(1, len(json['results']['bindings']))
postRequest(self.sesamePort, "/update?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:testDeleteUpdated</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDelete"}')
self.assertEquals(0, len(json['results']['bindings']))
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDeleteUpdated"}')
self.assertEquals(1, len(json['results']['bindings']))
postRequest(self.sesamePort, "/delete?identifier=uri:record", "", parse=False)
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDelete"}')
self.assertEquals(0, len(json['results']['bindings']))
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDeleteUpdated"}')
self.assertEquals(0, len(json['results']['bindings']))
postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:testDelete</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
json = self.query('SELECT ?x WHERE {?x ?y "uri:testDelete"}')
self.assertEquals(1, len(json['results']['bindings']))
def testInfo(self):
header, body = postRequest(self.numerateServerPort,
'/numerate',
data='id0',
parse=False)
header, body = postRequest(self.numerateServerPort,
'/numerate',
data='id1',
parse=False)
header, body = getRequest(self.numerateServerPort,
'/info',
parse=False)
self.assertTrue("200 OK" in header.upper(), header)
self.assertEqual('{"total": 2}', body)
def _createDatabase(self):
if self.fastMode:
print "Reusing database in", self.integrationTempdir
return
start = time()
print "Creating database in", self.integrationTempdir
try:
self._runExecutable(join(self.testdataDir, 'upload.py'), processName='IntegrationUpload', cwd=self.testdataDir, port=self.httpPort, redirect=False, timeoutInSeconds=60)
sleepWheel(5)
postRequest(self.luceneServerPort, "/default/settings/", data=JsonDict(commitCount=1).dumps(), parse=False)
print "Finished creating database in %s seconds" % (time() - start)
except Exception:
print 'Error received while creating database for', self.stateName
print_exc()
exit(1)
def testAcceptHeaders(self):
postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:test:acceptHeaders</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
request = Request('http://localhost:%s/query?%s' % (self.sesamePort, urlencode({'query': 'SELECT ?x WHERE {?x ?y "uri:test:acceptHeaders"}'})), headers={"Accept" : "application/xml"})
contents = urlopen(request).read()
self.assertTrue("""<variable name='x'/>""" in contents, contents)
headers, body = getRequest(self.sesamePort, "/query", arguments={'query': 'SELECT ?x WHERE {?x ?y "uri:test:acceptHeaders"}'}, additionalHeaders={"Accept" : "image/jpg"}, parse=False)
self.assertEquals(["HTTP/1.1 406 Not Acceptable", "Content-type: text/plain"], headers.split('\r\n')[:2])
self.assertTrue("""Supported formats SELECT query:""" in body, body)
def testPostAnnotation(self):
identifier = "urn:uuid:%s" % uuid4()
annotationBody = """<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:oa="http://www.w3.org/ns/openannotation/core/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:foaf="http://xmlns.com/foaf/0.1/">
<rdf:Description rdf:about="%(identifier)s">
<rdf:type rdf:resource="http://www.w3.org/ns/openannotation/core/Annotation"/>
<oa:hasBody rdf:resource="ex:HDFI-2"/>
<oa:hasTarget rdf:resource="ex:HDFV2"/>
<dc:title>An Annotions submitted through a form</dc:title>
<oa:annotatedBy rdf:resource="ex:AnotherUser"/>
<oa:annotatedAt>2000-02-01 12:34:56</oa:annotatedAt>
</rdf:Description>
</rdf:RDF>""" % locals()
self.assertQuery('RDF.Annotation.title = "An Annotions submitted through a form"', 0)
header, body = postRequest(self.portNumber, '/uploadform', urlencode(dict(annotation=annotationBody, apiKey=self.apiKeyForPostUser)), parse='lxml')
self.assertQuery('RDF.Annotation.title = "An Annotions submitted through a form"', 1)
textarea = xpath(body, '//textarea[@name="annotation"]/text()')
apiKey = xpath(body, '//input[@name="apiKey"]/@value')[0]
message = xpath(body, '//p[@class="success"]/text()')[0]
self.assertEquals(self.apiKeyForPostUser, apiKey)
self.assertEquals([], textarea)
self.assertTrue('success' in message, message)
def testAcceptHeaders(self):
postRequest(self.graphdbPort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:test:acceptHeaders</rdf:type>
</rdf:Description>
</rdf:RDF>""", parse=False)
self.commit()
request = Request('http://localhost:%s/query?%s' % (self.graphdbPort, urlencode({'query': 'SELECT ?x WHERE {?x ?y "uri:test:acceptHeaders"}'})), headers={"Accept" : "application/xml"})
contents = urlopen(request).read()
self.assertTrue("""<variable name='x'/>""" in contents, contents)
headers, body = getRequest(self.graphdbPort, "/query", arguments={'query': 'SELECT ?x WHERE {?x ?y "uri:test:acceptHeaders"}'}, additionalHeaders={"Accept" : "image/jpg"}, parse=False)
headers = headers.split('\r\n')
self.assertTrue("HTTP/1.1 200 OK" in headers, headers)
self.assertTrue("Content-Type: application/sparql-results+json; charset=UTF-8" in headers, headers)
def testAddByNewUser(self):
headers, body = postRequest(
self.portNumber, "/login.action", urlencode(dict(username="******", password="******"))
)
cookie = parseHeaders(headers)["Set-Cookie"]
headers, body = postRequest(
self.portNumber,
"/apikey.action/create",
urlencode(dict(formUrl="/user_management", username="******")),
additionalHeaders=dict(cookie=cookie),
)
headers, body = getRequest(self.portNumber, "/user_management", additionalHeaders={"Cookie": cookie})
apiKey = self.apiKeyForUser(body, "another")
self.assertTrue(len(apiKey) > 0, apiKey)
def setUp(self):
IntegrationTestCase.setUp(self)
self._path = "/default"
header, body = postRequest(
self.luceneServerPort, self._path + "/settings/", data=JsonDict(commitCount=1).dumps()
)
self.assertTrue("200 OK" in header.upper(), header)
def _createDatabase(self):
if self.fastMode:
print "Reusing database in", self.integrationTempdir
return
start = time()
print "Creating database in", self.integrationTempdir
try:
for f in listdir(self.testdataDir):
postRequest(self.gatewayPort, '/update', data=open(join(self.testdataDir, f)).read(), parse=False)
sleepWheel(2)
print "Finished creating database in %s seconds" % (time() - start)
except Exception:
print 'Error received while creating database for', self.stateName
print_exc()
sleep(1)
exit(1)
def doAdd(i=i):
header, body = postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type>uri:testSecond%s</rdf:type>
</rdf:Description>
</rdf:RDF>""" % i, parse=False)
responses.append((header, body))
def _setupUsers(self):
headers, body = postRequest(self.portNumber, '/login.action', urlencode(dict(username="******", password="******")), parse=False)
cookie = parseHeaders(headers)['Set-Cookie']
headers, body = postRequest(self.portNumber, '/apikey.action/create', urlencode(dict(formUrl='/user_management', username='******')), parse=False, additionalHeaders=dict(cookie=cookie))
headers, body = postRequest(self.portNumber, '/apikey.action/create', urlencode(dict(formUrl='/user_management', username='******')), parse=False, additionalHeaders=dict(cookie=cookie))
headers, body = postRequest(self.portNumber, '/apikey.action/create', urlencode(dict(formUrl='/user_management', username='******')), parse=False, additionalHeaders=dict(cookie=cookie))
headers, body = getRequest(self.portNumber, '/user_management', additionalHeaders={'Cookie': cookie})
self.apiKeyForTestUser = xpath(body, '//div[@id="apiKeys"]/table/tr[form/td[text()="testUser"]]/form/td[@class="apiKey"]/text()')[0]
assert self.apiKeyForTestUser != None
self.apiKeyForAnotherTestUser = xpath(body, '//div[@id="apiKeys"]/table/tr[form/td[text()="anotherTestUser"]]/form/td[@class="apiKey"]/text()')[0]
assert self.apiKeyForAnotherTestUser != None
self.apiKeyForPostUser = xpath(body, '//div[@id="apiKeys"]/table/tr[form/td[text()="postUser"]]/form/td[@class="apiKey"]/text()')[0]
assert self.apiKeyForPostUser != None
def _uploadUpdateRequest(updateRequest, uploadPath, uploadPort):
XML(updateRequest)
header, body = postRequest(uploadPort, uploadPath, updateRequest)
if '200 OK' not in header:
print 'No 200 OK response, but:\n', header
exit(123)
if "srw:diagnostics" in tostring(body):
print tostring(body)
exit(1234)
def _uploadUpdateRequest(updateRequest, uploadPath, uploadPort):
XML(updateRequest)
header, body = postRequest(uploadPort, uploadPath, updateRequest)
if '200 OK' not in header:
print 'No 200 OK response, but:\n', header
exit(123)
if "srw:diagnostics" in tostring(body):
print tostring(body)
exit(1234)
def testRegisterKeySet(self):
keySet = FixedBitSet(3)
keySet.set(2)
header, body = postRequest(self.suggestionServerPort,
'/registerFilterKeySet?name=test',
data=fixedBitSetAsBytes(keySet),
parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
def testKillTripleStoreRecovers(self):
postRequest(self.graphdbPort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description>
<rdf:type rdf:resource="uri:testKillTripleStoreRecovers"/>
</rdf:Description>
</rdf:RDF>""", parse=False)
postRequest(self.graphdbPort, "/addTriple", "uri:subject|http://www.w3.org/1999/02/22-rdf-syntax-ns#type|uri:testKillTripleStoreRecovers")
self.commit()
json = self.query('SELECT ?x WHERE {?x ?y <uri:testKillTripleStoreRecovers>}')
self.assertEquals(2, len(json['results']['bindings']))
kill(self.pids['graphdb'], SIGTERM)
waitpid(self.pids['graphdb'], WNOHANG)
sleep(1)
self.startGraphDBServer()
json = self.query('SELECT ?x WHERE {?x ?y <uri:testKillTripleStoreRecovers>}')
self.assertEquals(2, len(json['results']['bindings']))
def _uploadSolrData(self, dataDir):
for docFile in sorted(glob(join(dataDir, '*.doc'))):
# print docFile
identifier = basename(docFile).rsplit('.',1)[0]
addKwargs=dict(
identifier=identifier,
data=open(docFile).read(),
)
header, body = postRequest(port=self.solrClientPort, path='/add', data=dumps(addKwargs), parse=False)
assert '' == body, 'Something bad happened:\n' + body
def testDescribeQuery(self):
postRequest(self.sesamePort, "/add?identifier=uri:record", """<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="uri:test:describe">
<rdf:value>DESCRIBE</rdf:value>
</rdf:Description>
</rdf:RDF>""", parse=False)
headers, body = getRequest(self.sesamePort, "/query", arguments={'query': 'DESCRIBE <uri:test:describe>'}, additionalHeaders={"Accept" : "application/rdf+xml"}, parse=False)
self.assertTrue("Content-type: application/rdf+xml" in headers, headers)
self.assertXmlEquals("""<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:sesame="http://www.openrdf.org/schema/sesame#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:fn="http://www.w3.org/2005/xpath-functions#">
<rdf:Description rdf:about="uri:test:describe">
<rdf:value>DESCRIBE</rdf:value>
</rdf:Description></rdf:RDF>""", body)
def testSuggest(self):
data = """{
"value": "ha",
"trigram": false,
"filters": [],
"keySetName": null
}"""
header, body = postRequest(self.suggestionServerPort, '/suggest', data=data, parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertEqual("[]", body)
def testAddAndQueryDocument(self):
data = JsonList([
{"type": "TextField", "name": "fieldname", "value": "value"}
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=id1', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', data=JsonDict(query=dict(type="MatchAllDocsQuery")).dumps(), parse=False)
self.assertTrue("200 OK" in header.upper(), header)
response = loads(body)
self.assertEqual(1, response['total'])
self.assertEqual([{'id': 'id1', 'score': 1.0}], response['hits'])
header, body = postRequest(self.luceneServerPort, self._path + '/query/', data=JsonDict(query=dict(type="TermQuery", term=dict(field="fieldname", value="value"))).dumps(), parse=False)
self.assertTrue("200 OK" in header.upper(), header)
response = loads(body)
self.assertEqual(1, response['total'])
self.assertTrue("queryTime" in response)
self.assertTrue("times" in response)
self.assertEqual([{'id': 'id1', 'score': 0.28768208622932434}], response['hits'])
def testSuggest(self):
data = """{
"value": "ha",
"trigram": false,
"filters": [],
"keySetName": null
}"""
header, body = postRequest(self.suggestionServerPort, '/suggest', data=data, parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertTrue("Content-Type: application/json" in header, header)
self.assertEqual("[]", body)
def _createDatabase(self):
if self.fastMode:
print "Reusing database in", self.integrationTempdir
return
start = time()
print "Creating database in", self.integrationTempdir
try:
for f in sorted(glob(self.testdataDir + '/*.updateRequest')):
# for f in listdir(self.testdataDir):
print "Uploading file:", f
postRequest(self.gatewayPort,
'/update',
data=open(join(self.testdataDir, f)).read(),
parse=False)
sleepWheel(2)
print "Finished creating database in %s seconds" % (time() - start)
except Exception:
print 'Error received while creating database for', self.stateName
print_exc()
sleep(1)
exit(1)
def testKillTripleStoreWhileDoingQuery(self):
def doQueries():
for i in range(1000):
self.query('SELECT ?x WHERE { ?x ?y ?z }')
t = Thread(target=doQueries)
t.start()
for i in range(100):
header, body = postRequest(self.sesamePort, "/addTriple", "uri:subject%s|uri:predicate%s|uri:object%s" % (i, i, i), parse=False)
self.stopSesameServer()
t.join()
self.assertTrue('Shutdown completed.' in open(join(self.integrationTempdir, 'stdouterr-sesame.log')).read())
self.startSesameServer()
def testExportKeys(self):
composedQuery = ComposedQuery('main')
composedQuery.setCoreQuery('main', query=dict(type="MatchAllDocsQuery"))
header, body = postRequest(self.luceneServerPort, '/exportkeys/?exportKey=__key__.field', data=JsonDict(composedQuery.asDict()).dumps(), parse=False)
self.assertTrue("200 OK" in header.upper(), header + 2 * CRLF + body)
bitSet = readFixedBitSet(body)
for i in xrange(0, 102):
isSet = bitSet.get(i)
if 2 < i < 101:
self.assertTrue(isSet, i)
else:
self.assertFalse(isSet, i)
def _uploadSolrData(self, dataDir):
for docFile in sorted(glob(join(dataDir, '*.doc'))):
# print docFile
identifier = basename(docFile).rsplit('.', 1)[0]
addKwargs = dict(
identifier=identifier,
data=open(docFile).read(),
)
header, body = postRequest(port=self.solrClientPort,
path='/add',
data=dumps(addKwargs),
parse=False)
assert '' == body, 'Something bad happened:\n' + body
def testAddQueryDelete(self):
addKwargs=dict(
identifier='record:testAddQueryDelete',
data='''<doc>
<field name="__id__">record:testAddQueryDelete</field>
<field name="title">The title</field>
</doc>''',
)
header, body = postRequest(port=self.solrClientPort, path='/add', data=dumps(addKwargs), parse=False)
self.assertEquals('', body)
sleep(2)
response = self.solrRequest(luceneQueryString='__id__:record\:testAddQueryDelete')
self.assertEquals(1, response['total'])
self.assertEquals(['record:testAddQueryDelete'], response['hits'])
header, body = postRequest(port=self.solrClientPort, path='/delete', data=dumps(dict(identifier='record:testAddQueryDelete')), parse=False)
self.assertEquals('', body)
sleep(2)
response = self.solrRequest(luceneQueryString='__id__:record\:testAddQueryDelete')
self.assertEquals(0, response['total'])
def _createDatabase(self):
if self.fastMode:
print "Reusing database in", self.integrationTempdir
return
start = time()
print "Creating database in", self.integrationTempdir
try:
self._runExecutable(join(self.testdataDir, 'upload.py'),
processName='IntegrationUpload',
cwd=self.testdataDir,
port=self.httpPort,
redirect=False,
timeoutInSeconds=60)
sleepWheel(5)
postRequest(self.luceneServerPort,
"/default/settings/",
data=JsonDict(commitCount=1).dumps(),
parse=False)
print "Finished creating database in %s seconds" % (time() - start)
except Exception:
print 'Error received while creating database for', self.stateName
print_exc()
exit(1)
def testAddCreateAndSuggest(self):
data = """{
"key": 1,
"values": ["harry"], "types": ["uri:book"], "creators": ["rowling"]
}"""
try:
postRequest(self.suggestionServerPort,
'/add?identifier=id1',
data=data,
parse=False)
postRequest(self.suggestionServerPort,
'/createSuggestionNGramIndex?wait=True',
data=None,
parse=False)
data = """{
"value": "ha",
"trigram": false,
"filters": [],
"keySetName": null
}"""
header, body = postRequest(self.suggestionServerPort,
'/suggest',
data=data,
parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertEqual([
{
"suggestion": "harry",
"type": "uri:book",
"creator": 'rowling',
"score": 0.5753641724586487
},
], loads(body))
finally:
postRequest(self.suggestionServerPort,
'/delete?identifier=id1',
data=None,
parse=False)
postRequest(self.suggestionServerPort,
'/commit',
data=None,
parse=False)
def testPostRequestWithCookie(self):
mockSocket = self.createMockSocket([b'HTTP/1.1 200 Ok\r\nMy-Header: this\r\n\r\ndata'])
headers, result = postRequest(12345,
'/some/path',
data=b'lekker, lekker',
cookie='gevulde-koek',
timeOutInSeconds=200,
_createSocket=mockSocket.createSocket,
parse=False)
self.assertEqual(b'data', result)
self.assertEqual({"StatusCode":'200', 'Headers':{"My-Header": 'this'}}, headers)
self.assertEqual(['createSocket', 'send', 'recv', 'recv', 'close'], mockSocket.calledMethodNames())
create, send = mockSocket.calledMethods[:2]
self.assertEqual((12345, 200), create.args)
self.assertEqual('''POST /some/path HTTP/1.0
Content-Length: 14
Content-Type: text/xml; charset="utf-8"
Cookie: gevulde-koek
lekker, lekker''', send.args[0].decode().replace('\r\n','\n'))
def testAdd(self):
data = """{
"key": 1,
"values": ["harry"], "types": ["uri:book"], "creators": ["rowling"]
}"""
try:
header, body = postRequest(self.suggestionServerPort, '/add?identifier=id1', data=data, parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
header, body = postRequest(self.suggestionServerPort, '/commit', data=None, parse=False)
header, body = getRequest(self.suggestionServerPort, '/totalRecords', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertEqual("1", body)
header, body = getRequest(self.suggestionServerPort, '/totalSuggestions', parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
self.assertEqual("0", body)
finally:
postRequest(self.suggestionServerPort, '/delete?identifier=id1', data=None, parse=False)
postRequest(self.suggestionServerPort, '/commit', data=None, parse=False)
def testCommit(self):
header, body = postRequest(self.luceneServerPort, self._path + '/settings/', data=JsonDict(commitCount=10).dumps())
self.assertTrue("200 OK" in header.upper(), header)
try:
data = JsonList([
{"type": "TextField", "name": "fieldname", "value": "value"}
]).dumps()
header, body = postRequest(self.luceneServerPort, self._path + '/update/?identifier=idCommit', data=data)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', parse=False, data=JsonDict(query=dict(type="TermQuery", term=dict(field="__id__", value="idCommit"))).dumps())
response = loads(body)
self.assertEqual(0, response['total'])
header, body = postRequest(self.luceneServerPort, '/commit/', parse=False)
self.assertTrue("200 OK" in header.upper(), header)
header, body = postRequest(self.luceneServerPort, self._path + '/query/', parse=False, data=JsonDict(query=dict(type="TermQuery", term=dict(field="__id__", value="idCommit"))).dumps())
response = loads(body)
self.assertEqual(1, response['total'])
finally:
header, body = postRequest(self.luceneServerPort, self._path + '/delete/?identifier=idCommit', data=data)
self.assertTrue("200 OK" in header.upper(), header)
def testSimilarDocs(self):
header, body = postRequest(self.luceneServerPort, self._path + '/similarDocuments/?identifier=id1', data="", parse=False)
self.assertTrue("200 OK" in header.upper(), header + 2 * CRLF + body)
self.assertEqual({"total":0,"queryTime":0,"hits":[]}, loads(body))
def setUp(self):
IntegrationTestCase.setUp(self)
self._path = "/default"
header, body = postRequest(self.luceneServerPort, self._path + '/settings/', data=JsonDict(commitCount=1).dumps())
self.assertTrue("200 OK" in header.upper(), header)
def testDelete(self):
header, body = postRequest(self.suggestionServerPort,
'/delete?identifier=id1',
data=None,
parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
def testAutocompleteWithSuggestionIndexComponent(self):
data = """{
"key": 1,
"values": ["harry"], "types": ["uri:book"], "creators": ["rowling"]
}"""
postRequest(self.suggestionServerPort,
'/add?identifier=id1',
data=data,
parse=False)
data = """{
"key": 2,
"values": ["hallo"], "types": ["uri:ebook"], "creators": [null]
}"""
postRequest(self.suggestionServerPort,
'/add?identifier=id2',
data=data,
parse=False)
try:
postRequest(self.suggestionServerPort,
'/createSuggestionNGramIndex?wait=True',
data=None,
parse=False)
header, body = getRequest(port=self.httpPort,
path='/suggestion',
arguments={'value': 'ha'},
parse=False)
self.assertEqual(["ha", ["harry", "hallo"]], loads(body))
header, body = getRequest(port=self.httpPort,
path='/suggestion',
arguments={
'value': 'ha',
"filter": "type=uri:book"
},
parse=False)
self.assertEqual(["ha", ["harry"]], loads(body))
finally:
postRequest(self.suggestionServerPort,
'/delete?identifier=id1',
data=None,
parse=False)
postRequest(self.suggestionServerPort,
'/delete?identifier=id2',
data=None,
parse=False)
postRequest(self.suggestionServerPort,
'/commit',
data=None,
parse=False)
def solrRequest(self, path="/executeQuery", **queryKwargs):
header, body = postRequest(port=self.solrClientPort, path=path, data=dumps(queryKwargs), parse=False)
responseType, responseDict = body.split(': ', 1)
self.assertEquals('SolrResponse', responseType, responseType + responseDict)
return loads(responseDict)
def testCommit(self):
header, body = postRequest(self.numerateServerPort,
'/commit',
parse=False)
self.assertTrue("200 OK" in header.upper(), header)
def testCreate(self):
header, body = postRequest(self.suggestionServerPort,
'/createSuggestionNGramIndex?wait=True',
data=None,
parse=False)
self.assertTrue("200 OK" in header.upper(), header + body)
