microwave 0.1006.33 → 1.0.0

data/spec/unit/formatters/error_inspectors/run_list_expansion_error_inspector_spec.rb

@@ -0,0 +1,93 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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::Formatters::ErrorInspectors::RunListExpansionErrorInspector do
+  before do
+    @node = Chef::Node.new.tap do |n|
+      n.name("unit-test.example.com")
+      n.run_list("role[base]")
+    end
+
+    @description = Chef::Formatters::ErrorDescription.new("Error Expanding RunList:")
+    @outputter = Chef::Formatters::Outputter.new(StringIO.new, STDERR)
+    #@outputter = Chef::Formatters::Outputter.new(STDOUT, STDERR)
+  end
+
+  describe "when explaining a missing role error" do
+
+    before do
+      @run_list_expansion = Chef::RunList::RunListExpansion.new("_default", @node.run_list)
+      @run_list_expansion.missing_roles_with_including_role << [ "role[missing-role]", "role[base]" ]
+      @run_list_expansion.missing_roles_with_including_role << [ "role[another-missing-role]", "role[base]" ]
+
+      @exception = Chef::Exceptions::MissingRole.new(@run_list_expansion)
+
+
+      @inspector = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a pretty message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining an HTTP 403 error" do
+    before do
+
+      @response_body = "forbidden"
+      @response = Net::HTTPForbidden.new("1.1", "403", "(response) forbidden")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) forbidden", @response)
+      @inspector = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
+      @inspector.stub!(:config).and_return(:node_name => "unit-test.example.com")
+
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a pretty message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining an HTTP 401 error" do
+    before do
+      @response_body = "check your key and node name"
+      @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
+
+      @inspector = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
+      @inspector.stub!(:config).and_return(:node_name => "unit-test.example.com",
+                                           :client_key => "/etc/chef/client.pem",
+                                           :chef_server_url => "http://chef.example.com")
+
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a pretty message" do
+      @description.display(@outputter)
+    end
+  end
+
+end
+

data/spec/unit/handler/json_file_spec.rb

@@ -0,0 +1,64 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2010 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::Handler::JsonFile do
+  before(:each) do
+    @handler = Chef::Handler::JsonFile.new(:the_sun => "will rise", :path => '/tmp/foobarbazqux')
+  end
+
+  it "accepts arbitrary config options" do
+    @handler.config[:the_sun].should == "will rise"
+  end
+
+  it "creates the directory where the reports will be saved" do
+    FileUtils.should_receive(:mkdir_p).with('/tmp/foobarbazqux')
+    File.should_receive(:chmod).with(00700, '/tmp/foobarbazqux')
+    @handler.build_report_dir
+  end
+
+  describe "when reporting success" do
+    before(:each) do
+      @node = Chef::Node.new
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_status = Chef::RunStatus.new(@node, @events)
+      @expected_time = Time.now
+      Time.stub(:now).and_return(@expected_time, @expected_time + 5)
+      @run_status.start_clock
+      @run_status.stop_clock
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+      @run_status.run_context = @run_context
+      @run_status.exception = Exception.new("Boy howdy!")
+      @file_mock = StringIO.new
+      File.stub!(:open).and_yield(@file_mock)
+    end
+
+
+    it "saves run status data to a file as JSON" do
+      @handler.should_receive(:build_report_dir)
+      @handler.run_report_unsafe(@run_status)
+      reported_data = Chef::JSONCompat.from_json(@file_mock.string)
+      reported_data['exception'].should == "Exception: Boy howdy!"
+      reported_data['start_time'].should == @expected_time.to_s
+      reported_data['end_time'].should == (@expected_time + 5).to_s
+      reported_data['elapsed_time'].should == 5
+    end
+
+  end
+end

data/spec/unit/handler_spec.rb

