chef 14.1.12-universal-mingw32 → 14.2.0-universal-mingw32

data/spec/unit/resource/directory_spec.rb

@@ -22,22 +22,17 @@ require "spec_helper"
 describe Chef::Resource::Directory do
   let(:resource) { Chef::Resource::Directory.new("fakey_fakerton") }
 
-  it "has a name property" do
-    expect(resource.name).to eql("fakey_fakerton")
+  it "the path property is the name_property" do
+    expect(resource.path).to eql("fakey_fakerton")
   end
 
-  it "has a default action of 'create'" do
+  it "sets the default action as :create" do
     expect(resource.action).to eql([:create])
   end
 
-  it "accepts create or delete for action" do
+  it "supports :create, :delete actions" 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 "uses the object name as the path by default" do
-    expect(resource.path).to eql("fakey_fakerton")
   end
 
   it "accepts a string as the path" do

data/spec/unit/resource/dmg_package_spec.rb

@@ -19,17 +19,21 @@ require "spec_helper"
 
 describe Chef::Resource::DmgPackage do
 
-  let(:resource) { Chef::Resource::DmgPackage.new("myapp") }
+  let(:resource) { Chef::Resource::DmgPackage.new("fakey_fakerton") }
 
   it "has a resource name of :dmg_package" do
     expect(resource.resource_name).to eql(:dmg_package)
   end
 
-  it "has a default action of install" do
+  it "the app property is the name_property" do
+    expect(resource.app).to eql("fakey_fakerton")
+  end
+
+  it "sets the default action as :install" do
     expect(resource.action).to eql([:install])
   end
 
-  it "the app property is the name property" do
-    expect(resource.app).to eql("myapp")
+  it "supports :install action" do
+    expect { resource.action :install }.not_to raise_error
   end
 end

data/spec/unit/resource/dnf_package_spec.rb

@@ -31,13 +31,28 @@ describe Chef::Resource::DnfPackage, "initialize" do
 
 end
 
-describe Chef::Resource::DnfPackage, "arch" do
+describe Chef::Resource::DnfPackage, "defaults" do
   let(:resource) { Chef::Resource::DnfPackage.new("foo") }
 
   it "sets the arch variable to whatever is passed in" do
     resource.arch("i386")
     expect(resource.arch).to eql(["i386"])
   end
+
+  it "sets the default action as :install" do
+    expect(resource.action).to eql([:install])
+  end
+
+  it "supports :flush_cache, :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
+    expect { resource.action :flush_cache }.not_to raise_error
+    expect { resource.action :install }.not_to raise_error
+    expect { resource.action :lock }.not_to raise_error
+    expect { resource.action :purge }.not_to raise_error
+    expect { resource.action :reconfig }.not_to raise_error
+    expect { resource.action :remove }.not_to raise_error
+    expect { resource.action :unlock }.not_to raise_error
+    expect { resource.action :upgrade }.not_to raise_error
+  end
 end
 
 describe Chef::Resource::DnfPackage, "flush_cache" do

data/spec/unit/resource/dpkg_package_spec.rb

@@ -29,4 +29,22 @@ describe Chef::Resource::DpkgPackage, "initialize" do
     os: "linux"
   )
 
+  describe Chef::Resource::DpkgPackage, "defaults" do
+    let(:resource) { Chef::Resource::DpkgPackage.new("fakey_fakerton") }
+
+    it "sets the default action as :install" do
+      expect(resource.action).to eql([:install])
+    end
+
+    it "supports :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
+      expect { resource.action :install }.not_to raise_error
+      expect { resource.action :lock }.not_to raise_error
+      expect { resource.action :purge }.not_to raise_error
+      expect { resource.action :reconfig }.not_to raise_error
+      expect { resource.action :remove }.not_to raise_error
+      expect { resource.action :unlock }.not_to raise_error
+      expect { resource.action :upgrade }.not_to raise_error
+    end
+  end
+
 end

data/spec/unit/resource/dsc_resource_spec.rb

@@ -40,31 +40,31 @@ describe Chef::Resource::DscResource do
       expect(dsc_test_resource.action).to eq([:run])
     end
 
-    it "has an ed_actions attribute with only the `:run` and `:nothing` attributes" do
+    it "has an ed_actions property with only the `:run` and `:nothing` properties" do
       expect(dsc_test_resource.allowed_actions.to_set).to eq([:run, :nothing].to_set)
     end
 
-    it "allows the resource attribute to be set" do
+    it "allows the resource property to be set" do
       dsc_test_resource.resource(dsc_test_resource_name)
       expect(dsc_test_resource.resource).to eq(dsc_test_resource_name)
     end
 
