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

data/spec/unit/resource/dnf_package_spec.rb

@@ -36,7 +36,7 @@ describe Chef::Resource::DnfPackage, "arch" do
     @resource = Chef::Resource::DnfPackage.new("foo")
   end
 
-  it "should set the arch variable to whatever is passed in" do
+  it "sets the arch variable to whatever is passed in" do
     @resource.arch("i386")
     expect(@resource.arch).to eql(["i386"])
   end
@@ -47,40 +47,40 @@ describe Chef::Resource::DnfPackage, "flush_cache" do
     @resource = Chef::Resource::DnfPackage.new("foo")
   end
 
-  it "should default the flush timing to false" do
+  it "defaults the flush timing to false" do
     flush_hash = { :before => false, :after => false }
     expect(@resource.flush_cache).to eq(flush_hash)
   end
 
-  it "should allow you to set the flush timing with an array" do
+  it "allows you to set the flush timing with an array" do
     flush_array = [ :before, :after ]
     flush_hash = { :before => true, :after => true }
     @resource.flush_cache(flush_array)
     expect(@resource.flush_cache).to eq(flush_hash)
   end
 
-  it "should allow you to set the flush timing with a hash" do
+  it "allows you to set the flush timing with a hash" do
     flush_hash = { :before => true, :after => true }
     @resource.flush_cache(flush_hash)
     expect(@resource.flush_cache).to eq(flush_hash)
   end
 
-  it "should allow 'true' for flush_cache" do
+  it "allows 'true' for flush_cache" do
     @resource.flush_cache(true)
     expect(@resource.flush_cache).to eq({ before: true, after: true })
   end
 
-  it "should allow 'false' for flush_cache" do
+  it "allows 'false' for flush_cache" do
     @resource.flush_cache(false)
     expect(@resource.flush_cache).to eq({ before: false, after: false })
   end
 
-  it "should allow ':before' for flush_cache" do
+  it "allows ':before' for flush_cache" do
     @resource.flush_cache(:before)
     expect(@resource.flush_cache).to eq({ before: true, after: false })
   end
 
-  it "should allow ':after' for flush_cache" do
+  it "allows ':after' for flush_cache" do
     @resource.flush_cache(:after)
     expect(@resource.flush_cache).to eq({ before: false, after: true })
   end
@@ -91,7 +91,7 @@ describe Chef::Resource::DnfPackage, "allow_downgrade" do
     @resource = Chef::Resource::DnfPackage.new("foo")
   end
 
-  it "should allow you to specify whether allow_downgrade is true or false" do
+  it "allows you to specify whether allow_downgrade is true or false" do
     Chef::Config[:treat_deprecation_warnings_as_errors] = false
     expect { @resource.allow_downgrade true }.not_to raise_error
     expect { @resource.allow_downgrade false }.not_to raise_error

data/spec/unit/resource/env_spec.rb

@@ -25,16 +25,16 @@ describe Chef::Resource::Env do
     @resource = Chef::Resource::Env.new("FOO")
   end
 
-  it "should create a new Chef::Resource::Env" do
+  it "creates a new Chef::Resource::Env" do
     expect(@resource).to be_a_kind_of(Chef::Resource)
     expect(@resource).to be_a_kind_of(Chef::Resource::Env)
   end
 
-  it "should have a name" do
+  it "has a name" do
     expect(@resource.name).to eql("FOO")
   end
 
-  it "should have a default action of 'create'" do
+  it "has a default action of 'create'" do
     expect(@resource.action).to eql([:create])
   end
 
@@ -48,19 +48,19 @@ describe Chef::Resource::Env do
     end
   end
 
-  it "should use the object name as the key_name by default" do
+  it "uses the object name as the key_name by default" do
     expect(@resource.key_name).to eql("FOO")
   end
 
-  it "should accept a string as the env value via 'value'" do
+  it "accepts a string as the env value via 'value'" do
     expect { @resource.value "bar" }.not_to raise_error
   end
 
-  it "should not accept a Hash for the env value via 'to'" do
+  it "does not accept a Hash for the env value via 'to'" do
     expect { @resource.value Hash.new }.to raise_error(ArgumentError)
   end
 
-  it "should allow you to set an env value via 'to'" do
+  it "allows you to set an env value via 'to'" do
     @resource.value "bar"
     expect(@resource.value).to eql("bar")
   end

data/spec/unit/resource/erl_call_spec.rb

@@ -25,44 +25,44 @@ describe Chef::Resource::ErlCall do
     @resource = Chef::Resource::ErlCall.new("fakey_fakerton")
   end
 
