searchkick 3.1.0 → 3.1.1

data/test/test_helper.rb

@@ -1,593 +0,0 @@
-require "bundler/setup"
-Bundler.require(:default)
-require "minitest/autorun"
-require "minitest/pride"
-require "logger"
-require "active_support/core_ext" if defined?(NoBrainer)
-require "active_support/notifications"
-
-Searchkick.index_suffix = ENV["TEST_ENV_NUMBER"]
-
-ENV["RACK_ENV"] = "test"
-
-Minitest::Test = Minitest::Unit::TestCase unless defined?(Minitest::Test)
-
-if !defined?(ParallelTests) || ParallelTests.first_process?
-  File.delete("elasticsearch.log") if File.exist?("elasticsearch.log")
-end
-
-Searchkick.client.transport.logger = Logger.new("elasticsearch.log")
-Searchkick.search_timeout = 5
-
-if defined?(Redis)
-  if defined?(ConnectionPool)
-    Searchkick.redis = ConnectionPool.new { Redis.new }
-  else
-    Searchkick.redis = Redis.new
-  end
-end
-
-puts "Running against Elasticsearch #{Searchkick.server_version}"
-
-I18n.config.enforce_available_locales = true
-
-if defined?(ActiveJob)
-  ActiveJob::Base.logger = nil
-  ActiveJob::Base.queue_adapter = :inline
-end
-
-ActiveSupport::LogSubscriber.logger = ActiveSupport::Logger.new(STDOUT) if ENV["NOTIFICATIONS"]
-
-def nobrainer?
-  defined?(NoBrainer)
-end
-
-def cequel?
-  defined?(Cequel)
-end
-
-if defined?(Mongoid)
-  Mongoid.logger.level = Logger::INFO
-  Mongo::Logger.logger.level = Logger::INFO if defined?(Mongo::Logger)
-
-  Mongoid.configure do |config|
-    config.connect_to "searchkick_test"
-  end
-
-  class Product
-    include Mongoid::Document
-    include Mongoid::Timestamps
-
-    field :name
-    field :store_id, type: Integer
-    field :in_stock, type: Boolean
-    field :backordered, type: Boolean
-    field :orders_count, type: Integer
-    field :found_rate, type: BigDecimal
-    field :price, type: Integer
-    field :color
-    field :latitude, type: BigDecimal
-    field :longitude, type: BigDecimal
-    field :description
-    field :alt_description
-  end
-
-  class Store
-    include Mongoid::Document
-    has_many :products
-
-    field :name
-  end
-
-  class Region
-    include Mongoid::Document
-
-    field :name
-    field :text
-  end
-
-  class Speaker
-    include Mongoid::Document
-
-    field :name
-  end
-
-  class Animal
-    include Mongoid::Document
-
-    field :name
-  end
-
-  class Dog < Animal
-  end
-
-  class Cat < Animal
-  end
-
-  class Sku
-    include Mongoid::Document
-
-    field :name
-  end
-
-  class Song
-    include Mongoid::Document
-
-    field :name
-  end
-elsif defined?(NoBrainer)
-  NoBrainer.configure do |config|
-    config.app_name = :searchkick
-    config.environment = :test
-  end
-
-  class Product
-    include NoBrainer::Document
-    include NoBrainer::Document::Timestamps
-
-    field :id,           type: Object
-    field :name,         type: Text
-    field :in_stock,     type: Boolean
-    field :backordered,  type: Boolean
-    field :orders_count, type: Integer
-    field :found_rate
-    field :price,        type: Integer
-    field :color,        type: String
-    field :latitude
-    field :longitude
-    field :description, type: String
-    field :alt_description, type: String
-
-    belongs_to :store, validates: false
-  end
-
-  class Store
-    include NoBrainer::Document
-
-    field :id,   type: Object
-    field :name, type: String
-  end
-
-  class Region
-    include NoBrainer::Document
-
-    field :id,   type: Object
-    field :name, type: String
-    field :text, type: Text
-  end
-
-  class Speaker
-    include NoBrainer::Document
-
-    field :id,   type: Object
-    field :name, type: String
-  end
-
-  class Animal
-    include NoBrainer::Document
-
-    field :id,   type: Object
-    field :name, type: String
-  end
-
-  class Dog < Animal
-  end
-
-  class Cat < Animal
-  end
-
-  class Sku
-    include NoBrainer::Document
-
-    field :id,   type: String
-    field :name, type: String
-  end
-
-  class Song
-    include NoBrainer::Document
-
-    field :id,   type: Object
-    field :name, type: String
-  end
-elsif defined?(Cequel)
-  cequel =
-    Cequel.connect(
-      host: "127.0.0.1",
-      port: 9042,
-      keyspace: "searchkick_test",
-      default_consistency: :all
-    )
-  # cequel.logger = ActiveSupport::Logger.new(STDOUT)
-  cequel.schema.drop! if cequel.schema.exists?
-  cequel.schema.create!
-  Cequel::Record.connection = cequel
-
-  class Product
-    include Cequel::Record
-
-    key :id, :uuid, auto: true
-    column :name, :text, index: true
-    column :store_id, :int
-    column :in_stock, :boolean
-    column :backordered, :boolean
-    column :orders_count, :int
-    column :found_rate, :decimal
-    column :price, :int
-    column :color, :text
-    column :latitude, :decimal
-    column :longitude, :decimal
-    column :description, :text
-    column :alt_description, :text
-    column :created_at, :timestamp
-  end
-
-  class Store
-    include Cequel::Record
-
-    key :id, :timeuuid, auto: true
-    column :name, :text
-
-    # has issue with id serialization
-    def search_data
-      {
-        name: name
-      }
-    end
-  end
-
-  class Region
-    include Cequel::Record
-
-    key :id, :timeuuid, auto: true
-    column :name, :text
-    column :text, :text
-  end
-
-  class Speaker
-    include Cequel::Record
-
-    key :id, :timeuuid, auto: true
-    column :name, :text
-  end
-
-  class Animal
-    include Cequel::Record
-
-    key :id, :timeuuid, auto: true
-    column :name, :text
-
-    # has issue with id serialization
-    def search_data
-      {
-        name: name
-      }
-    end
-  end
-
-  class Dog < Animal
-  end
-
-  class Cat < Animal
-  end
-
-  class Sku
-    include Cequel::Record
-
-    key :id, :uuid
-    column :name, :text
-  end
-
-  class Song
-    include Cequel::Record
-
-    key :id, :timeuuid, auto: true
-    column :name, :text
-  end
-
-  [Product, Store, Region, Speaker, Animal, Sku, Song].each(&:synchronize_schema)
-else
-  require "active_record"
-
-  # for debugging
-  # ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-  # rails does this in activerecord/lib/active_record/railtie.rb
-  ActiveRecord::Base.default_timezone = :utc
-  ActiveRecord::Base.time_zone_aware_attributes = true
-
-  # migrations
-  ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-
-  ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING.start_with?("4.2.")
-
-  if defined?(Apartment)
-    class Rails
-      def self.env
-        ENV["RACK_ENV"]
-      end
-    end
-
-    tenants = ["tenant1", "tenant2"]
-    Apartment.configure do |config|
-      config.tenant_names = tenants
-      config.database_schema_file = false
-      config.excluded_models = ["Product", "Store", "Animal", "Dog", "Cat"]
-    end
-
-    class Tenant < ActiveRecord::Base
-      searchkick index_prefix: -> { Apartment::Tenant.current }
-    end
-
-    tenants.each do |tenant|
-      begin
-        Apartment::Tenant.create(tenant)
-      rescue Apartment::TenantExists
-        # do nothing
-      end
-      Apartment::Tenant.switch!(tenant)
-
-      ActiveRecord::Migration.create_table :tenants, force: true do |t|
-        t.string :name
-        t.timestamps null: true
-      end
-
-      Tenant.reindex
-    end
-
-    Apartment::Tenant.reset
-  end
-
-  ActiveRecord::Migration.create_table :products do |t|
-    t.string :name
-    t.integer :store_id
-    t.boolean :in_stock
-    t.boolean :backordered
-    t.integer :orders_count
-    t.decimal :found_rate
-    t.integer :price
-    t.string :color
-    t.decimal :latitude, precision: 10, scale: 7
-    t.decimal :longitude, precision: 10, scale: 7
-    t.text :description
-    t.text :alt_description
-    t.timestamps null: true
-  end
-
-  ActiveRecord::Migration.create_table :stores do |t|
-    t.string :name
-  end
-
-  ActiveRecord::Migration.create_table :regions do |t|
-    t.string :name
-    t.text :text
-  end
-
-  ActiveRecord::Migration.create_table :speakers do |t|
-    t.string :name
-  end
-
-  ActiveRecord::Migration.create_table :animals do |t|
-    t.string :name
-    t.string :type
-  end
-
-  ActiveRecord::Migration.create_table :skus, id: :uuid do |t|
-    t.string :name
-  end
-
-  ActiveRecord::Migration.create_table :songs do |t|
-    t.string :name
-  end
-
-  class Product < ActiveRecord::Base
-    belongs_to :store
-  end
-
-  class Store < ActiveRecord::Base
-    has_many :products
-  end
-
-  class Region < ActiveRecord::Base
-  end
-
-  class Speaker < ActiveRecord::Base
-  end
-
-  class Animal < ActiveRecord::Base
-  end
-
-  class Dog < Animal
-  end
-
-  class Cat < Animal
-  end
-
-  class Sku < ActiveRecord::Base
-  end
-
-  class Song < ActiveRecord::Base
-  end
-end
-
-class Product
-  searchkick \
-    synonyms: [
-      ["clorox", "bleach"],
-      ["scallion", "greenonion"],
-      ["saran wrap", "plastic wrap"],
-      ["qtip", "cottonswab"],
-      ["burger", "hamburger"],
-      ["bandaid", "bandag"],
-      ["UPPERCASE", "lowercase"],
-      "lightbulb => led,lightbulb",
-      "lightbulb => halogenlamp"
-    ],
-    suggest: [:name, :color],
-    conversions: [:conversions],
-    locations: [:location, :multiple_locations],
-    text_start: [:name],
-    text_middle: [:name],
-    text_end: [:name],
-    word_start: [:name],
-    word_middle: [:name],
-    word_end: [:name],
-    highlight: [:name],
-    filterable: [:name, :color, :description],
-    similarity: "BM25",
-    match: ENV["MATCH"] ? ENV["MATCH"].to_sym : nil
-
-  attr_accessor :conversions, :user_ids, :aisle, :details
-
-  def search_data
-    serializable_hash.except("id", "_id").merge(
-      conversions: conversions,
-      user_ids: user_ids,
-      location: {lat: latitude, lon: longitude},
-      multiple_locations: [{lat: latitude, lon: longitude}, {lat: 0, lon: 0}],
-      aisle: aisle,
-      details: details
-    )
-  end
-
-  def should_index?
-    name != "DO NOT INDEX"
-  end
-
-  def search_name
-    {
-      name: name
-    }
-  end
-end
-
-class Store
-  searchkick \
-    routing: true,
-    merge_mappings: true,
-    mappings: {
-      store: {
-        properties: {
-          name: {type: "keyword"}
-        }
-      }
-    }
-
-  def search_document_id
-    id
-  end
-
-  def search_routing
-    name
-  end
-end
-
-class Region
-  searchkick \
-    geo_shape: {
-      territory: {tree: "quadtree", precision: "10km"}
-    }
-
-  attr_accessor :territory
-
-  def search_data
-    {
-      name: name,
-      text: text,
-      territory: territory
-    }
-  end
-end
-
-class Speaker
-  searchkick \
-    conversions: ["conversions_a", "conversions_b"]
-
-  attr_accessor :conversions_a, :conversions_b, :aisle
-
-  def search_data
-    serializable_hash.except("id", "_id").merge(
-      conversions_a: conversions_a,
-      conversions_b: conversions_b,
-      aisle: aisle
-    )
-  end
-end
-
-class Animal
-  searchkick \
-    inheritance: true,
-    text_start: [:name],
-    suggest: [:name],
-    index_name: -> { "#{name.tableize}-#{Date.today.year}#{Searchkick.index_suffix}" },
-    callbacks: defined?(ActiveJob) ? :async : true
-    # wordnet: true
-end
-
-class Sku
-  searchkick callbacks: defined?(ActiveJob) ? :async : true
-end
-
-class Song
-  searchkick
-end
-
-Product.searchkick_index.delete if Product.searchkick_index.exists?
-Product.reindex
-Product.reindex # run twice for both index paths
-Product.create!(name: "Set mapping")
-
-Store.reindex
-Animal.reindex
-Speaker.reindex
-Region.reindex
-
-class Minitest::Test
-  def setup
-    Product.destroy_all
-    Store.destroy_all
-    Animal.destroy_all
-    Speaker.destroy_all
-  end
-
-  protected
-
-  def store(documents, klass = Product)
-    documents.shuffle.each do |document|
-      klass.create!(document)
-    end
-    klass.searchkick_index.refresh
-  end
-
-  def store_names(names, klass = Product)
-    store names.map { |name| {name: name} }, klass
-  end
-
-  # no order
-  def assert_search(term, expected, options = {}, klass = Product)
-    assert_equal expected.sort, klass.search(term, options).map(&:name).sort
-  end
-
-  def assert_order(term, expected, options = {}, klass = Product)
-    assert_equal expected, klass.search(term, options).map(&:name)
-  end
-
-  def assert_equal_scores(term, options = {}, klass = Product)
-    assert_equal 1, klass.search(term, options).hits.map { |a| a["_score"] }.uniq.size
-  end
-
-  def assert_first(term, expected, options = {}, klass = Product)
-    assert_equal expected, klass.search(term, options).map(&:name).first
-  end
-
-  def with_options(klass, options)
-    previous_options = klass.searchkick_options.dup
-    begin
-      klass.searchkick_options.merge!(options)
-      klass.reindex
-      yield
-    ensure
-      klass.searchkick_options.clear
-      klass.searchkick_options.merge!(previous_options)
-    end
-  end
-end