search_flip 2.0.0.beta2 → 2.0.0.beta3

data/spec/search_flip/http_client_spec.rb

@@ -0,0 +1,67 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+class HttpTestRequest
+  attr_accessor :calls
+
+  def initialize
+    self.calls = []
+  end
+
+  [:via, :basic_auth, :auth].each do |method|
+    define_method method do |*args|
+      dup.tap do |request|
+        request.calls = calls + [[method, args]]
+      end
+    end
+  end
+end
+
+RSpec.describe SearchFlip::HTTPClient do
+  describe "delegation" do
+    subject { SearchFlip::HTTPClient }
+
+    [:headers, :via, :basic_auth, :auth].each do |method|
+      it { should delegate(method).to(:new) }
+    end
+
+    [:get, :post, :put, :delete, :head].each do |method|
+      it { should delegate(method).to(:new) }
+    end
+  end
+
+  [:get, :put, :delete, :post, :head].each do |method|
+    describe "##{method}" do
+      it "performs the specified request" do
+        stub_request(method, "http://localhost/path").with(body: "body", query: { key: "value" }).to_return(body: "success")
+
+        expect(SearchFlip::HTTPClient.new.send(method, "http://localhost/path", body: "body", params: { key: "value" }).body.to_s).to eq("success")
+      end
+    end
+  end
+
+  [:via, :basic_auth, :auth].each do |method|
+    describe "##{method}" do
+      it "creates a dupped instance" do
+        client = SearchFlip::HTTPClient.new
+        client.request = HttpTestRequest.new
+
+        client1 = client.send(method, "key1")
+        client2 = client1.send(method, "key2")
+
+        expect(client1.object_id).not_to eq(client2.object_id)
+      end
+
+      it "extends the request" do
+        client = SearchFlip::HTTPClient.new
+        client.request = HttpTestRequest.new
+
+        client1 = client.send(method, "key1")
+        client2 = client1.send(method, "key2")
+
+        expect(client1.request.calls).to eq([[method, ["key1"]]])
+        expect(client2.request.calls).to eq([[method, ["key1"]], [method, ["key2"]]])
+      end
+    end
+  end
+end

data/spec/search_flip/index_spec.rb

