def test_build_terms_query(self): # Empty query fields = "" terms = None query = ElasticSearchBase.build_terms_query(fields, terms) self.assertFalse(query) #...................................................................... # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("term" in query) self.assertTrue(fields in query["term"]) self.assertEqual(query["term"][fields], terms) #...................................................................... # Multiple terms, single field query fields = "signature" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("terms" in query) self.assertTrue(fields in query["terms"]) self.assertEqual(query["terms"][fields], terms) #...................................................................... # Multiple terms, multiple fields query fields = ["signature", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("terms" in query) for field in fields: self.assertTrue(field in query["terms"]) self.assertEqual(query["terms"][field], terms)
def test_build_query_from_params(self): # Test with all default parameters config = self.get_dummy_context() params = {} params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("size" in query) self.assertTrue("from" in query) # Searching for a term in a specific field and with a specific product params = { "terms": "hang", "fields": "dump", "search_mode": "contains", "products": "fennec" } params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("filtered" in query["query"]) filtered = query["query"]["filtered"] self.assertTrue("query" in filtered) self.assertTrue("wildcard" in filtered["query"]) self.assertTrue("dump" in filtered["query"]["wildcard"]) dump_term = filtered["query"]["wildcard"]["dump"] self.assertEqual(dump_term, "*hang*") self.assertTrue("filter" in filtered) self.assertTrue("and" in filtered["filter"])
def test_build_wildcard_query(self): # Empty query fields = "" terms = None query = ElasticSearchBase.build_wildcard_query(fields, terms) self.assertFalse(query) #...................................................................... # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_wildcard_query(fields, terms) self.assertTrue("wildcard" in query) self.assertTrue("signature.full" in query["wildcard"]) self.assertEqual(query["wildcard"]["signature.full"], terms) #...................................................................... # Multiple terms, single field query fields = "dump" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_wildcard_query(fields, terms) self.assertTrue("wildcard" in query) self.assertTrue(fields in query["wildcard"]) self.assertEqual(query["wildcard"][fields], terms) #...................................................................... # Multiple terms, multiple fields query fields = ["reason", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_wildcard_query(fields, terms) self.assertTrue("wildcard" in query) for field in fields: self.assertTrue(field in query["wildcard"]) self.assertEqual(query["wildcard"][field], terms)
def __init__(self, *args, **kwargs): config = kwargs.get('config') # We have multiple inheritance here, explicitly calling superclasses's # init is mandatory. # See http://freshfoo.com/blog/object__init__takes_no_parameters SearchBase.__init__(self, config=config) ElasticSearchBase.__init__(self, config=config)
def test_format_versions(): """ Test ElasticSearchBase.format_versions() """ # Empty versions versions = None version_res = ElasticSearchBase.format_versions(versions) assert not version_res, ( "The versions string is %s, null expected." % version_res) # Only one product, no version versions = ["firefox"] version_res = ElasticSearchBase.format_versions(versions) assert isinstance(version_res, list), ( "Results should be a list, %s received" % type(version_res)) assert version_res == [{ "product": "firefox", "version": None}], ( "Wrong formatting of versions for one product, no version: " "%s" % version_res) # One product, one version versions = ["firefox:5.0.1b"] version_res = ElasticSearchBase.format_versions(versions) assert isinstance(version_res, list), ( "Results should be a list, %s received" % type(version_res)) assert "product" in version_res[0], "Result should have a product" assert "version" in version_res[0], "Result should have a version" assert version_res[0]["product"] == "firefox", ( "Result's product is wrong, expected 'firefox', received %s" % version_res[0]["product"]) assert version_res[0]["version"] == "5.0.1b", ( "Result's version is wrong, expected '5.0.1b', received %s" % version_res[0]["version"]) # Multiple products, multiple versions versions = ["firefox:5.0.1b", "fennec:1"] version_res = ElasticSearchBase.format_versions(versions) assert type(version_res) is list, ( "Results should be a list, %s received" % type(version_res)) for v in version_res: assert "product" in v, "Result should have a product" assert "version" in v, "Result should have a version" assert version_res[0]["product"] == "firefox", ( "Result's product is wrong, expected 'firefox', received %s" % version_res[0]["product"]) assert version_res[0]["version"] == "5.0.1b", ( "Result's version is wrong, expected '5.0.1b', received %s" % version_res[0]["version"]) assert version_res[1]["product"] == "fennec", ( "Result's product is wrong, expected 'fennec', received %s" % version_res[1]["product"]) assert version_res[1]["version"] == "1", ( "Result's version is wrong, expected '1', received %s" % version_res[1]["version"])
def test_generate_list_of_indexes(self): config = self._get_default_config() es = ElasticSearchBase(config=config) from_date = datetime.datetime(2000, 1, 1, 0, 0) to_date = datetime.datetime(2000, 1, 16, 0, 0) indexes = es.generate_list_of_indexes(from_date, to_date) indexes_exp = ["socorro200000", "socorro200001", "socorro200002"] self.assertEqual(indexes, indexes_exp)
def test_build_wildcard_query(): """ Test ElasticSearchBase.build_wildcard_query() """ # Empty query fields = "" terms = None query = ElasticSearchBase.build_wildcard_query(fields, terms) assert not query, "Query is %s, null or empty expected." % query # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_wildcard_query(fields, terms) assert "wildcard" in query, ( "Single term, single field query does not have " "a wildcard field: %s" % query) assert "signature.full" in query["wildcard"], ( "Term query does not have the asked %s field: %s" % (fields, query)) assert query["wildcard"]["signature.full"] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][fields], terms, query)) # Multiple terms, single field query fields = "dump" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_wildcard_query(fields, terms) assert "wildcard" in query, ( "Single term, single field query does not have " "a wildcard field: %s" % query) assert fields in query["wildcard"], ( "Term query does not have the asked %s field: %s" % (fields, query)) assert query["wildcard"][fields] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][fields], terms, query)) # Multiple terms, multiple fields query fields = ["reason", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_wildcard_query(fields, terms) assert "wildcard" in query, ( "Single term, single field query does not have " "a wildcard field: %s" % query) for field in fields: assert field in query["wildcard"], ( "Term query does not have the asked %s field: %s" % (field, query)) assert query["wildcard"][field] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][field], terms, query))
def test_build_terms_query(): """ Test ElasticSearchBase.build_terms_query() """ # Empty query fields = "" terms = None query = ElasticSearchBase.build_terms_query(fields, terms) assert not query # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_terms_query(fields, terms) assert "term" in query, ( "Single term, single field query does not have a term field: " "%s" % query) assert fields in query["term"], ( "Term query does not have the asked %s field: %s" % (fields, query)) assert query["term"][fields] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][fields], terms, query)) # Multiple terms, single field query fields = "signature" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_terms_query(fields, terms) assert "terms" in query, ( "Single term, single field query does not have a term field: " "%s" % query) assert fields in query["terms"], ( "Term query does not have the asked %s field: %s" % (fields, query)) assert query["terms"][fields] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][fields], terms, query)) # Multiple terms, multiple fields query fields = ["signature", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_terms_query(fields, terms) assert "terms" in query, ( "Single term, single field query does not have a term field: " "%s" % query) for field in fields: assert field in query["terms"], ( "Term query does not have the asked %s field: %s" % (field, query)) assert query["terms"][field] == terms, ( "Term query's value is %s, should be %s in query %s" % (query["term"][field], terms, query))
def test_build_query_from_params(): """ Test ElasticSearchBase.build_query_from_params() """ # Test with all default parameters args = { "config": get_dummy_context() } search = ElasticSearchBase(**args) params = {} params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params) assert query, "build_query_from_params returned a bad value: %s" % query assert "query" in query, ( "query is malformed, 'query' key missing: %s" % query) assert "size" in query, ( "query is malformed, 'size' key missing: %s" % query) assert "from" in query, ( "query is malformed, 'from' key missing: %s" % query) # Searching for a term in a specific field and with a specific product params = { "terms": "hang", "fields": "dump", "search_mode": "contains", "products": "fennec" } params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params) assert query, "build_query_from_params returned a bad value: %s" % query assert "query" in query, ( "query is malformed, 'query' key missing: %s" % query) assert "filtered" in query["query"], ( "query is malformed, 'filtered' key missing: %s" % query) filtered = query["query"]["filtered"] assert "query" in filtered, ( "query is malformed, 'query' key missing: %s" % query) assert "wildcard" in filtered["query"], ( "query is malformed, 'wildcard' key missing: %s" % query) assert "dump" in filtered["query"]["wildcard"], ( "query is malformed, 'dump' key missing: %s" % query) dump_term = filtered["query"]["wildcard"]["dump"] assert "*hang*" == dump_term, ( "query is malformed, value for wildcard is wrong: %s" % query) assert "filter" in filtered, ( "query is malformed, 'filter' key missing: %s" % query) assert "and" in filtered["filter"], ( "query is malformed, 'and' key missing: %s" % query)
def __init__(self, *args, **kwargs): config = kwargs.get('config') self.all_fields = self.get_fields() self.database_name_to_field_name_map = dict( (x['in_database_name'], x['name']) for x in self.all_fields.values()) # We have multiple inheritance here, explicitly calling superclasses's # init is mandatory. # See http://freshfoo.com/blog/object__init__takes_no_parameters SearchBase.__init__(self, config=config, fields=self.all_fields) ElasticSearchBase.__init__(self, config=config)
def test_generate_list_of_indexes(self): config = self._get_default_config() es = ElasticSearchBase(config=config) from_date = datetime.datetime(2000, 1, 1, 0, 0) to_date = datetime.datetime(2000, 1, 16, 0, 0) indexes = es.generate_list_of_indexes(from_date, to_date) indexes_exp = [ 'socorro200000', 'socorro200001', 'socorro200002', ] self.assertEqual(indexes, indexes_exp)
def __init__(self, *args, **kwargs): config = kwargs.get('config') ElasticSearchBase.__init__(self, config=config) self.all_fields = self.get_fields() self.database_name_to_field_name_map = dict( (x['in_database_name'], x['name']) for x in self.all_fields.values() ) # We have multiple inheritance here, explicitly calling superclasses's # init is mandatory. # See http://freshfoo.com/blog/object__init__takes_no_parameters SearchBase.__init__(self, config=config, fields=self.all_fields)
def test_generate_list_of_indexes(self): config = self._get_default_config() es = ElasticSearchBase(config=config) from_date = datetime.datetime(2000, 1, 1, 0, 0) to_date = datetime.datetime(2000, 1, 16, 0, 0) indexes = es.generate_list_of_indexes(from_date, to_date) indexes_exp = [ 'socorro200000', 'socorro200001', 'socorro200002', ] eq_(indexes, indexes_exp)
def test_query(self, mock_http): config = self._get_default_config() es = ElasticSearchBase(config=config) def post_fn(uri, query): if "socorro200002" in uri: return {"error": {"code": 404, "data": "IndexMissingException[[socorro200002]]"}} return "" mock_http.HttpClient.return_value.post = post_fn from_date = datetime.datetime(2000, 1, 1, 0, 0) to_date = datetime.datetime(2000, 1, 16, 0, 0) json_query = "{}" res = es.query(from_date, to_date, json_query) self.assertEqual(res, ("", "text/json"))
def test_query(self, mock_http): config = self._get_default_config() es = ElasticSearchBase(config=config) def post_fn(uri, query): if 'socorro200002' in uri: return { 'error': { 'code': 404, 'data': 'IndexMissingException[[socorro200002]]' } } return '' mock_http.HttpClient.return_value.post = post_fn from_date = datetime.datetime(2000, 1, 1, 0, 0) to_date = datetime.datetime(2000, 1, 16, 0, 0) json_query = '{}' res = es.query(from_date, to_date, json_query) self.assertEqual(res, ('', "text/json"))
def test_build_wildcard_query(self): # Empty query fields = "" terms = None query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_(not query) #...................................................................... # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) ok_("processed_crash.signature.full" in query["wildcard"]) eq_( query["wildcard"]["processed_crash.signature.full"], terms ) #...................................................................... # Multiple terms, single field query fields = "dump" prefixed_field = "processed_crash.dump" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) ok_(prefixed_field in query["wildcard"]) eq_(query["wildcard"][prefixed_field], terms) #...................................................................... # Multiple terms, multiple fields query fields = ["reason", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) for field in fields: prefixed_field = "processed_crash.%s" % field ok_(prefixed_field in query["wildcard"]) eq_(query["wildcard"][prefixed_field], terms)
def test_format_versions(self): # Empty versions versions = None version_res = ElasticSearchBase.format_versions(versions) self.assertFalse(version_res) #...................................................................... # Only one product, no version versions = ["firefox"] version_res = ElasticSearchBase.format_versions(versions) version_res_exp = [{"product": "firefox", "version": None}] self.assertTrue(isinstance(version_res, list)) self.assertEqual(version_res, version_res_exp) #...................................................................... # One product, one version versions = ["firefox:5.0.1b"] version_res = ElasticSearchBase.format_versions(versions) self.assertTrue(isinstance(version_res, list)) self.assertTrue("product" in version_res[0]) self.assertTrue("version" in version_res[0]) self.assertEqual(version_res[0]["product"], "firefox") self.assertEqual(version_res[0]["version"], "5.0.1b") #...................................................................... # Multiple products, multiple versions versions = ["firefox:5.0.1b", "fennec:1"] version_res = ElasticSearchBase.format_versions(versions) self.assertTrue(isinstance(version_res, list)) for v in version_res: self.assertTrue("product" in v) self.assertTrue("version" in v) self.assertEqual(version_res[0]["product"], "firefox") self.assertEqual(version_res[0]["version"], "5.0.1b") self.assertEqual(version_res[1]["product"], "fennec") self.assertEqual(version_res[1]["version"], "1")
def test_build_terms_query(self): # Empty query fields = "" terms = None query = ElasticSearchBase.build_terms_query(fields, terms) self.assertFalse(query) #...................................................................... # Single term, single field query fields = "signature" prefixed_field = "processed_crash.signature" terms = "hang" query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("term" in query) self.assertTrue(prefixed_field in query["term"]) self.assertEqual(query["term"][prefixed_field], terms) #...................................................................... # Multiple terms, single field query fields = "signature" prefixed_field = "processed_crash.signature" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("terms" in query) self.assertTrue(prefixed_field in query["terms"]) self.assertEqual(query["terms"][prefixed_field], terms) #...................................................................... # Multiple terms, multiple fields query fields = ["signature", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_terms_query(fields, terms) self.assertTrue("terms" in query) for field in fields: prefixed_field = "processed_crash.%s" % field self.assertTrue(prefixed_field in query["terms"]) self.assertEqual(query["terms"][prefixed_field], terms)
def test_format_versions(self): # Empty versions versions = None version_res = ElasticSearchBase.format_versions(versions) ok_(not version_res) #...................................................................... # Only one product, no version versions = ["firefox"] version_res = ElasticSearchBase.format_versions(versions) version_res_exp = [{"product": "firefox", "version": None}] ok_(isinstance(version_res, list)) eq_(version_res, version_res_exp) #...................................................................... # One product, one version versions = ["firefox:5.0.1b"] version_res = ElasticSearchBase.format_versions(versions) ok_(isinstance(version_res, list)) ok_("product" in version_res[0]) ok_("version" in version_res[0]) eq_(version_res[0]["product"], "firefox") eq_(version_res[0]["version"], "5.0.1b") #...................................................................... # Multiple products, multiple versions versions = ["firefox:5.0.1b", "fennec:1"] version_res = ElasticSearchBase.format_versions(versions) ok_(isinstance(version_res, list)) for v in version_res: ok_("product" in v) ok_("version" in v) eq_(version_res[0]["product"], "firefox") eq_(version_res[0]["version"], "5.0.1b") eq_(version_res[1]["product"], "fennec") eq_(version_res[1]["version"], "1")
def test_build_wildcard_query(self): # Empty query fields = "" terms = None query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_(not query) #...................................................................... # Single term, single field query fields = "signature" terms = "hang" query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) ok_("processed_crash.signature.full" in query["wildcard"]) eq_(query["wildcard"]["processed_crash.signature.full"], terms) #...................................................................... # Multiple terms, single field query fields = "dump" prefixed_field = "processed_crash.dump" terms = ["hang", "flash", "test"] query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) ok_(prefixed_field in query["wildcard"]) eq_(query["wildcard"][prefixed_field], terms) #...................................................................... # Multiple terms, multiple fields query fields = ["reason", "dump"] terms = ["hang", "flash"] query = ElasticSearchBase.build_wildcard_query(fields, terms) ok_("wildcard" in query) for field in fields: prefixed_field = "processed_crash.%s" % field ok_(prefixed_field in query["wildcard"]) eq_(query["wildcard"][prefixed_field], terms)
def test_prepare_terms(): """ Test Search.prepare_terms() """ # Empty terms terms = [] search_mode = None newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert not newterms, "Terms are %s, null or empty expected." % newterms # Contains mode, single term terms = ["test"] search_mode = "contains" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert newterms == "*test*", ( "Terms are not well prepared, missing stars around: %s" % newterms) # Contains mode, multiple terms terms = ["test", "hang"] search_mode = "contains" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert newterms == "*test hang*", ( "Terms are not well prepared, missing stars around: %s" % newterms) # Starts with mode, multiple terms terms = ["test", "hang"] search_mode = "starts_with" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert newterms == "test hang*", ( "Terms are not well prepared, missing stars after: %s" % newterms) # Is exactly mode, multiple terms terms = ["test", "hang"] search_mode = "is_exactly" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert newterms == " ".join(terms), ( "Terms should be concatenated when using a is_exactly mode.") # Random unexisting mode, multiple terms terms = ["test", "hang"] search_mode = "random_unexisting_mode" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) assert newterms == terms, ( "Terms should not be changed when using a mode other than " "is_exactly, starts_with or contains.")
def test_prepare_terms(self): """ Test Search.prepare_terms() """ # Empty terms terms = [] search_mode = None newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertFalse(newterms) # Contains mode, single term terms = ["test"] search_mode = "contains" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertEqual(newterms, "*test*") # Contains mode, multiple terms terms = ["test", "hang"] search_mode = "contains" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertEqual(newterms, "*test hang*") # Starts with mode, multiple terms terms = ["test", "hang"] search_mode = "starts_with" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertEqual(newterms, "test hang*") # Is exactly mode, multiple terms terms = ["test", "hang"] search_mode = "is_exactly" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertEqual(newterms, " ".join(terms)) # Random unexisting mode, multiple terms terms = ["test", "hang"] search_mode = "random_unexisting_mode" newterms = ElasticSearchBase.prepare_terms(terms, search_mode) self.assertEqual(newterms, terms)
def __init__(self, config): # We have multiple inheritance here, explicitly calling superclasses's # init is mandatory. # See http://freshfoo.com/blog/object__init__takes_no_parameters SearchBase.__init__(self, config=config) ElasticSearchBase.__init__(self, config=config)
def test_build_query_from_params(self): # Test with all default parameters config = self.get_dummy_context() params = {} params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("size" in query) self.assertTrue("from" in query) # Searching for a term in a specific field and with a specific product params = { "terms": "hang", "fields": "dump", "search_mode": "contains", "products": "fennec" } params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("filtered" in query["query"]) filtered = query["query"]["filtered"] self.assertTrue("query" in filtered) self.assertTrue("wildcard" in filtered["query"]) self.assertTrue("dump" in filtered["query"]["wildcard"]) dump_term = filtered["query"]["wildcard"]["dump"] self.assertEqual(dump_term, "*hang*") self.assertTrue("filter" in filtered) self.assertTrue("and" in filtered["filter"]) # Test versions params = { "products": "WaterWolf", "versions": "WaterWolf:1.0a1" } params = scommon.get_parameters(params) params['versions_info'] = { 'WaterWolf:1.0a1': { "version_string": "1.0a1", "product_name": "WaterWolf", "major_version": "1.0a1", "release_channel": "nightly-water", "build_id": None } } query = ElasticSearchBase.build_query_from_params(params, config) filtered = query["query"]["filtered"] self.assertTrue("and" in filtered["filter"]) and_filter_str = json.dumps(filtered["filter"]['and']) self.assertTrue('WaterWolf' in and_filter_str) self.assertTrue('1.0a1' in and_filter_str) self.assertTrue('nightly-water' in and_filter_str) # Test versions with an empty release channel in versions_info params = { "products": "WaterWolf", "versions": "WaterWolf:2.0" } params = scommon.get_parameters(params) params['versions_info'] = { 'WaterWolf:2.0': { "version_string": "2.0", "product_name": "WaterWolf", "major_version": "2.0", "release_channel": None, "build_id": None } } query = ElasticSearchBase.build_query_from_params(params, config) filtered = query["query"]["filtered"] self.assertTrue("and" in filtered["filter"]) and_filter_str = json.dumps(filtered["filter"]['and']) self.assertTrue('WaterWolf' in and_filter_str) self.assertTrue('2.0' in and_filter_str)
def test_build_query_from_params(self): # Test with all default parameters config = self.get_dummy_context() params = {} params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("size" in query) self.assertTrue("from" in query) # Searching for a term in a specific field and with a specific product params = { "terms": "hang", "fields": "dump", "search_mode": "contains", "products": "fennec" } params = scommon.get_parameters(params) query = ElasticSearchBase.build_query_from_params(params, config) self.assertTrue(query) self.assertTrue("query" in query) self.assertTrue("filtered" in query["query"]) filtered = query["query"]["filtered"] self.assertTrue("query" in filtered) self.assertTrue("wildcard" in filtered["query"]) self.assertTrue( "processed_crash.dump" in filtered["query"]["wildcard"]) dump_term = filtered["query"]["wildcard"]["processed_crash.dump"] self.assertEqual(dump_term, "*hang*") self.assertTrue("filter" in filtered) self.assertTrue("and" in filtered["filter"]) # Test versions params = {"products": "WaterWolf", "versions": "WaterWolf:1.0a1"} params = scommon.get_parameters(params) params["versions_info"] = { "WaterWolf:1.0a1": { "product_version_id": 1, "version_string": "1.0a1", "product_name": "WaterWolf", "major_version": "1.0a1", "release_channel": "nightly-water", "build_id": None, "is_rapid_beta": False, "is_from_rapid_beta": False, "from_beta_version": "WaterWolf:1.0a1", } } query = ElasticSearchBase.build_query_from_params(params, config) filtered = query["query"]["filtered"] self.assertTrue("and" in filtered["filter"]) and_filter_str = json.dumps(filtered["filter"]['and']) self.assertTrue('WaterWolf' in and_filter_str) self.assertTrue('1.0a1' in and_filter_str) self.assertTrue('nightly-water' in and_filter_str) # Test versions with an empty release channel in versions_info params = {"products": "WaterWolf", "versions": "WaterWolf:2.0"} params = scommon.get_parameters(params) params['versions_info'] = { 'WaterWolf:2.0': { "version_string": "2.0", "product_name": "WaterWolf", "major_version": "2.0", "release_channel": None, "build_id": None, "is_rapid_beta": False, "is_from_rapid_beta": False, "from_beta_version": "WaterWolf:2.0", } } query = ElasticSearchBase.build_query_from_params(params, config) filtered = query["query"]["filtered"] self.assertTrue("and" in filtered["filter"]) and_filter_str = json.dumps(filtered["filter"]['and']) self.assertTrue('WaterWolf' in and_filter_str) self.assertTrue('2.0' in and_filter_str)