thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/adapters/abstract_adapter_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-class CustomAdapter < ThinkingSphinx::AbstractAdapter
-  #
-end
-
-describe ThinkingSphinx::AbstractAdapter do
-  describe '.detect' do
-    let(:model) { stub('model') }
-
-    it "returns a MysqlAdapter object for :mysql" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :mysql)
-
-      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
-      adapter.should be_a(ThinkingSphinx::MysqlAdapter)
-    end
-
-    it "returns a PostgreSQLAdapter object for :postgresql" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :postgresql)
-
-      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
-      adapter.should be_a(ThinkingSphinx::PostgreSQLAdapter)
-    end
-
-    it "instantiates the provided class if one is provided" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => CustomAdapter)
-      CustomAdapter.should_receive(:new).and_return(stub('adapter'))
-
-      ThinkingSphinx::AbstractAdapter.detect(model)
-    end
-
-    it "raises an exception for other responses" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :sqlite)
-
-      lambda {
-        ThinkingSphinx::AbstractAdapter.detect(model)
-      }.should raise_error
-    end
-  end
-
-  describe '.adapter_for_model' do
-    let(:model) { stub('model') }
-
-    after :each do
-      ThinkingSphinx.database_adapter = nil
-    end
-
-    it "translates strings to symbols" do
-      ThinkingSphinx.database_adapter = 'foo'
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
-    end
-
-    it "passes through symbols unchanged" do
-      ThinkingSphinx.database_adapter = :bar
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :bar
-    end
-
-    it "returns standard_adapter_for_model if database_adapter is not set" do
-      ThinkingSphinx.database_adapter = nil
-      ThinkingSphinx::AbstractAdapter.stub!(:standard_adapter_for_model => :baz)
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :baz
-    end
-
-    it "calls the lambda and returns it if one is provided" do
-      ThinkingSphinx.database_adapter = lambda { |model| :foo }
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
-    end
-  end
-
-  describe '.standard_adapter_for_model' do
-    let(:klass)      { stub('connection class') }
-    let(:connection) { stub('connection', :class => klass) }
-    let(:model)      { stub('model', :connection => connection) }
-
-    it "translates a normal MySQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a MySQL plus adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlplusAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a MySQL2 adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a NullDB adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::NullDBAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a normal PostgreSQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-    it "translates a JDBC MySQL adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmysql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcpostgresql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-   it "translates a JDBC adapter with MySQL connection string to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
-                                  :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
-                                  :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-    it "returns other JDBC adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmssql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :jdbcmssql
-    end
-
-    it "returns other unknown adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
-    end
-  end
-end

