search_flip 1.0.0

data/test/search_flip/http_client_test.rb

@@ -0,0 +1,35 @@
+
+require File.expand_path("../../test_helper", __FILE__)
+
+class SearchFlip::HTTPClientTest < SearchFlip::TestCase
+  [:get, :put, :delete, :post, :head].each do |method|
+    define_method :"test_#{method}" do
+      stub_request(method, "http://localhost/path").with(body: "body", query: { key: "value" }).to_return(body: "success")
+
+      assert_equal "success", SearchFlip::HTTPClient.send(method, "http://localhost/path", body: "body", params: { key: "value" }).body.to_s
+    end
+  end
+
+  def test_headers
+    stub_request(:get, "http://localhost/path").with(headers: { "X-Key" => "Value" }).to_return(body: "success")
+
+    assert_equal "success", SearchFlip::HTTPClient.headers("X-Key" => "Value").get("http://localhost/path").body.to_s
+  end
+
+  def test_connection_error
+    stub_request(:get, "http://localhost/path").to_raise(HTTP::ConnectionError)
+
+    assert_raises SearchFlip::ConnectionError do
+      SearchFlip::HTTPClient.get("http://localhost/path")
+    end
+  end
+
+  def test_response_error
+    stub_request(:get, "http://localhost/path").to_return(status: 500)
+
+    assert_raises SearchFlip::ResponseError do
+      SearchFlip::HTTPClient.get("http://localhost/path")
+    end
+  end
+end
+

data/test/search_flip/index_test.rb

