algolia 2.0.0 → 2.3.2

data/lib/algolia/search_index.rb

@@ -5,18 +5,20 @@ module Algolia
       include CallType
       include Helpers
 
-      attr_reader :name, :transporter, :config
+      attr_reader :name, :transporter, :config, :logger
 
       # Initialize an index
       #
       # @param name [String] name of the index
       # @param transporter [Object] transport object used for the connection
       # @param config [Config] a Config object which contains your APP_ID and API_KEY
+      # @param logger [LoggerHelper] an optional LoggerHelper object to use
       #
-      def initialize(name, transporter, config)
+      def initialize(name, transporter, config, logger = nil)
         @name        = name
         @transporter = transporter
         @config      = config
+        @logger      = logger || LoggerHelper.create
       end
 
       # # # # # # # # # # # # # # # # # # # # #
@@ -36,7 +38,7 @@ module Algolia
           if status == 'published'
             return
           end
-          sleep(time_before_retry / 1000)
+          sleep(time_before_retry.to_f / 1000)
         end
       end
 
@@ -301,8 +303,8 @@ module Algolia
         request_options    = symbolize_hash(opts)
         if get_option(request_options, 'createIfNotExists')
           generate_object_id = true
-          request_options.delete(:createIfNotExists)
         end
+        request_options.delete(:createIfNotExists)
 
         if generate_object_id
           IndexingResponse.new(self, raw_batch(chunk('partialUpdateObject', objects), request_options))
@@ -830,7 +832,7 @@ module Algolia
         end
 
         # TODO: consider create a new client with state of retry is shared
-        tmp_client = Algolia::Search::Client.new(@config)
+        tmp_client = Algolia::Search::Client.new(@config, { logger: logger })
         tmp_index  = tmp_client.init_index(tmp_index_name)
 
         save_objects_response = tmp_index.save_objects(objects, request_options)
@@ -974,7 +976,11 @@ module Algolia
       # @return [Hash]
       #
       def get_settings(opts = {})
-        response = @transporter.read(:GET, path_encode('/1/indexes/%s/settings', @name) + handle_params({ getVersion: 2 }), {}, opts)
+        opts_default = {
+          getVersion: 2
+        }
+        opts         = opts_default.merge(opts)
+        response     = @transporter.read(:GET, path_encode('/1/indexes/%s/settings', @name), {}, opts)
 
         deserialize_settings(response, @config.symbolize_keys)
       end
@@ -987,7 +993,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 +1051,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/transport/request_options.rb

@@ -34,7 +34,7 @@ module Algolia
       def add_headers(opts = {})
         unless opts[:headers].nil?
           opts[:headers].each do |opt, value|
-            @headers[opt.to_sym] = value
+            @headers[opt.to_s] = value
           end
           opts.delete(:headers)
         end

data/lib/algolia/transport/transport.rb

@@ -1,4 +1,6 @@
 require 'faraday'
+# this is the default adapter and it needs to be required to be registered.
+require 'faraday/net_http_persistent' unless Faraday::VERSION < '1'
 
 module Algolia
   module Transport
@@ -89,11 +91,13 @@ module Algolia
       # @return [Hash]
       #
       def build_request(method, path, body, request_options)
-        request           = {}
-        request[:method]  = method.downcase
-        request[:path]    = build_uri_path(path, request_options.params)
-        request[:body]    = build_body(body, request_options, method)
-        request[:headers] = generate_headers(request_options)
+        request                   = {}
+        request[:method]          = method.downcase
+        request[:path]            = build_uri_path(path, request_options.params)
+        request[:body]            = build_body(body, request_options, method)
+        request[:headers]         = generate_headers(request_options)
+        request[:timeout]         = request_options.timeout
+        request[:connect_timeout] = request_options.connect_timeout
         request
       end
 
@@ -127,15 +131,12 @@ module Algolia
 
       # Generates headers from config headers and optional parameters
       #
-      # @option options [String] :headers
+      # @param request_options [RequestOptions]
       #
       # @return [Hash] merged headers
       #
       def generate_headers(request_options = {})
