diff --git a/test/aggs_test.rb b/test/aggs_test.rb
index 87f1f2c..b6066b7 100644
--- a/test/aggs_test.rb
+++ b/test/aggs_test.rb
@@ -13,16 +13,16 @@ class AggsTest < Minitest::Test
 
   def test_basic
     assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: [:store_id])
-    assert_equal ({1 => 1, 2 => 2}), buckets_as_hash(Product.search("Product", relation: true).aggs(:store_id).aggs["store_id"])
+    assert_equal ({1 => 1, 2 => 2}), buckets_as_hash(Product.search("Product").aggs(:store_id).aggs["store_id"])
   end
 
   def test_where
     assert_equal ({1 => 1}), store_agg(aggs: {store_id: {where: {in_stock: true}}})
-    assert_equal ({1 => 1}), buckets_as_hash(Product.search("Product", relation: true).aggs(store_id: {where: {in_stock: true}}).aggs["store_id"])
+    assert_equal ({1 => 1}), buckets_as_hash(Product.search("Product").aggs(store_id: {where: {in_stock: true}}).aggs["store_id"])
   end
 
   def test_relation
-    relation = Product.search("Product", relation: true).aggs(:store_id).aggs(color: {where: {in_stock: true}})
+    relation = Product.search("Product").aggs(:store_id).aggs(color: {where: {in_stock: true}})
     assert_equal ["color", "store_id"], relation.aggs.keys.sort
   end
 
@@ -30,7 +30,7 @@ class AggsTest < Minitest::Test
     agg = Product.search("Product", aggs: {color: {order: {_key: "desc"}}}).aggs["color"]
     assert_equal %w(red green blue), agg["buckets"].map { |b| b["key"] }
 
-    agg = Product.search("Product", relation: true).aggs(color: {order: {_key: "desc"}}).aggs["color"]
+    agg = Product.search("Product").aggs(color: {order: {_key: "desc"}}).aggs["color"]
     assert_equal %w(red green blue), agg["buckets"].map { |b| b["key"] }
   end
 
@@ -110,7 +110,7 @@ class AggsTest < Minitest::Test
   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)
-    assert_equal ({2 => 2}), buckets_as_hash(Product.search("Product", relation: true).where(color: "red").aggs(store_id: {where: {in_stock: false}}).smart_aggs(false).aggs["store_id"])
+    assert_equal ({2 => 2}), buckets_as_hash(Product.search("Product").where(color: "red").aggs(store_id: {where: {in_stock: false}}).smart_aggs(false).aggs["store_id"])
   end
 
   def test_aggs_group_by_date
diff --git a/test/autocomplete_test.rb b/test/autocomplete_test.rb
index 3d5fa33..5e5c39d 100644
--- a/test/autocomplete_test.rb
+++ b/test/autocomplete_test.rb
@@ -4,19 +4,19 @@ class AutocompleteTest < Minitest::Test
   def test_autocomplete
     store_names ["Hummus"]
     assert_search "hum", ["Hummus"], match: :text_start
-    assert_search_relation ["Hummus"], Product.search("hum", relation: true).match(:text_start)
+    assert_search_relation ["Hummus"], Product.search("hum").match(:text_start)
   end
 
   def test_autocomplete_two_words
     store_names ["Organic Hummus"]
     assert_search "hum", [], match: :text_start
-    assert_search_relation [], Product.search("hum", relation: true).match(:text_start)
+    assert_search_relation [], Product.search("hum").match(:text_start)
   end
 
   def test_autocomplete_fields
     store_names ["Hummus"]
     assert_search "hum", ["Hummus"], match: :text_start, fields: [:name]
-    assert_search_relation ["Hummus"], Product.search("hum", relation: true).match(:text_start).fields(:name)
+    assert_search_relation ["Hummus"], Product.search("hum").match(:text_start).fields(:name)
   end
 
   def test_text_start
@@ -74,7 +74,7 @@ class AutocompleteTest < Minitest::Test
   def test_exact
     store_names ["hi@example.org"]
     assert_search "hi@example.org", ["hi@example.org"], fields: [{name: :exact}]
-    assert_search_relation ["hi@example.org"], Product.search("hi@example.org", relation: true).fields(name: :exact)
+    assert_search_relation ["hi@example.org"], Product.search("hi@example.org").fields(name: :exact)
   end
 
   def test_exact_case
