def testValidateComposedQuery(self): composedQuery = ComposedQuery('coreA') composedQuery.setCoreQuery(core='coreA', query='Q0') composedQuery.setCoreQuery(core='coreB', query='Q1') self.assertValidateRaisesValueError(composedQuery, "No match set for cores ('coreA', 'coreB')") composedQuery = ComposedQuery('coreA', query="A") composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) composedQuery.validate() self.assertEquals(1, composedQuery.numberOfUsedCores)
def testUniteMakesItTwoCoreQuery(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.setCoreQuery('coreA', query='A') cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) cq.validate() self.assertEquals(set(['coreA', 'coreB']), cq.cores)
def testIsSingleCoreQuery(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.setCoreQuery('coreA', query='A') self.assertTrue(cq.isSingleCoreQuery()) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) self.assertFalse(cq.isSingleCoreQuery())
def testKeyName(self): composedQuery = ComposedQuery('coreA') composedQuery.setCoreQuery(core='coreA', query=None) composedQuery.setCoreQuery(core='coreB', query=None) composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) self.assertEquals('keyA', composedQuery.keyName('coreA')) self.assertEquals('keyB', composedQuery.keyName('coreB'))
def testUnite(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=None) cq.setCoreQuery(core='coreB', query=None) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEquals([('coreA', 'AQuery'), ('coreB', 'anotherQuery')], cq.unites)
def testConvertAllQueriesWithUnqualifiedTermFields(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery('coreA', 'Q1') cq.addFilterQuery('coreA', 'Q2') cq.setCoreQuery(core='coreB', query='Q3') cq.addFilterQuery('coreB', 'Q4') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) cq.unqualifiedTermFields = [('field0', 2.0), ('field1', 3.0)] convertCoreA = lambda query, unqualifiedTermFields=None, **kwargs: "Converted_A_{0}_{1}".format( query, not unqualifiedTermFields is None) convertCoreB = lambda query, **kwargs: "Converted_B_{0}".format(query) cq.convertWith(coreA=convertCoreA, coreB=convertCoreB) self.assertEquals("Converted_A_Q0_True", cq.queryFor('coreA')) self.assertEquals(["Converted_A_Q1_True", "Converted_A_Q2_True"], cq.filterQueriesFor('coreA')) self.assertEquals("Converted_B_Q3", cq.queryFor('coreB')) self.assertEquals(["Converted_B_Q4"], cq.filterQueriesFor('coreB')) self.assertEqual(1, len(cq.unites)) uniteQueries = list(cq.unites[0].queries()) self.assertEquals('Converted_A_Q5_True', uniteQueries[0][0]['query']) self.assertEquals('Converted_B_Q6', uniteQueries[1][0]['query'])
def testAddTypeAndMissingValueToSortField(self): self.response = JsonDict({ "total": 887, "queryTime": 6, "hits": [{"id": "record:1", "score": 0.1234}] }).dumps() cq = ComposedQuery('coreA') q = QueryExpressionToLuceneQueryDict([], LuceneSettings()).convert(cqlToExpression("field=value")) cq.setCoreQuery('coreB', q) cq.sortKeys = [dict(sortBy='sortField', core='coreA', sortDescending=True)] cq.addMatch(dict(core='coreA', uniqueKey='A'), dict(core='coreB', key='B')) consume(self._multiLucene.executeComposedQuery(cq)) self.assertEqual({ "_sortKeys": [{'core': 'coreA', 'sortBy': 'sortField', 'sortDescending': True, 'type': 'String', 'missingValue': 'STRING_FIRST'}], "resultsFrom": "coreA", '_matches': {'coreA->coreB': [{'core': 'coreA', 'uniqueKey': 'A'}, {'core': 'coreB', 'key': 'B'}]}, "_facets": {}, "_otherCoreFacetFilters": {}, "_rankQueries": {}, "_drilldownQueries": {}, "_unites": [], '_queries': {'coreB': {'term': {'field': 'field', 'value': 'value'}, 'type': 'TermQuery'}}, "cores": ["coreB", "coreA"], "_filterQueries": {} }, loads(self.post[0]['data']))
def testFilterQueries(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEquals(None, cq.stop) self.assertEquals(None, cq.start) self.assertEquals([], cq.sortKeys) cq.stop = 10 cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] self.assertEquals('Q0', cq.queryFor('coreA')) self.assertEquals(['Q1', 'Q2'], cq.filterQueriesFor('coreA')) self.assertEquals(['F0', 'F1'], cq.facetsFor('coreA')) self.assertEquals(10, cq.stop) self.assertEquals(0, cq.start) self.assertEquals([dict(sortBy='field', sortDescending=True)], cq.sortKeys)
def testInfoOnQuery(self): self.response = JsonDict({ "total": 887, "queryTime": 6, "hits": [{"id": "record:1", "score": 0.1234}] }).dumps() q = ComposedQuery('coreA') q.addFilterQuery('coreB', query='N=true') q.addMatch(dict(core='coreA', uniqueKey='A'), dict(core='coreB', key='B')) result = retval(self._multiLucene.executeComposedQuery(q)) self.assertEquals({ 'query': { 'cores': ['coreB', 'coreA'], 'drilldownQueries': {}, 'facets': {}, 'filterQueries': {'coreB': ['N=true']}, 'matches': {'coreA->coreB': [{'core': 'coreA', 'uniqueKey': 'A'}, {'core': 'coreB', 'key': 'B'}]}, 'otherCoreFacetFilters': {}, 'queries': {}, 'rankQueries': {}, 'resultsFrom': 'coreA', 'sortKeys': [], 'unites': [] }, 'type': 'ComposedQuery' }, result.info)
def testRemoteExecuteQuery(self): http = CallTrace('http') def httppost(*args, **kwargs): raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' % LuceneResponse(total=5, hits=[ Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5") ]).asJson()) yield http.methods['httppost'] = httppost remote = LuceneRemote(host='host', port=1234, path='/path') observable = Observable() observable.addObserver(remote) remote._httppost = http.httppost cq = ComposedQuery('coreA') cq.setCoreQuery( core='coreA', query=parseString('query AND field=value'), filterQueries=[parseString('query=fiets')], facets=[{ 'fieldname': 'field', 'maxTerms': 5 }], ) cq.setCoreQuery(core='coreB', query=parseString('query=test')) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) result = returnValueFromGenerator( observable.any.executeComposedQuery(query=cq)) self.assertEquals(5, result.total) self.assertEquals([ Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5") ], result.hits) self.assertEquals(['httppost'], http.calledMethodNames()) m = http.calledMethods[0] self.assertEquals('host', m.kwargs['host']) self.assertEquals(1234, m.kwargs['port']) self.assertEquals('/path/__lucene_remote__', m.kwargs['request']) self.assertEquals('application/json', m.kwargs['headers']['Content-Type']) message, kwargs = jsonLoadMessage(m.kwargs['body']) query = kwargs['query'] self.assertEquals('executeComposedQuery', message) self.assertEquals('coreA', query.resultsFrom) self.assertEquals([{ 'fieldname': 'field', 'maxTerms': 5 }], query.facetsFor('coreA'))
def testComposedQuery(self): self.response = JsonDict({ "total": 887, "queryTime": 6, "hits": [{"id": "record:1", "score": 0.1234}] }).dumps() cq = ComposedQuery('coreA') q = QueryExpressionToLuceneQueryDict([], LuceneSettings()).convert(cqlToExpression("field=value")) cq.setCoreQuery("coreA", q) consume(self._multiLucene.executeComposedQuery(cq)) self.assertEqual(1, len(self.post)) self.assertEqual("/query/", self.post[0]['path']) self.assertEqual({ "_sortKeys": [], "resultsFrom": "coreA", "_matches": {}, "_facets": {}, "_otherCoreFacetFilters": {}, "_rankQueries": {}, "_drilldownQueries": {}, "_unites": [], "_queries": {"coreA": {"term": {"field": "field", "value": "value"}, "type": "TermQuery"}}, "cores": ["coreA"], "_filterQueries": {} }, loads(self.post[0]['data']))
def testMatchesMustAlwaysIncludeResultsFrom(self): composedQuery = ComposedQuery('coreA', query='qA') composedQuery.setCoreQuery('coreB', query='qB') composedQuery.setCoreQuery('coreC', query='qC') self.assertRaises( ValueError, lambda: composedQuery.addMatch(dict(core='coreB', key='keyB'), dict(core='coreC', key='keyC')))
def testKeyName(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addFacet(core='coreB', facet='F0') self.assertEquals('keyA', cq.keyName('coreA', 'coreB')) self.assertEquals('keyB', cq.keyName('coreB', 'coreA')) self.assertEquals(set(['keyA']), cq.keyNames('coreA'))
def testAddRankQuery(self): cq = ComposedQuery('coreA') cq.setRankQuery('coreB', 'qB') self.assertValidateRaisesValueError(cq, "No match set for cores ('coreA', 'coreB')") cq.addMatch(dict(core='coreA', uniqueKey='kA'), dict(core='coreB', key='kB')) self.assertEquals('qB', cq.rankQueryFor('coreB')) cq.convertWith(coreB=lambda q: "converted_" + q) self.assertEquals('converted_qB', cq.rankQueryFor('coreB'))
def testUniqueKeyDoesntMatchResultsFrom(self): composedQuery = ComposedQuery('coreA', query='A').setCoreQuery('coreB', query='bQ') self.assertRaises(ValueError, lambda: composedQuery.addMatch(dict(core='coreA', key='keyA'), dict(core='coreB', key='keyB'))) self.assertRaises(ValueError, lambda: composedQuery.addMatch(dict(core='coreA', key='keyA'), dict(core='coreB', uniqueKey='keyB'))) composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) composedQuery.validate() composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', uniqueKey='keyB')) composedQuery.validate()
def testAddDrilldownQuery(self): cq = ComposedQuery('coreA') cq.addDrilldownQuery('coreB', ('field', ['value'])) self.assertValidateRaisesValueError(cq, "No match set for cores ('coreA', 'coreB')") cq.addMatch(dict(core='coreA', uniqueKey='kA'), dict(core='coreB', key='kB')) self.assertEquals([('field', ['value'])], cq.drilldownQueriesFor('coreB')) cq.convertWith(coreB=lambda q: "converted_" + q) self.assertEquals([('field', ['value'])], cq.drilldownQueriesFor('coreB'))
def testValidateComposedQueryForInvalidJson(self): composedQuery = ComposedQuery('coreA', query='Q0') composedQuery.relationalFilterJson = 'not JSON' self.assertValidateRaisesValueError( composedQuery, "Value 'not JSON' for 'relationalFilterJson' can not be parsed as JSON." ) composedQuery.relationalFilterJson = '{"type": "MockJoinQuery"}' composedQuery.validate()
def testAddFacetIncremental(self): cq = ComposedQuery('coreA') cq.addFacet(core='coreA', facet=dict(fieldname='Q1', maxTerms=10)) cq.addFacet(core='coreA', facet=dict(fieldname='Q2', maxTerms=10)) self.assertEquals([ dict(fieldname='Q1', maxTerms=10), dict(fieldname='Q2', maxTerms=10) ], cq.facetsFor('coreA'))
def testAddFilterQueryAfterConversion(self): cq = ComposedQuery('coreA') cq.setCoreQuery('coreA', query='A') cq.convertWith(coreA=lambda q, **kwargs: "converted_" + q) self.assertEquals('converted_A', cq.queryFor('coreA')) # Assert the following does not raise KeyError cq.addFilterQuery('coreA', 'field=value') cq.addFacet('coreA', 'F0') cq.addDrilldownQuery('coreA', 'drilldownQuery') cq.addOtherCoreFacetFilter('coreA', 'q')
def testSameCoreInDifferentMatchesRequiredToHaveSameKeyForNow(self): composedQuery = ComposedQuery('coreA', query='qA') composedQuery.setCoreQuery('coreB', query='qB') composedQuery.setCoreQuery('coreC', query='qC') composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) self.assertRaises( ValueError, lambda: composedQuery.addMatch(dict(core='coreA', key='keyX'), dict(core='coreC', key='keyC')))
def testAtMostOneMultiCoreOr(self): composedQuery = ComposedQuery('coreA') composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreC', key='keyC')) composedQuery.addUnite(dict(core='coreA', query='qA'), dict(core='coreB', query='qB')) self.assertRaises( ValueError, lambda: composedQuery.addUnite( dict(core='coreA', query='qA'), dict('coreC', query='qC')))
def testAddOtherCoreFacetFilter(self): cq = ComposedQuery('coreA') cq.addOtherCoreFacetFilter('coreB', 'field=value') self.assertValidateRaisesValueError( cq, "No match set for cores ('coreA', 'coreB')") cq.addMatch(dict(core='coreA', uniqueKey='kA'), dict(core='coreB', key='kB')) self.assertEquals(['field=value'], cq.otherCoreFacetFiltersFor('coreB')) cq.convertWith(coreB=lambda q: "converted_" + q) self.assertEquals(['converted_field=value'], cq.otherCoreFacetFiltersFor('coreB'))
def testLuceneServerHostPortDynamic(self): multiLucene = MultiLucene(defaultCore='core1') def httprequest1_1Mock(**kwargs): raise StopIteration(parseResponse(HTTP_RESPONSE)) yield observer = CallTrace( 'observer', returnValues=dict(luceneServer=('example.org', 1234)), methods=dict(httprequest1_1=httprequest1_1Mock)) multiLucene.addObserver(observer) query = QueryExpressionToLuceneQueryDict([], LuceneSettings()).convert(cqlToExpression("field=value")) response = retval(multiLucene.executeComposedQuery(ComposedQuery('core1', query))) self.assertEquals(887, response.total) self.assertEquals(['luceneServer', 'httprequest1_1'], observer.calledMethodNames())
def testConvertComposedQuery(self): q = ComposedQuery('A') q.setCoreQuery(core='A', query=parseString('valueAQ')) q.setCoreQuery(core='B', query=parseString('valueBQ')) q.addMatch(dict(core='A', uniqueKey='keyA'), dict(core='B', key='keyB')) q.addUnite(dict(core='A', query=parseString('fieldUA exact valueUA')), dict(core='B', query=parseString('fieldUB exact valueUB'))) q.validate() consume(self.dna.any.executeComposedQuery(query=q)) self.assertEquals(['executeComposedQuery'], self.observer.calledMethodNames()) self.assertEquals(repr(TermQuery(Term('fieldA', 'valueaq'))), repr(q.queryFor('A'))) self.assertEquals(repr(TermQuery(Term('fieldB', 'valuebq'))), repr(q.queryFor('B')))
def testConvertAllQueries(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery('coreA', 'Q1') cq.addFilterQuery('coreA', 'Q2') cq.setCoreQuery(core='coreB', query='Q3') cq.addFilterQuery('coreB', 'Q4') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) convertCoreA = lambda query: "Converted_A_{0}".format(query) convertCoreB = lambda query: "Converted_B_{0}".format(query) cq.convertWith(coreA=convertCoreA, coreB=convertCoreB) self.assertEquals("Converted_A_Q0", cq.queryFor('coreA')) self.assertEquals(["Converted_A_Q1", "Converted_A_Q2"], cq.filterQueriesFor('coreA')) self.assertEquals("Converted_B_Q3", cq.queryFor('coreB')) self.assertEquals(["Converted_B_Q4"], cq.filterQueriesFor('coreB')) self.assertEquals([('coreA', 'Converted_A_Q5'), ('coreB', 'Converted_B_Q6')], cq.unites)
def testConvertComposedQuery(self): q = ComposedQuery('A') q.setCoreQuery(core='A', query=cqlToExpression('valueAQ')) q.setCoreQuery(core='B', query=cqlToExpression('valueBQ')) q.addMatch(dict(core='A', uniqueKey='keyA'), dict(core='B', key='keyB')) q.addUnite( dict(core='A', query=cqlToExpression('fieldUA exact valueUA')), dict(core='B', query=cqlToExpression('fieldUB exact valueUB'))) q.validate() consume(self.dna.any.executeComposedQuery(query=q)) self.assertEquals(['executeComposedQuery'], self.observer.calledMethodNames()) self.assertEquals( "{'type': 'TermQuery', 'term': {'field': 'fieldA', 'value': u'valueaq'}, 'boost': 1.0}", repr(q.queryFor('A'))) self.assertEquals( "{'type': 'TermQuery', 'term': {'field': 'fieldB', 'value': u'valuebq'}, 'boost': 1.0}", repr(q.queryFor('B')))
def testAsDictFromDict(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.relationalFilter = '{"type": "madeUpJoinQuery"}' cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] cq.clustering = True cq.clusteringConfig = {'clusteringEps': 0.2} cq.rankQueryScoreRatio = 0.75 d = cq.asDict() cq2 = ComposedQuery.fromDict(d) self.assertEquals('coreA', cq2.resultsFrom) self.assertEquals(0, cq2.start) self.assertEquals(None, cq2.stop) self.assertEquals(['Q0', 'Q1', 'Q2'], cq2.queriesFor('coreA')) self.assertEquals('{"type": "madeUpJoinQuery"}', cq2.relationalFilter) self.assertEquals(['F0', 'F1'], cq2.facetsFor('coreA')) self.assertEquals('keyA', cq2.keyName('coreA', 'coreB')) self.assertEquals('keyB', cq2.keyName('coreB', 'coreA')) self.assertEqual(1, len(cq2.unites)) queries = list(cq2.unites[0].queries()) self.assertEquals(({ 'core': 'coreA', 'keyName': 'keyA', 'query': 'AQuery' }, 'keyA'), queries[0]) self.assertEquals(({ 'core': 'coreB', 'keyName': 'keyB', 'query': 'anotherQuery' }, 'keyA'), queries[1]) self.assertEquals({'clusteringEps': 0.2}, cq2.clusteringConfig) self.assertEquals(0.75, cq2.rankQueryScoreRatio)
def testUnite(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=None) cq.setCoreQuery(core='coreB', query=None) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEqual(1, len(cq.unites)) queries = list(cq.unites[0].queries()) self.assertEquals(({ 'query': 'AQuery', 'keyName': 'keyA', 'core': 'coreA' }, 'keyA'), queries[0]) self.assertEquals(({ 'query': 'anotherQuery', 'keyName': 'keyB', 'core': 'coreB' }, 'keyA'), queries[1])
def testConversionOfComposedQuery(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=parseString('Q0'), filterQueries=['Q1', 'Q2'], facets=['F0', 'F1']) cq.setCoreQuery(core='coreB', query='Q3', filterQueries=['Q4']) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] kwargs = {'q': cq} dump = jsonDumpMessage(message='aMessage', **kwargs) self.assertEquals(str, type(dump)) message, kwargs = jsonLoadMessage(dump) self.assertEquals('aMessage', message) cq2 = kwargs['q'] self.assertEquals(parseString('Q0'), cq2.queryFor('coreA'))
def testAsDictFromDict(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] d = cq.asDict() cq2 = ComposedQuery.fromDict(d) self.assertEquals('coreA', cq2.resultsFrom) self.assertEquals(0, cq2.start) self.assertEquals(None, cq2.stop) self.assertEquals(['Q0', 'Q1', 'Q2'], cq2.queriesFor('coreA')) self.assertEquals(['F0', 'F1'], cq2.facetsFor('coreA')) self.assertEquals('keyA', cq2.keyName('coreA')) self.assertEquals('keyB', cq2.keyName('coreB'))