searchkick 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cffaa2412f04c693b99dbd54f530b22f7ab32c53
-  data.tar.gz: 2dd98e1341946940a3cb0997400fe88d2687f540
+  metadata.gz: e5398d5720ac0d793c3e056ef46c93257da4e79a
+  data.tar.gz: 71d3ca9b8a853231cd5a285bb5b300912a7cbf5c
 SHA512:
-  metadata.gz: 16f646bd8e81672e98dc619d25814f071037b3522d63d235e64ee2aa7af782c483ab08e139411dd0a7501bb1e73163b475b9fffb69b44483525ad01d8f4b6981
-  data.tar.gz: 95b73d727ddbe424a8e9167dd2b62c2fead9fefe326a08a6da3c26cf98a33d8d824cc2c2f68921dca25b1167e26baced0cf80a802b1c976f4049a87e4cef1fec
+  metadata.gz: 0ccea382ae95b340d7bb9df48cde62f84dbceca61451cfd5dce6ca0212e73b8da464a1d9342a20be26fe9b3ef24fadf9599fbd4b09715790c9ab37c6fd6d48a8
+  data.tar.gz: 72f1350835f6a260d7fd051e677f24c3cacee5a469035b8fbc5da80c9b55c123b88e36eab0f41ce1955dd08ca55db6e8762ac0e8b9916b7f38d21a9f4424840a

data/README.md

@@ -167,13 +167,11 @@ class Product < ActiveRecord::Base
 end
 ```
 
-### Continually Improve Results
+### Keep Getting Better
 
-Searchkick uses conversion data to learn what users are looking for.
+Searchkick uses conversion data to learn what users are looking for.  If a user searches for “ice cream” and adds Ben & Jerry’s Chunky Monkey to the cart (our conversion metric at Instacart), that item gets a little more weight for similar searches.
 
-First, choose a conversion metric for your application.  At Instacart, an item added to the cart is a conversion.
-
-Next, track the conversions.  The database works well for low volume, but feel free to use Redis or another datastore.
+The first step is to define your conversion metric and start tracking conversions.  The database works well for low volume, but feel free to use Redis or another datastore.
 
 ```ruby
 class Search < ActiveRecord::Base
@@ -200,7 +198,7 @@ end
 Reindex and set up a cron job to add new conversions daily.
 
 ```ruby
-heroku run rake searchkick:reindex CLASS=Product
+rake searchkick:reindex CLASS=Product
 ```
 
 ### Facets
@@ -298,7 +296,9 @@ Product.search "milk", load: false
 2. Replace tire mapping w/ searchkick method
 
   ```ruby
-  searchkick index_name: "products_v2"
+  class Product < ActiveRecord::Base
+      searchkick
+  end
   ```
 
 3. Deploy and reindex
@@ -323,10 +323,12 @@ end
 
 ## Thanks
 
