freelancing-god-thinking-sphinx 0.9.6 → 0.9.7

data/spec/unit/thinking_sphinx/field_spec.rb

@@ -1,7 +1,21 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::Field do
-  describe "to_select_sql method" do
+  describe '#initialize' do
+    it 'raises if no columns are provided so that configuration errors are easier to track down' do
+      lambda {
+        ThinkingSphinx::Field.new([])
+      }.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::Field.new([1234])
+      }.should raise_error(RuntimeError)
+    end
+  end
+  
+  describe "to_select_sql method with MySQL" do
     before :each do
       @index = Person.indexes.first
       @index.link!
@@ -20,9 +34,31 @@ describe ThinkingSphinx::Field do
     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([])
+      @field = ThinkingSphinx::Field.new([Object.stub_instance(:__stack => [])])
       @field.stub_methods(:is_many? => false)
       
       ThinkingSphinx.stub_method(:use_group_by_shortcut? => false)
@@ -41,11 +77,139 @@ describe ThinkingSphinx::Field do
     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 [
+        Object.stub_instance(:__stack => [], :__name => "col_name")
+      ]
+    end
+    
+    it "should use the alias if there is one" do
+      @field.alias = "alias"
+      @field.unique_name.should == "alias"
+    end
+    
+    it "should use the alias if there's multiple columns" do
+      @field.columns << Object.stub_instance(:__stack => [], :__name => "col_name")
+      @field.unique_name.should be_nil
+      
+      @field.alias = "alias"
+      @field.unique_name.should == "alias"
+    end
+    
+    it "should use the column name if there's no alias and just one column" do
+      @field.unique_name.should == "col_name"
+    end
+  end
+
+  describe "prefixes method" do
+    it "should default to false" do
+      @field = ThinkingSphinx::Field.new([Object.stub_instance(:__stack => [])])
+      @field.prefixes.should be_false
+    end
     