@@ -0,0 +1,350 @@
+
+require File.expand_path("../../test_helper", __FILE__)
+
+class SearchFlip::IndexTest < SearchFlip::TestCase
+  should_delegate_methods :profile, :where, :where_not, :filter, :range, :match_all, :exists, :exists_not, :post_where,
+    :post_where_not, :post_filter, :post_range, :post_exists, :post_exists_not, :aggregate, :scroll, :source, :includes,
+    :eager_load, :preload, :sort, :resort, :order, :reorder, :offset, :limit, :paginate, :page, :per, :search,
+    :find_in_batches, :highlight, :suggest, :custom, :find_each, :failsafe, :total_entries, :total_count, :terminate_after,
+    :timeout, to: :criteria, subject: ProductIndex
+
+  def test_create_index
+    assert TestIndex.create_index
+    assert TestIndex.index_exists?
+
+    TestIndex.delete_index
+
+    refute TestIndex.index_exists?
+  end
+
+  def test_create_index_with_index_settings
+    TestIndex.stubs(:index_settings).returns(settings: { number_of_shards: 3 })
+
+    assert TestIndex.create_index
+    assert TestIndex.index_exists?
+
+    assert_equal "3", TestIndex.get_index_settings["test"]["settings"]["index"]["number_of_shards"]
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
+
+  def test_update_index_settings
+    assert TestIndex.create_index
+
+    TestIndex.stubs(:index_settings).returns(settings: { number_of_replicas: 3 })
+
+    assert TestIndex.update_index_settings
+
+    assert_equal "3", TestIndex.get_index_settings["test"]["settings"]["index"]["number_of_replicas"]
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
+
+  def test_get_index_settings
+    # Already tested
+  end
+
+  def test_index_exists?
+    # Already tested
+  end
+
+  def test_delete_index
+    # Already tested
+  end
+
+  def test_update_mapping
+    TestIndex.create_index
+    TestIndex.update_mapping
+
+    mapping = TestIndex.get_mapping
+
+    assert mapping["test"]["mappings"]["test"]["properties"]["test_field"]
+
+    TestIndex.delete_index
+  end
+
+  def test_get_mapping
+    # Aready tested
+  end
+
+  def test_refresh
+    assert_difference "ProductIndex.total_entries" do
+      ProductIndex.import create(:product)
+
+      assert ProductIndex.refresh
+    end
+  end
+
+  def test_base_url
+    assert_equal "http://127.0.0.1:9200", ProductIndex.base_url
+  end
+
+  def test_index_url
+    assert_equal "http://127.0.0.1:9200/products", ProductIndex.index_url
+
+    ProductIndex.stubs(:type_name).returns("products2")
+
+    assert_equal "http://127.0.0.1:9200/products2", ProductIndex.index_url
+
+    SearchFlip::Config[:index_prefix] = "prefix-"
+
+    assert_equal "http://127.0.0.1:9200/prefix-products2", ProductIndex.index_url
+
+    ProductIndex.stubs(:index_name).returns("products3")
+
+    assert_equal "http://127.0.0.1:9200/prefix-products3", ProductIndex.index_url
+
+    SearchFlip::Config[:index_prefix] = nil
+  end
+
+  def test_type_url
+    assert_equal "http://127.0.0.1:9200/products/products", ProductIndex.type_url
+
+    ProductIndex.stubs(:type_name).returns("products2")
+
+    assert_equal "http://127.0.0.1:9200/products2/products2", ProductIndex.type_url
+  end
+
+  def test_import_object
+    assert_difference "ProductIndex.total_entries" do
+      ProductIndex.import create(:product)
+    end
+  end
+
+  def test_import_array
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import [create(:product), create(:product)]
+    end
+  end
+
+  def test_import_scope
+    create_list :product, 2
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import Product.all
+    end
+  end
+
+  def test_import_with_param_options
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products, {}, version: 1, version_type: "external"
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      ProductIndex.import products, {}, version: 2, version_type: "external"
+      ProductIndex.import products, { ignore_errors: [409] }, version: 2, version_type: "external"
+
+      assert_raises SearchFlip::Bulk::Error do
+        ProductIndex.import products, {}, version: 2, version_type: "external"
+      end
+    end
+  end
+
+  def test_import_with_class_options
+    products = create_list(:product, 2)
+
+    ProductIndex.stubs(:index_options).returns(version: 3, version_type: "external")
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products
+    end
+
+    assert_equal [3, 3], products.map { |product| ProductIndex.get(product.id)["_version"] }
+  end
+
+  def test_index_array
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.index create_list(:product, 2)
+    end
+  end
+
+  def test_index_scope
+    temp_product_index = Class.new(ProductIndex)
+
+    temp_product_index.define_singleton_method(:index_scope) do |scope|
+      scope.where("price < 80")
+    end
+
+    products = [create(:product, price: 20), create(:product, price: 50), create(:product, price: 100)]
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      temp_product_index.index Product.where(id: products.map(&:id))
+    end
+  end
+
+  def test_create_array
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.create products
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      assert_raises SearchFlip::Bulk::Error do
+        ProductIndex.create products
+      end
+    end
+  end
+
+  def test_create_scope
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.create Product.where(id: create_list(:product, 2).map(&:id))
+    end
+  end
+
+  def test_update_array
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      ProductIndex.update products
+    end
+  end
+
+  def test_update_scope
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      ProductIndex.update Product.where(id: products.map(&:id))
+    end
+  end
+
+  def test_delete_array
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products
+    end
+
+    assert_difference "ProductIndex.total_entries", -2 do
+      ProductIndex.delete products
+    end
+  end
+
+  def test_delete_scope
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.import products
+    end
+
+    assert_difference "ProductIndex.total_entries", -2 do
+      ProductIndex.delete Product.where(id: Product.where(id: products.map(&:id)))
+    end
+  end
+
+  def test_create_already_created
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.create products
+    end
+
+    assert_raises SearchFlip::Bulk::Error do
+      ProductIndex.create products
+    end
+  end
+
+  def test_create_with_param_options
+    products = create_list(:product, 2)
+
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.create products
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      ProductIndex.create products, ignore_errors: [409]
+    end
+
+    products = create_list(:product, 2)
+
+    if SearchFlip.version.to_i >= 5
+      assert_difference "ProductIndex.total_entries", 2 do
+        ProductIndex.create products, {}, routing: "r1"
+      end
+
+      assert_equal "r1", ProductIndex.get(products.first.id, routing: "r1")["_routing"]
+    else
+      assert_difference "ProductIndex.total_entries", 2 do
+        ProductIndex.create products, {}, version: 2, version_type: "external"
+      end
+
+      assert_equal [2, 2], products.map { |product| ProductIndex.get(product.id)["_version"] }
+    end
+  end
+
+  def test_create_with_class_options
+    products = create_list(:product, 2)
+
+    if SearchFlip.version.to_i >= 5
+      ProductIndex.stubs(:index_options).returns(routing: "r1")
+
+      assert_difference "ProductIndex.total_entries", 2 do
+        ProductIndex.create products
+      end
+
+      assert_equal ["r1", "r1"], products.map { |product| ProductIndex.get(product.id, routing: "r1")["_routing"] }
+    else
+      ProductIndex.stubs(:index_options).returns(version: 2, version_type: "external")
+
+      assert_difference "ProductIndex.total_entries", 2 do
+        ProductIndex.create products
+      end
+
+      assert_equal [2, 2], products.map { |product| ProductIndex.get(product.id)["_version"] }
+    end
+  end
+
+  def test_get
+    # Already tested
+  end
+
+  def test_scope
+    temp_product_index = Class.new(ProductIndex)
+
+    temp_product_index.scope(:with_title) { |title| where(title: title) }
+
+    expected = create(:product, title: "expected")
+    rejected = create(:product, title: "rejected")
+
+    temp_product_index.import [expected, rejected]
+
+    results = temp_product_index.with_title("expected").records
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_bulk
+    assert_difference "ProductIndex.total_entries", 2 do
+      ProductIndex.bulk do |indexer|
+        indexer.index 1, id: 1
+        indexer.index 2, id: 2
+      end
+    end
+
+    assert_no_difference "ProductIndex.total_entries" do
+      assert_raises "SearchFlip::Bulk::Error" do
+        ProductIndex.bulk do |indexer|
+          indexer.index 1, { id: 1 }, version: 1, version_type: "external"
+          indexer.index 2, { id: 2 }, version: 1, version_type: "external"
+        end
+      end
+
+      ProductIndex.bulk ignore_errors: [409] do |indexer|
+        indexer.index 1, { id: 1 }, version: 1, version_type: "external"
+        indexer.index 2, { id: 2 }, version: 1, version_type: "external"
+      end
+    end
+  end
+end
+

