chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/daemon_spec.rb

@@ -23,12 +23,12 @@ describe Chef::Daemon do
     if windows?
       mock_struct = #Struct::Passwd.new(nil, nil, 111, 111)
       mock_struct = OpenStruct.new(:uid => 2342, :gid => 2342)
-      Etc.stub(:getpwnam).and_return mock_struct
-      Etc.stub(:getgrnam).and_return mock_struct
+      allow(Etc).to receive(:getpwnam).and_return mock_struct
+      allow(Etc).to receive(:getgrnam).and_return mock_struct
       # mock unimplemented methods
-      Process.stub(:initgroups).and_return nil
-      Process::GID.stub(:change_privilege).and_return 11
-      Process::UID.stub(:change_privilege).and_return 11
+      allow(Process).to receive(:initgroups).and_return nil
+      allow(Process::GID).to receive(:change_privilege).and_return 11
+      allow(Process::UID).to receive(:change_privilege).and_return 11
     end
   end
 
@@ -41,7 +41,7 @@ describe Chef::Daemon do
       end
 
       it "should return the supplied value" do
-        Chef::Daemon.pid_file.should eql("/var/run/chef/chef-client.pid")
+        expect(Chef::Daemon.pid_file).to eql("/var/run/chef/chef-client.pid")
       end
     end
 
@@ -52,7 +52,7 @@ describe Chef::Daemon do
       end
 
       it "should return a valued based on @name" do
-        Chef::Daemon.pid_file.should eql("/tmp/chef-client.pid")
+        expect(Chef::Daemon.pid_file).to eql("/tmp/chef-client.pid")
       end
 
     end
@@ -65,7 +65,7 @@ describe Chef::Daemon do
     end
 
     it "should suck the pid out of pid_file" do
-      File.should_receive(:read).with("/var/run/chef/chef-client.pid").and_return("1337")
+      expect(File).to receive(:read).with("/var/run/chef/chef-client.pid").and_return("1337")
       Chef::Daemon.pid_from_file
     end
   end
@@ -73,13 +73,13 @@ describe Chef::Daemon do
   describe ".change_privilege" do
 
     before do
-      Chef::Application.stub(:fatal!).and_return(true)
+      allow(Chef::Application).to receive(:fatal!).and_return(true)
       Chef::Config[:user] = 'aj'
-      Dir.stub(:chdir)
+      allow(Dir).to receive(:chdir)
     end
 
     it "changes the working directory to root" do
-      Dir.should_receive(:chdir).with("/").and_return(0)
+      expect(Dir).to receive(:chdir).with("/").and_return(0)
       Chef::Daemon.change_privilege
     end
 
@@ -90,24 +90,24 @@ describe Chef::Daemon do
       end
 
       it "should log an appropriate info message" do
-        Chef::Log.should_receive(:info).with("About to change privilege to aj:staff")
+        expect(Chef::Log).to receive(:info).with("About to change privilege to aj:staff")
         Chef::Daemon.change_privilege
       end
 
       it "should call _change_privilege with the user and group" do
-        Chef::Daemon.should_receive(:_change_privilege).with("aj", "staff")
+        expect(Chef::Daemon).to receive(:_change_privilege).with("aj", "staff")
         Chef::Daemon.change_privilege
       end
     end
 
     describe "when just the user option is supplied" do
       it "should log an appropriate info message" do
-        Chef::Log.should_receive(:info).with("About to change privilege to aj")
+        expect(Chef::Log).to receive(:info).with("About to change privilege to aj")
         Chef::Daemon.change_privilege
       end
 
       it "should call _change_privilege with just the user" do
-        Chef::Daemon.should_receive(:_change_privilege).with("aj")
+        expect(Chef::Daemon).to receive(:_change_privilege).with("aj")
         Chef::Daemon.change_privilege
       end
     end
@@ -116,56 +116,56 @@ describe Chef::Daemon do
   describe "._change_privilege" do
 
     before do
-      Process.stub(:euid).and_return(0)
-      Process.stub(:egid).and_return(0)
+      allow(Process).to receive(:euid).and_return(0)
+      allow(Process).to receive(:egid).and_return(0)
 
-      Process::UID.stub(:change_privilege).and_return(nil)
-      Process::GID.stub(:change_privilege).and_return(nil)
+      allow(Process::UID).to receive(:change_privilege).and_return(nil)
+      allow(Process::GID).to receive(:change_privilege).and_return(nil)
 
       @pw_user = double("Struct::Passwd", :uid => 501)
       @pw_group = double("Struct::Group", :gid => 20)
 