@@ -0,0 +1,216 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2010 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::Handler do
+  before(:each) do
+    @handler = Chef::Handler.new
+
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_status = Chef::RunStatus.new(@node, @events)
+
+    @handler.instance_variable_set(:@run_status, @run_status)
+  end
+
+  describe "when accessing the run status" do
+    before do
+      @backtrace = caller
+      @exception = Exception.new("epic_fail")
+      @exception.set_backtrace(@backtrace)
+      @run_status.exception = @exception
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+      @all_resources = [Chef::Resource::Cat.new('lolz'), Chef::Resource::ZenMaster.new('tzu')]
+      @all_resources.first.updated = true
+      @run_context.resource_collection.all_resources.replace(@all_resources)
+      @run_status.run_context = @run_context
+      @start_time = Time.now
+      @end_time = @start_time + 4.2
+      Time.stub!(:now).and_return(@start_time, @end_time)
+      @run_status.start_clock
+      @run_status.stop_clock
+    end
+
+    it "has a shortcut for the exception" do
+      @handler.exception.should == @exception
+    end
+
+    it "has a shortcut for the backtrace" do
+      @handler.backtrace.should == @backtrace
+    end
+
+    it "has a shortcut for all resources" do
+      @handler.all_resources.should == @all_resources
+    end
+
+    it "has a shortcut for just the updated resources" do
+      @handler.updated_resources.should == [@all_resources.first]
+    end
+
+    it "has a shortcut for the start time" do
+      @handler.start_time.should == @start_time
+    end
+
+    it "has a shortcut for the end time" do
+      @handler.end_time.should == @end_time
+    end
+
+    it "has a shortcut for the elapsed time" do
+      @handler.elapsed_time.should == 4.2
+    end
+
+    it "has a shortcut for the node" do
+      @handler.node.should == @node
+    end
+
+    it "has a shortcut for the run context" do
+      @handler.run_context.should == @run_context
+    end
+
+    it "has a shortcut for the success? and failed? predicates" do
+      @handler.success?.should be_false # becuase there's an exception
+      @handler.failed?.should be_true
+    end
+
+    it "has a shortcut to the hash representation of the run status" do
+      @handler.data.should == @run_status.to_hash
+    end
+  end
+
+  describe "when running the report" do
+    it "does not fail if the report handler raises an exception" do
+      $report_ran = false
+      def @handler.report
+        $report_ran = true
+        raise Exception, "I died the deth"
+      end
+      lambda {@handler.run_report_safely(@run_status)}.should_not raise_error
+      $report_ran.should be_true
+    end
+    it "does not fail if the report handler does not raise an exception" do
+      $report_ran = false
+      def @handler.report
+        $report_ran = true
+        puts "I'm AOK here."
+      end
+      lambda {@handler.run_report_safely(@run_status)}.should_not raise_error
+      $report_ran.should be_true
+    end
+  end
+
+  # Hmm, no tests for report handlers, looks like
+  describe "when running a report handler" do
+    before do
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+      @all_resources = [Chef::Resource::Cat.new('foo'), Chef::Resource::ZenMaster.new('moo')]
+      @all_resources.first.updated = true
+      @run_context.resource_collection.all_resources.replace(@all_resources)
+      @run_status.run_context = @run_context
+      @start_time = Time.now
+      @end_time = @start_time + 4.2
+      Time.stub!(:now).and_return(@start_time, @end_time)
+      @run_status.start_clock
+      @run_status.stop_clock 
+    end
+    
+    it "has a shortcut for all resources" do
+      @handler.all_resources.should == @all_resources
+    end
+
+    it "has a shortcut for just the updated resources" do
+      @handler.updated_resources.should == [@all_resources.first]
+    end
+
+    it "has a shortcut for the start time" do
+      @handler.start_time.should == @start_time
+    end
+
+    it "has a shortcut for the end time" do
+      @handler.end_time.should == @end_time
+    end
+
+    it "has a shortcut for the elapsed time" do
+      @handler.elapsed_time.should == 4.2
+    end
+
+    it "has a shortcut for the node" do
+      @handler.node.should == @node
+    end
+
+    it "has a shortcut for the run context" do
+      @handler.run_context.should == @run_context
+    end
+
+    it "has a shortcut for the success? and failed? predicates" do
+      @handler.success?.should be_true 
+      @handler.failed?.should be_false
+    end
+
+    it "has a shortcut to the hash representation of the run status" do
+      @handler.data.should == @run_status.to_hash
+    end
+  end
+
+  # and this would test the start handler
+  describe "when running a start handler" do
+    before do
+      @start_time = Time.now
+      Time.stub!(:now).and_return(@start_time)
+      @run_status.start_clock
+    end
+
+    it "should not have all resources" do
+      @handler.all_resources.should be_false
+    end
+
+    it "should not have updated resources" do
+      @handler.updated_resources.should be_false
+    end
+
+    it "has a shortcut for the start time" do
+      @handler.start_time.should == @start_time
+    end
+
+    it "does not have a shortcut for the end time" do
+      @handler.end_time.should be_false
+    end
+
+    it "does not have a shortcut for the elapsed time" do
+      @handler.elapsed_time.should be_false
+    end
+
+    it "has a shortcut for the node" do
+      @handler.node.should == @node
+    end
+
+    it "does not have a shortcut for the run context" do
+      @handler.run_context.should be_false
+    end
+
+    it "has a shortcut for the success? and failed? predicates" do
+      @handler.success?.should be_true # for some reason this is true
+      @handler.failed?.should be_false
+    end
+
+    it "has a shortcut to the hash representation of the run status" do
+      @handler.data.should == @run_status.to_hash
+    end
+  end
+
+end

