chef 16.5.77-universal-mingw32 → 16.10.8-universal-mingw32

data/spec/unit/platform/query_helpers_spec.rb

@@ -41,24 +41,23 @@ end
 
 describe "Chef::Platform#dsc_refresh_mode_disabled?" do
   let(:node) { instance_double("Chef::Node") }
-  let(:cmdlet) { instance_double("Chef::Util::Powershell::Cmdlet") }
-  let(:cmdlet_result) { instance_double("Chef::Util::Powershell::CmdletResult") }
+  let(:powershell) { instance_double("Chef::PowerShell") }
 
   it "returns true when RefreshMode is Disabled" do
-    expect(Chef::Util::Powershell::Cmdlet).to receive(:new)
-      .with(node, "Get-DscLocalConfigurationManager", :object)
-      .and_return(cmdlet)
-    expect(cmdlet).to receive(:run!).and_return(cmdlet_result)
-    expect(cmdlet_result).to receive(:return_value).and_return({ "RefreshMode" => "Disabled" })
+    expect(Chef::PowerShell).to receive(:new)
+      .with("Get-DscLocalConfigurationManager")
+      .and_return(powershell)
+    expect(powershell).to receive(:error!)
+    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "Disabled" })
     expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be true
   end
 
   it "returns false when RefreshMode is not Disabled" do
-    expect(Chef::Util::Powershell::Cmdlet).to receive(:new)
-      .with(node, "Get-DscLocalConfigurationManager", :object)
-      .and_return(cmdlet)
-    expect(cmdlet).to receive(:run!).and_return(cmdlet_result)
-    expect(cmdlet_result).to receive(:return_value).and_return({ "RefreshMode" => "LaLaLa" })
+    expect(Chef::PowerShell).to receive(:new)
+      .with("Get-DscLocalConfigurationManager")
+      .and_return(powershell)
+    expect(powershell).to receive(:error!)
+    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "LaLaLa" })
     expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be false
   end
 end

data/spec/unit/provider/dsc_resource_spec.rb

@@ -85,14 +85,13 @@ describe Chef::Provider::DscResource do
       node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
       node
     end
-    let(:resource_result) { double("CmdletResult", return_value: { "InDesiredState" => true }, stream: "description") }
-    let(:invoke_dsc_resource) { double("cmdlet", run!: resource_result) }
+    let(:resource_result) { double("PowerShell", result: { "InDesiredState" => true }, verbose: ["description"]) }
     let(:store) { double("ResourceStore", find: resource_records) }
     let(:resource_records) { [] }
 
     before do
       allow(Chef::Util::DSC::ResourceStore).to receive(:instance).and_return(store)
