muck-solr 0.4.0

data/test/unit/lazy_document_shoulda.rb

@@ -0,0 +1,34 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+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,268 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+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(: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

data/test/unit/solr_instance.rb

@@ -0,0 +1,49 @@
+class SolrInstance
+  include ActsAsSolr::InstanceMethods
+  attr_accessor :configuration, :solr_configuration, :name
+
+  class << self
+    include ActsAsSolr::ActsMethods
+    include ActsAsSolr::ClassMethods
+  end
+
+  def initialize(name = "Chunky bacon!")
+    @name = name
+  end
+  
+  def self.primary_key
+    "id"
+  end
+  
+  def logger
+    @logger ||= Logger.new(StringIO.new)
+  end
+  
+  def record_id(obj)
+    10
+  end
+  
+  def boost_rate
+    10.0
+  end
+  
+  def irate
+    8.0
+  end
+
+  def name_for_solr
+    name
+  end
+  
+  def id_for_solr
+    "bogus"
+  end
+  
+  def type_for_solr
+    "humbug"
+  end
+  
+  def get_solr_field_type(args)
+    "s"
+  end
+end

data/test/unit/test_helper.rb

@@ -0,0 +1,24 @@
+dir = File.dirname(__FILE__)
+$:.unshift(File.join(File.expand_path(dir), "..", "..", "lib"))
+
+require 'rubygems'
+require 'test/unit'
+require 'acts_as_solr'
+require 'activesupport'
+require 'mocha'
+require 'active_support'
+require 'logger'
+require File.expand_path("#{dir}/solr_instance")
+require File.expand_path("#{dir}/parser_instance")
+require 'erb'
+require 'ostruct'
+
+if RUBY_VERSION =~ /^1\.9/
+  puts "\nRunning the unit test suite doesn't as of yet work with Ruby 1.9, because Mocha hasn't yet been updated to use minitest."
+  puts
+  exit 1
+end
+
+require 'mocha'
+gem 'thoughtbot-shoulda'
+require 'shoulda'

metadata

@@ -0,0 +1,241 @@
+--- !ruby/object:Gem::Specification 
+name: muck-solr
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Mathias Meyer, Joel Duffin, Justin Ball
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-15 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: "This gem adds full text search capabilities and many other nifty features from Apache\xEF\xBF\xBDs Solr to any Rails model. I'm currently rearranging the test suite to include a real unit test suite, and adding a few features I need myself."
+email: meyer@paperplanes.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+- README.rdoc
+files: 
+- CHANGE_LOG
+- LICENSE
+- README.markdown
+- README.rdoc
+- Rakefile
+- TESTING_THE_PLUGIN
+- VERSION.yml
+- config/solr.yml
+- config/solr_environment.rb
+- lib/acts_as_solr.rb
+- lib/acts_as_solr/acts_methods.rb
+- lib/acts_as_solr/class_methods.rb
+- lib/acts_as_solr/common_methods.rb
+- lib/acts_as_solr/deprecation.rb
+- lib/acts_as_solr/instance_methods.rb
+- lib/acts_as_solr/lazy_document.rb
+- lib/acts_as_solr/parser_methods.rb
+- lib/acts_as_solr/search_results.rb
+- lib/acts_as_solr/solr_fixtures.rb
+- lib/acts_as_solr/tasks.rb
+- lib/acts_as_solr/tasks/database.rake
+- lib/acts_as_solr/tasks/solr.rake
+- lib/acts_as_solr/tasks/test.rake
+- lib/solr.rb
+- lib/solr/connection.rb
+- lib/solr/document.rb
+- lib/solr/exception.rb
+- lib/solr/field.rb
+- lib/solr/importer.rb
+- lib/solr/importer/array_mapper.rb
+- lib/solr/importer/delimited_file_source.rb
+- lib/solr/importer/hpricot_mapper.rb
+- lib/solr/importer/mapper.rb
+- lib/solr/importer/solr_source.rb
+- lib/solr/importer/xpath_mapper.rb
+- lib/solr/indexer.rb
+- lib/solr/request.rb
+- lib/solr/request/add_document.rb
+- lib/solr/request/base.rb
+- lib/solr/request/commit.rb
+- lib/solr/request/delete.rb
+- lib/solr/request/dismax.rb
+- lib/solr/request/index_info.rb
+- lib/solr/request/modify_document.rb
+- lib/solr/request/optimize.rb
+- lib/solr/request/ping.rb
+- lib/solr/request/select.rb
+- lib/solr/request/spellcheck.rb
+- lib/solr/request/standard.rb
+- lib/solr/request/update.rb
+- lib/solr/response.rb
+- lib/solr/response/add_document.rb
+- lib/solr/response/base.rb
+- lib/solr/response/commit.rb
+- lib/solr/response/delete.rb
+- lib/solr/response/dismax.rb
+- lib/solr/response/index_info.rb
+- lib/solr/response/modify_document.rb
+- lib/solr/response/optimize.rb
+- lib/solr/response/ping.rb
+- lib/solr/response/ruby.rb
+- lib/solr/response/select.rb
+- lib/solr/response/spellcheck.rb
+- lib/solr/response/standard.rb
+- lib/solr/response/xml.rb
+- lib/solr/solrtasks.rb
+- lib/solr/util.rb
+- lib/solr/xml.rb
+- solr/CHANGES.txt
+- solr/LICENSE.txt
+- solr/NOTICE.txt
+- solr/etc/jetty.xml
+- solr/etc/webdefault.xml
+- solr/lib/easymock.jar
+- solr/lib/jetty-6.1.3.jar
+- solr/lib/jetty-util-6.1.3.jar
+- solr/lib/jsp-2.1/ant-1.6.5.jar
+- solr/lib/jsp-2.1/core-3.1.1.jar
+- solr/lib/jsp-2.1/jsp-2.1.jar
+- solr/lib/jsp-2.1/jsp-api-2.1.jar
+- solr/lib/servlet-api-2.4.jar
+- solr/lib/servlet-api-2.5-6.1.3.jar
+- solr/lib/xpp3-1.1.3.4.O.jar
+- solr/solr/README.txt
+- solr/solr/bin/abc
+- solr/solr/bin/abo
+- solr/solr/bin/backup
+- solr/solr/bin/backupcleaner
+- solr/solr/bin/commit
+- solr/solr/bin/optimize
+- solr/solr/bin/readercycle
+- solr/solr/bin/rsyncd-disable
+- solr/solr/bin/rsyncd-enable
+- solr/solr/bin/rsyncd-start
+- solr/solr/bin/rsyncd-stop
+- solr/solr/bin/scripts-util
+- solr/solr/bin/snapcleaner
+- solr/solr/bin/snapinstaller
+- solr/solr/bin/snappuller
+- solr/solr/bin/snappuller-disable
+- solr/solr/bin/snappuller-enable
+- solr/solr/bin/snapshooter
+- solr/solr/conf/admin-extra.html
+- solr/solr/conf/protwords.txt
+- solr/solr/conf/schema.xml
+- solr/solr/conf/scripts.conf
+- solr/solr/conf/solrconfig.xml
+- solr/solr/conf/stopwords.txt
+- solr/solr/conf/synonyms.txt
+- solr/solr/conf/xslt/example.xsl
+- solr/solr/conf/xslt/example_atom.xsl
+- solr/solr/conf/xslt/example_rss.xsl
+- solr/start.jar
+- solr/webapps/solr.war
+- test/config/solr.yml
+- test/db/connections/mysql/connection.rb
+- test/db/connections/sqlite/connection.rb
+- test/db/migrate/001_create_books.rb
+- test/db/migrate/002_create_movies.rb
+- test/db/migrate/003_create_categories.rb
+- test/db/migrate/004_create_electronics.rb
+- test/db/migrate/005_create_authors.rb
+- test/db/migrate/006_create_postings.rb
+- test/db/migrate/007_create_posts.rb
+- test/db/migrate/008_create_gadgets.rb
+- test/fixtures/authors.yml
+- test/fixtures/books.yml
+- test/fixtures/categories.yml
+- test/fixtures/db_definitions/mysql.sql
+- test/fixtures/electronics.yml
+- test/fixtures/movies.yml
+- test/fixtures/postings.yml
+- test/functional/acts_as_solr_test.rb
+- test/functional/association_indexing_test.rb
+- test/functional/faceted_search_test.rb
+- test/functional/multi_solr_search_test.rb
+- test/models/author.rb
+- test/models/book.rb
+- test/models/category.rb
+- test/models/electronic.rb
+- test/models/gadget.rb
+- test/models/movie.rb
+- test/models/novel.rb
+- test/models/post.rb
+- test/models/posting.rb
+- test/test_helper.rb
+- test/unit/acts_methods_shoulda.rb
+- test/unit/class_methods_shoulda.rb
+- test/unit/common_methods_shoulda.rb
+- test/unit/instance_methods_shoulda.rb
+- test/unit/lazy_document_shoulda.rb
+- test/unit/parser_instance.rb
+- test/unit/parser_methods_shoulda.rb
+- test/unit/solr_instance.rb
+- test/unit/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mattmatt/acts_as_solr
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: muck-solr
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: "This gem adds full text search capabilities and many other nifty features from Apache\xEF\xBF\xBDs Solr to any Rails model. I'm currently rearranging the test suite to include a real unit test suite, and adding a few features I need myself."
+test_files: 
+- test/db/connections/mysql/connection.rb
+- test/db/connections/sqlite/connection.rb
+- test/db/migrate/001_create_books.rb
+- test/db/migrate/002_create_movies.rb
+- test/db/migrate/003_create_categories.rb
+- test/db/migrate/004_create_electronics.rb
+- test/db/migrate/005_create_authors.rb
+- test/db/migrate/006_create_postings.rb
+- test/db/migrate/007_create_posts.rb
+- test/db/migrate/008_create_gadgets.rb
+- test/functional/acts_as_solr_test.rb
+- test/functional/association_indexing_test.rb
+- test/functional/faceted_search_test.rb
+- test/functional/multi_solr_search_test.rb
+- test/models/author.rb
+- test/models/book.rb
+- test/models/category.rb
+- test/models/electronic.rb
+- test/models/gadget.rb
+- test/models/movie.rb
+- test/models/novel.rb
+- test/models/post.rb
+- test/models/posting.rb
+- test/test_helper.rb
+- test/unit/acts_methods_shoulda.rb
+- test/unit/class_methods_shoulda.rb
+- test/unit/common_methods_shoulda.rb
+- test/unit/instance_methods_shoulda.rb
+- test/unit/lazy_document_shoulda.rb
+- test/unit/parser_instance.rb
+- test/unit/parser_methods_shoulda.rb
+- test/unit/solr_instance.rb
+- test/unit/test_helper.rb