thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/index_set_spec.rb

@@ -0,0 +1,68 @@
+module ThinkingSphinx; end
+
+require 'active_support/core_ext/string/inflections'
+require 'thinking_sphinx/index_set'
+
+describe ThinkingSphinx::IndexSet do
+  let(:set)           { ThinkingSphinx::IndexSet.new classes, indices,
+    configuration }
+  let(:classes)       { [] }
+  let(:indices)       { [] }
+  let(:configuration) { double('configuration', :preload_indices => true,
+    :indices => []) }
+  let(:ar_base)       { double('ActiveRecord::Base') }
+
+  before :each do
+    stub_const 'ActiveRecord::Base', ar_base
+  end
+
+  def class_double(name, *superclasses)
+    klass = double 'class', :name => name, :class => Class
+    klass.stub :ancestors => ([klass] + superclasses + [ar_base])
+    klass
+  end
+
+  describe '#to_a' do
+    it "ensures the indices are loaded" do
+      configuration.should_receive(:preload_indices)
+
+      set.to_a
+    end
+
+    it "returns all indices when no models or indices are specified" do
+      article_core = double('index', :name => 'article_core')
+      user_core    = double('index', :name => 'user_core')
+      configuration.indices.replace [article_core, user_core]
+
+      set.to_a.should == [article_core, user_core]
+    end
+
+    it "uses indices for the given classes" do
+      classes << class_double('Article')
+
+      configuration.should_receive(:indices_for_references).with(:article).
+        and_return([])
+
+      set.to_a
+    end
+
+    it "requests indices for any superclasses" do
+      classes << class_double('OpinionArticle', class_double('Article'))
+
+      configuration.should_receive(:indices_for_references).
+        with(:opinion_article, :article).and_return([])
+
+      set.to_a
+    end
+
+    it "uses named indices if names are provided" do
+      article_core = double('index', :name => 'article_core')
+      user_core    = double('index', :name => 'user_core')
+      configuration.indices.replace [article_core, user_core]
+
+      indices << 'article_core'
+
+      set.to_a.should == [article_core]
+    end
+  end
+end

data/spec/thinking_sphinx/index_spec.rb

@@ -1,188 +1,124 @@
 require '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
+  describe '.define' do
+    let(:index)   { double('index', :definition_block= => nil) }
+    let(:config)  { Struct.new(:indices).new([]) }
 
-    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)
+      ThinkingSphinx::Configuration.stub :instance => config
     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
+    context 'with ActiveRecord' do
+      before :each do
+        ThinkingSphinx::ActiveRecord::Index.stub :new => index
+      end
 
-  describe '#to_riddle' do
-    it "should return two Riddle indexes if deltas are disabled" do
-      index = ThinkingSphinx::Index.new(Alpha)
+      it "creates an ActiveRecord index" do
+        ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
+          with(:user, :with => :active_record).and_return index
 
-      index.to_riddle(0).length.should == 2
-    end
+        ThinkingSphinx::Index.define(:user, :with => :active_record)
+      end
 
-    it "should return three Riddle indexes if deltas are enabled" do
-      index = ThinkingSphinx::Index.new(Beta)
-      index.delta_object = stub('delta')
+      it "returns the ActiveRecord index" do
+        ThinkingSphinx::Index.define(:user, :with => :active_record).
+          should == [index]
+      end
 
-      index.to_riddle(0).length.should == 3
-    end
+      it "adds the index to the collection of indices" do
+        ThinkingSphinx::Index.define(:user, :with => :active_record)
 
-    it "should include a distributed index" do
-      index = ThinkingSphinx::Index.new(Alpha)
+        config.indices.should include(index)
+      end
 
-      index.to_riddle(0).last.
-        should be_a(Riddle::Configuration::DistributedIndex)
-    end
+      it "sets the block in the index" do
+        index.should_receive(:definition_block=).with instance_of(Proc)
 
-    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'
+        ThinkingSphinx::Index.define(:user, :with => :active_record) do
+          indexes name
+        end
       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)
+      context 'with a delta' do
+        let(:delta_index) { double('delta index', :definition_block= => nil) }
+        let(:processor)   { double('delta processor') }
+
+        before :each do
+          ThinkingSphinx::Deltas.stub :processor_for => processor
+          ThinkingSphinx::ActiveRecord::Index.stub(:new).
+            and_return(index, delta_index)
+        end
+
+        it "creates two indices with delta settings" do
+          ThinkingSphinx::ActiveRecord::Index.unstub :new
+          ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
+            with(:user,
+              hash_including(:delta? => false, :delta_processor => processor)
+            ).once.
+            and_return index
+          ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
+            with(:user,
+              hash_including(:delta? => true,  :delta_processor => processor)
+            ).once.
+            and_return delta_index
+
+          ThinkingSphinx::Index.define :user,
+            :with  => :active_record,
+            :delta => true
+        end
+
+        it "appends both indices to the collection" do
+          ThinkingSphinx::Index.define :user,
+            :with  => :active_record,
+            :delta => true
+
+          config.indices.should include(index)
+          config.indices.should include(delta_index)
+        end
+
+        it "sets the block in the index" do
+          index.should_receive(:definition_block=).with instance_of(Proc)
+          delta_index.should_receive(:definition_block=).with instance_of(Proc)
+
+          ThinkingSphinx::Index.define(:user,
+            :with  => :active_record,
+            :delta => true) do
+            indexes name
+          end
+        end
       end
     end
 
