def test_create_queryset_with_scoring_min_score_track_score(): """ Create QuerySet with Scoring, Minimum Score and Track Scores """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s, min_score=0, track_scores=True) # Then I see the appropriate JSON results = { "min_score": 0, "track_scores": True, "query": { "function_score": { "functions": [ { "script_score": { "script": "foo = 0.0" } } ], "query": {"match_all": {}}, "boost_mode": "replace", "score_mode": "multiply" } } } homogeneous(t._query, results)
def test_create_queryset_with_scoring(): """ Create QuerySet with Scoring """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s) # Then I see the appropriate JSON results = { "query": { "function_score": { "functions": [ { "script_score": { "script": "foo = 0.0" } } ], "query": {"match_all": {}}, "boost_mode": "replace", "score_mode": "multiply" } } } homogeneous(t._query, results)
def test_search_multiple_scoring(context): """ Search with custom scoring and params """ # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 1, "baz": 4}) add_document("foo", {"bar": 1}) # And I add scoring with params score = ScriptScore("s = custom_param + doc['bar'].value", params={"custom_param": 1}) t.score(score) boost = { "boost_factor": "10", "filter": Exists("baz") } t.score(boost) results = t[0:10] # Then my results are scored correctly len(results).should.equal(2) results[0]["_source"]["baz"].should.equal(4) ("baz" in results[1]["_source"].keys()).should.be.false
def test_create_queryset_with_filters(): """ Create QuerySet with Multiple Filters """ # When create a query block t = QuerySet("foobar") # And I add a filter t.filter(Term("foo", "bar")) t.filter(Term("foobar", "foobar")) # Then I see the appropriate JSON results = { "query": { "filtered": { "query": {"match_all": {}}, "filter": { "and": [ { "term": { "foo": "bar" } }, { "term": { "foobar": "foobar" } } ] } } } } homogeneous(t._query, results)
def test_create_queryset_with_sorting(): """ Create QuerySet with Sorting """ # When create a query block t = QuerySet("foobar") # And I add sorting s = Sort("_id", order="asc") t.order_by(s) # Then I see the appropriate JSON results = { "query": { "match_all": {} }, "sort": [ { "_id": { "order": "asc" } } ] } homogeneous(t._query, results)
def test_search_nested_terms_aggregations_with_size(context): """ Search with nested terms aggregation and a specified size """ # When create a query block t = QuerySet("localhost", index="foo") # And there are nested records add_document("foo", {"child": [{"stuff": "yep", "bazbaz": "type0"}], "foo": "foo"}) add_document("foo", {"child": [{"stuff": "yep", "bazbaz": "type0"}], "foo": "foo"}) add_document("foo", {"child": [{"stuff": "nope", "bazbaz": "type1"}], "foo": "foofoo"}) add_document("foo", {"child": [{"stuff": "nope", "bazbaz": "type2"}], "foo": "foofoo"}) # And I do a nested t.aggregate(aggregation=Aggregations("baz_types", "bazbaz", "terms", nested_path="child", size=1)) t[0:10] # The I get the expected results t.aggregations().should.have.key("child").being.equal({ u'baz_types': { u'buckets': [{u'doc_count': 2, u'key': u'type0'}] }, u'doc_count': 4 })
def test_create_queryset_with_multiple_scoring(): """ Create QuerySet with Multiple Scoring """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s) # And I add more scoring ss = ScriptScore("foo = 1.0") t.score(ss) # Then I see the appropriate JSON results = { "query": { "function_score": { "query": {"match_all": {}}, "script_score": { "script": "foo = 1.0" }, "boost_mode": "replace" } } } homogeneous(t._query, results)
def test_wrappers(context): """ Search with wrapped match_all query """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 1}) add_document("foo", {"bar": 2}) add_document("foo", {"bar": 3}) # And I do a search def wrapper_function(search_results): return map(lambda x: x["_source"]["bar"] + 1, search_results) t.wrappers(wrapper_function) t.order_by(Sort("bar", order="asc")) results = t[0:10] # Then I get a the expected results len(results).should.equal(3) results[0].should.equal(2) results[1].should.equal(3) results[2].should.equal(4)
def test_create_queryset_with_multiple_sorting(): """ Create QuerySet with Multiple Sorting """ # When create a query block t = QuerySet("foobar") # And I add sorting s = Sort("_id", order="asc") t.order_by(s) ss = Sort("_id", order="desc") t.order_by(ss) # Then I see the appropriate JSON results = { "sort": [ { "_id": { "order": "asc" } }, { "_id": { "order": "desc" } } ], "query": { "match_all": {} } } homogeneous(t._query, results)
def test_create_queryset_with_scoring(): """ Create QuerySet with Scoring, Minimum Score and Track Scores """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s, min_score=0, track_scores=True) # Then I see the appropriate JSON results = { "min_score": 0, "track_scores": True, "query": { "function_score": { "functions": [ { "script_score": { "script": "foo = 0.0" } } ], "query": {"match_all": {}}, "boost_mode": "replace", "score_mode": "multiply" } } } homogeneous(t._query, results)
def test_queryset_iteration_with_no_results(): """ Fetch results with QuerySet via __iter__ with no results """ # When I create a query block t = QuerySet("foobar", index="bar") wrapper = lambda y: list(map(lambda x: x['_id'], y)) t.wrappers(wrapper) # And I have no records response = { "took": 12, "hits": { "total": 0, "max_score": 0, "hits": [] } } httpretty.register_uri(httpretty.GET, "http://foobar:9200/bar/_search", body=json.dumps(response), content_type="application/json") results = [] for result in t: results.append(result) len(results).should.equal(0) t.count().should.equal(0)
def test_search_global_aggregations(context): """ Search with global aggregations """ # With a specific query # q = QueryBuilder(query_string=QueryString(query={"match": {"foo_attr": "yes"}})) # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz", "foo_attr": "yes"}) add_document("foo", {"bar": "bazbaz", "foo_attr": "no"}) add_document("foo", {"bar": "bazbaz"}) # And I do a global t.aggregate(aggregation=Aggregations("foo_attrs", "bar", "terms", global_name="all_bar")) t[0:10] # I get the expected results t.aggregations().should.have.key("all_bar").being.equal({ u'foo_attrs': {u'buckets': [ {u'key': u'bazbaz', u'doc_count': 2}, {u'key': u'baz', u'doc_count': 1} ]}, u'doc_count': 3})
def test_post_query_actions(context): """ Search with match_all query with post query actions """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 1}) add_document("foo", {"bar": 2}) add_document("foo", {"bar": 3}) # And I have a post query action global my_global_var my_global_var = 1 def action(self, results, start, stop): global my_global_var my_global_var += 1 t.post_query_actions(action) # And I do a search t.order_by(Sort("bar", order="asc")) results = t[0:10] # Then I get a the expected results len(results).should.equal(3) results[0]["_source"]["bar"].should.equal(1) results[1]["_source"]["bar"].should.equal(2) results[2]["_source"]["bar"].should.equal(3) my_global_var.should.equal(2)
def test_queryset_max_score(): """ Get QuerySet Max Score """ # When I create a query block t = QuerySet("foobar") # Then I get an appropriate max score t.max_score().should.equal(None)
def test_queryset_count(): """ Get QuerySet Count """ # When I create a query block t = QuerySet("foobar") # Then I get an appropriate Count t.count().should.equal(None)
def test_queryset_getitem_with_post_query_action(): """ Fetch from QuerySet with __getitem__ and post query action """ # When I create a query block t = QuerySet("localhost", index="bar") # And I have a post query action global my_global_var my_global_var = 1 def action(self, results, start, stop): global my_global_var my_global_var += 1 t.post_query_actions(action) # And I have records response = { "took": 12, "timed_out": False, "_shards": { "total": 5, "successful": 5, "failed": 0 }, "hits": { "total": 1, "max_score": 10, "hits": [ { "_index": "bar", "_type": "baz", "_id": "1", "_score": 10, "_source": { "foo": "bar" }, "sort": [ 1395687078000 ] } ] } } httpretty.register_uri(httpretty.GET, "http://localhost:9200/bar/_search", body=json.dumps(response), content_type="application/json") results = t[0:1] len(results).should.equal(1) t.count().should.equal(1) # Then I see the correct results results[0]['_id'].should.equal('1') my_global_var.should.equal(2)
def test_search_with_filter_and_scoring_and_sorting_and_fields(context): """ Search with match_all query, filter, scoring, sorting, and fields """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz", "scoring_field": 0, "sorting_field": 30}) add_document("foo", {"bar": "baz", "scoring_field": 1, "sorting_field": 20}) add_document("foo", {"bar": "baz", "scoring_field": 2, "sorting_field": 10}) add_document("foo", {"bar": "bazbaz", "scoring_field": 3, "sorting_field": 0}) # And I do a search t.filter(Term("bar", "baz")) score = ScriptScore("final_score = 0 + doc['scoring_field'].value;") t.score(score) sorting = Sort("sorting_field", order="desc") t.order_by(sorting) t.only(["bar"]) results = t[0:10] # Then I get a the expected results len(results).should.equal(3) results[0]['fields'].should.equal({"bar": ["baz"]}) results[1]['fields'].should.equal({"bar": ["baz"]}) results[2]['fields'].should.equal({"bar": ["baz"]})
def test_search_filtered_aggregations(context): """ Search with filtered aggregations """ # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 0, "foo": "baz"}) add_document("foo", {"bar": 0, "foo": "baz"}) add_document("foo", {"bar": 2}) add_document("foo", {"bar": 3, "foo": "bazbaz"}) add_document("foo", {"bar": 5, "foo": "foobar"}) add_document("foo", {"bar": 5}) add_document("foo", {"bar": 5, "foo": "foobaz"}) add_document("foo", {"bar": 9}) # And I do a filtered f = Filter().filter(Range("bar", gte=5)) t.aggregate(aggregation=Aggregations("missing_foo", "foo", "missing", filter_val=f, filter_name="high_bar")) t[0:10] # Then I get the expected results t.aggregations().should.have.key("high_bar") t.aggregations()["high_bar"].should.have.key("missing_foo").being.equal( {u'doc_count': 2}) t.aggregations()["high_bar"]["doc_count"].should.equal(4)
def test_search_with_iterator(context): """ Search using an iterator """ # When create a queryset t = QuerySet("localhost", index="foo") # And set iterator fetching to a small size t._per_request = 2 # And there are records add_document("foo", {"bar": 0}) add_document("foo", {"bar": 1}) add_document("foo", {"bar": 2}) add_document("foo", {"bar": 3}) add_document("foo", {"bar": 4}) # And I do a filter on my new object # And a different filter on my old object t.order_by(Sort("bar", order="asc")) # Then I get the expected results for (counter, result) in enumerate(t): result['_source'].should.equal({"bar": counter}) len(t).should.equal(5) t.count().should.equal(5) t.max_score().should_not.be(None)
def test_create_queryset_with_scoring_and_filtering_from_object(): """ Create QuerySet with Scoring and Filter Object """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s) # And I add filtering f = Filter("and").filter(Term("foo", "bar")) t.filter(f) # Then I see the appropriate JSON results = { "query": { "function_score": { "query": { "filtered": { "query": {"match_all": {}}, "filter": { "and": [ { "term": { "foo": "bar" } } ] } } }, "functions": [ { "script_score": { "script": "foo = 0.0" } } ], "boost_mode": "replace", "score_mode": "multiply" } } } homogeneous(t._query, results)
def test_create_queryset_with_only_block(): """ Create QuerySet with Only block """ # When create a query block t = QuerySet("foobar") # And I add an 'only' block t.only("_id") # Then I see the appropriate JSON results = { "query": {"match_all": {}}, "fields": ["_id"] } homogeneous(t._query, results)
def test_geo_distance_search_array(context): """ Search with geo distance filter with array """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"location": {"lat": 1.1, "lon": 2.1}}) add_document("foo", {"location": {"lat": 40.1, "lon": 80.1}}) # And I filter for terms t.filter(GeoDistance([2.0, 1.0], "20mi")) results = t[0:10] # Then I get a the expected results len(results).should.equal(1)
def test_geo_distance_search_with_field_name(context): """ Search with geo distance filter with field_name """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"foo_loc": {"lat": 1.1, "lon": 2.1}}) add_document("foo", {"foo_loc": {"lat": 40.1, "lon": 80.1}}) # And I filter for distance t.filter(GeoDistance({"lat": 1.0, "lon": 2.0}, "20mi", field_name="foo_loc")) results = t[0:10] # Then I get a the expected results len(results).should.equal(1)
def test_search_nested_aggregations(context): """ Search with nested aggregations """ # When create a query block t = QuerySet("localhost", index="foo") # And there are nested records add_document("foo", {"child": [{"stuff": "yep", "bazbaz": 10}], "foo": "foo"}) add_document("foo", {"child": [{"stuff": "nope", "bazbaz": 1}], "foo": "foofoo"}) # And I do a nested t.aggregate(aggregation=Aggregations("best_bazbaz", "bazbaz", "max", nested_path="child")) t[0:10] # The I get the expected results t.aggregations().should.have.key("child").being.equal({'best_bazbaz': {'value': 10.0}, 'doc_count': 2})
def test_create_queryset_with_multiple_scoring(): """ Create QuerySet with Multiple Scoring """ # When create a query block t = QuerySet("foobar") # And I add scoring s = ScriptScore("foo = 0.0") t.score(s) # And I add more scoring boost = { "boost_factor": "3", "filter": Term("foo", "bar") } t.score(boost) # Then I see the appropriate JSON results = { "query": { "function_score": { "query": {"match_all": {}}, "functions": [ { "script_score": { "script": "foo = 0.0" } }, { "boost_factor": "3", "filter": { "term": { "foo": "bar" } } } ], "boost_mode": "replace", "score_mode": "multiply" } } } homogeneous(t._query, results)
def test_search_histogram_aggregations_with_min_doc_count(context): """ Search with aggregations that have histograms with min_doc_count """ # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 0, "foo": "baz"}) add_document("foo", {"bar": 0, "foo": "baz"}) add_document("foo", {"bar": 2}) add_document("foo", {"bar": 3, "foo": "bazbaz"}) add_document("foo", {"bar": 5, "foo": "foobar"}) add_document("foo", {"bar": 5}) add_document("foo", {"bar": 5, "foo": "foobaz"}) add_document("foo", {"bar": 9}) # When I do a histogram aggregation t.aggregate(aggregation=Aggregations("bar_buckets", "bar", "metric", histogram_interval=2, min_doc_count=2)) t[0:10] # I get the expected results t.aggregations().should.have.key("bar_buckets") t.aggregations()["bar_buckets"].should.have.key("buckets").being.equal([ {u'key': 4, u'doc_count': 3}, {u'key': 2, u'doc_count': 2}, {u'key': 0, u'doc_count': 2}])
def test_search_terms_aggregation_with_order_two(context): """ Search with terms aggregation ordered by count ascending """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz"}) add_document("foo", {"bar": "baz"}) add_document("foo", {"bar": "baz"}) add_document("foo", {"bar": "bazbaz"}) add_document("foo", {"bar": "bazbaz"}) add_document("foo", {"bar": "bazbar"}) # And I do an aggregated search t.aggregate(aggregation=Aggregations("foo_attrs", "bar", "terms", order_type="_count", order_dir="asc")) t[0:10] # Then I get a the expected results t.aggregations().should.have.key('foo_attrs') t.aggregations()['foo_attrs'].should.have.key("buckets").being.equal([ {u'key': u'bazbar', u'doc_count': 1}, {u'key': u'bazbaz', u'doc_count': 2}, {u'key': u'baz', u'doc_count': 3}])
def test_search_with_missing_existence_null_value(context): """ Search with missing via non-existence or a null value """ # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": 1}) add_document("foo", {"baz": 2}) add_document("foo", {"baz": 3, "bar": None}) # And I add filters t.filter(Missing("bar", existence=True, null_value=True)) results = t[0:10] # Then my results are filtered correctly len(results).should.equal(2)
def test_terms_search_with_execution(context): """ Search with terms filter with execution """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"foo": ["foo", "bar"]}) add_document("foo", {"foo": ["foo", "baz"]}) # And I filter for terms t.filter(Terms("foo", ["foo", "bar"], execution="and")) results = t[0:10] # Then I get a the expected results len(results).should.equal(1) results[0]["_source"]["foo"].should.equal(["foo", "bar"])
def test_simple_search_with_filter(context): """ Search with filter """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz"}) add_document("foo", {"bar": "bazbaz"}) # And I do a filtered search t.filter(Term("bar", "baz")) results = t[0:10] # Then I get a the expected results len(results).should.equal(1) results[0]['_source'].should.equal({"bar": "baz"})
def test_search_with_filter_block(context): """ Search with Filter Block """ # When create a query block t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz", "foo": "foo"}) add_document("foo", {"bar": "bazbaz", "foo": "foo"}) add_document("foo", {"bar": "bazbaz", "foo": "foofoo"}) # And I do a filtered search f = Filter("or").filter(Term("bar", "baz")).filter(Term("foo", "foo")) t.filter(f) results = t[0:10] # Then I get the appropriate response len(results).should.equal(2)
def test_match_all_search(context): """ Search with match all filter """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz", "foo": "foo"}) add_document("foo", {"bar": "bazbaz", "foo": "foo"}) add_document("foo", {"bar": "baz", "foo": "foofoo"}) add_document("foo", {"bar": "baz", "foo": "foofoofoo"}) # And I filter match_all t.filter(MatchAll()) results = t[0:10] # Then I get a the expected results len(results).should.equal(4)
def test_terms_search(context): """ Search with terms filter """ # When create a queryset t = QuerySet("localhost", index="foo") # And there are records add_document("foo", {"bar": "baz", "foo": "foo"}) add_document("foo", {"bar": "bazbaz", "foo": "foo"}) add_document("foo", {"bar": "baz", "foo": "foofoo"}) add_document("foo", {"bar": "baz", "foo": "foofoofoo"}) # And I filter for terms t.filter(Terms("foo", ["foo", "foofoo"])) results = t[0:10] # Then I get a the expected results len(results).should.equal(3)
def test_create_queryset(): """ Create Default QuerySet """ # When create a queryset t = QuerySet("foobar") # Then I see the appropriate JSON results = { "query": {"match_all": {}} } homogeneous(t._query, results)