-  it "should create a new Chef::Resource::ErlCall" do
+  it "creates a new Chef::Resource::ErlCall" do
     expect(@resource).to be_a_kind_of(Chef::Resource)
     expect(@resource).to be_a_kind_of(Chef::Resource::ErlCall)
   end
 
-  it "should have a resource name of :erl_call" do
+  it "has a resource name of :erl_call" do
     expect(@resource.resource_name).to eql(:erl_call)
   end
 
-  it "should have a default action of run" do
+  it "has a default action of run" do
     expect(@resource.action).to eql([:run])
   end
 
-  it "should accept run as an action" do
+  it "accepts run as an action" do
     expect { @resource.action :run }.not_to raise_error
   end
 
-  it "should allow you to set the code attribute" do
+  it "allows you to set the code attribute" do
     @resource.code "q()."
     expect(@resource.code).to eql("q().")
   end
 
-  it "should allow you to set the cookie attribute" do
+  it "allows you to set the cookie attribute" do
     @resource.cookie "nomnomnom"
     expect(@resource.cookie).to eql("nomnomnom")
   end
 
-  it "should allow you to set the distributed attribute" do
+  it "allows you to set the distributed attribute" do
     @resource.distributed true
     expect(@resource.distributed).to eql(true)
   end
 
-  it "should allow you to set the name_type attribute" do
+  it "allows you to set the name_type attribute" do
     @resource.name_type "sname"
     expect(@resource.name_type).to eql("sname")
   end
 
-  it "should allow you to set the node_name attribute" do
+  it "allows you to set the node_name attribute" do
     @resource.node_name "chef@erlang"
     expect(@resource.node_name).to eql("chef@erlang")
   end

data/spec/unit/resource/execute_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Resource::Execute do
   let(:execute_resource) { Chef::Resource::Execute.new(resource_instance_name) }
   it_behaves_like "an execute resource"
 
-  it "default guard interpreter should be :execute interpreter" do
+  it "default guard interpreter is :execute interpreter" do
     expect(execute_resource.guard_interpreter).to be(:execute)
   end
 
@@ -59,13 +59,13 @@ describe Chef::Resource::Execute do
 
   shared_examples_for "it received valid credentials" do
     describe "the validation method" do
-      it "should not raise an error" do
+      it "does not raise an error" do
         expect { execute_resource.validate_identity_platform(username, password, domain) }.not_to raise_error
       end
     end
 
     describe "the name qualification method" do
-      it "should correctly translate the user and domain" do
+      it "correctly translates the user and domain" do
         identity = nil
         expect { identity = execute_resource.qualify_user(username, password, domain) }.not_to raise_error
         expect(identity[:domain]).to eq(domain)
@@ -76,7 +76,7 @@ describe Chef::Resource::Execute do
 
   shared_examples_for "it received invalid credentials" do
     describe "the validation method" do
-      it "should raise an error" do
+      it "raises an error" do
         expect { execute_resource.validate_identity_platform(username, password, domain, elevated) }.to raise_error(ArgumentError)
       end
     end
@@ -84,7 +84,7 @@ describe Chef::Resource::Execute do
 
   shared_examples_for "it received invalid username and domain" do
     describe "the validation method" do
-      it "should raise an error" do
+      it "raises an error" do
         expect { execute_resource.qualify_user(username, password, domain) }.to raise_error(ArgumentError)
       end
     end
@@ -92,7 +92,7 @@ describe Chef::Resource::Execute do
 
   shared_examples_for "it received credentials that are not valid on the platform" do
     describe "the validation method" do
-      it "should raise an error" do
+      it "raises an error" do
         expect { execute_resource.validate_identity_platform(username, password, domain) }.to raise_error(Chef::Exceptions::UnsupportedPlatform)
       end
     end

data/spec/unit/resource/file/verification_spec.rb

@@ -66,6 +66,11 @@ describe Chef::Resource::File::Verification do
         v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &f_block)
         expect(v.verify(temp_path)).to eq(false)
       end
+
+      it "responds to to_s" do
+        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
+        expect(v.to_s).to eq("<Proc>")
+      end
     end
 
     context "with a verification command(String)" do
@@ -110,23 +115,32 @@ describe Chef::Resource::File::Verification do
         v = Chef::Resource::File::Verification.new(parent_resource, "true", {})
         expect(v.verify(temp_path)).to eq(true)
       end
+
+      it "responds to to_s" do
+        v = Chef::Resource::File::Verification.new(parent_resource, "some command --here", {})
+        expect(v.to_s).to eq("some command --here")
+      end
     end
 
     context "with a named verification(Symbol)" do
