chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

data/spec/support/shared/functional/securable_resource.rb

@@ -81,7 +81,7 @@ shared_context "use Windows permissions", :windows_only do
     SID ||= Chef::ReservedNames::Win32::Security::SID
     ACE ||= Chef::ReservedNames::Win32::Security::ACE
     ACL ||= Chef::ReservedNames::Win32::Security::ACL
-    SecurableObject ||= Chef::ReservedNames::Win32::Security::SecurableObject
+    SecurableObject ||= Chef::ReservedNames::Win32::Security::SecurableObject # rubocop:disable Style/ConstantName
   end
 
   def get_security_descriptor(path)
@@ -138,9 +138,9 @@ shared_context "use Windows permissions", :windows_only do
 
   RSpec::Matchers.define :have_expected_properties do |mask, type, flags|
     match do |ace|
-      ace.mask == mask
-      ace.type == type
-      ace.flags == flags
+      ace.mask == mask &&
+        ace.type == type &&
+        ace.flags == flags
     end
   end
 
@@ -439,7 +439,7 @@ shared_examples_for "a securable resource without existing target" do
 
     context "with a mode attribute" do
       if windows?
-        Security ||= Chef::ReservedNames::Win32::API::Security
+        Security ||= Chef::ReservedNames::Win32::API::Security # rubocop:disable Style/ConstantName
       end
 
       it "respects mode in string form as an octal number" do

data/spec/support/shared/functional/win32_service.rb

@@ -23,9 +23,7 @@ shared_context "using Win32::Service" do
       # We can only uninstall when the service is stopped.
       if test_service_state != "stopped"
         ::Win32::Service.send("stop", "spec-service")
-        while test_service_state != "stopped"
-          sleep 1
-        end
+        sleep 1 while test_service_state != "stopped"
       end
 
       ::Win32::Service.delete("spec-service")
@@ -39,7 +37,7 @@ shared_context "using Win32::Service" do
 
   # Definition for the test-service
 
-  let(:test_service) {
+  let(:test_service) do
     {
       :service_name => "spec-service",
       :service_display_name => "Spec Test Service",
@@ -47,13 +45,13 @@ shared_context "using Win32::Service" do
       :service_file_path => File.expand_path(File.join(File.dirname(__FILE__), "../../platforms/win32/spec_service.rb")),
       :delayed_start => true,
     }
-  }
+  end
 
   # Test service creates a file for us to verify that it is running.
   # Since our test service is running as Local System we should look
   # for the file it creates under SYSTEM temp directory
 
-  let(:test_service_file) {
+  let(:test_service_file) do
     "#{ENV['SystemDrive']}\\windows\\temp\\spec_service_file"
-  }
+  end
 end

data/spec/support/shared/integration/app_server_support.rb

@@ -33,9 +33,7 @@ module AppServerSupport
       end
     end
     Timeout.timeout(30) do
-      until server && server.status == :Running
-        sleep(0.01)
-      end
+      sleep(0.01) until server && server.status == :Running
     end
     [server, thread]
   end

data/spec/support/shared/integration/knife_support.rb

@@ -111,8 +111,6 @@ module KnifeSupport
     end
   end
 
-  private
-
   class KnifeResult
 
     include ::RSpec::Matchers

data/spec/support/shared/shared_examples.rb

@@ -3,9 +3,9 @@
 # Any object which defines a .to_json should import this test
 shared_examples "to_json equivalent to Chef::JSONCompat.to_json" do
 
-  let(:jsonable) {
+  let(:jsonable) do
     raise "You must define the subject when including this test"
-  }
+  end
 
   it "should allow consumers to call #to_json or Chef::JSONCompat.to_json" do
     expect(jsonable.to_json).to eq(Chef::JSONCompat.to_json(jsonable))

data/spec/support/shared/unit/api_versioning.rb

@@ -43,13 +43,13 @@ shared_examples_for "user and client reregister" do
   let(:generic_exception) { Exception.new }
   let(:min_version) { "2" }
   let(:max_version) { "5" }
-  let(:return_hash_406) {
+  let(:return_hash_406) do
     {
       "min_version" => min_version,
       "max_version" => max_version,
       "request_version" => "30",
     }
-  }
+  end
 
   context "when V0 is not supported by the server" do
     context "when the exception is 406 and returns x-ops-server-api-version header" do

data/spec/support/shared/unit/application_dot_d.rb

@@ -31,8 +31,9 @@ shared_examples_for "an application that loads a dot d" do
   context "when client_d_dir is set to a directory with configuration" do
     # We're not going to mock out globbing the directory. We want to
     # make sure that we are correctly globbing.