diff --git a/test/boost_test.rb b/test/boost_test.rb
index cc372e5..0a8f45d 100644
--- a/test/boost_test.rb
+++ b/test/boost_test.rb
@@ -11,7 +11,7 @@ class BoostTest < Minitest::Test
     ]
     assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"]
     assert_equal_scores "tomato", conversions: false
-    assert_equal 3, Product.search("tomato", relation: true).conversions(false).size
+    assert_equal 3, Product.search("tomato").conversions(false).size
   end
 
   def test_multiple_conversions
@@ -39,7 +39,7 @@ class BoostTest < Minitest::Test
 
     assert_order "speaker", ["Speaker A", "Speaker B", "Speaker C", "Speaker D"], {conversions: "conversions_a"}, Speaker
     assert_order "speaker", ["Speaker D", "Speaker C", "Speaker B", "Speaker A"], {conversions: "conversions_a", conversions_term: "speaker_1"}, Speaker
-    assert_order_relation ["Speaker D", "Speaker C", "Speaker B", "Speaker A"], Speaker.search("speaker", relation: true).conversions(:conversions_a).conversions_term("speaker_1")
+    assert_order_relation ["Speaker D", "Speaker C", "Speaker B", "Speaker A"], Speaker.search("speaker").conversions(:conversions_a).conversions_term("speaker_1")
   end
 
   def test_conversions_case
@@ -117,7 +117,7 @@ class BoostTest < Minitest::Test
     ]
     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}}
-    assert_order_relation ["Tomato C", "Tomato B", "Tomato A"], Product.search("tomato", relation: true).boost_by(orders_count: {factor: 10})
+    assert_order_relation ["Tomato C", "Tomato B", "Tomato A"], Product.search("tomato").boost_by(orders_count: {factor: 10})
   end
 
   def test_boost_by_missing
@@ -152,7 +152,7 @@ class BoostTest < Minitest::Test
     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}]}
 
-    assert_first_relation "Tomato B", Product.search("tomato", relation: true).boost_where(user_ids: 2)
+    assert_first_relation "Tomato B", Product.search("tomato").boost_where(user_ids: 2)
   end
 
   def test_boost_where_negative_boost
@@ -171,7 +171,7 @@ class BoostTest < Minitest::Test
       {name: "Article 3", created_at: Time.now}
     ]
     assert_order "article", ["Article 3", "Article 2", "Article 1"], boost_by_recency: {created_at: {scale: "7d", decay: 0.5}}
-    assert_order_relation ["Article 3", "Article 2", "Article 1"], Product.search("article", relation: true).boost_by_recency(created_at: {scale: "7d", decay: 0.5})
+    assert_order_relation ["Article 3", "Article 2", "Article 1"], Product.search("article").boost_by_recency(created_at: {scale: "7d", decay: 0.5})
   end
 
   def test_boost_by_recency_origin
