thinking-sphinx 3.1.4 → 6.0.0

data/spec/acceptance/specifying_sql_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'acceptance/spec_helper'
 
 describe 'specifying SQL for index definitions' do
@@ -8,7 +10,7 @@ describe 'specifying SQL for index definitions' do
       join user
     }
     index.render
-    index.sources.first.sql_query.should match(/LEFT OUTER JOIN .users./)
+    expect(index.sources.first.sql_query).to match(/LEFT OUTER JOIN .users./)
   end
 
   it "handles deep joins" do
@@ -20,8 +22,8 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .users./)
-    query.should match(/LEFT OUTER JOIN .articles./)
+    expect(query).to match(/LEFT OUTER JOIN .users./)
+    expect(query).to match(/LEFT OUTER JOIN .articles./)
   end
 
   it "handles has-many :through joins" do
@@ -32,8 +34,8 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .taggings./)
-    query.should match(/LEFT OUTER JOIN .tags./)
+    expect(query).to match(/LEFT OUTER JOIN .taggings./)
+    expect(query).to match(/LEFT OUTER JOIN .tags./)
   end
 
   it "handles custom join SQL statements" do
@@ -45,7 +47,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/INNER JOIN foo ON foo.x = bar.y/)
+    expect(query).to match(/INNER JOIN foo ON foo.x = bar.y/)
   end
 
   it "handles GROUP BY clauses" do
@@ -57,7 +59,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/GROUP BY .articles.\..id., .?articles.?\..title., .?articles.?\..id., lat/)
+    expect(query).to match(/GROUP BY .articles.\..id., .?articles.?\..title., .?articles.?\..id., lat/)
   end
 
   it "handles WHERE clauses" do
@@ -69,7 +71,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/WHERE .+title != 'secret'.+ GROUP BY/)
+    expect(query).to match(/WHERE .+title != 'secret'.+ GROUP BY/)
   end
 
   it "handles manual MVA declarations" do
@@ -81,7 +83,7 @@ describe 'specifying SQL for index definitions' do
     }
     index.render
 
-    index.sources.first.sql_attr_multi.should == ['uint tag_ids from field']
+    expect(index.sources.first.sql_attr_multi).to eq(['uint tag_ids from field'])
   end
 
   it "provides the sanitize_sql helper within the index definition block" do
@@ -93,7 +95,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/WHERE .+title != 'secret'.+ GROUP BY/)
+    expect(query).to match(/WHERE .+title != 'secret'.+ GROUP BY/)
   end
 
   it "escapes new lines in SQL snippets" do
@@ -111,7 +113,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/\\\n/)
+    expect(query).to match(/\\\n/)
   end
 
   it "joins each polymorphic relation" do
@@ -123,9 +125,9 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should match(/LEFT OUTER JOIN .books. ON .books.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Book'/)
-    query.should match(/.articles.\..title., .books.\..title./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).to match(/LEFT OUTER JOIN .books. ON .books.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Book'/)
+    expect(query).to match(/.articles.\..title., .books.\..title./)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "concatenates references that have column" do
@@ -137,9 +139,9 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should_not match(/articles\..title., users\..title./)
-    query.should match(/.articles.\..title./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).not_to match(/articles\..title., users\..title./)
+    expect(query).to match(/.articles.\..title./)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "respects deeper associations through polymorphic joins" do
@@ -151,13 +153,31 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should match(/LEFT OUTER JOIN .users. ON .users.\..id. = .articles.\..user_id./)
-    query.should match(/.users.\..name./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).to match(/LEFT OUTER JOIN .users. ON .users.\..id. = .articles.\..user_id./)
+    expect(query).to match(/.users.\..name./)
+  end
+
+  it "allows for STI mixed with polymorphic joins" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:event)
+    index.definition_block = Proc.new {
+      indexes eventable.name, :as => :name
+      polymorphs eventable, :to => %w(Bird Car)
+    }
+    index.render
+
+    query = index.sources.first.sql_query
+    expect(query).to match(/LEFT OUTER JOIN .animals. ON .animals.\..id. = .events.\..eventable_id. .* AND .events.\..eventable_type. = 'Animal'/)
+    expect(query).to match(/LEFT OUTER JOIN .cars. ON .cars.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Car'/)
+    expect(query).to match(/.animals.\..name., .cars.\..name./)
   end
 end if ActiveRecord::VERSION::MAJOR > 3
 
 describe 'separate queries for MVAs' do
+  def id_type
+    ActiveRecord::VERSION::STRING.to_f > 5.0 ? 'bigint' : 'uint'
+  end
+
   let(:index)  { ThinkingSphinx::ActiveRecord::Index.new(:article) }
   let(:count)  { ThinkingSphinx::Configuration.instance.indices.count }
   let(:source) { index.sources.first }
@@ -174,8 +194,33 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(declaration).to eq("uint tag_ids from query")
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)$/)
+  end
+
+  it "does not include attributes sourced via separate queries" do
+    index.definition_block = Proc.new {
+      indexes title
+      has taggings.tag_id, :as => :tag_ids, :source => :query
+    }
+    index.render
+
+    # We don't want it in the SELECT, JOIN or GROUP clauses. This should catch
+    # them all.
+    expect(source.sql_query).not_to include('taggings')
+  end
+
+  it "keeps the joins in for separately queried tables if they're used elsewhere" do
+    index.definition_block = Proc.new {
+      indexes taggings.tag.name, :as => :tag_names
+      has taggings.tag.created_at, :as => :tag_dates, :source => :query
+    }
+    index.render
+
+    expect(source.sql_query).to include('taggings')
+    expect(source.sql_query).to include('tags')
+    expect(source.sql_query).to_not match(/.tags.\..created_at./)
+    expect(source.sql_query).to match(/.tags.\..name./)
   end
 
   it "generates a SQL query with joins when appropriate for MVAs" do
