chef 13.6.4-universal-mingw32 → 13.7.16-universal-mingw32

data/spec/unit/resource/conditional_spec.rb

@@ -99,7 +99,7 @@ describe Chef::Resource::Conditional do
         expect(@conditional.continue?).to be_falsey
       end
 
-      it "should log a warning" do
+      it "logs a warning" do
         expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
         @conditional.continue?
       end
@@ -202,7 +202,7 @@ describe Chef::Resource::Conditional do
         expect(@conditional.continue?).to be_truthy
       end
 
-      it "should log a warning" do
+      it "logs a warning" do
         expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
         @conditional.continue?
       end

data/spec/unit/resource/cookbook_file_spec.rb

@@ -20,51 +20,45 @@
 require "spec_helper"
 
 describe Chef::Resource::CookbookFile do
-  before do
-    @cookbook_file = Chef::Resource::CookbookFile.new("sourcecode_tarball.tgz")
-  end
-
-  it "uses the name parameter for the source parameter" do
-    expect(@cookbook_file.name).to eq("sourcecode_tarball.tgz")
-  end
+  let(:resource) { Chef::Resource::CookbookFile.new("/foo/bar/sourcecode_tarball.tgz") }
 
-  it "has a source parameter" do
-    @cookbook_file.name("config_file.conf")
-    expect(@cookbook_file.name).to eq("config_file.conf")
+  it "uses the basepath of the resourc ename for the source property" do
+    expect(resource.source).to eq("sourcecode_tarball.tgz")
   end
 
-  it "defaults to a nil cookbook parameter (current cookbook will be used)" do
-    expect(@cookbook_file.cookbook).to be_nil
+  it "source property accepts Strings" do
+    resource.name("config_file.conf")
+    expect(resource.source).to eq("config_file.conf")
   end
 
-  it "has a cookbook parameter" do
-    @cookbook_file.cookbook("munin")
-    expect(@cookbook_file.cookbook).to eq("munin")
+  it "cookbook property defaults to nil (current cookbook will be used)" do
+    expect(resource.cookbook).to be_nil
   end
 
-  it "sets the provider to Chef::Provider::CookbookFile" do
-    expect(@cookbook_file.provider).to eq(Chef::Provider::CookbookFile)
+  it "has a cookbook property that accepts Strings" do
+    resource.cookbook("munin")
+    expect(resource.cookbook).to eq("munin")
   end
 
   describe "when it has a backup number, group, mode, owner, source, checksum, and cookbook on nix or path, rights, deny_rights, checksum on windows" do
     before do
       if Chef::Platform.windows?
-        @cookbook_file.path("C:/temp/origin/file.txt")
-        @cookbook_file.rights(:read, "Everyone")
-        @cookbook_file.deny_rights(:full_control, "Clumsy_Sam")
+        resource.path("C:/temp/origin/file.txt")
+        resource.rights(:read, "Everyone")
+        resource.deny_rights(:full_control, "Clumsy_Sam")
       else
-        @cookbook_file.path("/tmp/origin/file.txt")
-        @cookbook_file.group("wheel")
-        @cookbook_file.mode("0664")
-        @cookbook_file.owner("root")
-        @cookbook_file.source("/tmp/foo.txt")
-        @cookbook_file.cookbook("/tmp/cookbooks/cooked.rb")
+        resource.path("/tmp/origin/file.txt")
+        resource.group("wheel")
+        resource.mode("0664")
+        resource.owner("root")
+        resource.source("/tmp/foo.txt")
+        resource.cookbook("/tmp/cookbooks/cooked.rb")
       end
-      @cookbook_file.checksum("1" * 64)
+      resource.checksum("1" * 64)
     end
 
     it "describes the state" do
-      state = @cookbook_file.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       if Chef::Platform.windows?
         puts state
         expect(state[:rights]).to eq([{ :permissions => :read, :principals => "Everyone" }])
@@ -79,9 +73,9 @@ describe Chef::Resource::CookbookFile do
 
     it "returns the path as its identity" do
       if Chef::Platform.windows?
-        expect(@cookbook_file.identity).to eq("C:/temp/origin/file.txt")
+        expect(resource.identity).to eq("C:/temp/origin/file.txt")
       else