@@ -190,7 +190,7 @@ class BoostTest < Minitest::Test
       {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"}
-    assert_order_relation ["San Francisco", "San Antonio", "San Marino"], Product.search("san", relation: true).boost_by_distance(field: :location, origin: [37, -122], scale: "1000mi")
+    assert_order_relation ["San Francisco", "San Antonio", "San Marino"], Product.search("san").boost_by_distance(field: :location, origin: [37, -122], scale: "1000mi")
   end
 
   def test_boost_by_distance_hash
@@ -209,7 +209,7 @@ class BoostTest < Minitest::Test
       {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"}}
-    assert_order_relation ["San Francisco", "San Antonio", "San Marino"], Product.search("san", relation: true).boost_by_distance(location: {origin: [37, -122], scale: "1000mi"})
+    assert_order_relation ["San Francisco", "San Antonio", "San Marino"], Product.search("san").boost_by_distance(location: {origin: [37, -122], scale: "1000mi"})
   end
 
   def test_boost_by_distance_v2_hash
@@ -240,6 +240,6 @@ class BoostTest < Minitest::Test
 
     assert_order "Rex", ["Rexx", "Rex"], {models: [Animal, Product], indices_boost: {Animal => 1, Product => 200}, fields: [:name]}, Searchkick
 
-    assert_order_relation ["Rexx", "Rex"], Searchkick.search("Rex", relation: true).models(Animal, Product).indices_boost(Animal => 1, Product => 200).fields(:name)
+    assert_order_relation ["Rexx", "Rex"], Searchkick.search("Rex").models(Animal, Product).indices_boost(Animal => 1, Product => 200).fields(:name)
   end
 end
diff --git a/test/highlight_test.rb b/test/highlight_test.rb
index f515f6a..116b816 100644
--- a/test/highlight_test.rb
+++ b/test/highlight_test.rb
@@ -4,7 +4,7 @@ class HighlightTest < Minitest::Test
   def test_basic
     store_names ["Two Door Cinema Club"]
     assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema", highlight: true).highlights.first[:name]
-    assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema", relation: true).highlight(true).highlights.first[:name]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema").highlight(true).highlights.first[:name]
   end
 
   def test_with_highlights
@@ -50,7 +50,7 @@ class HighlightTest < Minitest::Test
   def test_multiple_words
     store_names ["Hello World Hello"]
     assert_equal "<em>Hello</em> World <em>Hello</em>", Product.search("hello", highlight: true).highlights.first[:name]
-    assert_equal "<em>Hello</em> World <em>Hello</em>", Product.search("hello", relation: true).highlight(true).highlights.first[:name]
+    assert_equal "<em>Hello</em> World <em>Hello</em>", Product.search("hello").highlight(true).highlights.first[:name]
   end
 
   def test_encoder
@@ -61,7 +61,7 @@ class HighlightTest < Minitest::Test
   def test_word_middle
     store_names ["Two Door Cinema Club"]
     assert_equal "Two Door <em>Cinema</em> Club", Product.search("ine", match: :word_middle, highlight: true).highlights.first[:name]
-    assert_equal "Two Door <em>Cinema</em> Club", Product.search("ine", relation: true).match(:word_middle).highlight(true).highlights.first[:name]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("ine").match(:word_middle).highlight(true).highlights.first[:name]
   end
 
   def test_body
diff --git a/test/inheritance_test.rb b/test/inheritance_test.rb
index 15d7e33..f09002e 100644
--- a/test/inheritance_test.rb
+++ b/test/inheritance_test.rb
@@ -32,7 +32,7 @@ class InheritanceTest < Minitest::Test
     store_names ["Green Bear"], Dog
     store_names ["Blue Bear"], Cat
     assert_equal ["Blue Bear"], Animal.search("bear", type: [Cat]).map(&:name)
-    assert_equal ["Blue Bear"], Animal.search("bear", relation: true).type(Cat).map(&:name)
+    assert_equal ["Blue Bear"], Animal.search("bear").type(Cat).map(&:name)
   end
 
   def test_force_multiple_types
diff --git a/test/match_test.rb b/test/match_test.rb
index 237316e..6d7fb6c 100644
--- a/test/match_test.rb
+++ b/test/match_test.rb
@@ -175,8 +175,8 @@ class MatchTest < Minitest::Test
   def test_exclude_butter
     store_names ["Butter Tub", "Peanut Butter Tub"]
     assert_search "butter", ["Butter Tub"], exclude: ["peanut butter"]
-    assert_search_relation ["Butter Tub"], Product.search("butter", relation: true).exclude("peanut butter")
-    assert_search_relation ["Butter Tub"], Product.search("butter", relation: true).exclude(["peanut butter"])
+    assert_search_relation ["Butter Tub"], Product.search("butter").exclude("peanut butter")
+    assert_search_relation ["Butter Tub"], Product.search("butter").exclude(["peanut butter"])
   end
 
   def test_exclude_butter_word_start
diff --git a/test/misspellings_test.rb b/test/misspellings_test.rb
index 8233bc0..58659a2 100644
--- a/test/misspellings_test.rb
+++ b/test/misspellings_test.rb
@@ -4,13 +4,13 @@ class MisspellingsTest < Minitest::Test
   def test_misspellings
     store_names ["abc", "abd", "aee"]
     assert_search "abc", ["abc"], misspellings: false
-    assert_search_relation ["abc"], Product.search("abc", relation: true).misspellings(false)
+    assert_search_relation ["abc"], Product.search("abc").misspellings(false)
   end
 
   def test_misspellings_distance
     store_names ["abbb", "aabb"]
     assert_search "aaaa", ["aabb"], misspellings: {distance: 2}
-    assert_search_relation ["aabb"], Product.search("aaaa", relation: true).misspellings(distance: 2)
+    assert_search_relation ["aabb"], Product.search("aaaa").misspellings(distance: 2)
   end
 
   def test_misspellings_prefix_length
diff --git a/test/multi_search_test.rb b/test/multi_search_test.rb
index 50f167c..7f091dc 100644
--- a/test/multi_search_test.rb
+++ b/test/multi_search_test.rb
@@ -14,8 +14,8 @@ class MultiSearchTest < Minitest::Test
   def test_basic_relation
     store_names ["Product A"]
     store_names ["Store A"], Store
-    products = Product.search("*", relation: true)
-    stores = Store.search("*", relation: true)
+    products = Product.search("*")
+    stores = Store.search("*")
     Searchkick.multi_search([products, stores])
     assert_equal ["Product A"], products.map(&:name)
     assert_equal ["Store A"], stores.map(&:name)
diff --git a/test/order_test.rb b/test/order_test.rb
index c4bc91a..0aee270 100644
--- a/test/order_test.rb
+++ b/test/order_test.rb
@@ -5,14 +5,14 @@ class OrderTest < Minitest::Test
     store_names ["Product A", "Product B", "Product C", "Product D"]
     expected = ["Product D", "Product C", "Product B", "Product A"]
     assert_order "product", expected, order: {name: :desc}
-    assert_equal expected, Product.search("product", relation: true).order(name: :desc).map(&:name)
+    assert_equal expected, Product.search("product").order(name: :desc).map(&:name)
   end
 
   def test_order_string
     store_names ["Product A", "Product B", "Product C", "Product D"]
     expected = ["Product A", "Product B", "Product C", "Product D"]
     assert_order "product", expected, order: "name"
-    assert_equal expected, Product.search("product", relation: true).order("name").map(&:name)
+    assert_equal expected, Product.search("product").order("name").map(&:name)
   end
 
   def test_order_id
@@ -24,7 +24,7 @@ class OrderTest < Minitest::Test
     expected = [product_a, product_b].sort_by { |r| r.id.to_s }.map(&:name)
     assert_order "product", expected, order: {id: :asc}
     # TODO fix in query?
-    # assert_equal expected, Product.search("product", relation: true).order(id: :asc).map(&:name)
+    # assert_equal expected, Product.search("product").order(id: :asc).map(&:name)
   end
 
   def test_order_multiple
@@ -35,12 +35,12 @@ class OrderTest < Minitest::Test
     ]
     expected = ["Product A", "Product B", "Product C"]
     assert_order "product", expected, order: {color: :asc, store_id: :desc}
