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 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 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 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 _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 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)