chef 12.17.44 → 12.18.31

data/spec/unit/provider/user/pw_spec.rb

@@ -34,7 +34,7 @@ describe Chef::Provider::User::Pw do
 
     # XXX: rip out in Chef-13
     Chef::Config[:treat_deprecation_warnings_as_errors] = false
-    @new_resource.supports :manage_home => true
+    @new_resource.supports manage_home: true
 
     @current_resource = Chef::Resource::User::PwUser.new("adam")
     @current_resource.comment  "Adam Jacob"
@@ -65,35 +65,36 @@ describe Chef::Provider::User::Pw do
 
       it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
         allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(@provider.set_options).to eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}' -m")
+        expect(@provider.set_options).to eql([ @new_resource.username, option, @new_resource.send(attribute), "-m"])
       end
 
       it "should set the option for #{attribute} if the new resources #{attribute} is not null, without homedir management" do
-        allow(@new_resource).to receive(:supports).and_return({ :manage_home => false })
+        allow(@new_resource).to receive(:supports).and_return(manage_home: false)
         allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(@provider.set_options).to eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}'")
+        expect(@provider.set_options).to eql([@new_resource.username, option, @new_resource.send(attribute)])
       end
     end
 
     it "should combine all the possible options" do
-      match_string = " adam"
+      match_array = [ "adam" ]
       field_list.sort { |a, b| a[0] <=> b[0] }.each do |attribute, option|
         allow(@new_resource).to receive(attribute).and_return("hola")
-        match_string << " #{option} 'hola'"
+        match_array << option
+        match_array << "hola"
       end
-      match_string << " -m"
-      expect(@provider.set_options).to eql(match_string)
+      match_array << "-m"
+      expect(@provider.set_options).to eql(match_array)
     end
   end
 
   describe "create_user" do
     before(:each) do
-      allow(@provider).to receive(:run_command).and_return(true)
+      allow(@provider).to receive(:shell_out!).and_return(true)
       allow(@provider).to receive(:modify_password).and_return(true)
     end
 
     it "should run pw useradd with the return of set_options" do
-      expect(@provider).to receive(:run_command).with({ :command => "pw useradd adam -m" }).and_return(true)
+      expect(@provider).to receive(:shell_out!).with("pw", "useradd", "adam", "-m").and_return(true)
       @provider.create_user
     end
 
@@ -105,12 +106,12 @@ describe Chef::Provider::User::Pw do
 
   describe "manage_user" do
     before(:each) do
-      allow(@provider).to receive(:run_command).and_return(true)
+      allow(@provider).to receive(:shell_out!).and_return(true)
       allow(@provider).to receive(:modify_password).and_return(true)
     end
 
     it "should run pw usermod with the return of set_options" do
-      expect(@provider).to receive(:run_command).with({ :command => "pw usermod adam -m" }).and_return(true)
+      expect(@provider).to receive(:shell_out!).with("pw", "usermod", "adam", "-m").and_return(true)
       @provider.manage_user
     end
 
@@ -122,13 +123,13 @@ describe Chef::Provider::User::Pw do
 
   describe "remove_user" do
     it "should run pw userdel with the new resources user name" do
-      @new_resource.supports :manage_home => false
-      expect(@provider).to receive(:run_command).with({ :command => "pw userdel #{@new_resource.username}" }).and_return(true)
+      @new_resource.supports manage_home: false
+      expect(@provider).to receive(:shell_out!).with("pw", "userdel", @new_resource.username).and_return(true)
       @provider.remove_user
     end
 
     it "should run pw userdel with the new resources user name and -r if manage_home is true" do
-      expect(@provider).to receive(:run_command).with({ :command => "pw userdel #{@new_resource.username} -r" }).and_return(true)
+      expect(@provider).to receive(:shell_out!).with("pw", "userdel", @new_resource.username, "-r").and_return(true)
       @provider.remove_user
     end
   end
@@ -147,23 +148,26 @@ describe Chef::Provider::User::Pw do
 
   describe "when locking the user" do
     it "should run pw lock with the new resources username" do
-      expect(@provider).to receive(:run_command).with({ :command => "pw lock #{@new_resource.username}" })
+      expect(@provider).to receive(:shell_out!).with("pw", "lock", @new_resource.username)
       @provider.lock_user
     end
   end
 
   describe "when unlocking the user" do
     it "should run pw unlock with the new resources username" do
