algolia 2.0.0.pre.alpha.2

data/sig/config/analytics_config.rbs

@@ -0,0 +1,11 @@
+module Algolia
+  module Analytics
+    class Config < AlgoliaConfig
+      attr_accessor region: String
+
+      attr_accessor default_hosts: [String]
+
+      def initialize: (?::Hash[Symbol, String] opts) -> void
+    end
+  end
+end

data/sig/config/insights_config.rbs

@@ -0,0 +1,11 @@
+module Algolia
+  module Insights
+    class Config < AlgoliaConfig
+      attr_accessor region: String
+
+      attr_accessor default_hosts: [String]
+
+      def initialize: (?::Hash[Symbol, String] opts) -> void
+    end
+  end
+end

data/sig/config/recommendation_config.rbs

@@ -0,0 +1,11 @@
+module Algolia
+  module Recommendation
+    class Config < AlgoliaConfig
+      attr_accessor region: String
+
+      attr_accessor default_hosts: [String]
+
+      def initialize: (?::Hash[Symbol, String] opts) -> void
+    end
+  end
+end

data/sig/config/search_config.rbs

@@ -0,0 +1,11 @@
+module Algolia
+  module Search
+    class Config < AlgoliaConfig
+      include CallType
+
+      attr_accessor default_hosts: Array[untyped]
+
+      def initialize: (?::Hash[Symbol, String|[String]] opts) -> void
+    end
+  end
+end

data/sig/enums/call_type.rbs

@@ -0,0 +1,5 @@
+module CallType
+  READ: ::Integer
+
+  WRITE: ::Integer
+end

data/sig/helpers.rbs

@@ -0,0 +1,12 @@
+module Helpers
+
+  def to_json: (String|Hash[Symbol, String] body) -> String
+  def symbolize_hash: (Hash[Symbol|String, untyped] hash) -> Hash[Symbol, untyped]
+  def handle_params: (Hash[Symbol, String] params) -> String
+  def to_query_string: (Hash[Symbol, String] params) -> String
+  def json_to_hash: (String json, bool symbolize_keys) -> Hash[Symbol, String]
+  def get_option: ([Symbol|String, String] hash, String key) -> (String | [String])
+  def path_encode: (String path, *String args) -> String
+  def deserialize_settings: (Hash[Symbol|String, String] data) -> Hash[Symbol, String]
+  def self.included: (self base) -> self
+end

data/sig/http/http_requester.rbs

@@ -0,0 +1,17 @@
+module Algolia
+  module Http
+    class HttpRequester
+      attr_accessor adapter: String
+
+      attr_accessor logger: Logger
+
+      def initialize: (String adapter, Logger logger) -> void
+
+      def send_request: (Algolia::Transport::StatefulHost host, Symbol method, String path, Hash[Symbol|String, untyped] body, Hash[String|Symbol, String|bool] headers, Integer timeout, Integer connect_timeout) -> Algolia::Http::Response
+
+      def connection: (Algolia::Transport::StatefulHost host) -> _Connection
+
+      def build_url: (Algolia::Transport::StatefulHost host) -> String
+    end
+  end
+end

data/sig/http/response.rbs

@@ -0,0 +1,14 @@
+module Algolia
+  module Http
+    class Response
+      attr_reader status: String
+      attr_reader body: String
+      attr_reader error: String
+      attr_reader headers: String
+      attr_reader has_timed_out: bool
+      attr_reader network_failure: bool
+
+      def initialize: (?::Hash[Symbol, String|bool] opts) -> untyped
+    end
+  end
+end

data/sig/interfaces/_connection.rbs

@@ -0,0 +1,16 @@
+interface _Connection
+
+  def options: () -> _ConnectionOptions
+
+  def run_request: (Symbol method, String path, Hash[Symbol, String|[String]] body, Hash[String, String] headers) -> Http::Response
+
+end
+
+interface _ConnectionOptions
+
+  def timeout: () -> Integer
+  def timeout=: (Integer timeout) -> Integer
+  def open_timeout: () -> Integer
+  def open_timeout=: (Integer timeout) -> Integer
+
+end