-    assert_equal expected, Product.search("product", relation: true).order(:color).order(store_id: :desc).map(&:name)
+    assert_equal expected, Product.search("product").order(:color).order(store_id: :desc).map(&:name)
   end
 
   def test_order_unmapped_type
     assert_order "product", [], order: {not_mapped: {unmapped_type: "long"}}
-    assert_search_relation [], Product.search("product", relation: true).order(not_mapped: {unmapped_type: "long"})
+    assert_search_relation [], Product.search("product").order(not_mapped: {unmapped_type: "long"})
   end
 
   def test_order_array
diff --git a/test/pagination_test.rb b/test/pagination_test.rb
index 832ca04..f6be682 100644
--- a/test/pagination_test.rb
+++ b/test/pagination_test.rb
@@ -45,7 +45,7 @@ class PaginationTest < Minitest::Test
 
   def test_pagination_relation
     store_names ["Product A", "Product B", "Product C", "Product D", "Product E", "Product F"]
-    products = Product.search("product", relation: true).order(name: :asc).page(2).per(2).padding(1)
+    products = Product.search("product").order(name: :asc).page(2).per(2).padding(1)
     assert_equal ["Product D", "Product E"], products.map(&:name)
     assert_equal "product", products.entry_name
     assert_equal 2, products.current_page
diff --git a/test/query_test.rb b/test/query_test.rb
index 2cfb3c4..3f6400c 100644
--- a/test/query_test.rb
+++ b/test/query_test.rb
@@ -12,22 +12,22 @@ class QueryTest < Minitest::Test
   def test_body_options
     store_names ["Milk", "Milk2"]
     assert_search "milk", ["Milk", "Milk2"], body_options: {min_score: 0.0001}
