thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/active_record/database_adapters_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
+  let(:model) { double('model') }
+
+  describe '.adapter_for' do
+    it "returns a MysqlAdapter object for :mysql" do
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :mysql)
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to be_a(
+          ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
+        )
+    end
+
+    it "returns a PostgreSQLAdapter object for :postgresql" do
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :postgresql)
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to 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
+      allow(adapter_class).to receive_messages(:new => adapter_instance)
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to eq(adapter_instance)
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = nil
+    end
+
+    it "raises an exception for other responses" do
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :sqlite)
+
+      expect {
+        ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)
+      }.to raise_error(ThinkingSphinx::InvalidDatabaseAdapter)
+    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
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
+    end
+
+    it "translates a MySQL2 adapter" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
+    end
+
+    it "translates a normal PostgreSQL adapter" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
+    end
+
+    it "translates a JDBC MySQL adapter to MySQL" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmysql'})
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
+    end
+
+    it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcpostgresql'})
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
+    end
+
+    it "translates a JDBC adapter with MySQL connection string to MySQL" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
+    end
+
+    it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
+    end
+
+    it "returns other JDBC adapters without translation" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmssql'})
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq('jdbcmssql')
+    end
+
+    it "returns other unknown adapters without translation" do
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
+
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).
+        to eq('ActiveRecord::ConnectionAdapters::FooAdapter')
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/field_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Field do
+  let(:field)        { ThinkingSphinx::ActiveRecord::Field.new model, column }
+  let(:column)       { double('column', :__name => :title, :__stack => [],
+    :string? => false) }
+  let(:model)        { double('model') }
+
+  before :each do
+    allow(column).to receive_messages :to_a => [column]
+  end
+
+  describe '#columns' do
+    it 'returns the provided Column object' do
+      expect(field.columns).to eq([column])
+    end
+
+    it 'translates symbols to Column objects' do
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).with(:title).
+        and_return(column)
+
+      ThinkingSphinx::ActiveRecord::Field.new model, :title
+    end
+  end
+
+  describe '#file?' do
+    it "defaults to false" do
+      expect(field).not_to be_file
+    end
+
+    it "is true if file option is set" do
+      field = ThinkingSphinx::ActiveRecord::Field.new model, column,
+        :file => true
+      expect(field).to be_file
+    end
+  end
+
+  describe '#with_attribute?' do
+    it "defaults to false" do
+      expect(field).not_to be_with_attribute
+    end
+
+    it "is true if the field is sortable" do
+      field = ThinkingSphinx::ActiveRecord::Field.new model, column,
+        :sortable => true
+      expect(field).to be_with_attribute
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/filter_reflection_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::FilterReflection do
+  describe '.call' do
+    let(:reflection) { double('Reflection', :macro => :has_some,
+      :options => options, :active_record => double, :name => 'baz',
+      :foreign_type => :foo_type, :class => original_klass,
+      :build_join_constraint => nil) }
+    let(:options)    { {:polymorphic => true} }
+    let(:filtered_reflection) { double 'filtered reflection' }
+    let(:original_klass)      { double }
+    let(:subclass)            { double :include => true }
+
+    before :each do
+      allow(reflection.active_record).to receive_message_chain(:connection, :quote_column_name).
+        and_return('"foo_type"')
+
+      if ActiveRecord::VERSION::STRING.to_f < 5.2
+        allow(original_klass).to receive(:new).and_return(filtered_reflection)
+      else
+        allow(Class).to receive(:new).with(original_klass).and_return(subclass)
+        allow(subclass).to receive(:new).and_return(filtered_reflection)
+      end
+    end
+
+    class ArgumentsWrapper
+      attr_reader :macro, :name, :scope, :options, :parent
+
+      def initialize(*arguments)
+        if ActiveRecord::VERSION::STRING.to_f < 4.0
+          @macro, @name, @options, @parent = arguments
+        elsif ActiveRecord::VERSION::STRING.to_f < 4.2
+          @macro, @name, @scope, @options, @parent = arguments
+        else
+          @name, @scope, @options, @parent = arguments
+        end
+      end
+    end
+
+    def reflection_klass
+      ActiveRecord::VERSION::STRING.to_f < 5.2 ? original_klass : subclass
+    end
+
+    def expected_reflection_arguments
+      expect(reflection_klass).to receive(:new) do |*arguments|
+        yield ArgumentsWrapper.new(*arguments)
+      end
+    end
+
+    it "uses the existing reflection's macro" do
+      expect(reflection_klass).to receive(:new) do |macro, *args|
+        expect(macro).to eq(:has_some)
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end if ActiveRecord::VERSION::STRING.to_f < 4.2
+
+    it "uses the supplied name" do
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.name).to eq('foo_bar')
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "uses the existing reflection's parent" do
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.parent).to eq(reflection.active_record)
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "removes the polymorphic setting from the options" do
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:polymorphic]).to be_nil
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "adds the class name option" do
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:class_name]).to eq('Bar')
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "sets the foreign key if necessary" do
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:foreign_key]).to eq('baz_id')
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "respects supplied foreign keys" do
+      options[:foreign_key] = 'qux_id'
+
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:foreign_key]).to eq('qux_id')
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    if ActiveRecord::VERSION::STRING.to_f < 4.0
+      it "sets conditions if there are none" do
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq("::ts_join_alias::.\"foo_type\" = 'Bar'")
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+
+      it "appends to the conditions array" do
+        options[:conditions] = ['existing']
+
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq(['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"])
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+
+      it "extends the conditions hash" do
+        options[:conditions] = {:x => :y}
+
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq({:x => :y, :foo_type => 'Bar'})
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+
+      it "appends to the conditions string" do
+        options[:conditions] = 'existing'
+
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq("existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'")
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+    else
+      it "does not add a conditions option" do
+        expected_reflection_arguments do |wrapper|
+          expect(wrapper.options.keys).not_to include(:conditions)
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+    end
+
+    it "includes custom behaviour in the subclass" do
+      expect(subclass).to receive(:include).with(ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection::BuildJoinConstraint)
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end if ActiveRecord::VERSION::STRING.to_f > 5.1
+
+    it "includes custom behaviour in the subclass" do
+      allow(reflection).to receive(:respond_to?).with(:build_join_constraint).
+        and_return(false)
+
+      expect(subclass).to receive(:include).with(ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection::JoinScope)
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end if ActiveRecord::VERSION::STRING.to_f >= 6.0
+
+    it "returns the new reflection" do
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )).to eq(filtered_reflection)
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/index_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Index do
+  let(:index)        { ThinkingSphinx::ActiveRecord::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 :reference_name => :user }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+  end
+
+  describe '#append_source' do
+    let(:model)  { double('model', :primary_key => :id,
+      :table_exists? => true) }
+    let(:source) { double('source') }
+
+    before :each do
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
+      allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages :new => source
+      allow(config).to receive_messages :next_offset => 17
+    end
+
+    it "adds a source to the index" do
+      expect(index.sources).to receive(:<<).with(source)
+
+      index.append_source
+    end
+
+    it "creates the source with the index's offset" do
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
+        with(model, hash_including(:offset => 17)).and_return(source)
+
+      index.append_source
+    end
+
+    it "returns the new source" do
+      expect(index.append_source).to eq(source)
+    end
+
+    it "defaults to the model's primary key" do
+      allow(model).to receive_messages :primary_key => :sphinx_id
+
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
+        with(model, hash_including(:primary_key => :sphinx_id)).
+        and_return(source)
+
+      index.append_source
+    end
+
+    it "uses a custom column when set" do
+      allow(model).to receive_messages :primary_key => :sphinx_id
+
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
+        with(model, hash_including(:primary_key => :custom_sphinx_id)).
+        and_return(source)
+
+      index = ThinkingSphinx::ActiveRecord::Index.new:user,
+        :primary_key => :custom_sphinx_id
+      index.append_source
+    end
+
+    it "defaults to id if no primary key is set" do
+      allow(model).to receive_messages :primary_key => nil
+
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
+        with(model, hash_including(:primary_key => :id)).
+        and_return(source)
+
+      index.append_source
+    end
+  end
+
+  describe '#delta?' do
+    it "defaults to false" do
+      expect(index).not_to be_delta
+    end
+
+    it "reflects the delta? option" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
+      expect(index).to be_delta
+    end
+  end
+
+  describe '#delta_processor' do
+    it "creates an instance of the delta processor option" do
+      processor       = double('processor')
+      processor_class = double('processor class', :new => processor)
+      index = ThinkingSphinx::ActiveRecord::Index.new :user,
+        :delta_processor => processor_class
+
+      expect(index.delta_processor).to eq(processor)
+    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 '#interpret_definition!' do
+    let(:block) { double('block') }
+
+    before :each do
+      index.definition_block = block
+    end
+
+    it "interprets the definition block" do
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
+        with(index, block)
+
+      index.interpret_definition!
+    end
+
+    it "only interprets the definition block once" do
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
+        once
+
+      index.interpret_definition!
+      index.interpret_definition!
+    end
+  end
+
+  describe '#model' do
+    let(:model)  { double('model') }
+
+    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
+    context 'with a render' do
+      before :each do
+        allow(FileUtils).to receive_messages :mkdir_p => true
+      end
+
+      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 "uses the core suffix by default" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user
+      expect(index.name).to eq('user_core')
+    end
+
+    it "uses the delta suffix when delta? is true" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
+      expect(index.name).to eq('user_delta')
+    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
+end