thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/real_time/index_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Index do
+  let(:index)        { ThinkingSphinx::RealTime::Index.new :user }
+  let(:config)       { double('config', :settings => {},
+    :indices_location => 'location', :next_offset => 8,
+    :index_set_class => index_set_class) }
+  let(:index_set_class) { double(:index_set_class, :reference_name => :user) }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+  end
+
+  describe '#add_attribute' do
+    let(:attribute) { double('attribute', name: 'my_attribute') }
+
+    it "appends attributes to the collection" do
+      index.add_attribute attribute
+
+      expect(index.attributes.collect(&:name)).to include('my_attribute')
+    end
+
+    it "replaces attributes with the same name" do
+      index.add_attribute double('attribute', name: 'my_attribute')
+      index.add_attribute attribute
+
+      matching = index.attributes.select { |attr| attr.name == attribute.name }
+
+      expect(matching).to eq([attribute])
+    end
+  end
+
+  describe '#add_field' do
+    let(:field) { double('field', name: 'my_field') }
+
+    it "appends fields to the collection" do
+      index.add_field field
+
+      expect(index.fields.collect(&:name)).to include('my_field')
+    end
+
+    it "replaces fields with the same name" do
+      index.add_field double('field', name: 'my_field')
+      index.add_field field
+
+      matching = index.fields.select { |fld| fld.name == field.name }
+
+      expect(matching).to eq([field])
+    end
+  end
+
+  describe '#attributes' do
+    it "has the internal id attribute by default" do
+      expect(index.attributes.collect(&:name)).to include('sphinx_internal_id')
+    end
+
+    it "has the class name attribute by default" do
+      expect(index.attributes.collect(&:name)).to include('sphinx_internal_class')
+    end
+
+    it "has the internal deleted attribute by default" do
+      expect(index.attributes.collect(&:name)).to include('sphinx_deleted')
+    end
+
+    it "does not have an internal updated_at attribute by default" do
+      expect(index.attributes.collect(&:name)).to_not include('sphinx_updated_at')
+    end
+
+    it "has an internal updated_at attribute if real_time_tidy is true" do
+      config.settings["real_time_tidy"] = true
+
+      expect(index.attributes.collect(&:name)).to include('sphinx_updated_at')
+    end
+  end
+
+  describe '#delta?' do
+    it "always returns false" do
+      expect(index).not_to be_delta
+    end
+  end
+
+  describe '#document_id_for_key' do
+    it "calculates the document id based on offset and number of indices" do
+      allow(config).to receive_message_chain(:indices, :count).and_return(5)
+      allow(config).to receive_messages :next_offset => 7
+
+      expect(index.document_id_for_key(123)).to eq(622)
+    end
+  end
+
+  describe '#fields' do
+    it "has the internal class field by default" do
+      expect(index.fields.collect(&:name)).to include('sphinx_internal_class_name')
+    end
+  end
+
+  describe '#interpret_definition!' do
+    let(:block) { double('block') }
+
+    before :each do
+      index.definition_block = block
+    end
+
+    it "interprets the definition block" do
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:translate!).
+        with(index, block)
+
+      index.interpret_definition!
+    end
+
+    it "only interprets the definition block once" do
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:translate!).
+        once
+
+      index.interpret_definition!
+      index.interpret_definition!
+    end
+  end
+
+  describe '#model' do
+    let(:model)  { double('model', :primary_key => :id) }
+
+    it "translates symbol references to model class" do
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
+
+      expect(index.model).to eq(model)
+    end
+
+    it "memoizes the result" do
+      expect(ActiveSupport::Inflector).to receive(:constantize).with('User').once.
+        and_return(model)
+
+      index.model
+      index.model
+    end
+  end
+
+  describe '#morphology' do
+    before :each do
+      skip
+    end
+
+    context 'with a render' do
+      it "defaults to nil" do
+        begin
+          index.render
+        rescue Riddle::Configuration::ConfigurationError
+        end
+
+        expect(index.morphology).to be_nil
+      end
+
+      it "reads from the settings file if provided" do
+        config.settings['morphology'] = 'stem_en'
+
+        begin
+          index.render
+        rescue Riddle::Configuration::ConfigurationError
+        end
+
+        expect(index.morphology).to eq('stem_en')
+      end
+    end
+  end
+
+  describe '#name' do
+    it "always uses the core suffix" do
+      index = ThinkingSphinx::RealTime::Index.new :user
+      expect(index.name).to eq('user_core')
+    end
+  end
+
+  describe '#offset' do
+    before :each do
+      allow(config).to receive_messages :next_offset => 4
+    end
+
+    it "uses the next offset value from the configuration" do
+      expect(index.offset).to eq(4)
+    end
+
+    it "uses the reference to get a unique offset" do
+      expect(config).to receive(:next_offset).with(:user).and_return(2)
+
+      index.offset
+    end
+  end
+
+  describe '#render' do
+    before :each do
+      allow(FileUtils).to receive_messages :mkdir_p => true
+    end
+
+    it "interprets the provided definition" do
+      expect(index).to receive(:interpret_definition!).at_least(:once)
+
+      begin
+        index.render
+      rescue Riddle::Configuration::ConfigurationError
+        # Ignoring underlying validation error.
+      end
+    end
+  end
+
+  describe '#scope' do
+    let(:model)  { double('model', :primary_key => :id) }
+
+    it "returns the model by default" do
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
+
+      expect(index.scope).to eq(model)
+    end
+
+    it "returns the evaluated scope if provided" do
+      index.scope = lambda { :foo }
+
+      expect(index.scope).to eq(:foo)
+    end
+  end
+
+  describe '#unique_attribute_names' do
+    it "returns all attribute names" do
+      expect(index.unique_attribute_names).to eq([
+        'sphinx_internal_id', 'sphinx_internal_class', 'sphinx_deleted'
+      ])
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/interpreter_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Interpreter do
+  let(:instance) {
+    ThinkingSphinx::RealTime::Interpreter.new index, block
+  }
+  let(:model)   { double('model') }
+  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
+      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
+      allow(ThinkingSphinx::RealTime::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
+
+      ThinkingSphinx::RealTime::Interpreter.translate! index, block
+    end
+  end
+
+  describe '#has' do
+    let(:column)    { double('column') }
+    let(:attribute) { double('attribute') }
+
+    before :each do
+      allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
+    end
+
+    it "creates a new attribute with the provided column" do
+      expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
+        with(column, {}).and_return(attribute)
+
+      instance.has column
+    end
+
+    it "passes through options to the attribute" do
+      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
+      expect(index).to receive(:add_attribute).with(attribute)
+
+      instance.has column
+    end
+
+    it "adds multiple attributes when passed multiple columns" do
+      expect(index).to receive(:add_attribute).with(attribute).twice
+
+      instance.has column, column
+    end
+  end
+
+  describe '#indexes' do
+    let(:column) { double('column') }
+    let(:field)  { double('field') }
+
+    before :each do
+      allow(ThinkingSphinx::RealTime::Field).to receive_messages :new => field
+    end
+
+    it "creates a new field with the provided column" do
+      expect(ThinkingSphinx::RealTime::Field).to receive(:new).
+        with(column, {}).and_return(field)
+
+      instance.indexes column
+    end
+
+    it "passes through options to the field" do
+      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
+      expect(index).to receive(:add_field).with(field)
+
+      instance.indexes column
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      expect(index).to receive(:add_field).with(field).twice
+
+      instance.indexes column, column
+    end
+
+    context 'sortable' do
+      let(:attribute) { double('attribute') }
+
+      before :each do
+        allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
+
+        allow(column).to receive_messages :__name => :col
+      end
+
+      it "adds the _sort suffix to the field's name" do
+        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
+        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
+        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
+        expect(index).to receive(:add_attribute).with(attribute)
+
+        instance.indexes column, :sortable => true
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:column) { double('column') }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Column).to receive_messages(:new => column)
+    end
+
+    it "returns a new column for the given method" do
+      expect(instance.id).to eq(column)
+    end
+
+    it "should initialise the column with the method name and arguments" do
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).
+        with(:users, :posts, :subject).and_return(column)
+
+      instance.users(:posts, :subject)
+    end
+  end
+
+  describe '#scope' do
+    it "passes the scope block through to the index" do
+      expect(index).to receive(:scope=).with(instance_of(Proc))
+
+      instance.scope { :foo }
+    end
+  end
+
+  describe '#set_property' do
+    before :each do
+      allow(index.class).to receive_messages :settings => [:morphology]
+    end
+
+    it 'saves other settings as index options' do
+      instance.set_property :field_weights => {:name => 10}
+
+      expect(index.options[:field_weights]).to eq({:name => 10})
+    end
+
+    context 'index settings' do
+      it "sets the provided setting" do
+        expect(index).to receive(:morphology=).with('stem_en')
+
+        instance.set_property :morphology => 'stem_en'
+      end
+    end
+  end
+
+  describe '#translate!' do
+    it "returns the block evaluated within the context of the interpreter" do
+      block = Proc.new {
+        __id__
+      }
+
+      interpreter = ThinkingSphinx::RealTime::Interpreter.new index, block
+      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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Scopes do
+  let(:model) {
+    Class.new do
+      include ThinkingSphinx::Scopes
+
+      def self.search(query = nil, options = {})
+        ThinkingSphinx::Search.new(query, options)
+      end
+    end
+  }
+
+  describe '#method_missing' do
+    before :each 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
+      expect(model.foo.class).to eq(ThinkingSphinx::Search)
+    end
+
+    it "passes block result to constructor" do
+      expect(model.foo.options[:with]).to eq({:foo => :bar})
+    end
+
+    it "passes non-scopes through to the standard method error call" do
+      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 }
+      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
+      expect(model.default_sphinx_scope).to eq(:foo)
+    end
+  end
+end