-        expect(@cookbook_file.identity).to eq("/tmp/origin/file.txt")
+        expect(resource.identity).to eq("/tmp/origin/file.txt")
       end
     end
   end

data/spec/unit/resource/cron_spec.rb

@@ -20,157 +20,154 @@
 require "spec_helper"
 
 describe Chef::Resource::Cron do
+  let(:resource) { Chef::Resource::Cron.new("cronify") }
 
-  before(:each) do
-    @resource = Chef::Resource::Cron.new("cronify")
+  it "creates a new Chef::Resource::Cron" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Cron)
   end
 
-  it "should create a new Chef::Resource::Cron" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Cron)
+  it "has a name property" do
+    expect(resource.name).to eql("cronify")
   end
 
-  it "should have a name" do
-    expect(@resource.name).to eql("cronify")
+  it "has a default action of [:create]" do
+    expect(resource.action).to eql([:create])
   end
 
-  it "should have a default action of 'create'" do
-    expect(@resource.action).to eql([:create])
+  it "accepts create or delete for action" do
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+    expect { resource.action :lolcat }.to raise_error(ArgumentError)
   end
 
-  it "should accept create or delete for action" do
-    expect { @resource.action :create }.not_to raise_error
-    expect { @resource.action :delete }.not_to raise_error
-    expect { @resource.action :lolcat }.to raise_error(ArgumentError)
+  it "allows you to set a command" do
+    resource.command "/bin/true"
+    expect(resource.command).to eql("/bin/true")
   end
 
-  it "should allow you to set a command" do
-    @resource.command "/bin/true"
-    expect(@resource.command).to eql("/bin/true")
+  it "allows you to set a user" do
+    resource.user "daemon"
+    expect(resource.user).to eql("daemon")
   end
 
-  it "should allow you to set a user" do
-    @resource.user "daemon"
-    expect(@resource.user).to eql("daemon")
+  it "allows you to specify the minute" do
+    resource.minute "30"
+    expect(resource.minute).to eql("30")
   end
 
-  it "should allow you to specify the minute" do
-    @resource.minute "30"
-    expect(@resource.minute).to eql("30")
+  it "allows you to specify the hour" do
+    resource.hour "6"
+    expect(resource.hour).to eql("6")
   end
 
-  it "should allow you to specify the hour" do
-    @resource.hour "6"
-    expect(@resource.hour).to eql("6")
+  it "allows you to specify the day" do
+    resource.day "10"
+    expect(resource.day).to eql("10")
   end
 
-  it "should allow you to specify the day" do
-    @resource.day "10"
-    expect(@resource.day).to eql("10")
+  it "allows you to specify the month" do
+    resource.month "10"
+    expect(resource.month).to eql("10")
   end
 
-  it "should allow you to specify the month" do
-    @resource.month "10"
-    expect(@resource.month).to eql("10")
+  it "allows you to specify the weekday" do
+    resource.weekday "2"
+    expect(resource.weekday).to eql("2")
   end
 
-  it "should allow you to specify the weekday" do
-    @resource.weekday "2"
-    expect(@resource.weekday).to eql("2")
+  it "allows you to specify the mailto variable" do
+    resource.mailto "test@example.com"
+    expect(resource.mailto).to eql("test@example.com")
   end
 
-  it "should allow you to specify the mailto variable" do
-    @resource.mailto "test@example.com"
-    expect(@resource.mailto).to eql("test@example.com")
+  it "allows you to specify the path" do
+    resource.path "/usr/bin:/usr/sbin"
+    expect(resource.path).to eql("/usr/bin:/usr/sbin")
   end
 
-  it "should allow you to specify the path" do
-    @resource.path "/usr/bin:/usr/sbin"
-    expect(@resource.path).to eql("/usr/bin:/usr/sbin")
+  it "allows you to specify the home directory" do
+    resource.home "/root"
+    expect(resource.home).to eql("/root")
   end
 
-  it "should allow you to specify the home directory" do
-    @resource.home "/root"
-    expect(@resource.home).to eql("/root")
+  it "allows you to specify the shell to run the command with" do
+    resource.shell "/bin/zsh"
+    expect(resource.shell).to eql("/bin/zsh")
   end
 
