microwave 1.0.4 → 11.400.2

data/spec/unit/checksum_spec.rb

@@ -1,94 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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'
-require 'chef/checksum'
-
-describe Chef::Checksum do
-
-  before do
-    Chef::Log.logger = Logger.new(StringIO.new)
-
-    @now = Time.now
-
-    Time.stub!(:now).and_return(@now)
-
-    @checksum_of_the_file = "3fafecfb15585ede6b840158cbc2f399"
-    @checksum = Chef::Checksum.new(@checksum_of_the_file)
-  end
-
-  it "has no original committed file location" do
-    @checksum.original_committed_file_location.should be_nil
-  end
-
-  it "has the MD5 checksum of the file it represents" do
-    @checksum.checksum.should == @checksum_of_the_file
-  end
-
-  it "stores the time it was created" do
-    @checksum.create_time.should == @now.iso8601
-  end
-
-  it "commits a sandbox file from a given location to the checksum repo location" do
-    @checksum.storage.should_receive(:commit).with("/tmp/arbitrary_file_location")
-    @checksum.should_receive(:cdb_save)
-    @checksum.commit_sandbox_file("/tmp/arbitrary_file_location")
-    @checksum.original_committed_file_location.should == "/tmp/arbitrary_file_location"
-  end
-
-  it "reverts committing a sandbox file" do
-    @checksum.storage.should_receive(:commit).with("/tmp/arbitrary_file_location")
-    @checksum.should_receive(:cdb_save)
-    @checksum.commit_sandbox_file("/tmp/arbitrary_file_location")
-    @checksum.original_committed_file_location.should == "/tmp/arbitrary_file_location"
-
-    @checksum.storage.should_receive(:revert).with("/tmp/arbitrary_file_location")
-    @checksum.should_receive(:cdb_destroy)
-    @checksum.revert_sandbox_file_commit
-  end
-
-  it "raises an error when trying to revert a checksum that was not previously committed" do
-    lambda {@checksum.revert_sandbox_file_commit}.should raise_error(Chef::Exceptions::IllegalChecksumRevert)
-  end
-
-  it "deletes the file and its document from couchdb" do
-    @checksum.should_receive(:cdb_destroy)
-    @checksum.storage.should_receive(:purge)
-    @checksum.purge
-  end
-
-  describe "when converted to json" do
-    before do
-      @checksum_as_json = @checksum.to_json
-      @checksum_as_hash_from_json = Chef::JSONCompat.from_json(@checksum_as_json, :create_additions => false)
-    end
-
-    it "contains the file's MD5 checksum" do
-      @checksum_as_hash_from_json["checksum"].should == @checksum_of_the_file
-    end
-
-    it "contains the creation time" do
-      @checksum_as_hash_from_json["create_time"].should == @now.iso8601
-    end
-
-    it "uses the file's MD5 checksum for its 'name' property" do
-      @checksum_as_hash_from_json["name"].should == @checksum_of_the_file
-    end
-  end
-
-end

data/spec/unit/couchdb_spec.rb

