thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/index/faux_column_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Index::FauxColumn do  
-  describe "coerce class method" do
-    before :each do
-      @column = stub('column')
-      ThinkingSphinx::Index::FauxColumn.stub!(: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 '#to_ary' do
-    it "should return an array with the instance inside it" do
-      subject.to_ary.should == [subject]
-    end
-  end
-end

data/spec/thinking_sphinx/search_methods_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::SearchMethods do
-  it "should be included into models with indexes" do
-    Alpha.included_modules.should include(ThinkingSphinx::SearchMethods)
-  end
-
-  it "should not be included into models that don't have indexes" do
-    Gamma.included_modules.should_not include(ThinkingSphinx::SearchMethods)
-  end
-
-  describe '.search_context' do
-    it "should return nil if not within a model" do
-      ThinkingSphinx.search_context.should be_nil
-    end
-
-    it "should return the model if within one" do
-      Alpha.search_context.should == Alpha
-    end
-  end
-
-  describe '.search' do
-    it "should return an instance of ThinkingSphinx::Search" do
-      Alpha.search.class.should == ThinkingSphinx::Search
-    end
-
-    it "should set the classes option if not already set" do
-      search = Alpha.search
-      search.options[:classes].should == [Alpha]
-    end
-
-    it "shouldn't set the classes option if already defined" do
-      search = Alpha.search :classes => [Beta]
-      search.options[:classes].should == [Beta]
-    end
-
-    it "should default to nil for the classes options" do
-      ThinkingSphinx.search.options[:classes].should be_nil
-    end
-  end
-
-  describe '.search_for_ids' do
-    it "should return an instance of ThinkingSphinx::Search" do
-      Alpha.search.class.should == ThinkingSphinx::Search
-    end
-
-    it "should set the classes option if not already set" do
-      search = Alpha.search_for_ids
-      search.options[:classes].should == [Alpha]
-    end
-
-    it "shouldn't set the classes option if already defined" do
-      search = Alpha.search_for_ids :classes => [Beta]
-      search.options[:classes].should == [Beta]
-    end
-
-    it "should set ids_only to true" do
-      search = Alpha.search_for_ids
-      search.options[:ids_only].should be_true
-    end
-  end
-
-  describe '.search_for_id' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @client = Riddle::Client.new
-
-      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
-      @client.stub!(:query => {:matches => [], :total_found => 0})
-    end
-
-    it "should set the id range to the given id value" do
-      ThinkingSphinx.search_for_id(101, 'alpha_core')
-
-      @client.id_range.should == (101..101)
-    end
-
-    it "should not make any calls to the database" do
-      Alpha.should_not_receive(:find)
-
-      ThinkingSphinx.search_for_id(101, 'alpha_core', :classes => [Alpha])
-    end
-
-    it "should return true if there is a record" do
-      @client.stub!(:query => {:matches => [
-        {:attributes => {'sphinx_internal_id' => 100}}
-      ], :total_found => 1})
-
-      ThinkingSphinx.search_for_id(101, 'alpha_core').should be_true
-    end
-
-    it "should return false if there isn't a record" do
-      ThinkingSphinx.search_for_id(101, 'alpha_core').should be_false
-    end
-  end
-
-  describe '.count' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @client = Riddle::Client.new
-
-      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
-      @client.stub!(:query => {:matches => [], :total_found => 42})
-    end
-
-    it "should fall through to ActiveRecord if called on a class" do
-      @client.should_not_receive(:query)
-
-      Alpha.count
-    end
-
-    it "should return the total number of results if called globally" do
-      ThinkingSphinx.count.should == 42
-    end
-  end
-
-  describe '.search_count' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @client = Riddle::Client.new
-
-      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
-      @client.stub!(:query => {:matches => [], :total_found => 42})
-    end
-
-    it "should return the total number of results" do
-      Alpha.search_count.should == 42
-    end
-
-    it "should not make any calls to the database" do
-      Alpha.should_not_receive(:find)
-
-      Alpha.search_count
-    end
-  end
-
-  describe '.facets' do
-    before :each do
-      ThinkingSphinx::Search.stub!(:bundle_searches => [])
-    end
-
-    it "should return a FacetSearch instance" do
-      Alpha.facets.should be_a(ThinkingSphinx::FacetSearch)
-    end
-
-    it "should set the classes option if not already set" do
-      facets = Alpha.facets
-      facets.options[:classes].should == [Alpha]
-    end
-
-    it "shouldn't set the classes option if already defined" do
-      facets = Alpha.facets :classes => [Beta]
-      facets.options[:classes].should == [Beta]
-    end
-  end
-end

data/spec/thinking_sphinx/source_spec.rb

@@ -1,267 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Source do
-  before :each do
-    @index  = ThinkingSphinx::Index.new(Person)
-    @source = ThinkingSphinx::Source.new(@index, :sql_range_step => 1000)
-  end
-
-  describe '#initialize' do
-    it "should store the current connection details" do
-      config = Person.connection.instance_variable_get(:@config)
-      @source.database_configuration.should == config
-    end
-  end
-
-  it "should generate the name from the model" do
-    @source.name.should == "person"
-  end
-
-  it "should handle namespaced models for name generation" do
-    index  = ThinkingSphinx::Index.new(Admin::Person)
-    source = ThinkingSphinx::Source.new(index)
-    source.name.should == "admin_person"
-  end
-
-  describe "#to_riddle_for_core" do
-    before :each do
-      config = ThinkingSphinx::Configuration.instance
-      config.source_options[:sql_ranged_throttle] = 100
-
-      ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:first_name)
-      )
-      ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:last_name)
-      )
-
-      ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:id), :as => :internal_id
-      )
-      ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:birthday)
-      )
-      ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:tags, :id), :as => :tag_ids
-      )
-      ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:contacts, :id),
-        :as => :contact_ids, :source => :query
-      )
-      ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:source, :id),
-        :as => :source_id, :type => :integer
-      )
-
-      ThinkingSphinx::Join.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:links)
-      )
-
-      @source.conditions << "`birthday` <= NOW()"
-      @source.groupings  << "`first_name`"
-
-      @index.local_options[:group_concat_max_len] = 1024
-
-      @riddle = @source.to_riddle_for_core(1, 0)
-    end
-
-    it "should generate a Riddle Source object" do
-      @riddle.should be_a_kind_of(Riddle::Configuration::SQLSource)
-    end
-
-    it "should use the index and name its own name" do
-      @riddle.name.should == "person_core_0"
-    end
-
-    it "should use the model's database connection to determine type" do
-      @riddle.type.should == "mysql"
-    end
-
-    it "should match the model's database settings" do
-      config = Person.connection.instance_variable_get(:@config)
-      @riddle.sql_db.should   == config[:database]
-      @riddle.sql_user.should == config[:username]
-      @riddle.sql_pass.should == config[:password].to_s
-      @riddle.sql_host.should == config[:host]
-      @riddle.sql_port.should == config[:port]
-      @riddle.sql_sock.should == config[:socket]
-
-      @riddle.mysql_ssl_ca.should   == config[:sslca]
-      @riddle.mysql_ssl_cert.should == config[:sslcert]
-      @riddle.mysql_ssl_key.should  == config[:sslkey]
-    end
-
-    it "should use a environment user if nothing else is provided" do
-      Person.connection.stub!(:instance_variable_get => {
-          :user     => nil,
-          :username => nil
-        })
-      @source = ThinkingSphinx::Source.new(@index)
-
-      riddle = @source.to_riddle_for_core(1, 0)
-      riddle.sql_user.should == ENV['USER']
-    end
-
-    it "should assign attributes" do
-      # 3 internal attributes plus the one requested
-      @riddle.sql_attr_uint.length.should == 4
-      @riddle.sql_attr_uint.last.should == :internal_id
-
-      @riddle.sql_attr_timestamp.length.should == 1
-      @riddle.sql_attr_timestamp.first.should == :birthday
-    end
-
-    it "should not include an attribute definition for polymorphic references without data" do
-      @riddle.sql_attr_uint.select { |uint|
-        uint == :source_id
-      }.should be_empty
-    end
-
-    it "should set Sphinx Source options" do
-      @riddle.sql_range_step.should      == 1000
-      @riddle.sql_ranged_throttle.should == 100
-    end
-
-    describe "#sql_query" do
-      before :each do
-        @query = @riddle.sql_query
-      end
-
-      it "should select data from the model table" do
-        @query.should match(/FROM\s+`people`/)
-      end
-
-      it "should select each of the fields" do
-        @query.should match(/`first_name`.+FROM/)
-        @query.should match(/`last_name`.+FROM/)
-      end
-
-      it "should select each of the attributes" do
-        @query.should match(/`id` AS `internal_id`.+FROM/)
-        @query.should match(/`birthday`.+FROM/)
-        @query.should match(/`tags`.`id`.+ AS `tag_ids`.+FROM/)
-      end
-
-      it "should not match the sourced MVA attribute" do
-        @query.should_not match(/contact_ids/)
-      end
-
-      it "should include joins for required associations" do
-        @query.should match(/LEFT OUTER JOIN `tags`/)
-      end
-
-      it "should not include joins for the sourced MVA attribute" do
-        @query.should_not match(/LEFT OUTER JOIN `contacts`/)
-      end
-
-      it "should include explicitly requested joins" do
-        @query.should match(/LEFT OUTER JOIN `links`/)
-      end
-
-      it "should include any defined conditions" do
-        @query.should match(/WHERE.+`birthday` <= NOW()/)
-      end
-
-      it "should include any defined groupings" do
-        @query.should match(/GROUP BY.+`first_name`/)
-      end
-
-      it "should include descendants" do
-        index  = ThinkingSphinx::Index.new(Child)
-        source = ThinkingSphinx::Source.new(index, :sql_range_step => 1000)
-        riddle = source.to_riddle_for_core(1, 0)
-        query  = riddle.sql_query
-
-        query.should match(/WHERE.+`people`\.`type`.+'Child'.+ 'Teenager'\)/)
-        query.should_not match(/WHERE.+"users"."type" = 'Employee'/)
-      end
-    end
-
-    describe "#sql_query_range" do
-      before :each do
-        @query = @riddle.sql_query_range
-      end
-
-      it "should select data from the model table" do
-        @query.should match(/FROM `people`/)
-      end
-
-      it "should select the minimum and the maximum ids" do
-        @query.should match(/SELECT.+MIN.+MAX.+FROM/)
-      end
-    end
-
-    describe "#sql_query_info" do
-      before :each do
-        @query = @riddle.sql_query_info
-      end
-
-      it "should select all fields from the model table" do
-        @query.should match(/SELECT \* FROM `people`/)
-      end
-
-      it "should filter the primary key with the offset" do
-        model_count = ThinkingSphinx.context.indexed_models.size
-        @query.should match(/WHERE `id` = \(\(\$id - 1\) \/ #{model_count}\)/)
-      end
-    end
-
-    describe "#sql_query_pre" do
-      before :each do
-        @queries = @riddle.sql_query_pre
-      end
-
-      it "should default to just the UTF8 statement" do
-        @queries.detect { |query|
-          query == "SET NAMES utf8"
-        }.should_not be_nil
-      end
-
-      it "should set the group_concat_max_len session value for MySQL if requested" do
-        @queries.detect { |query|
-          query == "SET SESSION group_concat_max_len = 1024"
-        }.should_not be_nil
-      end
-    end
-  end
-
-  describe "#to_riddle_for_core with range disabled" do
-    before :each do
-      ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:first_name)
-      )
-    end
-
-    describe "set per-index" do
-      before :each do
-        @index.local_options[:disable_range] = true
-        @riddle = @source.to_riddle_for_core(1, 0)
-      end
-
-      it "should not have the range in the sql_query" do
-        @riddle.sql_query.should_not match(/`people`.`id` >= \$start/)
-        @riddle.sql_query.should_not match(/`people`.`id` <= \$end/)
-      end
-
-      it "should not have a sql_query_range" do
-        @riddle.sql_query_range.should be_nil
-      end
-    end
-
-    describe "set globally" do
-      before :each do
-        ThinkingSphinx::Configuration.instance.index_options[:disable_range] = true
-        @riddle = @source.to_riddle_for_core(1, 0)
-      end
-
-      it "should not have the range in the sql_query" do
-        @riddle.sql_query.should_not match(/`people`.`id` >= \$start/)
-        @riddle.sql_query.should_not match(/`people`.`id` <= \$end/)
-      end
-
-      it "should not have a sql_query_range" do
-        @riddle.sql_query_range.should be_nil
-      end
-    end
-  end
-end