joshcutler-thinking-sphinx 1.3.18

data/spec/thinking_sphinx/index/faux_column_spec.rb

@@ -0,0 +1,36 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index::FauxColumn do  
+  describe "coerce class method" do
+    before :each do
+      @column = stub('column')
+      ThinkingSphinx::Index::FauxColumn.stub!(:new => @column)
+    end
+    
+    it "should return a single faux column if passed a string" do
+      ThinkingSphinx::Index::FauxColumn.coerce("string").should == @column
+    end
+    
+    it "should return a single faux column if passed a symbol" do
+      ThinkingSphinx::Index::FauxColumn.coerce(:string).should == @column
+    end
+    
+    it "should return an array of faux columns if passed an array of strings" do
+      ThinkingSphinx::Index::FauxColumn.coerce(["one", "two"]).should == [
+        @column, @column
+      ]
+    end
+    
+    it "should return an array of faux columns if passed an array of symbols" do
+      ThinkingSphinx::Index::FauxColumn.coerce([:one, :two]).should == [
+        @column, @column
+      ]
+    end
+  end
+  
+  describe '#to_ary' do
+    it "should return an array with the instance inside it" do
+      subject.to_ary.should == [subject]
+    end
+  end
+end

data/spec/thinking_sphinx/index_spec.rb

@@ -0,0 +1,183 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index do
+  describe "prefix_fields method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = stub('field', :prefixes => true)
+      @field_b = stub('field', :prefixes => false)
+      @field_c = stub('field', :prefixes => true)
+      
+      @index.stub!(:fields => [@field_a, @field_b, @field_c])
+    end
+    
+    it "should return fields that are flagged as prefixed" do
+      @index.prefix_fields.should include(@field_a)
+      @index.prefix_fields.should include(@field_c)
+    end
+    
+    it "should not return fields that aren't flagged as prefixed" do
+      @index.prefix_fields.should_not include(@field_b)
+    end
+  end
+  
+  describe "infix_fields method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = stub('field', :infixes => true)
+      @field_b = stub('field', :infixes => false)
+      @field_c = stub('field', :infixes => true)
+      
+      @index.stub!(:fields => [@field_a, @field_b, @field_c])
+    end
+    
+    it "should return fields that are flagged as infixed" do
+      @index.infix_fields.should include(@field_a)
+      @index.infix_fields.should include(@field_c)
+    end
+    
+    it "should not return fields that aren't flagged as infixed" do
+      @index.infix_fields.should_not include(@field_b)
+    end
+  end
+  
+  describe '.name_for' do
+    it "should return the model's name downcased" do
+      ThinkingSphinx::Index.name_for(Alpha).should == 'alpha'
+    end
+    
+    it "should separate words by underscores" do
+      ThinkingSphinx::Index.name_for(ActiveRecord).should == 'active_record'
+    end
+    
+    it "should separate namespaces by underscores" do
+      ThinkingSphinx::Index.name_for(ActiveRecord::Base).
+        should == 'active_record_base'
+    end
+  end
+  
+  describe '#name' do
+    it "should return the downcased name of the index's model" do
+      ThinkingSphinx::Index.new(Alpha).name.should == 'alpha'
+    end
+    
+    it "should return a custom name if one is set" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      index.name = 'custom'
+      index.name.should == 'custom'
+    end
+  end
+  
+  describe '#core_name' do
+    it "should take the index's name and append _core" do
+      ThinkingSphinx::Index.new(Alpha).core_name.should == 'alpha_core'
+    end
+  end
+  
+  describe '#delta_name' do
+    it "should take the index's name and append _delta" do
+      ThinkingSphinx::Index.new(Alpha).delta_name.should == 'alpha_delta'
+    end
+  end
+  
+  describe '#all_names' do
+    it "should return the core index name by default" do
+      ThinkingSphinx::Index.new(Alpha).all_names.should == ['alpha_core']
+    end
+    
+    it "should return both core and delta names if deltas are enabled" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      index.delta_object = stub('delta')
+      
+      index.all_names.should == ['alpha_core', 'alpha_delta']
+    end
+    
+    it "should respect custom names" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      index.name = 'custom'
+      
+      index.all_names.should == ['custom_core']
+    end
+    
+    it "should respect custom names when deltas are enabled" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      index.name = 'custom'
+      index.delta_object = stub('delta')
+      
+      index.all_names.should == ['custom_core', 'custom_delta']
+    end
+  end
+  
+  describe '#to_riddle' do
+    it "should return two Riddle indexes if deltas are disabled" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      
+      index.to_riddle(0).length.should == 2
+    end
+    
+    it "should return three Riddle indexes if deltas are enabled" do
+      index = ThinkingSphinx::Index.new(Beta)
+      index.delta_object = stub('delta')
+      
+      index.to_riddle(0).length.should == 3
+    end
+    
+    it "should include a distributed index" do
+      index = ThinkingSphinx::Index.new(Alpha)
+      
+      index.to_riddle(0).last.
+        should be_a(Riddle::Configuration::DistributedIndex)
+    end
+    
+    context 'core index' do
+      it "should use the core name" do
+        @index = ThinkingSphinx::Index.new(Alpha).to_riddle(0).first
+        @index.name.should == 'alpha_core'
+      end
+      
+      it "should not try to set disable_range on the index" do
+        ThinkingSphinx::Configuration.instance.
+          index_options[:disable_range] = true
+        
+        lambda {
+          @index = ThinkingSphinx::Index.new(Alpha).to_riddle(0).first
+        }.should_not raise_error(NoMethodError)
+      end
+    end
+    
+    context 'delta index' do
+      before :each do
+        index = ThinkingSphinx::Index.new(Beta)
+        index.delta_object = stub('delta')
+        @index = index.to_riddle(0)[1]
+      end
+      
+      it "should use the delta name" do
+        @index.name.should == 'beta_delta'
+      end
+    end
+    
+    context 'distributed index' do
+      it "should use the index's name" do
+        index = ThinkingSphinx::Index.new(Alpha)
+
+        index.to_riddle(0).last.name.should == 'alpha'
+      end
+      
+      it "should add the core index" do
+        index = ThinkingSphinx::Index.new(Alpha)
+
+        index.to_riddle(0).last.local_indexes.should include('alpha_core')
+      end
+      
+      it "should add the delta index if there is one" do
+        index = ThinkingSphinx::Index.new(Beta)
+        index.delta_object = stub('delta')
+
+        index.to_riddle(0).last.local_indexes.should include('beta_delta')
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/rails_additions_spec.rb

