thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/real_time/interpreter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Interpreter do
@@ -8,19 +10,23 @@ describe ThinkingSphinx::RealTime::Interpreter do
   let(:index)   { Struct.new(:attributes, :fields, :options).new([], [], {}) }
   let(:block)   { Proc.new { } }
 
+  before :each do
+    allow(index).to receive_messages(:add_attribute => nil, :add_field => nil)
+  end
+
   describe '.translate!' do
     let(:instance) { double('interpreter', :translate! => true) }
 
     it "creates a new interpreter instance with the given block and index" do
-      ThinkingSphinx::RealTime::Interpreter.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:new).
         with(index, block).and_return(instance)
 
       ThinkingSphinx::RealTime::Interpreter.translate! index, block
     end
 
     it "calls translate! on the instance" do
-      ThinkingSphinx::RealTime::Interpreter.stub!(:new => instance)
-      instance.should_receive(:translate!)
+      allow(ThinkingSphinx::RealTime::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
 
       ThinkingSphinx::RealTime::Interpreter.translate! index, block
     end
@@ -31,35 +37,33 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:attribute) { double('attribute') }
 
     before :each do
-      ThinkingSphinx::RealTime::Attribute.stub! :new => attribute
+      allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
     end
 
     it "creates a new attribute with the provided column" do
-      ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
         with(column, {}).and_return(attribute)
 
       instance.has column
     end
 
     it "passes through options to the attribute" do
-      ThinkingSphinx::RealTime::Attribute.should_receive(:new).
-        with(column, :as => :other_name).and_return(attribute)
+      expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
+        with(column, { :as => :other_name }).and_return(attribute)
 
       instance.has column, :as => :other_name
     end
 
     it "adds an attribute to the index" do
-      instance.has column
+      expect(index).to receive(:add_attribute).with(attribute)
 
-      index.attributes.should include(attribute)
+      instance.has column
     end
 
     it "adds multiple attributes when passed multiple columns" do
-      instance.has column, column
+      expect(index).to receive(:add_attribute).with(attribute).twice
 
-      index.attributes.select { |saved_attribute|
-        saved_attribute == attribute
-      }.length.should == 2
+      instance.has column, column
     end
   end
 
@@ -68,74 +72,72 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:field)  { double('field') }
 
     before :each do
-      ThinkingSphinx::RealTime::Field.stub! :new => field
+      allow(ThinkingSphinx::RealTime::Field).to receive_messages :new => field
     end
 
     it "creates a new field with the provided column" do
-      ThinkingSphinx::RealTime::Field.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Field).to receive(:new).
         with(column, {}).and_return(field)
 
       instance.indexes column
     end
 
     it "passes through options to the field" do
-      ThinkingSphinx::RealTime::Field.should_receive(:new).
-        with(column, :as => :other_name).and_return(field)
+      expect(ThinkingSphinx::RealTime::Field).to receive(:new).
+        with(column, { :as => :other_name }).and_return(field)
 
       instance.indexes column, :as => :other_name
     end
 
     it "adds a field to the index" do
-      instance.indexes column
+      expect(index).to receive(:add_field).with(field)
 
-      index.fields.should include(field)
+      instance.indexes column
     end
 
     it "adds multiple fields when passed multiple columns" do
-      instance.indexes column, column
+      expect(index).to receive(:add_field).with(field).twice
 
-      index.fields.select { |saved_field|
-        saved_field == field
-      }.length.should == 2
+      instance.indexes column, column
     end
 
     context 'sortable' do
       let(:attribute) { double('attribute') }
 
       before :each do
-        ThinkingSphinx::RealTime::Attribute.stub! :new => attribute
+        allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
 
-        column.stub :__name => :col
+        allow(column).to receive_messages :__name => :col
       end
 
       it "adds the _sort suffix to the field's name" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
-          with(column, :as => :col_sort, :type => :string).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
+          with(column, { :as => :col_sort, :type => :string }).
           and_return(attribute)
 
         instance.indexes column, :sortable => true
       end
 
       it "respects given aliases" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
-          with(column, :as => :other_sort, :type => :string).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
+          with(column, { :as => :other_sort, :type => :string }).
           and_return(attribute)
 
         instance.indexes column, :sortable => true, :as => :other
       end
 
       it "respects symbols instead of columns" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
-          with(:title, :as => :title_sort, :type => :string).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
+          with(:title, { :as => :title_sort, :type => :string }).
           and_return(attribute)
 
         instance.indexes :title, :sortable => true
       end
 
       it "adds an attribute to the index" do
-        instance.indexes column, :sortable => true
+        expect(index).to receive(:add_attribute).with(attribute)
 
-        index.attributes.should include(attribute)
+        instance.indexes column, :sortable => true
       end
     end
   end
