search_flip 2.0.0.beta2 → 2.0.0.beta3

data/spec/search_flip/aggregation_spec.rb

@@ -0,0 +1,265 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+RSpec.describe SearchFlip::Aggregation do
+  describe "#where" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1", title: "title", description: "description")
+      product2 = create(:product, category: "category2", title: "title", description: "description")
+      product3 = create(:product, category: "category1", title: "title", description: "description")
+      product4 = create(:product, category: "category2", title: "title", description: "other")
+      product5 = create(:product, category: "category1", title: "other", description: "description")
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.where(title: "title").where(description: "description").aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+
+    it "works with arrays" do
+      product1 = create(:product, category: "category1", title: "title1", description: "description1")
+      product2 = create(:product, category: "category2", title: "title2", description: "description2")
+      product3 = create(:product, category: "category1", title: "title3", description: "description3")
+      product4 = create(:product, category: "category2", title: "title4", description: "other")
+      product5 = create(:product, category: "category1", title: "other", description: "description")
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation
+          .where(title: ["title1", "title2", "title3", "title4"])
+          .where(description: ["description1", "description2", "description3"])
+          .aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+
+    it "works with ranges" do
+      product1 = create(:product, category: "category1", title: "title1", price: 100)
+      product2 = create(:product, category: "category2", title: "title2", price: 150)
+      product3 = create(:product, category: "category1", title: "title3", price: 200)
+      product4 = create(:product, category: "category2", title: "title4", price: 250)
+      product5 = create(:product, category: "category1", title: "other", price: 200)
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.where(title: "title1".."title3").where(price: 100..200).aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#where_not" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1", title: "title1")
+      product2 = create(:product, category: "category2", title: "title2")
+      product3 = create(:product, category: "category1", title: "title3")
+      product4 = create(:product, category: "category2", title: "title4")
+      product5 = create(:product, category: "category1", title: "title5")
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.where_not(title: "title4").where_not(title: "title5").aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+
+    it "works with arrays" do
+      product1 = create(:product, category: "category1", title: "title1")
+      product2 = create(:product, category: "category2", title: "title2")
+      product3 = create(:product, category: "category1", title: "title3")
+      product4 = create(:product, category: "category2", title: "title4")
+      product5 = create(:product, category: "category1", title: "title5")
+      product6 = create(:product, category: "category2", title: "title6")
+      product7 = create(:product, category: "category1", title: "title7")
+
+      ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.where_not(title: ["title1", "title2"]).where_not(title: ["title6", "title7"]).aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+
+    it "works with ranges" do
+      product1 = create(:product, category: "category1", title: "title1", price: 100)
+      product2 = create(:product, category: "category2", title: "title2", price: 150)
+      product3 = create(:product, category: "category1", title: "title3", price: 200)
+      product4 = create(:product, category: "category2", title: "title4", price: 250)
+      product5 = create(:product, category: "category1", title: "title5", price: 300)
+      product6 = create(:product, category: "category2", title: "title6", price: 350)
+      product7 = create(:product, category: "category1", title: "title7", price: 400)
+
+      ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.where_not(price: 100..150).where_not(title: "title6".."title7").aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#filter" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1", title: "title", price: 100)
+      product2 = create(:product, category: "category2", title: "title", price: 150)
+      product3 = create(:product, category: "category1", title: "title", price: 200)
+      product4 = create(:product, category: "category2", title: "other", price: 200)
+      product5 = create(:product, category: "category1", title: "title", price: 250)
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.filter(range: { price: { gte: 100, lte: 200 } }).filter(term: { title: "title" }).aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#range" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1", title: "title1", price: 100)
+      product2 = create(:product, category: "category2", title: "title2", price: 150)
+      product3 = create(:product, category: "category1", title: "title3", price: 200)
+      product4 = create(:product, category: "category2", title: "title4", price: 250)
+      product5 = create(:product, category: "category1", title: "title5", price: 300)
+      product6 = create(:product, category: "category2", title: "title6", price: 350)
+      product7 = create(:product, category: "category1", title: "title7", price: 400)
+
+      ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.range(:price, gte: 100, lte: 200).range(:title, gte: "title1", lte: "title3").aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#match_all" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1")
+      product2 = create(:product, category: "category2")
+      product3 = create(:product, category: "category1")
+
+      ProductIndex.import [product1, product2, product3]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.match_all.aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#exists" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1", title: "title1", price: 10)
+      product2 = create(:product, category: "category2", title: "title2")
+      product3 = create(:product, category: "category1", title: "title3", price: 20)
+      product4 = create(:product, category: "category2", title: "title4", price: 30)
+      product5 = create(:product, category: "category1", price: 40)
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.exists(:title).exists(:price).aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#exists_not" do
+    it "sets up the constraints correctly for the aggregation and is chainable" do
+      product1 = create(:product, category: "category1")
+      product2 = create(:product, category: "category2", title: "title2")
+      product3 = create(:product, category: "category1")
+      product4 = create(:product, category: "category2")
+      product5 = create(:product, category: "category1", price: 40)
+
+      ProductIndex.import [product1, product2, product3, product4, product5]
+
+      query = ProductIndex.aggregate(category: {}) do |aggregation|
+        aggregation.exists_not(:title).exists_not(:price).aggregate(:category)
+      end
+
+      aggregations = query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+    end
+  end
+
+  describe "#aggregate" do
+    it "aggregates within an aggregation" do
+      product1 = create(:product, category: "category1", title: "title1", price: 10)
+      product2 = create(:product, category: "category1", title: "title2", price: 15)
+      product3 = create(:product, category: "category1", title: "title1", price: 20)
+      product4 = create(:product, category: "category2", title: "title2", price: 25)
+      product5 = create(:product, category: "category2", title: "title1", price: 30)
+      product6 = create(:product, category: "category2", title: "title2", price: 35)
+
+      ProductIndex.import [product1, product2, product3, product4, product5, product6]
+
+      query = ProductIndex.aggregate(:category) do |aggregation|
+        aggregation.aggregate(:title) do |aggregation2|
+          aggregation2.aggregate(price: { sum: { field: "price" } })
+        end
+      end
+
+      aggregations = query.aggregations(:category).each_with_object({}) do |(key, agg), hash|
+        hash[key] = agg.doc_count
+      end
+
+      expect(aggregations).to eq("category1" => 3, "category2" => 3)
+
+      aggregations = query.aggregations(:category)["category1"].title.buckets.each_with_object({}) do |bucket, hash|
+        hash[bucket[:key]] = bucket.doc_count
+      end
+
+      expect(aggregations).to eq("title1" => 2, "title2" => 1)
+
+      aggregations = query.aggregations(:category)["category2"].title.buckets.each_with_object({}) do |bucket, hash|
+        hash[bucket[:key]] = bucket.doc_count
+      end
+
+      expect(aggregations).to eq("title1" => 1, "title2" => 2)
+
+      expect(query.aggregations(:category)["category1"].title.buckets.detect { |bucket| bucket[:key] == "title1" }.price.value).to eq(30)
+      expect(query.aggregations(:category)["category1"].title.buckets.detect { |bucket| bucket[:key] == "title2" }.price.value).to eq(15)
+      expect(query.aggregations(:category)["category2"].title.buckets.detect { |bucket| bucket[:key] == "title1" }.price.value).to eq(30)
+      expect(query.aggregations(:category)["category2"].title.buckets.detect { |bucket| bucket[:key] == "title2" }.price.value).to eq(60)
+    end
+  end
+end