data/test/search_flip/model_test.rb

@@ -0,0 +1,39 @@
+
+require File.expand_path("../../test_helper", __FILE__)
+
+class SearchFlip::ModelTest < SearchFlip::TestCase
+  class TestProduct < Product
+    include SearchFlip::Model
+
+    notifies_index(ProductIndex)
+  end
+
+  def test_save
+    assert_equal 0, ProductIndex.total_count
+
+    TestProduct.create!
+
+    assert_equal 1, ProductIndex.total_count
+  end
+
+  def test_destroy
+    test_product = TestProduct.create!
+
+    assert_equal 1, ProductIndex.total_count
+
+    test_product.destroy
+
+    assert_equal 0, ProductIndex.total_count
+  end
+
+  def test_touch
+    test_product = Timecop.freeze(Time.parse("2016-01-01 12:00:00")) { TestProduct.create! }
+
+    updated_at = ProductIndex.match_all.results.first.updated_at
+
+    Timecop.freeze(Time.parse("2017-01-01 12:00:00")) { test_product.touch }
+
+    refute_equal updated_at, ProductIndex.match_all.results.first.updated_at
+  end
+end
+

data/test/search_flip/response_test.rb

@@ -0,0 +1,136 @@
+
+require File.expand_path("../../test_helper", __FILE__)
+
+class SearchFlip::ResponseTest < SearchFlip::TestCase
+  def test_total_entries
+    ProductIndex.import create_list(:product, 3)
+
+    assert_equal 3, ProductIndex.total_entries
+  end
+
+  def test_curent_page
+    assert_equal 1, ProductIndex.match_all.current_page
+
+    ProductIndex.import create_list(:product, 3)
+
+    assert_equal 1, ProductIndex.paginate(page: 1, per_page: 2).current_page
+    assert_equal 2, ProductIndex.paginate(page: 2, per_page: 2).current_page
+    assert_equal 3, ProductIndex.paginate(page: 3, per_page: 2).current_page
+  end
+
+  def test_total_pages
+    assert_equal 1, ProductIndex.paginate(page: 1, per_page: 2).total_pages
+
+    ProductIndex.import create_list(:product, 3)
+
+    assert_equal 2, ProductIndex.paginate(page: 1, per_page: 2).total_pages
+  end
+
+  def test_previous_page
+    ProductIndex.import create_list(:product, 3)
+
+    assert_nil ProductIndex.paginate(page: 1, per_page: 2).previous_page
+    assert_equal 1, ProductIndex.paginate(page: 2, per_page: 2).previous_page
+    assert_equal 2, ProductIndex.paginate(page: 3, per_page: 2).previous_page
+  end
+
+  def test_next_page
+    ProductIndex.import create_list(:product, 3)
+
+    assert_equal 2, ProductIndex.paginate(page: 1, per_page: 2).next_page
+    assert_nil ProductIndex.paginate(page: 2, per_page: 2).next_page
+  end
+
+  def test_first_page?
+    ProductIndex.import create(:product)
+
+    assert ProductIndex.paginate(page: 1).first_page?
+    refute ProductIndex.paginate(page: 2).first_page?
+  end
+
+  def test_last_page?
+    ProductIndex.import create_list(:product, 31)
+
+    assert ProductIndex.paginate(page: 2).last_page?
+    refute ProductIndex.paginate(page: 1).last_page?
+  end
+
+  def test_out_of_range?
+    ProductIndex.import create(:product)
+
+    assert ProductIndex.paginate(page: 2).out_of_range?
+    refute ProductIndex.paginate(page: 1).out_of_range?
+  end
+
+  def test_results
+    products = create_list(:product, 3)
+
+    ProductIndex.import products
+
+    assert_equal products.map(&:id).to_set, ProductIndex.match_all.results.map(&:id).to_set
+  end
+
+  def test_hits
+    ProductIndex.import create_list(:product, 3)
+
+    response = ProductIndex.match_all.response
+
+    assert_present response.hits
+    assert_equal response.raw_response["hits"], response.hits
+  end
+
+  def test_scroll_id
+    ProductIndex.import create_list(:product, 3)
+
+    response = ProductIndex.scroll.response
+
+    assert_present response.scroll_id
+    assert_equal response.raw_response["_scroll_id"], response.scroll_id
+  end
+
+  def test_records
+    products = create_list(:product, 3)
+
+    ProductIndex.import products
+
+    assert_equal products.to_set, ProductIndex.match_all.records.to_set
+  end
+
+  def test_ids
+    products = create_list(:product, 3)
+
+    ProductIndex.import products
+
+    response = ProductIndex.match_all.response
+
+    assert_equal products.map(&:id).map(&:to_s).to_set, response.ids.to_set
+    assert_equal response.raw_response["hits"]["hits"].map { |hit| hit["_id"] }, response.ids
+  end
+
+  def test_took
+    ProductIndex.import create_list(:product, 3)
+
+    response = ProductIndex.match_all.response
+
+    assert_present response.took
+    assert_equal response.raw_response["took"], response.took
+  end
+
+  def test_aggregations
+    product1 = create(:product, price: 10, category: "category1")
+    product2 = create(:product, price: 20, category: "category2")
+    product3 = create(:product, price: 30, category: "category1")
+
+    ProductIndex.import [product1, product2, product3]
+
+    query = ProductIndex.aggregate(:category) do |aggregation|
+      aggregation.aggregate(price_sum: { sum: { field: "price" }})
+    end
+
+    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal 40, query.aggregations(:category)["category1"].price_sum.value
+    assert_equal 20, query.aggregations(:category)["category2"].price_sum.value
+  end
+end
+