-      expect(@provider).to receive(:run_command).with({ :command => "pw unlock #{@new_resource.username}" })
+      expect(@provider).to receive(:shell_out!).with("pw", "unlock", @new_resource.username)
       @provider.unlock_user
     end
   end
 
   describe "when modifying the password" do
     before(:each) do
-      @status = double("Status", :exitstatus => 0)
+      @status = double("Status", exitstatus: 0)
       allow(@provider).to receive(:popen4).and_return(@status)
-      @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
+      @pid = nil
+      @stdin = nil
+      @stdout = nil
+      @stderr = nil
     end
 
     describe "and the new password has not been specified" do
@@ -210,7 +214,7 @@ describe Chef::Provider::User::Pw do
       end
 
       it "should run pw usermod with the username and the option -H 0" do
-        expect(@provider).to receive(:popen4).with("pw usermod adam -H 0", :waitlast => true).and_return(@status)
+        expect(@provider).to receive(:popen4).with("pw usermod adam -H 0", waitlast: true).and_return(@status)
         @provider.modify_password
       end
 
@@ -239,12 +243,12 @@ describe Chef::Provider::User::Pw do
     end
 
     it "should raise an error if the required binary /usr/sbin/pw doesn't exist" do
-      expect(File).to receive(:exists?).with("/usr/sbin/pw").and_return(false)
+      expect(File).to receive(:exist?).with("/usr/sbin/pw").and_return(false)
       expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::User)
     end
 
     it "shouldn't raise an error if /usr/sbin/pw exists" do
-      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:exist?).and_return(true)
       expect { @provider.load_current_resource }.not_to raise_error
     end
   end

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

@@ -127,19 +127,19 @@ describe Chef::Provider::User::Windows do
 
   describe "when creating the user" do
     it "should call @net_user.add with the return of set_options" do
-      allow(@provider).to receive(:set_options).and_return(:name => "monkey")
-      expect(@net_user).to receive(:add).with(:name => "monkey")
+      allow(@provider).to receive(:set_options).and_return(name: "monkey")
+      expect(@net_user).to receive(:add).with(name: "monkey")
       @provider.create_user
     end
   end
 
   describe "manage_user" do
     before(:each) do
-      allow(@provider).to receive(:set_options).and_return(:name => "monkey")
+      allow(@provider).to receive(:set_options).and_return(name: "monkey")
     end
 
     it "should call @net_user.update with the return of set_options" do
-      expect(@net_user).to receive(:update).with(:name => "monkey")
+      expect(@net_user).to receive(:update).with(name: "monkey")
       @provider.manage_user
     end
   end

data/spec/unit/provider/user_spec.rb

@@ -58,7 +58,7 @@ describe Chef::Provider::User do
   describe "executing load_current_resource" do
     before(:each) do
       @node = Chef::Node.new
-      #@new_resource = double("Chef::Resource::User",
+      # @new_resource = double("Chef::Resource::User",
       #  :null_object => true,
       #  :username => "adam",
       #  :comment => "Adam Jacob",
@@ -68,7 +68,7 @@ describe Chef::Provider::User do
       #  :shell => "/usr/bin/zsh",
       #  :password => nil,
       #  :updated => nil
-      #)
+      # )
       allow(Chef::Resource::User).to receive(:new).and_return(@current_resource)
       @pw_user = EtcPwnamIsh.new
       @pw_user.name = "adam"
@@ -110,11 +110,11 @@ describe Chef::Provider::User do
 
     # The mapping between the Chef::Resource::User and Getpwnam struct
     user_attrib_map = {
-      :uid => :uid,
-      :gid => :gid,
-      :comment => :gecos,
-      :home => :dir,
-      :shell => :shell,
+      uid: :uid,
+      gid: :gid,
+      comment: :gecos,
+      home: :dir,
+      shell: :shell,
     }
     user_attrib_map.each do |user_attrib, getpwnam_attrib|
       it "should set the current resources #{user_attrib} based on getpwnam #{getpwnam_attrib}" do
@@ -140,18 +140,16 @@ describe Chef::Provider::User do
 
     describe "and running assertions" do
       def self.shadow_lib_unavail?
