delsolr 0.0.1 → 0.0.2

data/Manifest.txt

@@ -8,4 +8,6 @@ lib/delsolr/configuration.rb
 lib/delsolr/extensions.rb
 lib/delsolr/query_builder.rb
 lib/delsolr/response.rb
+lib/delsolr/document.rb
 lib/delsolr/version.rb
+

data/README.txt

@@ -15,6 +15,30 @@ while keeping the interface as ruby-esque as possible.
 
 See http://delsolr.rubyforge.org for more info
 
+Example:
+
+    c = DelSolr::Client.new(:server => 'solr1', :port => 8983)
+    rsp = c.query('dismax', :query => 'mp3 player',
+                            :filters => {:cost => (50..100)},
+                            :facets => [{:field => 'brand', :limit => 10},
+                                        {:query => {:onsale => true, :brand => 'Apple'},
+                                         :name => 'cheap_apple'}])
+
+    # output total matches
+    puts rsp.total
+
+    # output each id with score
+    rsp.docs.each { |doc| puts "#{doc[:id]} - #{doc[:score]}" }
+
+    # output each value for a facet
+    rsp.facet_field_values('brand').each do |brand|
+      puts "#{brand}: #{rsp.facet_field_count('brand', brand}"
+    end
+
+    # output a query facet
+    puts "Cheap Apple stuff: #{rsp.facet_query_count_by_name('cheap_apple')}"
+
+
 == REQUIREMENTS:
 
 You need Solr installed somewhere so you can query it ;)
@@ -23,11 +47,22 @@ You need Solr installed somewhere so you can query it ;)
 
 sudo gem install delsolr
 
+== TODO:
+
+ * finish unit tests (use mocha to stub out Net::HTTP)
+ * implement delete_by_query
+ * make thread safe
+   * it would be nice to be able to have things like commit/optimize be ran in threads on timers periodically
+   * right now a few things need to be locked
+     * connection
+     * pending_documents array
+
+
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008 FIXME full name
+Copyright (c) 2008 Avvo, INC - http://www.avvo.com
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/delsolr/configuration.rb

@@ -1,11 +1,12 @@
 module DelSolr
   class Client
     class Configuration
-      attr_accessor :server, :port    
+      attr_accessor :server, :port, :timeout
 
-      def initialize(server, port)
+      def initialize(server, port, timeout = 120)
         @server = server
         @port = port.to_i
+        @timeout = timeout || 120
       end
 
     end

data/lib/delsolr/document.rb

@@ -0,0 +1,82 @@
+module DelSolr
+  #
+  # DelSolr::Client::Document
+  # 
+  # Generally, indexing consists of iterating over your database, creating a huge xml buffer, and
+  # posting it to solr.  This wraps up the xml portion and DelSolr::Client wraps up the posting/batching
+  # portions.
+  # 
+  # This is what your indexing logic might look like if you're dealing w/ ActiveRecord objects:
+  # 
+  #          client = DelSolr::Client.new(:server => 'solr1', :port => 8983, :timout => 500)
+  #          models = SomeModel.find(:all)
+  #          models.each do |model|
+  #            doc = DelSolr::Document.new
+  #            doc.add_field('id', model.id)
+  #            doc.add_field('name', model.name)
+  #            model.tags.each do |tag| # multiple tag fields
+  #              doc.add_field('tag', tag.name)
+  #            end
+  #            client.update(doc) # batch the document update
+  #          end
+  #          client.post_update! # send the batch to solr
+  #          client.commit! # send the commit so solr updates the index
+  #  
+  # It's generally a good idea to experiment with different batch size.  500-2000 documents per post
+  # is a good starting point depending on how large your documents are.
+  # 
+  # You also may want to just update a signle document when it is changed.  Might looks like this:
+  # 
+  #          def after_save
+  #            doc = DelSolr::Document.new
+  #            doc.add_field('id', model.id)
+  #            doc.add_field('name', model.name)
+  #            $client.update_and_commit!(doc) # post the document and immediately post the commit
+  #          end
+  # 
+  #
+  class Document
+
+    # [<b><tt>field_mame</tt></b>]
+    #         is the name of the field in your schema.xml
+    # [<b><tt>value</tt></b>]
+    #         is the value of the field you wish to be indexed
+    # [<b><tt>options</tt></b>]
+    #         <b><tt>:cdata</tt></b>  set to true if you want the value wrap in a CDATA tag
+    #         
+    #         All other options are passed directly as xml attributes (see the solr documentation on usage)
+    def add_field(field_name, value, options = {})
+      field_buffer << construct_field_tag(field_name, value, options)
+    end
+
+    def xml
+      "<doc>\n" + field_buffer + "</doc>"
+    end
+
+    private
+
+    # creates xml field for given inputs
+    def construct_field_tag(name, value, options={})
+      options[:name] = name.to_s
+      use_cdata = options.delete(:cdata)
+      opts = []
+      options.each do |k,v| 
+        opts.push "#{k}=\"#{v}\""
+      end
+      opts = opts.join(" ")
+      opts = " " + opts if opts
+
+      return "<field#{opts}>#{use_cdata ? cdata(value) : value}</field>\n"
+    end  
+
+    def cdata(str)
+      "<![CDATA[#{str}]]>"
+    end
+
+    def field_buffer
+      @buffer ||= ""
+    end
+
+  end
+  
+end