data/spec/search_flip/bulk_spec.rb

@@ -0,0 +1,78 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+RSpec.describe SearchFlip::Bulk do
+  describe "#bulk" do
+    it "uses bulk mode" do
+      product1, product2 = create_list(:product, 2)
+
+      expect(ProductIndex.total_count).to eq(0)
+
+      ProductIndex.bulk do |bulk|
+        bulk.create product1.id, ProductIndex.serialize(product1)
+        bulk.create product2.id, ProductIndex.serialize(product1)
+      end
+
+      expect(ProductIndex.total_count).to eq(2)
+
+      ProductIndex.bulk do |bulk|
+        bulk.delete product1.id
+        bulk.delete product2.id
+      end
+
+      expect(ProductIndex.total_count).to eq(0)
+    end
+
+    it "accepts and passes options" do
+      product1, product2 = create_list(:product, 2)
+
+      ProductIndex.import [product1, product2]
+
+      block = lambda do
+        ProductIndex.bulk do |bulk|
+          bulk.create product1.id, ProductIndex.serialize(product1)
+          bulk.create product2.id, ProductIndex.serialize(product1)
+        end
+      end
+
+      expect(&block).to raise_error(SearchFlip::Bulk::Error)
+
+      ProductIndex.bulk(ignore_errors: [409]) do |bulk|
+        bulk.create product1.id, ProductIndex.serialize(product1)
+        bulk.create product2.id, ProductIndex.serialize(product1)
+      end
+    end
+
+    it "accepts and passes item options" do
+      product = create(:product)
+
+      ProductIndex.bulk do |bulk|
+        bulk.index product.id, ProductIndex.serialize(product), version: 1, version_type: "external_gt"
+      end
+
+      block = lambda do
+        ProductIndex.bulk do |bulk|
+          bulk.index product.id, ProductIndex.serialize(product), version: 1, version_type: "external_gt"
+        end
+      end
+
+      expect(&block).to raise_error(SearchFlip::Bulk::Error)
+    end
+
+    it "uses the specified http_client" do
+      product = create(:product)
+
+      stub_request(:put, "#{ProductIndex.type_url}/_bulk?filter_path=errors")
+        .with(headers: { "X-Header" => "Value" })
+        .to_return(status: 500)
+
+      block = lambda do
+        ProductIndex.bulk http_client: ProductIndex.connection.http_client.headers("X-Header" => "Value") do |bulk|
+          bulk.index product.id, ProductIndex.serialize(product)
+        end
+      end
+
+      expect(&block).to raise_error(SearchFlip::ResponseError)
+    end
+  end
+end

