thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/active_record/associations_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Associations do
+  JoinDependency = ::ActiveRecord::Associations::JoinDependency
+
+  let(:associations) { ThinkingSphinx::ActiveRecord::Associations.new model }
+  let(:model)        { model_double 'articles' }
+  let(:base)         {
+    double('base', :active_record => model, :join_base => join_base)
+  }
+  let(:join_base)    { double('join base') }
+  let(:join)         { join_double 'users' }
+  let(:sub_join)     { join_double 'posts' }
+
+  def join_double(table_alias)
+    double 'join',
+      :join_type=         => nil,
+      :aliased_table_name => table_alias,
+      :reflection         => double('reflection')
+  end
+
+  def model_double(table_name = nil)
+    double 'model', :quoted_table_name => table_name, :reflections => {}
+  end
+
+  before :each do
+    JoinDependency.stub :new => base
+    JoinDependency::JoinAssociation.stub(:new).and_return(join, sub_join)
+    model.reflections[:user] = join.reflection
+
+    join.stub :active_record => model_double
+    join.active_record.reflections[:posts] = sub_join.reflection
+  end
+
+  describe '#add_join_to' do
+    it "adds just one join for a stack with a single association" do
+      JoinDependency::JoinAssociation.unstub :new
+      JoinDependency::JoinAssociation.should_receive(:new).
+        with(join.reflection, base, join_base).once.and_return(join)
+
+      associations.add_join_to([:user])
+    end
+
+    it "does not duplicate joins when given the same stack twice" do
+      JoinDependency::JoinAssociation.unstub :new
+      JoinDependency::JoinAssociation.should_receive(:new).once.and_return(join)
+
+      associations.add_join_to([:user])
+      associations.add_join_to([:user])
+    end
+
+    context 'multiple joins' do
+      it "adds two joins for a stack with two associations" do
+        JoinDependency::JoinAssociation.unstub :new
+        JoinDependency::JoinAssociation.should_receive(:new).
+          with(join.reflection, base, join_base).once.and_return(join)
+        JoinDependency::JoinAssociation.should_receive(:new).
+          with(sub_join.reflection, base, join).once.and_return(sub_join)
+
+        associations.add_join_to([:user, :posts])
+      end
+
+      it "extends upon existing joins when given stacks where parts are already mapped" do
+        JoinDependency::JoinAssociation.unstub :new
+        JoinDependency::JoinAssociation.should_receive(:new).twice.
+          and_return(join, sub_join)
+
+        associations.add_join_to([:user])
+        associations.add_join_to([:user, :posts])
+      end
+    end
+  end
+
+  describe '#aggregate_for?' do
+    it "is false when the stack is empty" do
+      associations.aggregate_for?([]).should be_false
+    end
+
+    it "is true when a reflection is a has_many" do
+      join.reflection.stub!(:macro => :has_many)
+
+      associations.aggregate_for?([:user]).should be_true
+    end
+
+    it "is true when a reflection is a has_and_belongs_to_many" do
+      join.reflection.stub!(:macro => :has_and_belongs_to_many)
+
+      associations.aggregate_for?([:user]).should be_true
+    end
+
+    it "is false when a reflection is a belongs_to" do
+      join.reflection.stub!(:macro => :belongs_to)
+
+      associations.aggregate_for?([:user]).should be_false
+    end
+
+    it "is false when a reflection is a has_one" do
+      join.reflection.stub!(:macro => :has_one)
+
+      associations.aggregate_for?([:user]).should be_false
+    end
+
+    it "is true when one level is aggregate" do
+      join.reflection.stub!(:macro => :belongs_to)
+      sub_join.reflection.stub!(:macro => :has_many)
+
+      associations.aggregate_for?([:user, :posts]).should be_true
+    end
+
+    it "is true when both levels are aggregates" do
+      join.reflection.stub!(:macro => :has_many)
+      sub_join.reflection.stub!(:macro => :has_many)
+
+      associations.aggregate_for?([:user, :posts]).should be_true
+    end
+
+    it "is false when both levels are not aggregates" do
+      join.reflection.stub!(:macro => :belongs_to)
+      sub_join.reflection.stub!(:macro => :belongs_to)
+
+      associations.aggregate_for?([:user, :posts]).should be_false
+    end
+  end
+
+  describe '#alias_for' do
+    it "returns the model's table name when no stack is given" do
+      associations.alias_for([]).should == 'articles'
+    end
+
+    it "adds just one join for a stack with a single association" do
+      JoinDependency::JoinAssociation.unstub :new
+      JoinDependency::JoinAssociation.should_receive(:new).
+        with(join.reflection, base, join_base).once.and_return(join)
+
+      associations.alias_for([:user])
+    end
+
+    it "returns the aliased table name for the join" do
+      associations.alias_for([:user]).should == 'users'
+    end
+
+    it "does not duplicate joins when given the same stack twice" do
+      JoinDependency::JoinAssociation.unstub :new
+      JoinDependency::JoinAssociation.should_receive(:new).once.and_return(join)
+
+      associations.alias_for([:user])
+      associations.alias_for([:user])
+    end
+
+    context 'multiple joins' do
+      it "adds two joins for a stack with two associations" do
+        JoinDependency::JoinAssociation.unstub :new
+        JoinDependency::JoinAssociation.should_receive(:new).
+          with(join.reflection, base, join_base).once.and_return(join)
+        JoinDependency::JoinAssociation.should_receive(:new).
+          with(sub_join.reflection, base, join).once.and_return(sub_join)
+
+        associations.alias_for([:user, :posts])
+      end
+
+      it "returns the sub join's aliased table name" do
+        associations.alias_for([:user, :posts]).should == 'posts'
+      end
+
+      it "extends upon existing joins when given stacks where parts are already mapped" do
+        JoinDependency::JoinAssociation.unstub :new
+        JoinDependency::JoinAssociation.should_receive(:new).twice.
+          and_return(join, sub_join)
+
+        associations.alias_for([:user])
+        associations.alias_for([:user, :posts])
+      end
+    end
+  end
+
+  describe '#join_values' do
+    it "returns all joins that have been created" do
+      associations.alias_for([:user])
+      associations.alias_for([:user, :posts])
+
+      associations.join_values.should == [join, sub_join]
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/attribute/type_spec.rb

