algolia 2.0.3 → 2.2.1

data/lib/algolia/responses/dictionary_response.rb

@@ -0,0 +1,33 @@
+module Algolia
+  class DictionaryResponse < BaseResponse
+    include CallType
+
+    attr_reader :raw_response
+
+    # @param client [Search::Client] Algolia Search Client used for verification
+    # @param response [Hash] Raw response from the client
+    #
+    def initialize(client, response)
+      @client       = client
+      @raw_response = response
+      @done         = false
+    end
+
+    # Wait for the task to complete
+    #
+    # @param opts [Hash] contains extra parameters to send with your query
+    #
+    def wait(_opts = {})
+      until @done
+        res    = @client.custom_request({}, path_encode('/1/task/%s', @raw_response[:taskID]), :GET, READ)
+        status = get_option(res, 'status')
+        if status == 'published'
+          @done = true
+        end
+        sleep(Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY / 1000)
+      end
+
+      self
+    end
+  end
+end

data/lib/algolia/search_client.rb

@@ -80,7 +80,7 @@ module Algolia
       end
 
       # # # # # # # # # # # # # # # # # # # # #
-      # MISC
+      # INDEX METHODS
       # # # # # # # # # # # # # # # # # # # # #
 
       # Initialize an index with a given name
@@ -300,7 +300,7 @@ module Algolia
       # @return [AddApiKeyResponse]
       #
       def add_api_key!(acl, opts = {})
-        response = add_api_key(acl)
+        response = add_api_key(acl, opts)
 
         response.wait(opts)
       end
@@ -480,6 +480,7 @@ module Algolia
       def multiple_queries(queries, opts = {})
         @transporter.read(:POST, '/1/indexes/*/queries', { requests: queries }, opts)
       end
+      alias_method :search, :multiple_queries
 
       # # # # # # # # # # # # # # # # # # # # #
       # MCM METHODS
@@ -594,12 +595,185 @@ module Algolia
         @transporter.read(:GET, '/1/clusters/mapping/pending' + handle_params({ getClusters: retrieve_mappings }), {}, request_options)
       end
 
-      #
       # Aliases the pending_mappings? method
       #
       alias_method :has_pending_mappings, :pending_mappings?
 
+      # # # # # # # # # # # # # # # # # # # # #
+      # CUSTOM DICTIONARIES METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
+      # Save entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def save_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Save entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def save_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = save_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Replace entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def replace_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: true, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Replace entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def replace_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = replace_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Delete entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def delete_dictionary_entries(dictionary, object_ids, opts = {})
+        request  = object_ids.map do |object_id|
+          { objectID: object_id }
+        end
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('deleteEntry', request) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Delete entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
       #
+      def delete_dictionary_entries!(dictionary, object_ids, opts = {})
+        response = delete_dictionary_entries(dictionary, object_ids, opts)
+
+        response.wait(opts)
+      end
+
+      # Clear all entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def clear_dictionary_entries(dictionary, opts = {})
+        replace_dictionary_entries(dictionary, [], opts)
+      end
+
+      # Clear all entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def clear_dictionary_entries!(dictionary, opts = {})
+        response = replace_dictionary_entries(dictionary, [], opts)
+
+        response.wait(opts)
+      end
+
+      # Search entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param query [String] query to send
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def search_dictionary_entries(dictionary, query, opts = {})
+        @transporter.read(
+          :POST,
+          path_encode('/1/dictionaries/%s/search', dictionary),
+          { query: query },
+          opts
+        )
+      end
+
+      # Set settings for all the dictionaries
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings(dictionary_settings, opts = {})
+        response = @transporter.write(:PUT, '/1/dictionaries/*/settings', dictionary_settings, opts)
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Set settings for all the dictionaries and wait for the task to finish
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings!(dictionary_settings, opts = {})
+        response = set_dictionary_settings(dictionary_settings, opts)
+
+        response.wait(opts)
+      end
+
+      # Retrieve settings for all the dictionaries
+      #
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def get_dictionary_settings(opts = {})
+        @transporter.read(:GET, '/1/dictionaries/*/settings', {}, opts)
+      end
+
+      # # # # # # # # # # # # # # # # # # # # #
+      # MISC METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
       # Method available to make custom requests to the API
       #
       def custom_request(data, uri, method, call_type, opts = {})

data/lib/algolia/search_index.rb