data/spec/thinking_sphinx/association_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Association do
-  describe '.children' do
-    before :each do
-      @normal_reflection = stub('reflection', :options => {
-        :polymorphic => false
-      })
-      @normal_association = ThinkingSphinx::Association.new(nil, nil)
-      @poly_reflection = stub('reflection',
-        :options        => {:polymorphic => true},
-        :macro          => :has_many,
-        :name           => 'polly',
-        :active_record  => 'AR'
-      )
-      @non_poly_reflection = stub('reflection', :name => 'non_polly')
-
-      Person.stub!(:reflect_on_association => @normal_reflection)
-      ThinkingSphinx::Association.stub!(
-        :new                  => @normal_association,
-        :polymorphic_classes  => [Person, Person],
-        :casted_options       => {:casted => :options}
-      )
-      ::ActiveRecord::Reflection::AssociationReflection.stub!(
-        :new => @non_poly_reflection
-      )
-    end
-
-    it "should return an empty array if no association exists" do
-      Person.stub!(:reflect_on_association => nil)
-
-      ThinkingSphinx::Association.children(Person, :assoc).should == []
-    end
-
-    it "should return a single association instance in an array if assocation isn't polymorphic" do
-      ThinkingSphinx::Association.children(Person, :assoc).should == [@normal_association]
-    end
-
-    it "should return multiple association instances for polymorphic associations" do
-      Person.stub!(:reflect_on_association => @poly_reflection)
-
-      ThinkingSphinx::Association.children(Person, :assoc).should ==
-        [@normal_association, @normal_association]
-    end
-
-    it "should generate non-polymorphic 'casted' associations for each polymorphic possibility" do
-      reflections = double('reflections', :[]= => nil)
-      Person.stub!(:reflections => reflections)
-
-      Person.should_receive(:reflect_on_association).once.
-        and_return(@poly_reflection)
-      reflections.should_receive(:[]).with(:polly_Person).twice.and_return(nil)
-      ThinkingSphinx::Association.should_receive(:casted_options).with(
-        Person, @poly_reflection
-      ).twice
-      ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
-        with(:has_many, :polly_Person, {:casted => :options}, "AR").twice.
-        and_return(@non_poly_reflection)
-      ThinkingSphinx::Association.should_receive(:new).with(
-        nil, @non_poly_reflection
-      ).twice
-
-      ThinkingSphinx::Association.children(Person, :assoc)
-    end
-
-    it "should use existing non-polymorphic 'casted' associations" do
-      reflections = double('reflections', :[]= => nil)
-      Person.stub!(:reflections => reflections)
-
-      Person.stub!(:reflect_on_association).once.
-        and_return(@poly_reflection)
-      reflections.should_receive(:[]).with(:polly_Person).twice.
-        and_return(nil, @non_poly_reflection)
-      ThinkingSphinx::Association.should_receive(:casted_options).with(
-        Person, @poly_reflection
-      ).once
-      ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
-        with(:has_many, :polly_Person, {:casted => :options}, "AR").once.
-        and_return(@non_poly_reflection)
-      ThinkingSphinx::Association.should_receive(:new).with(
-        nil, @non_poly_reflection
-      ).twice
-
-      ThinkingSphinx::Association.children(Person, :assoc)
-    end
-  end
-
-  describe '#children' do
-    before :each do
-      @reflection   = stub('reflection', :klass => :klass)
-      @association  = ThinkingSphinx::Association.new(nil, @reflection)
-      ThinkingSphinx::Association.stub!(:children => :result)
-    end
-
-    it "should return the children associations for the given association" do
-      @association.children(:assoc).should == :result
-    end
-
-    it "should request children for the reflection klass" do
-      ThinkingSphinx::Association.should_receive(:children).
-        with(:klass, :assoc, @association)
-
-      @association.children(:assoc)
-    end
-  end
-
-  describe '#join_to' do
-    before :each do
-      @parent_join = stub('join assoc').as_null_object
-      @join = stub('join assoc').as_null_object
-      @parent = ThinkingSphinx::Association.new(nil, nil)
-      @parent.stub!(:join_to => true, :join => nil)
-      @base_join = stub('base join', :joins => [:a, :b, :c])
-
-      if ThinkingSphinx.rails_3_1?
-        ::ActiveRecord::Associations::JoinDependency::JoinAssociation.stub!(:new => @join)
-      else
-        ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub!(:new => @join)
-      end
-    end
-
-    it "should call the parent's join_to if parent has no join" do
-      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
-      @parent.should_receive(:join_to).with(@base_join)
-
-      @assoc.join_to(@base_join)
-    end
-
-    it "should not call the parent's join_to if it already has a join" do
-      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
-      @parent.stub!(:join => @parent_join)
-      @parent.should_not_receive(:join_to)
-
-      @assoc.join_to(@base_join)
-    end
-
-    it "should define the join association with a JoinAssociation instance" do
-      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
-
-      @assoc.join_to(@base_join).should == @join
-      @assoc.join.should == @join
-    end
-  end
-
-  describe '#is_many?' do
-    before :each do
-      @parent = stub('assoc', :is_many? => :parent_is_many)
-      @reflection = stub('reflection', :macro => :has_many)
-    end
-
-    it "should return true if association is either a has_many or a habtm" do
-      association = ThinkingSphinx::Association.new(@parent, @reflection)
-      association.is_many?.should be_true
-
-      @reflection.stub!(:macro => :has_and_belongs_to_many)
-      association.is_many?.should be_true
-    end
-
-    it "should return the parent value if not a has many or habtm and there is a parent" do
-      association = ThinkingSphinx::Association.new(@parent, @reflection)
-      @reflection.stub!(:macro => :belongs_to)
-      association.is_many?.should == :parent_is_many
-    end
-
-    it "should return false if no parent and not a has many or habtm" do
-      association = ThinkingSphinx::Association.new(nil, @reflection)
-      @reflection.stub!(:macro => :belongs_to)
-      association.is_many?.should be_false
-    end
-  end
-
-  describe '#ancestors' do
-    it "should return an array of associations - including all parents" do
-      parent = stub('assoc', :ancestors => [:all, :ancestors])
-      association = ThinkingSphinx::Association.new(parent, @reflection)
-      association.ancestors.should == [:all, :ancestors, association]
-    end
-  end
-
-  describe '.polymorphic_classes' do
-    it "should return all the polymorphic result types as classes" do
-      Person.connection.stub!(:select_all => [
-        {"person_type" => "Person"},
-        {"person_type" => "Friendship"}
-      ])
-      ref = stub('ref',
-        :active_record  => Person,
-        :options        => {:foreign_type => "person_type"}
-      )
-      ref.stub!(:foreign_type => "person_type") if ThinkingSphinx.rails_3_1?
-
-      ThinkingSphinx::Association.send(:polymorphic_classes, ref).should == [Person, Friendship]
-    end
-  end
-
-  describe '.casted_options' do
-    before :each do
-      @options = {
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :polymorphic  => true
-      }
-      @reflection = stub('assoc reflection', :options => @options)
-      @reflection.stub!(:foreign_type => "thing_type") if ThinkingSphinx.rails_3_1?
-    end
-
-    it "should return a new options set for a specific class" do
-      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :conditions   => "::ts_join_alias::.`thing_type` = 'Person'"
-      }
-    end
-
-    it "should append to existing Array of conditions" do
-      @options[:conditions] = ["first condition"]
-      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :conditions   => ["first condition", "::ts_join_alias::.`thing_type` = 'Person'"]
-      }
-    end
-
-    it "should merge to an existing Hash of conditions" do
-      @options[:conditions] = {"field" => "value"}
-      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :conditions   => {"field" => "value", "thing_type" => "Person"}
-      }
-    end
-
-    it "should append to an existing String of conditions" do
-      @options[:conditions] = "first condition"
-      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :conditions   => "first condition AND ::ts_join_alias::.`thing_type` = 'Person'"
-      }
-    end
-  end
-end

