searchkick-hooopo 2.3.0

data/test/aggs_test.rb

@@ -0,0 +1,197 @@
+require_relative "test_helper"
+
+class AggsTest < Minitest::Test
+  def setup
+    super
+    store [
+      {name: "Product Show", latitude: 37.7833, longitude: 12.4167, store_id: 1, in_stock: true, color: "blue", price: 21, created_at: 2.days.ago},
+      {name: "Product Hide", latitude: 29.4167, longitude: -98.5000, store_id: 2, in_stock: false, color: "green", price: 25, created_at: 2.days.from_now},
+      {name: "Product B", latitude: 43.9333, longitude: -122.4667, store_id: 2, in_stock: false, color: "red", price: 5, created_at: Time.now},
+      {name: "Foo", latitude: 43.9333, longitude: 12.4667, store_id: 3, in_stock: false, color: "yellow", price: 15, created_at: Time.now}
+    ]
+  end
+
+  def test_basic
+    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: [:store_id])
+  end
+
+  def test_where
+    assert_equal ({1 => 1}), store_agg(aggs: {store_id: {where: {in_stock: true}}})
+  end
+
+  def test_order
+    agg = Product.search("Product", aggs: {color: {order: {"_term" => "desc"}}}).aggs["color"]
+    assert_equal %w(red green blue), agg["buckets"].map { |b| b["key"] }
+  end
+
+  def test_field
+    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: {store_id: {}})
+    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: {store_id: {field: "store_id"}})
+    assert_equal ({1 => 1, 2 => 2}), store_agg({aggs: {store_id_new: {field: "store_id"}}}, "store_id_new")
+  end
+
+  def test_min_doc_count
+    assert_equal ({2 => 2}), store_agg(aggs: {store_id: {min_doc_count: 2}})
+  end
+
+  def test_no_aggs
+    assert_nil Product.search("*").aggs
+  end
+
+  def test_limit
+    agg = Product.search("Product", aggs: {store_id: {limit: 1}}).aggs["store_id"]
+    assert_equal 1, agg["buckets"].size
+    # assert_equal 3, agg["doc_count"]
+    assert_equal(1, agg["sum_other_doc_count"])
+  end
+
+  def test_ranges
+    price_ranges = [{to: 10}, {from: 10, to: 20}, {from: 20}]
+    agg = Product.search("Product", aggs: {price: {ranges: price_ranges}}).aggs["price"]
+
+    assert_equal 3, agg["buckets"].size
+    assert_equal 10.0, agg["buckets"][0]["to"]
+    assert_equal 20.0, agg["buckets"][2]["from"]
+    assert_equal 1, agg["buckets"][0]["doc_count"]
+    assert_equal 0, agg["buckets"][1]["doc_count"]
+    assert_equal 2, agg["buckets"][2]["doc_count"]
+  end
+
+  def test_date_ranges
+    ranges = [{to: 1.day.ago}, {from: 1.day.ago, to: 1.day.from_now}, {from: 1.day.from_now}]
+    agg = Product.search("Product", aggs: {created_at: {date_ranges: ranges}}).aggs["created_at"]
+
+    assert_equal 1, agg["buckets"][0]["doc_count"]
+    assert_equal 1, agg["buckets"][1]["doc_count"]
+    assert_equal 1, agg["buckets"][2]["doc_count"]
+  end
+
+  def test_query_where
+    assert_equal ({1 => 1}), store_agg(where: {in_stock: true}, aggs: [:store_id])
+  end
+
+  def test_two_wheres
+    assert_equal ({2 => 1}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false}}})
+  end
+
+  def test_where_override
+    assert_equal ({}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false, color: "blue"}}})
+    assert_equal ({2 => 1}), store_agg(where: {color: "blue"}, aggs: {store_id: {where: {in_stock: false, color: "red"}}})
+  end
+
+  def test_skip
+    assert_equal ({1 => 1, 2 => 2}), store_agg(where: {store_id: 2}, aggs: [:store_id])
+  end
+
+  def test_skip_complex
+    assert_equal ({1 => 1, 2 => 1}), store_agg(where: {store_id: 2, price: {gt: 5}}, aggs: [:store_id])
+  end
+
+  def test_multiple
+    assert_equal ({"store_id" => {1 => 1, 2 => 2}, "color" => {"blue" => 1, "green" => 1, "red" => 1}}), store_multiple_aggs(aggs: [:store_id, :color])
+  end
+
+  def test_smart_aggs_false
+    assert_equal ({2 => 2}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false}}}, smart_aggs: false)
+    assert_equal ({2 => 2}), store_agg(where: {color: "blue"}, aggs: {store_id: {where: {in_stock: false}}}, smart_aggs: false)
+  end
+
+  def test_aggs_group_by_date
+    store [{name: "Old Product", created_at: 3.years.ago}]
+    products =
+      Product.search("Product", {
+        where: {
+          created_at: {lt: Time.now}
+        },
+        aggs: {
+          products_per_year: {
+            date_histogram: {
+              field: :created_at,
+              interval: :year
+            }
+          }
+        }
+      })
+
+    assert_equal 4, products.aggs["products_per_year"]["buckets"].size
+  end
+
+  def test_aggs_avg
+    products =
+      Product.search("*", {
+        aggs: {
+          avg_price: {
+            avg: {
+              field: :price
+            }
+          }
+        }
+      })
+    assert_equal 16.5, products.aggs["avg_price"]["value"]
+  end
+
+  def test_aggs_cardinality
+    products =
+      Product.search("*", {
+        aggs: {
+          total_stores: {
+            cardinality: {
+              field: :store_id
+            }
+          }
+        }
+      })
+    assert_equal 3, products.aggs["total_stores"]["value"]
+  end
+
+  def test_aggs_min_max
+    products =
+      Product.search("*", {
+        aggs: {
+          min_price: {
+            min: {
+              field: :price
+            }
+          },
+          max_price: {
+            max: {
+              field: :price
+            }
+          }
+        }
+      })
+    assert_equal 5, products.aggs["min_price"]["value"]
+    assert_equal 25, products.aggs["max_price"]["value"]
+  end
+
+  def test_aggs_sum
+    products =
+      Product.search("*", {
+        aggs: {
+          sum_price: {
+            sum: {
+              field: :price
+            }
+          }
+        }
+      })
+    assert_equal 66, products.aggs["sum_price"]["value"]
+  end
+
+  protected
+
+  def buckets_as_hash(agg)
+    Hash[agg["buckets"].map { |v| [v["key"], v["doc_count"]] }]
+  end
+
+  def store_agg(options, agg_key = "store_id")
+    buckets = Product.search("Product", options).aggs[agg_key]
+    buckets_as_hash(buckets)
+  end
+
+  def store_multiple_aggs(options)
+    Hash[Product.search("Product", options).aggs.map do |field, filtered_agg|
+      [field, buckets_as_hash(filtered_agg)]
+    end]
+  end
+end