-Thanks to [Karel Minarik](https://github.com/karmi) for Tire and [Jaroslav Kalistsuk](https://github.com/jarosan) for zero downtime reindexing.
+Thanks to Karel Minarik for [Tire](https://github.com/karmi/tire) and Jaroslav Kalistsuk for [zero downtime reindexing](https://gist.github.com/jarosan/3124884).
 
 ## TODO
 
+- Custom results for each user
+- Make Searchkick work with any language
 - Built-in synonyms from WordNet
 
 ## Contributing

data/lib/searchkick/reindex.rb

@@ -22,19 +22,20 @@ module Searchkick
         end
 
         a.indices.add new_index
-        a.save
+        response = a.save
 
-        old_indices.each do |index|
-          i = Tire::Index.new(index)
-          i.delete
+        if response.success?
+          old_indices.each do |index|
+            i = Tire::Index.new(index)
+            i.delete
+          end
         end
       else
-        i = Tire::Index.new(alias_name)
-        i.delete if i.exists?
-        Tire::Alias.create(name: alias_name, indices: [new_index])
+        tire.index.delete
+        response = Tire::Alias.create(name: alias_name, indices: [new_index])
       end
 
-      true
+      response.success? || (raise response.to_s)
     end
 
     private
@@ -55,12 +56,12 @@ module Searchkick
               tokenizer: "standard",
               # synonym should come last, after stemming and shingle
               # shingle must come before snowball
-              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_index_shingle"]
+              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_index_shingle", "snowball"]
             },
             searchkick_search: {
               type: "custom",
               tokenizer: "standard",
-              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_search_shingle"]
+              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_search_shingle", "snowball"]
             },
             searchkick_search2: {
               type: "custom",
@@ -90,8 +91,12 @@ module Searchkick
           ignore_case: true,
           synonyms: synonyms.select{|s| s.size > 1 }.map{|s| "#{s[0..-2].join(",")} => #{s[-1]}" }
         }
+        # choosing a place for the synonym filter when stemming is not easy
+        # https://groups.google.com/forum/#!topic/elasticsearch/p7qcQlgHdB8
+        # TODO use a snowball stemmer on synonyms when creating the token filter
+        settings[:analysis][:analyzer][:default_index][:filter].insert(-4, "searchkick_synonym")
         settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_synonym"
-        settings[:analysis][:analyzer][:searchkick_search][:filter].insert(-2, "searchkick_synonym")
+        settings[:analysis][:analyzer][:searchkick_search][:filter].insert(-4, "searchkick_synonym")
         settings[:analysis][:analyzer][:searchkick_search][:filter] << "searchkick_synonym"
         settings[:analysis][:analyzer][:searchkick_search2][:filter] << "searchkick_synonym"
       end
@@ -109,7 +114,28 @@ module Searchkick
 
       mappings = {
         document_type.to_sym => {
-          properties: mapping
+          properties: mapping,
+          # https://gist.github.com/kimchy/2898285
+          dynamic_templates: [
+            {
+              string_template: {
+                match: "*",
+                match_mapping_type: "string",
+                mapping: {
+                  # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
+                  type: "multi_field",
+                  fields: {
+                    # analyzed field must be the default field for include_in_all
+                    # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
+                    # however, we can include the not_analyzed field in _all
+                    # and the _all index analyzer will take care of it
+                    "{name}" => {type: "string", index: "not_analyzed"},
+                    "analyzed" => {type: "string", index: "analyzed"}
+                  }
+                }
+              }
+            }
+          ]
         }
       }
 

data/lib/searchkick/search.rb

@@ -6,10 +6,17 @@ module Searchkick
       fields = options[:fields] || ["_all"]
       operator = options[:partial] ? "or" : "and"
       load = options[:load].nil? ? true : options[:load]
-      load = (options[:include] || true) if load
+      load = (options[:include] ? {include: options[:include]} : true) if load
+      page = options.has_key?(:page) ? [options[:page].to_i, 1].max : nil
+      tire_options = {
+        load: load,
+        page: page,
+        per_page: options[:limit] || options[:per_page] || 100000 # return all
+      }
+      tire_options[:index] = options[:index_name] if options[:index_name]
 
       collection =
-        tire.search load: load, page: options[:page], per_page: options[:per_page] do
+        tire.search tire_options do
           query do
             boolean do
               must do
@@ -24,10 +31,10 @@ module Searchkick
                       match fields, term, boost: 10, operator: operator, analyzer: "searchkick_search2"
                     end
                     query do
-                      match fields, term, use_dis_max: false, fuzziness: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search"
+                      match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search"
                     end
                     query do
-                      match fields, term, use_dis_max: false, fuzziness: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search2"
+                      match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search2"
                     end
                   end
                 end
@@ -36,7 +43,7 @@ module Searchkick
                 should do
                   nested path: "conversions", score_mode: "total" do
                     query do
-                      custom_score script: "log(doc['count'].value)" do
+                      custom_score script: "doc['count'].value" do
                         match "query", term
                       end
                     end
@@ -45,14 +52,14 @@ module Searchkick
               end
             end
           end
-          size options[:limit] || 100000 # return all - like sql query
           from options[:offset] if options[:offset]
           explain options[:explain] if options[:explain]
 
           # order
           if options[:order]
+            order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
             sort do
-              options[:order].each do |k, v|
+              order.each do |k, v|
                 by k, v
               end
             end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/test/boost_test.rb

@@ -0,0 +1,41 @@
+require_relative "test_helper"
+
+class TestBoost < Minitest::Unit::TestCase
+
+  # conversions
+
+  def test_conversions
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}},
+      {name: "Tomato C", conversions: {"tomato" => 3}}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"]
+  end
+
+  def test_conversions_stemmed
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1, "tomatos" => 1, "Tomatoes" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}}
+    ]
+    assert_order "tomato", ["Tomato A", "Tomato B"]
+  end
+
+  # global boost
+
+  def test_boost
+    store [
+      {name: "Organic Tomato A"},
+      {name: "Tomato B", orders_count: 10}
+    ]
+    assert_order "tomato", ["Tomato B", "Organic Tomato A"], boost: "orders_count"
+  end
+
+  def test_boost_zero
+    store [
+      {name: "Zero Boost", orders_count: 0}
+    ]
+    assert_order "zero", ["Zero Boost"], boost: "orders_count"
+  end
+
+end

