DrMark-thinking-sphinx 0.9.9 → 1.1.6

data/spec/unit/thinking_sphinx/core/string_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+
+describe String do  
+  describe "to_crc32 instance method" do
+    it "should return an integer" do
+      'to_crc32'.to_crc32.should be_a_kind_of(Integer)
+    end
+  end
+end    

data/spec/unit/thinking_sphinx/field_spec.rb

@@ -15,73 +15,6 @@ describe ThinkingSphinx::Field do
     end
   end
   
-  describe "to_select_sql method with MySQL" do
-    before :each do
-      @index = Person.indexes.first
-      @index.link!
-    end
-    
-    it "should concat with spaces if there are multiple columns" do
-      @index.fields.first.to_select_sql.should match(/CONCAT_WS\(' ', /)
-    end
-    
-    it "should concat with spaces if a column has more than one association" do
-      @index.fields[1].to_select_sql.should match(/CONCAT_WS\(' ', /)
-    end
-    
-    it "should group if any association for any column is a has_many or has_and_belongs_to_many" do
-      @index.fields[2].to_select_sql.should match(/GROUP_CONCAT/)
-    end
-  end
-  
-  describe "to_select_sql method with PostgreSQL" do
-    before :each do
-      @index = Person.indexes.first
-      Person.connection.class.stub_method(
-        :name => "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-      )
-      @index.link!
-    end
-    
-    it "should concat with spaces if there are multiple columns" do
-      @index.fields.first.to_select_sql.should match(/|| ' ' ||/)
-    end
-    
-    it "should concat with spaces if a column has more than one association" do
-      @index.fields[1].to_select_sql.should match(/|| ' ' ||/)
-    end
-    
-    it "should group if any association for any column is a has_many or has_and_belongs_to_many" do
-      @index.fields[2].to_select_sql.should match(/array_to_string\(array_accum\(/)
-    end
-  end
-  
-  describe "to_group_sql method" do
-    before :each do
-      @field = ThinkingSphinx::Field.new([Object.stub_instance(:__stack => [])])
-      @field.stub_methods(:is_many? => false)
-      
-      ThinkingSphinx.stub_method(:use_group_by_shortcut? => false)
-    end
-    
-    it "should return nil if is_many?" do
-      @field.stub_method(:is_many? => true)
-      
-      @field.to_group_sql.should be_nil
-    end
-    
-    it "should return nil if group_by shortcut is allowed" do
-      ThinkingSphinx.stub_method(:use_group_by_shortcut? => true)
-      
-      @field.to_group_sql.should be_nil
-    end
-    
-    it "should return an array if neither is_many? or shortcut allowed" do
-      @field.stub_method(:column_with_prefix => 'hello')
-      @field.to_group_sql.should be_a_kind_of(Array)
-    end
-  end
-  
   describe "unique_name method" do
     before :each do
       @field = ThinkingSphinx::Field.new [
@@ -135,18 +68,6 @@ describe ThinkingSphinx::Field do
     end
   end
   
-  describe "quote_column_name method" do
-    it "should delegate the call to the model's connection" do
-      @field = ThinkingSphinx::Field.new [
-        ThinkingSphinx::Index::FauxColumn.new(:col_name)
-      ]
-      @field.model = Person
-      Person.connection.stub_method(:quote_column_name => "quoted!")
-      
-      @field.send(:quote_column, "blah").should == "quoted!"
-    end
-  end
-  
   describe "column_with_prefix method" do
     before :each do
       @field = ThinkingSphinx::Field.new [

data/spec/unit/thinking_sphinx/index/builder_spec.rb

@@ -1,33 +1,5 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::Index::Builder do
-  before :each do
-    @builder = Class.new(ThinkingSphinx::Index::Builder)
-    @builder.setup
-  end
-  
-  describe "setup method" do
-    it "should set up the information arrays and properties hash" do
-      @builder.fields.should     == []
-      @builder.attributes.should == []
-      @builder.conditions.should == []
-      @builder.properties.should == {}
-    end
-  end
-  
-  describe "indexes method" do
-    
-  end
-  
-  describe "has method" do
-    
-  end
-  
-  describe "where method" do
-    
-  end
-  
-  describe "set_property method" do
-    
-  end
+  #
 end

data/spec/unit/thinking_sphinx/index/faux_column_spec.rb

@@ -1,22 +1,6 @@
 require 'spec/spec_helper'
 
-describe ThinkingSphinx::Index::FauxColumn do
-  it "should use the last argument as the name, with preceeding ones going into the stack" do
-    #
-  end
-  
-  it "should access the name through __name" do
-    #
-  end
-  
-  it "should access the stack through __stack" do
-    #
-  end
-  
-  it "should return true from is_string? if the name is a string and the stack is empty" do
-    #
-  end
-  
+describe ThinkingSphinx::Index::FauxColumn do  
   describe "coerce class method" do
     before :each do
       @column = ThinkingSphinx::Index::FauxColumn.stub_instance
@@ -43,26 +27,4 @@ describe ThinkingSphinx::Index::FauxColumn do
       ]
     end
   end
-  
-  describe "method_missing calls with no arguments" do
-    it "should push any further method calls into name, and the old name goes into the stack" do
-      #
-    end
-    
-    it "should return itself" do
-      #
-    end
-  end
-  
-  describe "method_missing calls with one argument" do
-    it "should act as if calling method missing with method, then argument" do
-      #
-    end
-  end
-  
-  describe "method_missing calls with more than one argument" do
-    it "should return a collection of Faux Columns sharing the same stack, but with each argument as the name" do
-      #
-    end
-  end
 end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -1,213 +1,12 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::Index do
-  describe "to_config method" do
-    before :each do
-      @index = ThinkingSphinx::Index.new(Person)
-      
-      @index.stub_methods(
-        :attributes => [
-          ThinkingSphinx::Attribute.stub_instance(:to_sphinx_clause => "attr a"),
-          ThinkingSphinx::Attribute.stub_instance(:to_sphinx_clause => "attr b")
-        ],
-        :link!              => true,
-        :adapter            => :mysql,
-        :to_sql_query_pre   => "sql_query_pre",
-        :to_sql             => "SQL",
-        :to_sql_query_range => "sql_query_range",
-        :to_sql_query_info  => "sql_query_info",
-        :delta?             => false
-      )
-      
-      @database = {
-        :host     => "localhost",
-        :username => "username",
-        :password => "blank",
-        :database => "db"
-      }
-    end
-    
-    it "should call link!" do
-      @index.to_config(Person, 0, @database, "utf-8", 0)
-      
-      @index.should have_received(:link!)
-    end
-    
-    it "should raise an exception if the adapter isn't mysql or postgres" do
-      @index.stub_method(:adapter => :sqlite)
-      
-      lambda { @index.to_config(Person, 0, @database, "utf-8", 0) }.should raise_error
-    end
-    
-    it "should set the core source name to {model}_{index}_core" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_core/
-      )
-    end
-    
-    it "should include the database config supplied" do
-      conf = @index.to_config(Person, 0, @database, "utf-8", 0)
-      conf.should match(/type\s+= mysql/)
-      conf.should match(/sql_host\s+= localhost/)
-      conf.should match(/sql_user\s+= username/)
-      conf.should match(/sql_pass\s+= blank/)
-      conf.should match(/sql_db\s+= db/)
-    end
-    
-    it "should use 'user' if 'username' doesn't exist in database configuration" do
-      conf = @index.to_config(Person, 0,
-        @database.except(:username).merge(:user => "username"),
-        "utf-8", 0
-      )
-      conf.should match(/sql_user\s+= username/)
-    end
-    
-    it "should include the database socket if set" do
-      conf = @index.to_config(Person, 0, @database.merge(:socket => "dbsocket"), "utf-8", 0)
-      conf.should match(/sql_sock\s+= dbsocket/)
-    end
-    
-    it "should not include the database socket if not set" do
-      conf = @index.to_config(Person, 0, @database, "utf-8", 0)
-      conf.should_not match(/sql_sock/)
-    end
-    
-    it "should have a pre query 'SET NAMES utf8' if using mysql and utf8 charset" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query_pre\s+= SET NAMES utf8/
-      )
-      
-      @index.stub_method(:delta? => true)
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta.+sql_query_pre\s+= SET NAMES utf8/m
-      )
-      
-      @index.stub_method(:delta? => false)
-      @index.to_config(Person, 0, @database, "non-utf-8", 0).should_not match(
-        /SET NAMES utf8/
-      )
-      
-      @index.stub_method(:adapter => :postgres)
-      @index.to_config(Person, 0, @database, "utf-8", 0).should_not match(
-        /SET NAMES utf8/
-      )
-    end
-    
-    it "should use the pre query from the index" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query_pre\s+= sql_query_pre/
-      )
-    end
-    
-    it "should not set group_concat_max_len if not specified" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should_not match(
-        /group_concat_max_len/
-      )
-    end
-
-    it "should set group_concat_max_len if specified" do
-      @index.options.merge! :group_concat_max_len => 2056
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query_pre\s+= SET SESSION group_concat_max_len = 2056/
-      )
-      
-      @index.stub_method(:delta? => true)
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta.+sql_query_pre\s+= SET SESSION group_concat_max_len = 2056/m
-      )
-    end
-    
-    it "should use the main query from the index" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query\s+= SQL/
-      )
-    end
-    
-    it "should use the range query from the index" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query_range\s+= sql_query_range/
-      )
-    end
-    
-    it "should pass the offset to the range query" do
-      @index.unstub_method(:to_sql_query_range)
-      @index.to_config(Person, 0, @database, "utf-8", 7).should include(
-        "sql_query_range  = SELECT MIN(`id` * 3 + 7), MAX(`id` * 3 + 7)"
-      )
-    end
-
-    it "should use the info query from the index" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /sql_query_info\s+= sql_query_info/
-      )
-    end
-    
-    it "should include the attribute sources" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /attr a\n\s+attr b/
-      )
-    end
-    
-    it "should add a delta index with name {model}_{index}_delta if requested" do
-      @index.stub_method(:delta? => true)
-      
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta/
-      )
-    end
-    
-    it "should not add a delta index unless requested" do
-      @index.to_config(Person, 0, @database, "utf-8", 0).should_not match(
-        /source person_0_delta/
-      )
-    end
-    
-    it "should have the delta index inherit from the core index" do
-      @index.stub_method(:delta? => true)
-      
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta : person_0_core/
-      )
-    end
-    
-    it "should redefine the main query for the delta index" do
-      @index.stub_method(:delta? => true)
-      
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta.+sql_query\s+= SQL/m
-      )
-    end
-    
-    it "should redefine the range query for the delta index" do
-      @index.stub_method(:delta? => true)
-      
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta.+sql_query_range\s+= sql_query_range/m
-      )
-    end
-    
-    it "should redefine the pre query for the delta index" do
-      @index.stub_method(:delta? => true)
-      
-      @index.to_config(Person, 0, @database, "utf-8", 0).should match(
-        /source person_0_delta.+sql_query_pre\s+=\s*\n/m
-      )
-    end
-  end
-  
-  describe "to_sql_query_range method" do
-    before :each do
+  describe "generated sql_query" do
+    it "should include explicit groupings if requested" do
       @index = ThinkingSphinx::Index.new(Person)
