rmla 1.0

data/spec/fixtures/models.rb

@@ -0,0 +1,99 @@
+class MongoidAlpha 
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  field :value, :type => Integer
+  field :cost, :type => Float
+  field :hidden
+  
+  self.whiny_indexing = true
+  
+  referenced_in :mongoid_epsilon
+  
+  search_in :name, :cost, :value
+end
+
+class MongoidBeta
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  
+  self.whiny_indexing = true
+    
+  embeds_many :mongoid_gammas
+  
+  search_in :name => {:boost => 2.0, :analyzer => 'snowball'}
+end
+
+class MongoidTheta < MongoidAlpha
+  field :extra  
+  
+  search_in :extra
+end
+
+class MongoidTau < MongoidAlpha
+  field :extra2  
+end
+
+class MongoidDelta
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  
+  self.whiny_indexing = true  
+end
+
+class MongoidOmega < MongoidDelta
+  search_in :name
+end
+
+class MongoidZeta
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  field :an_array, :type => Array
+  
+  search_in :name, :an_array
+end
+
+class MongoidGamma
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  field :value, :type => Integer  
+  
+  self.whiny_indexing = true
+  
+  embedded_in :mongoid_beta
+  
+  search_in :name, :value, :embedded_in => :mongoid_beta
+end
+
+class MongoidPi
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+  
+  self.whiny_indexing = true
+  
+  references_one :mongoid_epsilon
+  
+  search_in :name, :does_smth
+  
+  def does_smth
+    "returns smth"
+  end
+end
+
+class MongoidEpsilon
+  include Mongoid::Document
+  include Mongoid::Mebla
+  field :name
+
+  self.whiny_indexing = true
+  
+  referenced_in :mongoid_pi
+  references_many :mongoid_alphas
+  
+  search_in :name, :search_relations => {:mongoid_pi => :name, :mongoid_alphas => [:name, :value]}
+end

data/spec/fixtures/mongoid.yml

@@ -0,0 +1,3 @@
+username: ''
+password: ''
+host: localhost

data/spec/mebla/indexing_spec.rb