@@ -190,8 +235,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq("#{id_type} tag_ids from query")
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "respects has_many :through joins for MVA queries" do
@@ -206,8 +251,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq("#{id_type} tag_ids from query")
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "can handle multiple joins for MVA queries" do
@@ -224,8 +269,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.articles.\..user_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq("#{id_type} tag_ids from query")
+    expect(query).to match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.articles.\..user_id. IS NOT NULL\)\s?$/)
   end
 
   it "can handle simple HABTM joins for MVA queries" do
@@ -242,8 +287,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint genre_ids from query'
-    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres.\s?$/)
+    expect(declaration).to eq("#{id_type} genre_ids from query")
+    expect(query).to match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres.\s?$/)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "generates an appropriate range SQL queries for an MVA" do
@@ -258,9 +303,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq("uint tag_ids from ranged-query")
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVAs" do
@@ -275,9 +320,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq("#{id_type} tag_ids from ranged-query")
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
   it "can handle ranged queries for simple HABTM joins for MVA queries" do
@@ -294,9 +339,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint genre_ids from ranged-query'
-    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres. WHERE \(.books_genres.\..book_id. BETWEEN \$start AND \$end\)$/)
-    range.should match(/^SELECT MIN\(.books_genres.\..book_id.\), MAX\(.books_genres.\..book_id.\) FROM .books_genres.$/)
+    expect(declaration).to eq("#{id_type} genre_ids from ranged-query")
+    expect(query).to match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres. WHERE \(.books_genres.\..book_id. BETWEEN \$start AND \$end\)$/)
+    expect(range).to match(/^SELECT MIN\(.books_genres.\..book_id.\), MAX\(.books_genres.\..book_id.\) FROM .books_genres.$/)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "respects custom SQL snippets as the query value" do
@@ -312,8 +357,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should == 'My Custom SQL Query'
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to eq('My Custom SQL Query')
   end
 
   it "respects custom SQL snippets as the ranged query value" do
@@ -329,9 +374,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should == 'My Custom SQL Query'
-    range.should == 'And a Range'
+    expect(declaration).to eq('uint tag_ids from ranged-query')
+    expect(query).to eq('My Custom SQL Query')
+    expect(range).to eq('And a Range')
   end
 
   it "escapes new lines in custom SQL snippets" do
@@ -349,8 +394,8 @@ SQL Query
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should == "My Custom\\\nSQL Query"
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to eq("My Custom\\\nSQL Query")
   end
 end
 
@@ -368,8 +413,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "respects has_many :through joins for MVF queries" do
@@ -381,8 +426,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "can handle multiple joins for MVF queries" do
@@ -396,8 +441,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.articles.\..user_id. IS NOT NULL\)\s? ORDER BY .articles.\..user_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.articles.\..user_id. IS NOT NULL\)\s? ORDER BY .articles.\..user_id. ASC\s?$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVFs" do
@@ -409,9 +454,20 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query, range = field.split(/;\s+/)
 
-    declaration.should == 'tags from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq('tags from ranged-query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+  end
+
+  it "does not include fields sourced via separate queries" do
+    index.definition_block = Proc.new {
+      indexes taggings.tag.name, :as => :tags, :source => :query
+    }
+    index.render
+
+    # We don't want it in the SELECT, JOIN or GROUP clauses. This should catch
+    # them all.
+    expect(source.sql_query).not_to include('tags')
   end
 
   it "respects custom SQL snippets as the query value" do