-        begin
-          require "rubygems"
-          require "shadow"
-        rescue LoadError
-          skip "ruby-shadow gem not installed for dynamic load test"
-          true
-        else
-          false
-        end
+        require "rubygems"
+        require "shadow"
+      rescue LoadError
+        skip "ruby-shadow gem not installed for dynamic load test"
+        true
+      else
+        false
       end
 
-      before (:each) do
+      before(:each) do
         user = @pw_user.dup
         user.name = "root"
         user.passwd = "x"
@@ -161,15 +159,15 @@ describe Chef::Provider::User do
 
       unless shadow_lib_unavail?
         context "and we have the ruby-shadow gem" do
-          skip "and we are not root (rerun this again as root)", :requires_unprivileged_user => true
+          skip "and we are not root (rerun this again as root)", requires_unprivileged_user: true
 
-          context "and we are root", :requires_root => true do
+          context "and we are root", requires_root: true do
             it "should pass assertions when ruby-shadow can be loaded" do
               @provider.action = "create"
               original_method = @provider.method(:require)
               expect(@provider).to receive(:require) { |*args| original_method.call(*args) }
-              passwd_info = Struct::PasswdEntry.new(:sp_namp => "adm ", :sp_pwdp => "$1$T0N0Q.lc$nyG6pFI3Dpqa5cxUz/57j0", :sp_lstchg => 14861, :sp_min => 0, :sp_max => 99999,
-                                                    :sp_warn => 7, :sp_inact => -1, :sp_expire => -1, :sp_flag => -1)
+              passwd_info = Struct::PasswdEntry.new(sp_namp: "adm ", sp_pwdp: "$1$T0N0Q.lc$nyG6pFI3Dpqa5cxUz/57j0", sp_lstchg: 14861, sp_min: 0, sp_max: 99999,
+                                                    sp_warn: 7, sp_inact: -1, sp_expire: -1, sp_flag: -1)
               expect(Shadow::Passwd).to receive(:getspnam).with("adam").and_return(passwd_info)
               @provider.load_current_resource
               @provider.define_resource_requirements

data/spec/unit/provider_resolver_spec.rb

@@ -135,6 +135,7 @@ describe Chef::ProviderResolver do
             end
           else
             it "'#{name}' fails to resolve (since #{name.inspect} is unsupported on #{platform} #{platform_version})", *tags do
+              Chef::Config[:treat_deprecation_warnings_as_errors] = false
               expect(resolved_provider).to be_nil
             end
           end

data/spec/unit/resource/chocolatey_package_spec.rb

@@ -64,4 +64,16 @@ describe Chef::Resource::ChocolateyPackage do
     resource.version(["1.2.3", "4.5.6"])
     expect(resource.version).to eql(["1.2.3", "4.5.6"])
   end
+
+  it "the default returns should be 0" do
+    expect(resource.returns).to eql([0])
+  end
+
+  # Integer, Array
+  [ 0, [0, 48, 49] ].each do |val|
+    it "supports setting an alternate return value as a #{val.class}" do
+      resource.returns(val)
+      expect(resource.returns).to eql(val)
+    end
+  end
 end

data/spec/unit/resource/dnf_package_spec.rb

@@ -0,0 +1,99 @@
+#
+# Copyright:: Copyright 2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "support/shared/unit/resource/static_provider_resolution"
+
+describe Chef::Resource::DnfPackage, "initialize" do
+
+  static_provider_resolution(
+    resource: Chef::Resource::DnfPackage,
+    provider: Chef::Provider::Package::Dnf,
+    name: :dnf_package,
+    action: :install,
+    os: "linux",
+    platform_family: "rhel"
+  )
+
+end
+
+describe Chef::Resource::DnfPackage, "arch" do
+  before(:each) do
+    @resource = Chef::Resource::DnfPackage.new("foo")
+  end
+
+  it "should set the arch variable to whatever is passed in" do
+    @resource.arch("i386")
+    expect(@resource.arch).to eql(["i386"])
+  end
+end
+
+describe Chef::Resource::DnfPackage, "flush_cache" do
+  before(:each) do
+    @resource = Chef::Resource::DnfPackage.new("foo")
+  end
+
+  it "should default 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
+    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
+    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
+    @resource.flush_cache(true)
+    expect(@resource.flush_cache).to eq({ before: true, after: true })
+  end
+
+  it "should allow '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
+    @resource.flush_cache(:before)
+    expect(@resource.flush_cache).to eq({ before: true, after: false })
+  end
+
+  it "should allow ':after' for flush_cache" do
+    @resource.flush_cache(:after)
+    expect(@resource.flush_cache).to eq({ before: false, after: true })
+  end
+end
+
+describe Chef::Resource::DnfPackage, "allow_downgrade" do
+  before(:each) do
+    @resource = Chef::Resource::DnfPackage.new("foo")
+  end
+
+  it "should allow 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
+  end
+end

