thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/active_record/sql_source_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::SQLSource do
@@ -9,42 +11,80 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
   let(:db_config)  { {:host => 'localhost', :user => 'root',
     :database => 'default'} }
   let(:source)     { ThinkingSphinx::ActiveRecord::SQLSource.new(model,
-    :position => 3) }
+    :position => 3, :primary_key => model.primary_key || :id ) }
   let(:adapter)    { double('adapter') }
 
   before :each do
-    ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
-      stub!(:=== => true)
-    ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-      stub!(:adapter_for => adapter)
+    allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter).
+      to receive_messages(:=== => true)
+    allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+      to receive_messages(:adapter_for => adapter)
   end
 
   describe '#adapter' do
     it "returns a database adapter for the model" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        should_receive(:adapter_for).with(model).and_return(adapter)
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive(:adapter_for).with(model).and_return(adapter)
 
-      source.adapter.should == adapter
+      expect(source.adapter).to eq(adapter)
+    end
+  end
+
+  describe '#add_attribute' do
+    let(:attribute) { double('attribute', name: 'my_attribute') }
+
+    it "appends attributes to the collection" do
+      source.add_attribute attribute
+
+      expect(source.attributes.collect(&:name)).to include('my_attribute')
+    end
+
+    it "replaces attributes with the same name" do
+      source.add_attribute double('attribute', name: 'my_attribute')
+      source.add_attribute attribute
+
+      matching = source.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
+      source.add_field field
+
+      expect(source.fields.collect(&:name)).to include('my_field')
+    end
+
+    it "replaces fields with the same name" do
+      source.add_field double('field', name: 'my_field')
+      source.add_field field
+
+      matching = source.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
-      source.attributes.collect(&:name).should include('sphinx_internal_id')
+      expect(source.attributes.collect(&:name)).to include('sphinx_internal_id')
     end
 
     it "has the class name attribute by default" do
-      source.attributes.collect(&:name).should include('sphinx_internal_class')
+      expect(source.attributes.collect(&:name)).to include('sphinx_internal_class')
     end
 
     it "has the internal deleted attribute by default" do
-      source.attributes.collect(&:name).should include('sphinx_deleted')
+      expect(source.attributes.collect(&:name)).to include('sphinx_deleted')
     end
 
     it "marks the internal class attribute as a facet" do
-      source.attributes.detect { |attribute|
+      expect(source.attributes.detect { |attribute|
         attribute.name == 'sphinx_internal_class'
-      }.options[:facet].should be_true
+      }.options[:facet]).to be_truthy
     end
   end
 
@@ -53,27 +93,29 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
     let(:processor)       { double('processor') }
     let(:source)          {
       ThinkingSphinx::ActiveRecord::SQLSource.new model,
-        :delta_processor => processor_class
+        :delta_processor => processor_class,
+        :primary_key => model.primary_key || :id
     }
     let(:source_with_options)    {
       ThinkingSphinx::ActiveRecord::SQLSource.new model,
         :delta_processor => processor_class,
-        :delta_options   => { :opt_key => :opt_value }
+        :delta_options   => { :opt_key => :opt_value },
+        :primary_key => model.primary_key || :id
     }
 
     it "loads the processor with the adapter" do
-      processor_class.should_receive(:try).with(:new, adapter, {}).
+      expect(processor_class).to receive(:try).with(:new, adapter, {}).
         and_return processor
 
       source.delta_processor
     end
 
     it "returns the given processor" do
-      source.delta_processor.should == processor
+      expect(source.delta_processor).to eq(processor)
     end
 
     it "passes given options to the processor" do
-      processor_class.should_receive(:try).with(:new, adapter, {:opt_key => :opt_value})
+      expect(processor_class).to receive(:try).with(:new, adapter, {:opt_key => :opt_value})
       source_with_options.delta_processor
     end
   end
@@ -81,77 +123,99 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
   describe '#delta?' do
     it "returns the given delta setting" do
       source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
-        :delta? => true
+        :delta? => true,
+        :primary_key => model.primary_key || :id
 
