dpickett-thinking-sphinx 1.1.12 → 1.1.23

data/spec/unit/thinking_sphinx/association_spec.rb

@@ -79,7 +79,8 @@ describe ThinkingSphinx::Association do
     before :each do
       @parent_join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
       @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
-      @parent = ThinkingSphinx::Association.stub_instance(:join_to => true, :join => nil)
+      @parent = ThinkingSphinx::Association.new(nil, nil)
+      @parent.stub!(:join_to => true, :join => nil)
       @base_join = Object.stub_instance(:joins => [:a, :b, :c])
       
       ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_method(:new => @join)
@@ -87,19 +88,17 @@ describe ThinkingSphinx::Association do
     
     it "should call the parent's join_to if parent has no join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      @parent.should_receive(:join_to).with(@base_join)
       
       @assoc.join_to(@base_join)
-      
-      @parent.should have_received(:join_to).with(@base_join)
     end
     
     it "should not call the parent's join_to if it already has a join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
       @parent.stub_method(:join => @parent_join)
+      @parent.should_not_receive(:join_to)
       
       @assoc.join_to(@base_join)
-      
-      @parent.should_not have_received(:join_to)
     end
     
     it "should define the join association with a JoinAssociation instance" do

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -1,23 +1,30 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::Attribute do
+  before :each do
+    @index  = ThinkingSphinx::Index.new(Person)
+    @source = ThinkingSphinx::Source.new(@index)
+    
+    @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
+  end
+  
   describe '#initialize' do
     it 'raises if no columns are provided so that configuration errors are easier to track down' do
       lambda {
-        ThinkingSphinx::Attribute.new([])
+        ThinkingSphinx::Attribute.new(@source, [])
       }.should raise_error(RuntimeError)
     end
 
     it 'raises if an element of the columns param is an integer - as happens when you use id instead of :id - so that configuration errors are easier to track down' do
       lambda {
-        ThinkingSphinx::Attribute.new([1234])
+        ThinkingSphinx::Attribute.new(@source, [1234])
       }.should raise_error(RuntimeError)
     end
   end
   
   describe "unique_name method" do
     before :each do