data/test/facets_test.rb

@@ -0,0 +1,16 @@
+require_relative "test_helper"
+
+class TestFacets < Minitest::Unit::TestCase
+
+  def test_facets
+    store [
+      {name: "Product Show", store_id: 1, in_stock: true, color: "blue"},
+      {name: "Product Hide", store_id: 2, in_stock: false, color: "green"},
+      {name: "Product B", store_id: 2, in_stock: false, color: "red"}
+    ]
+    assert_equal 2, Product.search("Product", facets: [:store_id]).facets["store_id"]["terms"].size
+    assert_equal 1, Product.search("Product", facets: {store_id: {where: {in_stock: true}}}).facets["store_id"]["terms"].size
+    assert_equal 1, Product.search("Product", facets: {store_id: {where: {in_stock: true, color: "blue"}}}).facets["store_id"]["terms"].size
+  end
+
+end

data/test/match_test.rb

@@ -0,0 +1,113 @@
+require_relative "test_helper"
+
+class TestMatch < Minitest::Unit::TestCase
+
+  # exact
+
+  def test_match
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "milk", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  def test_case
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "MILK", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  def test_cheese_space_in_index
+    store_names ["Pepper Jack Cheese Skewers"]
+    assert_search "pepperjack cheese skewers", ["Pepper Jack Cheese Skewers"]
+  end
+
+  def test_cheese_space_in_query
+    store_names ["Pepperjack Cheese Skewers"]
+    assert_search "pepper jack cheese skewers", ["Pepperjack Cheese Skewers"]
+  end
+
+  def test_middle_token
+    store_names ["Dish Washer Amazing Organic Soap"]
+    assert_search "dish soap", ["Dish Washer Amazing Organic Soap"]
+  end
+
+  def test_percent
+    store_names ["1% Milk", "2% Milk", "Whole Milk"]
+    assert_search "1%", ["1% Milk"]
+  end
+
+  # ascii
+
+  def test_jalapenos
+    store_names ["Jalapeño"]
+    assert_search "jalapeno", ["Jalapeño"]
+  end
+
+  # stemming
+
+  def test_stemming
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "milks", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  # fuzzy
+
+  def test_misspelling_sriracha
+    store_names ["Sriracha"]
+    assert_search "siracha", ["Sriracha"]
+  end
+
+  def test_short_word
+    store_names ["Finn"]
+    assert_search "fin", ["Finn"]
+  end
+
+  def test_edit_distance
+    store_names ["Bingo"]
+    assert_search "bin", []
+    assert_search "bing", ["Bingo"]
+    assert_search "bingoo", ["Bingo"]
+    assert_search "bingooo", []
+    assert_search "ringo", ["Bingo"]
+    assert_search "mango", []
+    store_names ["thisisareallylongword"]
+    assert_search "thisisareallylongwor", ["thisisareallylongword"] # missing letter
+    assert_search "thisisareelylongword", [] # edit distance = 2
+  end
+
+  def test_misspelling_tabasco
+    store_names ["Tabasco"]
+    assert_search "tobasco", ["Tabasco"]
+  end
+
+  def test_misspelling_zucchini
+    store_names ["Zucchini"]
+    assert_search "zuchini", ["Zucchini"]
+  end
+
+  def test_misspelling_ziploc
+    store_names ["Ziploc"]
+    assert_search "zip lock", ["Ziploc"]
+  end
+
+  # spaces
+
+  def test_spaces_in_field
+    store_names ["Red Bull"]
+    assert_search "redbull", ["Red Bull"]
+  end
+
+  def test_spaces_in_query
+    store_names ["Dishwasher"]
+    assert_search "dish washer", ["Dishwasher"]
+  end
+
+  def test_spaces_three_words
+    store_names ["Dish Washer Soap", "Dish Washer"]
+    assert_search "dish washer soap", ["Dish Washer Soap"]
+  end
+
+  def test_spaces_stemming
+    store_names ["Almond Milk"]
+    assert_search "almondmilks", ["Almond Milk"]
+  end
+
+end