-      source.should be_a_delta
+      expect(source).to be_a_delta
     end
   end
 
   describe '#disable_range?' do
     it "returns the given range setting" do
       source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
-        :disable_range? => true
+        :disable_range? => true,
+        :primary_key => model.primary_key || :id
 
-      source.disable_range?.should be_true
+      expect(source.disable_range?).to be_truthy
     end
   end
 
   describe '#fields' do
     it "has the internal class field by default" do
-      source.fields.collect(&:name).
-        should include('sphinx_internal_class_name')
+      expect(source.fields.collect(&:name)).
+        to include('sphinx_internal_class_name')
     end
 
     it "sets the sphinx class field to use a string of the class name" do
-      source.fields.detect { |field|
+      expect(source.fields.detect { |field|
         field.name == 'sphinx_internal_class_name'
-      }.columns.first.__name.should == "'User'"
+      }.columns.first.__name).to eq("'User'")
     end
 
     it "uses the inheritance column if it exists for the sphinx class field" do
-      adapter.stub :quoted_table_name => '"users"', :quote => '"type"'
-      adapter.stub(:convert_blank) { |clause, default|
+      allow(adapter).to receive_messages :quoted_table_name => '"users"', :quote => '"type"'
+      allow(adapter).to receive(:convert_blank) { |clause, default|
         "coalesce(nullif(#{clause}, ''), #{default})"
       }
-      model.stub :column_names => ['type'], :sti_name => 'User'
+      allow(model).to receive_messages :column_names => ['type'], :sti_name => 'User'
 
-      source.fields.detect { |field|
+      expect(source.fields.detect { |field|
         field.name == 'sphinx_internal_class_name'
-      }.columns.first.__name.
-        should == "coalesce(nullif(\"users\".\"type\", ''), 'User')"
+      }.columns.first.__name).
+        to eq("coalesce(nullif(\"users\".\"type\", ''), 'User')")
     end
   end
 
   describe '#name' do
     it "defaults to the model name downcased with the given position" do
-      source.name.should == 'user_3'
+      expect(source.name).to eq('user_3')
     end
 
     it "allows for custom names, but adds the position suffix" do
       source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
-        :name => 'people', :position => 2
+        :name => 'people', :position => 2, :primary_key => model.primary_key || :id
 
-      source.name.should == 'people_2'
+      expect(source.name).to eq('people_2')
     end
   end
 
   describe '#offset' do
     it "returns the given offset" do
-      source = ThinkingSphinx::ActiveRecord::SQLSource.new model, :offset => 12
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :offset => 12, :primary_key => model.primary_key || :id
 
-      source.offset.should == 12
+      expect(source.offset).to eq(12)
     end
   end
 
   describe '#options' do
     it "defaults to having utf8? set to false" do
-      source.options[:utf8?].should be_false
+      expect(source.options[:utf8?]).to be_falsey
     end
 
     it "sets utf8? to true if the database encoding is utf8" do
       db_config[:encoding] = 'utf8'
 
-      source.options[:utf8?].should be_true
+      expect(source.options[:utf8?]).to be_truthy
+    end
+
+    it "sets utf8? to true if the database encoding starts with utf8" do
+      db_config[:encoding] = 'utf8mb4'
+
+      expect(source.options[:utf8?]).to be_truthy
+    end
+
+    describe "#primary key" do
+      let(:model)  { double('model', :connection => connection,
+                           :name => 'User', :column_names => [], :inheritance_column => 'type') }
+      let(:source) { ThinkingSphinx::ActiveRecord::SQLSource.new(model,
+                           :position => 3, :primary_key => :custom_key) }
+      let(:template) { ThinkingSphinx::ActiveRecord::SQLSource::Template.new(source) }
+
+      it 'template should allow primary key from options' do
+        template.apply
+        template.source.attributes.collect(&:columns) == :custom_key
+      end
     end
   end
 
@@ -164,42 +228,34 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
     let(:template)  { double('template', :apply => true) }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::SQLBuilder.stub! :new => builder
-      ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter.stub :new => presenter
-      ThinkingSphinx::ActiveRecord::SQLSource::Template.stub :new => template
-      ThinkingSphinx::Configuration.stub :instance => config
+      allow(ThinkingSphinx::ActiveRecord::SQLBuilder).to receive_messages :new => builder
+      allow(ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter).to receive_messages :new => presenter
+      allow(ThinkingSphinx::ActiveRecord::SQLSource::Template).to receive_messages :new => template
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
     end
 
     it "uses the builder's sql_query value" do
-      builder.stub! :sql_query => 'select * from table'
+      allow(builder).to receive_messages :sql_query => 'select * from table'
 
       source.render
 
-      source.sql_query.should == 'select * from table'
+      expect(source.sql_query).to eq('select * from table')
     end
 
     it "uses the builder's sql_query_range value" do
-      builder.stub! :sql_query_range => 'select 0, 10 from table'
+      allow(builder).to receive_messages :sql_query_range => 'select 0, 10 from table'
 
       source.render
 
-      source.sql_query_range.should == 'select 0, 10 from table'
+      expect(source.sql_query_range).to eq('select 0, 10 from table')
     end
 
     it "appends the builder's sql_query_pre value" do
-      builder.stub! :sql_query_pre => ['Change Setting']
-
-      source.render
-
-      source.sql_query_pre.should == ['Change Setting']
-    end
-
-    it "appends the builder's sql_query_post_index value" do
-      builder.stub! :sql_query_post_index => ['RESET DELTAS']
+      allow(builder).to receive_messages :sql_query_pre => ['Change Setting']
 
       source.render
 
-      source.sql_query_post_index.should include('RESET DELTAS')
+      expect(source.sql_query_pre).to eq(['Change Setting'])
     end
 
     it "adds fields with attributes to sql_field_string" do
@@ -208,7 +264,7 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
 
       source.render
 
-      source.sql_field_string.should include('title')
+      expect(source.sql_field_string).to include('title')
     end
 
     it "adds any joined or file fields" do
@@ -217,7 +273,7 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
 
       source.render
 
-      source.sql_file_field.should include('title')
+      expect(source.sql_file_field).to include('title')
     end
 
     it "adds wordcounted fields to sql_field_str2wordcount" do
@@ -226,11 +282,11 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
 
       source.render
 
-      source.sql_field_str2wordcount.should include('title')
+      expect(source.sql_field_str2wordcount).to include('title')
     end
 
     it "adds any joined fields" do
-      ThinkingSphinx::ActiveRecord::PropertyQuery.stub(
+      allow(ThinkingSphinx::ActiveRecord::PropertyQuery).to receive_messages(
         :new => double(:to_s => 'query for title')
       )
       source.fields << double('field', :name => 'title',
@@ -239,99 +295,99 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
 
       source.render
 
-      source.sql_joined_field.should include('query for title')
+      expect(source.sql_joined_field).to include('query for title')
     end
 
     it "adds integer attributes to sql_attr_uint" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'count', :collection_type => :uint
+      allow(presenter).to receive_messages :declaration => 'count', :collection_type => :uint
 
       source.render
 
-      source.sql_attr_uint.should include('count')
+      expect(source.sql_attr_uint).to include('count')
     end
 
     it "adds boolean attributes to sql_attr_bool" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'published', :collection_type => :bool
+      allow(presenter).to receive_messages :declaration => 'published', :collection_type => :bool
 
       source.render
 
-      source.sql_attr_bool.should include('published')
+      expect(source.sql_attr_bool).to include('published')
     end
 
     it "adds string attributes to sql_attr_string" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'name', :collection_type => :string
+      allow(presenter).to receive_messages :declaration => 'name', :collection_type => :string
 
       source.render
 
-      source.sql_attr_string.should include('name')
+      expect(source.sql_attr_string).to include('name')
     end
 
-    it "adds timestamp attributes to sql_attr_timestamp" do
+    it "adds timestamp attributes to sql_attr_uint" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'created_at',
-        :collection_type => :timestamp
+      allow(presenter).to receive_messages :declaration => 'created_at',
+        :collection_type => :uint
 
       source.render
 
-      source.sql_attr_timestamp.should include('created_at')
+      expect(source.sql_attr_uint).to include('created_at')
     end
 
     it "adds float attributes to sql_attr_float" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'rating', :collection_type => :float
+      allow(presenter).to receive_messages :declaration => 'rating', :collection_type => :float
 
       source.render
 
-      source.sql_attr_float.should include('rating')
+      expect(source.sql_attr_float).to include('rating')
     end
 
     it "adds bigint attributes to sql_attr_bigint" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'super_id', :collection_type => :bigint
+      allow(presenter).to receive_messages :declaration => 'super_id', :collection_type => :bigint
 
       source.render
 
-      source.sql_attr_bigint.should include('super_id')
+      expect(source.sql_attr_bigint).to include('super_id')
     end
 
     it "adds ordinal strings to sql_attr_str2ordinal" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'name', :collection_type => :str2ordinal
+      allow(presenter).to receive_messages :declaration => 'name', :collection_type => :str2ordinal
 
       source.render
 
-      source.sql_attr_str2ordinal.should include('name')
+      expect(source.sql_attr_str2ordinal).to include('name')
     end
 
     it "adds multi-value attributes to sql_attr_multi" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'uint tag_ids from field',
+      allow(presenter).to receive_messages :declaration => 'uint tag_ids from field',
         :collection_type => :multi
 
       source.render
 
-      source.sql_attr_multi.should include('uint tag_ids from field')
+      expect(source.sql_attr_multi).to include('uint tag_ids from field')
     end
 
     it "adds word count attributes to sql_attr_str2wordcount" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'name', :collection_type => :str2wordcount
+      allow(presenter).to receive_messages :declaration => 'name', :collection_type => :str2wordcount
 
       source.render
 
-      source.sql_attr_str2wordcount.should include('name')
+      expect(source.sql_attr_str2wordcount).to include('name')
     end
 
     it "adds json attributes to sql_attr_json" do
       source.attributes << double('attribute')
-      presenter.stub :declaration => 'json', :collection_type => :json
+      allow(presenter).to receive_messages :declaration => 'json', :collection_type => :json
 
       source.render
 
-      source.sql_attr_json.should include('json')
+      expect(source.sql_attr_json).to include('json')
     end
 
     it "adds relevant settings from thinking_sphinx.yml" do
@@ -340,7 +396,7 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
 
       source.render
 
-      source.mysql_ssl_cert.should == 'foo.cert'
+      expect(source.mysql_ssl_cert).to eq('foo.cert')
     end
   end
 
@@ -348,84 +404,104 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
     it "sets the sql_host setting from the model's database settings" do
       source.set_database_settings :host => '12.34.56.78'
 
-      source.sql_host.should == '12.34.56.78'
+      expect(source.sql_host).to eq('12.34.56.78')
     end
 
     it "defaults sql_host to localhost if the model has no host" do
       source.set_database_settings :host => nil
 
-      source.sql_host.should == 'localhost'
+      expect(source.sql_host).to eq('localhost')
     end
 
     it "sets the sql_user setting from the model's database settings" do
       source.set_database_settings :username => 'pat'
 
-      source.sql_user.should == 'pat'
+      expect(source.sql_user).to eq('pat')
     end
 
     it "uses the user setting if username is not set in the model" do
       source.set_database_settings :username => nil, :user => 'pat'
 
-      source.sql_user.should == 'pat'
+      expect(source.sql_user).to eq('pat')
     end
 
     it "sets the sql_pass setting from the model's database settings" do
       source.set_database_settings :password => 'swordfish'
 
-      source.sql_pass.should == 'swordfish'
+      expect(source.sql_pass).to eq('swordfish')
     end
 
     it "escapes hashes in the password for sql_pass" do
       source.set_database_settings :password => 'sword#fish'
 
-      source.sql_pass.should == 'sword\#fish'
+      expect(source.sql_pass).to eq('sword\#fish')
     end
 
     it "sets the sql_db setting from the model's database settings" do
       source.set_database_settings :database => 'rails_app'
 
-      source.sql_db.should == 'rails_app'
+      expect(source.sql_db).to eq('rails_app')
     end
 
     it "sets the sql_port setting from the model's database settings" do
       source.set_database_settings :port => 5432
 
-      source.sql_port.should == 5432
+      expect(source.sql_port).to eq(5432)
     end
 
     it "sets the sql_sock setting from the model's database settings" do
       source.set_database_settings :socket => '/unix/socket'
 
-      source.sql_sock.should == '/unix/socket'
+      expect(source.sql_sock).to eq('/unix/socket')
+    end
+
+    it "sets the mysql_ssl_cert from the model's database settings" do
+      source.set_database_settings :sslcert => '/path/to/cert.pem'
+
+      expect(source.mysql_ssl_cert).to  eq '/path/to/cert.pem'
+    end
+
+    it "sets the mysql_ssl_key from the model's database settings" do
+      source.set_database_settings :sslkey => '/path/to/key.pem'
+
+      expect(source.mysql_ssl_key).to  eq '/path/to/key.pem'
+    end
+
+    it "sets the mysql_ssl_ca from the model's database settings" do
+      source.set_database_settings :sslca => '/path/to/ca.pem'
+
+      expect(source.mysql_ssl_ca).to  eq '/path/to/ca.pem'
     end
   end
 
   describe '#type' do
     it "is mysql when using the MySQL Adapter" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
-        stub!(:=== => true)
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
-        stub!(:=== => false)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter).
+        to receive_messages(:=== => true)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter).
+        to receive_messages(:=== => false)
 
-      source.type.should == 'mysql'
+      expect(source.type).to eq('mysql')
     end
 
     it "is pgsql when using the PostgreSQL Adapter" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
-        stub!(:=== => false)
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
-        stub!(:=== => true)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter).
+        to receive_messages(:=== => false)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter).
+        to receive_messages(:=== => true)
 