data/spec/unit/resource/remote_file_spec.rb

@@ -36,13 +36,13 @@ describe Chef::Resource::RemoteFile do
   it "says its provider is RemoteFile when the source is an absolute URI" do
     @resource.source("http://www.google.com/robots.txt")
     expect(@resource.provider).to eq(Chef::Provider::RemoteFile)
-    expect(Chef::Platform.find_provider(:noplatform, "noversion", @resource)).to eq(Chef::Provider::RemoteFile)
+    expect(@resource.provider_for_action(:create)).to be_kind_of(Chef::Provider::RemoteFile)
   end
 
   it "says its provider is RemoteFile when the source is a network share" do
     @resource.source("\\\\fakey\\fakerton\\fake.txt")
     expect(@resource.provider).to eq(Chef::Provider::RemoteFile)
-    expect(Chef::Platform.find_provider(:noplatform, "noversion", @resource)).to eq(Chef::Provider::RemoteFile)
+    expect(@resource.provider_for_action(:create)).to be_kind_of(Chef::Provider::RemoteFile)
   end
 
   describe "source" do

data/spec/unit/resource/yum_package_spec.rb

@@ -65,6 +65,26 @@ describe Chef::Resource::YumPackage, "flush_cache" do
     @resource.flush_cache(flush_hash)
     expect(@resource.flush_cache).to eq(flush_hash)
   end
+
+  it "should allow '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
+    @resource.flush_cache(false)
+    expect(@resource.flush_cache).to eq({ before: false, after: false })
+  end
+
+  it "should allow ':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
+    @resource.flush_cache(:after)
+    expect(@resource.flush_cache).to eq({ before: false, after: true })
+  end
 end
 
 describe Chef::Resource::YumPackage, "allow_downgrade" do

data/spec/unit/resource_reporter_spec.rb

@@ -265,6 +265,30 @@ describe Chef::ResourceReporter do
       @resource_reporter.run_started(@run_status)
     end
 
+    context "when the new_resource is sensitive" do
+      before do
+        @execute_resource = Chef::Resource::Execute.new("sensitive-resource")
+        @execute_resource.name("sensitive-resource")
+        @execute_resource.command('echo "password: SECRET"')
+        @execute_resource.sensitive(true)
+        @resource_reporter.resource_action_start(@execute_resource, :run)
+        @resource_reporter.resource_current_state_loaded(@execute_resource, :run, @current_resource)
+        @resource_reporter.resource_updated(@execute_resource, :run)
+        @resource_reporter.resource_completed(@execute_resource)
+        @run_status.stop_clock
+        @report = @resource_reporter.prepare_run_data
+        @first_update_report = @report["resources"].first
+      end
+
+      it "resource_name in prepared_run_data should be the same" do
+        expect(@first_update_report["name"]).to eq("sensitive-resource")
+      end
+
+      it "resource_command in prepared_run_data should be blank" do
+        expect(@first_update_report["after"]).to eq({ :command => "sensitive-resource" })
+      end
+    end
+
     context "when the new_resource does not have a string for name and identity" do
       context "the new_resource name and id are nil" do
         before do

data/spec/unit/resource_spec.rb

@@ -838,6 +838,8 @@ describe Chef::Resource do
     it "should run only_if/not_if conditionals when notified to run another action (CHEF-972)" do
       snitch_var1 = snitch_var2 = 0
       runner = Chef::Runner.new(run_context)
+
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       Chef::Platform.set(
         :resource => :cat,
         :provider => Chef::Provider::SnakeOil