@@ -144,15 +146,15 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:column) { double('column') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Column.stub!(:new => column)
+      allow(ThinkingSphinx::ActiveRecord::Column).to receive_messages(:new => column)
     end
 
     it "returns a new column for the given method" do
-      instance.id.should == column
+      expect(instance.id).to eq(column)
     end
 
     it "should initialise the column with the method name and arguments" do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).
         with(:users, :posts, :subject).and_return(column)
 
       instance.users(:posts, :subject)
@@ -161,7 +163,7 @@ describe ThinkingSphinx::RealTime::Interpreter do
 
   describe '#scope' do
     it "passes the scope block through to the index" do
-      index.should_receive(:scope=).with(instance_of(Proc))
+      expect(index).to receive(:scope=).with(instance_of(Proc))
 
       instance.scope { :foo }
     end
@@ -169,18 +171,18 @@ describe ThinkingSphinx::RealTime::Interpreter do
 
   describe '#set_property' do
     before :each do
-      index.class.stub :settings => [:morphology]
+      allow(index.class).to receive_messages :settings => [:morphology]
     end
 
     it 'saves other settings as index options' do
       instance.set_property :field_weights => {:name => 10}
 
-      index.options[:field_weights].should == {:name => 10}
+      expect(index.options[:field_weights]).to eq({:name => 10})
     end
 
     context 'index settings' do
       it "sets the provided setting" do
-        index.should_receive(:morphology=).with('stem_en')
+        expect(index).to receive(:morphology=).with('stem_en')
 
         instance.set_property :morphology => 'stem_en'
       end
@@ -194,8 +196,8 @@ describe ThinkingSphinx::RealTime::Interpreter do
       }
 
       interpreter = ThinkingSphinx::RealTime::Interpreter.new index, block
-      interpreter.translate!.
-        should == interpreter.__id__
+      expect(interpreter.translate!).
+        to eq(interpreter.__id__)
     end
   end
 end

data/spec/thinking_sphinx/real_time/transcribe_instance_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::RealTime::TranscribeInstance do
+  let(:subject) do
+    ThinkingSphinx::RealTime::TranscribeInstance.call(
+      instance, index, [property_a, property_b, property_c]
+    )
+  end
+  let(:instance)   { double :id => 43 }
+  let(:index)      { double :document_id_for_key => 46, :primary_key => :id }
+  let(:property_a) { double :translate => 'A' }
+  let(:property_b) { double :translate => 'B' }
+  let(:property_c) { double :translate => 'C' }
+
+  it 'returns an array of each translated property, and the document id' do
+    expect(subject).to eq([46, 'A', 'B', 'C'])
+  end
+
+  it 'raises an error if something goes wrong' do
+    allow(property_b).to receive(:translate).and_raise(StandardError)
+
+    expect { subject }.to raise_error(ThinkingSphinx::TranscriptionError)
+  end
+
+  it 'notes the instance and property in the wrapper error' do
+    allow(property_b).to receive(:translate).and_raise(StandardError)
+
+    expect { subject }.to raise_error do |wrapper|
+      expect(wrapper.instance).to eq(instance)
+      expect(wrapper.property).to eq(property_b)
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/transcriber_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::RealTime::Transcriber do
+  let(:subject)    { ThinkingSphinx::RealTime::Transcriber.new index }
+  let(:index)      { double 'index', :name => 'foo_core', :conditions => [],
+    :fields => [double(:name => 'field_a'), double(:name => 'field_b')],
+    :attributes => [double(:name => 'attr_a'), double(:name => 'attr_b')],
+    :primary_key => :id }
+  let(:insert)     { double :replace! => replace }
+  let(:replace)    { double :to_sql => 'REPLACE QUERY' }
+  let(:connection) { double :execute => true }
+  let(:instance_a) { double :id => 48, :persisted? => true }
+  let(:instance_b) { double :id => 49, :persisted? => true }
+  let(:properties_a) { double }
+  let(:properties_b) { double }
+
+  before :each do
+    allow(Riddle::Query::Insert).to receive(:new).and_return(insert)
+    allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+    allow(ThinkingSphinx::RealTime::TranscribeInstance).to receive(:call).
+      with(instance_a, index, anything).and_return(properties_a)
+    allow(ThinkingSphinx::RealTime::TranscribeInstance).to receive(:call).
+      with(instance_b, index, anything).and_return(properties_b)
+  end
+
+  it "generates a SphinxQL command" do
+    expect(Riddle::Query::Insert).to receive(:new).with(
+      'foo_core',
+      ['id', 'field_a', 'field_b', 'attr_a', 'attr_b'],
+      [properties_a, properties_b]
+    )
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "executes the SphinxQL command" do
+    expect(connection).to receive(:execute).with('REPLACE QUERY')
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "deletes previous records" do
+    expect(connection).to receive(:execute).
+      with('DELETE FROM foo_core WHERE sphinx_internal_id IN (48, 49)')
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "skips instances that aren't in the database" do
+    allow(instance_a).to receive(:persisted?).and_return(false)
+
+    expect(Riddle::Query::Insert).to receive(:new).with(
+      'foo_core',
+      ['id', 'field_a', 'field_b', 'attr_a', 'attr_b'],
+      [properties_b]
+    )
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "skips instances that fail a symbol condition" do
+    index.conditions << :ok?
+    allow(instance_a).to receive(:ok?).and_return(true)
+    allow(instance_b).to receive(:ok?).and_return(false)
+
+    expect(Riddle::Query::Insert).to receive(:new).with(
+      'foo_core',
+      ['id', 'field_a', 'field_b', 'attr_a', 'attr_b'],
+      [properties_a]
+    )
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "skips instances that fail a Proc condition" do
+    index.conditions << Proc.new { |instance| instance.ok? }
+    allow(instance_a).to receive(:ok?).and_return(true)
+    allow(instance_b).to receive(:ok?).and_return(false)
+
+    expect(Riddle::Query::Insert).to receive(:new).with(
+      'foo_core',
+      ['id', 'field_a', 'field_b', 'attr_a', 'attr_b'],
+      [properties_a]
+    )
+
+    subject.copy instance_a, instance_b
+  end
+
+  it "skips instances that throw an error while transcribing values" do
+    error = ThinkingSphinx::TranscriptionError.new
+    error.instance = instance_a
+    error.inner_exception = StandardError.new
+
+    allow(ThinkingSphinx::RealTime::TranscribeInstance).to receive(:call).
+      with(instance_a, index, anything).
+      and_raise(error)
+    allow(ThinkingSphinx.output).to receive(:puts).and_return(nil)
+
+    expect(Riddle::Query::Insert).to receive(:new).with(
+      'foo_core',
+      ['id', 'field_a', 'field_b', 'attr_a', 'attr_b'],
+      [properties_b]
+    )
+
+    subject.copy instance_a, instance_b
+  end
+end