+      let(:registered_verification) { double("registered_verification") }
+      subject { described_class.new(parent_resource, :cats, {}) }
       before(:each) do
         class Chef::Resource::File::Verification::Turtle < Chef::Resource::File::Verification
           provides :cats
           def verify(path, opts)
           end
         end
+        allow(Chef::Resource::File::Verification::Turtle).to receive(:new).and_return(registered_verification)
       end
 
       it "delegates to the registered verification" do
-        registered_verification = double()
-        allow(Chef::Resource::File::Verification::Turtle).to receive(:new).and_return(registered_verification)
-        v = Chef::Resource::File::Verification.new(parent_resource, :cats, {})
         expect(registered_verification).to receive(:verify).with(temp_path, {})
-        v.verify(temp_path, {})
+        subject.verify(temp_path, {})
+      end
+
+      it "responds to to_s" do
+        expect(subject.to_s).to eq(":cats (Chef::Resource::File::Verification::Turtle)")
       end
     end
   end

data/spec/unit/resource/file_spec.rb

@@ -20,88 +20,86 @@ require "spec_helper"
 
 describe Chef::Resource::File do
 
-  before(:each) do
-    @resource = Chef::Resource::File.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::File.new("fakey_fakerton") }
 
-  it "should have a name" do
-    expect(@resource.name).to eql("fakey_fakerton")
+  it "has a name" do
+    expect(resource.name).to eql("fakey_fakerton")
   end
 
-  it "should have a default action of 'create'" do
-    expect(@resource.action).to eql([:create])
+  it "has a default action of 'create'" do
+    expect(resource.action).to eql([:create])
   end
 
-  it "should have a default content of nil" do
-    expect(@resource.content).to be_nil
+  it "has a default content of nil" do
+    expect(resource.content).to be_nil
   end
 
-  it "should be set to back up 5 files by default" do
-    expect(@resource.backup).to eql(5)
+  it "is set to back up 5 files by default" do
+    expect(resource.backup).to eql(5)
   end
 
-  it "should only accept strings for content" do
-    expect { @resource.content 5 }.to raise_error(ArgumentError)
-    expect { @resource.content :foo }.to raise_error(ArgumentError)
-    expect { @resource.content "hello" => "there" }.to raise_error(ArgumentError)
-    expect { @resource.content "hi" }.not_to raise_error
+  it "only accept strings for content" do
+    expect { resource.content 5 }.to raise_error(ArgumentError)
+    expect { resource.content :foo }.to raise_error(ArgumentError)
+    expect { resource.content "hello" => "there" }.to raise_error(ArgumentError)
+    expect { resource.content "hi" }.not_to raise_error
   end
 
-  it "should only accept false or a number for backup" do
-    expect { @resource.backup true }.to raise_error(ArgumentError)
-    expect { @resource.backup false }.not_to raise_error
-    expect { @resource.backup 10 }.not_to raise_error
-    expect { @resource.backup "blues" }.to raise_error(ArgumentError)
+  it "only accept false or a number for backup" do
+    expect { resource.backup true }.to raise_error(ArgumentError)
+    expect { resource.backup false }.not_to raise_error
+    expect { resource.backup 10 }.not_to raise_error
+    expect { resource.backup "blues" }.to raise_error(ArgumentError)
   end
 