@@ -423,8 +479,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should == 'My Custom SQL Query'
+    expect(declaration).to eq('tags from query')
+    expect(query).to eq('My Custom SQL Query')
   end
 
   it "respects custom SQL snippets as the ranged query value" do
@@ -437,9 +493,9 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query, range = field.split(/;\s+/)
 
-    declaration.should == 'tags from ranged-query'
-    query.should == 'My Custom SQL Query'
-    range.should == 'And a Range'
+    expect(declaration).to eq('tags from ranged-query')
+    expect(query).to eq('My Custom SQL Query')
+    expect(range).to eq('And a Range')
   end
 
   it "escapes new lines in custom SQL snippets" do
@@ -454,7 +510,7 @@ SQL Query
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should == "My Custom\\\nSQL Query"
+    expect(declaration).to eq('tags from query')
+    expect(query).to eq("My Custom\\\nSQL Query")
   end
 end

data/spec/acceptance/sphinx_scopes_spec.rb

@@ -1,41 +1,43 @@
+# frozen_string_literal: true
+
 require 'acceptance/spec_helper'
 
 describe 'Sphinx scopes', :live => true do
   it "allows calling sphinx scopes from models" do
-    gods  = Book.create! :title => 'American Gods',      :year => 2001
-    boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
-    grave = Book.create! :title => 'The Graveyard Book', :year => 2009
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
     index
 
-    Book.by_year(2009).to_a.should == [grave]
+    expect(Book.by_publishing_year(2009).to_a).to eq([grave])
   end
 
   it "allows scopes to return both query and options" do
-    gods  = Book.create! :title => 'American Gods',      :year => 2001
-    boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
-    grave = Book.create! :title => 'The Graveyard Book', :year => 2009
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
     index
 
-    Book.by_query_and_year('Graveyard', 2009).to_a.should == [grave]
+    expect(Book.by_query_and_publishing_year('Graveyard', 2009).to_a).to eq([grave])
   end
 
   it "allows chaining of scopes" do
-    gods  = Book.create! :title => 'American Gods',      :year => 2001
-    boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
-    grave = Book.create! :title => 'The Graveyard Book', :year => 2009
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
     index
 
-    Book.by_year(2001..2005).ordered.to_a.should == [boys, gods]
+    expect(Book.by_publishing_year(2001..2005).ordered.to_a).to eq([boys, gods])
   end
 
   it "allows chaining of scopes that include queries" do
-    gods  = Book.create! :title => 'American Gods',      :year => 2001
-    boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
-    grave = Book.create! :title => 'The Graveyard Book', :year => 2009
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
     index
 
-    Book.by_year(2001).by_query_and_year('Graveyard', 2009).to_a.
-      should == [grave]
+    expect(Book.by_publishing_year(2001).by_query_and_publishing_year('Graveyard', 2009).to_a).
+      to eq([grave])
   end
 
   it "allows further search calls on scopes" do
@@ -43,7 +45,7 @@ describe 'Sphinx scopes', :live => true do
     pratchett = Book.create! :title => 'Small Gods'
     index
 
-    Book.by_query('Gods').search('Small').to_a.should == [pratchett]
+    expect(Book.by_query('Gods').search('Small').to_a).to eq([pratchett])
   end
 
   it "allows facet calls on scopes" do
@@ -52,9 +54,9 @@ describe 'Sphinx scopes', :live => true do
     Book.create! :title => 'Small Gods',    :author => 'Terry Pratchett'
     index
 
-    Book.by_query('Gods').facets.to_hash[:author].should == {
+    expect(Book.by_query('Gods').facets.to_hash[:author]).to eq({
       'Neil Gaiman' => 1, 'Terry Pratchett' => 1
-    }
+    })
   end
 
   it "allows accessing counts on scopes" do
@@ -64,7 +66,7 @@ describe 'Sphinx scopes', :live => true do
     Book.create! :title => 'Night Watch'
     index
 
-    Book.by_query('gods').count.should == 2
+    expect(Book.by_query('gods').count).to eq(2)
   end
 
   it 'raises an exception when trying to modify a populated request' do
@@ -75,4 +77,11 @@ describe 'Sphinx scopes', :live => true do
       ThinkingSphinx::PopulatedResultsError
     )
   end
+
+  it "handles a chainable 'none' scope and returns nothing" do
+    Book.create! :title => 'Small Gods'
+    index
+
+    expect(Book.by_query('gods').none).to be_empty
+  end
 end

data/spec/acceptance/sql_deltas_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'acceptance/spec_helper'
 
 describe 'SQL delta indexing', :live => true do