data/sig/iterators/base_iterator.rbs

@@ -0,0 +1,15 @@
+module Algolia
+  class BaseIterator
+    include Helpers
+    #TODO: double check Enumerable
+    include Enumerable[Hash[Symbol, String|[String]], void]
+
+    # TODO: add Transporter
+    attr_reader transporter: untyped
+    attr_reader index_name: String
+    attr_reader opts: Hash[Symbol, String|[String]]
+
+    # TODO: add Transporter
+    def initialize: (untyped transporter, String index_name, Hash[Symbol, String|[String]] opts) -> void
+  end
+end

data/sig/iterators/object_iterator.rbs

@@ -0,0 +1,6 @@
+module Algolia
+  class ObjectIterator < BaseIterator
+
+    def each: () { (Hash[Symbol, String|[String]]) -> void } -> Hash[Symbol, String|[String]]
+  end
+end

data/sig/iterators/paginator_iterator.rbs

@@ -0,0 +1,8 @@
+module Algolia
+  class PaginatorIterator < BaseIterator
+    # TODO: type transporter
+    def initialize: (untyped transporter, String index_name, Hash[Symbol, String|[String]] opts) -> bool
+    def each: () { (Hash[Symbol, String|[String]]) -> void } -> Hash[Symbol, String|[String]]
+    def get_endpoint: () -> String
+  end
+end

data/sig/iterators/rule_iterator.rbs

@@ -0,0 +1,5 @@
+module Algolia
+  class RuleIterator < PaginatorIterator
+    def get_endpoint: () -> String
+  end
+end

data/sig/iterators/synonym_iterator.rbs

@@ -0,0 +1,5 @@
+module Algolia
+  class SynonymIterator < PaginatorIterator
+    def get_endpoint: () -> String
+  end
+end

data/sig/transport/request_options.rbs

@@ -0,0 +1,33 @@
+module Algolia
+  module Transport
+    class RequestOptions
+      attr_accessor headers: Hash[Symbol|String, String]
+
+      attr_accessor params: Hash[Symbol|String, untyped]
+
+      attr_accessor data: Hash[Symbol|String, untyped]
+
+      attr_accessor timeout: Integer
+
+      attr_accessor connect_timeout: Integer
+
+      attr_accessor compression_type: String
+
+      def initialize: (Algolia::Search::Config config) -> void
+
+      def create: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_headers: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_params: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_timeout: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_connect_timeout: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_compression_type: (?::Hash[Symbol|String, untyped] opts) -> void
+
+      def add_data_body: (?::Hash[Symbol|String, untyped] opts) -> void
+    end
+  end
+end

data/sig/transport/stateful_host.rbs

@@ -0,0 +1,21 @@
+module Algolia
+  module Transport
+    class StatefulHost
+      include CallType
+
+      attr_reader url: untyped
+
+      attr_reader protocol: untyped
+
+      attr_reader accept: untyped
+
+      attr_accessor last_use: untyped
+
+      attr_accessor retry_count: untyped
+
+      attr_accessor up: untyped
+
+      def initialize: (String url, ?::Hash[Symbol|String, untyped] opts) -> void
+    end
+  end
+end

data/test/algolia/integration/account_client_test.rb

