chef 12.18.31 → 13.0.118

data/spec/unit/provider/apt_repository_spec.rb

@@ -18,32 +18,30 @@
 
 require "spec_helper"
 
+# Now we are using the option --with-colons that works across old os versions
+# as well as the latest (16.10). This for both `apt-key` and `gpg` commands
+#
+# Output of the command:
+# => apt-key adv --list-public-keys --with-fingerprint --with-colons
 APT_KEY_FINGER = <<-EOF
-/etc/apt/trusted.gpg
---------------------
-pub   1024D/437D05B5 2004-09-12
-      Key fingerprint = 6302 39CC 130E 1A7F D81A  27B1 4097 6EAF 437D 05B5
-uid                  Ubuntu Archive Automatic Signing Key <ftpmaster@ubuntu.com>
-sub   2048g/79164387 2004-09-12
-
-pub   1024D/FBB75451 2004-12-30
-      Key fingerprint = C598 6B4F 1257 FFA8 6632  CBA7 4618 1433 FBB7 5451
-uid                  Ubuntu CD Image Automatic Signing Key <cdimage@ubuntu.com>
-
-pub   4096R/C0B21F32 2012-05-11
-      Key fingerprint = 790B C727 7767 219C 42C8  6F93 3B4F E6AC C0B2 1F32
-uid                  Ubuntu Archive Automatic Signing Key (2012) <ftpmaster@ubuntu.com>
-
-pub   4096R/EFE21092 2012-05-11
-      Key fingerprint = 8439 38DF 228D 22F7 B374  2BC0 D94A A3F0 EFE2 1092
-uid                  Ubuntu CD Image Automatic Signing Key (2012) <cdimage@ubuntu.com>
-
+tru:t:1:1488924856:0:3:1:5
+pub:-:1024:17:40976EAF437D05B5:2004-09-12:::-:Ubuntu Archive Automatic Signing Key <ftpmaster@ubuntu.com>::scESC:
+fpr:::::::::630239CC130E1A7FD81A27B140976EAF437D05B5:
+sub:-:2048:16:251BEFF479164387:2004-09-12::::::e:
+pub:-:1024:17:46181433FBB75451:2004-12-30:::-:Ubuntu CD Image Automatic Signing Key <cdimage@ubuntu.com>::scSC:
+fpr:::::::::C5986B4F1257FFA86632CBA746181433FBB75451:
+pub:-:4096:1:3B4FE6ACC0B21F32:2012-05-11:::-:Ubuntu Archive Automatic Signing Key (2012) <ftpmaster@ubuntu.com>::scSC:
+fpr:::::::::790BC7277767219C42C86F933B4FE6ACC0B21F32:
+pub:-:4096:1:D94AA3F0EFE21092:2012-05-11:::-:Ubuntu CD Image Automatic Signing Key (2012) <cdimage@ubuntu.com>::scSC:
+fpr:::::::::843938DF228D22F7B3742BC0D94AA3F0EFE21092:
 EOF
 
+# Output of the command:
+# => gpg --with-fingerprint --with-colons [FILE]
 GPG_FINGER = <<-EOF
-pub  1024D/02A818DD 2009-04-22 Cloudera Apt Repository
-      Key fingerprint = F36A 89E3 3CC1 BD0F 7107  9007 3275 74EE 02A8 18DD
-sub  2048g/D1CA74A1 2009-04-22
+pub:-:1024:17:327574EE02A818DD:2009-04-22:::-:Cloudera Apt Repository:
+fpr:::::::::F36A89E33CC1BD0F71079007327574EE02A818DD:
+sub:-:2048:16:84080586D1CA74A1:2009-04-22::::
 EOF
 
 describe Chef::Provider::AptRepository do
@@ -57,6 +55,10 @@ describe Chef::Provider::AptRepository do
     Chef::Provider::AptRepository.new(new_resource, run_context)
   end
 
+  let(:apt_key_finger_cmd) do
+    "apt-key adv --list-public-keys --with-fingerprint --with-colons"
+  end
+
   let(:apt_key_finger) do
     r = double("Mixlib::ShellOut", stdout: APT_KEY_FINGER, exitstatus: 0, live_stream: true)
     allow(r).to receive(:run_command)
