chef-solr 0.9.8 → 0.9.10.rc.0

data/bin/chef-solr-indexer

@@ -17,10 +17,11 @@
 # limitations under the License.
 #
 
+require 'rubygems'
+
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "chef", "lib")))
 
-require 'rubygems'
 require 'chef/solr/application/indexer'
 
 Chef::Solr::Application::Indexer.new.run

data/lib/chef/solr.rb

@@ -20,13 +20,6 @@ require 'chef/mixin/xml_escape'
 require 'chef/log'
 require 'chef/config'
 require 'chef/couchdb'
-require 'chef/role'
-require 'chef/node'
-require 'chef/data_bag'
-require 'chef/data_bag_item'
-require 'chef/api_client'
-require 'chef/openid_registration'
-require 'chef/webui_user'
 require 'net/http'
 require 'libxml'
 require 'uri'
@@ -55,11 +48,10 @@ class Chef
       select_url = "/solr/select?#{to_params(options)}"
       Chef::Log.debug("Sending #{select_url} to Solr")
       req = Net::HTTP::Get.new(select_url)
-      res = @http.request(req)
-      unless res.kind_of?(Net::HTTPSuccess)
-        Chef::Log.fatal("Search Query to Solr '#{select_url}' failed")
-        res.error!
-      end
+
+      description = "Search Query to Solr '#{solr_url}#{select_url}'"
+
+      res = http_request_handler(req, description)
       Chef::Log.debug("Parsing Solr result set:\n#{res.body}")
       eval(res.body)
     end
@@ -68,34 +60,37 @@ class Chef
       Chef::Log.debug("POSTing document to SOLR:\n#{doc}")
       req = Net::HTTP::Post.new("/solr/update", "Content-Type" => "text/xml")
       req.body = doc.to_s
-      res = @http.request(req)
-      unless res.kind_of?(Net::HTTPSuccess)
-        res.error!
-      end
-      res
+
+      description = "POST to Solr '#{solr_url}'"
+
+      http_request_handler(req, description)
     end
 
-    def solr_add(data)
-      data = [data] unless data.kind_of?(Array)
+    START_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc>"
+    END_XML   = "</doc></add>\n"
+    FIELD_ATTR = '<field name="'
+    FIELD_ATTR_END = '">'
+    CLOSE_FIELD = "</field>"
 
+    def solr_add(data)
       Chef::Log.debug("adding to SOLR: #{data.inspect}")
-      xml_document = LibXML::XML::Document.new
-      xml_add = LibXML::XML::Node.new("add")
-      data.each do |doc|
-        xml_doc = LibXML::XML::Node.new("doc")
-        doc.each do |field, values|
-          values = [values] unless values.kind_of?(Array)
-          values.each do |v|
-            xml_field = LibXML::XML::Node.new("field")
-            xml_field["name"] = field
-            xml_field.content = xml_escape(v.to_s)
-            xml_doc << xml_field
-          end
+
+      xml = ""
+      xml << START_XML
+
+      data.each do |field, values|
+        values.each do |v|
+          xml << FIELD_ATTR
+          xml << field
+          xml << FIELD_ATTR_END
+          xml <<  xml_escape(v)
+          xml << CLOSE_FIELD
         end
-        xml_add << xml_doc
       end
-      xml_document.root = xml_add
-      post_to_solr(xml_document.to_s(:indent => false))
+      xml << END_XML
+      xml
+
+      post_to_solr(xml)
     end
 
     def solr_commit(opts={})
@@ -210,6 +205,30 @@ class Chef
         '%'+$1.unpack('H2'*$1.size).join('%').upcase
       }.tr(' ', '+')
     end