data/lib/delsolr/query_builder.rb

@@ -6,6 +6,8 @@ module DelSolr
     
     class QueryBuilder
       
+      FL_DEFAULTS = 'id,unique_id,score' # redefine if you really want to change this.
+      
       attr_accessor :query_name, :options
 
       # ops can basically be straight solr URL params, but it also supports some other formats
@@ -19,19 +21,19 @@ module DelSolr
       def request_string
         @request_string ||= build_request_string
       end
-
+      
       # returns the query string of the facet query for the given query name (used for resolving counts for given queries)
       def facet_query_by_name(query_name)
         name_to_facet_query[query_name]
       end
       
     private
-
+      
       def build_request_string()
         raise "query_name must be set" if query_name.blank?
-
+        
         opts = self.options.dup
-
+        
         # cleanup the nils
         opts.delete_if {|k,v| v.nil?}
         
@@ -39,7 +41,7 @@ module DelSolr
         opts[:q] ||= opts[:query]
         opts[:rows] ||= opts[:limit] || 10
         opts[:start] ||= opts[:offset] || 0
-        opts[:fl] ||= opts[:fields] || 'id,unique_id,index_type,score'
+        opts[:fl] ||= opts[:fields] || FL_DEFAULTS
         opts[:bq] ||= opts[:boost]
         opts[:suggestionCount] ||= opts[:suggestion_count]
         opts[:onlyMorePopular] ||= opts[:only_more_popular]

data/lib/delsolr/response.rb

@@ -4,7 +4,7 @@ module DelSolr
   
     class Response
 
-      attr_reader :raw_response, :query_builder
+      attr_reader :query_builder
 
       def initialize(solr_response_buffer, query_builder, options = {})
         @query_builder = query_builder
@@ -26,91 +26,86 @@ module DelSolr
         end
       end
 
-      # returns the total number of matches
+      # Rreturns the "raw" ruby hash that is returned by the solr ruby response writer.  This is mostly for debugging purposes
+      def raw_response
+        @raw_response
+      end
+      
+      # Returns the total number of matches
       def total
         @total ||= raw_response['response']['numFound']
       end
       
+      # Returns true if there no results
       def blank?
-        total < 1
+        total.zero?
       end
       
       alias_method :empty?, :blank?
       
+      # Returns true if this response was pulled from the cache
       def from_cache?
         @from_cache
       end
       
-      # returns the offset
+      # Returns the offset that was given in the request
       def offset
         @offset ||= raw_response['response']['start']
       end
 
-      # returns the max score
+      # Returns the max score of the result set
       def max_score
         @max_score ||= raw_response['response']['maxScore'].to_f
       end
 
-      # returns an array of all ids for the given search
-      def ids
-        @ids ||= docs.collect {|d| d['id']}
-      end
-      
-      def unique_ids
-        @unique_ids ||= docs.collect {|d| d['unique_id']}
-      end
-
-      # returns an array of all the docs
+      # Returns an array of all the docs
       def docs
         @docs ||= raw_response['response']['docs']
       end
       