@@ -102,28 +104,32 @@ C5986B4F1257FFA86632CBA746181433FBB75451
 
     it "should run the desired command" do
       expect(apt_key_finger).to receive(:run_command)
-      provider.extract_fingerprints_from_cmd("apt-key finger")
+      provider.extract_fingerprints_from_cmd(apt_key_finger_cmd)
     end
 
     it "should return a list of key fingerprints" do
-      expect(provider.extract_fingerprints_from_cmd("apt-key finger")).to eql(apt_fingerprints)
+      expect(provider.extract_fingerprints_from_cmd(apt_key_finger_cmd)).to eql(apt_fingerprints)
     end
   end
 
   describe "#no_new_keys?" do
     before do
-      allow(provider).to receive(:extract_fingerprints_from_cmd).with("apt-key finger").and_return(apt_fingerprints)
+      allow(provider).to receive(:extract_fingerprints_from_cmd).with(apt_key_finger_cmd).and_return(apt_fingerprints)
     end
 
     let(:file) { "/tmp/remote-gpg-keyfile" }
 
     it "should match a set of keys" do
-      allow(provider).to receive(:extract_fingerprints_from_cmd).with("gpg --with-fingerprint #{file}").and_return(Array(apt_fingerprints.first))
+      allow(provider).to receive(:extract_fingerprints_from_cmd)
+        .with("gpg --with-fingerprint --with-colons #{file}")
+        .and_return(Array(apt_fingerprints.first))
       expect(provider.no_new_keys?(file)).to be_truthy
     end
 
     it "should notice missing keys" do
-      allow(provider).to receive(:extract_fingerprints_from_cmd).with("gpg --with-fingerprint #{file}").and_return(%w{ F36A89E33CC1BD0F71079007327574EE02A818DD })
+      allow(provider).to receive(:extract_fingerprints_from_cmd)
+        .with("gpg --with-fingerprint --with-colons #{file}")
+        .and_return(%w{ F36A89E33CC1BD0F71079007327574EE02A818DD })
       expect(provider.no_new_keys?(file)).to be_falsey
     end
   end

data/spec/unit/provider/cron_spec.rb

@@ -880,8 +880,7 @@ MAILTO=foo@example.com
 
   describe "read_crontab" do
     before :each do
-      @status = double("Status", :exitstatus => 0)
-      @stdout = StringIO.new(<<-CRONTAB)
+      @stdout = <<-CRONTAB
 0 2 * * * /some/other/command
 
 # Chef Name: something else
@@ -889,11 +888,12 @@ MAILTO=foo@example.com
 
 # Another comment
       CRONTAB
-      allow(@provider).to receive(:popen4).and_yield(1234, StringIO.new, @stdout, StringIO.new).and_return(@status)
+      @status = double("Status", exitstatus: 0, stdout: @stdout)
+      allow(@provider).to receive(:shell_out!).and_return(@status)
     end
 
     it "should call crontab -l with the user" do
-      expect(@provider).to receive(:popen4).with("crontab -l -u #{@new_resource.user}").and_return(@status)
+      expect(@provider).to receive(:shell_out!).with("crontab -l -u #{@new_resource.user}", returns: [0, 1]).and_return(@status)
       @provider.send(:read_crontab)
     end
 
@@ -910,60 +910,36 @@ MAILTO=foo@example.com
     end
 
     it "should return nil if the user has no crontab" do
-      status = double("Status", :exitstatus => 1)
-      allow(@provider).to receive(:popen4).and_return(status)
+      @status = double("Status", exitstatus: 1, stdout: "")
+      allow(@provider).to receive(:shell_out!).and_return(@status)
       expect(@provider.send(:read_crontab)).to eq(nil)
     end
 
     it "should raise an exception if another error occurs" do
