thinking-sphinx 3.2.0 → 3.3.0

data/spec/acceptance/support/database_cleaner.rb

@@ -3,7 +3,7 @@ RSpec.configure do |config|
     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

@@ -31,7 +31,10 @@ class SphinxController
   end
 
   def stop
-    config.controller.stop
+    while config.controller.running? do
+      config.controller.stop
+      sleep(0.1)
+    end
   end
 
   def index(*indices)

data/spec/acceptance/support/sphinx_helpers.rb

@@ -27,4 +27,8 @@ RSpec.configure do |config|
   config.after :all do |group|
     sphinx.stop if group.class.metadata[:live]
   end
+
+  config.after :suite do
+    SphinxController.new.stop
+  end
 end

data/spec/acceptance/suspended_deltas_spec.rb

@@ -5,50 +5,50 @@ describe 'Suspend deltas for a given action', :live => true 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])
 
     ThinkingSphinx::Deltas.suspend :book do
       book.reload.update_attributes(:author => 'Terry Pratchett')
       sleep 0.25
 
-      Book.search('Terry').to_a.should == []
+      expect(Book.search('Terry').to_a).to eq([])
     end
 
     sleep 0.25
-    Book.search('Terry').to_a.should == [book]
+    expect(Book.search('Terry').to_a).to eq([book])
   end
 
   it "returns core records even though they are no longer valid" 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])
 
     ThinkingSphinx::Deltas.suspend :book do
       book.reload.update_attributes(:author => 'Terry Pratchett')
       sleep 0.25
 
-      Book.search('Terry').to_a.should == []
+      expect(Book.search('Terry').to_a).to eq([])
     end
 
     sleep 0.25
-    Book.search('Harry').to_a.should == [book]
+    expect(Book.search('Harry').to_a).to eq([book])
   end
 
   it "marks core records as deleted" 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])
 
     ThinkingSphinx::Deltas.suspend_and_update :book do
       book.reload.update_attributes(:author => 'Terry Pratchett')
       sleep 0.25
 
-      Book.search('Terry').to_a.should == []
+      expect(Book.search('Terry').to_a).to eq([])
     end
 
     sleep 0.25
-    Book.search('Harry').to_a.should be_empty
+    expect(Book.search('Harry').to_a).to be_empty
   end
 end

data/spec/internal/app/indices/article_index.rb

@@ -5,7 +5,7 @@ ThinkingSphinx::Index.define :article, :with => :active_record do
 
   has published, user_id
   has taggings.tag_id, :as => :tag_ids, :source => :query
-  has taggings.created_at, :as => :taggings_at
+  has taggings.created_at, :as => :taggings_at, :type => :timestamp
 
   set_property :min_infix_len => 4
   set_property :enable_star   => true
@@ -18,7 +18,7 @@ ThinkingSphinx::Index.define :article, :with => :active_record,
 
   has published, user_id
   has taggings.tag_id, :as => :tag_ids
-  has taggings.created_at, :as => :taggings_at
+  has taggings.created_at, :as => :taggings_at, :type => :timestamp
 
   set_property :morphology => 'stem_en'
 end

data/spec/internal/app/indices/book_index.rb

@@ -4,5 +4,6 @@ ThinkingSphinx::Index.define :book, :with => :active_record, :delta => true do
   indexes [title, author], :as => :info
   indexes blurb_file, :file => true
 
-  has year, created_at
+  has year
+  has created_at, :type => :timestamp
 end

data/spec/internal/app/indices/product_index.rb

@@ -8,8 +8,6 @@ ThinkingSphinx::Index.define :product, :with => :real_time do
 end
 
 if multi_schema.active?
-  multi_schema.create 'thinking_sphinx'
-
   ThinkingSphinx::Index.define(:product,
     :name => :product_two, :offset_as => :product_two, :with => :real_time
   ) do

data/spec/internal/app/models/categorisation.rb

