chef 16.3.45-universal-mingw32 → 16.4.35-universal-mingw32

data/spec/unit/provider/remote_directory_spec.rb

@@ -201,17 +201,17 @@ describe Chef::Provider::RemoteDirectory do
         @fclass = Chef::CFCCheck.new
 
         Dir.mktmpdir do |tmp_dir|
-          begin
-            @fclass.file_class.symlink(tmp_dir.dup, symlinked_dir_path)
-            expect(::File.exist?(symlinked_dir_path)).to be_truthy
 
-            @provider.run_action
+          @fclass.file_class.symlink(tmp_dir.dup, symlinked_dir_path)
+          expect(::File.exist?(symlinked_dir_path)).to be_truthy
+
+          @provider.run_action
+
+          expect(::File.exist?(symlinked_dir_path)).to be_falsey
+          expect(::File.exist?(tmp_dir)).to be_truthy
+        rescue Chef::Exceptions::Win32APIError
+          skip "This must be run as an Administrator to create symlinks"
 
-            expect(::File.exist?(symlinked_dir_path)).to be_falsey
-            expect(::File.exist?(tmp_dir)).to be_truthy
-          rescue Chef::Exceptions::Win32APIError
-            skip "This must be run as an Administrator to create symlinks"
-          end
         end
       end
     end

data/spec/unit/provider/service/arch_service_spec.rb

@@ -37,7 +37,8 @@ describe Chef::Provider::Service::Arch, "load_current_resource" do
 
     @provider = Chef::Provider::Service::Arch.new(@new_resource, @run_context)
 
-    allow(::File).to receive(:exists?).with("/etc/rc.conf").and_return(true)
+    allow(::File).to receive(:exist?).with("/etc/rc.d/chef").and_return(false)
+    allow(::File).to receive(:exist?).with("/etc/rc.conf").and_return(true)
     allow(::File).to receive(:read).with("/etc/rc.conf").and_return("DAEMONS=(network apache sshd)")
   end
 
@@ -106,7 +107,7 @@ describe Chef::Provider::Service::Arch, "load_current_resource" do
   end
 
   it "should fail if file /etc/rc.conf does not exist" do
-    allow(::File).to receive(:exists?).with("/etc/rc.conf").and_return(false)
+    allow(::File).to receive(:exist?).with("/etc/rc.conf").and_return(false)
     expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Service)
   end
 

data/spec/unit/provider/service/debian_service_spec.rb

@@ -47,7 +47,7 @@ describe Chef::Provider::Service::Debian do
 
   describe "load_current_resource" do
     it "ensures /usr/sbin/update-rc.d is available" do
-      expect(File).to receive(:exists?).with("/usr/sbin/update-rc.d") .and_return(false)
+      expect(File).to receive(:exist?).with("/usr/sbin/update-rc.d").and_return(false)
 
       @provider.define_resource_requirements
       expect do

data/spec/unit/provider/service/gentoo_service_spec.rb

@@ -32,16 +32,16 @@ describe Chef::Provider::Service::Gentoo do
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
     @status = double("Status", exitstatus: 0, stdout: @stdout)
     allow(@provider).to receive(:shell_out).and_return(@status)
-    allow(File).to receive(:exists?).with("/etc/init.d/chef").and_return(true)
-    allow(File).to receive(:exists?).with("/sbin/rc-update").and_return(true)
-    allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+    allow(File).to receive(:exist?).with("/etc/init.d/chef").and_return(true)
+    allow(File).to receive(:exist?).with("/sbin/rc-update").and_return(true)
+    allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(false)
     allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(false)
   end
   # new test: found_enabled state
   #
   describe "load_current_resource" do
     it "should raise Chef::Exceptions::Service if /sbin/rc-update does not exist" do
-      expect(File).to receive(:exists?).with("/sbin/rc-update").and_return(false)
+      expect(File).to receive(:exist?).with("/sbin/rc-update").and_return(false)
       @provider.define_resource_requirements
       expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
@@ -65,7 +65,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file exists and is readable" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(true)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(true)
           end
           it "should set enabled to true" do
@@ -76,7 +76,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file exists but is not readable" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(true)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(false)
           end
 