-    let(:client_d_dir) { Chef::Util::PathHelper.cleanpath(
-      File.join(File.dirname(__FILE__), "../../../data/client.d_00")) }
+    let(:client_d_dir) do
+      Chef::Util::PathHelper.cleanpath(
+      File.join(File.dirname(__FILE__), "../../../data/client.d_00")) end
 
     it "loads the configuration in order" do
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_return("foo 0")
@@ -45,8 +46,9 @@ shared_examples_for "an application that loads a dot d" do
   end
 
   context "when client_d_dir is set to a directory without configuration" do
-    let(:client_d_dir) { Chef::Util::PathHelper.cleanpath(
-      File.join(File.dirname(__FILE__), "../../data/client.d_01")) }
+    let(:client_d_dir) do
+      Chef::Util::PathHelper.cleanpath(
+      File.join(File.dirname(__FILE__), "../../data/client.d_01")) end
 
     # client.d_01 has a nested folder with a rb file that if
     # executed, would raise an exception. If it is executed,
@@ -60,8 +62,9 @@ shared_examples_for "an application that loads a dot d" do
 
   context "when client_d_dir is set to a directory containing a directory named foo.rb" do
     # foo.rb as a directory should be ignored
-    let(:client_d_dir) { Chef::Util::PathHelper.cleanpath(
-      File.join(File.dirname(__FILE__), "../../data/client.d_02")) }
+    let(:client_d_dir) do
+      Chef::Util::PathHelper.cleanpath(
+      File.join(File.dirname(__FILE__), "../../data/client.d_02")) end
 
     it "does not raise an exception" do
       expect { app.reconfigure }.not_to raise_error

data/spec/support/shared/unit/provider/file.rb

@@ -459,11 +459,11 @@ shared_examples_for Chef::Provider::File do
     context "do_validate_content" do
       before { setup_normal_file }
 
-      let(:tempfile) {
+      let(:tempfile) do
         t = double("Tempfile", :path => "/tmp/foo-bar-baz", :closed? => true)
         allow(content).to receive(:tempfile).and_return(t)
         t
-      }
+      end
 
       context "with user-supplied verifications" do
         it "calls #verify on each verification with tempfile path" do

data/spec/support/shared/unit/provider/useradd_based_user_provider.rb

@@ -18,13 +18,18 @@
 # limitations under the License.
 #
 
+# XXX: this used to be shared by solaris and linux classes, but at some
+# point became linux-specific.  it is now a misnomer to call these 'shared'
+# examples and they should either realy get turned into shared examples or
+# should be copypasta'd back directly into the linux tests.
+
 shared_examples_for "a useradd-based user provider" do |supported_useradd_options|
   before(:each) do
     @node = Chef::Node.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
-    @new_resource = Chef::Resource::User.new("adam", @run_context)
+    @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
     @new_resource.comment "Adam Jacob"
     @new_resource.uid 1000
     @new_resource.gid 1000
@@ -35,7 +40,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     @new_resource.manage_home false
     @new_resource.force false
     @new_resource.non_unique false
-    @current_resource = Chef::Resource::User.new("adam", @run_context)
+    @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
     @current_resource.comment "Adam Jacob"
     @current_resource.uid 1000
     @current_resource.gid 1000
@@ -46,7 +51,6 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     @current_resource.manage_home false
     @current_resource.force false
     @current_resource.non_unique false
-    @current_resource.supports({ :manage_home => false, :non_unique => false })
   end
 
   describe "when setting option" do
@@ -96,62 +100,49 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
 
       it "should set useradd -r" do
         @new_resource.system(true)
-        expect(provider.useradd_options).to eq([ "-r" ])
+        expect(provider.useradd_options).to eq([ "-r", "-m" ])
       end
     end
 
     describe "when the resource has a different home directory and supports home directory management" do
       before do
-        allow(@new_resource).to receive(:home).and_return("/wowaweea")
-        allow(@new_resource).to receive(:supports).and_return({ :manage_home => true,
-                                                                :non_unique => false })
+        @new_resource.home "/wowaweea"
+        @new_resource.manage_home true
       end
 
       it "should set -m -d /homedir" do
-        expect(provider.universal_options).to eq(%w{-d /wowaweea -m})
-        expect(provider.useradd_options).to eq([])
+        expect(provider.universal_options).to eq(%w{-d /wowaweea})
+        expect(provider.usermod_options).to eq(%w{-m})
       end
     end
 
     describe "when the resource has a different home directory and supports home directory management (using real attributes)" do
       before do