@@ -0,0 +1,203 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::HashExcept do
+  before(:each) do
+    @hash = { :number => 20, :letter => 'b', :shape => 'rectangle' }
+  end
+  
+  describe "except method" do
+    it "returns a hash without the specified keys" do
+      new_hash = @hash.except(:number)
+      new_hash.should_not have_key(:number)
+    end
+  end
+  
+  describe "except! method" do
+    it "modifies hash removing specified keys" do
+      @hash.except!(:number)
+      @hash.should_not have_key(:number)
+    end
+  end
+  
+  describe "extends Hash" do
+    before :each do
+      @instance_methods = Hash.instance_methods.collect { |m| m.to_s }
+    end
+    
+    it 'with except' do
+      @instance_methods.include?('except').should be_true
+    end
+
+    it 'with except!' do
+      @instance_methods.include?('except!').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::ArrayExtractOptions do
+  describe 'extract_options! method' do
+    it 'returns a hash' do
+      array = []
+      array.extract_options!.should be_kind_of(Hash)
+    end
+
+    it 'returns the last option if it is a hash' do
+      array = ['a', 'b', {:c => 'd'}]
+      array.extract_options!.should == {:c => 'd'}
+    end
+  end
+  
+  describe "extends Array" do
+    it 'with extract_options!' do
+      Array.instance_methods.collect { |m| m.to_s }.include?('extract_options!').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::AbstractQuotedTableName do
+  describe 'quote_table_name method' do
+    it 'calls quote_column_name' do
+      adapter = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql')
+      adapter.should_receive(:quote_column_name).with('messages')
+      adapter.quote_table_name('messages')
+    end
+  end
+  
+  describe "extends ActiveRecord::ConnectionAdapters::AbstractAdapter" do
+    it 'with quote_table_name' do
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_methods.collect { |m|
+        m.to_s
+      }.include?('quote_table_name').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::MysqlQuotedTableName do
+  describe "quote_table_name method" do
+    it 'correctly quotes' do
+      adapter = ActiveRecord::Base.connection
+      adapter.quote_table_name('thinking_sphinx.messages').should == "`thinking_sphinx`.`messages`"
+    end
+  end
+  
+  describe "extends ActiveRecord::ConnectionAdapters::MysqlAdapter" do
+    it 'with quote_table_name' do
+      adapter = defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
+      ActiveRecord::ConnectionAdapters.const_get(adapter).instance_methods.collect { |m|
+        m.to_s
+      }.include?("quote_table_name").should be_true
+    end
+  end  
+end
+
+describe ThinkingSphinx::ActiveRecordQuotedName do
+  describe "quoted_table_name method" do
+    it 'returns table name wrappd in quotes' do
+      Person.quoted_table_name.should == '`people`'
+    end
+  end
+  
+  describe "extends ActiveRecord::Base" do
+    it 'with quoted_table_name' do
+      ActiveRecord::Base.respond_to?("quoted_table_name").should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::ActiveRecordStoreFullSTIClass do
+  describe "store_full_sti_class method" do
+    it 'returns false' do
+      Person.store_full_sti_class.should be_false
+    end
+  end
+  
+  describe "extends ActiveRecord::Base" do
+    it 'with store_full_sti_class' do
+      ActiveRecord::Base.respond_to?(:store_full_sti_class).should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::SingletonClass do
+  describe 'singleton_class' do
+    it "should exist as an instance method in Object" do
+      Object.new.should respond_to('singleton_class')
+    end
+    
+    it "should return the meta/eigen/singleton class" do
+      Object.new.singleton_class.should be_a(Class)
+    end
+  end
+end
+
+class TestModel
+  @@squares = 89
+  @@circles = 43
+  
+  def number_of_polygons
+    @@polygons
+  end
+end
+
+describe ThinkingSphinx::ClassAttributeMethods do
+  describe "cattr_reader method" do
+    it 'creates getters' do
+      TestModel.cattr_reader :herbivores
+      test_model = TestModel.new
+      test_model.respond_to?(:herbivores).should be_true
+    end
+
+    it 'sets the initial value to nil' do
+      TestModel.cattr_reader :carnivores
+      test_model = TestModel.new
+      test_model.carnivores.should be_nil
+    end
+
+    it 'does not override an existing definition' do
+      TestModel.cattr_reader :squares
+      test_model = TestModel.new
+      test_model.squares.should == 89      
+    end
+  end
+
+  describe "cattr_writer method" do
+    it 'creates setters' do
+      TestModel.cattr_writer :herbivores
+      test_model = TestModel.new
+      test_model.respond_to?(:herbivores=).should be_true
+    end
+    
+    it 'does not override an existing definition' do
+      TestModel.cattr_writer :polygons
+      test_model = TestModel.new
+      test_model.polygons = 100
+      test_model.number_of_polygons.should == 100
+    end
+  end
+
+  describe "cattr_accessor method" do
+    it 'calls cattr_reader' do
+      Class.should_receive(:cattr_reader).with('polygons')
+      Class.cattr_accessor('polygons')
+    end
+
+    it 'calls cattr_writer' do
+      Class.should_receive(:cattr_writer).with('polygons')
+      Class.cattr_accessor('polygons')
+    end
+  end
+
+  describe "extends Class" do
+    it 'with cattr_reader' do
+      Class.respond_to?('cattr_reader').should be_true
+    end
+
+    it 'with cattr_writer' do
+      Class.respond_to?('cattr_writer').should be_true
+    end
+
+    it 'with cattr_accessor' do
+      Class.respond_to?('cattr_accessor').should be_true
+    end
+  end
+end

