sunspot_rails 2.2.6 → 2.6.0

data/spec/{rails_template → rails_app}/config/sunspot.yml

@@ -2,6 +2,7 @@ test:
   solr:
     hostname: localhost
     port: 8983
+    update_format: <%= ENV.fetch('UPDATE_FORMAT', 'xml') %>
   auto_index_callback: after_save
   auto_remove_callback: after_destroy
 development:
@@ -22,6 +23,7 @@ config_test:
     bind_address: 127.0.0.1
     read_timeout: 2
     open_timeout: 0.5
+    update_format: json
     proxy: http://proxy.com:12345
   auto_commit_after_request: false
   auto_commit_after_delete_request: true

data/spec/rails_app/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run RailsApp::Application

data/spec/rails_app/db/schema.rb

@@ -0,0 +1,26 @@
+ActiveRecord::Schema.define(version: 0) do
+  create_table :posts, force: :cascade do |t|
+    t.string :title
+    t.string :type
+    t.integer :location_id
+    t.text :body
+    t.references :blog
+    t.timestamps null: true
+  end
+
+  create_table :locations, force: :cascade do |t|
+    t.float :lat
+    t.float :lng
+  end
+
+  create_table :blogs, force: :cascade do |t|
+    t.string :name
+    t.string :subdomain
+    t.timestamps null: true
+  end
+
+  create_table :writers, force: :cascade, primary_key: :writer_id do |t|
+    t.string :name
+    t.timestamps null: true
+  end
+end

data/spec/rails_app/vendor/engines/test_engine/app/models/test_engine/rake_task_auto_load_test_model.rb

@@ -0,0 +1,15 @@
+# This model should not be used for any test other than the spec test that
+# checks if all models are loaded. We don't want to pre-load this model in
+# another test because we're checking to see if it will be auto-loaded by
+# the reindex task
+module TestEngine
+  class RakeTaskAutoLoadTestModel < ActiveRecord::Base
+    def self.table_name
+      'posts'
+    end
+
+    searchable do
+      string :name
+    end
+  end
+end

data/spec/rails_app/vendor/engines/test_engine/lib/test_engine/engine.rb

@@ -0,0 +1,5 @@
+module TestEngine
+  class Engine < ::Rails::Engine
+    engine_name 'sunspot_rails_test_engine'
+  end
+end

data/spec/rails_app/vendor/engines/test_engine/lib/test_engine.rb

@@ -0,0 +1,4 @@
+require_relative "test_engine/engine"
+
+module TestEngine
+end

data/spec/rake_task_spec.rb

@@ -11,28 +11,28 @@ describe 'sunspot namespace rake task' do
     it "should reindex all models if none are specified" do
       run_rake_task("sunspot:reindex", '', '', true)
 
-      # This model should not be used by any other test and therefore should only be loaded by this test
-      Sunspot.searchable.collect(&:name).should include('RakeTaskAutoLoadTestModel')
+      # This models should not be used by any other test and therefore should only be loaded by this test
+      expect(Sunspot.searchable.collect(&:name)).to include('RakeTaskAutoLoadTestModel', 'TestEngine::RakeTaskAutoLoadTestModel')
     end
 
     it "should accept a space delimited list of models to reindex" do
-      Post.should_receive(:solr_reindex)
-      Author.should_receive(:solr_reindex)
-      Blog.should_not_receive(:solr_reindex)
+      expect(Post).to receive(:solr_reindex)
+      expect(Author).to receive(:solr_reindex)
+      expect(Blog).not_to receive(:solr_reindex)
 
       run_rake_task("sunspot:reindex", '', "Post Author", true)
     end
 
     it "should accept a plus delimited list of models to reindex" do
-      Post.should_receive(:solr_reindex)
-      Author.should_receive(:solr_reindex)
-      Blog.should_not_receive(:solr_reindex)
+      expect(Post).to receive(:solr_reindex)
+      expect(Author).to receive(:solr_reindex)
+      expect(Blog).not_to receive(:solr_reindex)
 
       run_rake_task("sunspot:reindex", '', "Post+Author", true)
     end
 
     it "should raise exception when all tables of sunspot models are empty" do
