def test_replacing(self):
responses = MultipleResponse()
responses.push(self.index.save_object({"objectID": "one"}))
responses.push(self.index.save_rule(F.rule(object_id="one")))
responses.push(self.index.save_synonym(
{"objectID": "one", "type": "synonym", "synonyms": ["one", "two"]}
))
responses.wait()
responses.push(self.index.replace_all_objects([{"objectID": "two"}]))
responses.push(self.index.replace_all_rules([{
"objectID": "two",
"condition": {"anchoring": "is", "pattern": "pattern"},
"consequence": {
"params": {
"query": {
"edits": [
{"type": "remove", "delete": "pattern"}
]
}
}
}
}
]))
responses.push(self.index.replace_all_synonyms([
{"objectID": "two", "type": "synonym", "synonyms": ["one", "two"]}
]))
responses.wait()
# Check that record with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_object('one')
# Check that record with objectID=`two` does exist
self.assertEqual(self.index.get_object('two')['objectID'], 'two')
# Check that rule with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_rule('one')
# Check that rule with objectID=`two` does exist
self.assertEqual(self.index.get_rule('two')['objectID'], 'two')
# Check that synonym with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_synonym('one')
# Check that synonym with objectID="two" does exist using getSynonym
self.assertEqual(self.index.get_synonym('two')['objectID'], 'two')
def test_batching(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"objectID": "one", "key": "value"},
{"objectID": "two", "key": "value"},
{"objectID": "three", "key": "value"},
{"objectID": "four", "key": "value"},
{"objectID": "five", "key": "value"},
]))
responses.push(self.index.batch([
{
"action": "addObject",
"body": {"objectID": "zero", "key": "value"}
},
{
"action": "updateObject",
"body": {"objectID": "one", "k": "v"}
},
{
"action": "partialUpdateObject",
"body": {"objectID": "two", "k": "v"}
},
{
"action": "partialUpdateObject",
"body": {"objectID": "two_bis", "key": "value"}
},
{
"action": "partialUpdateObjectNoCreate",
"body": {"objectID": "three", "k": "v"}
},
{
"action": "deleteObject",
"body": {"objectID": "four"}
}
]))
responses.wait()
objects = [
{"objectID": "zero", "key": "value"},
{"objectID": "one", "k": "v"},
{"objectID": "two", "key": "value", "k": "v"},
{"objectID": "two_bis", "key": "value"},
{"objectID": "three", "key": "value", "k": "v"},
{"objectID": "five", "key": "value"},
]
results = [obj for obj in self.index.browse_objects()]
for obj in objects:
self.assertIn(obj, results)
def test_batching(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"objectID": "one", "key": "value"},
{"objectID": "two", "key": "value"},
{"objectID": "three", "key": "value"},
{"objectID": "four", "key": "value"},
{"objectID": "five", "key": "value"},
]))
responses.push(self.index.batch([
{
"action": "addObject",
"body": {"objectID": "zero", "key": "value"}
},
{
"action": "updateObject",
"body": {"objectID": "one", "k": "v"}
},
{
"action": "partialUpdateObject",
"body": {"objectID": "two", "k": "v"}
},
{
"action": "partialUpdateObject",
"body": {"objectID": "two_bis", "key": "value"}
},
{
"action": "partialUpdateObjectNoCreate",
"body": {"objectID": "three", "k": "v"}
},
{
"action": "deleteObject",
"body": {"objectID": "four"}
}
]))
responses.wait()
objects = [
{"objectID": "zero", "key": "value"},
{"objectID": "one", "k": "v"},
{"objectID": "two", "key": "value", "k": "v"},
{"objectID": "two_bis", "key": "value"},
{"objectID": "three", "key": "value", "k": "v"},
{"objectID": "five", "key": "value"},
]
results = [obj for obj in self.index.browse_objects()]
for obj in objects:
self.assertIn(obj, results)
def test_replacing(self):
responses = MultipleResponse()
responses.push(self.index.save_object({"objectID": "one"}))
responses.push(self.index.save_rule(F.rule(object_id="one")))
responses.push(self.index.save_synonym(
{"objectID": "one", "type": "synonym", "synonyms": ["one", "two"]}
))
responses.wait()
responses.push(self.index.replace_all_objects([{"objectID": "two"}]))
responses.push(self.index.replace_all_rules([{
"objectID": "two",
"condition": {"anchoring": "is", "pattern": "pattern"},
"consequence": {
"params": {
"query": {
"edits": [
{"type": "remove", "delete": "pattern"}
]
}
}
}
}
]))
responses.push(self.index.replace_all_synonyms([
{"objectID": "two", "type": "synonym", "synonyms": ["one", "two"]}
]))
responses.wait()
# Check that record with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_object('one')
# Check that record with objectID=`two` does exist
self.assertEqual(self.index.get_object('two')['objectID'], 'two')
# Check that rule with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_rule('one')
# Check that rule with objectID=`two` does exist
self.assertEqual(self.index.get_rule('two')['objectID'], 'two')
# Check that synonym with objectID=`one` does not exist
with self.assertRaises(RequestException) as _:
self.index.get_synonym('one')
# Check that synonym with objectID="two" does exist using getSynonym
self.assertEqual(self.index.get_synonym('two')['objectID'], 'two')
def replace_all_objects(self, objects, request_options=None):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) and "safe" in request_options:
safe = request_options.pop("safe")
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
responses.push(
self.copy_to(tmp_index_name, {"scope": ["settings", "synonyms", "rules"]})
)
if safe:
responses.wait()
try:
from algoliasearch.search_client import SearchClient
except ImportError: # Already imported.
pass
tmp_client = SearchClient(self._transporter, self._config)
tmp_index = tmp_client.init_index(tmp_index_name)
responses.push(tmp_index.save_objects(objects, request_options))
if safe:
responses.wait()
responses.push(tmp_index.move_to(self._name))
if safe:
responses.wait()
return responses
def replace_all_objects(self, objects, request_options=None):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) \
and 'safe' in request_options:
safe = request_options.pop('safe')
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
responses.push(self.copy_to(tmp_index_name, {
'scope': ['settings', 'synonyms', 'rules']
}))
if safe:
responses.wait()
tmp_index = copy.copy(self)
tmp_index._name = tmp_index_name
responses.push(tmp_index.save_objects(objects, request_options))
if safe:
responses.wait()
responses.push(tmp_index.move_to(self._name))
if safe:
responses.wait()
return responses
def replace_all_objects(self, objects, request_options=None):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) \
and 'safe' in request_options:
safe = request_options.pop('safe')
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
responses.push(self.copy_to(tmp_index_name, {
'scope': ['settings', 'synonyms', 'rules']
}))
if safe:
responses.wait()
tmp_index = copy.copy(self)
tmp_index._name = tmp_index_name
responses.push(tmp_index.save_objects(objects, request_options))
if safe:
responses.wait()
responses.push(tmp_index.move_to(self._name))
if safe:
responses.wait()
return responses
def replace_all_objects_async(self, objects, # type: ignore
request_options=None):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) \
and 'safe' in request_options:
safe = request_options.pop('safe')
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
response = yield from self.copy_to_async( # type: ignore
tmp_index_name,
{
'scope': ['settings',
'synonyms',
'rules']
})
responses.push(response)
if safe:
responses.wait()
tmp_index = SearchIndexAsync(
self._search_index,
self._transporter_async,
self._config,
tmp_index_name
)
response = yield from tmp_index.save_objects_async( # type: ignore
objects,
request_options
)
responses.push(response)
if safe:
responses.wait()
response = yield from tmp_index.move_to_async( # type: ignore
self._name)
responses.push(response)
if safe:
responses.wait()
return responses
def replace_all_objects_async(self, objects, # type: ignore
request_options=None):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) \
and 'safe' in request_options:
safe = request_options.pop('safe')
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
response = yield from self.copy_to_async( # type: ignore
tmp_index_name,
{
'scope': ['settings',
'synonyms',
'rules']
})
responses.push(response)
if safe:
responses.wait()
tmp_index = SearchIndexAsync(
self._search_index,
self._transporter_async,
self._config,
tmp_index_name
)
response = yield from tmp_index.save_objects_async( # type: ignore
objects,
request_options
)
responses.push(response)
if safe:
responses.wait()
response = yield from tmp_index.move_to_async( # type: ignore
self._name)
responses.push(response)
if safe:
responses.wait()
return responses
def replace_all_objects_async( # type: ignore
self,
objects,
request_options=None,
):
# type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501
safe = False
if isinstance(request_options, dict) and "safe" in request_options:
safe = request_options.pop("safe")
tmp_index_name = self._create_temporary_name()
responses = MultipleResponse()
response = yield from self.copy_to_async( # type: ignore
tmp_index_name, {"scope": ["settings", "synonyms", "rules"]})
responses.push(response)
if safe:
responses.wait()
tmp_client = SearchClient(self._transporter, self._config)
tmp_index = SearchIndexAsync(
tmp_client.init_index(tmp_index_name),
self._transporter_async,
self._config,
tmp_index_name,
)
response = yield from tmp_index.save_objects_async( # type: ignore
objects, request_options)
responses.push(response)
if safe:
responses.wait()
response = yield from tmp_index.move_to_async( # type: ignore
self._name)
responses.push(response)
if safe:
responses.wait()
return responses
def test_copy_move_index(self):
objects = [
{"objectID": "one", "company": "apple"},
{"objectID": "two", "company": "algolia"},
]
responses = MultipleResponse(
[
self.index.save_objects(objects),
self.index.set_settings({"attributesForFaceting": ["company"]}),
self.index.save_synonym(
{
"objectID": "google_placeholder",
"type": "placeholder",
"placeholder": "<GOOG>",
"replacements": ["Google", "GOOG"],
}
),
self.index.save_rule(
{
"objectID": "company_auto_faceting",
"condition": {
"anchoring": "contains",
"pattern": "{facet:company}",
},
"consequence": {
"params": {"automaticFacetFilters": ["company"]}
},
}
),
]
).wait()
index2 = F.index(
self.client, "{}_settings".format(self._testMethodName)
) # noqa: E501
responses.push(self.client.copy_settings(self.index.name, index2.name))
index3 = F.index(
self.client, "{}_rules".format(self._testMethodName)
) # noqa: E501
responses.push(self.client.copy_rules(self.index.name, index3.name))
index4 = F.index(
self.client, "{}_synonyms".format(self._testMethodName)
) # noqa: E501
responses.push(self.client.copy_synonyms(self.index.name, index4.name))
index5 = F.index(
self.client, "{}_full_copy".format(self._testMethodName)
) # noqa: E501
responses.push(self.client.copy_index(self.index.name, index5.name))
responses.wait()
self.assertEqual(index2.get_settings()["attributesForFaceting"], ["company"])
index3.get_rule("company_auto_faceting")
with self.assertRaises(RequestException) as cm:
index3.get_synonym("google_placeholder")
index4.get_synonym("google_placeholder")
with self.assertRaises(RequestException) as cm:
index4.get_rule("company_auto_faceting")
index5.get_synonym("google_placeholder")
index5.get_rule("company_auto_faceting")
self.assertEqual(index5.get_settings()["attributesForFaceting"], ["company"])
for obj in index5.browse_objects():
self.assertIn(obj, objects)
index6 = F.index(
self.client, "{}_after_move".format(self._testMethodName)
) # noqa: E501
self.client.move_index(self.index.name, index6.name).wait()
index6.get_synonym("google_placeholder")
index6.get_rule("company_auto_faceting")
self.assertEqual(index6.get_settings()["attributesForFaceting"], ["company"])
for obj in index6.browse_objects():
self.assertIn(obj, objects)
with self.assertRaises(RequestException) as cm:
self.client.init_index(self.index.name).search("")
self.assertEqual(cm.exception.status_code, 404)
def test_rules(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"objectID": "iphone_7", "brand": "Apple", "model": "7"},
{"objectID": "iphone_8", "brand": "Apple", "model": "8"},
{"objectID": "iphone_x", "brand": "Apple", "model": "X"},
{"objectID": "one_plus_one", "brand": "OnePlus",
"model": "One"},
{"objectID": "one_plus_two", "brand": "OnePlus",
"model": "Two"},
]))
responses.push(self.index.set_settings({
'attributesForFaceting': ['brand']
}))
rule1 = {
"objectID": "brand_automatic_faceting",
"enabled": False,
"condition": {"anchoring": "is", "pattern": "{facet:brand}"},
"consequence": {
"params": {
"automaticFacetFilters": [
{"facet": "brand", "disjunctive": True, "score": 42},
]
}
},
"validity": [
{
"from": 1532439300,
"until": 1532525700
},
{
"from": 1532612100,
"until": 1532698500
}
],
"description": "Automatic apply the faceting on `brand` if a"
}
responses.push(self.index.save_rule(rule1))
rule2 = {
"objectID": "query_edits",
"condition": {"anchoring": "is", "pattern": "mobile phone"},
"consequence": {
"params": {
"query": {
"edits": [
{"type": "remove", "delete": "mobile"},
{"type": "replace", "delete": "phone",
"insert": "iphone"},
]
}
}
}
}
responses.push(self.index.save_rules([rule2]))
responses.wait()
self.assertEqual(self.index.get_rule(rule1['objectID']),
rule1)
self.assertEqual(self.index.get_rule(rule2['objectID']),
rule2)
self.assertEqual(self.index.search_rules('')['nbHits'], 2)
# Browse all records with browse_rules
results = []
for obj in self.index.browse_rules():
results.append(obj)
rules = [
rule1,
rule2,
]
for rule in rules:
self.assertIn(rule, results)
self.index.delete_rule(rule1['objectID']).wait()
# Try to get the first rule with get_rule and check
# that the rule does not exist anymore
with self.assertRaises(RequestException) as _:
self.index.get_rule(rule1['objectID'])
# Clear all the rules using clear_rules
self.index.clear_rules().wait()
# Perform a rule search using search_rule with an empty query
# and check that the number of returned nbHits is equal to 0
self.assertEqual(self.index.search_rules('')['nbHits'], 0)
def test_rules(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"objectID": "iphone_7", "brand": "Apple", "model": "7"},
{"objectID": "iphone_8", "brand": "Apple", "model": "8"},
{"objectID": "iphone_x", "brand": "Apple", "model": "X"},
{"objectID": "one_plus_one", "brand": "OnePlus",
"model": "One"},
{"objectID": "one_plus_two", "brand": "OnePlus",
"model": "Two"},
]))
responses.push(self.index.set_settings({
'attributesForFaceting': ['brand', 'model']
}))
rule1 = {
"objectID": "brand_automatic_faceting",
"enabled": False,
"condition": {"anchoring": "is", "pattern": "{facet:brand}"},
"consequence": {
"params": {
"automaticFacetFilters": [
{"facet": "brand", "disjunctive": True, "score": 42},
]
}
},
"validity": [
{
"from": 1532439300,
"until": 1532525700
},
{
"from": 1532612100,
"until": 1532698500
}
],
"description": "Automatic apply the faceting on `brand` if a"
}
responses.push(self.index.save_rule(rule1))
rule2 = {
"objectID": "query_edits",
"condition": {
"anchoring": "is",
"pattern": "mobile phone",
"alternatives": True
},
"consequence": {
"params": {
"query": {
"edits": [
{"type": "remove", "delete": "mobile"},
{"type": "replace", "delete": "phone",
"insert": "iphone"},
]
}
}
}
}
rule3 = {
"objectID": "query_promo",
"consequence": {
"params": {
"filters": "brand:OnePlus"
}
}
}
rule4 = {
"objectID": "query_promo_only_summer",
"condition": {
"context": "summer"
},
"consequence": {
"params": {
"filters": "model:One"
}
}
}
responses.push(self.index.save_rules([rule2, rule3, rule4]))
responses.wait()
# Should be only the One Plus model One
self.assertEqual(self.index.search('', {
'ruleContexts': ['summer']
})['nbHits'], 1);
self.assertEqual(self.index.get_rule(rule1['objectID']),
rule1)
self.assertEqual(self.index.get_rule(rule2['objectID']),
rule2)
self.assertEqual(self.index.get_rule(rule3['objectID']),
rule3)
self.assertEqual(self.index.get_rule(rule4['objectID']),
rule4)
self.assertEqual(self.index.search_rules('')['nbHits'], 4)
# Browse all records with browse_rules
results = []
for obj in self.index.browse_rules():
results.append(obj)
rules = [
rule1,
rule2,
rule3,
rule4
]
for rule in rules:
self.assertIn(rule, results)
self.index.delete_rule(rule1['objectID']).wait()
# Try to get the first rule with get_rule and check
# that the rule does not exist anymore
with self.assertRaises(RequestException) as _:
self.index.get_rule(rule1['objectID'])
# Clear all the rules using clear_rules
self.index.clear_rules().wait()
# Perform a rule search using search_rule with an empty query
# and check that the number of returned nbHits is equal to 0
self.assertEqual(self.index.search_rules('')['nbHits'], 0)
def test_synonyms(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"console": "Sony PlayStation <PLAYSTATIONVERSION>"},
{"console": "Nintendo Switch"},
{"console": "Nintendo Wii U"},
{"console": "Nintendo Game Boy Advance"},
{"console": "Microsoft Xbox"},
{"console": "Microsoft Xbox 360"},
{"console": "Microsoft Xbox One"}
], {'autoGenerateObjectIDIfNotExist': True}))
responses.push(self.index.save_synonym(F.synonym({
'synonyms': [
"gba",
"gameboy advance",
"game boy advance"
]
}, 'gba')))
synonym1 = {
'objectID': 'wii_to_wii_u',
'type': 'onewaysynonym',
'input': 'wii',
'synonyms': ['wii U']
}
synonym2 = {
'objectID': 'playstation_version_placeholder',
'type': 'placeholder',
'placeholder': '<PLAYSTATIONVERSION>',
'replacements': [
"1",
"One",
"2",
"3",
"4",
"4 Pro",
]
}
synonym3 = {
'objectID': 'ps4',
'type': 'altcorrection1',
'word': 'ps4',
'corrections': ['playstation4']
}
synonym4 = {
'objectID': 'psone',
'type': 'altcorrection2',
'word': 'psone',
'corrections': ['playstationone']
}
responses.push(self.index.save_synonyms([
synonym1,
synonym2,
synonym3,
synonym4
]))
responses.wait()
self.assertEqual(self.index.get_synonym(synonym1['objectID']),
synonym1)
self.assertEqual(self.index.get_synonym(synonym2['objectID']),
synonym2)
self.assertEqual(self.index.get_synonym(synonym3['objectID']),
synonym3)
self.assertEqual(self.index.get_synonym(synonym4['objectID']),
synonym4)
self.assertEqual(self.index.search_synonyms('')['nbHits'], 5)
# Browse all records with browse_objects
results = []
for obj in self.index.browse_synonyms():
results.append(obj)
synonyms = [
synonym1,
synonym2,
synonym3,
synonym4
]
for synonym in synonyms:
self.assertIn(synonym, results)
self.index.delete_synonym('gba').wait()
# Try to get the synonym with getSynonym with objectID `gba and c
# heck that the synonym does not exist anymore
with self.assertRaises(RequestException) as _:
self.index.get_synonym('gba')
# Clear all the synonyms using clear_synonyms
self.index.clear_synonyms().wait()
# Perform a synonym search using searchSynonyms with an empty query
# and check that the number of returned synonyms is equal to 0
self.assertEqual(self.index.search_synonyms('')['nbHits'], 0)
def test_search(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"company": "Algolia", "name": "Julien Lemoine",
"objectID": "julien-lemoine"}, # noqa: E501
{"company": "Algolia", "name": "Nicolas Dessaigne",
"objectID": "nicolas-dessaigne"}, # noqa: E501
{"company": "Amazon", "name": "Jeff Bezos"},
{"company": "Apple", "name": "Steve Jobs"},
{"company": "Apple", "name": "Steve Wozniak"},
{"company": "Arista Networks", "name": "Jayshree Ullal"},
{"company": "Google", "name": "Larry Page"},
{"company": "Google", "name": "Rob Pike"},
{"company": "Google", "name": "Serguey Brin"},
{"company": "Microsoft", "name": "Bill Gates"},
{"company": "SpaceX", "name": "Elon Musk"},
{"company": "Tesla", "name": "Elon Musk"},
{"company": "Yahoo", "name": "Marissa Mayer"}
], {'autoGenerateObjectIDIfNotExist': True}))
responses.push(self.index.set_settings({
'attributesForFaceting': ["searchable(company)"]
}))
responses.wait()
# Perform a search query using search with the query `algolia` and no
# parameter and check that the number of returned hits is equal to 2
result = self.index.search('algolia')
self.assertEqual(result['nbHits'], 2)
self.assertEqual(SearchIndex.get_object_position(
result, 'nicolas-dessaigne'), 0
)
self.assertEqual(SearchIndex.get_object_position(
result, 'julien-lemoine'), 1
)
self.assertEqual(SearchIndex.get_object_position(result, ''), -1)
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(lambda _: False)
# Call find_object with the following parameters and check that
# the first object is returned with a `position=0` and `page=0`
found = self.index.find_object(lambda _: True)
self.assertEqual(found['position'], 0)
self.assertEqual(found['page'], 0)
def callback(obj):
# type: (dict) -> bool
return obj.get('company') == 'Apple'
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(callback, {
'query': 'algolia'
})
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(callback, {
'query': '',
'paginate': False,
'hitsPerPage': 5
})
# Call find_object with the following parameters and check that
# the first object is returned with a `position=0` and `page=2`
found = self.index.find_object(callback, {
'query': '',
'paginate': True,
'hitsPerPage': 5
})
self.assertEqual(found['position'], 0)
self.assertEqual(found['page'], 2)
# Perform a search using search with the query `elon` and the
# following parameter and check that the queryID field from
# the response is not empty
result = self.index.search('elon', {'clickAnalytics': True})
self.assertIn('queryID', result)
# Perform a faceted search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 1
result = self.index.search('elon', {
'facets': '*',
'facetFilters': 'company:tesla'
})
self.assertEqual(result['nbHits'], 1)
# Perform a filtered search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 2
result = self.index.search('elon', {
'facets': '*',
'filters': '(company:tesla OR company:spacex)'
})
self.assertEqual(result['nbHits'], 2)
result = self.index.search_for_facet_values('company', 'a')[
'facetHits']
values = list(
map(lambda facet: facet['value'], result))
self.assertIn('Algolia', values)
self.assertIn('Amazon', values)
self.assertIn('Apple', values)
self.assertIn('Arista Networks', values)
def test_search(self):
responses = MultipleResponse()
responses.push(
self.index.save_objects(
[
{
"company": "Algolia",
"name": "Julien Lemoine",
"objectID": "julien-lemoine",
}, # noqa: E501
{
"company": "Algolia",
"name": "Nicolas Dessaigne",
"objectID": "nicolas-dessaigne",
}, # noqa: E501
{
"company": "Amazon",
"name": "Jeff Bezos"
},
{
"company": "Apple",
"name": "Steve Jobs"
},
{
"company": "Apple",
"name": "Steve Wozniak"
},
{
"company": "Arista Networks",
"name": "Jayshree Ullal"
},
{
"company": "Google",
"name": "Larry Page"
},
{
"company": "Google",
"name": "Rob Pike"
},
{
"company": "Google",
"name": "Serguey Brin"
},
{
"company": "Microsoft",
"name": "Bill Gates"
},
{
"company": "SpaceX",
"name": "Elon Musk"
},
{
"company": "Tesla",
"name": "Elon Musk"
},
{
"company": "Yahoo",
"name": "Marissa Mayer"
},
],
{"autoGenerateObjectIDIfNotExist": True},
))
responses.push(
self.index.set_settings(
{"attributesForFaceting": ["searchable(company)"]}))
responses.wait()
# Perform a search query using search with the query `algolia` and no
# parameter and check that the number of returned hits is equal to 2
result = self.index.search("algolia")
self.assertEqual(result["nbHits"], 2)
self.assertEqual(
SearchIndex.get_object_position(result, "nicolas-dessaigne"), 0)
self.assertEqual(
SearchIndex.get_object_position(result, "julien-lemoine"), 1)
self.assertEqual(SearchIndex.get_object_position(result, ""), -1)
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(lambda _: False)
# Call find_object with the following parameters and check that
# the first object is returned with a `position=0` and `page=0`
found = self.index.find_object(lambda _: True)
self.assertEqual(found["position"], 0)
self.assertEqual(found["page"], 0)
def callback(obj):
# type: (dict) -> bool
return obj.get("company") == "Apple"
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(callback, {"query": "algolia"})
# Call find_object with the following parameters and check that
# no object is found
with self.assertRaises(ObjectNotFoundException):
self.index.find_object(callback, {
"query": "",
"paginate": False,
"hitsPerPage": 5
})
# Call find_object with the following parameters and check that
# the first object is returned with a `position=0` and `page=2`
found = self.index.find_object(callback, {
"query": "",
"paginate": True,
"hitsPerPage": 5
})
self.assertEqual(found["position"], 0)
self.assertEqual(found["page"], 2)
# Perform a search using search with the query `elon` and the
# following parameter and check that the queryID field from
# the response is not empty
result = self.index.search("elon", {"clickAnalytics": True})
self.assertIn("queryID", result)
# Perform a faceted search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 1
result = self.index.search("elon", {
"facets": "*",
"facetFilters": "company:tesla"
})
self.assertEqual(result["nbHits"], 1)
# Perform a filtered search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 2
result = self.index.search(
"elon", {
"facets": "*",
"filters": "(company:tesla OR company:spacex)"
})
self.assertEqual(result["nbHits"], 2)
result = self.index.search_for_facet_values("company",
"a")["facetHits"]
values = list(map(lambda facet: facet["value"], result))
self.assertIn("Algolia", values)
self.assertIn("Amazon", values)
self.assertIn("Apple", values)
self.assertIn("Arista Networks", values)
def test_synonyms(self):
responses = MultipleResponse()
responses.push(
self.index.save_objects(
[
{
"console": "Sony PlayStation <PLAYSTATIONVERSION>"
},
{
"console": "Nintendo Switch"
},
{
"console": "Nintendo Wii U"
},
{
"console": "Nintendo Game Boy Advance"
},
{
"console": "Microsoft Xbox"
},
{
"console": "Microsoft Xbox 360"
},
{
"console": "Microsoft Xbox One"
},
],
{"autoGenerateObjectIDIfNotExist": True},
))
responses.push(
self.index.save_synonym(
F.synonym(
{
"synonyms":
["gba", "gameboy advance", "game boy advance"]
}, "gba")))
synonym1 = {
"objectID": "wii_to_wii_u",
"type": "onewaysynonym",
"input": "wii",
"synonyms": ["wii U"],
}
synonym2 = {
"objectID": "playstation_version_placeholder",
"type": "placeholder",
"placeholder": "<PLAYSTATIONVERSION>",
"replacements": ["1", "One", "2", "3", "4", "4 Pro"],
}
synonym3 = {
"objectID": "ps4",
"type": "altcorrection1",
"word": "ps4",
"corrections": ["playstation4"],
}
synonym4 = {
"objectID": "psone",
"type": "altcorrection2",
"word": "psone",
"corrections": ["playstationone"],
}
responses.push(
self.index.save_synonyms([synonym1, synonym2, synonym3, synonym4]))
responses.wait()
self.assertEqual(self.index.get_synonym(synonym1["objectID"]),
synonym1)
self.assertEqual(self.index.get_synonym(synonym2["objectID"]),
synonym2)
self.assertEqual(self.index.get_synonym(synonym3["objectID"]),
synonym3)
self.assertEqual(self.index.get_synonym(synonym4["objectID"]),
synonym4)
self.assertEqual(self.index.search_synonyms("")["nbHits"], 5)
# Browse all records with browse_objects
results = []
for obj in self.index.browse_synonyms():
results.append(obj)
synonyms = [synonym1, synonym2, synonym3, synonym4]
for synonym in synonyms:
self.assertIn(synonym, results)
self.index.delete_synonym("gba").wait()
# Try to get the synonym with getSynonym with objectID `gba and c
# heck that the synonym does not exist anymore
with self.assertRaises(RequestException) as _:
self.index.get_synonym("gba")
# Clear all the synonyms using clear_synonyms
self.index.clear_synonyms().wait()
# Perform a synonym search using searchSynonyms with an empty query
# and check that the number of returned synonyms is equal to 0
self.assertEqual(self.index.search_synonyms("")["nbHits"], 0)
def test_copy_move_index(self):
objects = [
{'objectID': 'one', 'company': 'apple'},
{'objectID': 'two', 'company': 'algolia'}
]
responses = MultipleResponse([
self.index.save_objects(objects),
self.index.set_settings({'attributesForFaceting': ['company']}),
self.index.save_synonym({
'objectID': 'google_placeholder',
'type': 'placeholder',
'placeholder': '<GOOG>',
'replacements': ['Google', 'GOOG']
}),
self.index.save_rule({
"objectID": "company_auto_faceting",
"condition": {
"anchoring": "contains",
"pattern": "{facet:company}",
},
"consequence": {
"params": {"automaticFacetFilters": ["company"]}
}
})
]).wait()
self.index2 = F.index('{}_settings'.format(self._testMethodName))
responses.push(self.client.copy_settings(
self.index.name, self.index2.name
))
self.index3 = F.index('{}_rules'.format(self._testMethodName))
responses.push(self.client.copy_rules(
self.index.name, self.index3.name
))
self.index4 = F.index('{}_synonyms'.format(self._testMethodName))
responses.push(self.client.copy_synonyms(
self.index.name, self.index4.name
))
self.index5 = F.index('{}_full_copy'.format(self._testMethodName))
responses.push(self.client.copy_index(
self.index.name, self.index5.name
))
responses.wait()
self.assertEqual(
self.index2.get_settings()['attributesForFaceting'], ['company']
)
self.index3.get_rule('company_auto_faceting')
with self.assertRaises(RequestException) as cm:
self.index3.get_synonym('google_placeholder')
self.index4.get_synonym('google_placeholder')
with self.assertRaises(RequestException) as cm:
self.index4.get_rule('company_auto_faceting')
self.index5.get_synonym('google_placeholder')
self.index5.get_rule('company_auto_faceting')
self.assertEqual(
self.index5.get_settings()['attributesForFaceting'], ['company']
)
for obj in self.index5.browse_objects():
self.assertIn(obj, objects)
self.index6 = F.index('{}_after_move'.format(self._testMethodName))
self.client.move_index(
self.index.name,
self.index6.name
).wait()
self.index6.get_synonym('google_placeholder')
self.index6.get_rule('company_auto_faceting')
self.assertEqual(
self.index6.get_settings()['attributesForFaceting'], ['company']
)
for obj in self.index6.browse_objects():
self.assertIn(obj, objects)
with self.assertRaises(RequestException) as cm:
self.client.init_index(self.index.name).search('')
self.assertEqual(cm.exception.status_code, 404)
def test_synonyms(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"console": "Sony PlayStation <PLAYSTATIONVERSION>"},
{"console": "Nintendo Switch"},
{"console": "Nintendo Wii U"},
{"console": "Nintendo Game Boy Advance"},
{"console": "Microsoft Xbox"},
{"console": "Microsoft Xbox 360"},
{"console": "Microsoft Xbox One"}
], {'autoGenerateObjectIDIfNotExist': True}))
responses.push(self.index.save_synonym(F.synonym({
'synonyms': [
"gba",
"gameboy advance",
"game boy advance"
]
}, 'gba')))
synonym1 = {
'objectID': 'wii_to_wii_u',
'type': 'onewaysynonym',
'input': 'wii',
'synonyms': ['wii U']
}
synonym2 = {
'objectID': 'playstation_version_placeholder',
'type': 'placeholder',
'placeholder': '<PLAYSTATIONVERSION>',
'replacements': [
"1",
"One",
"2",
"3",
"4",
"4 Pro",
]
}
synonym3 = {
'objectID': 'ps4',
'type': 'altcorrection1',
'word': 'ps4',
'corrections': ['playstation4']
}
synonym4 = {
'objectID': 'psone',
'type': 'altcorrection2',
'word': 'psone',
'corrections': ['playstationone']
}
responses.push(self.index.save_synonyms([
synonym1,
synonym2,
synonym3,
synonym4
]))
responses.wait()
self.assertEqual(self.index.get_synonym(synonym1['objectID']),
synonym1)
self.assertEqual(self.index.get_synonym(synonym2['objectID']),
synonym2)
self.assertEqual(self.index.get_synonym(synonym3['objectID']),
synonym3)
self.assertEqual(self.index.get_synonym(synonym4['objectID']),
synonym4)
self.assertEqual(self.index.search_synonyms('')['nbHits'], 5)
# Browse all records with browse_objects
results = []
for obj in self.index.browse_synonyms():
results.append(obj)
synonyms = [
synonym1,
synonym2,
synonym3,
synonym4
]
for synonym in synonyms:
self.assertIn(synonym, results)
self.index.delete_synonym('gba').wait()
# Try to get the synonym with getSynonym with objectID `gba and c
# heck that the synonym does not exist anymore
with self.assertRaises(RequestException) as _:
self.index.get_synonym('gba')
# Clear all the synonyms using clear_synonyms
self.index.clear_synonyms().wait()
# Perform a synonym search using searchSynonyms with an empty query
# and check that the number of returned synonyms is equal to 0
self.assertEqual(self.index.search_synonyms('')['nbHits'], 0)
def test_search(self):
responses = MultipleResponse()
responses.push(
self.index.save_objects([{
"company": "Algolia",
"name": "Julien Lemoine"
}, {
"company": "Algolia",
"name": "Nicolas Dessaigne"
}, {
"company": "Amazon",
"name": "Jeff Bezos"
}, {
"company": "Apple",
"name": "Steve Jobs"
}, {
"company": "Apple",
"name": "Steve Wozniak"
}, {
"company": "Arista Networks",
"name": "Jayshree Ullal"
}, {
"company": "Google",
"name": "Larry Page"
}, {
"company": "Google",
"name": "Rob Pike"
}, {
"company": "Google",
"name": "Serguey Brin"
}, {
"company": "Microsoft",
"name": "Bill Gates"
}, {
"company": "SpaceX",
"name": "Elon Musk"
}, {
"company": "Tesla",
"name": "Elon Musk"
}, {
"company": "Yahoo",
"name": "Marissa Mayer"
}], {'autoGenerateObjectIDIfNotExist': True}))
responses.push(
self.index.set_settings(
{'attributesForFaceting': ["searchable(company)"]}))
responses.wait()
# Perform a search query using search with the query `algolia` and no
# parameter and check that the number of returned hits is equal to 2
result = self.index.search('algolia')
self.assertEqual(result['nbHits'], 2)
# Perform a search using search with the query `elon` and the
# following parameter and check that the queryID field from
# the response is not empty
result = self.index.search('elon', {'clickAnalytics': True})
self.assertIn('queryID', result)
# Perform a faceted search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 1
result = self.index.search('elon', {
'facets': '*',
'facetFilters': 'company:tesla'
})
self.assertEqual(result['nbHits'], 1)
# Perform a filtered search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 2
result = self.index.search(
'elon', {
'facets': '*',
'filters': '(company:tesla OR company:spacex)'
})
self.assertEqual(result['nbHits'], 2)
result = self.index.search_for_facet_values('company',
'a')['facetHits']
values = list(map(lambda facet: facet['value'], result))
self.assertIn('Algolia', values)
self.assertIn('Amazon', values)
self.assertIn('Apple', values)
self.assertIn('Arista Networks', values)
def test_copy_move_index(self):
objects = [{
'objectID': 'one',
'company': 'apple'
}, {
'objectID': 'two',
'company': 'algolia'
}]
responses = MultipleResponse([
self.index.save_objects(objects),
self.index.set_settings({'attributesForFaceting': ['company']}),
self.index.save_synonym({
'objectID': 'google_placeholder',
'type': 'placeholder',
'placeholder': '<GOOG>',
'replacements': ['Google', 'GOOG']
}),
self.index.save_rule({
"objectID": "company_auto_faceting",
"condition": {
"anchoring": "contains",
"pattern": "{facet:company}",
},
"consequence": {
"params": {
"automaticFacetFilters": ["company"]
}
}
})
]).wait()
self.index2 = F.index('{}_settings'.format(self._testMethodName))
responses.push(
self.client.copy_settings(self.index.name, self.index2.name))
self.index3 = F.index('{}_rules'.format(self._testMethodName))
responses.push(
self.client.copy_rules(self.index.name, self.index3.name))
self.index4 = F.index('{}_synonyms'.format(self._testMethodName))
responses.push(
self.client.copy_synonyms(self.index.name, self.index4.name))
self.index5 = F.index('{}_full_copy'.format(self._testMethodName))
responses.push(
self.client.copy_index(self.index.name, self.index5.name))
responses.wait()
self.assertEqual(self.index2.get_settings()['attributesForFaceting'],
['company'])
self.index3.get_rule('company_auto_faceting')
with self.assertRaises(RequestException) as cm:
self.index3.get_synonym('google_placeholder')
self.index4.get_synonym('google_placeholder')
with self.assertRaises(RequestException) as cm:
self.index4.get_rule('company_auto_faceting')
self.index5.get_synonym('google_placeholder')
self.index5.get_rule('company_auto_faceting')
self.assertEqual(self.index5.get_settings()['attributesForFaceting'],
['company'])
for obj in self.index5.browse_objects():
self.assertIn(obj, objects)
self.index6 = F.index('{}_after_move'.format(self._testMethodName))
self.client.move_index(self.index.name, self.index6.name).wait()
self.index6.get_synonym('google_placeholder')
self.index6.get_rule('company_auto_faceting')
self.assertEqual(self.index6.get_settings()['attributesForFaceting'],
['company'])
for obj in self.index6.browse_objects():
self.assertIn(obj, objects)
with self.assertRaises(RequestException) as cm:
self.client.init_index(self.index.name).search('')
self.assertEqual(cm.exception.status_code, 404)
def test_search(self):
responses = MultipleResponse()
responses.push(self.index.save_objects([
{"company": "Algolia", "name": "Julien Lemoine"},
{"company": "Algolia", "name": "Nicolas Dessaigne"},
{"company": "Amazon", "name": "Jeff Bezos"},
{"company": "Apple", "name": "Steve Jobs"},
{"company": "Apple", "name": "Steve Wozniak"},
{"company": "Arista Networks", "name": "Jayshree Ullal"},
{"company": "Google", "name": "Larry Page"},
{"company": "Google", "name": "Rob Pike"},
{"company": "Google", "name": "Serguey Brin"},
{"company": "Microsoft", "name": "Bill Gates"},
{"company": "SpaceX", "name": "Elon Musk"},
{"company": "Tesla", "name": "Elon Musk"},
{"company": "Yahoo", "name": "Marissa Mayer"}
], {'autoGenerateObjectIDIfNotExist': True}))
responses.push(self.index.set_settings({
'attributesForFaceting': ["searchable(company)"]
}))
responses.wait()
# Perform a search query using search with the query `algolia` and no
# parameter and check that the number of returned hits is equal to 2
result = self.index.search('algolia')
self.assertEqual(result['nbHits'], 2)
# Perform a search using search with the query `elon` and the
# following parameter and check that the queryID field from
# the response is not empty
result = self.index.search('elon', {'clickAnalytics': True})
self.assertIn('queryID', result)
# Perform a faceted search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 1
result = self.index.search('elon', {
'facets': '*',
'facetFilters': 'company:tesla'
})
self.assertEqual(result['nbHits'], 1)
# Perform a filtered search using search with the query `elon` and the
# following parameters and check that the number of returned hits is
# equal to 2
result = self.index.search('elon', {
'facets': '*',
'filters': '(company:tesla OR company:spacex)'
})
self.assertEqual(result['nbHits'], 2)
result = self.index.search_for_facet_values('company', 'a')[
'facetHits']
values = list(
map(lambda facet: facet['value'], result))
self.assertIn('Algolia', values)
self.assertIn('Amazon', values)
self.assertIn('Apple', values)
self.assertIn('Arista Networks', values)