-    assert_search_relation ["Milk", "Milk2"], Product.search("milk", relation: true).body_options(min_score: 0.0001)
+    assert_search_relation ["Milk", "Milk2"], Product.search("milk").body_options(min_score: 0.0001)
   end
 
   def test_default_timeout
     assert_equal "6s", Product.search("*", execute: false).body[:timeout]
-    assert_equal "6s", Product.search("*", relation: true).body[:timeout]
+    assert_equal "6s", Product.search("*").body[:timeout]
   end
 
   def test_timeout_override
     assert_equal "1s", Product.search("*", body_options: {timeout: "1s"}, execute: false).body[:timeout]
-    assert_equal "1s", Product.search("*", relation: true).body_options(timeout: "1s").body[:timeout]
+    assert_equal "1s", Product.search("*").body_options(timeout: "1s").body[:timeout]
   end
 
   def test_request_params
     assert_equal "dfs_query_then_fetch", Product.search("*", request_params: {search_type: "dfs_query_then_fetch"}, execute: false).params[:search_type]
-    assert_equal "dfs_query_then_fetch", Product.search("*", relation: true).request_params(search_type: "dfs_query_then_fetch").params[:search_type]
+    assert_equal "dfs_query_then_fetch", Product.search("*").request_params(search_type: "dfs_query_then_fetch").params[:search_type]
   end
 
   def test_debug
@@ -41,7 +41,7 @@ class QueryTest < Minitest::Test
   def test_debug_relation
     store_names ["Milk"]
     out, _ = capture_io do
-      assert_search_relation ["Milk"], Product.search("milk", relation: true).debug(true)
+      assert_search_relation ["Milk"], Product.search("milk").debug(true)
     end
     refute_includes out, "Error"
   end
diff --git a/test/relation_test.rb b/test/relation_test.rb
index 955e6c6..8f87bb6 100644
--- a/test/relation_test.rb
+++ b/test/relation_test.rb
@@ -3,7 +3,7 @@ require_relative "test_helper"
 class RelationTest < Minitest::Test
   def test_works
     store_names ["Product A", "Product B"]
-    relation = Product.search("product", relation: true).where(name: "Product A").limit(1).offset(0).order(name: :desc)
+    relation = Product.search("product").where(name: "Product A").limit(1).offset(0).order(name: :desc)
     assert_equal ["Product A"], relation.map(&:name)
   end
 
@@ -14,7 +14,7 @@ class RelationTest < Minitest::Test
 
   def test_where
     store_names ["Product A", "Product B"]
-    assert_search_relation [], Product.search("*", relation: true).where(name: "Product A").where(name: "Product B")
+    assert_search_relation [], Product.search("*").where(name: "Product A").where(name: "Product B")
   end
 
   def test_parameters
diff --git a/test/routing_test.rb b/test/routing_test.rb
index 5b20871..2dd5ed4 100644
--- a/test/routing_test.rb
+++ b/test/routing_test.rb
@@ -5,7 +5,7 @@ class RoutingTest < Minitest::Test
     query = Store.search("Dollar Tree", routing: "Dollar Tree", execute: false)
     assert_equal query.params[:routing], "Dollar Tree"
 
-    query = Store.search("Dollar Tree", relation: true).routing("Dollar Tree")
+    query = Store.search("Dollar Tree").routing("Dollar Tree")
     assert_equal query.params[:routing], "Dollar Tree"
   end
 
diff --git a/test/scroll_test.rb b/test/scroll_test.rb
index e27879d..d062889 100644
--- a/test/scroll_test.rb
+++ b/test/scroll_test.rb
@@ -75,7 +75,7 @@ class ScrollTest < Minitest::Test
   def test_scroll_block_relation
     store_names ["Product A", "Product B", "Product C", "Product D", "Product E", "Product F"]
     batches_count = 0
-    Product.search("*", relation: true).per_page(2).scroll("1m") do |batch|
+    Product.search("*").per_page(2).scroll("1m") do |batch|
       assert_equal 2, batch.size
       batches_count += 1
     end
diff --git a/test/sql_test.rb b/test/sql_test.rb
index 8e0e873..fa6adf4 100644
--- a/test/sql_test.rb
+++ b/test/sql_test.rb
@@ -5,14 +5,14 @@ class SqlTest < Minitest::Test
     store_names ["Honey"]
     assert_search "fresh honey", []
     assert_search "fresh honey", ["Honey"], operator: "or"
