thinking-sphinx 2.1.0 → 3.0.0.pre

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

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.new instance
+  }
+  let(:instance)   { double('instance', :delta? => true) }
+  let(:config)     { double('config') }
+  let(:processor)  {
+    double('processor', :toggled? => true, :index => true, :delete => true)
+  }
+
+  before :each do
+    ThinkingSphinx::Configuration.stub :instance => config
+  end
+
+  [:after_commit, :before_save].each do |callback|
+    describe ".#{callback}" do
+      let(:callbacks) { double('callbacks', callback => nil) }
+
+      before :each do
+        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
+          stub :new => callbacks
+      end
+
+      it "builds an object from the instance" do
+        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
+          should_receive(:new).with(instance).and_return(callbacks)
+
+        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
+          send(callback, instance)
+      end
+
+      it "invokes #{callback} on the object" do
+        callbacks.should_receive(callback)
+
+        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
+          send(callback, instance)
+      end
+    end
+  end
+
+  describe '#after_commit' do
+    let(:index) {
+      double('index', :delta? => false, :delta_processor => processor)
+    }
+
+    before :each do
+      config.stub :indices_for_references => [index]
+    end
+
+    context 'without delta indices' do
+      it "does not fire a delta index when no delta indices" do
+        processor.should_not_receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete the instance from any index" do
+        processor.should_not_receive(:delete)
+
+        callbacks.after_commit
+      end
+    end
+
+    context 'with delta indices' do
+      let(:core_index) { double('index', :delta? => false, :name => 'foo_core',
+        :delta_processor => processor) }
+      let(:delta_index) { double('index', :delta? => true, :name => 'foo_delta',
+        :delta_processor => processor) }
+
+      before :each do
+        ThinkingSphinx::Deltas.stub :suspended? => false
+
+        config.stub :indices_for_references => [core_index, delta_index]
+      end
+
+      it "only indexes delta indices" do
+        processor.should_receive(:index).with(delta_index)
+
+        callbacks.after_commit
+      end
+
+      it "does not process delta indices when deltas are suspended" do
+        ThinkingSphinx::Deltas.stub :suspended? => true
+
+        processor.should_not_receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "deletes the instance from the core index" do
+        processor.should_receive(:delete).with(core_index, instance)
+
+        callbacks.after_commit
+      end
+
+      it "does not index if model's delta flag is not true" do
+        processor.stub :toggled? => false
+
+        processor.should_not_receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete if model's delta flag is not true" do
+        processor.stub :toggled? => false
+
+        processor.should_not_receive(:delete)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete when deltas are suspended" do
+        ThinkingSphinx::Deltas.stub :suspended? => true
+
+        processor.should_not_receive(:delete)
+
+        callbacks.after_commit
+      end
+    end
+  end
+
+  describe '#before_save' do
+    let(:index) {
+      double('index', :delta? => true, :delta_processor => processor)
+    }
+
+    before :each do
+      config.stub :indices_for_references => [index]
+    end
+
+    it "sets delta to true if there are delta indices" do
+      processor.should_receive(:toggle).with(instance)
+
+      callbacks.before_save
+    end
+
+    it "does not try to set delta to true if there are no delta indices" do
+      index.stub :delta? => false
+
+      processor.should_not_receive(:toggle)
+
+      callbacks.before_save
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module Callbacks; end
+  end
+end
+
+require 'active_support/core_ext/string/inflections'
+require 'mysql2/error'
+require 'thinking_sphinx/callbacks'
+require 'thinking_sphinx/active_record/callbacks/update_callbacks'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
+  describe '#after_update' do
+    let(:callbacks)     {
+      ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks.new instance }
+    let(:instance)      { double('instance', :class => klass, :id => 2) }
+    let(:klass)         { double(:name => 'Article') }
+    let(:configuration) { double('configuration', :connection => connection,
+      :settings => {'attribute_updates' => true},
+      :indices_for_references => [index]) }
+    let(:connection)    { double('connection', :query => '') }
+    let(:index)         { double('index', :name => 'article_core',
+      :sources => [source], :document_id_for_key => 3) }
+    let(:source)        { double('source', :attributes => []) }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Configuration',
+        double(:instance => configuration)
+      stub_const 'Riddle::Query', double(:update => 'SphinxQL')
+
+      source.attributes.replace([
+        double(:name => 'foo', :updateable? => true,
+          :columns => [double(:__name => 'foo_column')]),
+        double(:name => 'bar', :updateable? => true, :value_for => 7,
+          :columns => [double(:__name => 'bar_column')]),
+        double(:name => 'baz', :updateable? => false)
+      ])
+
+      instance.stub :changed => ['bar_column', 'baz'], :bar_column => 7
+    end
+
+    it "does not send any updates to Sphinx if updates are disabled" do
+      configuration.settings['attribute_updates'] = false
+
+      connection.should_not_receive(:query)
+
+      callbacks.after_update
+    end
+
+    it "builds an update query with only updateable attributes that have changed" do
+      Riddle::Query.should_receive(:update).
+        with('article_core', 3, 'bar' => 7).and_return('SphinxQL')
+
+      callbacks.after_update
+    end
+
+    it "sends the update query through to Sphinx" do
+      connection.should_receive(:query).with('SphinxQL')
+
+      callbacks.after_update
+    end
+
+    it "doesn't care if the update fails at Sphinx's end" do
+      connection.stub(:query).and_raise(Mysql2::Error.new(''))
+
+      lambda { callbacks.after_update }.should_not raise_error
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/column_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Column do
+  describe '#__name' do
+    it "returns the top item" do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:content)
+      column.__name.should == :content
+    end
+  end
+
+  describe '#__stack' do
+    it "returns all but the top item" do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:users, :posts, :id)
+      column.__stack.should == [:users, :posts]
+    end
+  end
+
+  describe '#method_missing' do
+    let(:column) { ThinkingSphinx::ActiveRecord::Column.new(:user) }
+
+    it "shifts the current name to the stack" do
+      column.email
+      column.__stack.should == [:user]
+    end
+
+    it "adds the new method call as the name" do
+      column.email
+      column.__name.should == :email
+    end
+
+    it "returns itself" do
+      column.email.should == column
+    end
+  end
+
+  describe '#string?' do
+    it "is true when the name is a string" do
+      column = ThinkingSphinx::ActiveRecord::Column.new('content')
+      column.should be_a_string
+    end
+
+    it "is false when the name is a symbol" do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:content)
+      column.should_not be_a_string
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/database_adapters/abstract_adapter_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter do
+  let(:adapter)    {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter.new model
+  }
+  let(:model)      { double('model', :connection => connection) }
+  let(:connection) { double('connection') }
+
+  describe '#quote' do
+    it "uses the model's connection to quote columns" do
+      connection.should_receive(:quote_column_name).with('foo')
+
+      adapter.quote 'foo'
+    end
+
+    it "returns the quoted value" do
+      connection.stub :quote_column_name => '"foo"'
+
+      adapter.quote('foo').should == '"foo"'
+    end
+  end
+
+  describe '#quoted_table_name' do
+    it "passes the method through to the model" do
+      model.should_receive(:quoted_table_name).and_return('"articles"')
+
+      adapter.quoted_table_name.should == '"articles"'
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/database_adapters/mysql_adapter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter do
+  let(:adapter) {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.new(model)
+  }
+  let(:model)   { double('model') }
+
+  it "returns 1 for true" do
+    adapter.boolean_value(true).should == 1
+  end
+
+  it "returns 0 for false" do
+    adapter.boolean_value(false).should == 0
+  end
+
+  describe '#cast_to_timestamp' do
+    it "converts to unix timestamps" do
+      adapter.cast_to_timestamp('created_at').
+        should == 'UNIX_TIMESTAMP(created_at)'
+    end
+  end
+
+  describe '#concatenate' do
+    it "concatenates with the given separator" do
+      adapter.concatenate('foo, bar, baz', ',').
+        should == "CONCAT_WS(',', foo, bar, baz)"
+    end
+  end
+
+  describe '#convert_nulls' do
+    it "translates arguments to an IFNULL SQL call" do
+      adapter.convert_nulls('id', 5).should == 'IFNULL(id, 5)'
+    end
+  end
+
+  describe '#group_concatenate' do
+    it "group concatenates the clause with the given separator" do
+      adapter.group_concatenate('foo', ',').
+        should == "GROUP_CONCAT(foo SEPARATOR ',')"
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/database_adapters/postgresql_adapter_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
+  let(:adapter) {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.new(model)
+  }
+  let(:model)   { double('model') }
+
+  describe '#boolean_value' do
+    it "returns 'TRUE' for true" do
+      adapter.boolean_value(true).should == 'TRUE'
+    end
+
+    it "returns 'FALSE' for false" do
+      adapter.boolean_value(false).should == 'FALSE'
+    end
+  end
+
+  describe '#cast_to_timestamp' do
+    it "converts to unix timestamps" do
+      adapter.cast_to_timestamp('created_at').
+        should == 'extract(epoch from created_at)::int'
+    end
+  end
+
+  describe '#concatenate' do
+    it "concatenates with the given separator" do
+      adapter.concatenate('foo, bar, baz', ',').
+        should == "COALESCE(foo, '') || ',' || COALESCE(bar, '') || ',' || COALESCE(baz, '')"
+    end
+  end
+
+  describe '#convert_nulls' do
+    it "translates arguments to a COALESCE SQL call" do
+      adapter.convert_nulls('id', 5).should == 'COALESCE(id, 5)'
+    end
+  end
+
+  describe '#group_concatenate' do
+    it "group concatenates the clause with the given separator" do
+      adapter.group_concatenate('foo', ',').
+        should == "array_to_string(array_agg(foo), ',')"
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/database_adapters_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
+  let(:model) { double('model') }
+
+  describe '.adapter_for' do
+    it "returns a MysqlAdapter object for :mysql" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        stub(:adapter_type_for => :mysql)
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
+        should be_a(
+          ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
+        )
+    end
+
+    it "returns a PostgreSQLAdapter object for :postgresql" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        stub(:adapter_type_for => :postgresql)
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
+        should be_a(
+          ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
+        )
+    end
+
+    it "instantiates using the default adapter if one is provided" do
+      adapter_class    = double('adapter class')
+      adapter_instance = double('adapter instance')
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = adapter_class
+      adapter_class.stub!(:new => adapter_instance)
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
+        should == adapter_instance
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = nil
+    end
+
+    it "raises an exception for other responses" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        stub(:adapter_type_for => :sqlite)
+
+      lambda {
+        ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)
+      }.should raise_error
+    end
+  end
+
+  describe '.adapter_type_for' do
+    let(:klass)      { double('connection class') }
+    let(:connection) { double('connection', :class => klass) }
+    let(:model)      { double('model', :connection => connection) }
+
+    it "translates a normal MySQL adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == :mysql
+    end
+
+    it "translates a MySQL2 adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == :mysql
+    end
+
+    it "translates a normal PostgreSQL adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(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::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(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::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == :postgresql
+    end
+
+    it "returns other JDBC adapters without translation" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbcmssql'})
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == 'jdbcmssql'
+    end
+
+    it "returns other unknown adapters without translation" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).
+        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
+    end
+  end
+end