@@ -0,0 +1,165 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'ruby-debug'
+
+describe "Mebla" do
+  describe "indexing" do
+    it "should index existing records" do
+      Mebla.context.drop_index
+      
+      fdocument = nil
+      ldocument = nil
+      
+      MongoidAlpha.without_indexing do
+        fdocument = MongoidAlpha.create! :name => "Testing indexing bulkly", :value => 1, :cost => 1.0
+        ldocument = MongoidAlpha.create! :name => "Testing indexing bulkly other one", :value => 2, :cost => 2.0
+      end
+      
+      Mebla.context.index_data
+      
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_alpha, fdocument.id.to_s)}.should_not raise_error
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_alpha, ldocument.id.to_s)}.should_not raise_error
+    end    
+    
+    it "should delete the existing index and create a new one" do
+      Mebla.context.rebuild_index.should_not == false
+    end
+      
+    it "should create the index with proper mapping" do      
+      maps = Mebla.context.slingshot_index.mapping["mongoid_alpha"]["properties"]
+      maps["name"]["type"].should == "string"
+      maps["value"]["type"].should == "integer"
+      maps["cost"]["type"].should == "float"
+    end
+    
+    describe "array fields" do
+      it "should index arrays" do
+        Mebla.context.drop_index
+        
+        zeta = nil
+        
+        MongoidZeta.without_indexing do
+          zeta = MongoidZeta.create! :name => "Document with an array", :an_array => [:item, :item2]
+        end
+        
+        Mebla.context.index_data
+        
+        lambda {Mebla.context.slingshot_index.retrieve(:mongoid_zeta, zeta.id.to_s)}.should_not raise_error
+      end
+    end
+    
+    describe "method fields" do
+      it "should index method results" do
+        Mebla.context.drop_index
+        
+        pi = nil
+        
+        MongoidPi.without_indexing do
+          pi = MongoidPi.create! :name => "Document with an indexed method"
+        end
+        
+        Mebla.context.index_data
+        
+        lambda {Mebla.context.slingshot_index.retrieve(:mongoid_pi, pi.id.to_s)}.should_not raise_error
+      end
+    end
+    
+    describe "relational fields" do
+      it "should index relational fields" do
+        Mebla.context.drop_index
+        
+        pi = nil
+
+        MongoidPi.without_indexing do
+          pi = MongoidPi.create! :name => "A pi"
+        end
+        
+        alpha = nil
+        
+        MongoidAlpha.without_indexing do
+          alpha = MongoidAlpha.create! :name => "Testing index", :value => 1, :cost => 2.0
+        end        
+        
+        epsilon = nil
+        
+        MongoidEpsilon.without_indexing do
+          epsilon = pi.create_mongoid_epsilon :name => "episilon", :mongoid_alphas => [alpha]
+        end
+        
+        Mebla.context.index_data
+        
+        lambda {Mebla.context.slingshot_index.retrieve(:mongoid_epsilon, epsilon.id.to_s)}.should_not raise_error
+      end
+    end
+    
+    describe "for sub-classed documents" do
+      it "should index existing records" do
+        Mebla.context.drop_index
+        
+        theta = nil
+        
+        MongoidTheta.without_indexing do
+          theta = MongoidTheta.create! :extra => "Subclassed parent"
+        end
+        
+        Mebla.context.index_data
+        
+        lambda {Mebla.context.slingshot_index.retrieve(:mongoid_theta, theta.id.to_s)}.should_not raise_error
+      end
+      
+      it "should not index non searchable subclassed models" do
+        Mebla.context.drop_index        
+        
+        tau = nil
+        MongoidAlpha.without_indexing do
+          MongoidAlpha.create! :name => "Testing indexing bulkly", :value => 1, :cost => 1.0          
+          tau = MongoidTau.create! :extra2 => "Should not be indexed"
+        end
+        
+        lambda {Mebla.context.index_data}.should_not raise_error
+        lambda {Mebla.context.slingshot_index.retrieve(:mongoid_tau, tau.id.to_s)}.should raise_error
+      end
+      
+      it "should index only models with defined indecies" do
+        Mebla.context.drop_index
+        
+        theta = nil
+        
+        MongoidOmega.without_indexing do
+          theta = MongoidOmega.create! :name => "Subclassed parent"
+        end        
+        
+        lambda {Mebla.context.index_data}.should_not raise_error
+      end
+    end
+    
+    describe "for embedded documents" do
+      it "should index existing records" do
+        Mebla.context.drop_index
+                
+        beta = nil
+        gamma = nil
+        
+        MongoidBeta.without_indexing do
+          beta = MongoidBeta.create! :name => "Embedor parent"
+          MongoidGamma.without_indexing do
+            gamma = beta.mongoid_gammas.create :name => "Embedded", :value => 1
+          end
+        end        
+        
+        Mebla.context.index_data
+        
+        lambda {
+          Slingshot::Configuration.client.get "#{Mebla::Configuration.instance.url}/#{Mebla.context.slingshot_index_name}/mongoid_gamma/#{gamma.id.to_s}?routing=#{beta.id.to_s}"
+        }.should_not raise_error
+      end
+      
+      it "should create the index with proper parent mapping" do      
+        mappings = Mebla.context.slingshot_index.mapping["mongoid_gamma"]
+        routing = mappings["_routing"]
+        parent = mappings["_parent"]
+        routing["path"].should == "mongoid_beta_id"        
+        parent["type"].should == "mongoid_beta"        
+      end
+    end
+  end
+end