-    assert_search_relation ["Honey"], Product.search("fresh honey", relation: true).operator(:or)
+    assert_search_relation ["Honey"], Product.search("fresh honey").operator(:or)
   end
 
   def test_operator_scoring
     store_names ["Big Red Circle", "Big Green Circle", "Small Orange Circle"]
     expected = ["Big Red Circle", "Big Green Circle", "Small Orange Circle"]
     assert_order "big red circle", expected, operator: "or"
-    assert_search_relation expected, Product.search("big red circle", relation: true).operator(:or)
+    assert_search_relation expected, Product.search("big red circle").operator(:or)
   end
 
   def test_fields_operator
@@ -25,7 +25,7 @@ class SqlTest < Minitest::Test
     ]
     expected = ["red", "blue", "cyan", "magenta"]
     assert_search "red blue", expected, operator: "or", fields: ["color"]
-    assert_search_relation expected, Product.search("red blue", relation: true).operator(:or).fields(:color)
+    assert_search_relation expected, Product.search("red blue").operator(:or).fields(:color)
   end
 
   def test_fields
@@ -34,7 +34,7 @@ class SqlTest < Minitest::Test
       {name: "blue", color: "red fish"}
     ]
     assert_search "blue", ["red"], fields: ["color"]
-    assert_equal ["red"], Product.search("blue", relation: true).fields(:color).map(&:name)
+    assert_equal ["red"], Product.search("blue").fields(:color).map(&:name)
   end
 
   def test_non_existent_field
@@ -56,7 +56,7 @@ class SqlTest < Minitest::Test
       {name: "Product", latitude: 80.0}
     ]
     assert_search "product", ["Product"], where: {latitude: {gt: 79}}
-    assert_search_relation ["Product"], Product.search("product", relation: true).where(latitude: {gt: 79})
+    assert_search_relation ["Product"], Product.search("product").where(latitude: {gt: 79})
   end
 
   # body_options
@@ -76,26 +76,26 @@ class SqlTest < Minitest::Test
   def test_load_false
     store_names ["Product A"]
     assert_kind_of Hash, Product.search("product", load: false).first
-    assert_kind_of Hash, Product.search("product", relation: true).load(false).first
+    assert_kind_of Hash, Product.search("product").load(false).first
   end
 
   def test_load_false_methods
     store_names ["Product A"]
     assert_equal "Product A", Product.search("product", load: false).first.name
-    assert_equal "Product A", Product.search("product", relation: true).load(false).first.name
+    assert_equal "Product A", Product.search("product").load(false).first.name
   end
 
   def test_load_false_with_includes
     store_names ["Product A"]
     assert_kind_of Hash, Product.search("product", load: false, includes: [:store]).first
-    assert_kind_of Hash, Product.search("product", relation: true).load(false).includes(:store).first
+    assert_kind_of Hash, Product.search("product").load(false).includes(:store).first
   end
 
   def test_load_false_nested_object
     aisle = {"id" => 1, "name" => "Frozen"}
     store [{name: "Product A", aisle: aisle}]
     assert_equal aisle, Product.search("product", load: false).first.aisle.to_hash
-    assert_equal aisle, Product.search("product", relation: true).load(false).first.aisle.to_hash
+    assert_equal aisle, Product.search("product").load(false).first.aisle.to_hash
   end
 
   # select
@@ -166,7 +166,7 @@ class SqlTest < Minitest::Test
 
   def test_select_relation
     store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", relation: true).load(false).select(:name, :store_id).first
+    result = Product.search("product").load(false).select(:name, :store_id).first
     assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_equal 1, result.store_id
@@ -174,13 +174,13 @@ class SqlTest < Minitest::Test
 
   def test_select_array_relation
     store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", relation: true).load(false).select(:user_ids).first
+    result = Product.search("product").load(false).select(:user_ids).first
     assert_equal [1, 2], result.user_ids
   end
 
   def test_select_single_field_relation
     store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", relation: true).load(false).select(:name).first
+    result = Product.search("product").load(false).select(:name).first
     assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_nil result.store_id
@@ -188,20 +188,20 @@ class SqlTest < Minitest::Test
 
   def test_select_all_relation
     store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", relation: true).select(true).hits.first