data/spec/search_flip/connection_spec.rb

@@ -0,0 +1,211 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+RSpec.describe SearchFlip::Connection do
+  describe "#base_url" do
+    it "returns the correct url" do
+      expect(SearchFlip::Connection.new(base_url: "base url").base_url).to eq("base url")
+    end
+  end
+
+  describe "#msearch" do
+    it "sends multiple queries and returns all responses" do
+      ProductIndex.import create(:product)
+      CommentIndex.import create(:comment)
+
+      responses = SearchFlip::Connection.new.msearch([ProductIndex.match_all, CommentIndex.match_all])
+
+      expect(responses.size).to eq(2)
+      expect(responses[0].total_entries).to eq(1)
+      expect(responses[1].total_entries).to eq(1)
+    end
+  end
+
+  describe "#update_aliases" do
+    it "changes the aliases" do
+      connection = SearchFlip::Connection.new
+
+      connection.update_aliases(actions: [add: { index: "products", alias: "alias1" }])
+      expect(connection.get_aliases(alias_name: "alias1").keys).to eq(["products"])
+
+      connection.update_aliases(actions: [remove: { index: "products", alias: "alias1" }])
+      expect(connection.alias_exists?("alias1")).to eq(false)
+    end
+  end
+
+  describe "#get_aliases" do
+    it "returns the specified aliases" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        connection.update_aliases(actions: [
+          { add: { index: "comments", alias: "alias1" } },
+          { add: { index: "products", alias: "alias2" } },
+          { add: { index: "products", alias: "alias3" } }
+        ])
+
+        expect(connection.get_aliases.keys.to_set).to eq(["comments", "products"].to_set)
+        expect(connection.get_aliases["products"]["aliases"].keys.to_set).to eq(["alias2", "alias3"].to_set)
+        expect(connection.get_aliases["comments"]["aliases"].keys).to eq(["alias1"])
+        expect(connection.get_aliases(index_name: "products").keys).to eq(["products"])
+        expect(connection.get_aliases(index_name: "comments,products").keys.to_set).to eq(["comments", "products"].to_set)
+        expect(connection.get_aliases(alias_name: "alias1,alias2").keys.to_set).to eq(["comments", "products"].to_set)
+        expect(connection.get_aliases(alias_name: "alias1,alias2")["products"]["aliases"].keys).to eq(["alias2"])
+      ensure
+        connection.update_aliases(actions: [
+          { remove: { index: "comments", alias: "alias1" } },
+          { remove: { index: "products", alias: "alias2" } },
+          { remove: { index: "products", alias: "alias3" } }
+        ])
+      end
+    end
+  end
+
+  describe "#alias_exists?" do
+    it "returns whether or not the specified alias exists?" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        expect(connection.alias_exists?(:some_alias)).to eq(false)
+
+        connection.update_aliases(actions: [add: { index: "products", alias: "some_alias" }])
+
+        expect(connection.alias_exists?(:some_alias)).to eq(true)
+      ensure
+        connection.update_aliases(actions: [remove: { index: "products", alias: "some_alias" }])
+      end
+    end
+  end
+
+  describe "#get_indices" do
+    it "returns the specified indices" do
+      connection = SearchFlip::Connection.new
+
+      expect(connection.get_indices.map { |index| index["index"] }.to_set).to eq(["comments", "products"].to_set)
+      expect(connection.get_indices("com*").map { |index| index["index"] }).to eq(["comments"])
+    end
+  end
+
+  describe "#create_index" do
+    it "creates the specified index" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        expect(connection.index_exists?("index_name")).to eq(false)
+
+        connection.create_index("index_name")
+
+        expect(connection.index_exists?("index_name")).to eq(true)
+      ensure
+        connection.delete_index("index_name") if connection.index_exists?("index_name")
+      end
+    end
+
+    it "respects a payload" do
+      connection = SearchFlip::Connection.new
+
+      connection.create_index("index_name", settings: { number_of_shards: 3 })
+
+      expect(connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_shards"]).to eq("3")
+    ensure
+      connection.delete_index("index_name") if connection.index_exists?("index_name")
+    end
+  end
+
+  describe "#update_index_settings" do
+    it "updates the index settings" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        connection.create_index("index_name")
+        connection.update_index_settings("index_name", settings: { number_of_replicas: 3 })
+
+        expect(connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_replicas"]).to eq("3")
+      ensure
+        connection.delete_index("index_name") if connection.index_exists?("index_name")
+      end
+    end
+  end
+
+  describe "#get_index_settings" do
+    it "fetches the index settings" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        connection.create_index("index_name", settings: { number_of_shards: 3 })
+
+        expect(connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_shards"]).to eq("3")
+      ensure
+        connection.delete_index("index_name") if connection.index_exists?("index_name")
+      end
+    end
+  end
+
+  describe "#update_mapping" do
+    it "updates the mapping of an index" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        mapping = { "type_name" => { "properties" => { "id" => { "type" => "long" } } } }
+
+        connection.create_index("index_name")
+        connection.update_mapping("index_name", "type_name", mapping)
+
+        expect(connection.get_mapping("index_name", "type_name")).to eq("index_name" => { "mappings" => mapping })
+      ensure
+        connection.delete_index("index_name") if connection.index_exists?("index_name")
+      end
+    end
+  end
+
+  describe "#delete_index" do
+    it "deletes the specified index" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        connection.create_index("index_name")
+        expect(connection.index_exists?("index_name")).to eq(true)
+
+        connection.delete_index("index_name")
+        expect(connection.index_exists?("index_name")).to eq(false)
+      ensure
+        connection.delete_index("index_name") if connection.index_exists?("index_name")
+      end
+    end
+  end
+
+  describe "#refresh" do
+    it "refreshes all or the specified indices" do
+      begin
+        connection = SearchFlip::Connection.new
+
+        connection.create_index("index1")
+        connection.create_index("index2")
+
+        expect(connection.refresh).to be_truthy
+        expect(connection.refresh("index1")).to be_truthy
+        expect(connection.refresh(["index1", "index2"])).to be_truthy
+      ensure
+        connection.delete_index("index1") if connection.index_exists?("index1")
+        connection.delete_index("index2") if connection.index_exists?("index2")
+      end
+    end
+  end
+
+  describe "#index_url" do
+    it "returns the index url for the specified index" do
+      connection = SearchFlip::Connection.new(base_url: "base_url")
+
+      expect(connection.index_url("index_name")).to eq("base_url/index_name")
+    end
+  end
+
+  describe "#type_url" do
+    it "returns the type url for the specified index and type" do
+      connection = SearchFlip::Connection.new(base_url: "base_url")
+
+      expect(connection.type_url("index_name", "type_name")).to eq("base_url/index_name/type_name")
+    end
+  end
+end
+