@@ -2,5 +2,12 @@ class Categorisation < ActiveRecord::Base
   belongs_to :category
   belongs_to :product
 
-  after_save ThinkingSphinx::RealTime.callback_for(:product, [:product])
+  after_commit :update_product
+
+  private
+
+  def update_product
+    product.reload
+    ThinkingSphinx::RealTime.callback_for(:product, [:product]).after_save self
+  end
 end

data/spec/spec_helper.rb

@@ -10,6 +10,8 @@ require 'thinking_sphinx/railtie'
 
 Combustion.initialize! :active_record
 
+MultiSchema.new.create 'thinking_sphinx'
+
 Dir["#{root}/support/**/*.rb"].each { |file| require file }
 
 RSpec.configure do |config|

data/spec/support/json_column.rb

@@ -6,7 +6,7 @@ class JSONColumn
   end
 
   def call
-    postgresql? && column?
+    sphinx? && postgresql? && column?
   end
 
   private
@@ -26,4 +26,8 @@ class JSONColumn
   def postgresql?
     ENV['DATABASE'] == 'postgresql'
   end
+
+  def sphinx?
+    ENV['SPHINX_VERSION'].nil? || ENV['SPHINX_VERSION'].to_f > 2.0
+  end
 end

data/spec/support/multi_schema.rb

@@ -4,12 +4,14 @@ class MultiSchema
   end
 
   def create(schema_name)
+    return unless active?
+
     unless connection.schema_exists? schema_name
       connection.execute %Q{CREATE SCHEMA "#{schema_name}"}
     end
 
     switch schema_name
-    silence_stream(STDOUT) { load Rails.root.join('db', 'schema.rb') }
+    load Rails.root.join('db', 'schema.rb')
   end
 
   def current

data/spec/support/sphinx_yaml_helpers.rb

@@ -1,6 +1,6 @@
 module SphinxYamlHelpers
   def write_configuration(hash)
-    File.stub :read => {'test' => hash}.to_yaml, :exists? => true
+    allow(File).to receive_messages :read => {'test' => hash}.to_yaml, :exists? => true
   end
 end
 

data/spec/thinking_sphinx/active_record/association_spec.rb

@@ -6,7 +6,7 @@ describe ThinkingSphinx::ActiveRecord::Association do
 
   describe '#stack' do
     it "returns the column's stack and name" do
-      association.stack.should == [:users, :post]
+      expect(association.stack).to eq([:users, :post])
     end
   end
 end

data/spec/thinking_sphinx/active_record/attribute/type_spec.rb

@@ -23,52 +23,55 @@ describe ThinkingSphinx::ActiveRecord::Attribute::Type do
     before :each do
       column.__stack << :foo
 
-      model.stub :reflect_on_association => association
+      allow(model).to receive(:reflect_on_association).and_return(association)
     end
 
     it "returns true if there are has_many associations" do
-      association.stub :macro => :has_many
+      allow(association).to receive(:macro).and_return(:has_many)
 
-      type.should be_multi
+      expect(type).to be_multi
     end
 
     it "returns true if there are has_and_belongs_to_many associations" do
-      association.stub :macro => :has_and_belongs_to_many
+      allow(association).to receive(:macro).and_return(:has_and_belongs_to_many)
 
-      type.should be_multi
+      expect(type).to be_multi
     end
 
     it "returns false if there are no associations" do
       column.__stack.clear
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns false if there are only belongs_to associations" do
-      association.stub :macro => :belongs_to
+      allow(association).to receive(:macro).and_return(:belongs_to)
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns false if there are only has_one associations" do
-      association.stub :macro => :has_one
+      allow(association).to receive(:macro).and_return(:has_one)
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns true if deeper associations have many" do
       column.__stack << :bar
       deep_association = double(:klass => double, :macro => :has_many)
-      association.stub :macro => :belongs_to,
-        :klass => double(:reflect_on_association => deep_association)
 