-    it "allows the module_name attribute to be set" do
+    it "allows the module_name property to be set" do
       dsc_test_resource.module_name(dsc_test_resource_name)
       expect(dsc_test_resource.module_name).to eq(dsc_test_resource_name)
     end
 
-    it "allows the module_version attribute to be set" do
+    it "allows the module_version property to be set" do
       dsc_test_resource.module_version(dsc_test_resource_module_version)
       expect(dsc_test_resource.module_version).to eq(dsc_test_resource_module_version)
     end
 
-    it "allows the reboot_action attribute to be set" do
+    it "allows the reboot_action property to be set" do
       dsc_test_resource.reboot_action(dsc_test_reboot_action)
       expect(dsc_test_resource.reboot_action).to eq(dsc_test_reboot_action)
     end
 
-    it "allows the timeout attribute to be set" do
+    it "allows the timeout property to be set" do
       dsc_test_resource.timeout(dsc_test_timeout)
       expect(dsc_test_resource.timeout).to eq(dsc_test_timeout)
     end

data/spec/unit/resource/dsc_script_spec.rb

@@ -19,7 +19,7 @@
 require "spec_helper"
 
 describe Chef::Resource::DscScript do
-  let(:dsc_test_resource_name) { "DSCTest" }
+  let(:resource_name) { "DSCTest" }
 
   context "when Powershell supports Dsc" do
     let(:dsc_test_run_context) do
@@ -28,8 +28,8 @@ describe Chef::Resource::DscScript do
       empty_events = Chef::EventDispatch::Dispatcher.new
       Chef::RunContext.new(node, {}, empty_events)
     end
-    let(:dsc_test_resource) do
-      Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
+    let(:resource) do
+      Chef::Resource::DscScript.new(resource_name, dsc_test_run_context)
     end
     let(:configuration_code) { 'echo "This is supposed to create a configuration document."' }
     let(:configuration_path) { "c:/myconfigs/formatc.ps1" }
@@ -37,41 +37,41 @@ describe Chef::Resource::DscScript do
     let(:configuration_data) { '@{AllNodes = @( @{ NodeName = "localhost"; PSDscAllowPlainTextPassword = $true })}' }
     let(:configuration_data_script) { "c:/myconfigs/data/safedata.psd1" }
 
-    it "has a default action of `:run`" do
-      expect(dsc_test_resource.action).to eq([:run])
+    it "sets the default action as :run" do
+      expect(resource.action).to eql([:run])
     end
 
-    it "has an allowed_actions attribute with only the `:run` and `:nothing` attributes" do
-      expect(dsc_test_resource.allowed_actions.to_set).to eq([:run, :nothing].to_set)
+    it "supports :run action" do
+      expect { resource.action :run }.not_to raise_error
     end
 
     it "allows the code attribute to be set" do
-      dsc_test_resource.code(configuration_code)
-      expect(dsc_test_resource.code).to eq(configuration_code)
+      resource.code(configuration_code)
+      expect(resource.code).to eq(configuration_code)
     end
 
     it "allows the command attribute to be set" do
-      dsc_test_resource.command(configuration_path)
-      expect(dsc_test_resource.command).to eq(configuration_path)
+      resource.command(configuration_path)
+      expect(resource.command).to eq(configuration_path)
     end
 
     it "allows the configuration_name attribute to be set" do
-      dsc_test_resource.configuration_name(configuration_name)
-      expect(dsc_test_resource.configuration_name).to eq(configuration_name)
+      resource.configuration_name(configuration_name)
+      expect(resource.configuration_name).to eq(configuration_name)
     end
 
     it "allows the configuration_data attribute to be set" do
-      dsc_test_resource.configuration_data(configuration_data)
-      expect(dsc_test_resource.configuration_data).to eq(configuration_data)
+      resource.configuration_data(configuration_data)
+      expect(resource.configuration_data).to eq(configuration_data)
     end
 
     it "allows the configuration_data_script attribute to be set" do
-      dsc_test_resource.configuration_data_script(configuration_data_script)
-      expect(dsc_test_resource.configuration_data_script).to eq(configuration_data_script)
+      resource.configuration_data_script(configuration_data_script)
+      expect(resource.configuration_data_script).to eq(configuration_data_script)
     end
 
     it "has the ps_credential helper method" do
-      expect(dsc_test_resource).to respond_to(:ps_credential)
+      expect(resource).to respond_to(:ps_credential)
     end
 
     context "when calling imports" do
@@ -80,55 +80,55 @@ describe Chef::Resource::DscScript do
       let(:dsc_resources) { %w{ResourceA ResourceB} }
 
       it "allows an arbitrary number of resources to be set for a module to be set" do