@@ -0,0 +1,147 @@
+module ThinkingSphinx
+  module ActiveRecord
+    class Attribute; end
+  end
+end
+
+require 'thinking_sphinx/active_record/attribute/type'
+
+describe ThinkingSphinx::ActiveRecord::Attribute::Type do
+  let(:type) {
+    ThinkingSphinx::ActiveRecord::Attribute::Type.new attribute, model }
+  let(:attribute) { double('attribute', :columns => [column], :options => {}) }
+  let(:model)     { double('model', :columns => [db_column]) }
+  let(:column)    { double('column', :__name => :created_at, :string? => false,
+    :__stack => []) }
+  let(:db_column) { double('column', :name => 'created_at',
+    :type => :integer) }
+
+  describe '#multi?' do
+    let(:association) { double('association', :klass => double) }
+
+    before :each do
+      column.__stack << :foo
+
+      model.stub :reflect_on_association => association
+    end
+
+    it "returns true if there are has_many associations" do
+      association.stub :macro => :has_many
+
+      type.should be_multi
+    end
+
+    it "returns true if there are has_and_belongs_to_many associations" do
+      association.stub :macro => :has_and_belongs_to_many
+
+      type.should be_multi
+    end
+
+    it "returns false if there are no associations" do
+      column.__stack.clear
+
+      type.should_not be_multi
+    end
+
+    it "returns false if there are only belongs_to associations" do
+      association.stub :macro => :belongs_to
+
+      type.should_not be_multi
+    end
+
+    it "returns false if there are only has_one associations" do
+      association.stub :macro => :has_one
+
+      type.should_not be_multi
+    end
+
+    it "returns true if deeper associations have many" do
+      column.__stack << :bar
+      deep_association = double(:klass => double, :macro => :has_many)
+      association.stub :macro => :belongs_to,
+        :klass => double(:reflect_on_association => deep_association)
+
+      type.should be_multi
+    end
+
+    it "respects the provided setting" do
+      attribute.options[:multi] = true
+
+      type.should be_multi
+    end
+  end
+
+  describe '#type' do
+    it "returns the type option provided" do
+      attribute.options[:type] = :datetime
+
+      type.type.should == :datetime
+    end
+
+    it "detects integer types from the database" do
+      db_column.stub!(:type => :integer, :sql_type => 'integer(11)')
+
+      type.type.should == :integer
+    end
+
+    it "detects boolean types from the database" do
+      db_column.stub!(:type => :boolean)
+
+      type.type.should == :boolean
+    end
+
+    it "detects datetime types from the database as timestamps" do
+      db_column.stub!(:type => :datetime)
+
+      type.type.should == :timestamp
+    end
+
+    it "detects date types from the database as timestamps" do
+      db_column.stub!(:type => :date)
+
+      type.type.should == :timestamp
+    end
+
+    it "detects string types from the database" do
+      db_column.stub!(:type => :string)
+
+      type.type.should == :string
+    end
+
+    it "detects text types from the database as strings" do
+      db_column.stub!(:type => :text)
+
+      type.type.should == :string
+    end
+
+    it "detects float types from the database" do
+      db_column.stub!(:type => :float)
+
+      type.type.should == :float
+    end
+
+    it "detects decimal types from the database as floats" do
+      db_column.stub!(:type => :decimal)
+
+      type.type.should == :float
+    end
+
+    it "detects big ints as big ints" do
+      db_column.stub :type => :bigint
+
+      type.type.should == :bigint
+    end
+
+    it "detects large integers as big ints" do
+      db_column.stub :type => :integer, :sql_type => 'bigint(20)'
+
+      type.type.should == :bigint
+    end
+
+    it "respects provided type setting" do
+      attribute.options[:type] = :timestamp
+
+      type.type.should == :timestamp
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Base do
+  let(:model) {
+    Class.new(ActiveRecord::Base) do
+      include ThinkingSphinx::ActiveRecord::Base
+
+      def self.name; 'Model'; end
+    end
+  }
+  let(:sub_model) {
+    Class.new(model) do
+      def self.name; 'SubModel'; end
+    end
+  }
+  let(:search) { double('search', :options => {})}
+
+  describe '.search' do
+    before :each do
+      ThinkingSphinx.stub :search => search
+    end
+
+    it "returns a new search object" do
+      model.search.should == search
+    end
+
+    it "passes through arguments to the search object initializer" do
+      ThinkingSphinx.should_receive(:search).with('pancakes', anything)
+
+      model.search 'pancakes'
+    end
+
+    it "scopes the search to a given model" do
+      model.search('pancakes').options[:classes].should == [model]
+    end
+    
+    it "merges the :classes option with the model" do
+      search_options = {:classes=>[sub_model]}
+      search.stub :options => search_options
+      model.search('pancakes', search_options).options[:classes].should == [sub_model, model]
+    end
+  end
+
+  describe '.search_count' do
+    let(:search) { double('search', :options => {}, :total_entries => 12) }
+
+    before :each do
+      ThinkingSphinx.stub :search => search
+    end
+
+    it "returns the search object's total entries count" do
+      model.search_count.should == search.total_entries
+    end
+
+    it "scopes the search to a given model" do
+      model.search_count
+
+      search.options[:classes].should == [model]
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/callbacks/delete_callbacks_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.new instance
+  }
+  let(:instance)   { double('instance', :delta? => true) }
+
+  describe '.after_destroy' do
+    let(:callbacks) { double('callbacks', :after_destroy => nil) }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        stub :new => callbacks
+    end
+
+    it "builds an object from the instance" do
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        should_receive(:new).with(instance).and_return(callbacks)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_destroy(instance)
+    end
+
+    it "invokes after_destroy on the object" do
+      callbacks.should_receive(:after_destroy)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_destroy(instance)
+    end
+  end
+
+  describe '#after_destroy' do
+    let(:config)     { double('config', :connection => connection,
+      :indices_for_references => [index], :preload_indices => true) }
+    let(:connection) { double('connection', :query => nil) }
+    let(:index)      {
+      double('index', :name => 'foo_core', :document_id_for_key => 14)
+    }
+    let(:instance)   { double('instance', :id => 7) }
+
+    before :each do
+      ThinkingSphinx::Configuration.stub :instance => config
+      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+    end
+
+    it "updates the deleted flag to false" do
+      connection.should_receive(:query).with('UPDATE STATEMENT')
+
+      callbacks.after_destroy
+    end
+
+    it "builds the update query for the given index" do
+      Riddle::Query.should_receive(:update).
+        with('foo_core', anything, anything).and_return('')
+
+      callbacks.after_destroy
+    end
+
+    it "builds the update query for the sphinx document id" do
+      Riddle::Query.should_receive(:update).
+        with(anything, 14, anything).and_return('')
+
+      callbacks.after_destroy
+    end
+
+    it "builds the update query for setting sphinx_deleted to true" do
+      Riddle::Query.should_receive(:update).
+        with(anything, anything, :sphinx_deleted => true).and_return('')
+
+      callbacks.after_destroy
+    end
+
+    it "doesn't care about Sphinx errors" do
+      connection.stub(:query).and_raise(Mysql2::Error.new(''))
+
+      lambda { callbacks.after_destroy }.should_not raise_error
+    end
+  end
+end