-      # helper for displaying a given field (first tries the highlight, then the stored value)
+      # Helper for displaying a given field (first tries the highlight, then the stored value)
       def display_for(doc, field)
         highlights_for(doc['unique_id'], field) || doc[field]
       end
       
-      # returns the highlights for a given id for a given field
+      # Returns the highlights for a given id for a given field
       def highlights_for(unique_id, field)
         raw_response['highlighting'] ||= {}
         raw_response['highlighting'][unique_id] ||= {}
         raw_response['highlighting'][unique_id][field]
       end
       
-      def suggestions
-        @suggestions ||= raw_response['suggestions']
-      end
-
-      # returns the query time in ms
+      # Returns the query time in ms
       def qtime
         @qtime ||= raw_response['responseHeader']['QTime'].to_i
       end
 
-      # returns the status code (0 for success)
+      # Returns the status code (0 for success)
       def status
         @status ||= raw_response['responseHeader']['status']
       end
 
-      # returns the params hash
+      # Returns the params hash
       def params
         @params ||= raw_response['responseHeader']['params']
       end
       
-      # returns the entire facet hash
+      # Returns the entire facet hash
       def facets
         @facets ||= raw_response['facet_counts'] || {}
       end
       
-      # returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
+      # Returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
       def facet_fields
         @facet_fields ||= facets['facet_fields'] || {}
       end
       
+      # Returns all of the facet queries
       def facet_queries
         @facet_queries ||= facets['facet_queries'] || {}
       end
       
-      # returns a hash of hashs rather than a hash of arrays (ie: {'instock_b' => {'true' => 123', 'false', => 20} })
+      # Returns a hash of hashs rather than a hash of arrays (ie: {'instock_b' => {'true' => 123', 'false', => 20} })
       def facet_fields_by_hash
         @facet_fields_by_hash ||= begin
           f = {}
@@ -128,12 +123,12 @@ module DelSolr
         end
       end
       
-      # returns an array of value/counts for a given field (ie: ['true', 123, 'false', 20]
+      # Returns an array of value/counts for a given field (ie: ['true', 123, 'false', 20]
       def facet_field(field)
         facet_fields[field.to_s]
       end
       
-      # returns the array of field values for the given field in the order they were returned from solr
+      # Returns the array of field values for the given field in the order they were returned from solr
       def facet_field_values(field)
         facet_field_values ||= {}
         facet_field_values[field.to_s] ||= begin
@@ -145,23 +140,23 @@ module DelSolr
         end
       end
       
-      # returns a hash of value/counts for a given field (ie: {'true' => 123, 'false' => 20}
+      # Returns a hash of value/counts for a given field (ie: {'true' => 123, 'false' => 20}
       def facet_field_by_hash(field)
         facet_fields_by_hash(field.to_s)
       end
       
-      # returns the count for the given field/value pair
+      # Returns the count for the given field/value pair
       def facet_field_count(field, value)
         facet_fields_by_hash[field.to_s][value.to_s] if facet_fields_by_hash[field.to_s]
       end
       
-      # returns the counts for a given facet_query_name
+      # Returns the counts for a given facet_query_name
       def facet_query_count_by_name(facet_query_name)
         query_string = query_builder.facet_query_by_name(facet_query_name)
         facet_queries[query_string] if query_string
       end
       
-      # returns the url send to solr
+      # Returns the url sent to solr
       def request_url
         query_builder.request_string
       end

data/lib/delsolr/version.rb

@@ -2,7 +2,7 @@ module DelSolr
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/delsolr.rb

@@ -6,6 +6,7 @@
 # see README.txt
 #
 
+
 require 'net/http'
 
 require 'digest/md5'
@@ -14,53 +15,136 @@ require File.join(File.dirname(__FILE__), 'delsolr', 'version')
 require File.join(File.dirname(__FILE__), 'delsolr', 'response')
 require File.join(File.dirname(__FILE__), 'delsolr', 'configuration')
 require File.join(File.dirname(__FILE__), 'delsolr', 'query_builder')