data/test/sql_test.rb

@@ -0,0 +1,106 @@
+require_relative "test_helper"
+
+class TestSql < Minitest::Unit::TestCase
+
+  def test_limit
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_search "product", ["Product A", "Product B"], order: {name: :asc}, limit: 2
+  end
+
+  def test_offset
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_search "product", ["Product C", "Product D"], order: {name: :asc}, offset: 2
+  end
+
+  def test_pagination
+    store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
+    assert_search "product", ["Product C", "Product D"], order: {name: :asc}, page: 2, per_page: 2
+  end
+
+  def test_pagination_nil_page
+    store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
+    assert_search "product", ["Product A", "Product B"], order: {name: :asc}, page: nil, per_page: 2
+  end
+
+  def test_where
+    now = Time.now
+    store [
+      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4},
+      {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, orders_count: 3},
+      {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, orders_count: 2},
+      {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, orders_count: 1},
+    ]
+    assert_search "product", ["Product A", "Product B"], where: {in_stock: true}
+    # date
+    assert_search "product", ["Product A"], where: {created_at: {gt: now - 1}}
+    assert_search "product", ["Product A", "Product B"], where: {created_at: {gte: now - 1}}
+    assert_search "product", ["Product D"], where: {created_at: {lt: now - 2}}
+    assert_search "product", ["Product C", "Product D"], where: {created_at: {lte: now - 2}}
+    # integer
+    assert_search "product", ["Product A"], where: {store_id: {lt: 2}}
+    assert_search "product", ["Product A", "Product B"], where: {store_id: {lte: 2}}
+    assert_search "product", ["Product D"], where: {store_id: {gt: 3}}
+    assert_search "product", ["Product C", "Product D"], where: {store_id: {gte: 3}}
+    # range
+    assert_search "product", ["Product A", "Product B"], where: {store_id: 1..2}
+    assert_search "product", ["Product A"], where: {store_id: 1...2}
+    assert_search "product", ["Product A", "Product B"], where: {store_id: [1, 2]}
+    assert_search "product", ["Product B", "Product C", "Product D"], where: {store_id: {not: 1}}
+    assert_search "product", ["Product C", "Product D"], where: {store_id: {not: [1, 2]}}
+    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{in_stock: true}, {store_id: 3}]]}
+  end
+
+  def test_where_string
+    store [
+      {name: "Product A", color: "RED"}
+    ]
+    assert_search "product", ["Product A"], where: {color: ["RED"]}
+  end
+
+  def test_order_hash
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_search "product", ["Product D", "Product C", "Product B", "Product A"], order: {name: :desc}
+  end
+
+  def test_order_string
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_search "product", ["Product A", "Product B", "Product C", "Product D"], order: "name"
+  end
+
+  def test_partial
+    store_names ["Honey"]
+    assert_search "fresh honey", []
+    assert_search "fresh honey", ["Honey"], partial: true
+  end
+
+  def test_fields
+    store [
+      {name: "red", color: "blue"},
+      {name: "blue", color: "red"}
+    ]
+    assert_search "blue", ["red"], fields: ["color"]
+  end
+
+  # load
+
+  def test_load_default
+    store_names ["Product A"]
+    assert_kind_of Product, Product.search("product").first
+  end
+
+  def test_load_false
+    store_names ["Product A"]
+    assert_kind_of Tire::Results::Item, Product.search("product", load: false).first
+  end
+
+  def test_load_false_with_include
+    store_names ["Product A"]
+    assert_kind_of Tire::Results::Item, Product.search("product", load: false, include: [:store]).first
+  end
+
+  def test_include
+    store_names ["Product A"]
+    assert Product.search("product", include: [:store]).first.association(:store).loaded?
+  end
+
+end