-      source.type.should == 'pgsql'
+      expect(source.type).to eq('pgsql')
     end
 
     it "raises an exception for any other adapter" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
-        stub!(:=== => false)
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
-        stub!(:=== => false)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter).
+        to receive_messages(:=== => false)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter).
+        to receive_messages(:=== => false)
 
-      lambda { source.type }.should raise_error
+      expect { source.type }.to raise_error(
+        ThinkingSphinx::UnknownDatabaseAdapter
+      )
     end
   end
 end

data/spec/thinking_sphinx/attribute_types_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::AttributeTypes do
+  let(:configuration) {
+    double('configuration', :configuration_file => 'sphinx.conf')
+  }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive(:instance).
+      and_return(configuration)
+
+    allow(File).to receive(:exist?).with('sphinx.conf').and_return(true)
+    allow(File).to receive(:read).with('sphinx.conf').and_return(<<-CONF)
+index plain_index
+{
+  source = plain_source
+}
+
+source plain_source
+{
+  type = mysql
+  sql_attr_uint = customer_id
+  sql_attr_float = price
+  sql_attr_multi = uint comment_ids from field
+}
+
+index rt_index
+{
+  type = rt
+  rt_attr_uint = user_id
+  rt_attr_multi = comment_ids
+}
+    CONF
+  end
+
+  it 'returns an empty hash if no configuration file exists' do
+    allow(File).to receive(:exist?).with('sphinx.conf').and_return(false)
+
+    expect(ThinkingSphinx::AttributeTypes.new.call).to eq({})
+  end
+
+  it 'returns all known attributes' do
+    expect(ThinkingSphinx::AttributeTypes.new.call).to eq({
+      'customer_id' => [:uint],
+      'price'       => [:float],
+      'comment_ids' => [:uint],
+      'user_id'     => [:uint]
+    })
+  end
+end