data/spec/unit/index_queue_spec.rb

@@ -0,0 +1,391 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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'
+
+class Chef
+  class IndexableTestHarness
+    include Chef::IndexQueue::Indexable
+    attr_reader :couchdb_id
+    def couchdb_id=(value)
+      self.index_id = @couchdb_id = value
+    end
+    attr_reader :index_id
+    def index_id=(value)
+        @index_id = value
+    end
+
+    def to_hash
+      {"ohai_world" => "I am IndexableTestHarness", "object_id" => object_id}
+    end
+
+  end
+end
+
+class IndexQueueSpecError < RuntimeError ; end
+
+class FauxQueue
+
+  attr_reader :published_message, :publish_options
+
+  # Note: If publish is not called, this published_message will cause
+  # JSON parsing to die with "can't convert Symbol into String"
+  def initialize
+    @published_message = :epic_fail!
+    @publish_options = :epic_fail!
+  end
+
+  def publish(message, options=nil)
+    @published_message = message
+    @publish_options = options
+  end
+end
+
+class IndexConsumerTestHarness
+  include Chef::IndexQueue::Consumer
+  
+  attr_reader :last_indexed_object, :unexposed_attr
+  
+  expose :index_this
+  
+  def index_this(object_to_index)
+    @last_indexed_object = object_to_index
+  end
+  
+  def not_exposed(arg)
+    @unexposed_attr = arg
+  end
+end
+
+describe Chef::IndexQueue::Indexable do
+  def a_uuid
+    /[0-9a-f]{8}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{12}/
+  end
+  
+  before do
+    Chef::IndexableTestHarness.reset_index_metadata!
+    @publisher      = Chef::IndexQueue::AmqpClient.instance
+    @indexable_obj  = Chef::IndexableTestHarness.new
+    @item_as_hash   = {"ohai_world" => "I am IndexableTestHarness", "object_id" => @indexable_obj.object_id}
+
+    @now = Time.now
+    Time.stub!(:now).and_return(@now)
+  end
+  
+  it "downcases the class name for the index_object_type when it's not explicitly set" do
+    @indexable_obj.index_object_type.should == "indexable_test_harness"
+  end
+  
+  it "uses an explicitly set index_object_type" do
+    Chef::IndexableTestHarness.index_object_type :a_weird_name
+    @indexable_obj.index_object_type.should == "a_weird_name"
+  end
+  
+  it "adds 'database', 'type', and 'id' (UUID) keys to the published object" do
+    with_metadata = @indexable_obj.with_indexer_metadata(:database => "foo", :id=>UUIDTools::UUID.random_create.to_s)
+    with_metadata.should have(5).keys
+    with_metadata.keys.should include("type", "id", "item", "database", "enqueued_at")
+    with_metadata["type"].should      == "indexable_test_harness"
+    with_metadata["database"].should  == "foo"
+    with_metadata["item"].should      == @item_as_hash
+    with_metadata["id"].should match(a_uuid)
+    with_metadata["enqueued_at"].should == @now.utc.to_i
+  end
+  
+  it "uses the couchdb_id if available" do
+    expected_uuid = "0000000-1111-2222-3333-444444444444"
+    @indexable_obj.couchdb_id = expected_uuid
+    metadata_id = @indexable_obj.with_indexer_metadata["id"]
+    metadata_id.should == expected_uuid
+  end
+
+  describe "adds and removes items to and from the index and respects Chef::Config[:persistent_queue]" do
+    before do
+      @exchange = mock("Bunny::Exchange")
+      @amqp_client = mock("Bunny::Client", :start => true, :exchange => @exchange)
+      @publisher.stub!(:amqp_client).and_return(@amqp_client)
+      @queue = FauxQueue.new
+      @publisher.should_receive(:queue_for_object).with("0000000-1111-2222-3333-444444444444").and_yield(@queue)
+      Chef::Config[:persistent_queue] = false
+    end
+
+    it "adds items to the index" do
+      @amqp_client.should_not_receive(:tx_select)
+      @amqp_client.should_not_receive(:tx_commit)
+      @amqp_client.should_not_receive(:tx_rollback)
+
+      @indexable_obj.add_to_index(:database => "couchdb@localhost,etc.", :id=>"0000000-1111-2222-3333-444444444444")
+
+      published_message = Chef::JSONCompat.from_json(@queue.published_message)
+      published_message.should == {"action" => "add", "payload" => {"item" => @item_as_hash,
+                                                                    "type" => "indexable_test_harness",
+                                                                    "database" => "couchdb@localhost,etc.",
+                                                                    "id" => "0000000-1111-2222-3333-444444444444",
+                                                                    "enqueued_at" => @now.utc.to_i}}
+      @queue.publish_options[:persistent].should == false
+    end
+
+    it "adds items to the index transactionactionally when Chef::Config[:persistent_queue] == true" do
+      @amqp_client.should_receive(:tx_select)
+      @amqp_client.should_receive(:tx_commit)
+      @amqp_client.should_not_receive(:tx_rollback)
+
+      # set and restore Chef::Config[:persistent_queue] to true
+      orig_value = Chef::Config[:persistent_queue]
+      Chef::Config[:persistent_queue] = true
+      begin
+        @indexable_obj.add_to_index(:database => "couchdb@localhost,etc.", :id=>"0000000-1111-2222-3333-444444444444")
+      ensure
+        Chef::Config[:persistent_queue] = orig_value
+      end
+
+      published_message = Chef::JSONCompat.from_json(@queue.published_message)
+      published_message.should == {"action" => "add", "payload" => {"item" => @item_as_hash,
+                                                                    "type" => "indexable_test_harness",
+                                                                    "database" => "couchdb@localhost,etc.",
+                                                                    "id" => "0000000-1111-2222-3333-444444444444",
+                                                                    "enqueued_at" => @now.utc.to_i}}
+      @queue.publish_options[:persistent].should == true
+    end
+
+    it "adds items to the index transactionally when Chef::Config[:persistent_queue] == true and rolls it back when there is a failure" do
+      @amqp_client.should_receive(:tx_select)
+      @amqp_client.should_receive(:tx_rollback)
+      @amqp_client.should_not_receive(:tx_commit)
+
+      # cause the publish to fail, and make sure the failure is our own
+      # by using a specific class
+      @queue.should_receive(:publish).and_raise(IndexQueueSpecError)
+
+      # set and restore Chef::Config[:persistent_queue] to true
+      orig_value = Chef::Config[:persistent_queue]
+      Chef::Config[:persistent_queue] = true
+      begin
+        lambda{
+          @indexable_obj.add_to_index(:database => "couchdb@localhost,etc.", :id=>"0000000-1111-2222-3333-444444444444")
+        }.should raise_error(IndexQueueSpecError)
+      ensure
+        Chef::Config[:persistent_queue] = orig_value
+      end
+    end
+
+    it "removes items from the index" do
+      @amqp_client.should_not_receive(:tx_select)
+      @amqp_client.should_not_receive(:tx_commit)
+      @amqp_client.should_not_receive(:tx_rollback)
+
+      @indexable_obj.delete_from_index(:database => "couchdb2@localhost", :id=>"0000000-1111-2222-3333-444444444444")
+      published_message = Chef::JSONCompat.from_json(@queue.published_message)
+      published_message.should == {"action" => "delete", "payload" => { "item" => @item_as_hash,
+                                                                        "type" => "indexable_test_harness",
+                                                                        "database" => "couchdb2@localhost",
+                                                                        "id" => "0000000-1111-2222-3333-444444444444",
+                                                                        "enqueued_at" => @now.utc.to_i}}
+      @queue.publish_options[:persistent].should == false
+    end
+  
+    it "removes items from the index transactionactionally when Chef::Config[:persistent_queue] == true" do
+      @amqp_client.should_receive(:tx_select)
+      @amqp_client.should_receive(:tx_commit)
+      @amqp_client.should_not_receive(:tx_rollback)
+
+      # set and restore Chef::Config[:persistent_queue] to true
+      orig_value = Chef::Config[:persistent_queue]
+      Chef::Config[:persistent_queue] = true
+      begin
+        @indexable_obj.delete_from_index(:database => "couchdb2@localhost", :id=>"0000000-1111-2222-3333-444444444444")
+      ensure
+        Chef::Config[:persistent_queue] = orig_value
+      end
+
+      published_message = Chef::JSONCompat.from_json(@queue.published_message)
+      published_message.should == {"action" => "delete", "payload" => { "item" => @item_as_hash,
+                                                                        "type" => "indexable_test_harness",
+                                                                        "database" => "couchdb2@localhost",
+                                                                        "id" => "0000000-1111-2222-3333-444444444444",
+                                                                        "enqueued_at" => @now.utc.to_i}}
+      @queue.publish_options[:persistent].should == true
+    end
+
+    it "remove items from the index transactionally when Chef::Config[:persistent_queue] == true and rolls it back when there is a failure" do
+      @amqp_client.should_receive(:tx_select)
+      @amqp_client.should_receive(:tx_rollback)
+      @amqp_client.should_not_receive(:tx_commit)
+
+      # cause the publish to fail, and make sure the failure is our own
+      # by using a specific class
+      @queue.should_receive(:publish).and_raise(IndexQueueSpecError)
+
+      # set and restore Chef::Config[:persistent_queue] to true
+      orig_value = Chef::Config[:persistent_queue]
+      Chef::Config[:persistent_queue] = true
+      begin
+        lambda{
+          @indexable_obj.delete_from_index(:database => "couchdb2@localhost", :id=>"0000000-1111-2222-3333-444444444444")      }.should raise_error(IndexQueueSpecError)
+      ensure
+        Chef::Config[:persistent_queue] = orig_value
+      end
+    end
+  end
+
+end
+
+describe Chef::IndexQueue::Consumer do
+  before do
+    @amqp_client  = Chef::IndexQueue::AmqpClient.instance
+    @consumer     = IndexConsumerTestHarness.new
+  end
+  
+  it "keeps a whitelist of exposed methods" do
+    IndexConsumerTestHarness.exposed_methods.should == [:index_this]
+    IndexConsumerTestHarness.whitelisted?(:index_this).should be_true
+    IndexConsumerTestHarness.whitelisted?(:not_exposed).should be_false
+  end
+  
+  it "doesn't route non-whitelisted methods" do
+    payload_json      = {"payload" => {"a_placeholder" => "object"}, "action" => "not_exposed"}.to_json
+    received_message  = {:payload => payload_json}
+    lambda {@consumer.call_action_for_message(received_message)}.should raise_error(ArgumentError)
+    @consumer.unexposed_attr.should be_nil
+  end
+  
+  it "routes message payloads to the correct method" do
+    payload_json      = {"payload" => {"a_placeholder" => "object"}, "action" => "index_this"}.to_json
+    received_message  = {:payload => payload_json}
+    @consumer.call_action_for_message(received_message)
+    @consumer.last_indexed_object.should == {"a_placeholder" => "object"}
+    
+  end
+  
+  it "subscribes to the queue for the indexer" do
+    payload_json  = {"payload" => {"a_placeholder" => "object"}, "action" => "index_this"}.to_json
+    message       = {:payload => payload_json}
+    queue = mock("Bunny::Queue")
+    @amqp_client.stub!(:queue).and_return(queue)
+    queue.should_receive(:subscribe).with(:timeout => false, :ack => true).and_yield(message)
+    @consumer.run
+    @consumer.last_indexed_object.should == {"a_placeholder" => "object"}
+  end
+  
+end
+
+
+describe Chef::IndexQueue::AmqpClient do
+  before do
+    Chef::Config[:amqp_host]        = '4.3.2.1'
+    Chef::Config[:amqp_port]        = '1337'
+    Chef::Config[:amqp_user]        = 'teh_rspecz'
+    Chef::Config[:amqp_pass]        = 'access_granted2rspec'
+    Chef::Config[:amqp_vhost]       = '/chef-specz'
+    Chef::Config[:amqp_consumer_id] = nil
+    
+    @publisher    = Chef::IndexQueue::AmqpClient.instance
+    @exchange     = mock("Bunny::Exchange")
+    
+    @amqp_client  = mock("Bunny::Client", :start => true, :exchange => @exchange)
+    def @amqp_client.connected?; false; end # stubbing predicate methods not working?
+    Bunny.stub!(:new).and_return(@amqp_client)
+    
+    @publisher.reset!
+  end
+  
+  after do
+    @publisher.disconnected!
+  end
+  
+  it "is a singleton" do
+    lambda {Chef::IndexQueue::Indexable::AmqpClient.new}.should raise_error
+  end
+  
+  it "creates an amqp client object on demand, starts a connection, and caches it" do
+    @amqp_client.should_receive(:start).once
+    @amqp_client.should_receive(:qos).with(:prefetch_count => 1)
+    ::Bunny.should_receive(:new).once.and_return(@amqp_client)
+    @publisher.amqp_client.should == @amqp_client
+    @publisher.amqp_client
+  end
+  
+  it "configures the amqp client with credentials from the config file" do
+    @publisher.reset!
+    Bunny.should_receive(:new).with(:spec => '08', :host => '4.3.2.1', :port => '1337', :user => "teh_rspecz",
+                                    :pass => "access_granted2rspec", :vhost => '/chef-specz').and_return(@amqp_client)
+    @amqp_client.should_receive(:qos).with(:prefetch_count => 1)
+    @publisher.amqp_client.should == @amqp_client
+  end
+  
+  it "creates an amqp exchange on demand and caches it" do
+    @amqp_client.stub!(:qos)
+    @publisher.exchange.should == @exchange
+    @amqp_client.should_not_receive(:exchange)
+    @publisher.exchange.should == @exchange
+  end
+  
+  describe "publishing" do
+
+    before do
+      @queue_1 = FauxQueue.new
+      @queue_2 = FauxQueue.new
+
+      @amqp_client.stub!(:qos)
+      #@amqp_client.stub!(:queue).and_return(@queue)
+      @data = {"some_data" => "in_a_hash"}
+    end
+  
+    it "resets the client upon a Bunny::ServerDownError when publishing" do
+      Bunny.stub!(:new).and_return(@amqp_client)
+      @amqp_client.should_receive(:queue).with("vnode-68", {:passive=>false, :durable=>true, :exclusive=>false, :auto_delete=>false}).twice.and_return(@queue_1, @queue_2)
+
+      @queue_1.should_receive(:publish).with(@data).and_raise(Bunny::ServerDownError)
+      @queue_2.should_receive(:publish).with(@data).and_raise(Bunny::ServerDownError)
+
+      @publisher.should_receive(:disconnected!).at_least(3).times
+      lambda {@publisher.queue_for_object("00000000-1111-2222-3333-444444444444") {|q| q.publish(@data)}}.should raise_error(Bunny::ServerDownError)
+    end
+    
+    it "resets the client upon a Bunny::ConnectionError when publishing" do
+      Bunny.stub!(:new).and_return(@amqp_client)
+      @amqp_client.should_receive(:queue).with("vnode-68", {:passive=>false, :durable=>true, :exclusive=>false, :auto_delete=>false}).twice.and_return(@queue_1, @queue_2)
+
+      @queue_1.should_receive(:publish).with(@data).and_raise(Bunny::ConnectionError)
+      @queue_2.should_receive(:publish).with(@data).and_raise(Bunny::ConnectionError)
+
+      @publisher.should_receive(:disconnected!).at_least(3).times
+      lambda {@publisher.queue_for_object("00000000-1111-2222-3333-444444444444") {|q| q.publish(@data)}}.should raise_error(Bunny::ConnectionError)
+    end
+    
+    it "resets the client upon a Errno::ECONNRESET when publishing" do
+      Bunny.stub!(:new).and_return(@amqp_client)
+      @amqp_client.should_receive(:queue).with("vnode-68", {:passive=>false, :durable=>true, :exclusive=>false, :auto_delete=>false}).twice.and_return(@queue_1, @queue_2)
+
+      @queue_1.should_receive(:publish).with(@data).and_raise(Errno::ECONNRESET)
+      @queue_2.should_receive(:publish).with(@data).and_raise(Errno::ECONNRESET)
+
+      @publisher.should_receive(:disconnected!).at_least(3).times
+      lambda {@publisher.queue_for_object("00000000-1111-2222-3333-444444444444") {|q| q.publish(@data)}}.should raise_error(Errno::ECONNRESET)
+    end
+    
+  end
+  
+  it "stops bunny and clears subscriptions" do
+    bunny_client  = mock("Bunny::Client")
+    @publisher.instance_variable_set(:@amqp_client, bunny_client)
+    bunny_client.should_receive(:stop)
+    @publisher.stop
+  end
+  
+end