acts_as_solr 1.0.0

data/test/unit/instance_methods_shoulda.rb

@@ -0,0 +1,326 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'instance_methods'
+require 'logger'
+module Solr; end
+require 'solr/xml'
+require 'solr/field'
+require 'solr/document'
+require 'solr_instance'
+require 'erb'
+require 'ostruct'
+
+class InstanceMethodsTest < Test::Unit::TestCase
+
+  context "With a Solr record instance" do
+    setup do
+      @instance = SolrInstance.new
+    end
+    
+    context "when checking whether indexing is disabled" do
+    
+      setup do
+        @instance.configuration = {:if => true}
+      end
+  
+      should "return true if the specified proc returns true " do
+        @instance.configuration[:offline] = proc {|record| true}
+        assert @instance.indexing_disabled?
+      end
+  
+      should "return false if the specified proc returns false" do
+        @instance.configuration[:offline] = proc {|record| false}
+        assert !@instance.indexing_disabled?
+      end
+  
+      should "return true if no valid offline option was specified" do
+        @instance.configuration[:offline] = nil
+        @instance.configuration[:if] = proc {true}
+        assert !@instance.indexing_disabled?
+      end
+    end
+
+    context "when validating the boost" do
+      setup do
+        @instance.solr_configuration = {:default_boost => 10.0}
+        @instance.configuration = {:if => true}
+      end
+    
+      should "accept and evaluate a block" do
+        @instance.configuration[:boost] = proc {|record| record.boost_rate}
+        assert_equal 10.0, @instance.send(:validate_boost, @instance.configuration[:boost])
+      end
+  
+      should "accept and return a float" do
+        @instance.configuration[:boost] = 9.0
+        assert_equal 9.0, @instance.send(:validate_boost, @instance.configuration[:boost])
+      end
+  
+      should "return the default float when the specified is negative" do
+        @instance.configuration[:boost] = -1.0
+        assert_equal 10.0, @instance.send(:validate_boost, @instance.configuration[:boost])
+      end
+  
+      should "execute the according method when value is a symbol" do
+        @instance.configuration[:boost] = :irate
+        assert_equal 8.0, @instance.send(:validate_boost, @instance.configuration[:boost])
+      end
+  
+      should "return the default boost when there is no valid boost" do
+        @instance.configuration[:boost] = "boost!"
+        assert_equal 10.0, @instance.send(:validate_boost, @instance.configuration[:boost])
+      end
+    end
+  
+    context "when determining the solr document id" do
+      should "combine class name and id" do
+        assert_equal "SolrInstance:10", @instance.solr_id
+      end
+    end
+  
+    context "when saving the instance to solr" do
+      context "with indexing disabled" do
+        setup do
+          @instance.configuration = {:fields => [:name], :if => nil}
+        end
+  
+        should "just return and do nothing" do
+          @instance.expects(:solr_add).never
+          @instance.expects(:solr_destroy).never
+          assert @instance.solr_save
+        end
+      end
+    
+      context "with indexing enabled" do
+        setup do
+          @instance.configuration = {:fields => [:name], :if => "true", :auto_commit => true}
+          @instance.stubs(:solr_commit)
+          @instance.stubs(:solr_add)
+          @instance.stubs(:to_solr_doc).returns("My test document")
+        end
+
+        should "add the solr document" do
+          @instance.expects(:solr_add).with("My test document").once
+          @instance.solr_save
+        end
+      
+        should "commit to solr" do
+          @instance.expects(:solr_commit).once
+          @instance.solr_save
+        end
+      
+        should "not commit if auto_commit is disabled" do
+          @instance.configuration.merge!(:auto_commit => false)
+          @instance.expects(:solr_commit).never
+          @instance.solr_save
+        end
+      
+        should "destroy the document if :if clause is false" do
+          @instance.configuration.merge!(:if => "false")
+          @instance.expects(:solr_destroy).once
+          @instance.solr_save
+        end
+      end
+    end
+  
+    context "when destroying an instance in solr" do
+      setup do
+        @instance.configuration = {:if => true, :auto_commit => true}
+        @instance.stubs(:solr_commit)
+        @instance.stubs(:solr_delete)
+      end
+
+      should "delete the instance" do
+        @instance.expects(:solr_delete).with("SolrInstance:10")
+        @instance.solr_destroy
+      end
+    
+      should "commit to solr" do
+        @instance.expects(:solr_commit)
+        @instance.solr_destroy
+      end
+    
+      should "not commit if auto_commit is disabled" do
+        @instance.configuration.merge!(:auto_commit => false)
+        @instance.expects(:solr_commit).never
+        @instance.solr_destroy
+      end
+      
+      context "with indexing disabled" do
+        should "not contact solr" do
+          @instance.configuration.merge!(:offline => true, :if => nil)
+          @instance.expects(:solr_delete).never
+          @instance.solr_destroy
+        end
+      end
+    end
+  
+    context "when converting an instance to a solr document" do
+      setup do
+        @instance.configuration = {:if => true, :auto_commit => true, :solr_fields => {:name => {:boost => 9.0}}, :boost => 10.0}
+        @instance.solr_configuration = {:type_field => "type", :primary_key_field => "pk_id", :default_boost => 25.0}
+      end
+    
+      should "add a document boost" do
+        assert_equal 10, @instance.to_solr_doc.boost
+      end
+      
+      should "set the solr id" do
+        assert_equal "SolrInstance:10", @instance.to_solr_doc[:id]
+      end
+      
+      should "set the type field" do
+        assert_equal "SolrInstance", @instance.to_solr_doc[:type]
+      end
+      
+      should "set the primary key fields" do
+        assert_equal("10", @instance.to_solr_doc[:pk_id])
+      end
+      
+      should "add the includes if they were configured" do
+        @instance.configuration.merge! :include => [:author]
+        @instance.expects(:add_includes)
+        @instance.to_solr_doc
+      end
+      
+      context "with indexed fields" do
+        should "add fields with type" do
+          assert_equal "Chunky bacon!", @instance.to_solr_doc[:name_s]
+        end
+        
+        should "add the field boost" do
+          field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "name_s"}
+          assert_equal 9.0, field.boost
+        end
+        
+        should "set the default boost for the field, if none is configured" do
+          @instance.configuration[:solr_fields][:name][:boost] = nil
+          field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "name_s"}
+          assert_equal 25.0, field.boost
+        end
+        
+        should "not overwrite the type or id field" do
+          @instance.configuration[:solr_fields] = {:type => {}, :id => {}}
+          doc = @instance.to_solr_doc
+          assert_not_equal "humbug", doc[:type]
+          assert_not_equal "bogus", doc[:id]
+        end
+        
+        should "set the default value if field value is nil" do
+          @instance.name = nil
+          @instance.expects(:set_value_if_nil).with('s')
+          @instance.to_solr_doc
+        end
+        
+        should "not include nil values" do
+          @instance.name = ""
+          @instance.stubs(:set_value_if_nil).returns ""
+          assert_nil @instance.to_solr_doc[:name_s]
+        end
+        
+        should "escape the contents" do
+          @instance.name = "<script>malicious()</script>"
+          assert_equal "&lt;script&gt;malicious()&lt;/script&gt;", @instance.to_solr_doc[:name_s]
+        end
+
+        should "use an alternate field name if specified in options" do
+          @instance.stubs(:nickname_for_solr).returns('Nick')
+          @instance.configuration[:solr_fields].merge! :nickname => {:as => :alias}
+          doc = @instance.to_solr_doc
+          assert_not_nil @instance.to_solr_doc.fields.find {|f| f.name.to_s == "alias_s"}
+          assert_nil     @instance.to_solr_doc.fields.find {|f| f.name.to_s == "nickname_s"}
+        end
+
+        context "when associations are included" do
+          setup do
+            class AssocLabel < String
+              @@singular = {'people' => 'person'}
+              def to_s
+                self
+              end
+              def singularize
+                @@singular[self]
+              end
+            end
+            @assoc = AssocLabel.new('people')
+            person = {:name => 'Hank Venture', :address => 'Venture Compound'}
+            @people = [OpenStruct.new(person.merge(:attributes => person))]
+            @instance.stubs(:people).returns(@people)
+            @reflection = OpenStruct.new(:macro => :has_many)
+            @instance.class.stubs(:reflect_on_association).returns(@reflection)
+            @instance.configuration[:solr_includes] = {@assoc => {}}
+            @instance.solr_configuration.merge! :default_boost => 35.0
+          end
+
+          should "set the default name for the include, if none is configured" do
+            @instance.configuration[:solr_includes] = {@assoc => {:type => :text}}
+            doc = @instance.to_solr_doc
+            assert_not_nil doc.fields.find {|f| f.name.to_s == "person_s"}
+          end
+
+          should "add the include alias" do
+            @instance.configuration[:solr_includes] = {@assoc => {:as => :human, :type => :text}}
+            doc = @instance.to_solr_doc
+            assert_not_nil doc.fields.find {|f| f.name.to_s == "human_s"}
+            assert_nil     doc.fields.find {|f| f.name.to_s == "person_s"}
+          end
+
+          should "add the include type" do
+            @instance.configuration[:solr_includes] = {@assoc => {:type => :date}}
+            @instance.expects(:get_solr_field_type).with(){|v| true}.at_least_once.returns('s')
+            @instance.expects(:get_solr_field_type).with(:date).once.returns('d')
+            doc = @instance.to_solr_doc
+          end
+
+          should "set the default boost for the include, if none is configured" do
+            # @instance.configuration[:solr_includes] = {@assoc => {}}
+            field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "person_s"}
+            assert_equal 35.0, field.boost
+          end
+
+          should "add the include boost" do
+            @instance.configuration[:solr_includes] = {@assoc => {:boost => 10.0}}
+            field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "person_s"}
+            assert_equal 10.0, field.boost
+          end
+
+          should "default to a field value with all association attributes" do
+            # @instance.configuration[:solr_includes] = {@assoc => {}}
+            field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "person_s"}
+            @people.first.attributes.each do |attr, value|
+              assert_match /#{attr}=#{value}/, field.value
+            end
+          end
+
+          should "use a field value from an association method, if one is configured" do
+            @instance.configuration[:solr_includes] = {@assoc => {:using => :name}}
+            field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "person_s"}
+            assert_equal @people.first.name, field.value
+          end
+
+          should "use a field value from a proc, if one is configured" do
+            @instance.configuration[:solr_includes] = {@assoc => {:using => lambda{|r| r.name.reverse}}}
+            field = @instance.to_solr_doc.fields.find {|f| f.name.to_s == "person_s"}
+            assert_equal @people.first.name.reverse, field.value
+          end
+
+          should "join multiple values into a single field unless the :multivalued options is specified" do
+            @instance.configuration[:solr_includes] = {@assoc => {:multivalued => :true}}
+            second_person = {:name => 'Dean Venture', :address => 'Venture Compound'}
+            @people << OpenStruct.new(second_person.merge(:attributes => second_person))
+            fields = @instance.to_solr_doc.fields.select {|f| f.name.to_s == "person_s"}
+            assert_equal @people.size, fields.size
+          end
+
+          should "include multiple values separately if the :multivalued options is specified"    do
+            # @instance.configuration[:solr_includes] = {@assoc => {}}
+            second_person = {:name => 'Dean Venture', :address => 'Venture Compound'}
+            @people << OpenStruct.new(second_person.merge(:attributes => second_person))
+            fields = @instance.to_solr_doc.fields.select {|f| f.name.to_s == "person_s"}
+            assert_not_equal @people.size, fields.size
+            assert_equal 1, fields.size
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/lazy_document_shoulda.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+require 'lazy_document'
+
+class UserModel; end
+
+class LazyDocumentTest < Test::Unit::TestCase
+  context "With a lazy document" do
+    setup do
+      @record = stub(:record)
+      @record.stubs(:is_valid?).returns true
+      UserModel.stubs(:find).returns @record
+      @document = ActsAsSolr::LazyDocument.new(1, UserModel)
+    end
+    
+    context "with an uninitialized document" do
+      should "fetch the record from the database" do
+        UserModel.expects(:find).with(1).returns(@record)
+        @document.is_valid?
+      end
+    end
+    
+    context "with an initialized document" do
+      should "not fetch the record again" do
+        @document.is_valid?
+        @document.expects(:find).never
+        @document.is_valid?
+      end
+      
+      should "reroute the calls to the record" do
+        @record.expects(:is_valid?).once
+        @document.is_valid?
+      end
+    end
+  end
+end