+require File.join(File.dirname(__FILE__), 'delsolr', 'document')
 require File.join(File.dirname(__FILE__), 'delsolr', 'extensions')
 
+
 module DelSolr
   
   class Client
     
-    attr_reader :configuration, :connection, :logger
+    attr_reader :configuration
     
-    # options
-    # :server - the server you want to connect to
-    # :port   - the port you want to connect to
-    # :cache  - [optional] a cache instance (any object the supports get and set)
-    # :shortcuts - [options] a list of values in the doc fields that generate short cuts for (defaults to [:id, :unique_id, :score]).
-    #           With the response you will then be able to do rsp.scores and have it return an array of scores.
-    def initialize(opts = {})
-      @configuration = DelSolr::Client::Configuration.new(opts[:server], opts[:port])
-      @cache = opts[:cache]
-      @shortcuts = opts[:shortcuts]
+    #
+    # [<b><tt>:server</tt></b>]
+    #   the server you want to connect to
+    #   
+    # [<b><tt>:port</tt></b>]
+    #   the port you want to connect to
+    #   
+    # [<b><tt>:cache</tt></b>]
+    #   (optional) a cache instance (any object the supports get and set)
+    # 
+    # [<b><tt>:shortcuts</tt></b>]
+    #   (options) a list of values in the doc fields to generate short cuts for (ie: [:scores, :id], you will be able to call <tt>rsp.scores</tt> and have it return an array of scores, likewise for <tt>ids</tt>.) Defaults to [:id, :unique_id, :score]
+    def initialize(options = {})
+      @configuration = DelSolr::Client::Configuration.new(options[:server], options[:port], options[:timeout])
+      @cache = options[:cache]
+      @shortcuts = options[:shortcuts]
     end
     
     #
     #
-    # query_name - type of query to perform (should match up w/ queries defined in solrconfig.xml)
+    # <tt>request_handler</tt> - type of query to perform (should match up w/ request handlers defined in solrconfig.xml)
+    # 
+    # 
+    # options 
+    # 
+    # [<b><tt>:query</tt></b>]
+    #   (required) effectively the 'q' param in the solr URL. The treatment of <tt>:query</tt> depends on the type
+    #   of request handler you are using.  The supported values are Strings and Hashes.  Any valid Lucene query string is acceptable
+    #   (ie: :query => "brand:apple" and :query => "apply" are both valid).  If given a Hash delsolr will build the appropriate
+    #   query string given a hash of fieldnames => values.  For instance, the following two queries are effectively the
+    #   same.  Both will end up passing "brand:apple" as the 'q' param to solr.
+    # 
+    #          c.query('standard', :query => {:brand => 'apple'})
+    #          c.query('standard', :query => "brand:apple")
+    # 
+    # [<b><tt>:filters</tt></b>]
+    #   (optional)array, string, or hash of additional filters to apply.  Filters end up in the 'fq' param in the solr query URL.
+    #   The value can be a String, Array of Strings, or Hash.  The following are all equivelent.  
+    # 
+    #          c.query('standard', :query => 'abc', :filters => {:instock => true})
+    #          c.query('standard', :query => 'abc', :filters => "instock:true")
+    #          c.query('standard', :query => 'abc', :filters => ["instock:true"])
+    #          
+    #   as are the following
+    #          
+    #          c.query('standard', :query => 'abc', :filters => {:instock => true, :onsale => true})
+    #          c.query('standard', :query => 'abc', :filters => ["instock:true", "onsale:true"])
+    #          
+    # 
+    # [<b><tt>:facets</tt></b>]
+    #   (optional) array of hashes for all the facet params (ie: {:field => 'instock_b', :limit => 15, :mincount => 5})
+    # 
+    #   <em>Faceting by field...</em>
+    #          
+    #          c.query('standard', :query => 'abc', :facets => [{:field => 'brand', :limit => 15, :mincount => 5}])
+    #          
+    #   ...will request counts for the 'brand' field name that have a minimum of 5 documents, returning
+    #   a max/limit of 15.  The counts for this facet can be pulled from the response like so:
+    #          
+    #          rsp.facet_field_count('brand', 'Apple') => 17 # returns count as fixnum
+    #          
+    #   The list of values for this facet can be pulled from the response like so:
+    #          
+    #          rsp.facet_field_values('brand') => ['Apple', 'Microsoft', 'Dell'] # returns an array of strings
+    #          
+    #   <em>Faceting by query...</em>
+    #   
+    #          c.query('standard', :query => 'abc',
+    #                              :facets => [:query => {:city => 'seattle', :instock => true},
+    #                                          :name => 'seattle_instock'}])
+    #          
+    #   ...will request counts for the number of documents where "seattle" matches on the "city" field and "instock" is set to true.
+    #   Faceting by query requires you to assign a name to the facet so the counts can easily be fetched from the response.  Solr 
+    #   resolves facet querys to count by the actual facet query string, which can be cumbersome.  The delsolr response object maintains
+    #   a mapping of query name => query string for you so your application only needs to remember the query name.
+    #    
+    #   The count for this facet query can be pulled like so:
+    #   
+    #          rsp.facet_query_count_by_name('seattle_instock').
     # 
+    # [<b><tt>:sorts</tt></b>]
+    #   (optional) array or string of sorts in Lucene syntax (<fieldname> <asc/desc>)
+    #   
+    #          c.query('standard', :query => 'abc', :sort => "product_name asc")
+    #          
+    #   
+    # [<b><tt>:limit</tt></b>]
+    #   (optional) number to return (defaults to 10).  (becomes the 'rows' param in the solr URL)
+    #   
+    #          c.query('standard', ;query => 'abc', :limit => 100)
     # 
-    # Possible options
-    # :query   - [required] unescape user input or solr query (can also be a hash {:field_name => value}).
-    # :filters - [optional] array, string, or hash of additional filters to apply
-    # :facet   - [optional] array of hashes for all the facet params (ie: {:field => 'instock_b', :limit => 15, :mincount => 5})
-    #            You can also specify facets using a query (ie: {:query => 'city_idm:seattle', :name => 'seattle'} or even 
-    #            {:query => {:city => 'seattle'}, :name => 'seattle'}) and then get counts for that facet by calling
-    #            rsp.facet_query_count_by_name('seattle').
-    #            
-    # :sorts   - [optional] array or string of sorts
-    # :limit   - [optional] number to return (defaults to 10)
-    # :offset  - [optional] offset (defaults to 0)
-    # :enable_caching - [optional] switch to control whether or not to use the cache (for fetching or setting)
+    # [<b><tt>:offset</tt></b>]
+    #   (optional) offset (defaults to 0, becomes the 'start' param in the solr URL)
+    #   
+    #          c.query('standard', :query => 'abc', :offset => 40)
+    #   
+    # [<b><tt>:enable_caching</tt></b>]
+    #   (optional) switch to control whether or not to use the cache (for fetching or setting) for the current query.  Only works if a cache store was passed to the constructor.
+    #
+    #          c = DelSolr::Client.new(:server => 'solr1', :port => 8983, :cache => SomeCacheStore.new)
+    #          c.query('standard', :query => 'abc', :filters => {:instock => true}, :enable_caching => true)
+    #          c.query('standard', :query => 'abc', :filters => {:instock => true}, :enable_caching => true) # this one should hit the cache
+    #          
+    #   Cache keys are created from MD5's of the solr URL that is generated.
+    #
+    # [<b><tt>:boot</tt></b>] becomes the 'bq' param which is used for query time boosting
+    # [<b><tt>:fields</tt></b>] becomes the 'fl' param which decides which fields to return.  Defaults to 'id,unique_id,score'
+    # 
+    # NOTE: Any unrecognized options will be passed along as URL params in the solr request URL.  This allows you to access solr features
+    # which are unsupported by DelSolr.
     #
     # Returns a DelSolr::Client::Response instance
-    def query(query_name, opts = {})
+    def query(request_handler, opts = {})
 