@@ -88,7 +88,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file does not exist" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(false)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return("foobarbaz")
           end
 

data/spec/unit/provider/service/macosx_spec.rb

@@ -83,7 +83,7 @@ describe Chef::Provider::Service::Macosx do
             .with(/(#{su_cmd} '#{cmd}'|#{cmd})/, default_env: false)
             .and_return(double("Status",
               stdout: launchctl_stdout, exitstatus: 0))
-          allow(File).to receive(:exists?).and_return([true], [])
+          allow(File).to receive(:exist?).and_return([true], [])
           allow(provider).to receive(:shell_out!)
             .with(/plutil -convert xml1 -o/, default_env: false)
             .and_return(double("Status", stdout: plutil_stdout))
@@ -109,7 +109,7 @@ describe Chef::Provider::Service::Macosx do
 
               before do
                 allow(Dir).to receive(:glob).and_return([])
-                allow(File).to receive(:exists?).and_return([true], [])
+                allow(File).to receive(:exist?).and_return([true], [])
                 allow(provider).to receive(:shell_out!)
                   .with(/plutil -convert xml1 -o/)
                   .and_raise(Mixlib::ShellOut::ShellCommandFailed)
@@ -165,7 +165,7 @@ describe Chef::Provider::Service::Macosx do
             describe "running unsupported actions" do
               before do
                 allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
-                allow(File).to receive(:exists?).and_return([true], [])
+                allow(File).to receive(:exist?).and_return([true], [])
               end
               it "should throw an exception when reload action is attempted" do
                 expect { provider.run_action(:reload) }.to raise_error(Chef::Exceptions::UnsupportedAction)

data/spec/unit/provider/service/redhat_spec.rb

@@ -21,7 +21,7 @@ require "ostruct"
 
 shared_examples_for "define_resource_requirements_common" do
   it "should raise an error if /sbin/chkconfig does not exist" do
-    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(false)
+    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(false)
     allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
     allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_raise(Errno::ENOENT)
     @provider.load_current_resource
@@ -55,7 +55,7 @@ describe "Chef::Provider::Service::Redhat" do
     @provider = Chef::Provider::Service::Redhat.new(@new_resource, @run_context)
     @provider.action = :start
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
-    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(true)
+    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(true)
   end
 
   describe "while not in why run mode" do

data/spec/unit/provider/service/upstart_service_spec.rb

@@ -74,7 +74,7 @@ describe Chef::Provider::Service::Upstart do
       @status = double("Status", exitstatus: 0, stdout: "", stderr: "")
       allow(@provider).to receive(:shell_out).and_return(@status)
 
-      allow(::File).to receive(:exists?).and_return(true)
+      allow(::File).to receive(:exist?).and_return(true)
       allow(::File).to receive(:open).and_return(true)
     end
 
@@ -181,13 +181,13 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should assume disable when no job configuration file is found" do
-      allow(::File).to receive(:exists?).and_return(false)
+      allow(::File).to receive(:exist?).and_return(false)
       expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should track state when the upstart configuration file fails to load" do
-      expect(File).to receive(:exists?).and_return false
+      expect(File).to receive(:exist?).and_return false
       @provider.load_current_resource
       expect(@provider.instance_variable_get("@config_file_found")).to eq(false)
     end

data/spec/unit/provider_resolver_spec.rb

@@ -54,11 +54,11 @@ describe Chef::ProviderResolver do
 
     let(:provider_resolver) { Chef::ProviderResolver.new(node, resource, action) }
     let(:resolved_provider) do
-      begin
-        resource ? resource.provider_for_action(action).class : nil
-      rescue Chef::Exceptions::ProviderNotFound
-        nil
-      end
+
+      resource ? resource.provider_for_action(action).class : nil
+    rescue Chef::Exceptions::ProviderNotFound
+      nil
+
     end
 
     let(:service_name) { "test" }
@@ -722,7 +722,7 @@ describe Chef::ProviderResolver do
           %w{mac_os_x mac_os_x_server} => {
             group: [ Chef::Resource::Group, Chef::Provider::Group::Dscl ],
             package: [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
-            osx_profile: [ Chef::Resource::OsxProfile, Chef::Provider::OsxProfile],
+            osx_profile: [ Chef::Resource::OsxProfile],
             user: [ Chef::Resource::User::DsclUser, Chef::Provider::User::Dscl ],
 
             "mac_os_x" => {

data/spec/unit/resource/batch_spec.rb

@@ -19,24 +19,24 @@
 require "spec_helper"
 
 describe Chef::Resource::Batch do
-  let(:node) { Chef::Node.new }
 
-  before(:each) do
+  let(:resource) do
+    node = Chef::Node.new
     node.default["kernel"] = {}
     node.default["kernel"][:machine] = :x86_64.to_s
     node.automatic[:os] = "windows"
 
     run_context = Chef::RunContext.new(node, nil, nil)
-    @resource = Chef::Resource::Batch.new("batch_unit_test", run_context)
+    Chef::Resource::Batch.new("batch_unit_test", run_context)
   end
 
   it "creates a new Chef::Resource::Batch" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::Batch)
+    expect(resource).to be_a_kind_of(Chef::Resource::Batch)
   end
 
   context "windows script" do
-    let(:resource_instance) { @resource }
-    let(:resource_instance_name ) { @resource.command }
+    let(:windows_script_resource) { resource }
+    let(:resource_instance_name ) { resource.command }
     let(:resource_name) { :batch }
     let(:interpreter_file_name) { "cmd.exe" }
 

data/spec/unit/resource/execute_spec.rb

@@ -116,172 +116,167 @@ describe Chef::Resource::Execute do
     end
   end
 
-  shared_examples_for "a consumer of the Execute resource" do
-    context "when running on Windows" do
-      before do
-        allow(resource).to receive(:windows?).and_return(true)
-      end
-
-      context "when no user, domain, or password is specified" do
-        let(:username) { nil }
-        let(:domain) { nil }
-        let(:password) { nil }
-        it_behaves_like "it received valid credentials"
-      end
-
-      context "when a valid username is specified" do
-        let(:username) { "starchild" }
-        let(:elevated) { false }
-        context "when a valid domain is specified" do
-          let(:domain) { "mothership" }
-
-          context "when the password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received invalid credentials"
-          end
-
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received valid credentials"
-          end
-        end
+  context "when running on Windows" do
+    before do
+      allow(resource).to receive(:windows?).and_return(true)
+    end
 
-        context "when the domain is not specified" do
-          let(:domain) { nil }
-          let(:elevated) { false }
+    context "when no user, domain, or password is specified" do
+      let(:username) { nil }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
+    end
 
-          context "when the password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received invalid credentials"
-          end
+    context "when a valid username is specified" do
+      let(:username) { "starchild" }
+      let(:elevated) { false }
+      context "when a valid domain is specified" do
+        let(:domain) { "mothership" }
 
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received valid credentials"
-          end
+        context "when the password is not specified" do
+          let(:password) { nil }
+          it_behaves_like "it received invalid credentials"
         end
 
-        context "when username is not specified" do
-          let(:username) { nil }
-
-          context "when domain is specified" do
-            let(:domain) { "mothership" }
-            let(:password) { nil }
-            it_behaves_like "it received invalid username and domain"
-          end
-
-          context "when password is specified" do
-            let(:domain) { nil }
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received invalid username and domain"
-          end
+        context "when the password is specified" do
+          let(:password) { "we.funk!" }
+          it_behaves_like "it received valid credentials"
         end
       end
 
-      context "when invalid username is specified" do
-        let(:username) { "user@domain@domain" }
+      context "when the domain is not specified" do
         let(:domain) { nil }
-        let(:password) { "we.funk!" }
-        it_behaves_like "it received invalid username and domain"
-      end
-
-      context "when the domain is provided in both username and domain" do
-        let(:domain) { "some_domain" }
-        let(:password) { "we.funk!" }
+        let(:elevated) { false }
 
-        context "when username is in the form domain\\user" do
-          let(:username) { "mothership\\starchild" }
-          it_behaves_like "it received invalid username and domain"
+        context "when the password is not specified" do
+          let(:password) { nil }
+          it_behaves_like "it received invalid credentials"
         end
 
-        context "when username is in the form user@domain" do
-          let(:username) { "starchild@mothership" }
-          it_behaves_like "it received invalid username and domain"
+        context "when the password is specified" do
+          let(:password) { "we.funk!" }
+          it_behaves_like "it received valid credentials"
         end
       end
 
-      context "when elevated is passed" do
-        let(:elevated) { true }
+      context "when username is not specified" do
+        let(:username) { nil }
 
-        context "when username and password are not passed" do
-          let(:username) { nil }
-          let(:domain) { nil }
+        context "when domain is specified" do
+          let(:domain) { "mothership" }
           let(:password) { nil }
-          it_behaves_like "it received invalid credentials"
+          it_behaves_like "it received invalid username and domain"
         end
 
-        context "when username and password are passed" do
-          let(:username) { "user" }
+        context "when password is specified" do
           let(:domain) { nil }
           let(:password) { "we.funk!" }
-          it_behaves_like "it received valid credentials"
+          it_behaves_like "it received invalid username and domain"
         end
       end
     end
 
-    context "when not running on Windows" do
-      before do
-        allow(resource).to receive(:node).and_return({ platform_family: "ubuntu" })
+    context "when invalid username is specified" do
+      let(:username) { "user@domain@domain" }
+      let(:domain) { nil }
+      let(:password) { "we.funk!" }
+      it_behaves_like "it received invalid username and domain"
+    end
+
+    context "when the domain is provided in both username and domain" do
+      let(:domain) { "some_domain" }
+      let(:password) { "we.funk!" }
+
+      context "when username is in the form domain\\user" do
+        let(:username) { "mothership\\starchild" }
+        it_behaves_like "it received invalid username and domain"
+      end
+
+      context "when username is in the form user@domain" do
+        let(:username) { "starchild@mothership" }
+        it_behaves_like "it received invalid username and domain"
       end
+    end
 
-      context "when no user, domain, or password is specified" do
+    context "when elevated is passed" do
+      let(:elevated) { true }
+
+      context "when username and password are not passed" do
         let(:username) { nil }
         let(:domain) { nil }
         let(:password) { nil }
+        it_behaves_like "it received invalid credentials"
+      end
+
+      context "when username and password are passed" do
+        let(:username) { "user" }
+        let(:domain) { nil }
+        let(:password) { "we.funk!" }
         it_behaves_like "it received valid credentials"
       end
+    end
+  end
+
+  context "when not running on Windows" do
+    before do
+      allow(resource).to receive(:node).and_return({ platform_family: "ubuntu" })
+    end
+
+    context "when no user, domain, or password is specified" do
+      let(:username) { nil }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
+    end
+
+    context "when the user is specified and the domain and password are not" do
+      let(:username) { "starchild" }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
 
-      context "when the user is specified and the domain and password are not" do
-        let(:username) { "starchild" }
+      context "when the password is specified and the domain is not" do
+        let(:password) { "we.funk!" }
         let(:domain) { nil }
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
+
+      context "when the domain is specified and the password is not" do
+        let(:domain) { "mothership" }
         let(:password) { nil }
-        it_behaves_like "it received valid credentials"
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
+
+      context "when the domain and password are specified" do
+        let(:domain) { "mothership" }
+        let(:password) { "we.funk!" }
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
+    end
 
-        context "when the password is specified and the domain is not" do
+    context "when the user is not specified" do
+      let(:username) { nil }
+      context "when the domain is specified" do
+        let(:domain) { "mothership" }
+        context "when the password is specified" do
           let(:password) { "we.funk!" }
-          let(:domain) { nil }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
 
-        context "when the domain is specified and the password is not" do
-          let(:domain) { "mothership" }
+        context "when password is not specified" do
           let(:password) { nil }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
+      end
 
-        context "when the domain and password are specified" do
-          let(:domain) { "mothership" }
+      context "when the domain is not specified" do
+        let(:domain) { nil }
+        context "when the password is specified" do
           let(:password) { "we.funk!" }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
       end
-
-      context "when the user is not specified" do
-        let(:username) { nil }
-        context "when the domain is specified" do
-          let(:domain) { "mothership" }
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-
-          context "when password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-        end
-
-        context "when the domain is not specified" do
-          let(:domain) { nil }
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-        end
-      end
     end
   end
-
-  it_behaves_like "a consumer of the Execute resource"
-
 end