-      Process.stub(:initgroups).and_return(true)
+      allow(Process).to receive(:initgroups).and_return(true)
 
-      Etc.stub(:getpwnam).and_return(@pw_user)
-      Etc.stub(:getgrnam).and_return(@pw_group)
+      allow(Etc).to receive(:getpwnam).and_return(@pw_user)
+      allow(Etc).to receive(:getgrnam).and_return(@pw_group)
     end
 
     describe "with sufficient privileges" do
       before do
-        Process.stub(:euid).and_return(0)
-        Process.stub(:egid).and_return(0)
+        allow(Process).to receive(:euid).and_return(0)
+        allow(Process).to receive(:egid).and_return(0)
       end
 
       it "should initialize the supplemental group list" do
-        Process.should_receive(:initgroups).with("aj", 20)
+        expect(Process).to receive(:initgroups).with("aj", 20)
         Chef::Daemon._change_privilege("aj")
       end
 
       it "should attempt to change the process GID" do
-        Process::GID.should_receive(:change_privilege).with(20).and_return(20)
+        expect(Process::GID).to receive(:change_privilege).with(20).and_return(20)
         Chef::Daemon._change_privilege("aj")
       end
 
       it "should attempt to change the process UID" do
-        Process::UID.should_receive(:change_privilege).with(501).and_return(501)
+        expect(Process::UID).to receive(:change_privilege).with(501).and_return(501)
         Chef::Daemon._change_privilege("aj")
       end
     end
 
     describe "with insufficient privileges" do
       before do
-        Process.stub(:euid).and_return(999)
-        Process.stub(:egid).and_return(999)
+        allow(Process).to receive(:euid).and_return(999)
+        allow(Process).to receive(:egid).and_return(999)
       end
 
       it "should log an appropriate error message and fail miserably" do
-        Process.stub(:initgroups).and_raise(Errno::EPERM)
+        allow(Process).to receive(:initgroups).and_raise(Errno::EPERM)
         error = "Operation not permitted"
         if RUBY_PLATFORM.match("solaris2") || RUBY_PLATFORM.match("aix")
           error = "Not owner"
         end
-        Chef::Application.should_receive(:fatal!).with("Permission denied when trying to change 999:999 to 501:20. #{error}")
+        expect(Chef::Application).to receive(:fatal!).with("Permission denied when trying to change 999:999 to 501:20. #{error}")
         Chef::Daemon._change_privilege("aj")
       end
     end

data/spec/unit/data_bag_item_spec.rb

@@ -20,107 +20,109 @@ require 'spec_helper'
 require 'chef/data_bag_item'
 
 describe Chef::DataBagItem do
-  before(:each) do
-    @data_bag_item = Chef::DataBagItem.new
-  end
+  let(:data_bag_item) { Chef::DataBagItem.new }
 
   describe "initialize" do
     it "should be a Chef::DataBagItem" do
-      @data_bag_item.should be_a_kind_of(Chef::DataBagItem)
+      expect(data_bag_item).to be_a_kind_of(Chef::DataBagItem)
     end
   end
 
   describe "data_bag" do
     it "should let you set the data_bag to a string" do
-      @data_bag_item.data_bag("clowns").should == "clowns"
+      expect(data_bag_item.data_bag("clowns")).to eq("clowns")
     end
 
     it "should return the current data_bag type" do
-      @data_bag_item.data_bag "clowns"
-      @data_bag_item.data_bag.should == "clowns"
+      data_bag_item.data_bag "clowns"
+      expect(data_bag_item.data_bag).to eq("clowns")
     end
 
     it "should not accept spaces" do
-      lambda { @data_bag_item.data_bag "clown masters" }.should raise_error(ArgumentError)
+      expect { data_bag_item.data_bag "clown masters" }.to raise_error(ArgumentError)
     end
 
     it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @data_bag_item.data_bag Hash.new }.should raise_error(ArgumentError)