data/test/autocomplete_test.rb

@@ -0,0 +1,75 @@
+require_relative "test_helper"
+
+class AutocompleteTest < Minitest::Test
+  def test_autocomplete
+    store_names ["Hummus"]
+    assert_search "hum", ["Hummus"], match: :text_start
+  end
+
+  def test_autocomplete_two_words
+    store_names ["Organic Hummus"]
+    assert_search "hum", [], match: :text_start
+  end
+
+  def test_autocomplete_fields
+    store_names ["Hummus"]
+    assert_search "hum", ["Hummus"], match: :text_start, fields: [:name]
+  end
+
+  def test_text_start
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_start}]
+    assert_search "in the world", [], fields: [{name: :text_start}]
+  end
+
+  def test_text_middle
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "n the wor", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "world carmen", [], fields: [{name: :text_middle}]
+  end
+
+  def test_text_end
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_end}]
+    assert_search "carmen san", [], fields: [{name: :text_end}]
+  end
+
+  def test_word_start
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "car san wor", ["Where in the World is Carmen San Diego"], fields: [{name: :word_start}]
+  end
+
+  def test_word_middle
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "orl", ["Where in the World is Carmen San Diego"], fields: [{name: :word_middle}]
+  end
+
+  def test_word_end
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "rld men ego", ["Where in the World is Carmen San Diego"], fields: [{name: :word_end}]
+  end
+
+  def test_word_start_multiple_words
+    store_names ["Dark Grey", "Dark Blue"]
+    assert_search "dark grey", ["Dark Grey"], fields: [{name: :word_start}]
+  end
+
+  def test_word_start_exact
+    store_names ["Back Scratcher", "Backpack"]
+    assert_order "back", ["Back Scratcher", "Backpack"], fields: [{name: :word_start}]
+  end
+
+  def test_word_start_exact_martin
+    store_names ["Martina", "Martin"]
+    assert_order "martin", ["Martin", "Martina"], fields: [{name: :word_start}]
+  end
+
+  # TODO find a better place
+
+  def test_exact
+    store_names ["hi@example.org"]
+    assert_search "hi@example.org", ["hi@example.org"], fields: [{name: :exact}]
+  end
+end