-        allow(@new_resource).to receive(:home).and_return("/wowaweea")
-        allow(@new_resource).to receive(:manage_home).and_return(true)
-        allow(@new_resource).to receive(:non_unique).and_return(false)
+        @new_resource.home("/wowaweea")
+        @new_resource.manage_home true
+        @new_resource.non_unique false
       end
 
       it "should set -m -d /homedir" do
-        expect(provider.universal_options).to eql(%w{-d /wowaweea -m})
-        expect(provider.useradd_options).to eq([])
+        expect(provider.universal_options).to eq(%w{-d /wowaweea})
+        expect(provider.usermod_options).to eq(%w{-m})
       end
     end
 
-    describe "when the resource supports non_unique ids" do
-      before do
-        allow(@new_resource).to receive(:supports).and_return({ :manage_home => false,
-                                                                :non_unique => true })
-      end
-
-      it "should set -m -o" do
-        expect(provider.universal_options).to eql([ "-o" ])
-      end
+    it "when non_unique is false should not set -m" do
+      @new_resource.non_unique false
+      expect(provider.universal_options).to eql([ ])
     end
 
-    describe "when the resource supports non_unique ids (using real attributes)" do
-      before do
-        allow(@new_resource).to receive(:manage_home).and_return(false)
-        allow(@new_resource).to receive(:non_unique).and_return(true)
-      end
-
-      it "should set -m -o" do
-        expect(provider.universal_options).to eql([ "-o" ])
-      end
+    it "when non_unique is true should set -o" do
+      @new_resource.non_unique true
+      expect(provider.universal_options).to eql([ "-o" ])
     end
   end
 
   describe "when creating a user" do
     before(:each) do
-      @current_resource = Chef::Resource::User.new(@new_resource.name, @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new(@new_resource.name, @run_context)
       @current_resource.username(@new_resource.username)
       provider.current_resource = @current_resource
       provider.new_resource.manage_home true
@@ -188,7 +179,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
         command.concat(["-p", "abracadabra"]) if supported_useradd_options.key?("password")
         command.concat([ "-s", "/usr/bin/zsh",
                          "-u", "1000",
-                         "-r",
+                         "-r", "-m",
                          "adam" ])
         expect(provider).to receive(:shell_out!).with(*command).and_return(true)
         provider.create_user
@@ -229,7 +220,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     end
 
     it "CHEF-3429: does not set -m if we aren't changing the home directory" do
-      expect(provider).to receive(:updating_home?).and_return(false)
+      expect(provider).to receive(:updating_home?).at_least(:once).and_return(false)
       command = ["usermod",
                   "-g", "23",
                   "adam" ]
@@ -246,15 +237,12 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     end
 
     it "should run userdel with the new resources user name and -r if manage_home is true" do
-      @new_resource.supports({ :manage_home => true,
-                               :non_unique => false })
+      @new_resource.manage_home true
       expect(provider).to receive(:shell_out!).with("userdel", "-r", @new_resource.username).and_return(true)
       provider.remove_user
     end
 
     it "should run userdel with the new resources user name if non_unique is true" do
-      @new_resource.supports({ :manage_home => false,
-                               :non_unique => true })
       expect(provider).to receive(:shell_out!).with("userdel", @new_resource.username).and_return(true)
       provider.remove_user
     end
@@ -269,7 +257,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
   describe "when checking the lock" do
     # lazy initialize so we can modify stdout and stderr strings
     let(:passwd_s_status) do
-      double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => @stdout, :stderr => @stderr)
+      double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => @stdout, :stderr => @stderr, :error! => nil)
     end
 
     before(:each) do
@@ -284,7 +272,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     end
 
     it "should return false if status begins with P" do
-      expect(provider).to receive(:shell_out!).
+      expect(provider).to receive(:shell_out).
         with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
         and_return(passwd_s_status)
       expect(provider.check_lock).to eql(false)
@@ -292,7 +280,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
 
     it "should return false if status begins with N" do
       @stdout = "root N"
-      expect(provider).to receive(:shell_out!).
+      expect(provider).to receive(:shell_out).
         with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
         and_return(passwd_s_status)
       expect(provider.check_lock).to eql(false)
@@ -300,57 +288,38 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
 
     it "should return true if status begins with L" do
       @stdout = "root L"
-      expect(provider).to receive(:shell_out!).
+      expect(provider).to receive(:shell_out).
         with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
         and_return(passwd_s_status)
       expect(provider.check_lock).to eql(true)
     end
 