@@ -0,0 +1,47 @@
+require_relative 'base_test'
+
+class AccountClientTest < BaseTest
+  describe 'Account client' do
+    def test_account_client
+      index1 = @@search_client.init_index(get_test_index_name('copy_index'))
+      index2 = @@search_client.init_index(get_test_index_name('copy_index2'))
+
+      exception = assert_raises Algolia::AlgoliaError do
+        Algolia::Account::Client.copy_index(index1, index2)
+      end
+
+      assert_equal 'The indices are on the same application. Use Algolia::Search::Client.copy_index instead.', exception.message
+
+      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_rule!({
+        objectID: 'one',
+        condition: { anchoring: 'is', pattern: 'pattern' },
+        consequence: {
+          params: {
+            query: {
+              edits: [
+                { type: 'remove', delete: 'pattern' }
+              ]
+            }
+          }
+        }
+      })
+      index1.save_synonym!({ objectID: 'one', type: 'synonym', synonyms: %w(one two) })
+      index1.set_settings!({ searchableAttributes: ['objectID'] })
+
+      Algolia::Account::Client.copy_index!(index1, index2)
+      assert_equal 'one', index2.get_object('one')[:objectID]
+      assert_equal 'one', index2.get_synonym('one')[:objectID]
+      assert_equal 'one', index2.get_rule('one')[:objectID]
+      assert index2.get_settings[:searchableAttributes]
+
+      exception = assert_raises Algolia::AlgoliaError do
+        Algolia::Account::Client.copy_index(index1, index2)
+      end
+
+      assert_equal 'Destination index already exists. Please delete it before copying index across applications.', exception.message
+    end
+  end
+end

data/test/algolia/integration/analytics_client_test.rb

@@ -0,0 +1,113 @@
+require_relative 'base_test'
+require 'date'
+
+class AnalyticsClientTest < BaseTest
+  describe 'Analytics client' do
+    def test_ab_testing
+      index1 = @@search_client.init_index(get_test_index_name('ab_testing'))
+      index2 = @@search_client.init_index(get_test_index_name('ab_testing_dev'))
+      client = Algolia::Analytics::Client.create(APPLICATION_ID_1, ADMIN_KEY_1)
+
+      index1.save_object!({ objectID: 'one' })
+      index2.save_object!({ objectID: 'one' })
+
+      ab_test_name = index1.index_name
+      tomorrow     = Time.now + 24*60*60
+
+      ab_test = {
+        name: ab_test_name,
+        variants: [
+          { index: index1.index_name, trafficPercentage: 60, description: 'a description' },
+          { index: index2.index_name, trafficPercentage: 40 }
+        ],
+        endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
+      }
+
+      response   = client.add_ab_test(ab_test)
+      ab_test_id = response[:abTestID]
+
+      index1.wait_task(response[:taskID])
+      result = client.get_ab_test(ab_test_id)
+
+      assert_equal ab_test[:name], result[:name]
+      assert_equal ab_test[:variants][0][:index], result[:variants][0][:index]
+      assert_equal ab_test[:variants][0][:trafficPercentage], result[:variants][0][:trafficPercentage]
+      assert_equal ab_test[:variants][0][:description], result[:variants][0][:description]
+      assert_equal ab_test[:endAt], result[:endAt]
+      refute_equal 'stopped', result[:status]
+
+      ab_tests = client.get_ab_tests
+      found    = false
+      ab_tests[:abtests].each do |iterated_ab_test|
+        if iterated_ab_test[:name] == ab_test_name
+          assert_equal ab_test[:name], iterated_ab_test[:name]
+          assert_equal ab_test[:variants][0][:index], iterated_ab_test[:variants][0][:index]
+          assert_equal ab_test[:variants][0][:trafficPercentage], iterated_ab_test[:variants][0][:trafficPercentage]
+          assert_equal ab_test[:variants][0][:description], iterated_ab_test[:variants][0][:description]
+          assert_equal ab_test[:endAt], iterated_ab_test[:endAt]
+          refute_equal 'stopped', iterated_ab_test[:status]
+          found = true
+        end
+      end
+
+      assert found
+
+      response = client.stop_ab_test(ab_test_id)
+      index1.wait_task(response[:taskID])
+      result   = client.get_ab_test(ab_test_id)
+      assert_equal 'stopped', result[:status]
+
+      response = client.delete_ab_test(ab_test_id)
+      index1.wait_task(response[:taskID])
+
+      exception = assert_raises Algolia::AlgoliaHttpError do
+        client.get_ab_test(ab_test_id)
+      end
+
+      assert_equal 404, exception.code
+      assert_equal 'ABTestID not found', exception.message
+    end
+
+    def test_aa_testing
+      index  = @@search_client.init_index(get_test_index_name('aa_testing'))
+      client = Algolia::Analytics::Client.create(APPLICATION_ID_1, ADMIN_KEY_1)
+
+      index.save_object!({ objectID: 'one' })
+
+      ab_test_name = index.index_name
+      tomorrow     = Time.now + 24*60*60
+
+      ab_test = {
+        name: ab_test_name,
+        variants: [
+          { index: index.index_name, trafficPercentage: 90 },
+          { index: index.index_name, trafficPercentage: 10, customSearchParameters: { ignorePlurals: true } }
+        ],
+        endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
+      }
+
+      response   = client.add_ab_test(ab_test)
+      ab_test_id = response[:abTestID]
+
+      index.wait_task(response[:taskID])
+      result = client.get_ab_test(ab_test_id)
+
+      assert_equal ab_test[:name], result[:name]
+      assert_equal ab_test[:variants][0][:index], result[:variants][0][:index]
+      assert_equal ab_test[:variants][0][:trafficPercentage], result[:variants][0][:trafficPercentage]
+      assert_equal ab_test[:variants][1][:customSearchParameters], result[:variants][1][:customSearchParameters]
+      assert_equal ab_test[:endAt], result[:endAt]
+      refute_equal 'stopped', result[:status]
+
+      response = client.delete_ab_test(ab_test_id)
+      index.wait_task(response[:taskID])
+
+      exception = assert_raises Algolia::AlgoliaHttpError do
+        client.get_ab_test(ab_test_id)
+      end
+
+      assert_equal 404, exception.code
+      assert_equal 'ABTestID not found', exception.message
+    end
+  end
+end