data/spec/thinking_sphinx/attribute_spec.rb

@@ -1,552 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Attribute do
-  before :each do
-    @index  = ThinkingSphinx::Index.new(Person)
-    @source = ThinkingSphinx::Source.new(@index)
-    
-    @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
-  end
-  
-  describe '#initialize' do
-    it 'raises if no columns are provided so that configuration errors are easier to track down' do
-      lambda {
-        ThinkingSphinx::Attribute.new(@source, [])
-      }.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::Attribute.new(@source, [1234])
-      }.should raise_error(RuntimeError)
-    end
-  end
-  
-  describe '#unique_name' do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        stub('column', :__stack => [], :__name => "col_name")
-      ]
-    end
-    
-    it "should use the alias if there is one" do
-      @attribute.alias = "alias"
-      @attribute.unique_name.should == "alias"
-    end
-    
-    it "should use the alias if there's multiple columns" do
-      @attribute.columns << stub('column', :__stack => [], :__name => "col_name")
-      @attribute.unique_name.should be_nil
-      
-      @attribute.alias = "alias"
-      @attribute.unique_name.should == "alias"
-    end
-    
-    it "should use the column name if there's no alias and just one column" do
-      @attribute.unique_name.should == "col_name"
-    end
-  end
-  
-  describe '#to_select_sql' do
-    it "should convert a mixture of dates and datetimes to timestamps" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:created_at),
-          ThinkingSphinx::Index::FauxColumn.new(:created_on) ],
-        :as => :times
-      )
-      attribute.model = Friendship
-      
-      attribute.to_select_sql.should == "CONCAT_WS(',', UNIX_TIMESTAMP(`friendships`.`created_at`), UNIX_TIMESTAMP(`friendships`.`created_on`)) AS `times`"
-    end
-    
-    it "should handle columns which don't exist for polymorphic joins" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:team, :name),
-          ThinkingSphinx::Index::FauxColumn.new(:team, :league) ],
-        :as => :team
-      )
-      
-      attribute.to_select_sql.should == "CONCAT_WS(' ', IFNULL(`cricket_teams`.`name`, ''), IFNULL(`football_teams`.`name`, ''), IFNULL(`football_teams`.`league`, '')) AS `team`"
-    end
-    
-    it "should return nil if polymorphic association data does not exist" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:source, :id)],
-        :as => :source_id, :type => :integer
-      )
-      
-      attribute.to_select_sql.should be_nil
-    end
-  end
-  
-  describe '#is_many?' do
-    before :each do
-      @assoc_a = ThinkingSphinx::Association.new(nil, nil)
-      @assoc_b = ThinkingSphinx::Association.new(nil, nil)
-      @assoc_c = ThinkingSphinx::Association.new(nil, nil)
-      
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
-      )
-      @attribute.associations = {
-        :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
-      }
-      @attribute.associations.values.each { |assoc|
-        assoc.stub!(:is_many? => true)
-      }
-    end
-    
-    it "should return true if all associations return true to is_many?" do
-      @attribute.send(:is_many?).should be_true
-    end
-    
-    it "should return true if one association returns true to is_many?" do
-      @assoc_b.stub!(:is_many? => false)
-      @assoc_c.stub!(:is_many? => false)
-      
-      @attribute.send(:is_many?).should be_true
-    end
-    
-    it "should return false if all associations return false to is_many?" do
-      @assoc_a.stub!(:is_many? => false)
-      @assoc_b.stub!(:is_many? => false)
-      @assoc_c.stub!(:is_many? => false)
-      
-      @attribute.send(:is_many?).should be_false
-    end
-  end
-  
-  describe '#is_string?' do
-    before :each do
-      @col_a = ThinkingSphinx::Index::FauxColumn.new("a")
-      @col_b = ThinkingSphinx::Index::FauxColumn.new("b")
-      @col_c = ThinkingSphinx::Index::FauxColumn.new("c")
-
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, [@col_a, @col_b, @col_c]
-      )
-    end
-    
-    it "should return true if all columns return true to is_string?" do
-      @attribute.send(:is_string?).should be_true
-    end
-    
-    it "should return false if one column returns true to is_string?" do
-      @col_a.send(:instance_variable_set, :@name, :a)
-      @attribute.send(:is_string?).should be_false
-    end
-    
-    it "should return false if all columns return false to is_string?" do
-      @col_a.send(:instance_variable_set, :@name, :a)
-      @col_b.send(:instance_variable_set, :@name, :b)
-      @col_c.send(:instance_variable_set, :@name, :c)
-      @attribute.send(:is_string?).should be_false
-    end
-  end
-  
-  describe '#type' do
-    before :each do
-      @column = ThinkingSphinx::Index::FauxColumn.new(:col_name)
-      @attribute = ThinkingSphinx::Attribute.new(@source, [@column])
-      @attribute.model = Person
-      @attribute.stub!(:is_many? => false)
-    end
-    
-    it "should return :multi if is_many? is true" do
-      @attribute.stub!(:is_many? => true)
-      @attribute.send(:type).should == :multi
-    end
-    
-    it "should return :string if there's more than one association" do
-      @attribute.associations = {:a => [:assoc], :b => [:assoc]}
-      @attribute.send(:type).should == :string
-    end
-    
-    it "should return the column type from the database if not :multi or more than one association" do
-      @column.send(:instance_variable_set, :@name, "birthday")
-      @attribute.type.should == :datetime
-      
-      @attribute.send(:instance_variable_set, :@type, nil)
-      @column.send(:instance_variable_set, :@name, "first_name")
-      @attribute.type.should == :string
-      
-      @attribute.send(:instance_variable_set, :@type, nil)
-      @column.send(:instance_variable_set, :@name, "id")
-      @attribute.type.should == :integer
-    end
-    
-    it "should return :multi if the columns return multiple datetimes" do
-      @attribute.stub!(:is_many? => true)
-      @attribute.stub!(:all_datetimes? => true)
-      
-      @attribute.type.should == :multi
-    end
-    
-    it "should return :bigint for 64bit integers" do
-      Person.columns.detect { |col|
-        col.name == 'id'
-      }.stub!(:sql_type => 'BIGINT(20)')
-      @column.send(:instance_variable_set, :@name, 'id')
-      
-      @attribute.type.should == :bigint
-    end
-  end
-  
-  describe '#all_ints?' do
-    it "should return true if all columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:team_id) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should be_all_ints
-    end
-    
-    it "should return false if only some columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:first_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should_not be_all_ints
-    end
-    
-    it "should return false if no columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:first_name),
-          ThinkingSphinx::Index::FauxColumn.new(:last_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should_not be_all_ints
-    end
-  end
-  
-  describe '#all_datetimes?' do
-    it "should return true if all columns are datetimes" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:created_at),
-          ThinkingSphinx::Index::FauxColumn.new(:updated_at) ]
-      )
-      attribute.model = Friendship
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should be_all_datetimes
-    end
-    
-    it "should return false if only some columns are datetimes" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:created_at) ]
-      )
-      attribute.model = Friendship
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should_not be_all_datetimes
-    end
-    
-    it "should return true if all columns can be " do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:created_at),
-          ThinkingSphinx::Index::FauxColumn.new(:created_on) ]
-      )
-      attribute.model = Friendship
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should be_all_datetimes
-    end
-  end
-  
-  describe '#all_strings?' do
-    it "should return true if all columns are strings or text" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:first_name),
-          ThinkingSphinx::Index::FauxColumn.new(:last_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should be_all_strings
-    end
-    
-    it "should return false if only some columns are strings" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:first_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should_not be_all_strings
-    end
-    
-    it "should return true if all columns are not strings" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:parent_id) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.should_not be_all_strings
-    end
-  end
-  
-  describe "MVA with source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query = attribute.config_value.split('; ')
-      declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
-    end
-  end
-  
-  describe "MVA with source query for a delta source" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query = attribute.config_value(nil, true).split('; ')
-      declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
-    end
-  end
-  
-  describe "MVA via a HABTM association with a source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-      :as => :link_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query = attribute.config_value.split('; ')
-      declaration.should == "uint link_ids from query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
-    end
-  end
-  
-  describe "MVA with ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value.split('; ')
-      declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} 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 "MVA with ranged source query for a delta source" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
-      declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
-      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
-    end
-  end
-  
-  describe "MVA via a has-many :through with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
-      :as => :football_team_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value.split('; ')
-      declaration.should == "uint football_team_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`football_team_id` AS `football_team_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 "MVA via a has-many :through using a foreign key with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
-      :as => :friend_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value.split('; ')
-      declaration.should == "uint friend_ids from ranged-query"
-      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} 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
-  
-  describe "MVA via a HABTM with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-      :as => :link_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value.split('; ')
-      declaration.should == "uint link_ids from ranged-query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
-      range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
-    end
-  end
-  
-  describe "MVA via two has-many associations with a ranged source query" do
-    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
-    let(:source)    { ThinkingSphinx::Source.new(index) }
-    let(:attribute) { ThinkingSphinx::Attribute.new(source,
-      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-      :as => :gamma_values, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value.split('; ')
-      declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
-      range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
-    end
-  end
-  
-  describe "MVA via two has-many associations with a ranged source query for a delta source" do
-    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
-    let(:source)    { ThinkingSphinx::Source.new(index) }
-    let(:attribute) { ThinkingSphinx::Attribute.new(source,
-      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-      :as => :gamma_values, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-      
-    before :each do
-      index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new index, index.local_options
-    end
-    
-    it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
-      
-      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
-      declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
-      range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
-    end
-  end
-  
-  describe "with custom queries" do
-    before :each do
-      index = CricketTeam.sphinx_indexes.first
-      @statement = index.sources.first.to_riddle_for_core(0, 0).sql_attr_multi.last
-    end
-    
-    it "should track the query type accordingly" do
-      @statement.should match(/uint tags from query/)
-    end
-    
-    it "should include the SQL statement" do
-      @statement.should match(/SELECT cricket_team_id, id FROM tags/)
-    end
-  end
-  
-  describe '#live_value' do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        stub('column', :__stack => [], :__name => "col_name")
-      ]
-      @instance = stub('model')
-    end
-    
-    it "should translate boolean values to integers" do
-      @instance.stub!(:col_name => true)
-      @attribute.live_value(@instance).should == 1
-      
-      @instance.stub!(:col_name => false)
-      @attribute.live_value(@instance).should == 0
-    end
-    
-    it "should translate timestamps to integers" do
-      now = Time.now
-      @instance.stub!(:col_name => now)
-      @attribute.live_value(@instance).should == now.to_i
-    end
-    
-    it "should translate dates to timestamp integers" do
-      today = Date.today
-      @instance.stub!(:col_name => today)
-      @attribute.live_value(@instance).should == today.to_time.to_i
-    end
-    
-    it "should translate nils to 0" do
-      @instance.stub!(:col_name => nil)
-      @attribute.live_value(@instance).should == 0
-    end
-    
-    it "should return integers as integers" do
-      @instance.stub!(:col_name => 42)
-      @attribute.live_value(@instance).should == 42
-    end
-    
-    it "should handle nils in the association chain" do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        stub('column', :__stack => [:assoc_name], :__name => :id)
-      ]
-      @instance.stub!(:assoc_name => nil)
-      @attribute.live_value(@instance).should == 0
-    end
-    
-    it "should handle association chains" do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        stub('column', :__stack => [:assoc_name], :__name => :id)
-      ]
-      @instance.stub!(:assoc_name => stub('object', :id => 42))
-      @attribute.live_value(@instance).should == 42
-    end
-    
-    it "should translate crc strings to their integer values" do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        stub('column', :__stack => [], :__name => "col_name")
-      ], :crc => true, :type => :string
-      @instance.stub!(:col_name => 'foo')
-      @attribute.live_value(@instance).should == 'foo'.to_crc32
-    end
-  end
-end