data/test/synonyms_test.rb

@@ -0,0 +1,45 @@
+require_relative "test_helper"
+
+class TestSynonyms < Minitest::Unit::TestCase
+
+  def test_bleach
+    store_names ["Clorox Bleach", "Kroger Bleach"]
+    assert_search "clorox", ["Clorox Bleach", "Kroger Bleach"]
+  end
+
+  def test_saran_wrap
+    store_names ["Saran Wrap", "Kroger Plastic Wrap"]
+    assert_search "saran wrap", ["Saran Wrap", "Kroger Plastic Wrap"]
+  end
+
+  def test_burger_buns
+    store_names ["Hamburger Buns"]
+    assert_search "burger buns", ["Hamburger Buns"]
+  end
+
+  def test_bandaids
+    store_names ["Band-Aid", "Kroger 12-Pack Bandages"]
+    assert_search "bandaids", ["Band-Aid", "Kroger 12-Pack Bandages"]
+  end
+
+  def test_qtips
+    store_names ["Q Tips", "Kroger Cotton Swabs"]
+    assert_search "q tips", ["Q Tips", "Kroger Cotton Swabs"]
+  end
+
+  def test_reverse
+    store_names ["Scallions"]
+    assert_search "green onions", ["Scallions"]
+  end
+
+  def test_exact
+    store_names ["Green Onions", "Yellow Onions"]
+    assert_search "scallion", ["Green Onions"]
+  end
+
+  def test_stemmed
+    store_names ["Green Onions", "Yellow Onions"]
+    assert_search "scallions", ["Green Onions"]
+  end
+
+end

data/test/test_helper.rb

@@ -24,12 +24,69 @@ ActiveRecord::Migration.create_table :products, :force => true do |t|
   t.timestamps
 end
 
-ActiveRecord::Migration.create_table :searches, :force => true do |t|
-  t.string :query
-  t.timestamp :searched_at
-  t.timestamp :converted_at
-  t.references :product
+ActiveRecord::Migration.create_table :store, :force => true do |t|
 end
 
 File.delete("elasticsearch.log") if File.exists?("elasticsearch.log")