+      expect { data_bag_item.data_bag Hash.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "raw_data" do
     it "should let you set the raw_data with a hash" do
-      lambda { @data_bag_item.raw_data = { "id" => "octahedron" } }.should_not raise_error
+      expect { data_bag_item.raw_data = { "id" => "octahedron" } }.not_to raise_error
     end
 
     it "should let you set the raw_data from a mash" do
-      lambda { @data_bag_item.raw_data = Mash.new({ "id" => "octahedron" }) }.should_not raise_error
+      expect { data_bag_item.raw_data = Mash.new({ "id" => "octahedron" }) }.not_to raise_error
     end
 
     it "should raise an exception if you set the raw data without a key" do
-      lambda { @data_bag_item.raw_data = { "monkey" => "pants" } }.should raise_error(ArgumentError)
+      expect { data_bag_item.raw_data = { "monkey" => "pants" } }.to raise_error(ArgumentError)
     end
 
     it "should raise an exception if you set the raw data to something other than a hash" do
-      lambda { @data_bag_item.raw_data = "katie rules" }.should raise_error(ArgumentError)
+      expect { data_bag_item.raw_data = "katie rules" }.to raise_error(ArgumentError)
     end
 
     it "should accept alphanum/-/_ for the id" do
-      lambda { @data_bag_item.raw_data = { "id" => "h1-_" } }.should_not raise_error
+      expect { data_bag_item.raw_data = { "id" => "h1-_" } }.not_to raise_error
     end
 
     it "should accept alphanum.alphanum for the id" do
-      lambda { @data_bag_item.raw_data = { "id" => "foo.bar" } }.should_not raise_error
+      expect { data_bag_item.raw_data = { "id" => "foo.bar" } }.not_to raise_error
     end
 
     it "should accept .alphanum for the id" do
-      lambda { @data_bag_item.raw_data = { "id" => ".bozo" } }.should_not raise_error
+      expect { data_bag_item.raw_data = { "id" => ".bozo" } }.not_to raise_error
     end
 
     it "should raise an exception if the id contains anything but alphanum/-/_" do
-      lambda { @data_bag_item.raw_data = { "id" => "!@#" } }.should raise_error(ArgumentError)
+      expect { data_bag_item.raw_data = { "id" => "!@#" } }.to raise_error(ArgumentError)
     end
 
     it "should return the raw data" do
-      @data_bag_item.raw_data = { "id" => "highway_of_emptiness" }
-      @data_bag_item.raw_data.should == { "id" => "highway_of_emptiness" }
+      data_bag_item.raw_data = { "id" => "highway_of_emptiness" }
+      expect(data_bag_item.raw_data).to eq({ "id" => "highway_of_emptiness" })
     end
 
     it "should be a Mash by default" do
-      @data_bag_item.raw_data.should be_a_kind_of(Mash)
+      expect(data_bag_item.raw_data).to be_a_kind_of(Mash)
     end
   end
 
   describe "object_name" do
-    before(:each) do
-      @data_bag_item.data_bag("dreams")
-      @data_bag_item.raw_data = { "id" => "the_beatdown" }
-    end
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item.data_bag("dreams")
+      data_bag_item.raw_data = { "id" => "the_beatdown" }
+      data_bag_item
+    }
 
     it "should return an object name based on the bag name and the raw_data id" do
-      @data_bag_item.object_name.should == "data_bag_item_dreams_the_beatdown"
+      expect(data_bag_item.object_name).to eq("data_bag_item_dreams_the_beatdown")
     end
   end
 
   describe "class method object_name" do
     it "should return an object name based based on the bag name and an id" do
-      Chef::DataBagItem.object_name("zen", "master").should == "data_bag_item_zen_master"
+      expect(Chef::DataBagItem.object_name("zen", "master")).to eq("data_bag_item_zen_master")
     end
   end
 
   describe "when used like a Hash" do
-    before(:each) do
-      @data_bag_item.raw_data = { "id" => "journey", "trials" => "been through" }
-    end
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item.raw_data = { "id" => "journey", "trials" => "been through" }
+      data_bag_item
+    }
 
     it "responds to keys" do
-      @data_bag_item.keys.should include("id")
-      @data_bag_item.keys.should include("trials")
+      expect(data_bag_item.keys).to include("id")
+      expect(data_bag_item.keys).to include("trials")
     end
 
     it "supports element reference with []" do
-      @data_bag_item["id"].should == "journey"
+      expect(data_bag_item["id"]).to eq("journey")
     end
 
     it "implements all the methods of Hash" do
@@ -131,100 +133,113 @@ describe Chef::DataBagItem do
       :invert, :update, :replace, :merge!, :merge, :has_key?, :has_value?,
       :key?, :value?]
       methods.each do |m|
-        @data_bag_item.should respond_to(m)
+        expect(data_bag_item).to respond_to(m)
       end
     end
-
   end
 
   describe "to_hash" do