-      @attribute = ThinkingSphinx::Attribute.new [
+      @attribute = ThinkingSphinx::Attribute.new @source, [
         Object.stub_instance(:__stack => [], :__name => "col_name")
       ]
     end
@@ -42,21 +49,21 @@ describe ThinkingSphinx::Attribute do
   
   describe "column_with_prefix method" do
     before :each do
-      @attribute = ThinkingSphinx::Attribute.new [
+      @attribute = ThinkingSphinx::Attribute.new @source, [
         ThinkingSphinx::Index::FauxColumn.new(:col_name)
       ]
       @attribute.columns.each { |col| @attribute.associations[col] = [] }
       @attribute.model = Person
       
-      @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
-      @second_join  = Object.stub_instance(:aliased_table_name => "data")
+      @first_join   = Object.new
+      @first_join.stub!(:aliased_table_name => "tabular")
+      @second_join  = Object.new
+      @second_join.stub!(:aliased_table_name => "data")
       
-      @first_assoc  = ThinkingSphinx::Association.stub_instance(
-        :join => @first_join, :has_column? => true
-      )
-      @second_assoc = ThinkingSphinx::Association.stub_instance(
-        :join => @second_join, :has_column? => true
-      )
+      @first_assoc  = ThinkingSphinx::Association.new nil, nil
+      @first_assoc.stub!(:join => @first_join, :has_column? => true)
+      @second_assoc = ThinkingSphinx::Association.new nil, nil
+      @second_assoc.stub!(:join => @second_join, :has_column? => true)
     end
     
     it "should return the column name if the column is a string" do
@@ -88,7 +95,7 @@ describe ThinkingSphinx::Attribute do
       @assoc_c = Object.stub_instance(:is_many? => true)
       
       @attribute = ThinkingSphinx::Attribute.new(
-        [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
+        @source, [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
       )
       @attribute.associations = {
         :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
@@ -122,7 +129,7 @@ describe ThinkingSphinx::Attribute do
       @col_c = ThinkingSphinx::Index::FauxColumn.new("c")
 
       @attribute = ThinkingSphinx::Attribute.new(
-        [@col_a, @col_b, @col_c]
+        @source, [@col_a, @col_b, @col_c]
       )
     end
     
@@ -146,7 +153,7 @@ describe ThinkingSphinx::Attribute do
   describe "type method" do
     before :each do
       @column = ThinkingSphinx::Index::FauxColumn.new(:col_name)
-      @attribute = ThinkingSphinx::Attribute.new([@column])
+      @attribute = ThinkingSphinx::Attribute.new(@source, [@column])
       @attribute.model = Person
       @attribute.stub_method(:is_many? => false)
     end
@@ -177,7 +184,7 @@ describe ThinkingSphinx::Attribute do
   
   describe "all_ints? method" do
     it "should return true if all columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(
+      attribute = ThinkingSphinx::Attribute.new(@source,
         [ ThinkingSphinx::Index::FauxColumn.new(:id),
           ThinkingSphinx::Index::FauxColumn.new(:team_id) ]
       )
@@ -188,7 +195,7 @@ describe ThinkingSphinx::Attribute do
     end
     
     it "should return false if only some columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(
+      attribute = ThinkingSphinx::Attribute.new(@source,
         [ ThinkingSphinx::Index::FauxColumn.new(:id),
           ThinkingSphinx::Index::FauxColumn.new(:first_name) ]
       )
@@ -199,7 +206,7 @@ describe ThinkingSphinx::Attribute do
     end
     
     it "should return false if no columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(
+      attribute = ThinkingSphinx::Attribute.new(@source,
         [ ThinkingSphinx::Index::FauxColumn.new(:first_name),
           ThinkingSphinx::Index::FauxColumn.new(:last_name) ]
       )
@@ -210,10 +217,193 @@ describe ThinkingSphinx::Attribute do
     end
   end
   
+  describe "MVA with source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :query
+      )
+    end
+    
+    it "should use a query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query = @attribute.config_value.split('; ')
+      declaration.should == "uint tag_ids from query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
+    end
+  end
+  
+  describe "MVA with source query for a delta source" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :query
+      )
+    end
+    
+    it "should use a query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query = @attribute.config_value(nil, true).split('; ')
+      declaration.should == "uint tag_ids from query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+    end
+  end
+  
+  describe "MVA via a HABTM association with a source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+        :as => :link_ids, :source => :query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query = @attribute.config_value.split('; ')
+      declaration.should == "uint link_ids from query"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
+    end
+  end
+  
+  describe "MVA with ranged source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint tag_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
+    end
+  end
+  
+  describe "MVA with ranged source query for a delta source" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration.should == "uint tag_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
+    end
+  end
+  
+  describe "MVA via a has-many :through with a ranged source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
+        :as => :football_team_ids, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint football_team_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
+    end
+  end
+  
+  describe "MVA via a has-many :through using a foreign key with a ranged source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
+        :as => :friend_ids, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint friend_ids from ranged-query"
+      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
+      range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
+    end
+  end
+  
+  describe "MVA via a HABTM with a ranged source query" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+        :as => :link_ids, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint link_ids from ranged-query"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
+      range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
+    end
+  end
+  
+  describe "MVA via two has-many associations with a ranged source query" do
+    before :each do
+      @index  = ThinkingSphinx::Index.new(Alpha)
+      @source = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+        :as => :gamma_values, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint gamma_values from ranged-query"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
+      range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
+    end
+  end
+  
+  describe "MVA via two has-many associations with a ranged source query for a delta source" do
+    before :each do
+      @index  = ThinkingSphinx::Index.new(Alpha)
+      @source = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+        :as => :gamma_values, :source => :ranged_query
+      )
+      
+      @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration.should == "uint gamma_values from ranged-query"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
+      range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
+    end
+  end
+  
   describe "with custom queries" do
     before :each do
       index = CricketTeam.sphinx_indexes.first
-      @statement = index.to_riddle_for_core(0, 0).sql_attr_multi.first
+      @statement = index.sources.first.to_riddle_for_core(0, 0).sql_attr_multi.last
     end
     
     it "should track the query type accordingly" do

data/spec/unit/thinking_sphinx/collection_spec.rb

@@ -2,12 +2,13 @@ require 'spec/spec_helper'
 
 describe ThinkingSphinx::Collection do
   it "should behave like WillPaginate::Collection" do
-    ThinkingSphinx::Collection.instance_methods.should include("previous_page")
-    ThinkingSphinx::Collection.instance_methods.should include("next_page")
-    ThinkingSphinx::Collection.instance_methods.should include("current_page")
-    ThinkingSphinx::Collection.instance_methods.should include("total_pages")
-    ThinkingSphinx::Collection.instance_methods.should include("total_entries")
-    ThinkingSphinx::Collection.instance_methods.should include("offset")
+    instance_methods = ThinkingSphinx::Collection.instance_methods.collect { |m| m.to_s }
+    instance_methods.should include("previous_page")
+    instance_methods.should include("next_page")
+    instance_methods.should include("current_page")
+    instance_methods.should include("total_pages")
+    instance_methods.should include("total_entries")
+    instance_methods.should include("offset")
     
     ThinkingSphinx::Collection.ancestors.should include(Array)
   end

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -10,11 +10,11 @@ describe ThinkingSphinx::Configuration do
     
     it "should use the Merb environment value if set" do
       unless defined?(Merb)
-        module Merb; end
+        module ::Merb; end
       end
-            
+      
       ThinkingSphinx::Configuration.stub_method(:defined? => true)
-      Merb.stub_method(:environment => "merb_production")
+      Merb.stub!(:environment => "merb_production")
       ThinkingSphinx::Configuration.environment.should == "merb_production"
       
       Object.send(:remove_const, :Merb)
@@ -48,7 +48,9 @@ describe ThinkingSphinx::Configuration do
           "morphology"        => "stem_ru",
           "charset_type"      => "latin1",
           "charset_table"     => "table",
-          "ignore_chars"      => "e"
+          "ignore_chars"      => "e",
+          "searchd_binary_name" => "sphinx-searchd",
+          "indexer_binary_name" => "sphinx-indexer"
         }
       }
       
