microwave 0.1006.33 → 1.0.0

data/spec/unit/solr_query/solr_http_request_spec.rb

@@ -0,0 +1,244 @@
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+require 'chef/solr_query'
+require 'net/http'
+
+describe Chef::SolrQuery::SolrHTTPRequest do
+  before do
+    Chef::Config[:solr_url] = "http://example.com:8983"
+    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
+    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@url_prefix, nil)
+
+    @request = Chef::SolrQuery::SolrHTTPRequest.new(:GET, '/solr/select')
+  end
+
+  it "defaults to using the configured solr_url" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://example.com:8983"
+  end
+
+  it "supports solr_url with a path" do
+    Chef::Config[:solr_url] = "http://example.com:8983/test"
+    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
+
+    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://example.com:8983/test"
+  end
+
+  it "updates the Solr URL as you like" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
+    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://chunkybacon.org:1234"
+  end
+
+  it "updates the URL prefix with a path" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/something"
+    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/something"
+  end
+
+  it "removes extra / at the end of solr_url" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/extra/"
+    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/extra"
+  end
+
+  it "creates a Net::HTTP client for the base Solr URL" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
+    http_client = Chef::SolrQuery::SolrHTTPRequest.http_client
+    http_client.address.should == "chunkybacon.org"
+    http_client.port.should == 1234
+  end
+
+  it "creates a Net::HTTP client for the base Solr URL ignoring the path" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/test"
+    http_client = Chef::SolrQuery::SolrHTTPRequest.http_client
+    http_client.address.should == "chunkybacon.org"
+    http_client.port.should == 1234
+  end
+
+  it "defaults url_prefix to /solr if the configured solr_url has no path" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
+    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/solr"
+  end
+
+  it "defaults url_prefix to the path from the configured solr_url" do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/test"
+    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/test"
+  end
+
+  describe "when configured with the Solr URL" do
+    before do
+      @http_response = mock(
+        "Net::HTTP::Response",
+        :kind_of? => Net::HTTPSuccess,
+        :body => "{ :some => :hash }"
+      )
+      @http_request = mock(
+        "Net::HTTP::Request",
+        :body= => true
+      )
+      @http = mock("Net::HTTP", :request => @http_response)
+      Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
+    end
+
+    describe "when executing a select query" do
+      before(:each) do
+        @http_response = mock(
+          "Net::HTTP::Response",
+          :kind_of? => Net::HTTPSuccess,
+          :body => '{"some": "hash" }'
+        )
+        @solr = Chef::SolrQuery.from_params(:type => 'node',
+                                            :q => "hostname:latte")
+        @params = @solr.to_hash
+        @http = mock("Net::HTTP", :request => @http_response)
+        Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
+      end
+
+      describe "when the HTTP call is successful" do
+        it "should call get to /solr/select with the escaped query" do
+          txfm_query = "q=content%3Ahostname__%3D__latte"
+          Net::HTTP::Get.should_receive(:new).with(%r(/solr/select?.+#{txfm_query}))
+          Chef::SolrQuery::SolrHTTPRequest.select(@params)
+        end
+
+        it "uses Solr's JSON response format" do
+          Net::HTTP::Get.should_receive(:new).with(%r(wt=json))
+          Chef::SolrQuery::SolrHTTPRequest.select(@params)
+        end
+
+        it "uses indent=off to get a compact response" do
+          Net::HTTP::Get.should_receive(:new).with(%r(indent=off))
+          Chef::SolrQuery::SolrHTTPRequest.select(@params)
+        end
+
+        it "uses the filter query to restrict the result set" do
+          filter_query =@solr.filter_query.gsub('+', '%2B').gsub(':', "%3A").gsub(' ', '+')
+          Net::HTTP::Get.should_receive(:new).with(/fq=#{Regexp.escape(filter_query)}/)
+          Chef::SolrQuery::SolrHTTPRequest.select(@params)
+        end
+
+        it "returns the evaluated response body" do
+          res = Chef::SolrQuery::SolrHTTPRequest.select(@params)
+          res.should == {"some" => "hash" }
+        end
+      end
+    end
+
+    describe "when updating" do
+      before do
+        Net::HTTP::Post.stub!(:new).and_return(@http_request)
+      end
+
+      it "should post to /solr/update" do
+        @doc = "<xml is the old tldr>"
+        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
+        Chef::SolrQuery::SolrHTTPRequest.update(@doc)
+      end
+
+      it "should set the body of the request to the stringified doc" do
+        @http_request.should_receive(:body=).with("foo")
+        Chef::SolrQuery::SolrHTTPRequest.update(:foo)
+      end
+
+      it "should send the request to solr" do
+        @http.should_receive(:request).with(@http_request).and_return(@http_response)
+        Chef::SolrQuery::SolrHTTPRequest.update(:foo)
+      end
+
+    end
+
+    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
+          response = mock("Net:HTTPResponse test double", :code => 500, :message => "oops", :class => exception)
+          @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_return(response)
+          response.should_receive(:error!).and_raise(exception)
+          Chef::Log.should_receive(:fatal).with("Search Query to Solr failed (#{exception} 500 oops)")
+
+          lambda {@request.run('Search Query to Solr')}.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
+        @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("HTTP Request to Solr failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED (net/http undefined method closed?) attempting to contact http://example.com:8983")
+        lambda {
+          @request.run
+        }.should raise_error(Chef::Exceptions::SolrConnectionError)
+      end
+    end
+
+  end
+
+  describe "when configured with the Solr URL with a path" do
+    before do
+      Chef::Config[:solr_url] = "http://example.com:8983/test"
+      Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
+      Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@url_prefix, nil)
+
+      @request = Chef::SolrQuery::SolrHTTPRequest.new(:GET, '/solr/select')
+
+      @http_response = mock(
+        "Net::HTTP::Response",
+        :kind_of? => Net::HTTPSuccess,
+        :body => "{ :some => :hash }"
+      )
+      @http_request = mock(
+        "Net::HTTP::Request",
+        :body= => true
+      )
+      @http = mock("Net::HTTP", :request => @http_response)
+      Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
+    end
+
+    describe "when executing a select query" do
+      before(:each) do
+        @http_response = mock(
+          "Net::HTTP::Response",
+          :kind_of? => Net::HTTPSuccess,
+          :body => '{"some": "hash" }'
+        )
+        @solr = Chef::SolrQuery.from_params(:type => 'node',
+                                            :q => "hostname:latte")
+        @params = @solr.to_hash
+        @http = mock("Net::HTTP", :request => @http_response)
+        Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
+      end
+
+      describe "when the HTTP call is successful" do
+        it "should call get to /test/select with the escaped query" do
+          txfm_query = "q=content%3Ahostname__%3D__latte"
+          Net::HTTP::Get.should_receive(:new).with(%r(/test/select?.+#{txfm_query}))
+          Chef::SolrQuery::SolrHTTPRequest.select(@params)
+        end
+      end
+    end
+
+    describe "when updating" do
+      before do
+        Net::HTTP::Post.stub!(:new).and_return(@http_request)
+      end
+
+      it "should post to /test/update" do
+        @doc = "<xml is the old tldr>"
+        Net::HTTP::Post.should_receive(:new).with("/test/update", "Content-Type" => "text/xml").and_return(@http_request)
+        Chef::SolrQuery::SolrHTTPRequest.update(@doc)
+      end
+    end
+  end
+end

data/spec/unit/solr_query_spec.rb

@@ -0,0 +1,203 @@
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010, 2011 Opscode, inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+require 'chef/solr_query'
+require 'net/http'
+
+#require 'rspec/mocks'
+
+describe Chef::SolrQuery do
+  before do
+    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://example.com:8983"
+
+    @http_response = mock(
+      "Net::HTTP::Response",
+      :kind_of? => Net::HTTPSuccess,
+      :body => "{ :some => :hash }"
+    )
+    @http_request = mock(
+      "Net::HTTP::Request",
+      :body= => true
+    )
+    @http = mock("Net::HTTP", :request => @http_response)
+    Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
+    Net::HTTP::Post.stub!(:new).and_return(@http_request)
+    Net::HTTP::Get.stub!(:new).and_return(@http_request)
+    @doc = { "foo" => "bar" }
+  end
+
+  before(:each) do
+    @solr = Chef::SolrQuery.new
+  end
+
+  it "sets filter query params" do
+    @solr.filter_by(:database => 'chef')
+    @solr.filter_query.should == "+X_CHEF_database_CHEF_X:chef"
+  end
+
+  it "filters by type when querying for a builtin type" do
+    @solr.filter_by_type("node")
+    @solr.filter_query.should == "+X_CHEF_type_CHEF_X:node"
+  end
+
+  it "filters by type for data bag items" do
+    @solr.filter_by_type("users")
+    @solr.filter_query.split(" ").sort.should == ['+X_CHEF_type_CHEF_X:data_bag_item', '+data_bag:users']
+  end
+
+  it "stores the main query" do
+    @solr.query = "role:prod AND tags:chef-server"
+    @solr.query.should == "role:prod AND tags:chef-server"
+  end
+
+  describe "when generating query params for select" do
+    before(:each) do
+      @solr = Chef::SolrQuery.from_params(:type => 'node', :q => "hostname:latte")
+      @params = @solr.to_hash
+    end
+
+    it "includes the query as q" do
+      @params[:q].should == "content:hostname__=__latte"
+    end
+
+    it "sets the response format to json" do
+      @params[:wt].should == "json"
+    end
+
+    it "uses indent=off to get a compact response" do
+      @params[:indent].should == "off"
+    end
+
+    it "includes the filter query to restrict the result set" do
+      @params[:fq].should == @solr.filter_query
+    end
+
+    it "defaults to returning 1000 rows" do
+      @params[:rows].should == 1000
+    end
+
+    it "returns the number of rows requested" do
+      @solr.params[:rows] = 500
+      @solr.to_hash[:rows].should == 500
+    end
+
+    it "offsets the row selection if requested" do
+      @solr.params[:start] = 500
+      @solr.to_hash[:start].should == 500
+    end
+
+  end
+
+  describe "when querying solr" do
+    before do
+      @couchdb = mock("CouchDB Test Double", :couchdb_database => "chunky_bacon")
+      @couchdb.stub!(:kind_of?).with(Chef::CouchDB).and_return(true) #ugh.
+      @solr = Chef::SolrQuery.from_params({:type => 'node', :q => "hostname:latte", :start => 10, :rows => 5}, @couchdb)
+      @docs = [1,2,3,4,5].map { |doc_id| {'X_CHEF_id_CHEF_X' => doc_id} }
+      @solr_response = {"response" => {"docs" => @docs, "start" => 10, "results" => 123}}
+      Chef::SolrQuery::SolrHTTPRequest.should_receive(:select).with(@solr.to_hash).and_return(@solr_response)
+    end
+
+    it "it collects the document ids from the response" do
+      @solr.object_ids.should == [1,2,3,4,5]
+    end
+
+    it "does a bulk get of the objects from CouchDB" do
+      @couchdb.should_receive(:bulk_get).with([1,2,3,4,5]).and_return(%w{obj1 obj2 obj3 obj4 obj5})
+      @solr.objects.should == %w{obj1 obj2 obj3 obj4 obj5}
+    end
+
+  end
+
+  describe "when forcing a Solr commit" do
+    it "sends valid commit xml to solr" do
+      Chef::SolrQuery::SolrHTTPRequest.should_receive(:update).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<commit/>\n")
+      @solr.commit
+    end
+  end
+
+  describe "when deleting a database from Solr" do
+    it "sends a valid delete query to solr and forces a commit" do
+      Chef::SolrQuery::SolrHTTPRequest.should_receive(:update).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><query>X_CHEF_database_CHEF_X:chef</query></delete>\n")
+      @solr.should_receive(:commit)
+      @solr.delete_database("chef")
+    end
+  end
+
+  describe "rebuilding the index" do
+    before do
+      Chef::Config[:couchdb_database] = "chunky_bacon"
+    end
+
+    it "deletes the index and commits" do
+      @solr.should_receive(:delete_database).with("chunky_bacon")
+      @solr.stub!(:reindex_all)
+      Chef::DataBag.stub!(:cdb_list).and_return([])
+      @solr.rebuild_index
+    end
+
+    it "reindexes Chef::ApiClient, Chef::Node, and Chef::Role objects, reporting the results as a hash" do
+      @solr.should_receive(:delete_database).with("chunky_bacon")
+      @solr.should_receive(:reindex_all).with(Chef::ApiClient).and_return(true)
+      @solr.should_receive(:reindex_all).with(Chef::Environment).and_return(true)
+      @solr.should_receive(:reindex_all).with(Chef::Node).and_return(true)
+      @solr.should_receive(:reindex_all).with(Chef::Role).and_return(true)
+      Chef::DataBag.stub!(:cdb_list).and_return([])
+
+      result = @solr.rebuild_index
+      result["Chef::ApiClient"].should == "success"
+      result["Chef::Node"].should == "success"
+      result["Chef::Role"].should == "success"
+    end
+
+    it "does not reindex Chef::OpenIDRegistration or Chef::WebUIUser objects" do
+      # hi there. the reason we're specifying this behavior is because these objects
+      # are not properly indexed in the first place and trying to reindex them
+      # tickles a bug in our CamelCase to snake_case code. See CHEF-1009.
+      @solr.should_receive(:delete_database).with("chunky_bacon")
+      @solr.stub!(:reindex_all).with(Chef::ApiClient)
+      @solr.stub!(:reindex_all).with(Chef::Node)
+      @solr.stub!(:reindex_all).with(Chef::Role)
+      @solr.should_not_receive(:reindex_all).with(Chef::OpenIDRegistration)
+      @solr.should_not_receive(:reindex_all).with(Chef::WebUIUser)
+      Chef::DataBag.stub!(:cdb_list).and_return([])
+
+      @solr.rebuild_index
+    end
+
+    it "reindexes databags" do
+      one_data_item = Chef::DataBagItem.new
+      one_data_item.raw_data = {"maybe"=>"snakes actually are evil", "id" => "just_sayin"}
+      two_data_item = Chef::DataBagItem.new
+      two_data_item.raw_data = {"tone_depth"=>"rumble_fish", "id" => "eff_yes"}
+      data_bag = Chef::DataBag.new
+      data_bag.stub!(:list).and_return([one_data_item, two_data_item])
+
+      @solr.should_receive(:delete_database).with("chunky_bacon")
+      @solr.stub!(:reindex_all)
+      Chef::DataBag.stub!(:cdb_list).and_return([data_bag])
+
+      data_bag.should_receive(:add_to_index)
+      one_data_item.should_receive(:add_to_index)
+      two_data_item.should_receive(:add_to_index)
+
+      @solr.rebuild_index["Chef::DataBag"].should == "success"
+    end
+  end
+end

data/spec/unit/util/file_edit_spec.rb

@@ -0,0 +1,135 @@
+#
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Util::FileEdit do
+
+  before(:each) do
+
+    @hosts_content=<<-HOSTS
+127.0.0.1       localhost
+255.255.255.255 broadcasthost
+::1             localhost
+fe80::1%lo0     localhost
+HOSTS
+
+    @tempfile = Tempfile.open('file_edit_spec')
+    @tempfile.write(@hosts_content)
+    @tempfile.close
+    @fedit = Chef::Util::FileEdit.new(@tempfile.path)
+  end
+
+  after(:each) do
+    @tempfile && @tempfile.close!
+  end
+
+  describe "initialiize" do
+    it "should create a new Chef::Util::FileEdit object" do
+      Chef::Util::FileEdit.new(@tempfile.path).should be_kind_of(Chef::Util::FileEdit)
+    end
+
+    it "should throw an exception if the input file does not exist" do
+      lambda{Chef::Util::FileEdit.new("nonexistfile")}.should raise_error
+    end
+
+    it "should throw an exception if the input file is blank" do
+      lambda do
+        Chef::Util::FileEdit.new(File.join(CHEF_SPEC_DATA, "filedit", "blank"))
+      end.should raise_error
+    end
+  end
+
+  describe "search_file_replace" do
+    it "should accept regex passed in as a string (not Regexp object) and replace the match if there is one" do
+      @fedit.search_file_replace("localhost", "replacement")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should match(/replacement/)
+    end
+
+    it "should accept regex passed in as a Regexp object and replace the match if there is one" do
+      @fedit.search_file_replace(/localhost/, "replacement")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should match(/replacement/)
+    end
+
+    it "should do nothing if there isn't a match" do
+      @fedit.search_file_replace(/pattern/, "replacement")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should_not match(/replacement/)
+    end
+  end
+
+  describe "search_file_replace_line" do
+    it "should search for match and replace the whole line" do
+      @fedit.search_file_replace_line(/localhost/, "replacement line")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should match(/replacement/)
+      newfile[0].should_not match(/127/)
+    end
+  end
+
+  describe "search_file_delete" do
+    it "should search for match and delete the match" do
+      @fedit.search_file_delete(/localhost/)
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should_not match(/localhost/)
+      newfile[0].should match(/127/)
+    end
+  end
+
+  describe "search_file_delete_line" do
+    it "should search for match and delete the matching line" do
+      @fedit.search_file_delete_line(/localhost/)
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[0].should_not match(/localhost/)
+      newfile[0].should match(/broadcasthost/)
+    end
+  end
+
+  describe "insert_line_after_match" do
+    it "should search for match and insert the given line after the matching line" do
+      @fedit.insert_line_after_match(/localhost/, "new line inserted")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[1].should match(/new/)
+    end
+  end
+
+  describe "insert_line_if_no_match" do
+    it "should search for match and insert the given line if no line match" do
+      @fedit.insert_line_if_no_match(/pattern/, "new line inserted")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile.last.should match(/new/)
+    end
+
+    it "should do nothing if there is a match" do
+      @fedit.insert_line_if_no_match(/localhost/, "replacement")
+      @fedit.write_file
+      newfile = File.new(@tempfile.path).readlines
+      newfile[1].should_not match(/replacement/)
+    end
+  end
+end