data/test/algolia/integration/base_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'minitest/hell'
+
+class BaseTest < Minitest::Test
+  parallelize_me!
+  def setup
+    check_environment_variables
+  end
+end

data/test/algolia/integration/insights_client_test.rb

@@ -0,0 +1,80 @@
+require_relative 'base_test'
+require 'date'
+
+class InsightsClientTest < BaseTest
+  describe 'Insights client' do
+    def test_insights_client
+      index  = @@search_client.init_index(get_test_index_name('sending_events'))
+      client = Algolia::Insights::Client.create(APPLICATION_ID_1, ADMIN_KEY_1)
+
+      index.save_objects!([
+        { objectID: 'one' },
+        { objectID: 'two' }
+      ])
+
+      today = Date.today
+
+      client.send_event({
+        eventType: 'click',
+        eventName: 'foo',
+        index: index.index_name,
+        userToken: 'bar',
+        objectIDs: %w(one two),
+        timestamp: (today - 2).strftime('%Q').to_i
+      })
+
+      client.send_events([
+        {
+          eventType: 'click',
+          eventName: 'foo',
+          index: index.index_name,
+          userToken: 'bar',
+          objectIDs: %w(one two),
+          timestamp: (today - 2).strftime('%Q').to_i
+        }, {
+          eventType: 'click',
+          eventName: 'foo',
+          index: index.index_name,
+          userToken: 'bar',
+          objectIDs: %w(one two),
+          timestamp: (today - 2).strftime('%Q').to_i
+        }
+      ])
+
+      user_client = client.user('bar')
+      response    = user_client.clicked_object_ids('foo', index.index_name, %w(one two))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      query_id = index.search('', { clickAnalytics: true })[:queryID]
+
+      response = user_client.clicked_object_ids_after_search('foo', index.index_name, %w(one two), [1, 2], query_id)
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.clicked_filters('foo', index.index_name, %w(filter:foo filter:bar))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.converted_object_ids('foo', index.index_name, %w(one two))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.converted_object_ids_after_search('foo', index.index_name, %w(one two), query_id)
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.converted_filters('foo', index.index_name, %w(filter:foo filter:bar))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.viewed_object_ids('foo', index.index_name, %w(one two))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+
+      response = user_client.viewed_filters('foo', index.index_name, %w(filter:foo filter:bar))
+      assert_equal 200, response[:status]
+      assert_equal 'OK', response[:message]
+    end
+  end
+end