-  it "should allow you to specify the shell to run the command with" do
-    @resource.shell "/bin/zsh"
-    expect(@resource.shell).to eql("/bin/zsh")
-  end
-
-  it "should allow you to specify environment variables hash" do
+  it "allows you to specify environment variables hash" do
     env = { "TEST" => "LOL" }
-    @resource.environment env
-    expect(@resource.environment).to eql(env)
+    resource.environment env
+    expect(resource.environment).to eql(env)
   end
 
-  it "should allow * for all time and date values" do
+  it "allows * for all time and date values" do
     %w{minute hour day month weekday}.each do |x|
-      expect(@resource.send(x, "*")).to eql("*")
+      expect(resource.send(x, "*")).to eql("*")
     end
   end
 
-  it "should allow ranges for all time and date values" do
+  it "allows ranges for all time and date values" do
     %w{minute hour day month weekday}.each do |x|
-      expect(@resource.send(x, "1-2,5")).to eql("1-2,5")
+      expect(resource.send(x, "1-2,5")).to eql("1-2,5")
     end
   end
 
-  it "should have a default value of * for all time and date values" do
+  it "has a default value of * for all time and date values" do
     %w{minute hour day month weekday}.each do |x|
-      expect(@resource.send(x)).to eql("*")
+      expect(resource.send(x)).to eql("*")
     end
   end
 
-  it "should have a default value of root for the user" do
-    expect(@resource.user).to eql("root")
+  it "has a default value of root for the user" do
+    expect(resource.user).to eql("root")
   end
 
-  it "should reject any minute over 59" do
-    expect { @resource.minute "60" }.to raise_error(RangeError)
+  it "rejects any minute over 59" do
+    expect { resource.minute "60" }.to raise_error(RangeError)
   end
 
-  it "should reject any hour over 23" do
-    expect { @resource.hour "24" }.to raise_error(RangeError)
+  it "rejects any hour over 23" do
+    expect { resource.hour "24" }.to raise_error(RangeError)
   end
 
-  it "should reject any day over 31" do
-    expect { @resource.day "32" }.to raise_error(RangeError)
+  it "rejects any day over 31" do
+    expect { resource.day "32" }.to raise_error(RangeError)
   end
 
-  it "should reject any month over 12" do
-    expect { @resource.month "13" }.to raise_error(RangeError)
+  it "rejects any month over 12" do
+    expect { resource.month "13" }.to raise_error(RangeError)
   end
 
   describe "weekday" do
-    it "should reject any weekday over 7" do
-      expect { @resource.weekday "8" }.to raise_error(RangeError)
+    it "rejects any weekday over 7" do
+      expect { resource.weekday "8" }.to raise_error(RangeError)
     end
-    it "should reject any symbols which don't represent day of week" do
-      expect { @resource.weekday :foo }.to raise_error(RangeError)
+    it "rejects any symbols which don't represent day of week" do
+      expect { resource.weekday :foo }.to raise_error(RangeError)
     end
   end
 
-  it "should convert integer schedule values to a string" do
+  it "converts integer schedule values to a string" do
     %w{minute hour day month weekday}.each do |x|
-      expect(@resource.send(x, 5)).to eql("5")
+      expect(resource.send(x, 5)).to eql("5")
     end
   end
 
   describe "when it has a time (minute, hour, day, month, weeekend) and user" do
     before do
-      @resource.command("tackle")
-      @resource.minute("1")
-      @resource.hour("2")
-      @resource.day("3")
-      @resource.month("4")
-      @resource.weekday("5")
-      @resource.user("root")
+      resource.command("tackle")
+      resource.minute("1")
+      resource.hour("2")
+      resource.day("3")
+      resource.month("4")
+      resource.weekday("5")
+      resource.user("root")
     end
 
     it "describes the state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:minute]).to eq("1")
       expect(state[:hour]).to eq("2")
       expect(state[:day]).to eq("3")
@@ -180,7 +177,7 @@ describe Chef::Resource::Cron do
     end
 
     it "returns the command as its identity" do
-      expect(@resource.identity).to eq("tackle")
+      expect(resource.identity).to eq("tackle")
     end
   end
 end

data/spec/unit/resource/csh_spec.rb