+    
+    # handles multiple net/http exceptions and no method closed? bug
+    def http_request_handler(req, description='HTTP call')
+      res = @http.request(req)
+      unless res.kind_of?(Net::HTTPSuccess)
+        Chef::Log.fatal("#{description} failed (#{res.class} #{res.code} #{res.message})")
+        res.error!
+      end
+      res
+    rescue Timeout::Error, Errno::EINVAL, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, NoMethodError => e
+      # http://redmine.ruby-lang.org/issues/show/2708
+      # http://redmine.ruby-lang.org/issues/show/2758
+      if e.to_s =~ /#{Regexp.escape(%q|undefined method 'closed?' for nil:NilClass|)}/
+        Chef::Log.fatal("#{description} failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED (net/http undefined method closed?) attempting to contact #{@solr_url}")
+        Chef::Log.debug("rescued error in http connect, treating it as Errno::ECONNREFUSED to hide bug in net/http")
+        Chef::Log.debug(e.backtrace.join("\n"))
+        raise Chef::Exceptions::SolrConnectionError, "Errno::ECONNREFUSED: Connection refused attempting to contact #{@solr_url}"
+      end
+
+      Chef::Log.fatal("#{description} failed.  Chef::Exceptions::SolrConnectionError exception: #{e.class.name}: #{e.to_s} attempting to contact #{@solr_url}")
+      Chef::Log.debug(e.backtrace.join("\n"))
+
+      raise Chef::Exceptions::SolrConnectionError, "#{e.class.name}: #{e.to_s}"
+    end
 
   end
 end

data/lib/chef/solr/index.rb

@@ -6,9 +6,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -26,12 +26,24 @@ class Chef
   class Solr
     class Index < Solr
 
+      UNDERSCORE              = '_'
+      X                       = 'X'
+
+      X_CHEF_id_CHEF_X        = 'X_CHEF_id_CHEF_X'
+      X_CHEF_database_CHEF_X  = 'X_CHEF_database_CHEF_X'
+      X_CHEF_type_CHEF_X      = 'X_CHEF_type_CHEF_X'
+
       def add(id, database, type, item)
-        raise ArgumentError, "Object must respond to keys!" unless item.respond_to?(:keys)
+        unless item.respond_to?(:keys)
+          raise ArgumentError, "#{self.class.name} can only index Hash-like objects. You gave #{item.inspect}"
+        end
+
         to_index = flatten_and_expand(item)
-        to_index["X_CHEF_id_CHEF_X"] = id
-        to_index["X_CHEF_database_CHEF_X"] = database
-        to_index["X_CHEF_type_CHEF_X"] = type
+
+        to_index[X_CHEF_id_CHEF_X]        = [id]
+        to_index[X_CHEF_database_CHEF_X]  = [database]
+        to_index[X_CHEF_type_CHEF_X]      = [type]
+
         solr_add(to_index)
         to_index
       end
@@ -44,117 +56,48 @@ class Chef
         solr_delete_by_query(query)
       end
 
-      def flatten_and_expand(item, fields=Hash.new, parent=nil)
-        item.keys.each do |key|
-          # If we have a parent, we want to add the current key as a value 
-          if parent
-            # foo_bar = bar
-            set_field_value(fields, parent, key) 
-            # foo_X = bar, etc.
-            make_expando_fields(parent).each do |ex_key|
-              set_field_value(fields, ex_key, key)
-            end
-          end
-          case item[key]
-          when Hash
-            parent_key = parent ? "#{parent}_#{key}" : key
-            flatten_and_expand(item[key], fields, parent_key)
-          else
-            parent_key = parent ? "#{parent}_#{key}" : key
-            set_field_value(fields, key, item[key])
-            set_field_value(fields, parent_key, item[key]) if parent
-            make_expando_fields(parent_key).each do |ex_key|
-              set_field_value(fields, ex_key, item[key])
-            end
-          end
-        end
-        fields
-      end
-
-      def make_expando_fields(key)
-        key = key.to_s
-        fields = Array.new 
-        parts = key.split("_")
-        length = parts.length
-        parts.each_index do |i|
-          beginning = nil
-          remainder = nil
-          if i == 0
-            beginning = "X"
-          else
-            beginning = parts[0..i-1].join("_")
-          end
-
-          if i == length-1
-            remainder = "X"
-          else
-            remainder = parts[i+1..-1].join("_")
-          end
+      def flatten_and_expand(item)
+        @flattened_item = Hash.new {|hash, key| hash[key] = []}
 