data/spec/thinking_sphinx/real_time/translator_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Translator do
+  let(:subject) { ThinkingSphinx::RealTime::Translator.call object, column }
+  let(:object)  { double }
+  let(:column)  { double :__stack => [], :__name => :title }
+
+  it "converts non-UTF-8 strings to UTF-8" do
+    allow(object).to receive(:title).
+      and_return "hello".dup.force_encoding("ASCII-8BIT")
+
+    expect(subject).to eq("hello")
+    expect(subject.encoding.name).to eq("UTF-8")
+  end
+end

data/spec/thinking_sphinx/scopes_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Scopes do
@@ -16,30 +18,34 @@ describe ThinkingSphinx::Scopes do
       model.sphinx_scopes[:foo] = Proc.new { {:with => {:foo => :bar}} }
     end
 
+    it "implements respond_to" do
+      expect(model).to respond_to(:foo)
+    end
+
     it "creates new search" do
-      model.foo.class.should == ThinkingSphinx::Search
+      expect(model.foo.class).to eq(ThinkingSphinx::Search)
     end
 
     it "passes block result to constructor" do
-      model.foo.options[:with].should == {:foo => :bar}
+      expect(model.foo.options[:with]).to eq({:foo => :bar})
     end
 
     it "passes non-scopes through to the standard method error call" do
-      lambda { model.bar }.should raise_error(NoMethodError)
+      expect { model.bar }.to raise_error(NoMethodError)
     end
   end
 
   describe '#sphinx_scope' do
     it "saves the given block with a name" do
       model.sphinx_scope(:foo) { 27 }
-      model.sphinx_scopes[:foo].call.should == 27
+      expect(model.sphinx_scopes[:foo].call).to eq(27)
     end
   end
 
   describe '#default_sphinx_scope' do
     it "gets and sets the default scope depending on the argument" do
       model.default_sphinx_scope :foo
-      model.default_sphinx_scope.should == :foo
+      expect(model.default_sphinx_scope).to eq(:foo)
     end
   end
 end

data/spec/thinking_sphinx/search/glaze_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   class Search; end
 end
@@ -12,11 +14,11 @@ describe ThinkingSphinx::Search::Glaze do
 
   describe '#!=' do
     it "is true for objects that don't match" do
-      (glaze != double('foo')).should be_true
+      expect(glaze != double('foo')).to be_truthy
     end
 
     it "is false when the underlying object is a match" do
-      (glaze != object).should be_false
+      expect(glaze != object).to be_falsey
     end
   end
 