-    before(:each) do
-      @data_bag_item.data_bag("still_lost")
-      @data_bag_item.raw_data = { "id" => "whoa", "i_know" => "kung_fu" }
-      @to_hash = @data_bag_item.to_hash
-    end
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item.data_bag("still_lost")
+      data_bag_item.raw_data = { "id" => "whoa", "i_know" => "kung_fu" }
+      data_bag_item
+    }
+
+    let(:to_hash) { data_bag_item.to_hash }
 
     it "should return a hash" do
-      @to_hash.should be_a_kind_of(Hash)
+      expect(to_hash).to be_a_kind_of(Hash)
     end
 
     it "should have the raw_data keys as top level keys" do
-      @to_hash["id"].should == "whoa"
-      @to_hash["i_know"].should == "kung_fu"
+      expect(to_hash["id"]).to eq("whoa")
+      expect(to_hash["i_know"]).to eq("kung_fu")
     end
 
     it "should have the chef_type of data_bag_item" do
-      @to_hash["chef_type"].should == "data_bag_item"
+      expect(to_hash["chef_type"]).to eq("data_bag_item")
     end
 
     it "should have the data_bag set" do
-      @to_hash["data_bag"].should == "still_lost"
+      expect(to_hash["data_bag"]).to eq("still_lost")
     end
   end
 
   describe "when deserializing from JSON" do
-    before(:each) do
-      @data_bag_item.data_bag('mars_volta')
-      @data_bag_item.raw_data = { "id" => "octahedron", "snooze" => { "finally" => :world_will }}
-      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag_item))
-    end
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item.data_bag('mars_volta')
+      data_bag_item.raw_data = { "id" => "octahedron", "snooze" => { "finally" => :world_will } }
+      data_bag_item
+    }
+
+    let(:deserial) { Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(data_bag_item)) }
+
 
     it "should deserialize to a Chef::DataBagItem object" do
-      @deserial.should be_a_kind_of(Chef::DataBagItem)
+      expect(deserial).to be_a_kind_of(Chef::DataBagItem)
     end
 
     it "should have a matching 'data_bag' value" do
-      @deserial.data_bag.should == @data_bag_item.data_bag
+      expect(deserial.data_bag).to eq(data_bag_item.data_bag)
     end
 
     it "should have a matching 'id' key" do
-      @deserial["id"].should == "octahedron"
+      expect(deserial["id"]).to eq("octahedron")
     end
 
     it "should have a matching 'snooze' key" do
-      @deserial["snooze"].should == { "finally" => "world_will" }
+      expect(deserial["snooze"]).to eq({ "finally" => "world_will" })
     end
 
     include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { @data_bag_item }
+      let(:jsonable) { data_bag_item }
     end
   end
 
   describe "when converting to a string" do
     it "converts to a string in the form data_bag_item[ID]" do
-      @data_bag_item['id'] = "heart of darkness"
-      @data_bag_item.to_s.should == 'data_bag_item[heart of darkness]'
+      data_bag_item['id'] = "heart of darkness"
+      expect(data_bag_item.to_s).to eq('data_bag_item[heart of darkness]')
     end
 
     it "inspects as data_bag_item[BAG, ID, RAW_DATA]" do
       raw_data = {"id" => "heart_of_darkness", "author" => "Conrad"}
-      @data_bag_item.raw_data = raw_data
-      @data_bag_item.data_bag("books")
+      data_bag_item.raw_data = raw_data
+      data_bag_item.data_bag("books")
 
-      @data_bag_item.inspect.should == "data_bag_item[\"books\", \"heart_of_darkness\", #{raw_data.inspect}]"
+      expect(data_bag_item.inspect).to eq("data_bag_item[\"books\", \"heart_of_darkness\", #{raw_data.inspect}]")
     end
   end
 
   describe "save" do
+    let(:server) { instance_double(Chef::REST) }
+
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item['id'] = "heart of darkness"
+      data_bag_item.raw_data = {"id" => "heart_of_darkness", "author" => "Conrad"}
+      data_bag_item.data_bag("books")
+      data_bag_item
+    }
+
     before do
-      @rest = double("Chef::REST")
-      Chef::REST.stub(:new).and_return(@rest)
-      @data_bag_item['id'] = "heart of darkness"
-      raw_data = {"id" => "heart_of_darkness", "author" => "Conrad"}
-      @data_bag_item.raw_data = raw_data
-      @data_bag_item.data_bag("books")
+      expect(Chef::REST).to receive(:new).and_return(server)
     end
+
     it "should update the item when it already exists" do