@@ -62,7 +64,7 @@ describe ThinkingSphinx::Configuration do
       config.send(:parse_config)
       
       %w(config_file searchd_log_file query_log_file pid_file searchd_file_path
-        address port).each do |key|
+        address port searchd_binary_name indexer_binary_name).each do |key|
         config.send(key).should == @settings["development"][key]
       end
     end
@@ -71,7 +73,16 @@ describe ThinkingSphinx::Configuration do
       FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
     end
   end
-    
+
+  describe "block configuration" do
+    it "should let the user set-up a custom app_root" do
+      ThinkingSphinx::Configuration.configure do |config|
+        config.app_root = "/here/somewhere"
+      end
+      ThinkingSphinx::Configuration.instance.app_root.should == "/here/somewhere"
+    end
+  end
+  
   describe "initialisation" do
     it "should have a default bin_path of nothing" do
       ThinkingSphinx::Configuration.instance.bin_path.should == ""
@@ -93,6 +104,81 @@ describe ThinkingSphinx::Configuration do
     end
   end
   
+  describe "index options" do
+    before :each do
+      @settings = {
+        "development" => {"disable_range" => true}
+      }
+      
+      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump(@settings)
+      end
+      
+      @config = ThinkingSphinx::Configuration.instance
+      @config.send(:parse_config)
+    end
+    
+    it "should collect disable_range" do
+      @config.index_options[:disable_range].should be_true
+    end
+  end
+  
+  describe "#load_models" do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.model_directories = ['']
+      
+      @file_name        = 'a.rb'
+      @model_name_lower = 'a'
+      @class_name       = 'A'
+      
+      @file_name.stub!(:gsub).and_return(@model_name_lower)
+      @model_name_lower.stub!(:camelize).and_return(@class_name)
+      Dir.stub(:[]).and_return([@file_name])
+    end
+    
+    it "should load the files by guessing the file name" do
+      @class_name.should_receive(:constantize).and_return(true)
+      
+      @config.load_models
+    end
+    
+    it "should not raise errors if the model name is nil" do
+      @file_name.stub!(:gsub).and_return(nil)
+      
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+    
+    it "should not raise errors if the file name does not represent a class name" do
+      @class_name.should_receive(:constantize).and_raise(NameError)
+      
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+    
+    it "should retry if the first pass fails and contains a directory" do
+      @model_name_lower.stub!(:gsub!).and_return(true, nil)
+      @class_name.stub(:constantize).and_raise(LoadError)
+      @model_name_lower.should_receive(:camelize).twice
+      
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+    
+    it "should catch database errors with a warning" do
+      @class_name.should_receive(:constantize).and_raise(Mysql::Error)
+      @config.should_receive(:puts).with('Warning: Error loading a.rb')
+      
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+  end
+  
   it "should insert set index options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
     ThinkingSphinx::Configuration::IndexOptions.each do |option|
@@ -133,4 +219,4 @@ describe ThinkingSphinx::Configuration do
     }
     file.should_not match(/index alpha_core\s+\{\s+[^\}]*prefix_fields\s+=[^\}]*\}/m)
   end
-end
+end