data/test/search_flip/to_json_test.rb

@@ -0,0 +1,30 @@
+
+require File.expand_path("../../test_helper", __FILE__)
+require "search_flip/to_json"
+
+class SearchFlip::ToJsonTest < SearchFlip::TestCase
+  def test_time
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      assert_equal "\"2018-01-01T12:00:00.000000Z\"", Time.now.utc.to_json
+    end
+  end
+
+  def test_date
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      assert_equal "\"2018-01-01\"", Date.today.to_json
+    end
+  end
+
+  def test_date_time
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      assert_equal "\"2018-01-01T12:00:00.000000Z\"", Time.now.utc.to_json
+    end
+  end
+
+  def test_time_with_zone
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      assert_equal "\"2018-01-01T12:00:00.000000Z\"", Time.find_zone("UTC").now.to_json
+    end
+  end
+end
+

data/test/search_flip_test.rb

@@ -0,0 +1,26 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class SearchFlipTest < SearchFlip::TestCase
+  def test_msearch
+    ProductIndex.import create(:product)
+    CommentIndex.import create(:comment)
+
+    responses = SearchFlip.msearch([ProductIndex.match_all, CommentIndex.match_all])
+
+    assert_equal 2, responses.size
+    assert_equal 1, responses[0].total_entries
+    assert_equal 1, responses[1].total_entries
+  end
+
+  def test_aliases
+    assert SearchFlip.aliases(actions: [
+      add: { index: "products", alias: "alias1" }
+    ])
+
+    assert SearchFlip.aliases(actions: [
+      remove: { index: "products", alias: "alias1" }
+    ])
+  end
+end
+