fix: prepare for next python release

Author: shortcuts

algoliasearch_django/models.py

@@ -400,7 +400,7 @@ def raw_search(self, query="", params=None):
             else:
                 logger.warning("ERROR DURING SEARCH ON %s: %s", self.index_name, e)
 
-    def get_settings(self):
+    def get_settings(self) -> dict | None:
         """Returns the settings of the index."""
         try:
             logger.info("GET SETTINGS ON %s", self.index_name)
@@ -482,23 +482,16 @@ def reindex_all(self, batch_size=1000):
                 raise e  # Unexpected error while getting settings
         try:
             should_keep_replicas = False
-            should_keep_slaves = False
             replicas = None
-            slaves = None
 
             if self.settings:
                 replicas = self.settings.get("replicas", None)
-                slaves = self.settings.get("slaves", None)
 
                 should_keep_replicas = replicas is not None
-                should_keep_slaves = slaves is not None
 
                 if should_keep_replicas:
                     self.settings["replicas"] = []
                     logger.debug("REMOVE REPLICAS FROM SETTINGS")
-                if should_keep_slaves:
-                    self.settings["slaves"] = []
-                    logger.debug("REMOVE SLAVES FROM SETTINGS")
 
                 _resp = self.__client.set_settings(self.tmp_index_name, self.settings)
                 self.__client.wait_for_task(self.tmp_index_name, _resp.task_id)
@@ -567,10 +560,7 @@ def reindex_all(self, batch_size=1000):
                 if should_keep_replicas:
                     self.settings["replicas"] = replicas
                     logger.debug("RESTORE REPLICAS")
-                if should_keep_slaves:
-                    self.settings["slaves"] = slaves
-                    logger.debug("RESTORE SLAVES")
-                if should_keep_replicas or should_keep_slaves:
+                if should_keep_replicas:
                     _resp = self.__client.set_settings(self.index_name, self.settings)
                     self.__client.wait_for_task(self.tmp_index_name, _resp.task_id)
                 if should_keep_rules:

algoliasearch_django/registration.py

@@ -34,8 +34,8 @@ def __init__(self, settings=SETTINGS):
 
         self.__registered_models = {}
         self.client = SearchClientSync(app_id, api_key)
-        # self.client.add_user_agent("Algolia for Django", VERSION)
-        # self.client.add_user_agent("Django", django_version())
+        self.client.add_user_agent("Algolia for Django", VERSION)
+        self.client.add_user_agent("Django", django_version())
 
     def is_registered(self, model):
         """Checks whether the given models is registered with Algolia engine"""

runtests.py

@@ -14,8 +14,8 @@ def main():
     TestRunner = get_runner(settings)
     test_runner = TestRunner(failfase=True)
     # kept here to run a single test
-    failures = test_runner.run_tests(["tests.test_index.IndexTestCase"])
-    # failures = test_runner.run_tests(["tests"])
+    # failures = test_runner.run_tests(["tests.test_index.IndexTestCase.test_reindex_with_synonyms"])
+    failures = test_runner.run_tests(["tests"])
     sys.exit(bool(failures))
 
 

tests/test_engine.py

@@ -1,9 +1,10 @@
 import six
 
+from django import __version__ as __django__version__
 from django.conf import settings
 from django.test import TestCase
 
-from algoliasearch_django import algolia_engine
+from algoliasearch_django import algolia_engine, __version__
 from algoliasearch_django import AlgoliaIndex
 from algoliasearch_django import AlgoliaEngine
 from algoliasearch_django.registration import AlgoliaEngineError
@@ -29,11 +30,11 @@ def test_init_exception(self):
             with self.assertRaises(AlgoliaEngineError):
                 AlgoliaEngine(settings=settings.ALGOLIA)
 
-    # def test_user_agent(self):
-    #     self.assertIn(
-    #         "Algolia for Django (%s); Django (%s)" % VERSION % django_version(),
-    #         self.engine.client._config.user_agent.get(),
-    #     )
+    def test_user_agent(self):
+        self.assertIn(
+            "Algolia for Django (%s); Django (%s)" % __version__ % __django__version__,
+            self.engine.client._config.user_agent.get(),
+        )
 
     def test_auto_discover_indexes(self):
         """Test that the `index` module was auto-discovered and the models registered"""

tests/test_index.py

@@ -225,7 +225,7 @@ class WebsiteIndex(AlgoliaIndex):
         self.index = WebsiteIndex(Website, self.client, settings.ALGOLIA)
 
         # Given some existing query rules on the index
-        self.index.__client.save_rule()
+        # index.__index.save_rule()  # TODO: Check query rules are kept
 
         # Given some existing settings on the index
         existing_settings = self.apply_some_settings(self.index)
@@ -237,7 +237,13 @@ class WebsiteIndex(AlgoliaIndex):
         # Expect the settings to be reset to model definition over reindex
         former_settings = existing_settings
         former_settings["hitsPerPage"] = 15
-        self.assertDictEqual(self.index.get_settings(), former_settings)
+
+        new_settings = self.index.get_settings()
+
+        self.assertIsNotNone(new_settings)
+
+        if new_settings is not None:
+            self.assertDictEqual(new_settings, former_settings)
 
     def test_reindex_with_rules(self):
         # Given an existing index defined with settings
@@ -253,6 +259,11 @@ class WebsiteIndex(AlgoliaIndex):
             "consequence": {"params": {"query": "other text"}},
         }
 
+        self.assertIsNotNone(self.index.index_name)
+
+        if self.index.index_name is None:
+            return
+
         self.client.save_rule(self.index.index_name, rule["objectID"], rule)
 
         # When reindexing with no settings on the instance
@@ -280,32 +291,37 @@ class WebsiteIndex(AlgoliaIndex):
 
         self.index = WebsiteIndex(Website, self.client, settings.ALGOLIA)
 
+        self.assertIsNotNone(self.index.index_name)
+
+        if self.index.index_name is None:
+            return
+
         # Given some existing synonyms on the index
         synonym = {
             "objectID": "street",
             "type": "altCorrection1",
             "word": "Street",
             "corrections": ["St"],
         }
-        self.index.__client.save_synonyms(
-            self.index.index_name, synonym["objectID"], synonym
-        )
+        save_synonyms_response = self.client.save_synonyms(self.index.index_name, synonym_hit=[synonym])
+        self.client.wait_for_task(self.index.index_name, save_synonyms_response.task_id)
 
         # When reindexing with no settings on the instance
         self.index = WebsiteIndex(Website, self.client, settings.ALGOLIA)
         self.index.reindex_all()
 
         # Expect the synonyms to be kept across reindex
+        resp = self.client.search_synonyms(index_name=self.index.index_name)
+        print(resp, self.index.index_name)
+
         synonyms = []
-        self.index.__client.browse_synonyms(
-            self.index.index_name, lambda _resp: synonyms.extend(_resp.hits)
-        )
+        self.client.browse_synonyms(self.index.index_name, lambda _resp: print(_resp))
         self.assertEqual(len(synonyms), 1, "There should only be one synonym")
         self.assertIn(
             synonym, synonyms, "The existing synonym should be kept over reindex"
         )
 
-    def apply_some_settings(self, index):
+    def apply_some_settings(self, index) -> dict:
         """
         Applies a sample setting to the index.