data/test/unit/parser_instance.rb

@@ -0,0 +1,19 @@
+class ActsAsSolr::ParserInstance
+  include ActsAsSolr::ParserMethods
+  include ActsAsSolr::CommonMethods
+  attr_accessor :configuration, :solr_configuration
+  
+  def table_name
+    "documents"
+  end
+  
+  def primary_key
+    "id"
+  end
+  
+  def find(*args)
+    []
+  end
+  
+  public :parse_results, :reorder, :parse_query, :add_scores, :replace_types
+end

data/test/unit/parser_methods_shoulda.rb

@@ -0,0 +1,279 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'parser_methods'
+require 'common_methods'
+require 'search_results'
+require 'deprecation'
+module Solr; module Request; end; end
+require 'solr/request/base'
+require 'solr/request/select'
+require 'solr/request/standard'
+require 'parser_instance'
+require 'lazy_document'
+
+class ActsAsSolr::Post; end
+
+class ParserMethodsTest < Test::Unit::TestCase
+
+  context "With a parser instance" do
+    setup do
+      @parser = ActsAsSolr::ParserInstance.new
+    end
+    
+    context "When parsing results" do
+      setup do
+        @results = stub(:results)
+        @results.stubs(:highlighting).returns({})
+        @results.stubs(:total_hits).returns(2)
+        @results.stubs(:hits).returns([])
+        @results.stubs(:max_score).returns 2.1
+        @results.stubs(:data).returns({"responseHeader" => {"QTime" => "10.2"}})
+      end
+    
+      should "return a SearchResults object" do
+        assert_equal ActsAsSolr::SearchResults, @parser.parse_results(@results).class
+      end
+    
+      should "set the max score" do
+        assert_equal 2.1, @parser.parse_results(@results).max_score
+      end
+    
+      should "include the facets" do
+        @results.stubs(:data).returns({"responseHeader" => {"QTime" => "10.2"}, "facet_counts" => 2})
+        assert_equal 2, @parser.parse_results(@results, :facets => true).facets
+      end
+
+      context "when the format requests objects" do
+        setup do
+          @parser.configuration = {:format => :objects}
+          @parser.solr_configuration = {:primary_key_field => :pk_id}
+          @results.stubs(:hits).returns [{"pk_id" => 1}, {"pk_id" => 2}]
+          @parser.stubs(:reorder)
+        end
+      
+        should "query with the record ids" do
+          @parser.expects(:find).with(:all, :conditions => ["documents.id in (?)", [1, 2]]).returns [1, 2]
+          @parser.parse_results(@results)
+        end
+      
+        should "reorder the records" do
+          @parser.expects(:reorder).with([], [1, 2])
+          @parser.parse_results(@results)
+        end
+      
+        should "add :include if :include was specified" do
+          @parser.expects(:find).with(:all, :conditions => ["documents.id in (?)", [1, 2]], :include => [:author]).returns [1, 2]
+          @parser.parse_results(@results, :include => [:author])
+        end
+      end
+    
+      context "when the format doesn't request objects" do
+        setup do
+          @parser.solr_configuration = {:primary_key_field => "pk_id"}
+        end
+
+        should "not query the database" do
+          @parser.expects(:find).never
+          @parser.parse_results(@results, :format => nil)
+        end
+      
+        should "return just the ids" do
+          @results.stubs(:hits).returns([{"pk_id" => 1}, {"pk_id" => 2}])
+          assert_equal [1, 2], @parser.parse_results(@results, :format => nil).docs
+        end
+        
+        should "ignore the :lazy option" do
+          @results.stubs(:hits).returns([{"pk_id" => 1}, {"pk_id" => 2}])
+          assert_equal [1, 2], @parser.parse_results(@results, :format => :ids, :lazy => true).docs
+        end
+      end
+    
+      context "with an empty result set" do
+        setup do
+          @results.stubs(:total_hits).returns(0)
+          @results.stubs(:hits).returns([])
+        end
+
+        should "return an empty search results set" do
+          assert_equal 0, @parser.parse_results(@results).total
+        end
+      
+        should "not have any search results" do
+          assert_equal [], @parser.parse_results(@results).docs
+        end
+      end
+      
+      context "with a nil result set" do
+        should "return an empty search results set" do
+          assert_equal 0, @parser.parse_results(nil).total
+        end
+      end
+    
+      context "with the scores option" do
+        should "add the scores" do
+          @parser.expects(:add_scores).with([], @results)
+          @parser.parse_results(@results, :scores => true)
+        end
+      end
+      
+      context "with lazy format" do
+        setup do
+          @parser.solr_configuration = {:primary_key_field => :pk_id}
+          @results.stubs(:hits).returns([{"pk_id" => 1}, {"pk_id" => 2}])
+        end
+        
+        should "create LazyDocuments for the resulting docs" do
+          result = @parser.parse_results(@results, :lazy => true)
+          assert_equal ActsAsSolr::LazyDocument, result.results.first.class
+        end
+        
+        should "set the document id as the record id" do
+          result = @parser.parse_results(@results, :lazy => true)
+          assert_equal 1, result.results.first.id
+        end
+        
+        should "set the document class" do
+          result = @parser.parse_results(@results, :lazy => true)
+          assert_equal ActsAsSolr::ParserInstance, result.results.first.clazz.class
+        end
+      end
+      
+    end
+  
+    context "when reordering results" do
+      should "raise an error if arguments don't have the same number of elements" do
+        assert_raise(RuntimeError) {@parser.reorder([], [1])}
+      end
+    
+      should "reorder the results to match the order of the documents returned by solr" do
+        thing1 = stub(:thing1)
+        thing1.stubs(:id).returns 5
+        thing2 = stub(:thing2)
+        thing2.stubs(:id).returns 1
+        thing3 = stub(:things3)
+        thing3.stubs(:id).returns 3
+        things = [thing1, thing2, thing3]
+        reordered = @parser.reorder(things, [1, 3, 5])
+        assert_equal [1, 3, 5], reordered.collect{|thing| thing.id}
+      end
+    end
+
+    context "When parsing a query" do
+      setup do
+        ActsAsSolr::Post.stubs(:execute)
+        @parser.stubs(:solr_type_condition).returns "(type:ParserMethodsTest)"
+        @parser.solr_configuration = {:primary_key_field => "id"}
+        @parser.configuration = {:solr_fields => nil}
+      end
+    
+      should "set the limit and offset" do
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          10 == request.to_hash[:rows]
+          20 == request.to_hash[:start]
+        }
+        @parser.parse_query "foo", :limit => 10, :offset => 20
+      end
+    
+      should "set the operator" do
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          "OR" == request.to_hash["q.op"]
+        }
+        @parser.parse_query "foo", :operator => :or
+      end
+    
+      should "not execute anything if the query is nil" do
+        ActsAsSolr::Post.expects(:execute).never
+        assert_nil @parser.parse_query(nil)
+      end
+      
+      should "not execute anything if the query is ''" do
+        ActsAsSolr::Post.expects(:execute).never
+        assert_nil @parser.parse_query('')
+      end
+    
+      should "raise an error if invalid options where specified" do
+        assert_raise(RuntimeError) {@parser.parse_query "foo", :invalid => true}
+      end
+    
+      should "add the type" do
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          request.to_hash[:q].include?("(type:ParserMethodsTest)")
+        }
+        @parser.parse_query "foo"
+      end
+    
+      should "append the field types for the specified fields" do
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          request.to_hash[:q].include?("(username_t:Chunky)")
+        }
+        @parser.parse_query "username:Chunky"
+      end
+    
+      should "replace the field types" do
+        @parser.expects(:replace_types).returns(["active_i:1"])
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          request.to_hash[:q].include?("active_i:1")
+        }
+        @parser.parse_query "active:1"
+      end
+    
+      should "add score and primary key to field list" do
+        ActsAsSolr::Post.expects(:execute).with {|request|
+          request.to_hash[:fl] == ('id,score')
+        }
+        @parser.parse_query "foo"
+      end
+    
+      context "with the order option" do
+        should "add the order criteria to the query" do
+          ActsAsSolr::Post.expects(:execute).with {|request|
+            request.to_hash[:q].include?(";active_t desc")
+          }
+          @parser.parse_query "active:1", :order => "active desc"
+        end
+      end
+    
+      context "with facets" do
+      end
+    end
+  
+    context "When setting the field types" do
+      setup do
+        @parser.configuration = {:solr_fields => {:name => {:type => :string},
+                                          :age => {:type => :integer}}}
+      end
+    
+      should "replace the _t suffix with the real type" do
+        assert_equal ["name_s:Chunky AND age_i:21"], @parser.replace_types(["name_t:Chunky AND age_t:21"])
+      end
+    
+      context "with a suffix" do
+        should "not include the colon when false" do
+          assert_equal ["name_s"], @parser.replace_types(["name_t"], false)
+        end
+      
+        should "include the colon by default" do
+          assert_equal ["name_s:Chunky"], @parser.replace_types(["name_t:Chunky"])
+        end
+      end
+    end
+  
+    context "When adding scores" do
+      setup do
+        @solr_data = stub(:results)
+        @solr_data.stubs(:total_hits).returns(1)
+        @solr_data.stubs(:hits).returns([{"id" => 2, "score" => 2.546}])
+        @solr_data.stubs(:max_score).returns 2.1
+      
+        @results = [Array.new]
+      
+        @parser.stubs(:record_id).returns(2)
+      
+        @parser.solr_configuration = {:primary_key_field => "id"}
+      end
+    
+      should "add the score to the result document" do
+        assert_equal 2.546, @parser.add_scores(@results, @solr_data).first.last.solr_score
+      end
+    end
+  end
+end