-    context 'delta index' do
+    context 'with Real-Time' do
       before :each do
-        index = ThinkingSphinx::Index.new(Beta)
-        index.delta_object = stub('delta')
-        @index = index.to_riddle(0)[1]
+        ThinkingSphinx::RealTime::Index.stub :new => index
       end
 
-      it "should use the delta name" do
-        @index.name.should == 'beta_delta'
-      end
-    end
+      it "creates a real-time index" do
+        ThinkingSphinx::RealTime::Index.should_receive(:new).
+          with(:user, :with => :real_time).and_return index
 
-    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'
+        ThinkingSphinx::Index.define(:user, :with => :real_time)
       end
 
-      it "should add the core index" do
-        index = ThinkingSphinx::Index.new(Alpha)
-
-        index.to_riddle(0).last.local_indices.should include('alpha_core')
+      it "returns the ActiveRecord index" do
+        ThinkingSphinx::Index.define(:user, :with => :real_time).
+          should == [index]
       end
 
-      it "should add the delta index if there is one" do
-        index = ThinkingSphinx::Index.new(Beta)
-        index.delta_object = stub('delta')
+      it "adds the index to the collection of indices" do
+        ThinkingSphinx::Index.define(:user, :with => :real_time)
 
-        index.to_riddle(0).last.local_indices.should include('beta_delta')
+        config.indices.should include(index)
       end
 
-      it "should add additional local indexes if there are any" do
-        index = ThinkingSphinx::Index.new(Alpha)
-        index.additional_indices << "other_index_core"
-        index.to_riddle(0).last.local_indices.should include('other_index_core')
+      it "sets the block in the index" do
+        index.should_receive(:definition_block=).with instance_of(Proc)
+
+        ThinkingSphinx::Index.define(:user, :with => :real_time) do
+          indexes name
+        end
       end
     end
   end

data/spec/thinking_sphinx/masks/pagination_mask_spec.rb

@@ -0,0 +1,121 @@
+module ThinkingSphinx
+  module Masks; end
+end
+
+require 'active_support/core_ext/object/blank'
+require 'thinking_sphinx/masks/pagination_mask'
+
+describe ThinkingSphinx::Masks::PaginationMask do
+  let(:search) { double('search', :options => {}, :meta => {},
+    :per_page => 20) }
+  let(:mask)   { ThinkingSphinx::Masks::PaginationMask.new search }
+
+  describe '#first_page?' do
+    it "returns true when on the first page" do
+      mask.should be_first_page
+    end
+
+    it "returns false on other pages" do
+      search.options[:page] = 2
+
+      mask.should_not be_first_page
+    end
+  end
+
+  describe '#last_page?' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "is true when there's no more pages" do
+      search.options[:page] = 3
+
+      mask.should be_last_page
+    end
+
+    it "is false when there's still more pages" do
+      mask.should_not be_last_page
+    end
+  end
+
+  describe '#next_page' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "should return one more than the current page" do
+      mask.next_page.should == 2
+    end
+
+    it "should return nil if on the last page" do
+      search.options[:page] = 3
+
+      mask.next_page.should be_nil
+    end
+  end
+
+  describe '#next_page?' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "is true when there is a second page" do
+      mask.next_page?.should be_true
+    end
+
+    it "is false when there's no more pages" do
+      search.options[:page] = 3
+
+      mask.next_page?.should be_false
+    end
+  end
+
+  describe '#previous_page' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "should return one less than the current page" do
+      search.options[:page] = 2
+
+      mask.previous_page.should == 1
+    end
+
+    it "should return nil if on the first page" do
+      mask.previous_page.should be_nil
+    end
+  end
+
+  describe '#total_entries' do
+    before :each do
+      search.meta['total_found'] = '12'
+    end
+
+    it "returns the total found from the search request metadata" do
+      mask.total_entries.should == 12
+    end
+  end
+
+  describe '#total_pages' do
+    before :each do
+      search.meta['total']       = '40'
+      search.meta['total_found'] = '44'
+    end
+
+    it "uses the total available from the search request metadata" do
+      mask.total_pages.should == 2
+    end
+
+    it "should allow for custom per_page values" do
+      search.stub :per_page => 40
+
+      mask.total_pages.should == 1
+    end
+
+    it "should return 0 if there is no index and therefore no results" do
+      search.meta.clear
+
+      mask.total_pages.should == 0
+    end
+  end
+end