@@ -987,7 +987,15 @@ module Algolia
       # @return [IndexingResponse]
       #
       def set_settings(settings, opts = {})
-        response = @transporter.write(:PUT, path_encode('/1/indexes/%s/settings', @name), settings, opts)
+        request_options      = symbolize_hash(opts)
+        forward_to_replicas  = request_options.delete(:forwardToReplicas) || false
+
+        response = @transporter.write(
+          :PUT,
+          path_encode('/1/indexes/%s/settings', @name) + handle_params({ forwardToReplicas: forward_to_replicas }),
+          settings,
+          request_options
+        )
 
         IndexingResponse.new(self, response)
       end
@@ -1037,55 +1045,6 @@ module Algolia
 
       private
 
-      # Check the passed object to determine if it's an array
-      #
-      # @param object [Object]
-      #
-      def check_array(object)
-        raise AlgoliaError, 'argument must be an array of objects' unless object.is_a?(Array)
-      end
-
-      # Check the passed object
-      #
-      # @param object [Object]
-      # @param in_array [Boolean] whether the object is an array or not
-      #
-      def check_object(object, in_array = false)
-        case object
-        when Array
-          raise AlgoliaError, in_array ? 'argument must be an array of objects' : 'argument must not be an array'
-        when String, Integer, Float, TrueClass, FalseClass, NilClass
-          raise AlgoliaError, "argument must be an #{'array of' if in_array} object, got: #{object.inspect}"
-        end
-      end
-
-      # Check if passed object has a objectID
-      #
-      # @param object [Object]
-      # @param object_id [String]
-      #
-      def get_object_id(object, object_id = nil)
-        check_object(object)
-        object_id ||= object[:objectID] || object['objectID']
-        raise AlgoliaError, "Missing 'objectID'" if object_id.nil?
-        object_id
-      end
-
-      # Build a batch request
-      #
-      # @param action [String] action to perform on the engine
-      # @param objects [Array] objects on which build the action
-      # @param with_object_id [Boolean] if set to true, check if each object has an objectID set
-      #
-      def chunk(action, objects, with_object_id = false)
-        objects.map do |object|
-            check_object(object, true)
-            request            = { action: action, body: object }
-            request[:objectID] = get_object_id(object).to_s if with_object_id
-            request
-        end
-      end
-
       def raw_batch(requests, opts)
         @transporter.write(:POST, path_encode('/1/indexes/%s/batch', @name), { requests: requests }, opts)
       end

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = '2.0.3'.freeze
+  VERSION = '2.2.1'.freeze
 end

data/lib/algolia.rb

@@ -7,6 +7,8 @@ require 'algolia/config/base_config'
 require 'algolia/config/search_config'
 require 'algolia/config/analytics_config'
 require 'algolia/config/insights_config'
+require 'algolia/config/recommend_config'
+require 'algolia/config/personalization_config'
 require 'algolia/config/recommendation_config'
 require 'algolia/enums/call_type'
 require 'algolia/enums/retry_outcome_type'
@@ -20,6 +22,7 @@ require 'algolia/responses/indexing_response'
 require 'algolia/responses/add_api_key_response'
 require 'algolia/responses/update_api_key_response'
 require 'algolia/responses/delete_api_key_response'
+require 'algolia/responses/dictionary_response'
 require 'algolia/responses/restore_api_key_response'
 require 'algolia/responses/multiple_batch_indexing_response'
 require 'algolia/responses/multiple_response'
@@ -32,6 +35,8 @@ require 'algolia/account_client'
 require 'algolia/search_client'
 require 'algolia/analytics_client'
 require 'algolia/insights_client'
+require 'algolia/recommend_client'
+require 'algolia/personalization_client'
 require 'algolia/recommendation_client'
 require 'algolia/error'
 require 'algolia/search_index'

data/test/algolia/integration/analytics_client_test.rb

@@ -23,7 +23,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index1.wait_task(response[:taskID])
@@ -86,7 +88,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index.wait_task(response[:taskID])

data/test/algolia/integration/mocks/mock_requester.rb

@@ -1,25 +1,27 @@
 class MockRequester
+  attr_accessor :requests
   def initialize
     @connection = nil
+    @requests   = []
   end
 