-          if beginning == "X" || remainder == "X"
-            unless beginning == "X" && remainder == "X"
-              fields << "#{beginning}_#{remainder}" 
-            end
-          else
-            fields << "#{beginning}_X_#{remainder}"
-          end
+        item.each do |key, value|
+          flatten_each([key.to_s], value)
         end
-        fields
-      end
 
-      def set_field_value(fields, key, value)
-        key = key.to_s
-        if fields.has_key?(key)
-          convert_field_to_array(fields, key, value) unless fields[key].kind_of?(Array)
-          add_value_to_field_array(fields, key, value)
-        else
-          check_value(value)
-          if value.kind_of?(Array)
-            fields[key] = Array.new
-            value.each do |v|
-              if v.kind_of?(Hash)
-                flatten_and_expand(v, fields, key)
-              else
-                fields[key] << v.to_s
-              end    
-            end
-          else
-            fields[key] = value.to_s
-          end
-        end
-        fields
+        @flattened_item.each_value { |values| values.uniq! }
+        @flattened_item
       end
 
-      def add_value_to_field_array(fields, key, value)
-        check_value(value)
-        if value.kind_of?(Array)
-          value.each do |v|
-            if v.kind_of?(Hash)
-              flatten_and_expand(v, fields, key)
-            else
-              fields[key] << v.to_s unless fields[key].include?(v.to_s)
-            end    
+      def flatten_each(keys, values)
+        case values
+        when Hash
+          values.each do |child_key, child_value|
+            add_field_value(keys, child_key)
+            flatten_each(keys + [child_key.to_s], child_value)
           end
+        when Array
+          values.each { |child_value| flatten_each(keys, child_value) }
         else
-          fields[key] << value.to_s unless fields[key].include?(value.to_s)
+          add_field_value(keys, values)
         end
-        fields
       end
 
-      def convert_field_to_array(fields, key, value)
-        if fields[key] != value
-          safe = fields[key]
-          fields[key] = [ safe ]
-        end
-        fields
+      def add_field_value(keys, value)
+        value = value.to_s
+        each_expando_field(keys) { |expando_field| @flattened_item[expando_field] << value }
+        @flattened_item[keys.join(UNDERSCORE)] << value
+        @flattened_item[keys.last] << value
       end
 
-      def check_value(value)
-        raise ArgumentError, "Value must not be a type of hash!" if value.kind_of?(Hash)
-        value
+      def each_expando_field(keys)
+        return if keys.size == 1
+        0.upto(keys.size - 1) do |index|
+          original = keys[index]
+          keys[index] = X
+          yield keys.join(UNDERSCORE)
+          keys[index] = original
+        end
       end
 
     end
   end
 end
-

data/lib/chef/solr/index_queue_consumer.rb

@@ -20,12 +20,6 @@ require 'chef/log'
 require 'chef/config'
 require 'chef/solr'
 require 'chef/solr/index'
-require 'chef/node'
-require 'chef/role'
-require 'chef/rest'
-require 'chef/data_bag'
-require 'chef/data_bag_item'
-require 'chef/api_client'
 require 'chef/couchdb'
 require 'chef/index_queue'
 
@@ -41,7 +35,10 @@ class Chef
         Chef::Log.debug("Dequeued item for indexing: #{payload.inspect}")
 
         begin
-          pitem = payload["item"].to_hash                  
+          # older producers will send the raw item, and we no longer inflate it
+          # to an object.
+          pitem = payload["item"].to_hash
+          pitem.delete("json_class")
           response = generate_response { index.add(payload["id"], payload["database"], payload["type"], pitem) }                  
         rescue NoMethodError
           response = generate_response() { raise ArgumentError, "Payload item does not respond to :keys or :to_hash, cannot index!" }

data/lib/chef/solr/version.rb

@@ -1,5 +1,5 @@
 class Chef
   class Solr
-    VERSION = '0.9.8'
+    VERSION = '0.9.10.rc.0'
   end
 end

data/spec/chef/solr/index_spec.rb

@@ -1,5 +1,7 @@
 require File.expand_path(File.join("#{File.dirname(__FILE__)}", '..', '..', 'spec_helper'))
 