-      raise "query_name must be supplied" if query_name.blank?
+      raise "request_handler must be supplied" if request_handler.blank?
 
       enable_caching = opts.delete(:enable_caching) && !@cache.nil?
       ttl = opts.delete(:ttl) || 1.hours
 
-      query_builder = DelSolr::Client::QueryBuilder.new(query_name, opts)
+      query_builder = DelSolr::Client::QueryBuilder.new(request_handler, opts)
 
       # it's important that the QueryBuilder returns strings in a deterministic fashion
       # so that the cache keys will match for the same query.
@@ -74,12 +158,7 @@ module DelSolr
       end
 
       if body.blank? # cache miss (or wasn't enabled)
-
-        # only bother to create the connection if we know we failed to hit the cache
-        @connection ||= Net::HTTP.new(configuration.server, configuration.port)      
-        raise "Failed to connect to #{configuration.server}:#{configuration.port}" if @connection.nil?
-
-        header, body = @connection.get(query_builder.request_string)
+        header, body = connection.get(query_builder.request_string)
 
         # add to the cache if caching
         if enable_caching
@@ -92,6 +171,95 @@ module DelSolr
 
       DelSolr::Client::Response.new(body, query_builder, :from_cache => from_cache, :shortcuts => @shortcuts)
     end
+    
+    # Adds a document to the buffer to be posted to solr (NOTE: does not perform the actual post)
+    #
+    # [<b><tt>docs</tt></b>]
+    #            docs must be a DelSolr::Document or array of instances.  See DelSolr::Document for how to setup a document 
+    def update(docs)
+      self.pending_documents.push(*Array(docs))
+      true
+    end
+    
+    # Exactly like <tt>update</tt>, but performs the post immediately. Use <tt>update</tt> if you wish to batch document updates.
+    def update!(docs)
+      update(docs) && post_update!
+    end
+    
+    # Calls <tt>update!</tt> on the docs and then <tt>commit!</tt>
+    def update_and_commit!(docs)
+      update!(docs) && commit!
+    end
+    
+    # posts the buffer created by <tt>update</tt> to solr
+    def post_update!
+      h,b = post(prepare_update_xml())
+      success?(b)
+    end
+    
+    # deletes <tt>unique_id</tt> from the index
+    def delete(unique_id)
+      h,b = post("<delete><id>#{unique_id}</id></delete>")
+      success?(b)
+    end
+    
+    # not implemented
+    def delete_by_query(query)
+      raise 'not implemented yet :('
+    end
+    
+    # commits all pending adds/deletes
+    def commit!
+      h,b = post("<commit/>")
+      success?(b)
+    end
+    
+    # posts the optimize directive to solr
+    def optimize!
+      h,b = post("<optimize/>")
+      success?(b)
+    end
+
+    # accessor to the connection instance
+    def connection
+      @connection ||= begin
+        c = Net::HTTP.new(configuration.server, configuration.port)
+        c.read_timeout = configuration.timeout
+        raise "Failed to connect to #{configuration.server}:#{configuration.port}" if c.nil?
+        c
+      end
+    end
 
+    # clears out the connection so a new one will be created
+    def reset_connection!
+      @connection = nil
+    end
+    
+    # returns the array of documents that are waiting to be posted to solr
+    def pending_documents
+      @pending_documents ||= []
+    end
+    
+    private
+    
+    # returns the update xml buffer
+    def prepare_update_xml
+      r = ["<add>\n"]
+      # copy and clear pending docs
+      working_docs, @pending_documents = @pending_documents, nil
+      working_docs.each { |doc| r << doc.xml }
+      r << "\n</add>\n"
+      r.join # not sure, but I think Array#join is faster then String#<< for large buffers
+    end
+    
+    # helper for posting data to solr
+    def post(buffer)
+      connection.post('/solr/update', buffer, {'Content-type' => 'text/xml;charset=utf-8'})
+    end
+    
+    def success?(response_body)
+      response_body == '<result status="0"></result>'
+    end
+    
   end
 end

data/test/test_client.rb

@@ -1,9 +1,119 @@
 require File.dirname(__FILE__) + '/test_helper'