-    it "should raise a Chef::Exceptions::User if passwd -S fails on anything other than redhat/centos" do
-      @node.automatic_attrs[:platform] = "ubuntu"
-      expect(provider).to receive(:shell_out!).
+    it "should raise a ShellCommandFailed exception if passwd -S exits with something other than 0 or 1" do
+      expect(passwd_s_status).to receive(:error!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect(provider).to receive(:shell_out).
         with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
         and_return(passwd_s_status)
-      expect(passwd_s_status).to receive(:exitstatus).and_return(1)
-      expect { provider.check_lock }.to raise_error(Chef::Exceptions::User)
+      expect { provider.check_lock }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
 
-    %w{redhat centos}.each do |os|
-      it "should not raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is version 0.73-1" do
-        @node.automatic_attrs[:platform] = os
-        expect(passwd_s_status).to receive(:exitstatus).and_return(1)
-        expect(provider).to receive(:shell_out!).
-          with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
-          and_return(passwd_s_status)
-        rpm_status = double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => "passwd-0.73-1\n", :stderr => "")
-        expect(provider).to receive(:shell_out!).with("rpm -q passwd").and_return(rpm_status)
-        expect { provider.check_lock }.not_to raise_error
-      end
-
-      it "should raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is not version 0.73-1" do
-        @node.automatic_attrs[:platform] = os
-        expect(passwd_s_status).to receive(:exitstatus).and_return(1)
-        expect(provider).to receive(:shell_out!).
-          with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
-          and_return(passwd_s_status)
-        rpm_status = double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => "passwd-0.73-2\n", :stderr => "")
-        expect(provider).to receive(:shell_out!).with("rpm -q passwd").and_return(rpm_status)
-        expect { provider.check_lock }.to raise_error(Chef::Exceptions::User)
-      end
-
-      it "should raise a ShellCommandFailed exception if passwd -S exits with something other than 0 or 1 on #{os}" do
-        @node.automatic_attrs[:platform] = os
-        expect(provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-        expect { provider.check_lock }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
-      end
+    it "should raise an error if the output isn't parsable" do
+      expect(passwd_s_status).to receive(:stdout).and_return("")
+      expect(passwd_s_status).to receive(:stderr).and_return("")
+      expect(provider).to receive(:shell_out).
+        with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
+        and_return(passwd_s_status)
+      expect { provider.check_lock }.to raise_error(Chef::Exceptions::User)
     end
 
     context "when in why run mode" do
       before do
         passwd_status = double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => "", :stderr => "passwd: user 'chef-test' does not exist\n")
-        expect(provider).to receive(:shell_out!).
+        expect(provider).to receive(:shell_out).
           with("passwd", "-S", @new_resource.username, { :returns => [0, 1] }).
           and_return(passwd_status)
+        # ubuntu returns 252 on user-does-not-exist so will raise if #error! is called or if
+        # shell_out! is used
+        allow(passwd_status).to receive(:error!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
         Chef::Config[:why_run] = true
       end
 
@@ -420,9 +389,9 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
       end
     end
     it "should return true if the current home does not exist but a home is specified by the new resource" do
-      @new_resource = Chef::Resource::User.new("adam", @run_context)
-      @current_resource = Chef::Resource::User.new("adam", @run_context)
-      provider = Chef::Provider::User::Useradd.new(@new_resource, @run_context)
+      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      provider = Chef::Provider::User::Linux.new(@new_resource, @run_context)
       provider.current_resource = @current_resource
       @current_resource.home nil
       @new_resource.home "/home/kitten"

data/spec/support/shared/unit/resource/static_provider_resolution.rb

@@ -33,13 +33,13 @@ def static_provider_resolution(opts = {})
   platform_version = opts[:platform_version]
 
   describe resource_class, "static provider initialization" do
-    let(:node) {
+    let(:node) do
       node = Chef::Node.new
       node.automatic_attrs[:os] = os
       node.automatic_attrs[:platform_family] = platform_family
       node.automatic_attrs[:platform_version] = platform_version
       node
-    }
+    end
     let(:events) { Chef::EventDispatch::Dispatcher.new }
     let(:run_context) { Chef::RunContext.new(node, {}, events) }
     let(:resource) { resource_class.new("foo", run_context) }

data/spec/support/shared/unit/script_resource.rb

@@ -57,18 +57,18 @@ shared_examples_for "a script resource" do
   end
 
   describe "when executing guards" do
-    let(:resource) {
+    let(:resource) do
       resource = script_resource
       resource.run_context = run_context
       resource.code "echo hi"
       resource
-    }
-    let(:node) {
+    end
+    let(:node) do
       node = Chef::Node.new
       node.automatic[:platform] = "debian"
       node.automatic[:platform_version] = "6.0"
       node
-    }
+    end
     let(:events) { Chef::EventDispatch::Dispatcher.new }
     let(:run_context) { Chef::RunContext.new(node, {}, events) }