-Tire.configure { logger "elasticsearch.log", :level => "debug" }
+Tire.configure do
+  logger "elasticsearch.log", :level => "debug"
+  pretty true
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :store
+
+  searchkick \
+    settings: {
+      number_of_shards: 1
+    },
+    synonyms: [
+      ["clorox", "bleach"],
+      ["scallion", "greenonion"],
+      ["saranwrap", "plasticwrap"],
+      ["qtip", "cotton swab"],
+      ["burger", "hamburger"],
+      ["bandaid", "bandag"]
+    ]
+
+  attr_accessor :conversions
+
+  def search_data
+    as_json.merge conversions: conversions
+  end
+end
+
+class Store < ActiveRecord::Base
+end
+
+Product.reindex
+
+class MiniTest::Unit::TestCase
+
+  def setup
+    Product.destroy_all
+  end
+
+  protected
+
+  def store(documents)
+    documents.each do |document|
+      Product.create!(document)
+    end
+    Product.index.refresh
+  end
+
+  def store_names(names)
+    store names.map{|name| {name: name} }
+  end
+
+  # no order
+  def assert_search(term, expected, options = {})
+    assert_equal expected.sort, Product.search(term, options).map(&:name).sort
+  end
+
+  def assert_order(term, expected, options = {})
+    assert_equal expected, Product.search(term, options).map(&:name)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-30 00:00:00.000000000 Z
+date: 2013-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tire
@@ -113,7 +113,11 @@ files:
 - lib/searchkick/tasks.rb
 - lib/searchkick/version.rb
 - searchkick.gemspec
-- test/searchkick_test.rb
+- test/boost_test.rb
+- test/facets_test.rb
+- test/match_test.rb
+- test/sql_test.rb
+- test/synonyms_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ankane/searchkick
 licenses:
@@ -140,5 +144,9 @@ signing_key:
 specification_version: 4
 summary: Search made easy
 test_files:
-- test/searchkick_test.rb
+- test/boost_test.rb
+- test/facets_test.rb
+- test/match_test.rb
+- test/sql_test.rb
+- test/synonyms_test.rb
 - test/test_helper.rb

data/test/searchkick_test.rb