@@ -0,0 +1,455 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+RSpec.describe SearchFlip::Index do
+  describe "delegation" do
+    subject { ProductIndex }
+
+    methods = [
+      :profile, :where, :where_not, :filter, :range, :match_all, :exists,
+      :exists_not, :post_where, :post_where_not, :post_filter, :post_must,
+      :post_must_not, :post_should, :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, :records, :results,
+      :should, :should_not, :must, :must_not, :find_each_result,
+      :find_results_in_batches
+    ]
+
+    methods.each do |method|
+      it { should delegate(method).to(:criteria) }
+    end
+  end
+
+  describe ".serialize" do
+    it "raises a SearchFlip::MethodNotImplemented by default" do
+      klass = Class.new do
+        include SearchFlip::Index
+      end
+
+      expect { klass.serialize(Object.new) }.to raise_error(SearchFlip::MethodNotImplemented)
+    end
+  end
+
+  describe ".type_name" do
+    it "raises a SearchFlip::MethodNotImplemented by default" do
+      klass = Class.new do
+        include SearchFlip::Index
+      end
+
+      expect { klass.type_name }.to raise_error(SearchFlip::MethodNotImplemented)
+    end
+  end
+
+  describe ".create_index" do
+    it "delegates to connection" do
+      allow(TestIndex.connection).to receive(:create_index).and_call_original
+
+      TestIndex.create_index
+
+      expect(TestIndex.connection).to have_received(:create_index).with("test", {})
+    end
+
+    it "includes the mapping if specified" do
+      mapping = { test: { properties: { id: { type: "long" } } } }
+
+      allow(TestIndex).to receive(:mapping).and_return(mapping)
+      allow(TestIndex.connection).to receive(:create_index).and_call_original
+
+      TestIndex.create_index(include_mapping: true)
+
+      expect(TestIndex.connection).to have_received(:create_index).with("test", mappings: mapping)
+    end
+
+    it "includes the index settings" do
+      allow(TestIndex).to receive(:index_settings).and_return(number_of_shards: 2)
+      allow(TestIndex.connection).to receive(:create_index).and_call_original
+
+      TestIndex.create_index
+
+      expect(TestIndex.connection).to have_received(:create_index).with("test", number_of_shards: 2)
+    end
+  end
+
+  describe ".index_exists?" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      allow(TestIndex.connection).to receive(:index_exists?).and_call_original
+
+      TestIndex.index_exists?
+
+      expect(TestIndex.connection).to have_received(:index_exists?).with("test")
+    end
+  end
+
+  describe ".delete_index" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      expect(TestIndex.index_exists?).to eq(true)
+
+      allow(TestIndex.connection).to receive(:delete_index).and_call_original
+
+      TestIndex.delete_index
+
+      expect(TestIndex.index_exists?).to eq(false)
+    end
+  end
+
+  describe ".get_index_settings" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      allow(TestIndex.connection).to receive(:get_index_settings).and_call_original
+
+      TestIndex.get_index_settings
+
+      expect(TestIndex.connection).to have_received(:get_index_settings).with("test")
+    end
+  end
+
+  describe ".update_index_settings" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      allow(TestIndex).to receive(:index_settings).and_return(number_of_replicas: 3)
+      allow(TestIndex.connection).to receive(:update_index_settings).and_call_original
+
+      TestIndex.update_index_settings
+
+      expect(TestIndex.connection).to have_received(:update_index_settings).with("test", number_of_replicas: 3)
+    end
+  end
+
+  describe ".update_mapping" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      mapping = { test: { properties: { id: { type: "long" } } } }
+
+      allow(TestIndex).to receive(:mapping).and_return(mapping)
+      allow(TestIndex.connection).to receive(:update_mapping).and_call_original
+
+      TestIndex.update_mapping
+
+      expect(TestIndex.connection).to have_received(:update_mapping).with("test", "test", mapping)
+    end
+  end
+
+  describe ".get_mapping" do
+    it "delegates to connection" do
+      TestIndex.create_index
+      TestIndex.update_mapping
+
+      allow(TestIndex.connection).to receive(:get_mapping).and_call_original
+
+      TestIndex.get_mapping
+
+      expect(TestIndex.connection).to have_received(:get_mapping).with("test", "test")
+    end
+  end
+
+  describe ".refresh" do
+    it "delegates to connection" do
+      TestIndex.create_index
+
+      allow(TestIndex.connection).to receive(:refresh).and_call_original
+
+      TestIndex.refresh
+
+      expect(TestIndex.connection).to have_received(:refresh).with("test")
+    end
+  end
+
+  describe ".index_url" do
+    it "delegates to connection" do
+      allow(TestIndex.connection).to receive(:index_url).and_call_original
+
+      TestIndex.index_url
+
+      expect(TestIndex.connection).to have_received(:index_url).with("test")
+    end
+
+    it "includes the index prefix" do
+      begin
+        SearchFlip::Config[:index_prefix] = "prefix-"
+
+        allow(TestIndex.connection).to receive(:index_url).and_call_original
+
+        TestIndex.index_url
+
+        expect(TestIndex.connection).to have_received(:index_url).with("prefix-test")
+      ensure
+        SearchFlip::Config[:index_prefix] = nil
+      end
+    end
+  end
+
+  describe ".type_url" do
+    it "delegates to connection" do
+      allow(TestIndex.connection).to receive(:type_url).and_call_original
+
+      TestIndex.type_url
+
+      expect(TestIndex.connection).to have_received(:type_url).with("test", "test")
+    end
+  end
+
+  describe ".import" do
+    it "imports an object" do
+      expect { ProductIndex.import create(:product) }.to(change { ProductIndex.total_count }.by(1))
+    end
+
+    it "imports an array of objects" do
+      expect { ProductIndex.import [create(:product), create(:product)] }.to(change { ProductIndex.total_count }.by(2))
+    end
+
+    it "imports a scope" do
+      create_list :product, 2
+
+      expect { ProductIndex.import Product.all }.to(change { ProductIndex.total_count }.by(2))
+    end
+
+    it "allows param options" do
+      products = create_list(:product, 2)
+
+      expect { ProductIndex.import products, {}, version: 1, version_type: "external" }.to(change { ProductIndex.total_count }.by(2))
+      expect { ProductIndex.import products, {}, version: 2, version_type: "external" }.not_to(change { ProductIndex.total_count })
+      expect { ProductIndex.import products, { ignore_errors: [409] }, version: 2, version_type: "external" }.not_to(change { ProductIndex.total_count })
+      expect { ProductIndex.import products, {}, version: 2, version_type: "external" }.to raise_error(SearchFlip::Bulk::Error)
+    end
+
+    it "passes param options" do
+      product = create(:product)
+
+      ProductIndex.import product, {}, version: 10, version_type: "external"
+
+      expect(ProductIndex.get(product.id)["_version"]).to eq(10)
+    end
+
+    it "passes class options" do
+      product = create(:product)
+
+      allow(ProductIndex).to receive(:index_options).and_return(version: 10, version_type: "external")
+
+      ProductIndex.import product
+
+      expect(ProductIndex.get(product.id)["_version"]).to eq(10)
+    end
+  end
+
+  describe ".index" do
+    it "indexes an object" do
+      expect { ProductIndex.index create(:product) }.to(change { ProductIndex.total_count }.by(1))
+    end
+
+    it "indexes an array of objects" do
+      expect { ProductIndex.index [create(:product), create(:product)] }.to(change { ProductIndex.total_count }.by(2))
+    end
+
+    it "indexes a scope" do
+      create_list :product, 2
+
+      expect { ProductIndex.index Product.all }.to(change { ProductIndex.total_count }.by(2))
+    end
+  end
+
+  describe ".create" do
+    it "creates an object" do
+      product = create(:product)
+
+      expect { ProductIndex.create product }.to(change { ProductIndex.total_count }.by(1))
+      expect { ProductIndex.create product }.to raise_error(SearchFlip::Bulk::Error)
+    end
+
+    it "create an array of objects" do
+      products = create_list(:product, 2)
+
+      expect { ProductIndex.create products }.to(change { ProductIndex.total_count }.by(2))
+      expect { ProductIndex.create products }.to raise_error(SearchFlip::Bulk::Error)
+    end
+
+    it "creates a scope of objects" do
+      create_list(:product, 2)
+
+      expect { ProductIndex.create Product.all }.to(change { ProductIndex.total_count }.by(2))
+      expect { ProductIndex.create Product.all }.to raise_error(SearchFlip::Bulk::Error)
+    end
+
+    it "allows respects param options" do
+      products = create_list(:product, 2)
+
+      expect { ProductIndex.create products }.to(change { ProductIndex.total_count }.by(2))
+      expect { ProductIndex.create products, ignore_errors: [409] }.not_to(change { ProductIndex.total_count })
+
+      products = create_list(:product, 2)
+
+      if ProductIndex.connection.version.to_i >= 5
+        expect { ProductIndex.create products, {}, routing: "r1" }.to(change { ProductIndex.total_count }.by(2))
+
+        expect(ProductIndex.get(products.first.id, routing: "r1")["_routing"]).to eq("r1")
+      else
+        expect { ProductIndex.create products, {}, version: 2, version_type: "external" }.to(change { ProductIndex.total_count }.by(2))
+
+        expect(ProductIndex.get(products.first.id)["_version"]).to eq(2)
+      end
+    end
+
+    it "allows respects class options" do
+      products = create_list(:product, 2)
+
+      if ProductIndex.connection.version.to_i >= 5
+        allow(ProductIndex).to receive(:index_options).and_return(routing: "r1")
+
+        expect { ProductIndex.create products }.to(change { ProductIndex.total_count }.by(2))
+
+        expect(ProductIndex.get(products.first.id, routing: "r1")["_routing"]).to eq("r1")
+      else
+        allow(ProductIndex).to receive(:index_options).and_return(version: 2, version_type: "external")
+
+        expect { ProductIndex.create products }.to(change { ProductIndex.total_count }.by(2))
+
+        expect(ProductIndex.get(products.first.id)["_version"]).to eq(2)
+      end
+    end
+  end
+
+  describe ".update" do
+    it "updates an object" do
+      product = create(:product)
+
+      ProductIndex.import product
+
+      expect { ProductIndex.update product }.not_to(change { ProductIndex.total_count })
+    end
+
+    it "updates an array of objects" do
+      products = create_list(:product, 2)
+
+      ProductIndex.import products
+
+      expect { ProductIndex.update products }.not_to(change { ProductIndex.total_count })
+    end
+
+    it "updates a scope of objects" do
+      products = create_list(:product, 2)
+
+      ProductIndex.import products
+
+      expect { ProductIndex.update Product.all }.not_to(change { ProductIndex.total_count })
+    end
+  end
+
+  describe ".delete" do
+    it "deletes an object" do
+      product = create(:product)
+
+      ProductIndex.import product
+
+      expect { ProductIndex.delete product }.to(change { ProductIndex.total_count }.by(-1))
+    end
+
+    it "deletes an array of objects" do
+      products = create_list(:product, 2)
+
+      ProductIndex.import products
+
+      expect { ProductIndex.delete products }.to(change { ProductIndex.total_count }.by(-2))
+    end
+
+    it "deletes a scope of objects" do
+      products = create_list(:product, 2)
+
+      ProductIndex.import products
+
+      expect { ProductIndex.delete Product.all }.to(change { ProductIndex.total_count }.by(-2))
+    end
+  end
+
+  describe ".get" do
+    it "retrieves the document" do
+      product = create(:product)
+
+      ProductIndex.import product
+
+      expect(ProductIndex.get(product.id)["_id"]).to eq(product.id.to_s)
+    end
+
+    it "passes params" do
+      product = create(:product)
+      ProductIndex.import product
+
+      expect(ProductIndex.get(product.id).keys).to include("_source")
+      expect(ProductIndex.get(product.id, _source: false).keys).not_to include("_source")
+    end
+  end
+
+  describe ".scope" do
+    it "adds a scope" do
+      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
+
+      expect(results).to eq([expected])
+    end
+  end
+
+  describe ".bulk" do
+    it "imports objects" do
+      bulk = proc do
+        ProductIndex.bulk do |indexer|
+          indexer.index 1, id: 1
+          indexer.index 2, id: 2
+        end
+      end
+
+      expect(&bulk).to(change { ProductIndex.total_count }.by(2))
+    end
+
+    it "respects options" do
+      ProductIndex.bulk do |indexer|
+        indexer.index 1, id: 1
+        indexer.index 2, id: 2
+      end
+
+      bulk = proc 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
+
+      expect(&bulk).to raise_error(SearchFlip::Bulk::Error)
+
+      bulk = proc do
+        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
+
+      expect(&bulk).not_to(change { ProductIndex.total_count })
+    end
+  end
+
+  describe ".connection" do
+    it "returns a SearchFlip::Connection" do
+      expect(ProductIndex.connection).to be_instance_of(SearchFlip::Connection)
+    end
+
+    it "memoizes" do
+      connection = ProductIndex.connection
+
+      expect(ProductIndex.connection).to equal(connection)
+    end
+  end
+end
+

data/spec/search_flip/model_spec.rb

@@ -0,0 +1,44 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+class TestProduct < Product
+  include SearchFlip::Model
+
+  notifies_index(ProductIndex)
+end
+
+RSpec.describe SearchFlip::Model do
+  describe "#save" do
+    it "imports the record to the index" do
+      expect(ProductIndex.total_count).to eq(0)
+
+      TestProduct.create!
+
+      expect(ProductIndex.total_count).to eq(1)
+    end
+  end
+
+  describe "#destroy" do
+    it "delete the record from the index" do
+      test_product = TestProduct.create!
+
+      expect(ProductIndex.total_count).to eq(1)
+
+      test_product.destroy
+
+      expect(ProductIndex.total_count).to eq(0)
+    end
+  end
+
+  describe "#touch" do
+    it "imports the record to the index" do
+      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 }
+
+      expect(ProductIndex.match_all.results.first.updated_at).not_to eq(updated_at)
+    end
+  end
+end