-      allow(Chef::Util::Powershell::Cmdlet).to receive(:new).and_return(invoke_dsc_resource)
+      allow(provider).to receive(:powershell_exec!).and_return(resource_result)
       allow(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
     end
 
@@ -112,9 +111,8 @@ describe Chef::Provider::DscResource do
     it "flags the resource as reboot required when required" do
       expect(provider).to receive(:test_resource).and_return(false)
       expect(provider).to receive(:invoke_resource)
-        .and_return(double(stdout: "", return_value: nil))
+        .and_return(double(result: { "RebootRequired" => true }))
       expect(provider).to receive(:add_dsc_verbose_log)
-      expect(provider).to receive(:return_dsc_resource_result).and_return(true)
       expect(provider).to receive(:create_reboot_resource)
       provider.run_action(:run)
     end
@@ -122,9 +120,8 @@ describe Chef::Provider::DscResource do
     it "does not flag the resource as reboot required when not required" do
       expect(provider).to receive(:test_resource).and_return(false)
       expect(provider).to receive(:invoke_resource)
-        .and_return(double(stdout: "", return_value: nil))
+        .and_return(double(stdout: "", result: {}))
       expect(provider).to receive(:add_dsc_verbose_log)
-      expect(provider).to receive(:return_dsc_resource_result).and_return(false)
       expect(provider).to_not receive(:create_reboot_resource)
       provider.run_action(:run)
     end
@@ -142,9 +139,7 @@ describe Chef::Provider::DscResource do
         let(:resource_records) { [{}] }
 
         it "returns the default dsc resource module" do
-          expect(Chef::Util::Powershell::Cmdlet).to receive(:new) do |node, cmdlet, format|
-            expect(cmdlet).to match(/Module PSDesiredStateConfiguration /)
-          end.and_return(invoke_dsc_resource)
+          expect(provider).to receive(:powershell_exec!).with(/Module PSDesiredStateConfiguration /).and_return(resource_result)
           provider.run_action(:run)
         end
       end
@@ -153,9 +148,7 @@ describe Chef::Provider::DscResource do
         let(:resource_records) { [{ "Module" => { "Name" => "ModuleName" } }] }
 
         it "returns the default dsc resource module" do
-          expect(Chef::Util::Powershell::Cmdlet).to receive(:new) do |node, cmdlet, format|
-            expect(cmdlet).to match(/Module ModuleName /)
-          end.and_return(invoke_dsc_resource)
+          expect(provider).to receive(:powershell_exec!).with(/Module ModuleName /).and_return(resource_result)
           provider.run_action(:run)
         end
       end
@@ -286,8 +279,6 @@ describe Chef::Provider::DscResource do
   end
 
   describe "invoke_resource" do
-    let(:cmdlet) { double(run!: nil) }
-
     before(:each) do
       allow(provider).to receive(:translate_type).and_return("my_properties")
       provider.instance_variable_set(:@new_resource, double(
@@ -301,12 +292,8 @@ describe Chef::Provider::DscResource do
       end
 
       it "invokes Invoke-DscResource command with module name" do
-        expect(Chef::Util::Powershell::Cmdlet).to receive(:new).with(
-          node,
-          "Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module my_module -Verbose",
-          "my_output_format"
-        ).and_return(cmdlet)
-        provider.send(:invoke_resource, "my_method", "my_output_format")
+        expect(provider).to receive(:powershell_exec!).with("Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module my_module -Verbose").and_return(nil)
+        provider.send(:invoke_resource, "my_method")
       end
     end
 
@@ -318,12 +305,8 @@ describe Chef::Provider::DscResource do
       end
 
       it "invokes Invoke-DscResource command with module info object" do
-        expect(Chef::Util::Powershell::Cmdlet).to receive(:new).with(
-          node,
-          "Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module @{ModuleName='my_module';ModuleVersion='my_module_version'} -Verbose",
-          "my_output_format"
-        ).and_return(cmdlet)
-        provider.send(:invoke_resource, "my_method", "my_output_format")
+        expect(provider).to receive(:powershell_exec!).with("Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module @{ModuleName='my_module';ModuleVersion='my_module_version'} -Verbose").and_return(nil)
+        provider.send(:invoke_resource, "my_method")
       end
     end
   end

data/spec/unit/provider/dsc_script_spec.rb

@@ -99,7 +99,7 @@ describe Chef::Provider::DscScript do
       it "should noop if neither code or command are provided" do
         allow(provider).to receive(:load_current_resource)
         generator = double("Chef::Util::DSC::ConfigurationGenerator")
-        expect(generator).to receive(:configuration_document_from_script_code).with("", anything, anything, anything)
+        expect(generator).to receive(:configuration_document_from_script_code).with("", anything, anything)
         allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
         provider.send(:generate_configuration_document, "tmp", nil)
       end

data/spec/unit/provider/group/windows_spec.rb

@@ -39,6 +39,12 @@ describe Chef::Provider::Group::Windows do
   end
 
   describe "when creating the group" do
+    before do
+      @current_resource = Chef::Resource::Group.new("staff")
+      @current_resource.members %w{all your base}
+      @provider.current_resource = @current_resource
+    end
+
     it "should call @net_group.local_add" do
       expect(@net_group).to receive(:local_set_members).with([])
       expect(@net_group).to receive(:local_add)

data/spec/unit/provider/group_spec.rb

@@ -266,7 +266,7 @@ describe Chef::Provider::User do
       @new_resource.members << "user1"
       allow(@new_resource).to receive(:append).and_return false
       expect(@provider.compare_group).to be_truthy
-      expect(@provider.change_desc).to eq([ "replace group members with new list of members" ])
+      expect(@provider.change_desc).to eq([ "replace group members with new list of members: aj, user1" ])
     end
 
     it "should report the gid will be changed when it does not match" do

data/spec/unit/provider/mount/linux_spec.rb

@@ -24,6 +24,7 @@ describe Chef::Provider::Mount::Linux do
   before(:each) do
     allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
     allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup").and_return true
     allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
     allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
@@ -92,6 +93,15 @@ describe Chef::Provider::Mount::Linux do
       expect(provider.current_resource.mounted).to be_falsey
     end
 
+    it "should set mounted true if network_device? is true and the mount point is found in the mounts list" do
+      new_resource.device "//192.168.11.102/Share/backup"
+      new_resource.fstype "cifs"
+      mount = "/tmp/foo //192.168.11.102/Share/backup[/backup] cifs rw\n"
+      mount << "#{new_resource.mount_point} #{new_resource.device} type #{new_resource.fstype}\n"
+      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
+      provider.load_current_resource
+      expect(provider.current_resource.mounted).to be_truthy
+    end
   end
 
 end

data/spec/unit/provider/mount/mount_spec.rb

@@ -247,15 +247,6 @@ describe Chef::Provider::Mount::Mount do
       expect(@provider.current_resource.enabled).to be_falsey
     end
 
-    it "should set enabled to false if the mount point is not last in fstab" do
-      line_1 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
-      line_2 = "/dev/sdy1 #{@new_resource.mount_point}  ext3  defaults  1 2\n"
-      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield(line_1).and_yield(line_2)
-
-      @provider.load_current_resource
-      expect(@provider.current_resource.enabled).to be_falsey
-    end
-
     it "should not mangle the mount options if the device in fstab is a symlink" do
       # expand the target path to correct specs on Windows
       target = "/dev/mapper/target"
@@ -427,10 +418,30 @@ describe Chef::Provider::Mount::Mount do
         @fstab = StringIO.new
         allow(::File).to receive(:readlines).and_return([])
         expect(::File).to receive(:open).once.with("/etc/fstab", "w").and_yield(@fstab)
-        expect(::File).to receive(:open).once.with("/etc/fstab", "a").and_yield(@fstab)
 
         @provider.enable_fs
       end
+
+      it "should update the last matching entry if enabled is true" do
+        @new_resource.fstype("ext4")
+        @new_resource.dump(2)
+        @new_resource.pass(1)
+        allow(@current_resource).to receive(:enabled).and_return(true)
+        fstab_read = ["/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n",
+                      "/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n",
+                      "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n",
+                      "/dev/sdz1 /tmp/foobar  ext3  defaults  1 2\n"]
+
+        fstab_write = StringIO.new
+        allow(::File).to receive(:readlines).with("/etc/fstab").and_return(fstab_read)
+        allow(::File).to receive(:open).with("/etc/fstab", "w").and_yield(fstab_write)
+
+        @provider.enable_fs
+        expect(fstab_write.string).to eq("/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n" +
+          "/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n" +
+          "/dev/sdz1 /tmp/foo #{@new_resource.fstype} defaults #{@new_resource.dump} #{@new_resource.pass}\n" +
+          "/dev/sdz1 /tmp/foobar  ext3  defaults  1 2\n")
+      end
     end
 
     describe "when disabling the fs" do

data/spec/unit/provider/mount/solaris_spec.rb

@@ -544,7 +544,7 @@ describe Chef::Provider::Mount::Solaris, :unix_only do
 
       it "should mount the filesystem with options if options were passed" do
         options = "logging,noatime,largefiles,nosuid,rw,quota"
-        new_resource.options(options.split(/,/))
+        new_resource.options(options.split(","))
         expect(provider).to receive(:shell_out_compacted!).with("mount", "-F", fstype, "-o", options, device, mountpoint)
         provider.mount_fs
       end

data/spec/unit/provider/mount/windows_spec.rb

@@ -23,6 +23,7 @@ class Chef
     class Windows
       class NetUse
       end
+
       class Volume
       end
     end

data/spec/unit/provider/mount_spec.rb

@@ -151,6 +151,24 @@ describe Chef::Provider::Mount do
       provider.run_action(:enable)
       expect(new_resource).not_to be_updated_by_last_action
     end
+
+    it "should enable the mount if device changed" do
+      allow(current_resource).to receive(:enabled).and_return(true)
+      expect(provider).to receive(:mount_options_unchanged?).and_return(true)
+      expect(provider).to receive(:device_unchanged?).and_return(false)
+      expect(provider).to receive(:enable_fs).and_return(true)
+      provider.run_action(:enable)
+      expect(new_resource).to be_updated_by_last_action
+    end
+
+    it "should not enable the mount if device not changed" do
+      allow(current_resource).to receive(:enabled).and_return(true)
+      expect(provider).to receive(:mount_options_unchanged?).and_return(true)
+      expect(provider).to receive(:device_unchanged?).and_return(true)
+      expect(provider).not_to receive(:enable_fs)
+      provider.run_action(:enable)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
   end
 
   describe "when the target state is to disable the mount" do
@@ -188,4 +206,17 @@ describe Chef::Provider::Mount do
   it "should delegates the disable implementation to subclasses" do
     expect { provider.disable_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
+
+  # Not supported on solaris because it can't cope with a LABEL device type.
+  describe "#device_unchanged?", :not_supported_on_solaris do
+    it "should be true when device_type not changed" do
+      expect(provider.device_unchanged?).to be_truthy
+    end
+
+    it "should be false when device_type changed" do
+      new_resource.device_type :label
+      current_resource.device_type :device
+      expect(provider.device_unchanged?).to be_falsey
+    end
+  end
 end

data/spec/unit/provider/package/chocolatey_spec.rb

@@ -501,8 +501,7 @@ describe "behavior when Chocolatey is not installed" do
 
   before do
     # the shellout sometimes returns "", but test nil to be safe.
-    allow(provider).to receive(:choco_install_path).and_return(nil)
-    provider.instance_variable_set("@choco_install_path", nil)
+    allow(provider).to receive(:choco_install_path).and_return("")
 
     # we don't care what this returns, but we have to let it be called.
     allow(provider).to receive(:shell_out_compacted!).and_return(double(stdout: ""))

data/spec/unit/provider/package/dnf/python_helper_spec.rb

@@ -19,11 +19,17 @@ require "spec_helper"
 
 # NOTE: most of the tests of this functionality are baked into the func tests for the dnf package provider
 
-describe Chef::Provider::Package::Dnf::PythonHelper do
+# run this test only for following platforms.
+exclude_test = !(%w{rhel fedora amazon}.include?(ohai[:platform_family]) && File.exist?("/usr/bin/dnf"))
+describe Chef::Provider::Package::Dnf::PythonHelper, :requires_root, external: exclude_test do
   let(:helper) { Chef::Provider::Package::Dnf::PythonHelper.instance }
 
   it "propagates stacktraces on stderr from the forked subprocess", :rhel do
     allow(helper).to receive(:dnf_command).and_return("ruby -e 'raise \"your hands in the air\"'")
     expect { helper.package_query(:whatprovides, "tcpdump") }.to raise_error(/your hands in the air/)
   end
+
+  it "compares EVRAs with dots in the release correctly" do
+    expect(helper.compare_versions("0:1.8.29-6.el8.x86_64", "0:1.8.29-6.el8_3.1.x86_64")).to eql(-1)
+  end
 end

data/spec/unit/provider/package/freebsd/pkgng_spec.rb

@@ -66,7 +66,7 @@ describe Chef::Provider::Package::Freebsd::Port do
     end
 
     it "should query pkg database" do
-      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "zsh", env: nil, returns: [0, 70], timeout: 900).and_return(@pkg_info)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "zsh", env: nil, returns: [0, 1, 70], timeout: 900).and_return(@pkg_info)
       expect(@provider.current_installed_version).to eq("3.1.7")
     end
   end