-    end
-    
-    it "should add COALESCE around MIN and MAX calls if using PostgreSQL" do
-      @index.stub_method(:adapter => :postgres)
       
-      @index.to_sql_query_range.should match(/COALESCE\(MIN.+COALESCE\(MAX/)
-    end
-    
-    it "shouldn't add COALESCE if using MySQL" do
-      @index.to_sql_query_range.should_not match(/COALESCE/)
+      @index.groupings << "custom_sql"
+      @index.to_riddle_for_core(0, 0).sql_query.should match(/GROUP BY.+custom_sql/)
     end
   end
   
@@ -253,40 +52,93 @@ describe ThinkingSphinx::Index do
     end
   end
   
-  describe "empty? method" do
-    before :each do
-      @index = ThinkingSphinx::Index.new(Person)
-      config = ThinkingSphinx::Configuration.new
+  describe "multi-value attribute as ranged-query with has-many association" do
+    before :each do 
+      @index = ThinkingSphinx::Index.new(Person) do
+        has tags(:id), :as => :tag_ids, :source => :ranged_query
+      end
+      @index.link!
       
-      `mkdir -p #{config.searchd_file_path}`
-      @file_path = "#{config.searchd_file_path}/#{@index.name}_core.spa"
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
     end
     
-    after :each do
-      FileUtils.rm(@file_path, :force => true)
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/tag_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`id`/)
     end
     
-    it "should return true if the core index files are empty" do
-      `touch #{@file_path}`
-      @index.should be_empty
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(: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 "multi-value attribute as ranged-query with has-many-through association" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has football_teams(:id), :as => :football_teams_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
     end
     
-    it "should return true if the core index files don't exist" do
-      @index.should be_empty
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/football_teams_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`football_team_id`/)
     end
     
-    it "should return false if the core index files aren't empty" do
-      `echo 'a' > #{@file_path}`
-      @index.should_not be_empty
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
     end
     
-    it "should check the delta files if specified" do
-      @index.should be_empty(:delta)
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
       
-      `echo 'a' > #{@file_path.gsub(/_core.spa$/, '_delta.spa')}`
-      @index.should_not be_empty(:delta)
+      declaration, query, range_query = attribute.send(:config_value).split('; ')
+      declaration.should == "uint football_teams_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_teams_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 "multi-value attribute as ranged-query with has-many-through association and foreign_key" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has friends(:id), :as => :friend_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/friend_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`friendships`.`friend_id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `friendships`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
       
-      `rm #{@file_path}` if File.exists?(@file_path.gsub(/_core.spa$/, '_delta.spa'))
+      declaration, query, range_query = attribute.send(: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
 end