thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/panes/excerpts_pane_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/excerpts_pane'
+
+describe ThinkingSphinx::Panes::ExcerptsPane do
+  let(:pane)    {
+    ThinkingSphinx::Panes::ExcerptsPane.new context, object, raw }
+  let(:context) { {:indices => [double(:name => 'foo_core')]} }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+  let(:search)  { double('search', :query => 'foo', :options => {}) }
+
+  before :each do
+    allow(context).to receive_messages :search => search
+  end
+
+  describe '#excerpts' do
+    let(:excerpter) { double('excerpter') }
+    let(:excerpts)  { double('excerpts object') }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Excerpter', double(:new => excerpter)
+      allow(ThinkingSphinx::Panes::ExcerptsPane::Excerpts).to receive_messages :new => excerpts
+    end
+
+    it "returns an excerpt glazing" do
+      expect(pane.excerpts).to eq(excerpts)
+    end
+
+    it "creates an excerpter with the first index and the query and conditions values" do
+      context[:indices] = [double(:name => 'alpha'), double(:name => 'beta')]
+      context.search.options[:conditions] = {:baz => 'bar'}
+
+      expect(ThinkingSphinx::Excerpter).to receive(:new).
+        with('alpha', 'foo bar', anything).and_return(excerpter)
+
+      pane.excerpts
+    end
+
+    it "passes through excerpts options" do
+      search.options[:excerpts] = {:before_match => 'foo'}
+
+      expect(ThinkingSphinx::Excerpter).to receive(:new).
+        with(anything, anything, { :before_match => 'foo' }).and_return(excerpter)
+
+      pane.excerpts
+    end
+  end
+end

data/spec/thinking_sphinx/panes/weight_pane_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/weight_pane'
+
+describe ThinkingSphinx::Panes::WeightPane do
+  let(:pane)    { ThinkingSphinx::Panes::WeightPane.new context, object, raw }
+  let(:context) { double('context') }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+
+  describe '#weight' do
+    it "returns the object's weight by default" do
+      raw["weight()"] = 101
+
+      expect(pane.weight).to eq(101)
+    end
+  end
+end