+    hit = Product.search("product").select(true).hits.first
     assert_equal hit["_source"]["name"], "Product A"
     assert_equal hit["_source"]["user_ids"], [1, 2]
   end
 
   def test_select_none_relation
     store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", relation: true).select(false).hits.first
+    hit = Product.search("product").select(false).hits.first
     assert_nil hit["_source"]
   end
 
   def test_select_includes_relation
     store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", relation: true).load(false).select(includes: [:name]).first
+    result = Product.search("product").load(false).select(includes: [:name]).first
     assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_nil result.store_id
@@ -209,7 +209,7 @@ class SqlTest < Minitest::Test
 
   def test_select_excludes_relation
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", relation: true).load(false).select(excludes: [:name]).first
+    result = Product.search("product").load(false).select(excludes: [:name]).first
     assert_nil result.name
     assert_equal [1, 2], result.user_ids
     assert_equal 1, result.store_id
@@ -218,7 +218,7 @@ class SqlTest < Minitest::Test
   def test_select_include_and_excludes_relation
     # let's take this to the next level
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", relation: true).load(false).select(includes: [:store_id], excludes: [:name]).first
+    result = Product.search("product").load(false).select(includes: [:store_id], excludes: [:name]).first
     assert_equal 1, result.store_id
     assert_nil result.name
     assert_nil result.user_ids
@@ -229,7 +229,7 @@ class SqlTest < Minitest::Test
   def test_nested_search
     store [{name: "Product A", aisle: {"id" => 1, "name" => "Frozen"}}], Speaker
     assert_search "frozen", ["Product A"], {fields: ["aisle.name"]}, Speaker
-    assert_equal ["Product A"], Speaker.search("frozen", relation: true).fields("aisle.name").map(&:name)
+    assert_equal ["Product A"], Speaker.search("frozen").fields("aisle.name").map(&:name)
   end
 
   # other tests
@@ -239,7 +239,7 @@ class SqlTest < Minitest::Test
 
     store_names ["Product A"]
     assert Product.search("product", includes: [:store]).first.association(:store).loaded?
-    assert Product.search("product", relation: true).includes(:store).first.association(:store).loaded?
+    assert Product.search("product").includes(:store).first.association(:store).loaded?
   end
 
   def test_model_includes
@@ -256,7 +256,7 @@ class SqlTest < Minitest::Test
       assert records.first.association(associations[klass].first).loaded?
     end
 
-    result = Searchkick.search("*", relation: true).models(Product, Store).model_includes(associations)
+    result = Searchkick.search("*").models(Product, Store).model_includes(associations)
     assert_equal 2, result.length
     result.group_by(&:class).each_pair do |klass, records|
       assert records.first.association(associations[klass].first).loaded?
@@ -268,6 +268,6 @@ class SqlTest < Minitest::Test
 
     store_names ["Product A", "Product B"]
     assert_search "product", ["Product A"], scope_results: ->(r) { r.where(name: "Product A") }
-    assert_equal ["Product A"], Product.search("product", relation: true).load(->(r) { r.where(name: "Product A") }).map(&:name)
+    assert_equal ["Product A"], Product.search("product").load(->(r) { r.where(name: "Product A") }).map(&:name)
   end
 end
diff --git a/test/suggest_test.rb b/test/suggest_test.rb
index 1922e46..02f873b 100644
--- a/test/suggest_test.rb
+++ b/test/suggest_test.rb
@@ -9,7 +9,7 @@ class SuggestTest < Minitest::Test
   def test_basic
     store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
     assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [:name]
-    assert Product.search("How Big is a Tigre Shar", relation: true).suggest(true).fields(:name).suggestions.include?("how big is a tiger shark")
+    assert Product.search("How Big is a Tigre Shar").suggest(true).fields(:name).suggestions.include?("how big is a tiger shark")
   end
 
   def test_perfect
diff --git a/test/test_helper.rb b/test/test_helper.rb
index b18f671..cad70f0 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -14,8 +14,6 @@ Searchkick.client.transport.logger = $logger
 Searchkick.search_timeout = 5
 Searchkick.index_suffix = ENV["TEST_ENV_NUMBER"] # for parallel tests
 
-# Searchkick.relation = ENV["RELATION"]
-
 # add to elasticsearch-7.0.0/config/
 Searchkick.wordnet_path = "wn_s.pl" if ENV["WORDNET"]
 
--
libgit2 0.21.0