-      type.should be_multi
+      allow(association).to receive(:macro).and_return(:belongs_to)
+      allow(association).to receive(:klass).and_return(
+        double(:reflect_on_association => deep_association)
+      )
+
+      expect(type).to be_multi
     end
 
     it "respects the provided setting" do
       attribute.options[:multi] = true
 
-      type.should be_multi
+      expect(type).to be_multi
     end
   end
 
@@ -76,79 +79,79 @@ describe ThinkingSphinx::ActiveRecord::Attribute::Type do
     it "returns the type option provided" do
       attribute.options[:type] = :datetime
 
-      type.type.should == :datetime
+      expect(type.type).to eq(:datetime)
     end
 
     it "detects integer types from the database" do
-      db_column.stub!(:type => :integer, :sql_type => 'integer(11)')
+      allow(db_column).to receive_messages(:type => :integer, :sql_type => 'integer(11)')
 
-      type.type.should == :integer
+      expect(type.type).to eq(:integer)
     end
 
     it "detects boolean types from the database" do
-      db_column.stub!(:type => :boolean)
+      allow(db_column).to receive_messages(:type => :boolean)
 
-      type.type.should == :boolean
+      expect(type.type).to eq(:boolean)
     end
 
     it "detects datetime types from the database as timestamps" do
-      db_column.stub!(:type => :datetime)
+      allow(db_column).to receive_messages(:type => :datetime)
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it "detects date types from the database as timestamps" do
-      db_column.stub!(:type => :date)
+      allow(db_column).to receive_messages(:type => :date)
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it "detects string types from the database" do
-      db_column.stub!(:type => :string)
+      allow(db_column).to receive_messages(:type => :string)
 
-      type.type.should == :string
+      expect(type.type).to eq(:string)
     end
 
     it "detects text types from the database as strings" do
-      db_column.stub!(:type => :text)
+      allow(db_column).to receive_messages(:type => :text)
 
-      type.type.should == :string
+      expect(type.type).to eq(:string)
     end
 
     it "detects float types from the database" do
-      db_column.stub!(:type => :float)
+      allow(db_column).to receive_messages(:type => :float)
 
-      type.type.should == :float
+      expect(type.type).to eq(:float)
     end
 
     it "detects decimal types from the database as floats" do
-      db_column.stub!(:type => :decimal)
+      allow(db_column).to receive_messages(:type => :decimal)
 
-      type.type.should == :float
+      expect(type.type).to eq(:float)
     end
 
     it "detects big ints as big ints" do
-      db_column.stub :type => :bigint
+      allow(db_column).to receive_messages :type => :bigint
 
-      type.type.should == :bigint
+      expect(type.type).to eq(:bigint)
     end
 
     it "detects large integers as big ints" do
-      db_column.stub :type => :integer, :sql_type => 'bigint(20)'
+      allow(db_column).to receive_messages :type => :integer, :sql_type => 'bigint(20)'
 
-      type.type.should == :bigint
+      expect(type.type).to eq(:bigint)
     end
 
     it "detects JSON" do
-      db_column.stub :type => :json
+      allow(db_column).to receive_messages :type => :json
 
-      type.type.should == :json
+      expect(type.type).to eq(:json)
     end
 
     it "respects provided type setting" do
       attribute.options[:type] = :timestamp
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it 'raises an error if the database column does not exist' do

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -16,34 +16,34 @@ describe ThinkingSphinx::ActiveRecord::Base do
 
   describe '.facets' do
     it "returns a new search object" do
-      model.facets.should be_a(ThinkingSphinx::FacetSearch)
+      expect(model.facets).to be_a(ThinkingSphinx::FacetSearch)
     end
 
     it "passes through arguments to the search object" do
-      model.facets('pancakes').query.should == 'pancakes'
+      expect(model.facets('pancakes').query).to eq('pancakes')
     end
 
     it "scopes the search to a given model" do
-      model.facets('pancakes').options[:classes].should == [model]
+      expect(model.facets('pancakes').options[:classes]).to eq([model])
     end
 
     it "merges the :classes option with the model" do