data/spec/thinking_sphinx/rake_interface_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RakeInterface do
+  let(:interface) { ThinkingSphinx::RakeInterface.new }
+  let(:commander) { double :call => nil }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Commander', commander
+  end
+
+  describe '#configure' do
+    it 'sends the configure command' do
+      expect(commander).to receive(:call).
+        with(:configure, anything, {:verbose => true})
+
+      interface.configure
+    end
+  end
+
+  describe '#daemon' do
+    it 'returns a daemon interface' do
+      expect(interface.daemon.class).to eq(ThinkingSphinx::Interfaces::Daemon)
+    end
+  end
+
+  describe '#rt' do
+    it 'returns a real-time interface' do
+      expect(interface.rt.class).to eq(ThinkingSphinx::Interfaces::RealTime)
+    end
+  end
+
+  describe '#sql' do
+    it 'returns an SQL interface' do
+      expect(interface.sql.class).to eq(ThinkingSphinx::Interfaces::SQL)
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/attribute_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Attribute do
+  let(:attribute) { ThinkingSphinx::RealTime::Attribute.new column }
+  let(:column)    { double('column', :__name => :created_at, :__stack => []) }
+
+  describe '#name' do
+    it "uses the provided option by default" do
+      attribute = ThinkingSphinx::RealTime::Attribute.new column, :as => :foo
+      expect(attribute.name).to eq('foo')
+    end
+
+    it "falls back to the column's name" do
+      expect(attribute.name).to eq('created_at')
+    end
+  end
+
+  describe '#translate' do
+    let(:klass)  { Struct.new(:name, :parent) }
+    let(:object) { klass.new 'the object name', parent }
+    let(:parent) { klass.new 'the parent name', nil }
+
+    it "returns the column's name if it's a string" do
+      allow(column).to receive_messages :__name => 'value'
+
+      expect(attribute.translate(object)).to eq('value')
+    end
+
+    it "returns the column's name if it's an integer" do
+      allow(column).to receive_messages :__name => 404
+
+      expect(attribute.translate(object)).to eq(404)
+    end
+
+    it "returns the object's method matching the column's name" do
+      allow(object).to receive_messages :created_at => 'a time'
+
+      expect(attribute.translate(object)).to eq('a time')
+    end
+
+    it "uses the column's stack to navigate through the object tree" do
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
+
+      expect(attribute.translate(object)).to eq('the parent name')
+    end
+
+    it "returns zero if any element in the object tree is nil" do
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
+      object.parent = nil
+
+      expect(attribute.translate(object)).to be_zero
+    end
+  end
+
+  describe '#type' do
+    it "returns the given type option" do
+      attribute = ThinkingSphinx::RealTime::Attribute.new column,
+        :type => :string
+      expect(attribute.type).to eq(:string)
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/callbacks/real_time_callbacks_spec.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new :article
+  }
+  let(:instance)   { double('instance', :id => 12, :persisted? => true) }
+  let(:config)     { double('config', :indices_for_references => [index],
+    :settings => {}) }
+  let(:index)      { double('index', :name => 'my_index', :is_a? => true,
+    :document_id_for_key => 123, :fields => [], :attributes => [],
+    :conditions => [], :primary_key => :id) }
+  let(:connection) { double('connection', :execute => true) }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+    allow(ThinkingSphinx::Connection).to receive_message_chain(:pool, :take).and_yield connection
+  end
+
+  describe '#after_save, #after_commit' do
+    let(:insert)     { double('insert', :to_sql => 'REPLACE INTO my_index') }
+    let(:time)       { 1.day.ago }
+    let(:field)      { double('field', :name => 'name', :translate => 'Foo') }
+    let(:attribute)  { double('attribute', :name => 'created_at',
+      :translate => time) }
+
+    before :each do
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+      allow(Riddle::Query::Insert).to receive_messages :new => insert
+      allow(insert).to receive_messages :replace! => insert
+      allow(index).to receive_messages :fields => [field], :attributes => [attribute]
+    end
+
+    it "creates an insert statement with all fields and attributes" do
+      expect(Riddle::Query::Insert).to receive(:new).
+        with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+        and_return(insert)
+
+      callbacks.after_save instance
+    end
+
+    it "switches the insert to a replace statement" do
+      expect(insert).to receive(:replace!).and_return(insert)
+
+      callbacks.after_save instance
+    end
+
+    it "sends the insert through to the server" do
+      expect(connection).to receive(:execute).with('REPLACE INTO my_index')
+
+      callbacks.after_save instance
+    end
+
+    it "creates an insert statement with all fields and attributes" do
+      expect(Riddle::Query::Insert).to receive(:new).
+        with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+        and_return(insert)
+
+      callbacks.after_commit instance
+    end
+
+    it "switches the insert to a replace statement" do
+      expect(insert).to receive(:replace!).and_return(insert)
+
+      callbacks.after_commit instance
+    end
+
+    it "sends the insert through to the server" do
+      expect(connection).to receive(:execute).with('REPLACE INTO my_index')
+
+      callbacks.after_commit instance
+    end
+
+    context 'with a given path' do
+      let(:callbacks)  {
+        ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
+          :article, [:user]
+        )
+      }
+      let(:instance)   { double('instance', :id => 12, :user => user) }
+      let(:user)       { double('user', :id => 13, :persisted? => true) }
+
+      it "creates an insert statement with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_save instance
+      end
+
+      it "gets the document id for the user object" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+
+        callbacks.after_save instance
+      end
+
+      it "translates values for the user object" do
+        expect(field).to receive(:translate).with(user).and_return('Foo')
+
+        callbacks.after_save instance
+      end
+
+      it "creates an insert statement with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for the user object" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for the user object" do
+        expect(field).to receive(:translate).with(user).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
+    end
+
+    context 'with a path returning multiple objects' do
+      let(:callbacks)  {
+        ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
+          :article, [:readers]
+        )
+      }
+      let(:instance)   { double('instance', :id => 12,
+        :readers => [user_a, user_b]) }
+      let(:user_a)     { double('user', :id => 13, :persisted? => true) }
+      let(:user_b)     { double('user', :id => 14, :persisted? => true) }
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_save instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_save instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_save instance
+      end
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
+    end
+
+    context 'with a block instead of a path' do
+      let(:callbacks)  {
+        ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
+          :article
+        ) { |object| object.readers }
+      }
+      let(:instance)   { double('instance', :id => 12,
+        :readers => [user_a, user_b]) }
+      let(:user_a)     { double('user', :id => 13, :persisted? => true) }
+      let(:user_b)     { double('user', :id => 14, :persisted? => true) }
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_save instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_save instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_save instance
+      end
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/field_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Field do
+  let(:field)  { ThinkingSphinx::RealTime::Field.new column }
+  let(:column) { double('column', :__name => :created_at, :__stack => []) }
+
+  describe '#column' do
+    it 'returns the provided Column object' do
+      expect(field.column).to eq(column)
+    end
+
+    it 'translates symbols to Column objects' do
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).with(:title).
+        and_return(column)
+
+      ThinkingSphinx::RealTime::Field.new :title
+    end
+  end
+
+  describe '#name' do
+    it "uses the provided option by default" do
+      field = ThinkingSphinx::RealTime::Field.new column, :as => :foo
+      expect(field.name).to eq('foo')
+    end
+
+    it "falls back to the column's name" do
+      expect(field.name).to eq('created_at')
+    end
+  end
+
+  describe '#translate' do
+    let(:klass)  { Struct.new(:name, :parent) }
+    let(:object) { klass.new 'the object name', parent }
+    let(:parent) { klass.new 'the parent name', nil }
+
+    it "returns the column's name if it's a string" do
+      allow(column).to receive_messages :__name => 'value'
+
+      expect(field.translate(object)).to eq('value')
+    end
+
+    it "returns the column's name as a string if it's an integer" do
+      allow(column).to receive_messages :__name => 404
+
+      expect(field.translate(object)).to eq('404')
+    end
+
+    it "returns the object's method matching the column's name" do
+      allow(object).to receive_messages :created_at => 'a time'
+
+      expect(field.translate(object)).to eq('a time')
+    end
+
+    it "uses the column's stack to navigate through the object tree" do
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
+
+      expect(field.translate(object)).to eq('the parent name')
+    end
+
+    it "returns a blank string if any element in the object tree is nil" do
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
+      object.parent = nil
+
+      expect(field.translate(object)).to eq('')
+    end
+  end
+end