data/spec/mebla/searching_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Mebla" do
+  describe "searching" do    
+    before(:each) do
+      Mebla.context.rebuild_index
+      MongoidAlpha.create! :name => "Testing index", :value => 1, :cost => 2.0
+    end
+    
+    it "should search and return the only relevant result" do
+      results=MongoidAlpha.search "name: Testing index"      
+      
+      results.total.should == 1          
+    end
+    
+    it "should search and return the only relevant result, and cast it into the correct class type" do
+      results=MongoidAlpha.search "name: Testing index"
+            
+      results.first.class.should == MongoidAlpha
+    end
+    
+    describe "documents with arrays" do
+      before(:each) do
+        Mebla.context.rebuild_index
+        MongoidZeta.create! :name => "Document with array", :an_array => [:item, :item2]
+      end
+      
+      it "should return arrays correctly" do
+        results = MongoidZeta.search "Document with array"
+        
+        results.first.an_array.class.should == Array
+      end
+      
+      it "should search within arrays" do
+        results = MongoidZeta.search "item2"
+        
+        results.total.should == 1
+      end
+    end
+    
+    describe "documents with indexed methods" do
+      before(:each) do
+        Mebla.context.rebuild_index
+        MongoidPi.create! :name => "Document with an indexed method"
+      end
+      
+      it "should search within indexed methods" do
+        results = MongoidPi.search "returns smth"
+        
+        results.total.should == 1
+      end
+    end
+    
+    describe "documents with indexed relation fields" do
+      before(:each) do
+        Mebla.context.rebuild_index
+        pi = MongoidPi.create! :name => "A pi"
+        alpha = MongoidAlpha.create! :name => "Testing index", :value => 1, :cost => 2.0
+        epsilon = pi.create_mongoid_epsilon :name => "epsilon"#, :mongoid_alphas => [alpha] # currently there is a bug in setting the relation like this while creating the document
+        epsilon.mongoid_alphas << alpha
+        epsilon.save # another bug; mongoid doesn't raise the save callbacks for `<<` method
+      end
+      
+      it "should search within indexed fields from the relations" do
+        results = MongoidEpsilon.search "Testing index"
+        
+        results.total.should == 1        
+      end
+    end
+    
+    describe "multiple types" do
+      before(:each) do
+        MongoidBeta.create! :name => "Testing index"
+      end
+      
+      it "should search and return all results of all class types" do        
+        results=Mebla.search  "name: Testing index"        
+        
+        results.total.should == 2
+        (results.each.collect{|e| e.class} & [MongoidAlpha, MongoidBeta]).should =~ [MongoidAlpha, MongoidBeta]
+      end
+      
+      it "should search and return only results from the searched class type" do        
+        results=MongoidAlpha.search "name: Testing index"        
+        
+        results.total.should == 1
+        results.first.class.should == MongoidAlpha
+      end
+    end
+    
+    describe "embedded documents" do
+      before(:each) do
+        beta = MongoidBeta.create! :name => "Embedor parent"
+        beta.mongoid_gammas.create :name => "Embedded", :value => 1
+      end
+      
+      it "should search and return the only relevant result" do
+        results=MongoidGamma.search "name: Embedded"        
+        
+        results.total.should == 1
+      end
+      
+      it "should search and return the only relevant result, and cast it into the correct class type" do
+        results=MongoidGamma.search "name: Embedded"        
+        
+        results.first.class.should == MongoidGamma
+      end
+    end
+    
+    describe "with options" do
+      before(:each) do        
+        beta = MongoidBeta.create! :name => "Different map"
+        beta.mongoid_gammas.create :name => "Testing index 2", :value => 2
+      end
+      
+      it "should sort descending according to the criteria defined" do
+        Mebla.search("Testing index").desc(:value).first.class.should == MongoidGamma
+      end
+      
+      it "should sort ascending according to the criteria defined" do
+        Mebla.search("Testing index").asc(:value).first.class.should == MongoidAlpha
+      end
+      
+      it "should search and only return results matching the term defined" do
+        Mebla.search.term(:name, "index").total.should == 2
+      end
+      
+      it "should search and only return results matching the terms defined" do
+        Mebla.search.terms(:name, ["index", "map"]).total.should == 3
+      end
+      
+      it "should search and filter results according to the filters defined" do
+        Mebla.search.terms(:name, ["index", "map"]).only(:value => [1]).total.should == 1
+      end
+      
+      it "should search and return results along with facets" do
+        results = Mebla.search.terms(:name, ["index", "map"]).facet("values", :value)        
+        results.facets["values"]["terms"].count.should == 2
+      end
+    end
+  end  
+end

