thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/active_record/interpreter_spec.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Interpreter do
+  let(:instance) {
+    ThinkingSphinx::ActiveRecord::Interpreter.new index, block
+  }
+  let(:model)   { double('model') }
+  let(:index)   { double('index', :append_source => source, :options => {}) }
+  let(:source)  {
+    Struct.new(:attributes, :fields, :associations, :groupings, :conditions).
+      new([], [], [], [], [])
+  }
+  let(:block)   { Proc.new { } }
+
+  before :each do
+    allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages(
+      :new => source
+    )
+
+    allow(source).to receive_messages(
+      :model => model, :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::ActiveRecord::Interpreter).to receive(:new).
+        with(index, block).and_return(instance)
+
+      ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
+    end
+
+    it "calls translate! on the instance" do
+      allow(ThinkingSphinx::ActiveRecord::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
+
+      ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
+    end
+  end
+
+  describe '#group_by' do
+    it "adds a source to the index" do
+      expect(index).to receive(:append_source).and_return(source)
+
+      instance.group_by 'lat'
+    end
+
+    it "only adds a single source for the given context" do
+      expect(index).to receive(:append_source).once.and_return(source)
+
+      instance.group_by 'lat'
+      instance.group_by 'lng'
+    end
+
+    it "appends a new grouping statement to the source" do
+      instance.group_by 'lat'
+
+      expect(source.groupings).to include('lat')
+    end
+  end
+
+  describe '#has' do
+    let(:column)    { double('column') }
+    let(:attribute) { double('attribute') }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Attribute).to receive_messages :new => attribute
+    end
+
+    it "adds a source to the index" do
+      expect(index).to receive(:append_source).and_return(source)
+
+      instance.has column
+    end
+
+    it "only adds a single source for the given context" do
+      expect(index).to receive(:append_source).once.and_return(source)
+
+      instance.has column
+      instance.has column
+    end
+
+    it "creates a new attribute with the provided column" do
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
+        with(model, column, {}).and_return(attribute)
+
+      instance.has column
+    end
+
+    it "passes through options to the attribute" do
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
+        with(model, column, { :as => :other_name }).and_return(attribute)
+
+      instance.has column, :as => :other_name
+    end
+
+    it "adds an attribute to the source" do
+      expect(source).to receive(:add_attribute).with(attribute)
+
+      instance.has column
+    end
+
+    it "adds multiple attributes when passed multiple columns" do
+      expect(source).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::ActiveRecord::Field).to receive_messages :new => field
+    end
+
+    it "adds a source to the index" do
+      expect(index).to receive(:append_source).and_return(source)
+
+      instance.indexes column
+    end
+
+    it "only adds a single source for the given context" do
+      expect(index).to receive(:append_source).once.and_return(source)
+
+      instance.indexes column
+      instance.indexes column
+    end
+
+    it "creates a new field with the provided column" do
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
+        with(model, column, {}).and_return(field)
+
+      instance.indexes column
+    end
+
+    it "passes through options to the field" do
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
+        with(model, column, { :as => :other_name }).and_return(field)
+
+      instance.indexes column, :as => :other_name
+    end
+
+    it "adds a field to the source" do
+      expect(source).to receive(:add_field).with(field)
+
+      instance.indexes column
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      expect(source).to receive(:add_field).with(field).twice
+
+      instance.indexes column, column
+    end
+  end
+
+  describe '#join' do
+    let(:column)      { double('column') }
+    let(:association) { double('association') }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Association).to receive_messages :new => association
+    end
+
+    it "adds a source to the index" do
+      expect(index).to receive(:append_source).and_return(source)
+
+      instance.join column
+    end
+
+    it "only adds a single source for the given context" do
+      expect(index).to receive(:append_source).once.and_return(source)
+
+      instance.join column
+      instance.join column
+    end
+
+    it "creates a new association with the provided column" do
+      expect(ThinkingSphinx::ActiveRecord::Association).to receive(:new).
+        with(column).and_return(association)
+
+      instance.join column
+    end
+
+    it "adds an association to the source" do
+      instance.join column
+
+      expect(source.associations).to include(association)
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      instance.join column, column
+
+      expect(source.associations.select { |saved_assoc|
+        saved_assoc == association
+      }.length).to eq(2)
+    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 '#set_database' do
+    before :each do
+      allow(source).to receive_messages :set_database_settings => true
+
+      stub_const 'ActiveRecord::Base',
+        double(:configurations => {'other' => {'baz' => 'qux'}})
+    end
+
+    it "sends through a hash if provided" do
+      expect(source).to receive(:set_database_settings).with({ :foo => :bar })
+
+      instance.set_database :foo => :bar
+    end
+
+    it "finds the environment settings if given a string key" do
+      expect(source).to receive(:set_database_settings).with({ :baz => 'qux' })
+
+      instance.set_database 'other'
+    end
+
+    it "finds the environment settings if given a symbol key" do
+      expect(source).to receive(:set_database_settings).with({ :baz => 'qux' })
+
+      instance.set_database :other
+    end
+  end
+
+  describe '#set_property' do
+    before :each do
+      allow(index.class).to receive_messages  :settings => [:morphology]
+      allow(source.class).to receive_messages :settings => [:mysql_ssl_cert]
+    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
+
+    context 'source settings' do
+      before :each do
+        allow(source).to receive_messages :mysql_ssl_cert= => true
+      end
+
+      it "adds a source to the index" do
+        expect(index).to receive(:append_source).and_return(source)
+
+        instance.set_property :mysql_ssl_cert => 'private.cert'
+      end
+
+      it "only adds a single source for the given context" do
+        expect(index).to receive(:append_source).once.and_return(source)
+
+        instance.set_property :mysql_ssl_cert => 'private.cert'
+        instance.set_property :mysql_ssl_cert => 'private.cert'
+      end
+
+      it "sets the provided setting" do
+        expect(source).to receive(:mysql_ssl_cert=).with('private.cert')
+
+        instance.set_property :mysql_ssl_cert => 'private.cert'
+      end
+    end
+  end
+
+  describe '#translate!' do
+    it "returns the block evaluated within the context of the interpreter" do
+      block = Proc.new {
+        __id__
+      }
+
+      interpreter = ThinkingSphinx::ActiveRecord::Interpreter.new index, block
+      expect(interpreter.translate!).
+        to eq(interpreter.__id__)
+    end
+  end
+
+  describe '#where' do
+    it "adds a source to the index" do
+      expect(index).to receive(:append_source).and_return(source)
+
+      instance.where 'id > 100'
+    end
+
+    it "only adds a single source for the given context" do
+      expect(index).to receive(:append_source).once.and_return(source)
+
+      instance.where 'id > 100'
+      instance.where 'id < 150'
+    end
+
+    it "appends a new grouping statement to the source" do
+      instance.where 'id > 100'
+
+      expect(source.conditions).to include('id > 100')
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Polymorpher do
+  let(:polymorpher) { ThinkingSphinx::ActiveRecord::Polymorpher.new source,
+    column, class_names }
+  let(:source)      { double 'Source', :model => outer, :fields => [field],
+    :attributes => [attribute] }
+  let(:column)      { double 'Column', :__name => :foo, :__stack => [:a, :b],
+    :__path => [:a, :b, :foo] }
+  let(:class_names) { %w( Article Animal ) }
+  let(:field)       { double :rebase => true }
+  let(:attribute)   { double :rebase => true }
+  let(:outer)       { double(
+    :reflect_on_association => double(:klass => inner)) }
+  let(:inner)       { double(
+    :reflect_on_association => double(:klass => model)) }
+  let(:model)       { double 'Model', :reflections => {},
+    :reflect_on_association => reflection }
+  let(:reflection)  { double 'Polymorphic Reflection' }
+
+  describe '#morph!' do
+    let(:article_reflection) { double 'Article Reflection' }
+    let(:animal_reflection)  { double 'Animal Reflection' }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
+        and_return(article_reflection, animal_reflection)
+
+      allow(model).to receive(:reflect_on_association) do |name|
+        name == :foo ? reflection : nil
+      end
+
+      if ActiveRecord::Reflection.respond_to?(:add_reflection)
+        allow(ActiveRecord::Reflection).to receive :add_reflection
+      end
+    end
+
+    it "creates a new reflection for each class" do
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).and_call_original
+
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
+        with(reflection, :foo_article, 'Article').
+        and_return(article_reflection)
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
+        with(reflection, :foo_animal, 'Animal').
+        and_return(animal_reflection)
+
+      polymorpher.morph!
+    end
+
+    it "adds the new reflections to the end-of-stack model" do
+      if ActiveRecord::Reflection.respond_to?(:add_reflection)
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
+          with(model, :foo_article, article_reflection)
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
+          with(model, :foo_animal, animal_reflection)
+
+        polymorpher.morph!
+      else
+        polymorpher.morph!
+
+        expect(model.reflections[:foo_article]).to eq(article_reflection)
+        expect(model.reflections[:foo_animal]).to eq(animal_reflection)
+      end
+    end
+
+    it "rebases each field" do
+      expect(field).to receive(:rebase).with([:a, :b, :foo],
+        :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
+
+      polymorpher.morph!
+    end
+
+    it "rebases each attribute" do
+      expect(attribute).to receive(:rebase).with([:a, :b, :foo],
+        :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
+
+      polymorpher.morph!
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/property_sql_presenter_spec.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
+  let(:adapter)      { double 'adapter' }
+  let(:associations) { double 'associations', :alias_for => 'articles' }
+  let(:model)        { double :column_names => ['title', 'created_at'] }
+  let(:path)         { double :aggregate? => false, :model => model }
+
+  before :each do
+    allow(adapter).to receive(:quote) { |column| column }
+
+    stub_const 'Joiner::Path', double(:new => path)
+  end
+
+  context 'with a field' do
+    let(:presenter) {
+      ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
+        field, adapter, associations
+      )
+    }
+    let(:field)     { double('field', :name => 'title', :columns => [column],
+      :type => nil, :multi? => false, :source_type => nil, :model => double) }
+    let(:column)    { double('column', :string? => false, :__stack => [],
+      :__name => 'title') }
+
+    describe '#to_group' do
+      it "returns the column name as a string" do
+        expect(presenter.to_group).to eq('articles.title')
+      end
+
+      it "gets the column's table alias from the associations object" do
+        allow(column).to receive_messages(:__stack => [:users, :posts])
+
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
+          and_return('posts')
+
+        presenter.to_group
+      end
+
+      it "returns nil if the property is an aggregate" do
+        allow(path).to receive_messages :aggregate? => true
+
+        expect(presenter.to_group).to be_nil
+      end
+
+      it "returns nil if the field is sourced via a separate query" do
+        allow(field).to receive_messages :source_type => 'query'
+
+        expect(presenter.to_group).to be_nil
+      end
+    end
+
+    describe '#to_select' do
+      it "returns the column name as a string" do
+        expect(presenter.to_select).to eq('articles.title AS title')
+      end
+
+      it "gets the column's table alias from the associations object" do
+        allow(column).to receive_messages(:__stack => [:users, :posts])
+
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
+          and_return('posts')
+
+        presenter.to_select
+      end
+
+      it "returns the column name with an alias when provided" do
+        allow(field).to receive_messages(:name => :subject)
+
+        expect(presenter.to_select).to eq('articles.title AS subject')
+      end
+
+      it "groups and concatenates aggregated columns" do
+        allow(adapter).to receive :group_concatenate do |clause, separator|
+          "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
+        end
+
+        allow(path).to receive_messages :aggregate? => true
+
+        expect(presenter.to_select).
+          to eq("GROUP_CONCAT(articles.title SEPARATOR ' ') AS title")
+      end
+
+      it "concatenates multiple columns" do
+        allow(adapter).to receive :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+
+        allow(field).to receive_messages(:columns => [column, column])
+
+        expect(presenter.to_select).
+          to eq("CONCAT_WS(' ', articles.title, articles.title) AS title")
+      end
+
+      it "does not include columns that don't exist" do
+        allow(adapter).to receive :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+
+        allow(field).to receive_messages(:columns => [column, double('column', :string? => false,
+          :__stack => [], :__name => 'body')])
+
+        expect(presenter.to_select).
+          to eq("CONCAT_WS(' ', articles.title) AS title")
+      end
+
+      it "returns nil for query sourced fields" do
+        allow(field).to receive_messages :source_type => :query
+
+        expect(presenter.to_select).to be_nil
+      end
+
+      it "returns nil for ranged query sourced fields" do
+        allow(field).to receive_messages :source_type => :ranged_query
+
+        expect(presenter.to_select).to be_nil
+      end
+    end
+  end
+
+  context 'with an attribute' do
+    let(:presenter) {
+      ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
+        attribute, adapter, associations
+      )
+    }
+    let(:attribute) { double('attribute', :name => 'created_at',
+      :columns => [column], :type => :integer, :multi? => false,
+      :source_type => nil, :model => double) }
+    let(:column)    { double('column', :string? => false, :__stack => [],
+      :__name => 'created_at') }
+
+    before :each do
+      allow(adapter).to receive :cast_to_timestamp do |clause|
+        "UNIX_TIMESTAMP(#{clause})"
+      end
+    end
+
+    describe '#to_group' do
+      it "returns the column name as a string" do
+        expect(presenter.to_group).to eq('articles.created_at')
+      end
+
+      it "gets the column's table alias from the associations object" do
+        allow(column).to receive_messages(:__stack => [:users, :posts])
+
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
+          and_return('posts')
+
+        presenter.to_group
+      end
+
+      it "returns nil if the column is a string" do
+        allow(column).to receive_messages(:string? => true)
+
+        expect(presenter.to_group).to be_nil
+      end
+
+      it "returns nil if the property is an aggregate" do
+        allow(path).to receive_messages :aggregate? => true
+
+        expect(presenter.to_group).to be_nil
+      end
+
+      it "returns nil if the attribute is sourced via a separate query" do
+        allow(attribute).to receive_messages :source_type => 'query'
+
+        expect(presenter.to_group).to be_nil
+      end
+    end
+
+    describe '#to_select' do
+      it "returns the column name as a string" do
+        expect(presenter.to_select).to eq('articles.created_at AS created_at')
+      end
+
+      it "gets the column's table alias from the associations object" do
+        allow(column).to receive_messages(:__stack => [:users, :posts])
+
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
+          and_return('posts')
+
+        presenter.to_select
+      end
+
+      it "returns the column name with an alias when provided" do
+        allow(attribute).to receive_messages(:name => :creation_timestamp)
+
+        expect(presenter.to_select).
+          to eq('articles.created_at AS creation_timestamp')
+      end
+
+      it "ensures datetime attributes are converted to timestamps" do
+        allow(attribute).to receive_messages :type => :timestamp
+
+        expect(presenter.to_select).
+          to eq('UNIX_TIMESTAMP(articles.created_at) AS created_at')
+      end
+
+      it "does not include columns that don't exist" do
+        allow(adapter).to receive :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+        allow(adapter).to receive :cast_to_string do |clause|
+          "CAST(#{clause} AS varchar)"
+        end
+
+        allow(attribute).to receive_messages(:columns => [column, double('column',
+          :string? => false, :__stack => [], :__name => 'updated_at')])
+
+        expect(presenter.to_select).to eq("CONCAT_WS(',', CAST(articles.created_at AS varchar)) AS created_at")
+      end
+
+      it "casts and concatenates multiple columns for attributes" do
+        allow(adapter).to receive :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+        allow(adapter).to receive :cast_to_string do |clause|
+          "CAST(#{clause} AS varchar)"
+        end
+
+        allow(attribute).to receive_messages(:columns => [column, column])
+
+        expect(presenter.to_select).to eq("CONCAT_WS(',', CAST(articles.created_at AS varchar), CAST(articles.created_at AS varchar)) AS created_at")
+      end
+
+      it "double-casts and concatenates multiple columns for timestamp attributes" do
+        allow(adapter).to receive :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+        allow(adapter).to receive :cast_to_string do |clause|
+          "CAST(#{clause} AS varchar)"
+        end
+
+        allow(attribute).to receive_messages :columns => [column, column], :type => :timestamp
+
+        expect(presenter.to_select).to eq("CONCAT_WS(',', CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar), CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar)) AS created_at")
+      end
+
+      it "does not split attribute clause for timestamp casting if it looks like a function call" do
+        allow(column).to receive_messages :__name => "COALESCE(articles.updated_at, articles.created_at)", :string? => true
+
+        allow(attribute).to receive_messages :name => 'mod_date', :columns => [column],
+          :type => :timestamp
+
+        expect(presenter.to_select).to eq("UNIX_TIMESTAMP(COALESCE(articles.updated_at, articles.created_at)) AS mod_date")
+      end
+
+      it "returns nil for query sourced attributes" do
+        allow(attribute).to receive_messages :source_type => :query
+
+        expect(presenter.to_select).to be_nil
+      end
+
+      it "returns nil for ranged query sourced attributes" do
+        allow(attribute).to receive_messages :source_type => :ranged_query
+
+        expect(presenter.to_select).to be_nil
+      end
+    end
+  end
+end