-        dsc_test_resource.imports module_name, *dsc_resources
-        module_imports = dsc_test_resource.imports[module_name]
+        resource.imports module_name, *dsc_resources
+        module_imports = resource.imports[module_name]
         expect(module_imports).to eq(dsc_resources)
       end
 
       it "adds * to the imports when no resources are set for a moudle" do
-        dsc_test_resource.imports module_name
-        module_imports = dsc_test_resource.imports[module_name]
+        resource.imports module_name
+        module_imports = resource.imports[module_name]
         expect(module_imports).to eq(["*"])
       end
 
       it "allows an arbitrary number of modules" do
-        dsc_test_resource.imports module_name
-        dsc_test_resource.imports module_name_b
-        expect(dsc_test_resource.imports).to have_key(module_name)
-        expect(dsc_test_resource.imports).to have_key(module_name_b)
+        resource.imports module_name
+        resource.imports module_name_b
+        expect(resource.imports).to have_key(module_name)
+        expect(resource.imports).to have_key(module_name_b)
       end
 
       it "allows resources to be added for a module" do
-        dsc_test_resource.imports module_name, dsc_resources[0]
-        dsc_test_resource.imports module_name, dsc_resources[1]
-        module_imports = dsc_test_resource.imports[module_name]
+        resource.imports module_name, dsc_resources[0]
+        resource.imports module_name, dsc_resources[1]
+        module_imports = resource.imports[module_name]
         expect(module_imports).to eq(dsc_resources)
       end
     end
 
     it "raises an ArgumentError exception if an attempt is made to set the code attribute when the command attribute is already set" do
-      dsc_test_resource.command(configuration_path)
-      expect { dsc_test_resource.code(configuration_code) }.to raise_error(ArgumentError)
+      resource.command(configuration_path)
+      expect { resource.code(configuration_code) }.to raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError exception if an attempt is made to set the command attribute when the code attribute is already set" do
-      dsc_test_resource.code(configuration_code)
-      expect { dsc_test_resource.command(configuration_path) }.to raise_error(ArgumentError)
+      resource.code(configuration_code)
+      expect { resource.command(configuration_path) }.to raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError exception if an attempt is made to set the configuration_name attribute when the code attribute is already set" do
-      dsc_test_resource.code(configuration_code)
-      expect { dsc_test_resource.configuration_name(configuration_name) }.to raise_error(ArgumentError)
+      resource.code(configuration_code)
+      expect { resource.configuration_name(configuration_name) }.to raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError exception if an attempt is made to set the configuration_data attribute when the configuration_data_script attribute is already set" do
-      dsc_test_resource.configuration_data_script(configuration_data_script)
-      expect { dsc_test_resource.configuration_data(configuration_data) }.to raise_error(ArgumentError)
+      resource.configuration_data_script(configuration_data_script)
+      expect { resource.configuration_data(configuration_data) }.to raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError exception if an attempt is made to set the configuration_data_script attribute when the configuration_data attribute is already set" do
-      dsc_test_resource.configuration_data(configuration_data)
-      expect { dsc_test_resource.configuration_data_script(configuration_data_script) }.to raise_error(ArgumentError)
+      resource.configuration_data(configuration_data)
+      expect { resource.configuration_data_script(configuration_data_script) }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/unit/resource/execute_spec.rb

@@ -21,15 +21,23 @@ require "spec_helper"
 
 describe Chef::Resource::Execute do
   let(:resource_instance_name) { "some command" }
-  let(:execute_resource) { Chef::Resource::Execute.new(resource_instance_name) }
+  let(:resource) { Chef::Resource::Execute.new(resource_instance_name) }
   it_behaves_like "an execute resource"
 
+  it "sets the default action as :run" do
+    expect(resource.action).to eql([:run])
+  end
+
+  it "supports :run action" do
+    expect { resource.action :run }.not_to raise_error
+  end
+
   it "default guard interpreter is :execute interpreter" do
-    expect(execute_resource.guard_interpreter).to be(:execute)
+    expect(resource.guard_interpreter).to be(:execute)
   end
 
   it "defaults to not being a guard interpreter" do
-    expect(execute_resource.is_guard_interpreter).to eq(false)
+    expect(resource.is_guard_interpreter).to eq(false)
   end
 
   describe "#qualify_user" do
@@ -40,7 +48,7 @@ describe Chef::Resource::Execute do
       let(:username) { "user@domain" }
 
       it "correctly parses the user and domain" do
-        identity = execute_resource.qualify_user(username, password, domain)
+        identity = resource.qualify_user(username, password, domain)
         expect(identity[:domain]).to eq("domain")
         expect(identity[:user]).to eq("user")
       end
@@ -50,7 +58,7 @@ describe Chef::Resource::Execute do
       let(:username) { "domain\\user" }
 
       it "correctly parses the user and domain" do
