thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/real_time/callbacks/real_time_callbacks_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new instance
+  }
+  let(:instance)   { double('instance', :id => 12) }
+  let(:config)     { double('config', :indices_for_references => [index],
+    :connection => connection) }
+  let(:index)      { double('index', :name => 'my_index', :is_a? => true,
+    :document_id_for_key => 123, :fields => [], :attributes => []) }
+  let(:connection) { double('connection', :query => true) }
+
+  before :each do
+    ThinkingSphinx::Configuration.stub :instance => config
+  end
+
+  describe '.after_save' do
+    let(:callbacks) { double('callbacks', :after_save => nil) }
+
+    before :each do
+      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
+        stub :new => callbacks
+    end
+
+    it "builds an object from the instance" do
+      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
+        should_receive(:new).with(instance).and_return(callbacks)
+
+      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
+        after_save(instance)
+    end
+
+    it "invokes after_save on the object" do
+      callbacks.should_receive(:after_save)
+
+      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
+        after_save(instance)
+    end
+  end
+
+  describe '#after_save' do
+    let(:insert)     { double('insert', :to_sql => 'REPLACE INTO my_index') }
+    let(:time)       { 1.day.ago }
+    let(:field)      { double('field', :name => 'name', :translate => 'Foo') }
+    let(:attribute)  { double('attribute', :name => 'created_at',
+      :translate => time) }
+
+    before :each do
+      ThinkingSphinx::Configuration.stub :instance => config
+      Riddle::Query::Insert.stub :new => insert
+      insert.stub :replace! => insert
+      index.stub :fields => [field], :attributes => [attribute]
+    end
+
+    it "creates an insert statement with all fields and attributes" do
+      Riddle::Query::Insert.should_receive(:new).
+        with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+        and_return(insert)
+
+      callbacks.after_save
+    end
+
+    it "switches the insert to a replace statement" do
+      insert.should_receive(:replace!).and_return(insert)
+
+      callbacks.after_save
+    end
+
+    it "sends the insert through to the server" do
+      connection.should_receive(:query).with('REPLACE INTO my_index')
+
+      callbacks.after_save
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/field_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Field do
+  let(:field)  { ThinkingSphinx::RealTime::Field.new column }
+  let(:column) { double('column', :__name => :created_at, :__stack => []) }
+
+  describe '#name' do
+    it "uses the provided option by default" do
+      field = ThinkingSphinx::RealTime::Field.new column, :as => :foo
+      field.name.should == 'foo'
+    end
+
+    it "falls back to the column's name" do
+      field.name.should == 'created_at'
+    end
+  end
+
+  describe '#translate' do
+    let(:klass)  { Struct.new(:name, :parent) }
+    let(:object) { klass.new 'the object name', parent }
+    let(:parent) { klass.new 'the parent name', nil }
+
+    it "returns the column's name if it's a string" do
+      column.stub :__name => 'value'
+
+      field.translate(object).should == 'value'
+    end
+
+    it "returns the column's name if it's an integer" do
+      column.stub :__name => 404
+
+      field.translate(object).should == 404
+    end
+
+    it "returns the object's method matching the column's name" do
+      object.stub :created_at => 'a time'
+
+      field.translate(object).should == 'a time'
+    end
+
+    it "uses the column's stack to navigate through the object tree" do
+      column.stub :__name => :name, :__stack => [:parent]
+
+      field.translate(object).should == 'the parent name'
+    end
+
+    it "returns nil if any element in the object tree is nil" do
+      column.stub :__name => :name, :__stack => [:parent]
+      object.parent = nil
+
+      field.translate(object).should be_nil
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/index_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Index do
+  let(:index)        { ThinkingSphinx::RealTime::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 '#attributes' do
+    it "has the internal id attribute by default" do
+      index.attributes.collect(&:name).should include('sphinx_internal_id')
+    end
+
+    it "has the internal deleted attribute by default" do
+      index.attributes.collect(&:name).should include('sphinx_deleted')
+    end
+  end
+
+  describe '#delta?' do
+    it "always returns false" do
+      index.should_not be_delta
+    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 '#fields' do
+    it "has the internal class field by default" do
+      index.fields.collect(&:name).should include('sphinx_internal_class')
+    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::RealTime::Interpreter.should_receive(:translate!).
+        with(index, block)
+
+      index.interpret_definition!
+    end
+
+    it "only interprets the definition block once" do
+      ThinkingSphinx::RealTime::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
+    before :each do
+      pending
+    end
+
+    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 "always uses the core suffix" do
+      index = ThinkingSphinx::RealTime::Index.new :user
+      index.name.should == 'user_core'
+    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
+
+  describe '#unique_attribute_names' do
+    it "returns all attribute names" do
+      index.unique_attribute_names.
+        should == ['sphinx_internal_id', 'sphinx_deleted']
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/interpreter_spec.rb

@@ -0,0 +1,147 @@
+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).new([], []) }
+  let(:block)   { Proc.new { } }
+
+  describe '.translate!' do
+    let(:instance) { double('interpreter', :translate! => true) }
+
+    it "creates a new interpreter instance with the given block and index" do
+      ThinkingSphinx::RealTime::Interpreter.should_receive(:new).
+        with(index, block).and_return(instance)
+
+      ThinkingSphinx::RealTime::Interpreter.translate! index, block
+    end
+
+    it "calls translate! on the instance" do
+      ThinkingSphinx::RealTime::Interpreter.stub!(:new => instance)
+      instance.should_receive(:translate!)
+
+      ThinkingSphinx::RealTime::Interpreter.translate! index, block
+    end
+  end
+
+  describe '#has' do
+    let(:column)    { double('column') }
+    let(:attribute) { double('attribute') }
+
+    before :each do
+      ThinkingSphinx::RealTime::Attribute.stub! :new => attribute
+    end
+
+    it "creates a new attribute with the provided column" do
+      ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+        with(column, {}).and_return(attribute)
+
+      instance.has column
+    end
+
+    it "passes through options to the attribute" do
+      ThinkingSphinx::RealTime::Attribute.should_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
+      instance.has column
+
+      index.attributes.should include(attribute)
+    end
+
+    it "adds multiple attributes when passed multiple columns" do
+      instance.has column, column
+
+      index.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::RealTime::Field.stub! :new => field
+    end
+
+    it "creates a new field with the provided column" do
+      ThinkingSphinx::RealTime::Field.should_receive(:new).
+        with(column, {}).and_return(field)
+
+      instance.indexes column
+    end
+
+    it "passes through options to the field" do
+      ThinkingSphinx::RealTime::Field.should_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
+      instance.indexes column
+
+      index.fields.should include(field)
+    end
+
+    it "adds multiple fields when passed multiple columns" do
+      instance.indexes column, column
+
+      index.fields.select { |saved_field|
+        saved_field == field
+      }.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]
+    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
+  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
+      interpreter.translate!.
+        should == interpreter.__id__
+    end
+  end
+end

data/spec/thinking_sphinx/scopes_spec.rb

@@ -0,0 +1,38 @@
+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 "creates new search" do
+      model.foo.class.should == ThinkingSphinx::Search
+    end
+
+    it "passes block result to constructor" do
+      model.foo.options[:with].should == {:foo => :bar}
+    end
+
+    it "passes non-scopes through to the standard method error call" do
+      lambda { model.bar }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe '#sphinx_scope' do
+    it "saves the given block with a name" do
+      model.sphinx_scope(:foo) { 27 }
+      model.sphinx_scopes[:foo].call.should == 27
+    end
+  end
+end