chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/certificate_spec.rb

@@ -1,76 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2009 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/certificate'
-require 'ostruct'
-require 'tempfile'
-
-class FakeFile
-  attr_accessor :data
-
-  def write(arg)
-    @data = arg
-  end
-end
-
-describe Chef::Certificate do
-  describe "generate_signing_ca" do
-    before(:each) do
-      Chef::Config[:signing_ca_user] = nil
-      Chef::Config[:signing_ca_group] = nil
-      FileUtils.stub!(:mkdir_p).and_return(true)
-      FileUtils.stub!(:chown).and_return(true)
-      File.stub!(:open).and_return(true)
-      File.stub!(:exists?).and_return(false)
-      @ca_cert = FakeFile.new 
-      @ca_key = FakeFile.new 
-    end
-
-    it "should generate a ca certificate" do
-      File.should_receive(:open).with(Chef::Config[:signing_ca_cert], "w").and_yield(@ca_cert)
-      Chef::Certificate.generate_signing_ca
-      @ca_cert.data.should =~ /BEGIN CERTIFICATE/
-    end
-    
-    it "should generate an RSA private key" do
-      File.should_receive(:open).with(Chef::Config[:signing_ca_key], File::WRONLY|File::EXCL|File::CREAT, 0600).and_yield(@ca_key)
-      FileUtils.should_not_receive(:chown)
-      Chef::Certificate.generate_signing_ca
-      @ca_key.data.should =~ /BEGIN RSA PRIVATE KEY/
-    end
-
-    it "should generate an RSA private key with user and group" do
-      Chef::Config[:signing_ca_user] = "funky"
-      Chef::Config[:signing_ca_group] = "fresh"
-      File.should_receive(:open).with(Chef::Config[:signing_ca_key], File::WRONLY|File::EXCL|File::CREAT, 0600).and_yield(@ca_key)
-      FileUtils.should_receive(:chown).with(Chef::Config[:signing_ca_user], Chef::Config[:signing_ca_group], Chef::Config[:signing_ca_key])
-      Chef::Certificate.generate_signing_ca
-      @ca_key.data.should =~ /BEGIN RSA PRIVATE KEY/
-    end
-  end
-
-  describe "generate_keypair" do
-    it "should return a client certificate" do
-      public_key, private_key = Chef::Certificate.gen_keypair("oasis")
-      public_key.to_s.should =~ /(BEGIN RSA PUBLIC KEY|BEGIN PUBLIC KEY)/
-      private_key.to_s.should =~ /BEGIN RSA PRIVATE KEY/
-    end
-  end
-end

data/spec/unit/checksum_cache_spec.rb