-      STDOUT.should_receive(:puts).with("You have no data in the database. Reindexing does nothing here.")
+      expect(STDOUT).to receive(:puts).with("You have no data in the database. Reindexing does nothing here.")
       empty_tables
       run_rake_task("sunspot:reindex")
     end

data/spec/request_lifecycle_spec.rb

@@ -15,47 +15,43 @@ describe PostsController, :type => :controller do
     Sunspot::Rails.configuration = nil
   end
 
-  unless respond_to?(:describes)
-    controller_name :posts  # RSpec 1
-  end
-
   it 'should automatically commit after each action if specified' do
     @configuration.user_configuration = { 'auto_commit_after_request' => true }
-    Sunspot.should_receive(:commit_if_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).to receive(:commit_if_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
-  
+
   it 'should not commit, if configuration is set to false' do
     @configuration.user_configuration = { 'auto_commit_after_request' => false }
-    Sunspot.should_not_receive(:commit_if_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).not_to receive(:commit_if_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
 
   it 'should commit if configuration is not specified' do
     @configuration.user_configuration = {}
-    Sunspot.should_receive(:commit_if_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).to receive(:commit_if_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
-  
+
   ### auto_commit_if_delete_dirty
-  
+
   it 'should automatically commit after each delete if specified' do
     @configuration.user_configuration = { 'auto_commit_after_request' => false,
                                           'auto_commit_after_delete_request' => true }
-    Sunspot.should_receive(:commit_if_delete_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).to receive(:commit_if_delete_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
-  
+
   it 'should not automatically commit on delete if configuration is set to false' do
     @configuration.user_configuration = { 'auto_commit_after_request' => false,
                                           'auto_commit_after_delete_request' => false }
-    Sunspot.should_not_receive(:commit_if_delete_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).not_to receive(:commit_if_delete_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
 
   it 'should not automatically commit on delete if configuration is not specified' do
     @configuration.user_configuration = { 'auto_commit_after_request' => false }
-    Sunspot.should_not_receive(:commit_if_delete_dirty)
-    post :create, :post => { :title => 'Test 1' }
+    expect(Sunspot).not_to receive(:commit_if_delete_dirty)
+    post :create, :params => { :post => { :title => 'Test 1' } }
   end
-end
+end

data/spec/schema.rb

@@ -1,27 +1,26 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :posts, :force => true do |t|
+ActiveRecord::Schema.define(version: 0) do
+  create_table :posts, force: true do |t|
     t.string :title
     t.string :type
     t.integer :location_id
     t.text :body
     t.references :blog
-    t.timestamps
+    t.timestamps null: true
   end
 
-  create_table :locations, :force => true do |t|
+  create_table :locations, force: true do |t|
     t.float :lat
     t.float :lng
   end
 
-  create_table :blogs, :force => true do |t|
+  create_table :blogs, force: true do |t|
     t.string :name
     t.string :subdomain
-    t.timestamps
+    t.timestamps null: true
   end
 
-  create_table :writers, :force => true, :primary_key => :writer_id do |t|
+  create_table :writers, force: true, primary_key: :writer_id do |t|
     t.string :name
-    t.timestamps
+    t.timestamps null: true
   end
-
 end

data/spec/searchable_spec.rb

@@ -6,10 +6,10 @@ describe Sunspot::Rails::Searchable do
     	# Rspec runs tests in random order, causing this test to fail on occasion unless we ensure the models have loaded.
     	Author; Blog; Post;
 
-      Sunspot.searchable.should_not be_empty
-      Sunspot.searchable.should include(Author)
-      Sunspot.searchable.should include(Blog)
-      Sunspot.searchable.should include(Post)
+      expect(Sunspot.searchable).not_to be_empty
+      expect(Sunspot.searchable).to include(Author)
+      expect(Sunspot.searchable).to include(Blog)
+      expect(Sunspot.searchable).to include(Post)
     end
   end
 end

data/spec/server_spec.rb

@@ -4,28 +4,28 @@ describe Sunspot::Rails::Server do
   before :each do
     @server = Sunspot::Rails::Server.new
     @config = Sunspot::Rails::Configuration.new
-    @server.stub(:configuration){ @config }
+    allow(@server).to receive(:configuration){ @config }
     @solr_home = File.join(@config.solr_home)
   end
 
   it "sets the correct Solr home" do
-    @server.solr_home.should == @solr_home
+    expect(@server.solr_home).to eq(@solr_home)
   end
 
   it "sets the correct Solr PID path" do
-    @server.pid_path.should == File.join(@server.pid_dir, 'sunspot-solr-test.pid')
+    expect(@server.pid_path).to eq(File.join(@server.pid_dir, 'sunspot-solr-test.pid'))
   end
 
   it "sets the correct port" do
-    @server.port.should == 8983
+    expect(@server.port).to eq(8983)
   end
 
   it "sets the log level using configuration" do
-    @config.stub(:log_level){ 'WARNING' }
-    @server.log_level.should == "WARNING"
+    allow(@config).to receive(:log_level){ 'WARNING' }
+    expect(@server.log_level).to eq("WARNING")
   end
 
   it "sets the correct log file" do
-    @server.log_file.should == File.join(Rails.root, 'log', 'sunspot-solr-test.log')
+    expect(@server.log_file).to eq(File.join(Rails.root, 'log', 'sunspot-solr-test.log'))
   end
 end

data/spec/session_spec.rb

@@ -19,7 +19,7 @@ describe 'Sunspot::Rails session' do
 
     # There should be no items in the queue with the same object_id
     object_ids = sessions.map(&:object_id)
-    object_ids.uniq.should == object_ids
+    expect(object_ids.uniq).to eq(object_ids)
   end
 
   it 'should create a separate master/slave session if configured' do
@@ -31,7 +31,7 @@ describe 'Sunspot::Rails session' do
   context 'disabled' do
     before do
       Sunspot::Rails.reset
-      ::Rails.stub(:env).and_return("config_disabled_test")
+      allow(::Rails).to receive(:env).and_return("config_disabled_test")
     end
 
     after do
@@ -39,7 +39,7 @@ describe 'Sunspot::Rails session' do
     end
 
     it 'sets the session proxy as a stub' do
-      Sunspot::Rails.build_session.should be_a_kind_of(Sunspot::Rails::StubSessionProxy)
+      expect(Sunspot::Rails.build_session).to be_a_kind_of(Sunspot::Rails::StubSessionProxy)
     end
   end
 

data/spec/shared_examples/indexed_after_save.rb

@@ -3,6 +3,6 @@ shared_examples_for 'indexed after save' do
     subject.save!
     Sunspot.commit
 
-    subject.class.search.results.should include(subject)
+    expect(subject.class.search.results).to include(subject)
   end
 end

data/spec/shared_examples/not_indexed_after_save.rb

@@ -3,6 +3,6 @@ shared_examples_for 'not indexed after save' do
     subject.save!
     Sunspot.commit
 
-    subject.class.search.results.should_not include(subject)
+    expect(subject.class.search.results).not_to include(subject)
   end
 end

data/spec/spec_helper.rb

@@ -1,75 +1,42 @@
-# This file is copied to spec/ when you run 'rails generate rspec:install'
 ENV["RAILS_ENV"] ||= 'test'
-if rsolr_version = ENV['RSOLR_GEM_VERSION']
-  STDERR.puts("Forcing RSolr version #{rsolr_version}")
-  gem "rsolr", rsolr_version
-end
-
-# Require the Database-specific gems
-ENV['DB'] ||= 'sqlite'
-Bundler.require(ENV['DB'])
 
-require File.expand_path('config/environment', ENV['RAILS_ROOT'])
+require File.expand_path('config/environment', File.expand_path('../rails_app', __FILE__))
+require File.expand_path('../../lib/sunspot_rails', __FILE__)
 require 'rspec/rails'
-require 'rspec/autorun'
-require File.join('sunspot', 'rails', 'solr_logging')
 
-# Requires supporting ruby files with custom matchers and macros, etc, in
-# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
-# run as spec files by default. This means that files in spec/support that end
-# in _spec.rb will both be required and run as specs, causing the specs to be
-# run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with with the --pattern
-# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
-Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+if RSolr::VERSION >= '2'
+  require File.join('sunspot', 'rails', 'solr_logging')
+end
 
 # Load all shared examples
-Dir[File.expand_path("shared_examples/*.rb", File.dirname(__FILE__))].each {|f| require f}
+Dir[File.expand_path("shared_examples/*.rb", File.dirname(__FILE__))].each { |f| require f }
 
 # Load the schema
-load File.join(ENV['RAILS_ROOT'], 'db', 'schema.rb')
+load File.join(File.expand_path('../rails_app', __FILE__), 'db', 'schema.rb')
 
 RSpec.configure do |config|
-  # ## Mock Framework
-  #
-  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
-  #
-  # config.mock_with :mocha
-  # config.mock_with :flexmock
-  # config.mock_with :rr
-
-  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
-
-  # If you're not using ActiveRecord, or you'd prefer not to run each of your
-  # examples within a transaction, remove the following line or assign false
-  # instead of true.
   config.use_transactional_fixtures = true
-
-  # If true, the base class of anonymous controllers will be inferred
-  # automatically. This will be the default behavior in future versions of
-  # rspec-rails.
   config.infer_base_class_for_anonymous_controllers = false
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  # --seed 1234
-  config.order = "random"
+  config.order = 'random'
+  config.infer_spec_type_from_file_location!
 
   config.before(:each) do
     empty_tables
     Sunspot.remove_all!
-  end  
+  end
 end
 
 def empty_tables
-  ActiveRecord::Base.connection.tables.each do |table_name|
+  sources = if Rails::VERSION::MAJOR > 4
+              ActiveRecord::Base.connection.data_sources
+            else
+              ActiveRecord::Base.connection.tables
+            end
+  sources.each do |table_name|
     ActiveRecord::Base.connection.execute("DELETE FROM #{table_name}") unless table_name == 'schema_migrations'
   end
 end
 
-# COMPATIBILITY: Rails 4 has deprecated the 'scoped' method in favour of 'all'
 def relation(clazz)
-  ::Rails.version >= '4' ? clazz.all : clazz.scoped
-end
+  Rails::VERSION::MAJOR >= 4 ? clazz.all : clazz.scoped
+end

data/spec/stub_session_proxy_spec.rb

@@ -13,142 +13,146 @@ describe 'specs with Sunspot stubbed' do
     foo = double('Foo')
     block = lambda { foo.bar }
 
-    foo.should_receive(:bar)
+    expect(foo).to receive(:bar)
 
     Sunspot.batch(&block)
   end
 
   it 'should not send index to session' do
-    @session.should_not_receive(:index)
+    expect(@session).not_to receive(:index)
     @post.index
   end
 
   it 'should not send index! to session' do
-    @session.should_not_receive(:index!)
+    expect(@session).not_to receive(:index!)
     @post.index!
   end
 
   it 'should not send atomic_update to session' do
-    @session.should_not_receive(:atomic_update)
+    expect(@session).not_to receive(:atomic_update)
     @post.index
   end
 
   it 'should not send atomic_update! to session' do
-    @session.should_not_receive(:atomic_update!)
+    expect(@session).not_to receive(:atomic_update!)
     @post.index!
   end
 
   it 'should not send commit to session' do
-    @session.should_not_receive(:commit)
+    expect(@session).not_to receive(:commit)
     Sunspot.commit
   end
 
   it 'should not send remove to session' do
-    @session.should_not_receive(:remove)
+    expect(@session).not_to receive(:remove)
     @post.remove_from_index
   end
 
   it 'should not send remove! to session' do
-    @session.should_not_receive(:remove)
+    expect(@session).not_to receive(:remove)
     @post.remove_from_index!
   end
 
   it 'should not send remove_by_id to session' do
-    @session.should_not_receive(:remove_by_id)
+    expect(@session).not_to receive(:remove_by_id)
     Sunspot.remove_by_id(Post, 1)
   end
 
   it 'should not send remove_by_id! to session' do
-    @session.should_not_receive(:remove_by_id!)
+    expect(@session).not_to receive(:remove_by_id!)
     Sunspot.remove_by_id!(Post, 1)
   end
 
   it 'should not send remove_all to session' do
-    @session.should_not_receive(:remove_all)
+    expect(@session).not_to receive(:remove_all)
     Post.remove_all_from_index
   end
 
   it 'should not send remove_all! to session' do
-    @session.should_not_receive(:remove_all!)
+    expect(@session).not_to receive(:remove_all!)
     Post.remove_all_from_index!
   end
 
   it 'should not send optimize to session' do
-    @session.should_not_receive(:optimize)
+    expect(@session).not_to receive(:optimize)
     Sunspot.optimize
   end
 
   it 'should return false for dirty?' do
-    @session.should_not_receive(:dirty?)
-    Sunspot.dirty?.should == false
+    expect(@session).not_to receive(:dirty?)
+    expect(Sunspot.dirty?).to eq(false)
   end
 
   it 'should not send commit_if_dirty to session' do
-    @session.should_not_receive(:commit_if_dirty)
+    expect(@session).not_to receive(:commit_if_dirty)
     Sunspot.commit_if_dirty
   end
 
   it 'should return false for delete_dirty?' do
-    @session.should_not_receive(:delete_dirty?)
-    Sunspot.delete_dirty?.should == false
+    expect(@session).not_to receive(:delete_dirty?)
+    expect(Sunspot.delete_dirty?).to eq(false)
   end
 
   it 'should not send commit_if_delete_dirty to session' do
-    @session.should_not_receive(:commit_if_delete_dirty)
+    expect(@session).not_to receive(:commit_if_delete_dirty)
     Sunspot.commit_if_delete_dirty
   end
 
   it 'should not execute a search when #search called' do
-    @session.should_not_receive(:search)
+    expect(@session).not_to receive(:search)
     Post.search
   end
 
   it 'should not execute a search when #search called with parameters' do
-    @session.should_not_receive(:search)
+    expect(@session).not_to receive(:search)
     Post.search(:include => :blog, :select => 'id, title')
   end
 
   it 'should return a new search' do
-    @session.should_not_receive(:new_search)
-    Sunspot.new_search(Post).should respond_to(:execute)
+    expect(@session).not_to receive(:new_search)
+    expect(Sunspot.new_search(Post)).to respond_to(:execute)
   end
 
   it 'should not send more_like_this to session' do
-    @session.should_not_receive(:more_like_this)
+    expect(@session).not_to receive(:more_like_this)
     Sunspot.more_like_this(@post)
   end
 
+  it 'should not raise error when reindexing scope' do
+    expect{ Post.solr_index }.to_not raise_error
+  end
+
   describe 'stub search' do
     before :each do
       @search = Post.search
     end
 
     it 'should return empty results' do
-      @search.results.should == []
+      expect(@search.results).to eq([])
     end
 
     it 'should return empty hits' do
-      @search.hits.should == []
+      expect(@search.hits).to eq([])
     end
 
     it 'should return the same for raw_results as hits' do
-      @search.raw_results.should == @search.hits
+      expect(@search.raw_results).to eq(@search.hits)
     end
 
     it 'should return zero total' do
-      @search.total.should == 0
+      expect(@search.total).to eq(0)
     end
 
     it 'should return empty results for a given facet' do
-      @search.facet(:category_id).rows.should == []
+      expect(@search.facet(:category_id).rows).to eq([])
     end
 
     it 'should return empty results for a given dynamic facet' do
-      @search.dynamic_facet(:custom).rows.should == []
+      expect(@search.dynamic_facet(:custom).rows).to eq([])
     end
 
     it 'should return empty array if listing facets' do
-      @search.facets.should == []
+      expect(@search.facets).to eq([])
     end
 
     describe '#data_accessor_for' do
@@ -157,11 +161,11 @@ describe 'specs with Sunspot stubbed' do
       end
 
       it 'should provide accessor for select' do
-        @accessor.should respond_to(:select, :select=)
+        expect(@accessor).to respond_to(:select, :select=)
       end
 
       it 'should provide accessor for include' do
-        @accessor.should respond_to(:include, :include=)
+        expect(@accessor).to respond_to(:include, :include=)
       end
     end
 
@@ -171,7 +175,7 @@ describe 'specs with Sunspot stubbed' do
       end
 
       it 'should response to all the available data methods' do
-        @stats.should respond_to(
+        expect(@stats).to respond_to(
           :min,
           :max,
           :count,
@@ -183,11 +187,11 @@ describe 'specs with Sunspot stubbed' do
       end
 
       it 'should return empty results for a given facet' do
-        @stats.facet(:category_id).rows.should == []
+        expect(@stats.facet(:category_id).rows).to eq([])
       end
 
       it 'should return empty array if listing facets' do
-        @stats.facets.should == []
+        expect(@stats.facets).to eq([])
       end
 
     end