@@ -28,50 +30,50 @@ describe ThinkingSphinx::Search::Glaze do
     let(:pane_two) { double('pane two', :foo => 'two', :bar => 'two') }
 
     before :each do
-      klass.stub(:new).and_return(pane_one, pane_two)
+      allow(klass).to receive(:new).and_return(pane_one, pane_two)
     end
 
     it "respects objects existing methods" do
-      object.stub :foo => 'original'
+      allow(object).to receive_messages :foo => 'original'
 
-      glaze.foo.should == 'original'
+      expect(glaze.foo).to eq('original')
     end
 
     it "uses the first pane that responds to the method" do
-      glaze.foo.should == 'one'
-      glaze.bar.should == 'two'
+      expect(glaze.foo).to eq('one')
+      expect(glaze.bar).to eq('two')
     end
 
     it "raises the method missing error otherwise" do
-      object.stub :respond_to? => false
-      object.stub(:baz).and_raise(NoMethodError)
+      allow(object).to receive_messages :respond_to? => false
+      allow(object).to receive(:baz).and_raise(NoMethodError)
 
-      lambda { glaze.baz }.should raise_error(NoMethodError)
+      expect { glaze.baz }.to raise_error(NoMethodError)
     end
   end
 
   describe '#respond_to?' do
     it "responds to underlying object methods" do
-      object.stub :foo => true
+      allow(object).to receive_messages :foo => true
 
-      glaze.respond_to?(:foo).should be_true
+      expect(glaze.respond_to?(:foo)).to be_truthy
     end
 
     it "responds to underlying pane methods" do
       pane  = double('Pane Class', :new => double('pane', :bar => true))
       glaze = ThinkingSphinx::Search::Glaze.new context, object, raw, [pane]
 
-      glaze.respond_to?(:bar).should be_true
+      expect(glaze.respond_to?(:bar)).to be_truthy
     end
 
     it "does not to respond to methods that don't exist" do
-      glaze.respond_to?(:something).should be_false
+      expect(glaze.respond_to?(:something)).to be_falsey
     end
   end
 
   describe '#unglazed' do
     it "returns the original object" do
-      glaze.unglazed.should == object
+      expect(glaze.unglazed).to eq(object)
     end
   end
 end

data/spec/thinking_sphinx/search/query_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   class Search; end
 end
@@ -14,30 +16,30 @@ describe ThinkingSphinx::Search::Query do
     it "passes through the keyword as provided" do
       query = ThinkingSphinx::Search::Query.new 'pancakes'
 
-      query.to_s.should == 'pancakes'
+      expect(query.to_s).to eq('pancakes')
     end
 
     it "pairs fields and keywords for given conditions" do
       query = ThinkingSphinx::Search::Query.new '', :title => 'pancakes'
 
-      query.to_s.should == '@title pancakes'
+      expect(query.to_s).to eq('@title pancakes')
     end
 
     it "combines both keywords and conditions" do
       query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes'
 
-      query.to_s.should == 'tasty @title pancakes'
+      expect(query.to_s).to eq('tasty @title pancakes')
     end
 
     it "automatically stars keywords if requested" do
-      ThinkingSphinx::Query.should_receive(:wildcard).with('cake', true).
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('cake', true).
         and_return('*cake*')
 
       ThinkingSphinx::Search::Query.new('cake', {}, true).to_s
     end
 
     it "automatically stars condition keywords if requested" do
-      ThinkingSphinx::Query.should_receive(:wildcard).with('pan', true).
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('pan', true).
         and_return('*pan*')
 
       ThinkingSphinx::Search::Query.new('', {:title => 'pan'}, true).to_s
@@ -47,32 +49,39 @@ describe ThinkingSphinx::Search::Query do
       query = ThinkingSphinx::Search::Query.new '',
         {:sphinx_internal_class_name => 'article'}, true
 
-      query.to_s.should == '@sphinx_internal_class_name article'
+      expect(query.to_s).to eq('@sphinx_internal_class_name article')
     end
 
     it "handles null values by removing them from the conditions hash" do
       query = ThinkingSphinx::Search::Query.new '', :title => nil
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "handles empty string values by removing them from the conditions hash" do
       query = ThinkingSphinx::Search::Query.new '', :title => ''
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "handles nil queries" do
       query = ThinkingSphinx::Search::Query.new nil, {}
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "allows mixing of blank and non-blank conditions" do
       query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes',
         :ingredients => nil
 
-      query.to_s.should == 'tasty @title pancakes'
+      expect(query.to_s).to eq('tasty @title pancakes')
+    end
+
+    it "handles multiple fields for a single condition" do
+      query = ThinkingSphinx::Search::Query.new '',
+        [:title, :content] => 'pancakes'
+
+      expect(query.to_s).to eq('@(title,content) pancakes')
     end
   end
 end