@@ -1,274 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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::CouchDB do
-  before(:each) do
-    Chef::Config[:couchdb_database] = "chef"
-    @rest = mock("Chef::REST")
-    @rest.stub!(:run_request).and_return({"couchdb" => "Welcome", "version" =>"0.9.0"})
-    @rest.stub!(:url).and_return("http://localhost:5984")
-    Chef::REST.stub!(:new).and_return(@rest)
-    @couchdb = Chef::CouchDB.new
-  end
-
-  describe "new" do
-    it "should create a new Chef::REST object from the default url" do
-      old_url = Chef::Config[:couchdb_url]
-      Chef::Config[:couchdb_url] = "http://monkey"
-      Chef::REST.should_receive(:new).with("http://monkey", nil, nil)
-      Chef::CouchDB.new
-      Chef::Config[:couchdb_url] = old_url
-    end
-
-    it "should create a new Chef::REST object from a provided url" do
-      Chef::REST.should_receive(:new).with("http://monkeypants", nil, nil)
-      Chef::CouchDB.new("http://monkeypants")
-    end
-  end
-
-  describe "create_db" do
-    before(:each) do
-      @couchdb.stub!(:create_design_document).and_return(true)
-    end
-
-    it "should get a list of current databases" do
-      @rest.should_receive(:get_rest).and_return(["chef"])
-      @couchdb.create_db
-    end
-
-    it "should create the chef database if it does not exist" do
-      @rest.stub!(:get_rest).and_return([])
-      @rest.should_receive(:put_rest).with("chef", {}).and_return(true)
-      @couchdb.create_db
-    end
-
-    it "should not create the chef database if it does exist" do
-      @rest.stub!(:get_rest).and_return(["chef"])
-      @rest.should_not_receive(:put_rest)
-      @couchdb.create_db
-    end
-
-    it "should return 'chef'" do
-      @rest.should_receive(:get_rest).with("_all_dbs").and_return(%w{chef})
-      @couchdb.create_db.should eql("chef")
-    end
-  end
-
-  describe "create_design_document" do
-    before(:each) do
-      @mock_design = {
-        "version" => 1,
-        "_rev" => 1
-      }
-      @mock_data = {
-        "version" => 1,
-        "language" => "javascript",
-        "views" => {
-          "all" => {
-            "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                emit(doc.name, doc);
-              }
-            }
-            EOJS
-          },
-        }
-      }
-      @rest.stub!(:get_rest).and_return(@mock_design)
-      @rest.stub!(:put_rest).and_return(true)
-      @couchdb.stub!(:create_db).and_return(true)
-    end
-
-    def do_create_design_document
-      @couchdb.create_design_document("bob", @mock_data)
-    end
-
-    it "should fetch the existing design document" do
-      @rest.should_receive(:get_rest).with("chef/_design/bob")
-      do_create_design_document
-    end
-
-    it "should populate the _rev in the new design if the versions dont match" do
-      @mock_data["version"] = 2
-      do_create_design_document
-      @mock_data["_rev"].should eql(1)
-    end
-
-    it "should create the view if it requires updating" do
-      @mock_data["version"] = 2
-      @rest.should_receive(:put_rest).with("chef/_design%2Fbob", @mock_data)
-      do_create_design_document
-    end
-
-    it "should not create the view if it does not require updating" do
-      @mock_data["version"] = 1
-      @rest.should_not_receive(:put_rest)
-      do_create_design_document
-    end
-  end
-
-  describe "store" do
-    before(:each) do
-      @mock_results = {
-        "rows" => [
-          "id" => 'a0934635-e111-45d9-8223-cb58e1c9434c'
-        ]
-      }
-      @couchdb.stub!(:get_view).with("id_map", "name_to_id", :key => [ "node", "bob" ]).and_return(@mock_results)
-    end
-
-    it "should put the object into couchdb with a pre-existing GUID" do
-      item_to_store = {}
-      item_to_store.should_receive(:add_to_index)
-      @rest.should_receive(:put_rest).with("chef/#{@mock_results["rows"][0]["id"]}", item_to_store).and_return(true)
-      @couchdb.store("node", "bob", item_to_store)
-    end
-
-    it "should put the object into couchdb with a new GUID" do
-      @mock_results = { "rows" => [] }
-      item_to_store = {}
-      item_to_store.should_receive(:add_to_index).with(:database => "chef", :id => "aaaaaaaa-xxxx-xxxx-xxxx-xxxxxxxxxxx", :type => "node")
-      @couchdb.stub!(:get_view).with("id_map", "name_to_id", :key => [ "node", "bob" ]).and_return(@mock_results)
-      UUIDTools::UUID.stub!(:random_create).and_return("aaaaaaaa-xxxx-xxxx-xxxx-xxxxxxxxxxx")
-      @rest.should_receive(:put_rest).with("chef/aaaaaaaa-xxxx-xxxx-xxxx-xxxxxxxxxxx", item_to_store).and_return(true)
-      @couchdb.store("node", "bob", item_to_store)
-    end
-
-  end
-
-  describe "when fetching the database status" do
-    it "gets couchdb's version string'" do
-      @rest.should_receive(:get_rest).with('/').and_return({"couchdb" => "Welcome","version" => "1.0.1"})
-      @couchdb.server_stats.should == {"couchdb" => "Welcome","version" => "1.0.1"}
-    end
-
-    it "gets database stats" do
-      db_stats = {"db_name" => "opscode_account","doc_count" => 206,"doc_del_count" => 1,"update_seq" => 208,"purge_seq" => 0,
-                  "compact_running" => false,"disk_size" => 122969,"instance_start_time" => "1298070021394804","disk_format_version" => 5,"committed_update_seq" => 208}
-      @rest.should_receive(:get_rest).with('/chef').and_return(db_stats)
-      @couchdb.db_stats.should == db_stats
-    end
-
-  end
-
-  describe "load" do
-    before(:each) do
-      @mock_node = Chef::Node.new()
-      @mock_node.name("bob")
-      @couchdb.stub!(:find_by_name).with("node", "bob").and_return(@mock_node)
-    end
-
-    it "should load the object from couchdb" do
-      @couchdb.load("node", "bob").should eql(@mock_node)
-    end
-  end
-
-  describe "delete" do
-    before(:each) do
-      @mock_current = {
-        "version" => 1,
-        "_rev" => 1
-      }
-      @rest.stub!(:get_rest).and_return(@mock_current)
-      @rest.stub!(:delete_rest).and_return(true)
-      @node = Chef::Node.new()
-      @node.name("bob")
-      @node.couchdb_rev = 15
-      @couchdb.stub!(:find_by_name).with("node", "bob", true).and_return([ @node, "ax" ])
-    end
-
-    def do_delete(rev=nil)
-      @couchdb.delete("node", "bob", rev)
-    end
-
-    it "should remove the object from couchdb with a specific revision" do
-      @node.should_receive(:delete_from_index)
-      @rest.should_receive(:delete_rest).with("chef/ax?rev=1")
-      do_delete(1)
-    end
-
-    it "should remove the object from couchdb based on the couchdb_rev of the current obj" do
-      @node.should_receive(:delete_from_index)
-      @rest.should_receive(:delete_rest).with("chef/ax?rev=15")
-      do_delete
-    end
-  end
-
-  describe "list" do
-    before(:each) do
-      Chef::Config.stub!(:[]).with(:couchdb_database).and_return("chef")
-      @mock_response = {"rows" => []}
-    end
-
-    describe "on couchdb 0.9+" do
-      before do
-        Chef::Config.stub!(:[]).with(:couchdb_version).and_return(0.9)
-      end
-
-      it "should get the view for all objects if inflate is true" do
-        @rest.should_receive(:get_rest).with("chef/_design/node/_view/all").and_return(@mock_response)
-        @couchdb.list("node", true)
-      end
-
-      it "should get the view for just the object id's if inflate is false" do
-        @rest.should_receive(:get_rest).with("chef/_design/node/_view/all_id").and_return(@mock_response)
-        @couchdb.list("node", false)
-      end
-    end
-  end
-
-  describe "has_key?" do
-    it "should return true if the object exists" do
-      @couchdb.stub!(:find_by_name).with("node", "bob").and_return(true)
-      @couchdb.has_key?("node", "bob").should eql(true)
-    end
-
-    it "should return false if the object does not exist" do
-      @couchdb.stub!(:find_by_name).and_raise(Chef::Exceptions::CouchDBNotFound)
-      @couchdb.has_key?("node", "bob").should eql(false)
-    end
-  end
-
-  describe "get_view" do
-    it "should construct a call to the view for the proper design document" do
-      @rest.should_receive(:get_rest).with("chef/_design/nodes/_view/mastodon")
-      @couchdb.get_view("nodes", "mastodon")
-    end
-
-    it "should allow arguments to the view" do
-      @rest.should_receive(:get_rest).with("chef/_design/nodes/_view/mastodon?startkey=%22dont%20stay%22")
-      @couchdb.get_view("nodes", "mastodon", :startkey => "dont stay")
-    end
-
-  end
-
-  describe "view_uri" do
-    it "should output an appropriately formed view URI" do
-      @couchdb.should_receive(:view_uri).with("nodes", "all").and_return("chef/_design/nodes/_view/all")
-      @couchdb.view_uri("nodes", "all")
-    end
-  end
-
-end
-
-
-
-

data/spec/unit/index_queue_spec.rb

@@ -1,391 +0,0 @@
-#
-# 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