-  it "should accept a sha256 for checksum" do
-    expect { @resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.not_to raise_error
-    expect { @resource.checksum "monkey!" }.to raise_error(ArgumentError)
+  it "accepts a sha256 for checksum" do
+    expect { resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.not_to raise_error
+    expect { resource.checksum "monkey!" }.to raise_error(ArgumentError)
   end
 
-  it "should accept create, delete or touch for action" do
-    expect { @resource.action :create }.not_to raise_error
-    expect { @resource.action :delete }.not_to raise_error
-    expect { @resource.action :touch }.not_to raise_error
-    expect { @resource.action :blues }.to raise_error(ArgumentError)
+  it "accepts create, delete or touch for action" do
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+    expect { resource.action :touch }.not_to raise_error
+    expect { resource.action :blues }.to raise_error(ArgumentError)
   end
 
-  it "should accept a block, symbol, or string for verify" do
-    expect { @resource.verify {} }.not_to raise_error
-    expect { @resource.verify "" }.not_to raise_error
-    expect { @resource.verify :json }.not_to raise_error
-    expect { @resource.verify true }.to raise_error(ArgumentError)
-    expect { @resource.verify false }.to raise_error(ArgumentError)
+  it "accepts a block, symbol, or string for verify" do
+    expect { resource.verify {} }.not_to raise_error
+    expect { resource.verify "" }.not_to raise_error
+    expect { resource.verify :json }.not_to raise_error
+    expect { resource.verify true }.to raise_error(ArgumentError)
+    expect { resource.verify false }.to raise_error(ArgumentError)
   end
 
-  it "should accept multiple verify statements" do
-    @resource.verify "foo"
-    @resource.verify "bar"
-    @resource.verify.length == 2
+  it "accepts multiple verify statements" do
+    resource.verify "foo"
+    resource.verify "bar"
+    resource.verify.length == 2
   end
 
-  it "should use the object name as the path by default" do
-    expect(@resource.path).to eql("fakey_fakerton")
+  it "uses the object name as the path by default" do
+    expect(resource.path).to eql("fakey_fakerton")
   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)
+  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
 
   describe "when it has a path, owner, group, mode, and checksum" do
     before do
-      @resource.path("/tmp/foo.txt")
-      @resource.owner("root")
-      @resource.group("wheel")
-      @resource.mode("0644")
-      @resource.checksum("1" * 64)
+      resource.path("/tmp/foo.txt")
+      resource.owner("root")
+      resource.group("wheel")
+      resource.mode("0644")
+      resource.checksum("1" * 64)
     end
 
     context "on unix", :unix_only do
       it "describes its state" do
-        state = @resource.state_for_resource_reporter
+        state = resource.state_for_resource_reporter
         expect(state[:owner]).to eq("root")
         expect(state[:group]).to eq("wheel")
         expect(state[:mode]).to eq("0644")
@@ -110,21 +108,20 @@ describe Chef::Resource::File do
     end
 
     it "returns the file path as its identity" do
-      expect(@resource.identity).to eq("/tmp/foo.txt")
+      expect(resource.identity).to eq("/tmp/foo.txt")
     end
 
   end
 
   describe "when access controls are set on windows", :windows_only => true do
     before do
-      @resource.rights :read, "Everyone"
-      @resource.rights :full_control, "DOMAIN\User"
+      resource.rights :read, "Everyone"
+      resource.rights :full_control, "DOMAIN\User"
     end
     it "describes its state including windows ACL attributes" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:rights]).to eq([ { :permissions => :read, :principals => "Everyone" },
                                { :permissions => :full_control, :principals => "DOMAIN\User" } ])
     end
   end
-
 end

data/spec/unit/resource/freebsd_package_spec.rb

@@ -30,22 +30,22 @@ describe Chef::Resource::FreebsdPackage do
   end
 
   describe "Initialization" do
-    it "should return a Chef::Resource::FreebsdPackage" do
+    it "returns a Chef::Resource::FreebsdPackage" do
       expect(@resource).to be_a_kind_of(Chef::Resource::FreebsdPackage)
     end
 
-    it "should set the resource_name to :freebsd_package" do
+    it "sets the resource_name to :freebsd_package" do
       expect(@resource.resource_name).to eql(:freebsd_package)
     end
 
-    it "should not set the provider" do
+    it "does not set the provider" do
       expect(@resource.provider).to be_nil
     end
   end
 
   describe "Assigning provider after creation" do
     describe "if ports specified as source" do
-      it "should be Freebsd::Port" do
+      it "is Freebsd::Port" do
         @resource.source("ports")
         @resource.after_created
         expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Port)
@@ -53,7 +53,7 @@ describe Chef::Resource::FreebsdPackage do
     end
 
     describe "if freebsd_version is greater than or equal to 1000017" do
-      it "should be Freebsd::Pkgng" do
+      it "is Freebsd::Pkgng" do
         [1000017, 1000018, 1000500, 1001001, 1100000].each do |freebsd_version|
           @node.automatic_attrs[:os_version] = freebsd_version
           @resource.after_created
@@ -63,7 +63,7 @@ describe Chef::Resource::FreebsdPackage do
     end
 
     describe "if pkgng enabled" do
-      it "should be Freebsd::Pkgng" do
+      it "is Freebsd::Pkgng" do
         pkg_enabled = OpenStruct.new(:stdout => "yes\n")
         allow(@resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)
         @resource.after_created
@@ -72,7 +72,7 @@ describe Chef::Resource::FreebsdPackage do
     end
 
     describe "if freebsd_version is less than 1000017 and pkgng not enabled" do
-      it "should be Freebsd::Pkg" do
+      it "is Freebsd::Pkg" do
         pkg_enabled = OpenStruct.new(:stdout => "\n")
         allow(@resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)