data/test/boost_test.rb

@@ -0,0 +1,175 @@
+require_relative "test_helper"
+
+class BoostTest < Minitest::Test
+  # 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"]
+    assert_equal_scores "tomato", conversions: false
+  end
+
+  def test_multiple_conversions
+    store [
+      {name: "Speaker A", conversions_a: {"speaker" => 1}, conversions_b: {"speaker" => 6}},
+      {name: "Speaker B", conversions_a: {"speaker" => 2}, conversions_b: {"speaker" => 5}},
+      {name: "Speaker C", conversions_a: {"speaker" => 3}, conversions_b: {"speaker" => 4}}
+    ], Speaker
+
+    assert_equal_scores "speaker", {conversions: false}, Speaker
+    assert_equal_scores "speaker", {}, Speaker
+    assert_equal_scores "speaker", {conversions: ["conversions_a", "conversions_b"]}, Speaker
+    assert_equal_scores "speaker", {conversions: ["conversions_b", "conversions_a"]}, Speaker
+    assert_order "speaker", ["Speaker C", "Speaker B", "Speaker A"], {conversions: "conversions_a"}, Speaker
+    assert_order "speaker", ["Speaker A", "Speaker B", "Speaker C"], {conversions: "conversions_b"}, Speaker
+  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: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "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
+
+  def test_conversions_weight
+    store [
+      {name: "Product Boost", orders_count: 20},
+      {name: "Product Conversions", conversions: {"product" => 10}}
+    ]
+    assert_order "product", ["Product Conversions", "Product Boost"], boost: "orders_count"
+  end
+
+  def test_boost_fields
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10", "color"]
+  end
+
+  def test_boost_fields_decimal
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10.5", "color"]
+  end
+
+  def test_boost_fields_word_start
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: [{"name^10" => :word_start}, "color"]
+  end
+
+  # for issue #855
+  def test_apostrophes
+    store_names ["Valentine's Day Special"]
+    assert_search "Valentines", ["Valentine's Day Special"], fields: ["name^5"]
+    assert_search "Valentine's", ["Valentine's Day Special"], fields: ["name^5"]
+    assert_search "Valentine", ["Valentine's Day Special"], fields: ["name^5"]
+  end
+
+  def test_boost_by
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: [:orders_count]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: {orders_count: {factor: 10}}
+  end
+
+  def test_boost_by_boost_mode_multiply
+    store [
+      {name: "Tomato A", found_rate: 0.9},
+      {name: "Tomato B"},
+      {name: "Tomato C", found_rate: 0.5}
+    ]
+
+    assert_order "tomato", ["Tomato B", "Tomato A", "Tomato C"], boost_by: {found_rate: {boost_mode: "multiply"}}
+  end
+
+  def test_boost_where
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2]},
+      {name: "Tomato C", user_ids: [3]}
+    ]
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: 2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: 1..2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: [1, 4]}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: 2, factor: 10}}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: [1, 4], factor: 10}}
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_where: {user_ids: [{value: 1, factor: 10}, {value: 3, factor: 20}]}
+  end
+
+  def test_boost_by_distance
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: [37, -122], scale: "1000mi"}
+  end
+
+  def test_boost_by_distance_hash
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: {lat: 37, lon: -122}, scale: "1000mi"}
+  end
+
+  def test_boost_by_distance_v2
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {location: {origin: [37, -122], scale: "1000mi"}}
+  end
+
+  def test_boost_by_distance_v2_hash
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {location: {origin: {lat: 37, lon: -122}, scale: "1000mi"}}
+  end
+
+  def test_boost_by_indices
+    skip if cequel?
+
+    store_names ["Rex"], Animal
+    store_names ["Rexx"], Product
+
+    assert_order "Rex", ["Rexx", "Rex"], {index_name: [Animal, Product], indices_boost: {Animal => 1, Product => 200}, fields: [:name]}, Store
+  end
+end