-        identity = execute_resource.qualify_user(username, password, domain)
+        identity = resource.qualify_user(username, password, domain)
         expect(identity[:domain]).to eq("domain")
         expect(identity[:user]).to eq("user")
       end
@@ -60,14 +68,14 @@ describe Chef::Resource::Execute do
   shared_examples_for "it received valid credentials" do
     describe "the validation method" do
       it "does not raise an error" do
-        expect { execute_resource.validate_identity_platform(username, password, domain) }.not_to raise_error
+        expect { resource.validate_identity_platform(username, password, domain) }.not_to raise_error
       end
     end
 
     describe "the name qualification method" 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 = resource.qualify_user(username, password, domain) }.not_to raise_error
         expect(identity[:domain]).to eq(domain)
         expect(identity[:user]).to eq(username)
       end
@@ -77,7 +85,7 @@ describe Chef::Resource::Execute do
   shared_examples_for "it received invalid credentials" do
     describe "the validation method" do
       it "raises an error" do
-        expect { execute_resource.validate_identity_platform(username, password, domain, elevated) }.to raise_error(ArgumentError)
+        expect { resource.validate_identity_platform(username, password, domain, elevated) }.to raise_error(ArgumentError)
       end
     end
   end
@@ -85,7 +93,7 @@ describe Chef::Resource::Execute do
   shared_examples_for "it received invalid username and domain" do
     describe "the validation method" do
       it "raises an error" do
-        expect { execute_resource.qualify_user(username, password, domain) }.to raise_error(ArgumentError)
+        expect { resource.qualify_user(username, password, domain) }.to raise_error(ArgumentError)
       end
     end
   end
@@ -93,7 +101,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 "raises an error" do
-        expect { execute_resource.validate_identity_platform(username, password, domain) }.to raise_error(Chef::Exceptions::UnsupportedPlatform)
+        expect { resource.validate_identity_platform(username, password, domain) }.to raise_error(Chef::Exceptions::UnsupportedPlatform)
       end
     end
   end
@@ -101,7 +109,7 @@ describe Chef::Resource::Execute do
   shared_examples_for "a consumer of the Execute resource" do
     context "when running on Windows" do
       before do
-        allow(execute_resource).to receive(:node).and_return({ :platform_family => "windows" })
+        allow(resource).to receive(:node).and_return({ :platform_family => "windows" })
       end
 
       context "when no user, domain, or password is specified" do
@@ -203,7 +211,7 @@ describe Chef::Resource::Execute do
 
     context "when not running on Windows" do
       before do
-        allow(execute_resource).to receive(:node).and_return({ :platform_family => "ubuntu" })
+        allow(resource).to receive(:node).and_return({ :platform_family => "ubuntu" })
       end
 
       context "when no user, domain, or password is specified" do

data/spec/unit/resource/file_spec.rb

@@ -22,14 +22,21 @@ describe Chef::Resource::File do
 
   let(:resource) { Chef::Resource::File.new("fakey_fakerton") }
 
-  it "has a name property" do
-    expect(resource.name).to eql("fakey_fakerton")
+  it "the path property is the name_property" do
+    expect(resource.path).to eql("fakey_fakerton")
   end
 
-  it "has a default action of 'create'" do
+  it "sets the default action as :create" do
     expect(resource.action).to eql([:create])
   end
 
+  it "supports :create, :create_if_missing, :delete, :touch actions" do
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :create_if_missing }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+    expect { resource.action :touch }.not_to raise_error
+  end
+
   it "has a default content of nil" do
     expect(resource.content).to be_nil
   end
@@ -57,13 +64,6 @@ describe Chef::Resource::File do
     expect { resource.checksum "monkey!" }.to raise_error(ArgumentError)
   end
 
-  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 "accepts a block, symbol, or string for verify" do
     expect { resource.verify {} }.not_to raise_error
     expect { resource.verify "" }.not_to raise_error

data/spec/unit/resource/freebsd_package_spec.rb

@@ -42,6 +42,22 @@ describe Chef::Resource::FreebsdPackage do
     end
   end
 
+  describe "Actions" do
+    it "sets the default action as :install" do
+      expect(resource.action).to eql([:install])
+    end
+
+    it "supports :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
+      expect { resource.action :install }.not_to raise_error
+      expect { resource.action :lock }.not_to raise_error
+      expect { resource.action :purge }.not_to raise_error
+      expect { resource.action :reconfig }.not_to raise_error
+      expect { resource.action :remove }.not_to raise_error
+      expect { resource.action :unlock }.not_to raise_error
+      expect { resource.action :upgrade }.not_to raise_error
+    end
+  end
+
   describe "Assigning provider after creation" do
     describe "if ports specified as source" do
       it "is Freebsd::Port" do