+require 'rubygems'
+gem 'mocha', '=0.9.0'
+require 'mocha'
 
 class ClientTest < Test::Unit::TestCase
 
   include Test::Unit::Assertions
   
+  SUCCESS = '<result status="0"></result>'
+  FAILURE = '<result status="1"></result>'
+  CONTENT_TYPE = {'Content-type' => 'text/xml;charset=utf-8'}
+  
+  class TestCache    
+    def set(k,v,t)
+      @cache ||= {}
+      @cache[k] = v
+    end
+    
+    def get(k)
+      @cache ||= {}
+      @cache[k]
+    end    
+  end
+  
+  @@response_buffer = %{
+    {
+     'responseHeader'=>{
+      'status'=>0,
+      'QTime'=>151,
+      'params'=>{
+            'wt'=>'ruby',
+            'rows'=>'10',
+            'explainOther'=>'',
+            'start'=>'0',
+            'hl.fl'=>'',
+            'indent'=>'on',
+            'hl'=>'on',
+            'q'=>'index_type:widget',
+            'fl'=>'*,score',
+            'qt'=>'standard',
+            'version'=>'2.2'}},
+     'response'=>{'numFound'=>1522698,'start'=>0,'maxScore'=>1.5583541,'docs'=>[
+            {
+             'index_type'=>'widget',
+             'id'=>1,
+             'unique_id'=>'1_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>3,
+             'unique_id'=>'3_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>4,
+             'unique_id'=>'4_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>5,
+             'unique_id'=>'5_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>7,
+             'unique_id'=>'7_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>8,
+             'unique_id'=>'8_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>9,
+             'unique_id'=>'9_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>10,
+             'unique_id'=>'10_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>11,
+             'unique_id'=>'11_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>12,
+             'unique_id'=>'12_widget',
+             'score'=>1.5583541}]
+     },
+     'facet_counts'=>{
+      'facet_queries'=>{
+        'city_idm:19596' => 392},
+      'facet_fields'=>{
+        'available_b'=>[
+          'false',1328],
+        'onsale_b'=>[
+          'false',1182,
+          'true',174]}},
+     'highlighting'=>{
+      '1_widget'=>{},
+      '3_widget'=>{},
+      '4_widget'=>{},
+      '5_widget'=>{},
+      '7_widget'=>{},
+      '8_widget'=>{},
+      '9_widget'=>{},
+      '10_widget'=>{},
+      '11_widget'=>{},
+      '12_widget'=>{}}}
+  }
+  
   def test_create
     s = nil
     assert_nothing_raised do
@@ -12,4 +122,96 @@ class ClientTest < Test::Unit::TestCase
     assert(s)
   end
   