@@ -20,21 +20,19 @@ require "spec_helper"
 
 describe Chef::Resource::Csh do
 
-  before(:each) do
-    @resource = Chef::Resource::Csh.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Csh.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::Csh" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Csh)
+  it "creates a new Chef::Resource::Csh" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Csh)
   end
 
-  it "should have a resource name of :csh" do
-    expect(@resource.resource_name).to eql(:csh)
+  it "has a resource name of :csh" do
+    expect(resource.resource_name).to eql(:csh)
   end
 
-  it "should have an interpreter of csh" do
-    expect(@resource.interpreter).to eql("csh")
+  it "has an interpreter of csh" do
+    expect(resource.interpreter).to eql("csh")
   end
 
 end

data/spec/unit/resource/deploy_spec.rb

@@ -248,7 +248,7 @@ describe Chef::Resource::Deploy do
   end
 
   describe "when it has no timeout attribute" do
-    it "should have no default timeout" do
+    it "has no default timeout" do
       expect(@resource.timeout).to be_nil
     end
   end

data/spec/unit/resource/directory_spec.rb

@@ -20,63 +20,60 @@
 require "spec_helper"
 
 describe Chef::Resource::Directory do
+  let(:resource) { Chef::Resource::Directory.new("fakey_fakerton") }
 
-  before(:each) do
-    @resource = Chef::Resource::Directory.new("fakey_fakerton")
+  it "creates a new Chef::Resource::Directory" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Directory)
   end
 
-  it "should create a new Chef::Resource::Directory" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Directory)
+  it "has a name" do
+    expect(resource.name).to eql("fakey_fakerton")
   end
 
-  it "should have a name" do
-    expect(@resource.name).to eql("fakey_fakerton")
+  it "has a default action of 'create'" do
+    expect(resource.action).to eql([:create])
   end
 
-  it "should have a default action of 'create'" do
-    expect(@resource.action).to eql([:create])
+  it "accepts create or delete for action" do
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+    expect { resource.action :blues }.to raise_error(ArgumentError)
   end
 
-  it "should accept create or delete for action" do
-    expect { @resource.action :create }.not_to raise_error
-    expect { @resource.action :delete }.not_to raise_error
-    expect { @resource.action :blues }.to raise_error(ArgumentError)
+  it "uses the object name as the path by default" do
+    expect(resource.path).to eql("fakey_fakerton")
   end
 
-  it "should use the object name as the path by default" do
-    expect(@resource.path).to eql("fakey_fakerton")
+  it "accepts a string as the path" do
+    expect { resource.path "/tmp" }.not_to raise_error
+    expect(resource.path).to eql("/tmp")
+    expect { resource.path Hash.new }.to raise_error(ArgumentError)
   end
 
-  it "should accept a string as the path" do
-    expect { @resource.path "/tmp" }.not_to raise_error
-    expect(@resource.path).to eql("/tmp")
-    expect { @resource.path Hash.new }.to raise_error(ArgumentError)
-  end
-
-  it "should allow you to have specify whether the action is recursive with true/false" do
-    expect { @resource.recursive true }.not_to raise_error
-    expect { @resource.recursive false }.not_to raise_error
-    expect { @resource.recursive "monkey" }.to raise_error(ArgumentError)
+  it "allows you to have specify whether the action is recursive with true/false" do
+    expect { resource.recursive true }.not_to raise_error
+    expect { resource.recursive false }.not_to raise_error
+    expect { resource.recursive "monkey" }.to raise_error(ArgumentError)
   end
 
   describe "when it has group, mode, and owner" do
     before do
-      @resource.path("/tmp/foo/bar/")
-      @resource.group("wheel")
-      @resource.mode("0664")
-      @resource.owner("root")
+      resource.path("/tmp/foo/bar/")
+      resource.group("wheel")
+      resource.mode("0664")
+      resource.owner("root")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:group]).to eq("wheel")
       expect(state[:mode]).to eq("0664")
       expect(state[:owner]).to eq("root")
     end
 
     it "returns the directory path as its identity" do
-      expect(@resource.identity).to eq("/tmp/foo/bar/")
+      expect(resource.identity).to eq("/tmp/foo/bar/")
     end
   end
 end