pixeltrix-thinking-sphinx 1.1.5

data/spec/unit/thinking_sphinx/collection_spec.rb

@@ -0,0 +1,14 @@
+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")
+    
+    ThinkingSphinx::Collection.ancestors.should include(Array)
+  end
+end

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -0,0 +1,136 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Configuration do
+  describe "environment class method" do
+    before :each do
+      ThinkingSphinx::Configuration.send(:class_variable_set, :@@environment, nil)
+      
+      ENV["RAILS_ENV"] = nil
+    end
+    
+    it "should use the Merb environment value if set" do
+      unless defined?(Merb)
+        module Merb; end
+      end
+            
+      ThinkingSphinx::Configuration.stub_method(:defined? => true)
+      Merb.stub_method(:environment => "merb_production")
+      ThinkingSphinx::Configuration.environment.should == "merb_production"
+      
+      Object.send(:remove_const, :Merb)
+    end
+    
+    it "should use the Rails environment value if set" do
+      ENV["RAILS_ENV"] = "rails_production"
+      ThinkingSphinx::Configuration.environment.should == "rails_production"
+    end
+    
+    it "should default to development" do
+      ThinkingSphinx::Configuration.environment.should == "development"
+    end
+  end
+  
+  describe "parse_config method" do
+    before :each do
+      @settings = {
+        "development" => {
+          "config_file"       => "tmp/config/development.sphinx.conf",
+          "searchd_log_file"  => "searchd_log_file.log",
+          "query_log_file"    => "query_log_file.log",
+          "pid_file"          => "pid_file.pid",
+          "searchd_file_path" => "searchd/file/path",
+          "address"           => "127.0.0.1",
+          "port"              => 3333,
+          "min_prefix_len"    => 2,
+          "min_infix_len"     => 3,
+          "mem_limit"         => "128M",
+          "max_matches"       => 1001,
+          "morphology"        => "stem_ru",
+          "charset_type"      => "latin1",
+          "charset_table"     => "table",
+          "ignore_chars"      => "e"
+        }
+      }
+      
+      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump(@settings)
+      end
+    end
+    
+    it "should use the accessors to set the configuration values" do
+      config = ThinkingSphinx::Configuration.instance
+      config.send(:parse_config)
+      
+      %w(config_file searchd_log_file query_log_file pid_file searchd_file_path
+        address port).each do |key|
+        config.send(key).should == @settings["development"][key]
+      end
+    end
+    
+    after :each do
+      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+    end
+  end
+    
+  describe "initialisation" do
+    it "should have a default bin_path of nothing" do
+      ThinkingSphinx::Configuration.instance.bin_path.should == ""
+    end
+    
+    it "should append a / to bin_path if one is supplied" do
+      @settings = {
+        "development" => {
+          "bin_path" => "path/to/somewhere"
+        }
+      }
+      
+      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump(@settings)
+      end
+      
+      ThinkingSphinx::Configuration.instance.send(:parse_config)
+      ThinkingSphinx::Configuration.instance.bin_path.should match(/\/$/)
+    end
+  end
+  
+  it "should insert set index options into the configuration file" do
+    config = ThinkingSphinx::Configuration.instance
+    ThinkingSphinx::Configuration::IndexOptions.each do |option|
+      config.index_options[option.to_sym] = "something"
+      config.build
+      
+      file = open(config.config_file) { |f| f.read }
+      file.should match(/#{option}\s+= something/)
+      
+      config.index_options[option.to_sym] = nil
+    end
+  end
+  
+  it "should insert set source options into the configuration file" do
+    config = ThinkingSphinx::Configuration.instance
+    ThinkingSphinx::Configuration::SourceOptions.each do |option|
+      config.source_options[option.to_sym] = "something"
+      config.build
+      
+      file = open(config.config_file) { |f| f.read }
+      file.should match(/#{option}\s+= something/)
+      
+      config.source_options[option.to_sym] = nil
+    end
+  end
+  
+  it "should set any explicit prefixed or infixed fields" do
+    file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
+      f.read
+    }
+    file.should match(/prefix_fields\s+= city/)
+    file.should match(/infix_fields\s+= state/)    
+  end
+  
+  it "should not have prefix fields in indexes where nothing is set" do
+    file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
+      f.read
+    }
+    file.should_not match(/index alpha_core\s+\{\s+[^\}]*prefix_fields\s+=[^\}]*\}/m)
+  end
+end

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

@@ -0,0 +1,145 @@
+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 "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 "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 name if the column is a string" do
+      @field.columns = [ThinkingSphinx::Index::FauxColumn.new("string")]
+      @field.send(:column_with_prefix, @field.columns.first).should == "string"
+    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,5 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index::Builder do
+  #
+end

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

@@ -0,0 +1,30 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index::FauxColumn do  
+  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
+end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -0,0 +1,54 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index do
+  describe "generated sql_query" do
+    it "should include explicit groupings if requested" do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @index.groupings << "custom_sql"
+      @index.to_riddle_for_core(0, 0).sql_query.should match(/GROUP BY.+custom_sql/)
+    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
+end

data/spec/unit/thinking_sphinx/search_spec.rb

@@ -0,0 +1,59 @@
+require 'spec/spec_helper'
+require 'will_paginate/collection'
+
+describe ThinkingSphinx::Search do
+  describe "search method" do
+    before :each do
+      @client = Riddle::Client.stub_instance(
+        :filters    => [],
+        :filters=   => true,
+        :id_range=  => true,
+        :sort_mode  => :asc,
+        :limit      => 5,
+        :offset=    => 0,
+        :sort_mode= => true,
+        :query      => {
+          :matches  => [],
+          :total    => 50
+        }
+      )
+      
+      ThinkingSphinx::Search.stub_methods(
+        :client_from_options => @client,
+        :search_conditions   => ["", []]
+      )
+    end
+    
+    describe ":star option" do
+      
+      it "should not apply by default" do
+        ThinkingSphinx::Search.search "foo bar"
+        @client.should have_received(:query).with("foo bar")
+      end
+
+      it "should apply when passed, and handle full extended syntax" do
+        input    = %{a b* c (d | e) 123 5&6 (f_f g) !h "i j" "k l"~10 "m n"/3 @o p -(q|r)}
+        expected = %{*a* b* *c* (*d* | *e*) *123* *5*&*6* (*f_f* *g*) !*h* "i j" "k l"~10 "m n"/3 @o *p* -(*q*|*r*)}
+        ThinkingSphinx::Search.search input, :star => true
+        @client.should have_received(:query).with(expected)
+      end
+
+      it "should default to /\w+/ as token" do
+        ThinkingSphinx::Search.search "foo@bar.com", :star => true
+        @client.should have_received(:query).with("*foo*@*bar*.*com*")
+      end
+
+      it "should honour custom token" do
+        ThinkingSphinx::Search.search "foo@bar.com -foo-bar", :star => /[\w@.-]+/u
+        @client.should have_received(:query).with("*foo@bar.com* -*foo-bar*")
+      end
+
+    end
+  end
+end
+
+describe ThinkingSphinx::Search, "playing nice with Search model" do
+  it "should not conflict with models called Search" do
+    lambda { Search.find(:all) }.should_not raise_error
+  end
+end