data/spec/mebla/synchronizing_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Mebla" do  
+  describe "synchronizing" do
+    before(:each) do
+      Mebla.context.rebuild_index
+      MongoidAlpha.create! :name => "Testing index", :value => 1, :cost => 2.0
+    end
+    
+    it "should index new documents automatically" do
+      mdocument = MongoidAlpha.first
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_alpha, mdocument.id.to_s)}.should_not raise_error
+    end
+    
+    it "should remove deleted documents from index automatically" do
+      mdocument = MongoidAlpha.first
+      doc_id = mdocument.id.to_s
+      mdocument.destroy
+      
+      lambda {MongoidAlpha.slingshot_index.retrieve(:mongoid_alpha, doc_id)}.should raise_error
+    end
+    
+    it "should update the index automatically when a document is updated" do      
+      udocument = MongoidAlpha.first
+      udocument.update_attributes(:cost => 3.1).should == true
+      
+      result = Mebla.context.slingshot_index.retrieve(:mongoid_alpha, udocument.id.to_s)
+      result[:cost].should == 3.1
+    end    
+  end
+  
+  describe "sub classes" do
+    before(:each) do
+      Mebla.context.rebuild_index      
+      MongoidTheta.create! :extra => "Is this indexed?"
+    end
+    
+    it "should index sub-classed documents automatically under the sub-class type" do
+      mdocument = MongoidTheta.first
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_theta, mdocument.id.to_s)}.should_not raise_error
+    end
+    
+     it "should index sub-classed documents automatically and correctly" do
+      pdocument = MongoidTheta.first
+      result = Mebla.context.slingshot_index.retrieve(:mongoid_theta, pdocument.id.to_s)
+      result[:extra].should == "Is this indexed?"      
+    end
+  end
+  
+  describe "documents with indexed method fields" do
+    before(:each) do
+      Mebla.context.rebuild_index
+      MongoidPi.create! :name => "Testing indexing methods"
+    end
+    
+    it "should index method" do
+      pdocument = MongoidPi.first
+      
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_pi, pdocument.id.to_s)}.should_not raise_error
+    end
+    
+     it "should index method fields documents automatically and correctly" do
+      pdocument = MongoidPi.first
+      result = Mebla.context.slingshot_index.retrieve(:mongoid_pi, pdocument.id.to_s)
+      result[:does_smth].should == "returns smth"
+    end
+  end
+  
+  describe "documents with indexed relation fields" do
+    before(:each) do
+      Mebla.context.rebuild_index
+      pi = MongoidPi.create! :name => "A pi"
+      alpha = MongoidAlpha.create! :name => "Testing index", :value => 1, :cost => 2.0
+      epsilon = pi.create_mongoid_epsilon :name => "epsilon"#, :mongoid_alphas => [alpha] # currently there is a bug in setting the relation like this while creating the document
+      epsilon.mongoid_alphas << alpha
+      epsilon.save # another bug; mongoid doesn't raise the save callbacks for `<<` method
+    end
+    
+    it "should index documents with indexed fields from the relations" do
+      edocument = MongoidEpsilon.first
+      
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_epsilon, edocument.id.to_s)}.should_not raise_error
+    end
+    
+    it "should index fields from the relations with the document" do
+      edocument = MongoidEpsilon.first
+      
+      result = Mebla.context.slingshot_index.retrieve(:mongoid_epsilon, edocument.id.to_s)
+      result[:mongoid_pi][:name].should == "A pi"      
+      result[:mongoid_alphas].is_a?(Array).should == true      
+      result[:mongoid_alphas].first["name"].should == "Testing index"
+      result[:mongoid_alphas].first["value"].should == 1
+    end
+  end
+  
+  describe "array fields documents" do
+    it "should index array fields and retrieve them correctly" do
+      Mebla.context.rebuild_index
+      zdocument = MongoidZeta.create :name => "Document with array", :an_array => [:index, :index2, :index2]
+      
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_zeta, zdocument.id.to_s)}.should_not raise_error
+    end
+    
+    it "should index array fields and retrieve them correctly" do
+      Mebla.context.rebuild_index
+      zdocument = MongoidZeta.create :name => "Document with array", :an_array => [:index, :index2, :index2]
+      
+      lambda {Mebla.context.slingshot_index.retrieve(:mongoid_zeta, zdocument.id.to_s)}.should_not raise_error
+    end
+  end
+  
+  describe "embedded documents" do
+    before(:each) do
+      Mebla.context.rebuild_index
+      beta = MongoidBeta.create! :name => "Embedor parent"
+      beta.mongoid_gammas.create :name => "Embedded", :value => 1
+    end
+    
+    it "should index embedded documents automatically and link to the parent" do
+      mdocument = MongoidBeta.first.mongoid_gammas.first
+      lambda {
+        Slingshot::Configuration.client.get "#{Mebla::Configuration.instance.url}/#{Mebla.context.slingshot_index_name}/mongoid_gamma/#{mdocument.id.to_s}?routing=#{mdocument.mongoid_beta.id.to_s}"
+      }.should_not raise_error
+    end
+  end
+end