-      model.facets('pancakes', :classes => [sub_model]).
-        options[:classes].should == [sub_model, model]
+      expect(model.facets('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
     end
 
     it "applies the default scope if there is one" do
-      model.stub :default_sphinx_scope => :default,
+      allow(model).to receive_messages :default_sphinx_scope => :default,
         :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
 
-      model.facets.options[:order].should == :created_at
+      expect(model.facets.options[:order]).to eq(:created_at)
     end
 
     it "does not apply a default scope if one is not set" do
-      model.stub :default_sphinx_scope => nil,
+      allow(model).to receive_messages :default_sphinx_scope => nil,
         :default => {:order => :created_at}
 
-      model.facets.options[:order].should be_nil
+      expect(model.facets.options[:order]).to be_nil
     end
   end
 
@@ -55,55 +55,55 @@ describe ThinkingSphinx::ActiveRecord::Base do
     end
 
     it "returns a new search object" do
-      model.search.should be_a(ThinkingSphinx::Search)
+      expect(model.search).to be_a(ThinkingSphinx::Search)
     end
 
     it "passes through arguments to the search object" do
-      model.search('pancakes').query.should == 'pancakes'
+      expect(model.search('pancakes').query).to eq('pancakes')
     end
 
     it "scopes the search to a given model" do
-      model.search('pancakes').options[:classes].should == [model]
+      expect(model.search('pancakes').options[:classes]).to eq([model])
     end
 
     it "passes through options to the search object" do
-      model.search('pancakes', populate: true).
-        options[:populate].should be_true
+      expect(model.search('pancakes', populate: true).
+        options[:populate]).to be_truthy
     end
 
     it "should automatically populate when :populate is set to true" do
-      stack.should_receive(:call).and_return(true)
+      expect(stack).to receive(:call).and_return(true)
 
       model.search('pancakes', populate: true)
     end
 
     it "merges the :classes option with the model" do
-      model.search('pancakes', :classes => [sub_model]).
-        options[:classes].should == [sub_model, model]
+      expect(model.search('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
     end
 
     it "respects provided middleware" do
-      model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
-        options[:middleware].should == ThinkingSphinx::Middlewares::RAW_ONLY
+      expect(model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
+        options[:middleware]).to eq(ThinkingSphinx::Middlewares::RAW_ONLY)
     end
 
     it "respects provided masks" do
-      model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
-        masks.should == [ThinkingSphinx::Masks::PaginationMask]
+      expect(model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
+        masks).to eq([ThinkingSphinx::Masks::PaginationMask])
     end
 
     it "applies the default scope if there is one" do
-      model.stub :default_sphinx_scope => :default,
+      allow(model).to receive_messages :default_sphinx_scope => :default,
         :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
 
-      model.search.options[:order].should == :created_at
+      expect(model.search.options[:order]).to eq(:created_at)
     end
 
     it "does not apply a default scope if one is not set" do
-      model.stub :default_sphinx_scope => nil,
+      allow(model).to receive_messages :default_sphinx_scope => nil,
         :default => {:order => :created_at}
 
-      model.search.options[:order].should be_nil
+      expect(model.search.options[:order]).to be_nil
     end
   end
 
@@ -112,18 +112,18 @@ describe ThinkingSphinx::ActiveRecord::Base do
       :populated? => false) }
 
     before :each do
-      ThinkingSphinx.stub :search => search
-      FileUtils.stub :mkdir_p => true
+      allow(ThinkingSphinx).to receive_messages :search => search
+      allow(FileUtils).to receive_messages :mkdir_p => true
     end
 
     it "returns the search object's total entries count" do
-      model.search_count.should == search.total_entries
+      expect(model.search_count).to eq(search.total_entries)
     end
 
     it "scopes the search to a given model" do
       model.search_count
 
-      search.options[:classes].should == [model]
+      expect(search.options[:classes]).to eq([model])
     end
   end
 end