@@ -1,286 +0,0 @@
-require "test_helper"
-
-class Product < ActiveRecord::Base
-  has_many :searches
-
-  searchkick \
-    synonyms: [
-      ["clorox", "bleach"],
-      ["scallion", "greenonion"],
-      ["saranwrap", "plasticwrap"],
-      ["qtip", "cotton swab"],
-      ["burger", "hamburger"],
-      ["bandaid", "bandag"]
-    ],
-    settings: {
-      number_of_shards: 1
-    }
-
-  def search_data
-    as_json.merge conversions: searches.group("query").count
-  end
-end
-
-class Search < ActiveRecord::Base
-  belongs_to :product
-end
-
-Product.reindex
-
-class TestSearchkick < Minitest::Unit::TestCase
-
-  def setup
-    Search.delete_all
-    Product.destroy_all
-  end
-
-  # exact
-
-  def test_match
-    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
-    assert_search "milk", ["Milk", "Whole Milk", "Fat Free Milk"]
-  end
-
-  def test_case
-    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
-    assert_search "MILK", ["Milk", "Whole Milk", "Fat Free Milk"]
-  end
-
-  def test_cheese_space_in_index
-    store_names ["Pepper Jack Cheese Skewers"]
-    assert_search "pepperjack cheese skewers", ["Pepper Jack Cheese Skewers"]
-  end
-
-  def test_cheese_space_in_query
-    store_names ["Pepperjack Cheese Skewers"]
-    assert_search "pepper jack cheese skewers", ["Pepperjack Cheese Skewers"]
-  end
-
-  def test_middle_token
-    store_names ["Dish Washer Amazing Organic Soap"]
-    assert_search "dish soap", ["Dish Washer Amazing Organic Soap"]
-  end
-
-  def test_percent
-    store_names ["1% Milk", "2% Milk", "Whole Milk"]
-    assert_search "1%", ["1% Milk"]
-  end
-
-  # ascii
-
-  def test_jalapenos
-    store_names ["Jalapeño"]
-    assert_search "jalapeno", ["Jalapeño"]
-  end
-
-  # stemming
-
-  def test_stemming
-    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
-    assert_search "milks", ["Milk", "Whole Milk", "Fat Free Milk"]
-  end
-
-  # fuzzy
-
-  def test_misspelling_sriracha
-    store_names ["Sriracha"]
-    assert_search "siracha", ["Sriracha"]
-  end
-
-  def test_misspelling_tabasco
-    store_names ["Tabasco"]
-    assert_search "tobasco", ["Tabasco"]
-  end
-
-  def test_misspelling_zucchini
-    store_names ["Zucchini"]
-    assert_search "zuchini", ["Zucchini"]
-  end
-
-  def test_misspelling_ziploc
-    store_names ["Ziploc"]
-    assert_search "zip lock", ["Ziploc"]
-  end
-
-  # conversions
-
-  def test_conversions
-    store_conversions [
-      {name: "Tomato Sauce", conversions: [{query: "tomato sauce", count: 5}, {query: "tomato", count: 20}]},
-      {name: "Tomato Paste", conversions: []},
-      {name: "Tomatoes", conversions: [{query: "tomato", count: 10}, {query: "tomato sauce", count: 2}]}
-    ]
-    assert_search "tomato", ["Tomato Sauce", "Tomatoes", "Tomato Paste"]
-  end
-
-  def test_conversions_stemmed
-    store_conversions [
-      {name: "Tomato A", conversions: [{query: "tomato", count: 2}, {query: "tomatos", count: 2}, {query: "Tomatoes", count: 2}]},
-      {name: "Tomato B", conversions: [{query: "tomato", count: 4}]}
-    ]
-    assert_search "tomato", ["Tomato A", "Tomato B"]
-  end
-
-  # spaces
-
-  def test_spaces_in_field
-    store_names ["Red Bull"]
-    assert_search "redbull", ["Red Bull"]
-  end
-
-  def test_spaces_in_query
-    store_names ["Dishwasher Soap"]
-    assert_search "dish washer", ["Dishwasher Soap"]
-  end
-
-  def test_spaces_three_words
-    store_names ["Dish Washer Soap", "Dish Washer"]
-    assert_search "dish washer soap", ["Dish Washer Soap"]
-  end
-
-  def test_spaces_stemming
-    store_names ["Almond Milk"]
-    assert_search "almondmilks", ["Almond Milk"]
-  end
-
-  # keywords
-
-  def test_keywords
-    store_names ["Clorox Bleach", "Kroger Bleach", "Saran Wrap", "Kroger Plastic Wrap", "Hamburger Buns", "Band-Aid", "Kroger 12-Pack Bandages"]
-    assert_search "clorox", ["Clorox Bleach", "Kroger Bleach"]
-    assert_search "saran wrap", ["Saran Wrap", "Kroger Plastic Wrap"]
-    assert_search "burger buns", ["Hamburger Buns"]
-    assert_search "bandaids", ["Band-Aid", "Kroger 12-Pack Bandages"]
-  end
-
-  def test_keywords_qtips
-    store_names ["Q Tips", "Kroger Cotton Swabs"]
-    assert_search "q tips", ["Q Tips", "Kroger Cotton Swabs"]
-  end
-
-  def test_keywords_reverse
-    store_names ["Scallions"]
-    assert_search "green onions", ["Scallions"]
-  end
-
-  def test_keywords_exact
-    store_names ["Green Onions", "Yellow Onions"]
-    assert_search "scallion", ["Green Onions"]
-  end
-
-  def test_keywords_stemmed
-    store_names ["Green Onions", "Yellow Onions"]
-    assert_search "scallions", ["Green Onions"]
-  end
-
-  # global boost
-
-  def test_boost
-    store [
-      {name: "Organic Tomato A"},
-      {name: "Tomato B", orders_count: 10}
-    ]
-    assert_search "tomato", ["Tomato B", "Organic Tomato A"], boost: "orders_count"
-  end
-
-  def test_boost_zero
-    store [
-      {name: "Zero Boost", orders_count: 0}
-    ]
-    assert_search "zero", ["Zero Boost"], boost: "orders_count"
-  end
-
-  # search method
-
-  def test_limit
-    store_names ["Product A", "Product B"]
-    assert_equal 1, Product.search("Product", limit: 1).size
-  end
-
-  def test_offset
-    store_names ["Product A", "Product B"]
-    assert_equal 1, Product.search("Product", offset: 1).size
-  end
-
-  def test_where
-    now = Time.now
-    store [
-      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4},
-      {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, orders_count: 3},
-      {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, orders_count: 2},
-      {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, orders_count: 1},
-    ]
-    assert_search "product", ["Product A", "Product B"], where: {in_stock: true}
-    # date
-    assert_search "product", ["Product A"], where: {created_at: {gt: now - 1}}
-    assert_search "product", ["Product A", "Product B"], where: {created_at: {gte: now - 1}}
-    assert_search "product", ["Product D"], where: {created_at: {lt: now - 2}}
-    assert_search "product", ["Product C", "Product D"], where: {created_at: {lte: now - 2}}
-    # integer
-    assert_search "product", ["Product A"], where: {store_id: {lt: 2}}
-    assert_search "product", ["Product A", "Product B"], where: {store_id: {lte: 2}}
-    assert_search "product", ["Product D"], where: {store_id: {gt: 3}}
-    assert_search "product", ["Product C", "Product D"], where: {store_id: {gte: 3}}
-    # range
-    assert_search "product", ["Product A", "Product B"], where: {store_id: 1..2}
-    assert_search "product", ["Product A"], where: {store_id: 1...2}
-    assert_search "product", ["Product A", "Product B"], where: {store_id: [1, 2]}
-    assert_search "product", ["Product B", "Product C", "Product D"], where: {store_id: {not: 1}}
-    assert_search "product", ["Product C", "Product D"], where: {store_id: {not: [1, 2]}}
-    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{in_stock: true}, {store_id: 3}]]}
-  end
-
-  def test_order
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_search "product", ["Product D", "Product C", "Product B", "Product A"], order: {name: :desc}
-  end
-
-  def test_facets
-    store [
-      {name: "Product Show", store_id: 1, in_stock: true, color: "blue"},
-      {name: "Product Hide", store_id: 2, in_stock: false, color: "green"},
-      {name: "Product B", store_id: 2, in_stock: false, color: "red"}
-    ]
-    assert_equal 2, Product.search("Product", facets: [:store_id]).facets["store_id"]["terms"].size
-    assert_equal 1, Product.search("Product", facets: {store_id: {where: {in_stock: true}}}).facets["store_id"]["terms"].size
-    assert_equal 1, Product.search("Product", facets: {store_id: {where: {in_stock: true, color: "blue"}}}).facets["store_id"]["terms"].size
-  end
-
-  def test_partial
-    store_names ["Honey"]
-    assert_search "fresh honey", []
-    assert_search "fresh honey", ["Honey"], partial: true
-  end
-
-  protected
-
-  def store(documents)
-    documents.each do |document|
-      Product.create!(document)
-    end
-    Product.index.refresh
-  end
-
-  def store_names(names)
-    store names.map{|name| {name: name} }
-  end
-
-  def store_conversions(documents)
-    documents.each do |document|
-      conversions = document.delete(:conversions)
-      product = Product.create!(document)
-      conversions.each do |c|
-        c[:count].times do
-          product.searches.create!(query: c[:query])
-        end
-      end
-    end
-    Product.reindex
-    Product.index.refresh
-  end
-
-  def assert_search(term, expected, options = {})
-    assert_equal expected, Product.search(term, options.merge(fields: [:name])).map(&:name)
-  end
-
-end