-    after :each do
-      ThinkingSphinx.unstub_method(:use_group_by_shortcut?)
+    it "should be true if the corresponding option is set" do
+      @field = ThinkingSphinx::Field.new(
+        [Object.stub_instance(:__stack => [])], :prefixes => true
+      )
+      @field.prefixes.should be_true
+    end
+  end
+  
+  describe "infixes method" do
+    it "should default to false" do
+      @field = ThinkingSphinx::Field.new([Object.stub_instance(:__stack => [])])
+      @field.infixes.should be_false
+    end
+    
+    it "should be true if the corresponding option is set" do
+      @field = ThinkingSphinx::Field.new(
+        [Object.stub_instance(:__stack => [])], :infixes => true
+      )
+      @field.infixes.should be_true
+    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 [
+        ThinkingSphinx::Index::FauxColumn.new(:col_name)
+      ]
+      @field.columns.each { |col| @field.associations[col] = [] }
+      @field.model = Person
+      
+      @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
+      @second_join  = Object.stub_instance(:aliased_table_name => "data")
+      
+      @first_assoc  = ThinkingSphinx::Association.stub_instance(:join => @first_join)
+      @second_assoc = ThinkingSphinx::Association.stub_instance(:join => @second_join)
+    end
+    
+    it "should return the column with model's table prefix if there's no associations for the column" do
+      @field.send(:column_with_prefix, @field.columns.first).should == "`people`.`col_name`"
+    end
+    
+    it "should return the column with its join table prefix if an association exists" do
+      column = @field.columns.first
+      @field.associations[column] = [@first_assoc]
+      @field.send(:column_with_prefix, column).should == "`tabular`.`col_name`"
+    end
+    
+    it "should return multiple columns concatenated if more than one association exists" do
+      column = @field.columns.first
+      @field.associations[column] = [@first_assoc, @second_assoc]
+      @field.send(:column_with_prefix, column).should == "`tabular`.`col_name`, `data`.`col_name`"
+    end
+  end
+  
+  describe "is_many? method" do
+    before :each do
+      @assoc_a = Object.stub_instance(:is_many? => true)
+      @assoc_b = Object.stub_instance(:is_many? => true)
+      @assoc_c = Object.stub_instance(:is_many? => true)
+      
+      @field = ThinkingSphinx::Field.new(
+        [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
+      )
+      @field.associations = {
+        :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
+      }
+    end
+    
+    it "should return true if all associations return true to is_many?" do
+      @field.send(:is_many?).should be_true
+    end
+    
+    it "should return true if one association returns true to is_many?" do
+      @assoc_b.stub_method(:is_many? => false)
+      @assoc_c.stub_method(:is_many? => false)
+      
+      @field.send(:is_many?).should be_true
+    end
+    
+    it "should return false if all associations return false to is_many?" do
+      @assoc_a.stub_method(:is_many? => false)
+      @assoc_b.stub_method(:is_many? => false)
+      @assoc_c.stub_method(:is_many? => false)
+      
+      @field.send(:is_many?).should be_false
     end
   end
-end
+end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -1,5 +1,190 @@
 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(0, @database, "utf-8")
+      
+      @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(0, @database, "utf-8") }.should raise_error
+    end
+    
+    it "should set the core source name to {model}_{index}_core" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /source person_0_core/
+      )
+    end
+    
+    it "should include the database config supplied" do
+      conf = @index.to_config(0, @database, "utf-8")
+      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 have a pre query 'SET NAMES utf8' if using mysql and utf8 charset" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /sql_query_pre\s+= SET NAMES utf8/
+      )
+      
+      @index.to_config(0, @database, "non-utf-8").should_not match(
+        /SET NAMES utf8/
+      )
+      
+      @index.stub_method(:adapter => :postgres)
+      @index.to_config(0, @database, "utf-8").should_not match(
+        /SET NAMES utf8/
+      )
+    end
+    
+    it "should use the pre query from the index" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /sql_query_pre\s+= sql_query_pre/
+      )
+    end
+    
+    it "should use the main query from the index" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /sql_query\s+= SQL/
+      )
+    end
+    
+    it "should use the range query from the index" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /sql_query_range\s+= sql_query_range/
+      )
+    end
+    
+    it "should use the info query from the index" do
+      @index.to_config(0, @database, "utf-8").should match(
+        /sql_query_info\s+= sql_query_info/
+      )
+    end
+    
+    it "should include the attribute sources" do
+      @index.to_config(0, @database, "utf-8").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(0, @database, "utf-8").should match(
+        /source person_0_delta/
+      )
+    end
+    
+    it "should not add a delta index unless requested" do
+      @index.to_config(0, @database, "utf-8").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(0, @database, "utf-8").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(0, @database, "utf-8").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(0, @database, "utf-8").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(0, @database, "utf-8").should match(
+        /source person_0_delta.+sql_query_pre\s+=\s*\n/m
+      )
+    end
+  end
+  
+  describe "prefix_fields method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = ThinkingSphinx::Field.stub_instance(:prefixes => true)
+      @field_b = ThinkingSphinx::Field.stub_instance(:prefixes => false)
+      @field_c = ThinkingSphinx::Field.stub_instance(:prefixes => true)
+      
+      @index.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" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = ThinkingSphinx::Field.stub_instance(:infixes => true)
+      @field_b = ThinkingSphinx::Field.stub_instance(:infixes => false)
+      @field_c = ThinkingSphinx::Field.stub_instance(:infixes => true)
+      
+      @index.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
 end

data/spec/unit/thinking_sphinx_spec.rb

@@ -78,5 +78,30 @@ describe ThinkingSphinx do
       
       ThinkingSphinx.use_group_by_shortcut?.should be_false
     end
+    
+    describe "if not using MySQL" do
+      before :each do
+        @connection = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.stub_instance(
+          :select_all => true
+        )
+        ::ActiveRecord::Base.stub_method(
+          :connection => @connection
+        )
+      end
+      
+      after :each do
+        ::ActiveRecord::Base.unstub_method(:connection)
+      end
+    
+      it "should return false" do
+        ThinkingSphinx.use_group_by_shortcut?.should be_false
+      end
+    
+      it "should not call select_all" do
+        ThinkingSphinx.use_group_by_shortcut?
+        
+        @connection.should_not have_received(:select_all)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: freelancing-god-thinking-sphinx
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Pat Allan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-14 00:00:00 -07:00
+date: 2008-06-05 00:00:00 -07:00
 default_executable: 
 dependencies: []