@@ -1,209 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
-# 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'
-
-describe Chef::ChecksumCache do
-  before(:each) do
-    Chef::Config[:cache_type] = "Memory"
-    Chef::Config[:cache_options] = { } 
-    @cache = Chef::ChecksumCache.instance
-    @cache.reset!
-  end
-
-  describe "loading the moneta backend" do
-    it "should build a Chef::ChecksumCache object" do
-      @cache.should be_a_kind_of(Chef::ChecksumCache)
-    end
-
-    it "should set up a Moneta Cache adaptor" do
-      @cache.moneta.should be_a_kind_of(Moneta::Memory)
-    end
-
-    it "should raise an exception if it cannot load the moneta adaptor" do
-      Chef::Log.should_receive(:fatal).with(/^Could not load Moneta back end/)
-      lambda {
-        c = Chef::ChecksumCache.instance.reset!('WTF')
-      }.should raise_error(LoadError)
-    end
-  end
-
-  describe "when caching checksums of cookbook files and templates" do
-
-    before do
-      @cache.reset!("Memory", {})
-    end
-
-    it "proxies the class method checksum_for_file to the instance" do
-      @cache.should_receive(:checksum_for_file).with("a_file_or_a_fail")
-      Chef::ChecksumCache.checksum_for_file("a_file_or_a_fail")
-    end
-
-    it "returns a cached checksum value" do
-      @cache.moneta["chef-file-riseofthemachines"] = {"mtime" => "12345", "checksum" => "123abc"}
-      fstat = mock("File.stat('riseofthemachines')", :mtime => Time.at(12345))
-      File.should_receive(:stat).with("riseofthemachines").and_return(fstat)
-      @cache.checksum_for_file("riseofthemachines").should == "123abc"
-    end
-
-    it "gives nil for a cache miss" do
-      @cache.moneta["chef-file-riseofthemachines"] = {"mtime" => "12345", "checksum" => "123abc"}
-      fstat = mock("File.stat('riseofthemachines')", :mtime => Time.at(555555))
-      @cache.lookup_checksum("chef-file-riseofthemachines", fstat).should be_nil
-    end
-
-    it "treats a non-matching mtime as a cache miss" do
-      @cache.moneta["chef-file-riseofthemachines"] = {"mtime" => "12345", "checksum" => "123abc"}
-      fstat = mock("File.stat('riseofthemachines')", :mtime => Time.at(555555))
-      @cache.lookup_checksum("chef-file-riseofthemachines", fstat).should be_nil
-    end
-
-    it "computes a checksum of a file" do
-      fixture_file = CHEF_SPEC_DATA + "/checksum/random.txt"
-      expected = "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
-      @cache.send(:checksum_file, fixture_file, Digest::SHA256.new).should == expected
-    end
-
-    it "computes a checksum and stores it in the cache" do
-      fstat = mock("File.stat('riseofthemachines')", :mtime => Time.at(555555))
-      @cache.should_receive(:checksum_file).with("riseofthemachines", an_instance_of(Digest::SHA256)).and_return("ohai2uChefz")
-      @cache.generate_checksum("chef-file-riseofthemachines", "riseofthemachines", fstat).should == "ohai2uChefz"
-      @cache.lookup_checksum("chef-file-riseofthemachines", fstat).should == "ohai2uChefz"
-    end
-
-    it "returns a generated checksum if there is no cached value" do
-      fixture_file = CHEF_SPEC_DATA + "/checksum/random.txt"
-      expected = "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
-      @cache.checksum_for_file(fixture_file).should == expected
-    end
-
-    it "generates a key from a file name" do
-      file = "/this/is/a/test/random.rb"
-      @cache.generate_key(file).should == "chef-file--this-is-a-test-random-rb"
-    end
-
-    it "generates a key from a file name and group" do
-      file = "/this/is/a/test/random.rb"
-      @cache.generate_key(file, "spec").should == "spec-file--this-is-a-test-random-rb"
-    end
-
-    it "returns a cached checksum value using a user defined key" do
-      key = @cache.generate_key("riseofthemachines", "specs")
-      @cache.moneta[key] = {"mtime" => "12345", "checksum" => "123abc"}
-      fstat = mock("File.stat('riseofthemachines')", :mtime => Time.at(12345))
-      File.should_receive(:stat).with("riseofthemachines").and_return(fstat)
-      @cache.checksum_for_file("riseofthemachines", key).should == "123abc"
-    end
-
-    it "generates a checksum from a non-file IO object" do
-      io = StringIO.new("riseofthemachines\nriseofthechefs\n")
-      expected_md5 = '0e157ac1e2dd73191b76067fb6b4bceb'
-      @cache.generate_md5_checksum(io).should == expected_md5
-    end
-
-  end
-
-  describe "when cleaning up after outdated checksums" do
-
-    before do
-      Chef::ChecksumCache.reset_cache_validity
-    end
-
-    it "initially has no valid cached checksums" do
-      Chef::ChecksumCache.valid_cached_checksums.should be_empty
-    end
-
-    it "adds a checksum to the list of valid cached checksums when it's created" do
-      @cache.checksum_for_file(File.join(CHEF_SPEC_DATA, 'checksum', 'random.txt'))
-      Chef::ChecksumCache.valid_cached_checksums.should have(1).valid_checksum
-    end
-
-    it "adds a checksum to the list of valid cached checksums when it's read" do
-      @cache.checksum_for_file(File.join(CHEF_SPEC_DATA, 'checksum', 'random.txt'))
-      Chef::ChecksumCache.reset_cache_validity
-      @cache.checksum_for_file(File.join(CHEF_SPEC_DATA, 'checksum', 'random.txt'))
-      Chef::ChecksumCache.valid_cached_checksums.should have(1).valid_checksum
-    end
-
-    context "with an existing set of cached checksums" do
-      before do
-        Chef::Config[:cache_type] = "BasicFile"
-        Chef::Config[:cache_options] = {:path => File.join(CHEF_SPEC_DATA, "checksum_cache")} 
-
-        @expected_cached_checksums = ["chef-file--tmp-chef-rendered-template20100929-10863-600hhz-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-6m8zdk-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-ahd2gq-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-api8ux-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-b0r1m1-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-bfygsi-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-el14l6-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-ivrl3y-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-kkbs85-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-ory1ux-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-pgsq76-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-ra8uim-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-t7k1g-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-t8g0sv-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-ufy6g3-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-x2d6j9-0",
-                                      "chef-file--tmp-chef-rendered-template20100929-10863-xi0l6h-0"]
-        @expected_cached_checksums.sort!
-      end
-
-      after do
-        Chef::Config[:cache_type] = "Memory"
-        Chef::Config[:cache_options] = { } 
-        @cache = Chef::ChecksumCache.instance
-        @cache.reset!
-      end
-
-      it "lists all of the cached checksums in the cache directory" do
-        Chef::ChecksumCache.all_cached_checksums.keys.sort.should == @expected_cached_checksums
-      end
-
-      it "clears all of the checksums not marked valid from the checksums directory" do
-        valid_cksum_key = "chef-file--tmp-chef-rendered-template20100929-10863-ivrl3y-0"
-        valid_cksum_file = File.join(CHEF_SPEC_DATA, "checksum_cache", valid_cksum_key)
-        @expected_cached_checksums.delete(valid_cksum_key)
-
-        Chef::ChecksumCache.valid_cached_checksums << valid_cksum_key
-
-        Chef::ChecksumCache.should_not_receive(:remove_unused_checksum).with(valid_cksum_file)
-        @expected_cached_checksums.each do |cksum_key|
-          full_path_to_cksum = File.join(CHEF_SPEC_DATA, "checksum_cache", cksum_key)
-          Chef::ChecksumCache.should_receive(:remove_unused_checksum).with(full_path_to_cksum)
-        end
-
-        Chef::ChecksumCache.cleanup_checksum_cache
-      end
-
-      it "cleans all 0byte checksum files when it encounters a Marshal error" do
-        @cache.moneta.stub!(:fetch).and_raise(ArgumentError)
-        # This cache file is 0 bytes, raises an argument error when
-        # attempting to Marshal.load
-        File.should_receive(:unlink).with(File.join(CHEF_SPEC_DATA, "checksum_cache", "chef-file--tmp-chef-rendered-template20100929-10863-6m8zdk-0"))
-        @cache.lookup_checksum("chef-file--tmp-chef-rendered-template20100929-10863-6m8zdk-0", "foo")
-      end
-    end
-
-  end
-
-end
-

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
-
-
-
-