+
+
 describe Chef::Solr::Index do
   before(:each) do
     @index = Chef::Solr::Index.new
@@ -25,37 +27,36 @@ describe Chef::Solr::Index do
 
     it "should index the object as a single flat hash, with only strings or arrays as values" do
       validate = {
-        "X_CHEF_id_CHEF_X" => 1,
-        "X_CHEF_database_CHEF_X" => "monkey",
-        "X_CHEF_type_CHEF_X" => "snakes", 
-        "foo" => "bar",
+        "X_CHEF_id_CHEF_X" => [1],
+        "X_CHEF_database_CHEF_X" => ["monkey"],
+        "X_CHEF_type_CHEF_X" => ["snakes"],
+        "foo" => ["bar"],
         "battles" => [ "often", "but", "for" ],
-        "battles_often" => "sings like smurfs",
-        "often" => "sings like smurfs",
-        "battles_but" => "still has good records",
-        "but" => "still has good records",
+        "battles_often" => ["sings like smurfs"],
+        "often" => ["sings like smurfs"],
+        "battles_but" => ["still has good records"],
+        "but" => ["still has good records"],
         "battles_for" => [ "all", "of", "that" ],
         "for" => [ "all", "of", "that" ],
-        "snoopy" => "sits_in_a_barn",
+        "snoopy" => ["sits-in-a-barn"],
         "battles_X" => [ "sings like smurfs", "still has good records", "all", "of", "that" ],
-        "X_often" => "sings like smurfs",
-        "X_but" => "still has good records",
+        "X_often" =>[ "sings like smurfs"],
+        "X_but" => ["still has good records"],
         "X_for" => [ "all", "of", "that" ]
-      } 
-      to_index = @index.add(1, "monkey", "snakes", { 
+      }
+      to_index = @index.add(1, "monkey", "snakes", {
         "foo" => :bar,
-        "battles" => { 
+        "battles" => {
           "often" => "sings like smurfs",
           "but" => "still has good records",
           "for" => [ "all", "of", "that" ]
         },
-        "snoopy" => "sits_in_a_barn"
+        "snoopy" => "sits-in-a-barn"
       })
+
       validate.each do |k, v|
         if v.kind_of?(Array)
-          # Every entry in to_index[k] should be in v
-          r = to_index[k] & v
-          r.length.should == to_index[k].length
+          to_index[k].sort.should == v.sort
         else
           to_index[k].should == v
         end
@@ -88,101 +89,99 @@ describe Chef::Solr::Index do
     end
 
     it "should set a value for the parent as key, with the key as the value" do
-      @index.flatten_and_expand({ "one" => "woot" }, @fields, "omerta")
-      @fields["omerta"].should == "one"
+      @fields = @index.flatten_and_expand("omerta" => { "one" => "woot" })
+      @fields["omerta"].should == ["one"]
     end
 
     it "should call itself recursively for values that are hashes" do
-      @index.flatten_and_expand({ "one" => { "two" => "three", "four" => { "five" => "six" } }}, @fields)
-      {
-        "one" => [ "two", "four" ],
-        "one_two" => "three",
-        "X_two" => "three",
-        "two" => "three",
-        "one_four" => "five",
-        "X_four" => "five",
-        "one_X" => [ "three", "five" ],
-        "one_four_five" => "six", 
-        "X_four_five" => "six",
-        "one_X_five" => "six",
-        "one_four_X" => "six",
-        "five" => "six"
-      }.each do |k, v|
+      @fields = @index.flatten_and_expand({ "one" => { "two" => "three", "four" => { "five" => "six" } }})
+      expected = {"one" => [ "two", "four" ],
+                  "one_two" => ["three"],
+                  "X_two" => ["three"],
+                  "two" => ["three"],
+                  "one_four" => ["five"],
+                  "X_four" => ["five"],
+                  "one_X" => [ "three", "five" ],
+                  "one_four_five" => ["six"],
+                  "X_four_five" => ["six"],
+                  "one_X_five" => ["six"],
+                  "one_four_X" => ["six"],
+                  "five" => ["six"]}
+      expected.each do |k, v|
         @fields[k].should == v
       end
     end
 
     it "should call itself recursively for hashes nested in arrays" do
-      @index.flatten_and_expand({ :one => [ { :two => "three" }, { :four => { :five => "six" } } ] }, @fields)
-      {
-        "one_X_five" => "six",
-        "one_four" => "five",
-        "one_X" => [ "three", "five" ],
-        "two" => "three",
-        "one_four_X" => "six",
-        "X_four" => "five",
-        "X_four_five" => "six",
-        "one" => [ "two", "four" ],
-        "one_four_five" => "six",
-        "five" => "six",
-        "X_two" => "three",
-        "one_two" => "three"
-      }.each do |k, v|
-        @fields[k].should == v
+      @fields = @index.flatten_and_expand({ :one => [ { :two => "three" }, { :four => { :five => "six" } } ] })
+      expected = {"one_X_five" => ["six"],
+                  "one_four" => ["five"],
+                  "one_X" => [ "three", "five" ],
+                  "two" => ["three"],
+                  "one_four_X" => ["six"],
+                  "X_four" => ["five"],
+                  "X_four_five" => ["six"],
+                  "one" => [ "two", "four" ],
+                  "one_four_five" => ["six"],
+                  "five" => ["six"],
+                  "X_two" => ["three"],
+                  "one_two" => ["three"]}
+
+      expected.each do |key, expected_value|
+        @fields[key].should == expected_value
       end
     end
 
-  end
-
-  describe "set_field_value" do
-    before(:each) do
-      @fields = Hash.new
-    end
-
-    it "should set a value in the fields hash" do
-      @index.set_field_value(@fields, "one", "two")
-      @fields["one"].should eql("two")
-    end
-
-    it "should create an array of all values, if a field is set twice" do
-      @index.set_field_value(@fields, "one", "two")
-      @index.set_field_value(@fields, "one", "three")
-      @fields["one"].should eql([ "two", "three" ])
-    end
-
-    it "should not add duplicate values to a field when there is one string entry" do
-      @index.set_field_value(@fields, "one", "two")
-      @index.set_field_value(@fields, "one", "two")
-      @fields["one"].should eql("two")
-    end
-
-    it "should not add duplicate values to a field when it is an array" do
-      @index.set_field_value(@fields, "one", "two")
-      @index.set_field_value(@fields, "one", "three")
-      @index.set_field_value(@fields, "one", "two")
-      @fields["one"].should eql([ "two", "three" ])
-    end
-
-    it "should accept arrays as values" do
-      @index.set_field_value(@fields, "one", [ "two", "three" ])
-      @fields["one"].should eql([ "two", "three" ]) 
-    end
-
-    it "should not duplicate values when a field has been set with multiple arrays" do
-      @index.set_field_value(@fields, "one", [ "two", "three" ])
-      @index.set_field_value(@fields, "one", [ "two", "four" ])
-      @fields["one"].should eql([ "two", "three", "four" ]) 
+    it "generates unlimited levels of expando fields when expanding" do
+      expected_keys = ["one",
+                       "one_two",
+                       "X_two",
+                       "one_X",
+                       "one_two_three",
+                       "X_two_three",
+                       "one_X_three",
+                       "one_two_X",
+                       "one_two_three_four",
+                       "X_two_three_four",
+                       "one_X_three_four",
+                       "one_two_X_four",
+                       "one_two_three_X",
+                       "one_two_three_four_five",
+                       "X_two_three_four_five",
+                       "one_X_three_four_five",
+                       "one_two_X_four_five",
+                       "one_two_three_X_five",
+                       "one_two_three_four_X",
+                       "six",
+                       "one_two_three_four_five_six",
+                       "X_two_three_four_five_six",
+                       "one_X_three_four_five_six",
+                       "one_two_X_four_five_six",
+                       "one_two_three_X_five_six",
+                       "one_two_three_four_X_six",
+                       "one_two_three_four_five_X"].sort
+
+      nested = {:one => {:two => {:three => {:four => {:five => {:six => :end}}}}}}
+      @fields = @index.flatten_and_expand(nested)
+
+      @fields.keys.sort.should include(*expected_keys)
     end
 
+  end
 
-    it "should allow you to set a value in the fields hash to an array" do
-      @index.set_field_value(@fields, "one", [ "foo", "bar", "baz" ])
+  describe "creating expando fields" do
+    def make_expando_fields(parts)
+      expando_fields = []
+      @index.each_expando_field(parts) { |ex| expando_fields << ex }
+      expando_fields
     end
 
-    it "should not allow you to set a value in the fields hash to a hash" do
-      lambda {
-        @index.set_field_value(@fields, "one", { "two" => "three" })
-      }.should raise_error(ArgumentError)
+    it "joins the fields with a big X" do
+      make_expando_fields(%w{foo bar baz qux}).should == ["X_bar_baz_qux", "foo_X_baz_qux", "foo_bar_X_qux", "foo_bar_baz_X"]
+      make_expando_fields(%w{foo bar baz}).should == ["X_bar_baz", "foo_X_baz", "foo_bar_X"]
+      make_expando_fields(%w{foo bar}).should == ["X_bar", "foo_X"]
+      make_expando_fields(%w{foo}).should == []
     end
   end
+
 end

data/spec/chef/solr_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join("#{File.dirname(__FILE__)}", '..', 'spec_helper'))
+require 'net/http'
 
 describe Chef::Solr do
   before(:each) do 
@@ -27,33 +28,55 @@ describe Chef::Solr do
       @solr.http = @http
     end
 
-    it "should call get to /solr/select with the escaped query" do
-      Net::HTTP::Get.should_receive(:new).with(%r(q=hostname%3Alatte))
-      @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-    end
+    describe "when the HTTP call is successful" do
+      it "should call get to /solr/select with the escaped query" do
+        Net::HTTP::Get.should_receive(:new).with(%r(q=hostname%3Alatte))
+        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+      end
 
-    it "should call get to /solr/select with wt=ruby" do
-      Net::HTTP::Get.should_receive(:new).with(%r(wt=ruby))
-      @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-    end
+      it "should call get to /solr/select with wt=ruby" do
+        Net::HTTP::Get.should_receive(:new).with(%r(wt=ruby))
+        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+      end
 
-    it "should call get to /solr/select with indent=off" do
-      Net::HTTP::Get.should_receive(:new).with(%r(indent=off))
-      @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-    end
-     
-    it "should call get to /solr/select with filter query" do
-      Net::HTTP::Get.should_receive(:new).with(/fq=%2BX_CHEF_database_CHEF_X%3Achef_opscode\+%2BX_CHEF_type_CHEF_X%3Anode/)
-      @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+      it "should call get to /solr/select with indent=off" do
+        Net::HTTP::Get.should_receive(:new).with(%r(indent=off))
+        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+      end
+
+      it "should call get to /solr/select with filter query" do
+        Net::HTTP::Get.should_receive(:new).with(/fq=%2BX_CHEF_database_CHEF_X%3Achef_opscode\+%2BX_CHEF_type_CHEF_X%3Anode/)
+        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+      end
+
+      it "should return the evaluated response body" do
+        res = @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+        res.should == { :some => :hash }
+      end
     end
 
-    it "should return the evaluated response body" do
-      res = @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-      res.should == { :some => :hash }
+    describe "when the HTTP call is unsuccessful" do
+      [Timeout::Error, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EINVAL].each do |exception|
+        it "should rescue, log an error message, and raise a SolrConnectionError encountering exception #{exception}" do
+          lambda {
+            @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_raise(exception)
+            Chef::Log.should_receive(:fatal).with(/Search Query to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: #{exception}:.+/)
+            @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+          }.should raise_error(Chef::Exceptions::SolrConnectionError)
+        end
+      end
+
+      it "should rescue, log an error message, and raise a SolrConnectionError when encountering exception NoMethodError and net/http closed? bug" do
+        lambda {
+          @no_method_error = NoMethodError.new("undefined method 'closed\?' for nil:NilClass")
+          @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_raise(@no_method_error)
+          Chef::Log.should_receive(:fatal).with(/Search Query to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED.+net\/http undefined method closed.+/)
+          @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
+        }.should raise_error(Chef::Exceptions::SolrConnectionError)
+      end
     end
   end
 
-
   describe "post_to_solr" do
     before(:each) do
       @http_response = mock(
@@ -70,27 +93,60 @@ describe Chef::Solr do
       Net::HTTP::Post.stub!(:new).and_return(@http_request)
       @doc = { "foo" => "bar" }
     end
-  
-    it "should post to /solr/update" do
-      Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
-      @solr.post_to_solr(@doc)
-    end
 
-    it "should set the body of the request to the stringified doc" do
-      @http_request.should_receive(:body=).with("foo")
-      @solr.post_to_solr(:foo)
+    describe 'when the HTTP call is successful' do
+      it "should post to /solr/update" do
+        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
+        @solr.post_to_solr(@doc)
+      end
+
+      it "should set the body of the request to the stringified doc" do
+        @http_request.should_receive(:body=).with("foo")
+        @solr.post_to_solr(:foo)
+      end
+
+      it "should send the request to solr" do
+        @http.should_receive(:request).with(@http_request).and_return(@http_response)
+        @solr.post_to_solr(:foo).should
+      end
     end
 
-    it "should send the request to solr" do
-      @http.should_receive(:request).with(@http_request).and_return(@http_response)
-      @solr.post_to_solr(:foo)
+    describe "when the HTTP call is unsuccessful due to an exception" do
+      it "should post to /solr/update" do
+        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
+        @solr.post_to_solr(@doc)
+      end
+
+      it "should set the body of the request to the stringified doc" do
+        @http_request.should_receive(:body=).with("foo")
+        @solr.post_to_solr(:foo)
+      end
+
+      [Timeout::Error, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EINVAL].each do |exception|
+        it "should rescue and log an error message when encountering exception #{exception} and then re-raise it" do
+          lambda {
+            @http.should_receive(:request).with(@http_request).and_raise(exception)
+            Chef::Log.should_receive(:fatal).with(/POST to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: #{exception}:.+/)
+            @solr.post_to_solr(:foo)
+          }.should raise_error(Chef::Exceptions::SolrConnectionError)
+        end
+      end
+
+      it "should rescue and log an error message when encountering exception NoMethodError and net/http closed? bug" do
+        lambda {
+          @no_method_error = NoMethodError.new("undefined method 'closed\?' for nil:NilClass")
+          @http.should_receive(:request).with(@http_request).and_raise(@no_method_error)
+          Chef::Log.should_receive(:fatal).with(/POST to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED.+net\/http undefined method closed.+/)
+          @solr.post_to_solr(:foo)
+        }.should raise_error(Chef::Exceptions::SolrConnectionError)
+      end
     end
   end
 
   describe "solr_add" do
     before(:each) do
       @solr.stub!(:post_to_solr).and_return(true)
-      @data = { "foo" => "bar" }
+      @data = { "foo" => ["bar"] }
     end
 
     it "should send valid XML to solr" do
@@ -99,7 +155,7 @@ describe Chef::Solr do
     end
 
     it "XML escapes content before sending to SOLR" do
-      @data["foo"] = "<&>"
+      @data["foo"] = ["<&>"]
       @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc><field name=\"foo\">&lt;&amp;&gt;</field></doc></add>\n")
 
       @solr.solr_add(@data)
@@ -234,5 +290,4 @@ describe Chef::Solr do
       @solr.rebuild_index["Chef::DataBag"].should == "success"
     end
   end
-
 end

metadata

@@ -1,12 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: chef-solr
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 0
   - 9
-  - 8
-  version: 0.9.8
+  - 10
+  - rc
+  - 0
+  version: 0.9.10.rc.0
 platform: ruby
 authors: 
 - Adam Jacob
@@ -14,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-05 00:00:00 -07:00
+date: 2010-10-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,8 +60,10 @@ dependencies:
         segments: 
         - 0
         - 9
-        - 8
-        version: 0.9.8
+        - 10
+        - rc
+        - 0
+        version: 0.9.10.rc.0
   type: :runtime
   version_requirements: *id003
 description: 
@@ -114,11 +118,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: