ryanb-thinking_sphinx 0.9.8

data/spec/unit/thinking_sphinx/field_spec.rb

@@ -0,0 +1,219 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Field 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!
+    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 [
+        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
+    
+    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, :has_column? => true
+      )
+      @second_assoc = ThinkingSphinx::Association.stub_instance(
+        :join => @second_join, :has_column? => true
+      )
+    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

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,68 @@
+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 "coerce class method" do
+    before :each do
+      @column = ThinkingSphinx::Index::FauxColumn.stub_instance
+      ThinkingSphinx::Index::FauxColumn.stub_method(: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 "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

@@ -0,0 +1,277 @@
+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 include the database socket if set" do
+      conf = @index.to_config(0, @database.merge(:socket => "dbsocket"), "utf-8")
+      conf.should match(/sql_sock\s+= dbsocket/)
+    end
+    
+    it "should not include the database socket if not set" do
+      conf = @index.to_config(0, @database, "utf-8")
+      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(0, @database, "utf-8").should match(
+        /sql_query_pre\s+= SET NAMES utf8/
+      )
+      
+      @index.stub_method(:delta? => true)
+      @index.to_config(0, @database, "utf-8").should match(
+        /source person_0_delta.+sql_query_pre\s+= SET NAMES utf8/m
+      )
+      
+      @index.stub_method(:delta? => false)
+      @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 not set group_concat_max_len if not specified" do
+      @index.to_config(0, @database, "utf-8").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(0, @database, "utf-8").should match(
+        /sql_query_pre\s+= SET SESSION group_concat_max_len = 2056/
+      )
+      
+      @index.stub_method(:delta? => true)
+      @index.to_config(0, @database, "utf-8").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(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 "to_sql_query_range method" do
+    before :each 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/)
+    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 method" 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
+  
+  describe "empty? method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      config = ThinkingSphinx::Configuration.new
+      
+      `mkdir -p #{config.searchd_file_path}`
+      @file_path = "#{config.searchd_file_path}/#{@index.name}_core.spa"
+    end
+    
+    after :each do
+      `rm #{@file_path}` if File.exists?(@file_path)
+    end
+    
+    it "should return true if the core index files are empty" do
+      `touch #{@file_path}`
+      @index.should be_empty
+    end
+    
+    it "should return true if the core index files don't exist" do
+      @index.should be_empty
+    end
+    
+    it "should return false if the core index files aren't empty" do
+      `echo 'a' > #{@file_path}`
+      @index.should_not be_empty
+    end
+    
+    it "should check the delta files if specified" do
+      @index.should be_empty(:delta)
+      
+      `echo 'a' > #{@file_path.gsub(/_core.spa$/, '_delta.spa')}`
+      @index.should_not be_empty(:delta)
+      
+      `rm #{@file_path}` if File.exists?(@file_path.gsub(/_core.spa$/, '_delta.spa'))
+    end
+  end
+end