thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/active_record/field_spec.rb

@@ -0,0 +1,36 @@
+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
+    column.stub! :to_a => [column]
+  end
+
+  describe '#file?' do
+    it "defaults to false" do
+      field.should_not be_file
+    end
+
+    it "is true if file option is set" do
+      field = ThinkingSphinx::ActiveRecord::Field.new model, column,
+        :file => true
+      field.should be_file
+    end
+  end
+
+  describe '#with_attribute?' do
+    it "defaults to false" do
+      field.should_not be_with_attribute
+    end
+
+    it "is true if the field is sortable" do
+      field = ThinkingSphinx::ActiveRecord::Field.new model, column,
+        :sortable => true
+      field.should be_with_attribute
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/index_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Index do
+  let(:index)        { ThinkingSphinx::ActiveRecord::Index.new :user }
+  let(:indices_path) { double('indices path', :join => '') }
+  let(:config)       { double('config', :settings => {},
+    :indices_location => indices_path, :next_offset => 8) }
+
+  before :each do
+    ThinkingSphinx::Configuration.stub :instance => config
+  end
+
+  describe '#append_source' do
+    let(:model)  { double('model', :primary_key => :id) }
+    let(:source) { double('source') }
+
+    before :each do
+      ActiveSupport::Inflector.stub(:constantize => model)
+      ThinkingSphinx::ActiveRecord::SQLSource.stub :new => source
+      config.stub :next_offset => 17
+    end
+
+    it "adds a source to the index" do
+      index.sources.should_receive(:<<).with(source)
+
+      index.append_source
+    end
+
+    it "creates the source with the index's offset" do
+      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+        with(model, hash_including(:offset => 17)).and_return(source)
+
+      index.append_source
+    end
+
+    it "returns the new source" do
+      index.append_source.should == source
+    end
+
+    it "defaults to the model's primary key" do
+      model.stub :primary_key => :sphinx_id
+
+      ThinkingSphinx::ActiveRecord::SQLSource.should_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
+      model.stub :primary_key => :sphinx_id
+
+      ThinkingSphinx::ActiveRecord::SQLSource.should_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
+      model.stub :primary_key => nil
+
+      ThinkingSphinx::ActiveRecord::SQLSource.should_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
+      index.should_not be_delta
+    end
+
+    it "reflects the delta? option" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
+      index.should 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
+
+      index.delta_processor.should == processor
+    end
+  end
+
+  describe '#document_id_for_key' do
+    it "calculates the document id based on offset and number of indices" do
+      config.stub_chain(:indices, :count).and_return(5)
+      config.stub :next_offset => 7
+
+      index.document_id_for_key(123).should == 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
+      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:translate!).
+        with(index, block)
+
+      index.interpret_definition!
+    end
+
+    it "only interprets the definition block once" do
+      ThinkingSphinx::ActiveRecord::Interpreter.should_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
+      ActiveSupport::Inflector.stub(:constantize => model)
+
+      index.model.should == model
+    end
+
+    it "memoizes the result" do
+      ActiveSupport::Inflector.should_receive(:constantize).with('User').once.
+        and_return(model)
+
+      index.model
+      index.model
+    end
+  end
+
+  describe '#morphology' do
+    context 'with a render' do
+      it "defaults to nil" do
+        begin
+          index.render
+        rescue Riddle::Configuration::ConfigurationError
+        end
+
+        index.morphology.should 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
+
+        index.morphology.should == 'stem_en'
+      end
+    end
+  end
+
+  describe '#name' do
+    it "uses the core suffix by default" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user
+      index.name.should == 'user_core'
+    end
+
+    it "uses the delta suffix when delta? is true" do
+      index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
+      index.name.should == 'user_delta'
+    end
+  end
+
+  describe '#offset' do
+    before :each do
+      config.stub :next_offset => 4
+    end
+
+    it "uses the next offset value from the configuration" do
+      index.offset.should == 4
+    end
+
+    it "uses the reference to get a unique offset" do
+      config.should_receive(:next_offset).with(:user).and_return(2)
+
+      index.offset
+    end
+  end
+
+  describe '#render' do
+    it "interprets the provided definition" do
+      index.should_receive(:interpret_definition!)
+
+      begin
+        index.render
+      rescue Riddle::Configuration::ConfigurationError
+        # Ignoring underlying validation error.
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/interpreter_spec.rb