data/test/callbacks_test.rb

@@ -0,0 +1,59 @@
+require_relative "test_helper"
+
+class CallbacksTest < Minitest::Test
+  def test_true_create
+    Searchkick.callbacks(true) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"]
+  end
+
+  def test_false_create
+    Searchkick.callbacks(false) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", []
+  end
+
+  def test_bulk_create
+    Searchkick.callbacks(:bulk) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"]
+  end
+
+  def test_queue
+    skip unless defined?(ActiveJob) && defined?(Redis)
+
+    reindex_queue = Product.searchkick_index.reindex_queue
+    reindex_queue.clear
+
+    Searchkick.callbacks(:queue) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", [], load: false, conversions: false
+    assert_equal 2, reindex_queue.length
+
+    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"], load: false
+    assert_equal 0, reindex_queue.length
+
+    Searchkick.callbacks(:queue) do
+      Product.where(name: "Product B").destroy_all
+      Product.create!(name: "Product C")
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"], load: false
+    assert_equal 2, reindex_queue.length
+
+    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product C"], load: false
+    assert_equal 0, reindex_queue.length
+  end
+end

data/test/ci/before_install.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -e
+
+gem install bundler
+
+if [[ $ELASTICSEARCH_VERSION == 1* ]]; then
+  curl -L -O https://download.elastic.co/elasticsearch/elasticsearch/elasticsearch-$ELASTICSEARCH_VERSION.tar.gz
+elif [[ $ELASTICSEARCH_VERSION == 2* ]]; then
+  curl -L -O https://download.elastic.co/elasticsearch/release/org/elasticsearch/distribution/tar/elasticsearch/$ELASTICSEARCH_VERSION/elasticsearch-$ELASTICSEARCH_VERSION.tar.gz
+else
+  curl -L -O https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-$ELASTICSEARCH_VERSION.tar.gz
+fi
+tar -xvf elasticsearch-$ELASTICSEARCH_VERSION.tar.gz
+cd elasticsearch-$ELASTICSEARCH_VERSION/bin
+./elasticsearch -d
+wget -O- --waitretry=1 --tries=30 --retry-connrefused -v http://127.0.0.1:9200/

data/test/errors_test.rb

@@ -0,0 +1,19 @@
+require_relative "test_helper"
+
+class ErrorsTest < Minitest::Test
+  def test_bulk_import_raises_error
+    valid_dog = Product.create(name: "2016-01-02")
+    invalid_dog = Product.create(name: "Ol' One-Leg")
+    index = Searchkick::Index.new "dogs", mappings: {
+      dog: {
+        properties: {
+          name: {type: "date"}
+        }
+      }
+    }
+    index.store valid_dog
+    assert_raises(Searchkick::ImportError) do
+      index.bulk_index [valid_dog, invalid_dog]
+    end
+  end
+end

data/test/gemfiles/activerecord31.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 3.1.0"

data/test/gemfiles/activerecord32.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 3.2.0"

data/test/gemfiles/activerecord40.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.0.0"
+gem "activejob_backport"

data/test/gemfiles/activerecord41.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.1.0"
+gem "activejob_backport"

data/test/gemfiles/activerecord42.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.2.0"

data/test/gemfiles/activerecord50.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 5.0.0"

data/test/gemfiles/apartment.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.2.0"
+gem "apartment"

data/test/gemfiles/cequel.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "cequel"
+gem "activejob"
+gem "redis"

data/test/gemfiles/mongoid2.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 2"
+gem "bson_ext"

data/test/gemfiles/mongoid3.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 3.1.0"

data/test/gemfiles/mongoid4.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 4.0.0"
+gem "activejob_backport"

data/test/gemfiles/mongoid5.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 5.0.0"
+gem "activejob"

data/test/gemfiles/mongoid6.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 6.0.0"
+gem "activejob"
+gem "redis"

data/test/gemfiles/nobrainer.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "nobrainer", ">= 0.21.0"
+gem "activejob"
+gem "redis"