-  def send_request(host, method, path, _body, headers, _timeout, _connect_timeout)
-    connection = get_connection(host)
-    response   = {
-      connection: connection,
+  def send_request(host, method, path, body, headers, timeout, connect_timeout)
+    request = {
       host: host,
+      method: method,
       path: path,
+      body: body,
       headers: headers,
-      method: method,
-      status: 200,
-      body: '{"hits":[],"nbHits":0,"page":0,"nbPages":1,"hitsPerPage":20,"exhaustiveNbHits":true,"query":"test","params":"query=test","processingTimeMS":1}',
-      success: true
+      timeout: timeout,
+      connect_timeout: connect_timeout
     }
 
+    @requests.push(request)
+
     Algolia::Http::Response.new(
-      status: response[:status],
-      body: response[:body],
-      headers: response[:headers]
+      status: 200,
+      body: '{"hits": []}',
+      headers: {}
     )
   end
 

data/test/algolia/integration/personalization_client_test.rb

@@ -0,0 +1,30 @@
+require_relative 'base_test'
+require 'date'
+
+class PersonalizationClientTest < BaseTest
+  describe 'Personalization client' do
+    def test_personalization_client
+      client                   = Algolia::Personalization::Client.create(APPLICATION_ID_1, ADMIN_KEY_1)
+      personalization_strategy = {
+        eventsScoring: [
+          { eventName: 'Add to cart', eventType: 'conversion', score: 50 },
+          { eventName: 'Purchase', eventType: 'conversion', score: 100 }
+        ],
+        facetsScoring: [
+          { facetName: 'brand', score: 100 },
+          { facetName: 'categories', score: 10 }
+        ],
+        personalizationImpact: 0
+      }
+
+      begin
+        client.set_personalization_strategy(personalization_strategy)
+      rescue Algolia::AlgoliaHttpError => e
+        raise e unless e.code == 429
+      end
+      response = client.get_personalization_strategy
+
+      assert_equal response, personalization_strategy
+    end
+  end
+end

data/test/algolia/integration/recommend_client_test.rb

@@ -0,0 +1,70 @@
+require 'securerandom'
+require_relative 'base_test'
+
+class RecommendClientTest < BaseTest
+  describe 'Recommendations' do
+    def test_get_recommendations
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      # It correctly formats queries using the 'bought-together' model
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER }])
+
+      # It correctly formats queries using the 'related-products' model
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::RELATED_PRODUCTS }])
+
+      # It correctly formats multiple queries.
+      client.get_recommendations(
+        [
+          { indexName: 'products', objectID: 'B018APC4LE-1', model: Algolia::Recommend::Model::RELATED_PRODUCTS, threshold: 0 },
+          { indexName: 'products', objectID: 'B018APC4LE-2', model: Algolia::Recommend::Model::RELATED_PRODUCTS, threshold: 0 }
+        ]
+      )
+
+      # It resets the threshold to 0 if it's not numeric.
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER, threshold: nil }])
+
+      # It passes the threshold correctly if it's numeric.
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER, threshold: 42 }])
+
+      assert_requests(
+        requester,
+        [
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"related-products","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE-1","model":"related-products","threshold":0},{"indexName":"products","objectID":"B018APC4LE-2","model":"related-products","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":42}]}' }
+        ]
+      )
+    end
+
+    def test_get_related_products
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      client.get_related_products([{ indexName: 'products', objectID: 'B018APC4LE' }])
+
+      assert_requests(
+        requester,
+        [{ method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"related-products","threshold":0}]}' }]
+      )
+    end
+
+    def test_get_frequently_bought_together
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      client.get_frequently_bought_together([{ indexName: 'products', objectID: 'B018APC4LE' }])
+      client.get_frequently_bought_together([{ indexName: 'products', objectID: 'B018APC4LE', fallbackParameters: {} }])
+
+      assert_requests(
+        requester,
+        [
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' }
+        ]
+      )
+    end
+  end
+end

data/test/algolia/integration/search_client_test.rb

@@ -1,3 +1,4 @@
+require 'securerandom'
 require_relative 'base_test'
 
 class SearchClientTest < BaseTest
@@ -215,6 +216,7 @@ class SearchClientTest < BaseTest
 
     def test_api_keys
       assert_equal ['search'], @api_key[:acl]
+      assert_equal 'A description', @api_key[:description]
 
       api_keys = @@search_client.list_api_keys[:keys].map do |key|
         key[:value]
@@ -222,7 +224,9 @@ class SearchClientTest < BaseTest
       assert_includes api_keys, @api_key[:value]
 
       @@search_client.update_api_key!(@api_key[:value], { maxHitsPerQuery: 42 })