@@ -0,0 +1,293 @@
+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) }
+  let(:source)  {
+    Struct.new(:attributes, :fields, :associations, :groupings, :conditions).
+      new([], [], [], [], [])
+  }
+  let(:block)   { Proc.new { } }
+
+  before :each do
+    ThinkingSphinx::ActiveRecord::SQLSource.stub! :new => source
+    source.stub :model => model
+  end
+
+  describe '.translate!' do
+    let(:instance) { double('interpreter', :translate! => true) }
+
+    it "creates a new interpreter instance with the given block and index" do
+      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:new).
+        with(index, block).and_return(instance)
+
+      ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
+    end
+
+    it "calls translate! on the instance" do
+      ThinkingSphinx::ActiveRecord::Interpreter.stub!(:new => instance)
+      instance.should_receive(:translate!)
+
+      ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
+    end
+  end
+
+  describe '#group_by' do
+    it "adds a source to the index" do
+      index.should_receive(:append_source).and_return(source)
+
+      instance.group_by 'lat'
+    end
+
+    it "only adds a single source for the given context" do
+      index.should_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'
+
+      source.groupings.should include('lat')
+    end
+  end
+
+  describe '#has' do
+    let(:column)    { double('column') }
+    let(:attribute) { double('attribute') }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::Attribute.stub! :new => attribute
+    end
+
+    it "adds a source to the index" do
+      index.should_receive(:append_source).and_return(source)
+
+      instance.has column
+    end
+
+    it "only adds a single source for the given context" do
+      index.should_receive(:append_source).once.and_return(source)
+
+      instance.has column
+      instance.has column
+    end
+
+    it "creates a new attribute with the provided column" do
+      ThinkingSphinx::ActiveRecord::Attribute.should_receive(:new).
+        with(model, column, {}).and_return(attribute)
+
+      instance.has column
+    end
+
+    it "passes through options to the attribute" do
+      ThinkingSphinx::ActiveRecord::Attribute.should_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
+      instance.has column
+
+      source.attributes.should include(attribute)
+    end
+
+    it "adds multiple attributes when passed multiple columns" do
+      instance.has column, column
+
+      source.attributes.select { |saved_attribute|
+        saved_attribute == attribute
+      }.length.should == 2
+    end
+  end
+
+  describe '#indexes' do
+    let(:column) { double('column') }
+    let(:field)  { double('field') }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::Field.stub! :new => field
+    end
+
+    it "adds a source to the index" do
+      index.should_receive(:append_source).and_return(source)
+
+      instance.indexes column
+    end
+
+    it "only adds a single source for the given context" do
+      index.should_receive(:append_source).once.and_return(source)
+
+      instance.indexes column
+      instance.indexes column
+    end
+
+    it "creates a new field with the provided column" do
+      ThinkingSphinx::ActiveRecord::Field.should_receive(:new).
+        with(model, column, {}).and_return(field)
+
+      instance.indexes column
+    end
+
+    it "passes through options to the field" do
+      ThinkingSphinx::ActiveRecord::Field.should_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
+      instance.indexes column
+
+      source.fields.should include(field)
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      instance.indexes column, column
+
+      source.fields.select { |saved_field|
+        saved_field == field
+      }.length.should == 2
+    end
+  end
+
+  describe '#join' do
+    let(:column)      { double('column') }
+    let(:association) { double('association') }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::Association.stub! :new => association
+    end
+
+    it "adds a source to the index" do
+      index.should_receive(:append_source).and_return(source)
+
+      instance.join column
+    end
+
+    it "only adds a single source for the given context" do
+      index.should_receive(:append_source).once.and_return(source)
+
+      instance.join column
+      instance.join column
+    end
+
+    it "creates a new association with the provided column" do
+      ThinkingSphinx::ActiveRecord::Association.should_receive(:new).
+        with(column).and_return(association)
+
+      instance.join column
+    end
+
+    it "adds an association to the source" do
+      instance.join column
+
+      source.associations.should include(association)
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      instance.join column, column
+
+      source.associations.select { |saved_assoc|
+        saved_assoc == association
+      }.length.should == 2
+    end
+  end
+
+  describe '#method_missing' do
+    let(:column) { double('column') }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::Column.stub!(:new => column)
+    end
+
+    it "returns a new column for the given method" do
+      instance.id.should == column
+    end
+
+    it "should initialise the column with the method name and arguments" do
+      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).
+        with(:users, :posts, :subject).and_return(column)
+
+      instance.users(:posts, :subject)
+    end
+  end
+
+  describe '#set_property' do
+    before :each do
+      index.class.stub  :settings => [:morphology]
+      source.class.stub :settings => [:mysql_ssl_cert]
+    end
+
+    context 'index settings' do
+      it "sets the provided setting" do
+        index.should_receive(:morphology=).with('stem_en')
+
+        instance.set_property :morphology => 'stem_en'
+      end
+    end
+
+    context 'source settings' do
+      before :each do
+        source.stub :mysql_ssl_cert= => true
+      end
+
+      it "adds a source to the index" do
+        index.should_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
+        index.should_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
+        source.should_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
+      interpreter.translate!.
+        should == interpreter.__id__
+    end
+  end
+
+  describe '#where' do
+    it "adds a source to the index" do
+      index.should_receive(:append_source).and_return(source)
+
+      instance.where 'id > 100'
+    end
+
+    it "only adds a single source for the given context" do
+      index.should_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'
+
+      source.conditions.should include('id > 100')
+    end
+  end
+end