-      status = double("Status", :exitstatus => 2)
-      allow(@provider).to receive(:popen4).and_return(status)
-      expect do
-        @provider.send(:read_crontab)
-      end.to raise_error(Chef::Exceptions::Cron, "Error determining state of #{@new_resource.name}, exit: 2")
+      @status = double("Status", exitstatus: 2)
+      allow(@provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect { @provider.send(:read_crontab) }.to raise_error(Chef::Exceptions::Cron)
     end
   end
 
   describe "write_crontab" do
     before :each do
-      @status = double("Status", :exitstatus => 0)
-      @stdin = StringIO.new
-      allow(@provider).to receive(:popen4).and_yield(1234, @stdin, StringIO.new, StringIO.new).and_return(@status)
+      @status = double("Status", exitstatus: 0)
+      allow(@provider).to receive(:shell_out!).and_return(@status)
     end
 
     it "should call crontab for the user" do
-      expect(@provider).to receive(:popen4).with("crontab -u #{@new_resource.user} -", :waitlast => true).and_return(@status)
+      expect(@provider).to receive(:shell_out!).with("crontab -u #{@new_resource.user} -", input: "Foo").and_return(@status)
       @provider.send(:write_crontab, "Foo")
     end
 
-    it "should write the given string to the crontab command" do
-      @provider.send(:write_crontab, "Foo\n# wibble\n wah!!")
-      expect(@stdin.string).to eq("Foo\n# wibble\n wah!!")
-    end
-
     it "should raise an exception if the command returns non-zero" do
-      allow(@status).to receive(:exitstatus).and_return(1)
-      expect do
-        @provider.send(:write_crontab, "Foo")
-      end.to raise_error(Chef::Exceptions::Cron, "Error updating state of #{@new_resource.name}, exit: 1")
-    end
-
-    it "should raise an exception if the command die's and parent tries to write" do
-      class WriteErrPipe
-        def write(str)
-          raise Errno::EPIPE, "Test"
-        end
-      end
-      allow(@status).to receive(:exitstatus).and_return(1)
-      allow(@provider).to receive(:popen4).and_yield(1234, WriteErrPipe.new, StringIO.new, StringIO.new).and_return(@status)
-
-      expect(Chef::Log).to receive(:debug).with("Broken pipe - Test")
-
+      @status = double("Status", exitstatus: 1)
+      allow(@provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
       expect do
         @provider.send(:write_crontab, "Foo")
-      end.to raise_error(Chef::Exceptions::Cron, "Error updating state of #{@new_resource.name}, exit: 1")
+      end.to raise_error(Chef::Exceptions::Cron)
     end
-
   end
 
   describe "weekday_in_crontab" do

data/spec/unit/provider/deploy_spec.rb

@@ -595,7 +595,7 @@ describe Chef::Provider::Deploy do
 
       callback_code = Proc.new do
         snitch = 42
-        temp_collection = self.resource_collection
+        temp_collection = resource_collection
         run("tehMice")
         snitch = temp_collection.lookup("execute[tehMice]")
       end

data/spec/unit/provider/directory_spec.rb

@@ -148,6 +148,16 @@ describe Chef::Provider::Directory do
         directory.run_action(:create)
         expect(new_resource).not_to be_updated
       end
+
+      context "in why run mode" do
+        before { Chef::Config[:why_run] = true }
+        after { Chef::Config[:why_run] = false }
+
+        it "does not modify new_resource" do
+          expect(directory).not_to receive(:load_resource_attributes_from_file).with(new_resource)
+          directory.run_action(:create)
+        end
+      end
     end
 
     describe "when the directory does not exist" do

data/spec/unit/provider/dsc_resource_spec.rb

@@ -165,4 +165,179 @@ describe Chef::Provider::DscResource do
       end
     end
   end
+
+  describe "define_resource_requirements" do
+    let (:node) do
+      set_node_object
+    end
+
+    context "module usage is valid" do
+      before do
+        allow(provider).to receive(:module_usage_valid?).and_return(true)
+        allow(provider).to receive(:action_run)
+      end
+
+      [:run].each do |action|
+        context "action #{action}" do
+          it "does not raise the exception" do
+            expect { provider.run_action(action) }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    context "module usage is invalid" do
+      before do
+        allow(provider).to receive(:module_usage_valid?).and_return(false)
+        allow(provider).to receive(:action_run)
+      end
+
+      [:run].each do |action|
+        context "action #{action}" do
+          it "raises the exception" do
+            expect { provider.run_action(action) }.to raise_error(
+              Chef::Exceptions::DSCModuleNameMissing
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe "module_usage_valid?" do
+    let (:node) do
+      set_node_object
+    end
+
+    context "module_name and module_version both are not provided" do
+      before do
+        provider.instance_variable_set(:@module_name, nil)
+        provider.instance_variable_set(:@module_version, nil)
+      end
+
+      it "returns true" do
+        response = provider.send(:module_usage_valid?)
+        expect(response).to be == true
+      end
+    end
+
+    context "module_name and module_version both are provided" do
+      before do
+        provider.instance_variable_set(:@module_name, "my_module")
+        provider.instance_variable_set(:@module_version, "1.3")
+      end
+
+      it "returns true" do
+        response = provider.send(:module_usage_valid?)
+        expect(response).to be == true
+      end
+    end
+
+    context "module_name is given but module_version is not given" do
+      before do
+        provider.instance_variable_set(:@module_name, "my_module")
+        provider.instance_variable_set(:@module_version, nil)
+      end
+
+      it "returns true" do
+        response = provider.send(:module_usage_valid?)
+        expect(response).to be == true
+      end
+    end
+
+    context "module_name is not given but module_version is given" do
+      before do
+        provider.instance_variable_set(:@module_name, nil)
+        provider.instance_variable_set(:@module_version, "1.4.0.1")
+      end
+
+      it "returns false" do
+        response = provider.send(:module_usage_valid?)
+        expect(response).to be == false
+      end
+    end
+  end
+
+  describe "module_info_object" do
+    let (:node) do
+      set_node_object
+    end
+
+    context "module_version is not given" do
+      before do
+        provider.instance_variable_set(:@module_version, nil)
+        allow(provider).to receive(:module_name).and_return("my_module")
+      end
+
+      it "returns only name of the module" do
+        response = provider.send(:module_info_object)
+        expect(response).to be == "my_module"
+      end
+    end
+
+    context "module_version is given" do
+      before do
+        provider.instance_variable_set(:@module_version, "1.3.1")
+        allow(provider).to receive(:module_name).and_return("my_module")
+      end
+
+      it "returns the module info object" do
+        response = provider.send(:module_info_object)
+        expect(response).to be == "@{ModuleName='my_module';ModuleVersion='1.3.1'}"
+      end
+    end
+  end
+
+  describe "invoke_resource" do
+    let (:node) do
+      set_node_object
+    end
+
+    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(
+        :properties => "my_properties", :resource => "my_resource", :timeout => 123
+      ))
+    end
+
+    context "when module_version is not given" do
+      before do
+        allow(provider).to receive(:module_info_object).and_return("my_module")
+      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")
+      end
+    end
+
+    context "when module_version is given" do
+      before do
+        allow(provider).to receive(:module_info_object).and_return(
+          "@{ModuleName='my_module';ModuleVersion='my_module_version'}"
+        )
+      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")
+      end
+    end
+  end
+end
+
+def set_node_object
+  node = Chef::Node.new
+  node.automatic[:languages][:powershell][:version] = "5.0.10586.0"
+  node
 end

data/spec/unit/provider/erl_call_spec.rb

@@ -31,11 +31,8 @@ describe Chef::Provider::ErlCall do
 
     @provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
 
-    allow(@provider).to receive(:popen4).and_return(@status)
-    @stdin = StringIO.new
-    @stdout = StringIO.new("{ok, woohoo}")
-    @stderr = StringIO.new
-    @pid = 2342999
+    @status = double("Status", stdout: "{ok, woohoo}", stderr: "")
+    allow(@provider).to receive(:shell_out!).and_return(@status)
   end
 
   it "should return a Chef::Provider::ErlCall object" do
@@ -56,12 +53,9 @@ describe Chef::Provider::ErlCall do
 
     it "should write to stdin of the erl_call command" do
       expected_cmd = "erl_call -e -s -sname chef@localhost -c nomnomnom"
-      expect(@provider).to receive(:popen4).with(expected_cmd, :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
-      expect(Process).to receive(:wait).with(@pid)
+      expect(@provider).to receive(:shell_out!).with(expected_cmd, input: @new_resource.code).and_return(@status)
 
       @provider.action_run
-
-      expect(@stdin.string).to eq("#{@new_resource.code}\n")
     end
   end
 
@@ -73,12 +67,10 @@ describe Chef::Provider::ErlCall do
     end
 
     it "should write to stdin of the erl_call command" do
-      expect(@provider).to receive(:popen4).with("erl_call -e  -name chef@localhost ", :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
-      expect(Process).to receive(:wait).with(@pid)
+      expected_cmd = "erl_call -e  -name chef@localhost "
+      expect(@provider).to receive(:shell_out!).with(expected_cmd, input: @new_resource.code).and_return(@status)
 
       @provider.action_run
-
-      expect(@stdin.string).to eq("#{@new_resource.code}\n")
     end
   end
 

data/spec/unit/provider/execute_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -118,19 +118,9 @@ describe Chef::Provider::Execute do
         new_resource.creates "foo_resource"
       end
 
-      it "should warn in Chef-12", chef: "< 13" do
-        expect(Chef::Log).to receive(:warn).with(/relative path/)
-        expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
+      it "should raise if user specified relative path without cwd for Chef-13" do
         expect(provider).not_to receive(:shell_out!)
-        provider.run_action(:run)
-        expect(new_resource).not_to be_updated
-      end
-
-      it "should raise if user specified relative path without cwd for Chef-13", chef: ">= 13" do
-        expect(Chef::Log).to receive(:warn).with(/relative path/)
-        expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
-        expect(provider).not_to receive(:shell_out!)
-        expect { provider.run_action(:run) }.to raise_error # @todo: add a real error for Chef-13
+        expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::Execute)
       end
     end
 
@@ -238,6 +228,5 @@ describe Chef::Provider::Execute do
 
       end
     end
-
   end
 end

data/spec/unit/provider/launchd_spec.rb

@@ -185,8 +185,8 @@ XML
       end
 
       describe "hash is passed" do
-        it "should produce the test_plist from the hash" do
-          new_resource.hash test_hash
+        it "should produce the test_plist content from the plist_hash property" do
+          new_resource.plist_hash test_hash
           expect(provider.content?).to be_truthy
           expect(provider.content).to eql(test_plist)
         end

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

@@ -28,7 +28,7 @@ describe Chef::Provider::Package::Aix do
     @new_resource.source("/tmp/samba.base")
 
     @provider = Chef::Provider::Package::Aix.new(@new_resource, @run_context)
-    allow(::File).to receive(:exists?).and_return(true)
+    allow(::File).to receive(:exist?).with(@new_resource.source).and_return(true)
   end
 
   describe "assessing the current package status" do
@@ -41,23 +41,23 @@ describe Chef::Provider::Package::Aix do
 
     it "should create a current resource with the name of new_resource" do
       status = double("Status", :stdout => @bffinfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(@empty_status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(@empty_status)
       @provider.load_current_resource
       expect(@provider.current_resource.name).to eq("samba.base")
     end
 
     it "should set the current resource bff package name to the new resource bff package name" do
       status = double("Status", :stdout => @bffinfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(@empty_status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(@empty_status)
       @provider.load_current_resource
       expect(@provider.current_resource.package_name).to eq("samba.base")
     end
 
     it "should raise an exception if a source is supplied but not found" do
       allow(@provider).to receive(:shell_out).and_return(@empty_status)
-      allow(::File).to receive(:exists?).and_return(false)
+      allow(::File).to receive(:exist?).with(@new_resource.source).and_return(false)
       @provider.load_current_resource
       @provider.define_resource_requirements
       expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Package)
@@ -65,8 +65,8 @@ describe Chef::Provider::Package::Aix do
 
     it "should get the source package version from lslpp if provided" do
       status = double("Status", :stdout => @bffinfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(@empty_status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(@empty_status)
       @provider.load_current_resource
 
       expect(@provider.current_resource.package_name).to eq("samba.base")
@@ -77,8 +77,8 @@ describe Chef::Provider::Package::Aix do
       info = "samba.base:samba.base.samples:3.3.12.0::COMMITTED:I:Samba for AIX:
   /etc/objrepos:samba.base:3.3.12.0::COMMITTED:I:Samba for AIX:"
       status = double("Status", :stdout => info, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(@empty_status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(@empty_status)
       expect(Chef::Log).to receive(:warn).once.with(%r{bff package by product name})
       @provider.load_current_resource
 
@@ -90,8 +90,8 @@ describe Chef::Provider::Package::Aix do
       status = double("Status", :stdout => @bffinfo, :exitstatus => 0)
       @stdout = StringIO.new(@bffinfo)
       @stdin, @stderr = StringIO.new, StringIO.new
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(status)
       @provider.load_current_resource
       expect(@provider.current_resource.version).to eq("3.3.12.0")
     end
@@ -112,8 +112,8 @@ describe Chef::Provider::Package::Aix do
 
     it "should return a current resource with a nil version if the package is not found" do
       status = double("Status", :stdout => @bffinfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
-      expect(@provider).to receive(:shell_out).with("lslpp -lcq samba.base", timeout: 900).and_return(@empty_status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("lslpp", "-lcq", "samba.base", timeout: 900).and_return(@empty_status)
       @provider.load_current_resource
       expect(@provider.current_resource.version).to be_nil
     end
@@ -122,7 +122,7 @@ describe Chef::Provider::Package::Aix do
       wrongbffinfo = "/usr/lib/objrepos:openssl.base:0.9.8.2400::COMMITTED:I:Open Secure Socket Layer:
 /etc/objrepos:openssl.base:0.9.8.2400::COMMITTED:I:Open Secure Socket Layer:"
       status = double("Status", :stdout => wrongbffinfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("installp -L -d /tmp/samba.base", timeout: 900).and_return(status)
+      expect(@provider).to receive(:shell_out).with("installp", "-L", "-d", "/tmp/samba.base", timeout: 900).and_return(status)
       expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
   end
@@ -130,7 +130,7 @@ describe Chef::Provider::Package::Aix do
   describe "candidate_version" do
     it "should return the candidate_version variable if already setup" do
       @provider.candidate_version = "3.3.12.0"
-      expect(@provider).not_to receive(:shell_out )
+      expect(@provider).not_to receive(:shell_out)
       @provider.candidate_version
     end
 
@@ -150,34 +150,34 @@ describe Chef::Provider::Package::Aix do
 
   describe "install and upgrade" do
     it "should run installp -aYF -d with the package source to install" do
-      expect(@provider).to receive(:shell_out!).with("installp -aYF -d /tmp/samba.base samba.base", timeout: 900)
+      expect(@provider).to receive(:shell_out!).with("installp", "-aYF", "-d", "/tmp/samba.base", "samba.base", timeout: 900)
       @provider.install_package("samba.base", "3.3.12.0")
     end
 
-    it "should run  when the package is a path to install" do
+    it "should run installp -aYF -d when the package is a path to install" do
       @new_resource = Chef::Resource::Package.new("/tmp/samba.base")
       @provider = Chef::Provider::Package::Aix.new(@new_resource, @run_context)
       expect(@new_resource.source).to eq("/tmp/samba.base")
-      expect(@provider).to receive(:shell_out!).with("installp -aYF -d /tmp/samba.base /tmp/samba.base", timeout: 900)
+      expect(@provider).to receive(:shell_out!).with("installp", "-aYF", "-d", "/tmp/samba.base", "/tmp/samba.base", timeout: 900)
       @provider.install_package("/tmp/samba.base", "3.3.12.0")
     end
 
     it "should run installp with -eLogfile option." do
       allow(@new_resource).to receive(:options).and_return("-e/tmp/installp.log")
-      expect(@provider).to receive(:shell_out!).with("installp -aYF  -e/tmp/installp.log -d /tmp/samba.base samba.base", timeout: 900)
+      expect(@provider).to receive(:shell_out!).with("installp", "-aYF", "-e/tmp/installp.log", "-d", "/tmp/samba.base", "samba.base", timeout: 900)
       @provider.install_package("samba.base", "3.3.12.0")
     end
   end
 
   describe "remove" do
     it "should run installp -u samba.base to remove the package" do
-      expect(@provider).to receive(:shell_out!).with("installp -u samba.base", timeout: 900)
+      expect(@provider).to receive(:shell_out!).with("installp", "-u", "samba.base", timeout: 900)
       @provider.remove_package("samba.base", "3.3.12.0")
     end
 
     it "should run installp -u -e/tmp/installp.log  with options -e/tmp/installp.log" do
       allow(@new_resource).to receive(:options).and_return("-e/tmp/installp.log")
-      expect(@provider).to receive(:shell_out!).with("installp -u  -e/tmp/installp.log samba.base", timeout: 900)
+      expect(@provider).to receive(:shell_out!).with("installp", "-u", "-e/tmp/installp.log", "samba.base", timeout: 900)
       @provider.remove_package("samba.base", "3.3.12.0")
     end