+  def test_commit_success
+    c = setup_client
+    c.connection.expects(:post).once.returns([nil,SUCCESS])
+    assert(c.commit!)
+  end
+
+  def test_commit_failure
+    c = setup_client
+    c.connection.expects(:post).once.returns([nil,FAILURE])
+    assert(!c.commit!)
+  end
+  
+  def test_optimize_success
+    c = setup_client
+    c.connection.expects(:post).once.returns([nil,SUCCESS])
+    assert(c.optimize!)
+  end
+
+  def test_optimize_failure
+    c = setup_client
+    c.connection.expects(:post).once.returns([nil,FAILURE])
+    assert(!c.optimize!)
+  end
+  
+  def test_update
+    c = setup_client
+    
+    doc = DelSolr::Document.new
+    doc.add_field(:id, 123)
+    doc.add_field(:name, 'mp3 player')
+    
+    expected_post_data = "<add>\n#{doc.xml}\n</add>\n"
+    
+    assert(c.update(doc))
+    assert_equal(1, c.pending_documents.length)
+    
+    c.connection.expects(:post).with('/solr/update', expected_post_data, CONTENT_TYPE).returns([nil,SUCCESS])
+    assert(c.post_update!)
+    assert_equal(0, c.pending_documents.length)
+  end
+
+  def test_update!
+    c = setup_client
+    
+    doc = DelSolr::Document.new
+    doc.add_field(:id, 123)
+    doc.add_field(:name, 'mp3 player')
+    
+    expected_post_data = "<add>\n#{doc.xml}\n</add>\n"
+    
+    c.connection.expects(:post).with('/solr/update', expected_post_data, CONTENT_TYPE).returns([nil,SUCCESS])
+    assert(c.update!(doc))
+    assert_equal(0, c.pending_documents.length)
+  end
+  
+  def test_query
+    c = setup_client
+    
+    mock_query_builder = DelSolr::Client::QueryBuilder
+    mock_query_builder.stubs(:request_string).returns('/solr/select?some_query') # mock the query builder
+    DelSolr::Client::QueryBuilder.stubs(:new).returns(mock_query_builder)
+    c.connection.expects(:get).with(mock_query_builder.request_string).returns([nil, @@response_buffer]) # mock the connection
+    r = c.query('standard', :query => '123')
+    assert(r)
+    assert_equal([1,3,4,5,7,8,9,10,11,12], r.ids.sort)
+    assert(!r.from_cache?, 'should not be from cache')
+  end
+  
+  def test_query_from_cache
+    c = setup_client(:cache => TestCache.new)
+    
+    mock_query_builder = DelSolr::Client::QueryBuilder
+    mock_query_builder.stubs(:request_string).returns('/solr/select?some_query') # mock the query builder
+    DelSolr::Client::QueryBuilder.stubs(:new).returns(mock_query_builder)
+    c.connection.expects(:get).with(mock_query_builder.request_string).returns([nil, @@response_buffer]) # mock the connection
+    r = c.query('standard', :query => '123', :enable_caching => true)
+    assert(r)
+    assert_equal([1,3,4,5,7,8,9,10,11,12], r.ids.sort)
+    assert(!r.from_cache?, 'should not be from cache')
+
+    r = c.query('standard', :query => '123', :enable_caching => true)
+    assert(r)
+    assert_equal([1,3,4,5,7,8,9,10,11,12], r.ids.sort)
+    assert(r.from_cache?, 'this one should be from the cache')
+  end
+  
+private
+  
+  def setup_client(options = {})
+    DelSolr::Client.new({:server => 'localhost', :port => 8983}.merge(options))
+  end
+
 end

data/test/test_document.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DocumentTest < Test::Unit::TestCase
+
+  include Test::Unit::Assertions
+  
+  def test_create
+    d = DelSolr::Document.new
+    assert(d)
+    
+    d.add_field('person_name', 'John Smith')
+    
+    buf = "<doc>\n<field name=\"person_name\">John Smith</field>\n</doc>"
+    
+    assert_equal(buf, d.xml)
+  end
+  
+  def test_cdata
+    d = DelSolr::Document.new
+    assert(d)
+    
+    d.add_field('person_name', 'John Smith', :cdata => true)
+    
+    buf = "<doc>\n<field name=\"person_name\"><![CDATA[John Smith]]></field>\n</doc>"
+    
+    assert_equal(buf, d.xml)
+  end
+  
+end

data/test/test_query_builder.rb

@@ -89,7 +89,7 @@ class QueryBuilderTest < Test::Unit::TestCase
     assert_equal(p['q'], 'index_type:books')
   end
   
-  def test_facets
+  def test_facets_001
     qb = nil
     opts = {}
     opts[:query] = "games"
@@ -106,7 +106,7 @@ class QueryBuilderTest < Test::Unit::TestCase
     assert_equal(p['f.on_sale_b.facet.limit'], '1')
   end
   
-  def test_facets
+  def test_facets_002
     qb = nil
     opts = {}
     opts[:query] = "games"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delsolr
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ben VandenBos
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-08 00:00:00 -07:00
+date: 2008-10-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,6 +45,7 @@ files:
 - lib/delsolr/extensions.rb
 - lib/delsolr/query_builder.rb
 - lib/delsolr/response.rb
+- lib/delsolr/document.rb
 - lib/delsolr/version.rb
 has_rdoc: true
 homepage: http://delsolr.rubyforge.org
@@ -84,4 +85,5 @@ test_files:
 - test/test_response.rb
 - test/test_query_builder.rb
 - test/test_helper.rb
+- test/test_document.rb
 - test/test_client.rb