-      updated_api_key = @@search_client.get_api_key(@api_key[:value])
+      updated_api_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value], test: 'test')
+      end
       assert_equal 42, updated_api_key[:maxHitsPerQuery]
 
       @@search_client.delete_api_key!(@api_key[:value])
@@ -233,18 +237,13 @@ class SearchClientTest < BaseTest
 
       assert_equal 'Key does not exist', exception.message
 
-      loop do
-        begin
-          @@search_client.restore_api_key!(@api_key[:value])
-          break
-        rescue Algolia::AlgoliaHttpError => e
-          if e.code != 404
-            raise StandardError
-          end
-        end
+      retry_test do
+        @@search_client.restore_api_key!(@api_key[:value])
       end
 
-      restored_key = @@search_client.get_api_key(@api_key[:value])
+      restored_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value])
+      end
 
       refute_nil restored_key
     end
@@ -333,7 +332,12 @@ class SearchClientTest < BaseTest
         secured_index1 = secured_client.init_index(@index1.name)
         secured_index2 = secured_client.init_index(@index2.name)
 
-        secured_index1.search('')
+        res = retry_test do
+          secured_index1.search('')
+        end
+
+        assert_equal 1, res[:hits].length
+
         exception = assert_raises Algolia::AlgoliaHttpError do
           secured_index2.search('')
         end
@@ -366,5 +370,96 @@ class SearchClientTest < BaseTest
         assert_equal 'The SecuredAPIKey doesn\'t have a validUntil parameter.', exception.message
       end
     end
+
+    describe 'Custom Dictionaries' do
+      def before_all
+        @client = Algolia::Search::Client.create(APPLICATION_ID_2, ADMIN_KEY_2)
+      end
+
+      def test_stopwords_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'en',
+          word: 'down'
+        }
+        @client.save_dictionary_entries!('stopwords', [entry])
+
+        stopwords = @client.search_dictionary_entries('stopwords', entry_id)
+        assert_equal 1, stopwords[:nbHits]
+        assert_equal stopwords[:hits][0][:objectID], entry[:objectID]
+        assert_equal stopwords[:hits][0][:word], entry[:word]
+
+        @client.delete_dictionary_entries!('stopwords', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        old_dictionary_state   = @client.search_dictionary_entries('stopwords', '')
+        old_dictionary_entries = old_dictionary_state[:hits].map do |hit|
+          hit.reject { |key| key == :type }
+        end
+
+        @client.save_dictionary_entries!('stopwords', [entry])
+        assert_equal 1, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        @client.replace_dictionary_entries!('stopwords', old_dictionary_entries)
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        stopwords_settings = {
+          disableStandardEntries: {
+            stopwords: {
+              en: true
+            }
+          }
+        }
+
+        @client.set_dictionary_settings!(stopwords_settings)
+
+        assert_equal @client.get_dictionary_settings, stopwords_settings
+      end
+
+      def test_plurals_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'fr',
+          words: %w(cheval chevaux)
+        }
+        @client.save_dictionary_entries!('plurals', [entry])
+
+        plurals = @client.search_dictionary_entries('plurals', entry_id)
+        assert_equal 1, plurals[:nbHits]
+        assert_equal plurals[:hits][0][:objectID], entry[:objectID]
+        assert_equal plurals[:hits][0][:words], entry[:words]
+
+        @client.delete_dictionary_entries!('plurals', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+      end
+
+      def test_compounds_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'de',
+          word: 'kopfschmerztablette',
+          decomposition: %w(kopf schmerz tablette)
+        }
+        @client.save_dictionary_entries!('compounds', [entry])
+
+        compounds = @client.search_dictionary_entries('compounds', entry_id)
+        assert_equal 1, compounds[:nbHits]
+        assert_equal compounds[:hits][0][:objectID], entry[:objectID]
+        assert_equal compounds[:hits][0][:word], entry[:word]
+        assert_equal compounds[:hits][0][:decomposition], entry[:decomposition]
+
+        @client.delete_dictionary_entries!('compounds', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+      end
+    end
   end
 end

data/test/algolia/integration/search_index_test.rb

@@ -274,6 +274,9 @@ class SearchIndexTest < BaseTest
       @index.set_settings!(settings)
 
       assert_equal @index.get_settings, settings
+
+      # check that the forwardToReplicas parameter is passed correctly
+      assert @index.set_settings!(settings, { forwardToReplicas: true })
     end
   end