-        headers                                             = {}
-        extra_headers                                       = request_options.headers || {}
-        @config.headers.each { |key, val| headers[key.to_s] = val }
-        extra_headers.each { |key, val| headers[key.to_s]   = val }
+        headers = @config.headers.merge(request_options.headers)
         if request_options.compression_type == Defaults::GZIP_ENCODING
           headers['Accept-Encoding']  = Defaults::GZIP_ENCODING
         end

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.3.2'.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/renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

data/test/algolia/integration/account_client_test.rb

@@ -14,7 +14,7 @@ class AccountClientTest < BaseTest
 
       search_client2 = Algolia::Search::Client.create(APPLICATION_ID_2, ADMIN_KEY_2)
       index2         = search_client2.init_index(get_test_index_name('copy_index2'))
-      index1.save_object!({ objectID: 'one' })
+      index1.save_object!({ objectID: 'one', title: 'Test title' })
       index1.save_rule!({
         objectID: 'one',
         condition: { anchoring: 'is', pattern: 'pattern' },
@@ -29,7 +29,7 @@ class AccountClientTest < BaseTest
         }
       })
       index1.save_synonym!({ objectID: 'one', type: 'synonym', synonyms: %w(one two) })
-      index1.set_settings!({ searchableAttributes: ['objectID'] })
+      index1.set_settings!({ searchableAttributes: ['title'] })
 
       Algolia::Account::Client.copy_index!(index1, index2)
       assert_equal 'one', index2.get_object('one')[:objectID]

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": [], "status": "published"}',
+      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
@@ -295,7 +294,7 @@ class SearchClientTest < BaseTest
 
       results = @@search_client.multiple_queries([
         { indexName: index_name1, params: to_query_string({ query: '', hitsPerPage: 2 }) },
-        { indexName: index_name2, params: to_query_string({ query: '', hitsPerPage: 2 }) }
+        { indexName: index_name2, params: { query: '', hitsPerPage: 2 } }
       ], { strategy: 'none' })[:results]
 
       assert_equal 2, results.length
@@ -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,37 @@ 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
+
+    # Check version 1 API calling (ref. PR #473)
+    def test_version_param
+      @index.save_object!(generate_object('obj1')) # create index
+
+      # Check response's version value by actual access
+      assert_equal 2, @index.get_settings[:version]
+      assert_equal 1, @index.get_settings(getVersion: 1)[:version]
+      assert_equal 2, @index.get_settings(getVersion: 2)[:version]
+
+      # Check API endpoint handling by mock access
+      requester = MockRequester.new
+      client    = Algolia::Search::Client.new(@@search_config, http_requester: requester)
+      index     = client.init_index(@index_name)
+
+      index.get_settings # default
+      index.get_settings(getVersion: 1)
+      index.get_settings(getVersion: 2)
+
+      assert_requests(
+        requester,
+        [
+          { method: :get, path: "/1/indexes/#{@index_name}/settings?getVersion=2" },
+          { method: :get, path: "/1/indexes/#{@index_name}/settings?getVersion=1" },
+          { method: :get, path: "/1/indexes/#{@index_name}/settings?getVersion=2" }
+        ]
+      )
     end
   end
 

data/test/algolia/unit/helpers_test.rb

@@ -26,13 +26,15 @@ class HelpersTest
       old_settings = {
         'attributesToIndex' => %w(attr1 attr2),
         'numericAttributesToIndex' => %w(attr1 attr2),
-        'slaves' => %w(index1 index2)
+        'slaves' => %w(index1 index2),
+        'minWordSizefor1Typo' => 1
       }
 
       new_settings = {
         'searchableAttributes' => %w(attr1 attr2),
         'numericAttributesForFiltering' => %w(attr1 attr2),
-        'replicas' => %w(index1 index2)
+        'replicas' => %w(index1 index2),
+        'minWordSizefor1Typo' => 1
       }
 
       deserialized_settings = deserialize_settings(old_settings, false)