@@ -7,38 +9,50 @@ describe 'SQL delta indexing', :live => true do
     )
     index
 
-    Book.search('Terry Pratchett').to_a.should == [guards]
+    expect(Book.search('Terry Pratchett').to_a).to eq([guards])
 
     men = Book.create(
       :title => 'Men At Arms', :author => 'Terry Pratchett'
     )
     sleep 0.25
 
-    Book.search('Terry Pratchett').to_a.should == [guards, men]
+    expect(Book.search('Terry Pratchett').to_a).to match_array([guards, men])
   end
 
   it "automatically indexes updated records" do
     book = Book.create :title => 'Night Watch', :author => 'Harry Pritchett'
     index
 
-    Book.search('Harry').to_a.should == [book]
+    expect(Book.search('Harry').to_a).to eq([book])
 
-    book.reload.update_attributes(:author => 'Terry Pratchett')
+    book.reload.update(:author => 'Terry Pratchett')
     sleep 0.25
 
-    Book.search('Terry').to_a.should == [book]
+    expect(Book.search('Terry').to_a).to eq([book])
   end
 
   it "does not match on old values" do
     book = Book.create :title => 'Night Watch', :author => 'Harry Pritchett'
     index
 
-    Book.search('Harry').to_a.should == [book]
+    expect(Book.search('Harry').to_a).to eq([book])
+
+    book.reload.update(:author => 'Terry Pratchett')
+    sleep 0.25
+
+    expect(Book.search('Harry')).to be_empty
+  end
+
+  it "does not match on old values with alternative ids" do
+    album = Album.create :name => 'Eternal Nightcap', :artist => 'The Whitloms'
+    index
+
+    expect(Album.search('Whitloms').to_a).to eq([album])
 
-    book.reload.update_attributes(:author => 'Terry Pratchett')
+    album.reload.update(:artist => 'The Whitlams')
     sleep 0.25
 
-    Book.search('Harry').should be_empty
+    expect(Book.search('Whitloms')).to be_empty
   end
 
   it "automatically indexes new records of subclasses" do
@@ -47,6 +61,18 @@ describe 'SQL delta indexing', :live => true do
     )
     sleep 0.25
 
-    Book.search('Gaiman').to_a.should == [book]
+    expect(Book.search('Gaiman').to_a).to eq([book])
+  end
+
+  it "updates associated models" do
+    colour = Colour.create(:name => 'green')
+    sleep 0.25
+
+    expect(Colour.search('green').to_a).to eq([colour])
+
+    tee = colour.tees.create
+    sleep 0.25
+
+    expect(Colour.search(:with => {:tee_ids => tee.id}).to_a).to eq([colour])
   end
 end

data/spec/acceptance/support/database_cleaner.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 RSpec.configure do |config|
   config.before(:suite) do
     DatabaseCleaner.strategy = :truncation
   end
 
-  config.after(:each) do
+  config.after(:each) do |example|
     if example.example_group_instance.class.metadata[:live]
       DatabaseCleaner.clean
     end

data/spec/acceptance/support/sphinx_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SphinxController
   def initialize
     config.searchd.mysql41 = 9307
@@ -10,14 +12,12 @@ class SphinxController
 
     ThinkingSphinx::Configuration.reset
 
-    ActiveSupport::Dependencies.loaded.each do |path|
-      $LOADED_FEATURES.delete "#{path}.rb"
-    end
-
-    ActiveSupport::Dependencies.clear
+    if Rails::VERSION::MAJOR < 7
+      ActiveSupport::Dependencies.loaded.each do |path|
+        $LOADED_FEATURES.delete "#{path}.rb"
+      end
 
-    if ENV['SPHINX_VERSION'].try :[], /2.0.\d/
-      ThinkingSphinx::Configuration.instance.settings['utf8'] = false
+      ActiveSupport::Dependencies.clear
     end
 
     config.searchd.mysql41 = 9307
@@ -28,14 +28,30 @@ class SphinxController
 
   def start
     config.controller.start
+  rescue Riddle::CommandFailedError => error
+    puts <<-TXT
+
+The Sphinx start command failed:
+  Command: #{error.command_result.command}
+  Status:  #{error.command_result.status}
+  Output:  #{error.command_result.output}
+    TXT
+    raise error
   end
 
   def stop
-    config.controller.stop
+    while config.controller.running? do
+      config.controller.stop
+      sleep(0.1)
+    end
   end
 
   def index(*indices)
-    config.controller.index *indices
+    ThinkingSphinx::Commander.call :index_sql, config, :indices => indices
+  end
+
+  def merge
+    ThinkingSphinx::Commander.call(:merge_and_update, config, {})
   end
 
   private