data/spec/thinking_sphinx/search_methods_spec.rb

@@ -0,0 +1,152 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::SearchMethods do
+  it "should be included into models with indexes" do
+    Alpha.included_modules.should include(ThinkingSphinx::SearchMethods)
+  end
+  
+  it "should not be included into models that don't have indexes" do
+    Gamma.included_modules.should_not include(ThinkingSphinx::SearchMethods)
+  end
+  
+  describe '.search_context' do
+    it "should return nil if not within a model" do
+      ThinkingSphinx.search_context.should be_nil
+    end
+    
+    it "should return the model if within one" do
+      Alpha.search_context.should == Alpha
+    end
+  end
+  
+  describe '.search' do
+    it "should return an instance of ThinkingSphinx::Search" do
+      Alpha.search.class.should == ThinkingSphinx::Search
+    end
+    
+    it "should set the classes option if not already set" do
+      search = Alpha.search
+      search.options[:classes].should == [Alpha]
+    end
+    
+    it "shouldn't set the classes option if already defined" do
+      search = Alpha.search :classes => [Beta]
+      search.options[:classes].should == [Beta]
+    end
+    
+    it "should default to nil for the classes options" do
+      ThinkingSphinx.search.options[:classes].should be_nil
+    end
+  end
+  
+  describe '.search_for_ids' do
+    it "should return an instance of ThinkingSphinx::Search" do
+      Alpha.search.class.should == ThinkingSphinx::Search
+    end
+    
+    it "should set the classes option if not already set" do
+      search = Alpha.search_for_ids
+      search.options[:classes].should == [Alpha]
+    end
+    
+    it "shouldn't set the classes option if already defined" do
+      search = Alpha.search_for_ids :classes => [Beta]
+      search.options[:classes].should == [Beta]
+    end
+    
+    it "should set ids_only to true" do
+      search = Alpha.search_for_ids
+      search.options[:ids_only].should be_true
+    end
+  end
+  
+  describe '.search_for_id' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @client = Riddle::Client.new
+
+      @config.stub!(:client => @client)
+      @client.stub!(:query => {:matches => [], :total_found => 0})
+    end
+    
+    it "should set the id range to the given id value" do
+      ThinkingSphinx.search_for_id(101, 'alpha_core')
+      
+      @client.id_range.should == (101..101)
+    end
+    
+    it "should not make any calls to the database" do
+      Alpha.should_not_receive(:find)
+      
+      ThinkingSphinx.search_for_id(101, 'alpha_core', :classes => [Alpha])
+    end
+    
+    it "should return true if there is a record" do
+      @client.stub!(:query => {:matches => [
+        {:attributes => {'sphinx_internal_id' => 100}}
+      ], :total_found => 1})
+      
+      ThinkingSphinx.search_for_id(101, 'alpha_core').should be_true
+    end
+    
+    it "should return false if there isn't a record" do
+      ThinkingSphinx.search_for_id(101, 'alpha_core').should be_false
+    end
+  end
+  
+  describe '.count' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @client = Riddle::Client.new
+
+      @config.stub!(:client => @client)
+      @client.stub!(:query => {:matches => [], :total_found => 42})
+    end
+    
+    it "should fall through to ActiveRecord if called on a class" do
+      @client.should_not_receive(:query)
+      
+      Alpha.count
+    end
+    
+    it "should return the total number of results if called globally" do
+      ThinkingSphinx.count.should == 42
+    end
+  end
+  
+  describe '.search_count' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @client = Riddle::Client.new
+
+      @config.stub!(:client => @client)
+      @client.stub!(:query => {:matches => [], :total_found => 42})
+    end
+    
+    it "should return the total number of results" do
+      Alpha.search_count.should == 42
+    end
+    
+    it "should not make any calls to the database" do
+      Alpha.should_not_receive(:find)
+      
+      Alpha.search_count
+    end
+  end
+  
+  describe '.facets' do
+    it "should return a FacetSearch instance" do
+      Alpha.facets.should be_a(ThinkingSphinx::FacetSearch)
+    end
+    
+    it "should set the classes option if not already set" do
+      facets = Alpha.facets
+      facets.options[:classes].should == [Alpha]
+    end
+    
+    it "shouldn't set the classes option if already defined" do
+      facets = Alpha.facets :classes => [Beta]
+      facets.options[:classes].should == [Beta]
+    end
+  end
+end