-      @rest.should_receive(:put_rest).with("data/books/heart_of_darkness", @data_bag_item)
-      @data_bag_item.save
+      expect(server).to receive(:put_rest).with("data/books/heart_of_darkness", data_bag_item)
+      data_bag_item.save
     end
 
     it "should create if the item is not found" do
       exception = double("404 error", :code => "404")
-      @rest.should_receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception))
-      @rest.should_receive(:post_rest).with("data/books", @data_bag_item)
-      @data_bag_item.save
+      expect(server).to receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception))
+      expect(server).to receive(:post_rest).with("data/books", data_bag_item)
+      data_bag_item.save
     end
+
     describe "when whyrun mode is enabled" do
       before do
         Chef::Config[:why_run] = true
@@ -232,41 +247,60 @@ describe Chef::DataBagItem do
       after do
         Chef::Config[:why_run] = false
       end
+
       it "should not save" do
-        @rest.should_not_receive(:put_rest)
-        @rest.should_not_receive(:post_rest)
-        @data_bag_item.data_bag("books")
-        @data_bag_item.save
+        expect(server).not_to receive(:put_rest)
+        expect(server).not_to receive(:post_rest)
+        data_bag_item.data_bag("books")
+        data_bag_item.save
       end
     end
 
+  end
+
+  describe "destroy" do
+    let(:server) { instance_double(Chef::REST) }
+
+    let(:data_bag_item) {
+      data_bag_item = Chef::DataBagItem.new
+      data_bag_item.data_bag('a_baggy_bag')
+      data_bag_item.raw_data = { "id" => "some_id" }
+      data_bag_item
+    }
 
+    it "should set default parameters" do
+      expect(Chef::REST).to receive(:new).and_return(server)
+      expect(server).to receive(:delete_rest).with("data/a_baggy_bag/data_bag_item_a_baggy_bag_some_id")
+
+      data_bag_item.destroy
+    end
   end
 
   describe "when loading" do
     before do
-      @data_bag_item.raw_data = {"id" => "charlie", "shell" => "zsh", "ssh_keys" => %w{key1 key2}}
-      @data_bag_item.data_bag("users")
+      data_bag_item.raw_data = {"id" => "charlie", "shell" => "zsh", "ssh_keys" => %w{key1 key2}}
+      data_bag_item.data_bag("users")
     end
 
     describe "from an API call" do
+      let(:http_client) { double("Chef::REST") }
+
       before do
-        @http_client = double("Chef::REST")
-        Chef::REST.stub(:new).and_return(@http_client)
+        allow(Chef::REST).to receive(:new).and_return(http_client)
       end
 
       it "converts raw data to a data bag item" do
-        @http_client.should_receive(:get_rest).with("data/users/charlie").and_return(@data_bag_item.to_hash)
+        expect(http_client).to receive(:get_rest).with("data/users/charlie").and_return(data_bag_item.to_hash)
         item = Chef::DataBagItem.load(:users, "charlie")
-        item.should be_a_kind_of(Chef::DataBagItem)
-        item.should == @data_bag_item
+        expect(item).to be_a_kind_of(Chef::DataBagItem)
+        expect(item).to eq(data_bag_item)
       end
 
       it "does not convert when a DataBagItem is returned from the API call" do
-        @http_client.should_receive(:get_rest).with("data/users/charlie").and_return(@data_bag_item)
+        expect(http_client).to receive(:get_rest).with("data/users/charlie").and_return(data_bag_item)
         item = Chef::DataBagItem.load(:users, "charlie")
-        item.should be_a_kind_of(Chef::DataBagItem)
-        item.should equal(@data_bag_item)
+        expect(item).to be_a_kind_of(Chef::DataBagItem)
+        expect(item).to equal(data_bag_item)
       end
     end
 
@@ -280,13 +314,11 @@ describe Chef::DataBagItem do
       end
 
       it "converts the raw data to a data bag item" do
-        Chef::DataBag.should_receive(:load).with('users').and_return({'charlie' => @data_bag_item.to_hash})
+        expect(Chef::DataBag).to receive(:load).with('users').and_return({'charlie' => data_bag_item.to_hash})
         item = Chef::DataBagItem.load('users', 'charlie')
-        item.should be_a_kind_of(Chef::DataBagItem)
-        item.should == @data_bag_item
+        expect(item).to be_a_kind_of(Chef::DataBagItem)
+        expect(item).to eq(data_bag_item)
       end
     end
-
   end
-
 end