chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

data/spec/unit/provider/systemd_unit_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Nathan Williams (<nath.e.will@gmail.com>)
-# Copyright:: Copyright (c), Nathan Williams
+# Copyright:: Copyright 2016-2018, Nathan Williams
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,17 +19,8 @@
 require "spec_helper"
 
 describe Chef::Provider::SystemdUnit do
-  let(:node) do
-    Chef::Node.new.tap do |n|
-      n.default["etc"] = {}
-      n.default["etc"]["passwd"] = {
-        "joe" => {
-          "uid" => 1_000,
-        },
-      }
-    end
-  end
 
+  let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:unit_name) { "sysstat-collect\\x2d.timer" }
@@ -83,6 +74,7 @@ describe Chef::Provider::SystemdUnit do
   end
 
   before(:each) do
+    allow(Etc).to receive(:getpwuid).and_return(OpenStruct.new(uid: 1000))
     allow(Chef::Resource::SystemdUnit).to receive(:new)
                                             .with(unit_name)
                                             .and_return(current_resource)
@@ -258,7 +250,7 @@ describe Chef::Provider::SystemdUnit do
                              .and_return(systemctl_path)
       end
 
-      describe "creates/deletes the unit" do
+      describe "creates/deletes/presets/reverts the unit" do
         it "creates the unit file when it does not exist" do
           allow(provider).to receive(:manage_unit_file)
                                .with(:create)
@@ -353,6 +345,22 @@ describe Chef::Provider::SystemdUnit do
             expect(provider).to_not receive(:manage_unit_file)
             provider.action_delete
           end
+
+          it "presets the unit" do
+            new_resource.user("joe")
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user preset #{unit_name_escaped}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_preset
+          end
+
+          it "reverts the unit" do
+            new_resource.user("joe")
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user revert #{unit_name_escaped}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_revert
+          end
         end
 
         context "when no user is specified" do
@@ -376,11 +384,33 @@ describe Chef::Provider::SystemdUnit do
             expect(provider).to_not receive(:manage_unit_file)
             provider.action_delete
           end
+
+          it "presets the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system preset #{unit_name_escaped}", {})
+                                  .and_return(shell_out_success)
+            provider.action_preset
+          end
+
+          it "reverts the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system revert #{unit_name_escaped}", {})
+                                  .and_return(shell_out_success)
+            provider.action_revert
+          end
         end
       end
 
-      describe "enables/disables the unit" do
+      describe "enables/disables/reenables the unit" do
         context "when a user is specified" do
+          it "reenables the unit" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user reenable #{unit_name_escaped}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_reenable
+          end
+
           it "enables the unit when it is disabled" do
             current_resource.user(user_name)
             current_resource.enabled(false)
@@ -429,6 +459,13 @@ describe Chef::Provider::SystemdUnit do
         end
 
         context "when no user is specified" do
+          it "reenables the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system reenable #{unit_name_escaped}", {})
+                                  .and_return(shell_out_success)
+            provider.action_reenable
+          end
+
           it "enables the unit when it is disabled" do
             current_resource.enabled(false)
             expect(provider).to receive(:shell_out_with_systems_locale!)

data/spec/unit/provider/template_spec.rb

@@ -26,7 +26,8 @@ require "support/shared/unit/provider/file"
 describe Chef::Provider::Template do
   let(:node) { double("Chef::Node") }
   let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-  let(:run_context) { double("Chef::RunContext", :node => node, :events => events) }
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
+  let(:run_context) { double("Chef::RunContext", :node => node, :events => events, :logger => logger) }
   let(:enclosing_directory) do
     canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
   end
@@ -58,9 +59,6 @@ describe Chef::Provider::Template do
 
   context "when creating the template" do
 
-    let(:node) { double("Chef::Node") }
-    let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-    let(:run_context) { double("Chef::RunContext", :node => node, :events => events) }
     let(:enclosing_directory) do
       canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
     end

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

@@ -28,11 +28,14 @@ class Chef
 end
 
 describe Chef::Provider::User::Windows do
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
+
   before(:each) do
     @node = Chef::Node.new
     @new_resource = Chef::Resource::User::WindowsUser.new("monkey")
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
+    allow(@run_context).to receive(:logger).and_return(logger)
     @current_resource = Chef::Resource::User::WindowsUser.new("monkey")
 
     @net_user = double("Chef::Util::Windows::NetUser")

data/spec/unit/provider/{env_spec.rb → windows_env_spec.rb}

@@ -18,15 +18,16 @@
 
 require "spec_helper"
 
-describe Chef::Provider::Env do
+describe Chef::Provider::WindowsEnv, :windows_only do
 
   before do
     @node = Chef::Node.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Env.new("FOO")
+    @new_resource = Chef::Resource::WindowsEnv.new("FOO")
     @new_resource.value("bar")
-    @provider = Chef::Provider::Env.new(@new_resource, @run_context)
+    @new_resource.user("<System>")
+    @provider = Chef::Provider::WindowsEnv.new(@new_resource, @run_context)
   end
 
   it "assumes the key_name exists by default" do
@@ -47,12 +48,17 @@ describe Chef::Provider::Env do
       expect(@provider.new_resource.name).to eq("FOO")
     end
 
+    it "should create a current resource with the same user as the new resource" do
+      @provider.load_current_resource
+      expect(@provider.new_resource.user).to eq("<System>")
+    end
+
     it "should set the key_name to the key name of the new resource" do
       @provider.load_current_resource
       expect(@provider.current_resource.key_name).to eq("FOO")
     end
 
-    it "should check if the key_name exists" do
+    it "should check if the key_name and user exist" do
       expect(@provider).to receive(:env_key_exists).with("FOO").and_return(true)
       @provider.load_current_resource
       expect(@provider.key_exists).to be_truthy
@@ -65,7 +71,7 @@ describe Chef::Provider::Env do
     end
 
     it "should return the current resource" do
-      expect(@provider.load_current_resource).to be_a_kind_of(Chef::Resource::Env)
+      expect(@provider.load_current_resource).to be_a_kind_of(Chef::Resource::WindowsEnv)
     end
   end
 
@@ -76,7 +82,7 @@ describe Chef::Provider::Env do
       allow(@provider).to receive(:modify_env).and_return(true)
     end
 
-    it "should call create_env if the key does not exist" do
+    it "should call create_env if the key does not exist with user" do
       expect(@provider).to receive(:create_env).and_return(true)
       @provider.action_create
     end
@@ -92,7 +98,7 @@ describe Chef::Provider::Env do
       @provider.action_create
     end
 
-    it "should call modify_env if the key exists and values are not equal" do
+    it "should call modify_env if the key exists with provided user and values are not equal" do
       @provider.key_exists = true
       allow(@provider).to receive(:requires_modify_or_create?).and_return(true)
       expect(@provider).to receive(:modify_env).and_return(true)
@@ -152,6 +158,12 @@ describe Chef::Provider::Env do
       @provider.action_modify
     end
 
+    it "should call modify_group if the key exists and users are not equal" do
+      expect(@provider).to receive(:requires_modify_or_create?).and_return(true)
+      expect(@provider).to receive(:modify_env).and_return(true)
+      @provider.action_modify
+    end
+
     it "should set the new resources updated flag to true if modify_env is called" do
       allow(@provider).to receive(:requires_modify_or_create?).and_return(true)
       allow(@provider).to receive(:modify_env).and_return(true)
@@ -159,25 +171,26 @@ describe Chef::Provider::Env do
       expect(@new_resource).to be_updated
     end
 
-    it "should not call modify_env if the key exists but the values are equal" do
+    it "should not call modify_env if the key exists with user but the values are equal" do
       expect(@provider).to receive(:requires_modify_or_create?).and_return(false)
       expect(@provider).not_to receive(:modify_env)
       @provider.action_modify
     end
 
-    it "should raise a Chef::Exceptions::Env if the key doesn't exist" do
+    it "should raise a Chef::Exceptions::WindowsEnv if the key doesn't exist" do
       @provider.key_exists = false
-      expect { @provider.action_modify }.to raise_error(Chef::Exceptions::Env)
+      expect { @provider.action_modify }.to raise_error(Chef::Exceptions::WindowsEnv)
     end
   end
 
   describe "delete_element" do
     before(:each) do
-      @current_resource = Chef::Resource::Env.new("FOO")
+      @current_resource = Chef::Resource::WindowsEnv.new("FOO")
 
       @new_resource.delim ";"
       @new_resource.value "C:/bar/bin"
 
+      @current_resource.user "<System>"
       @current_resource.value "C:/foo/bin;C:/bar/bin"
       @provider.current_resource = @current_resource
     end
@@ -280,7 +293,7 @@ describe Chef::Provider::Env do
       allow(@provider).to receive(:create_env).and_return(true)
       @new_resource.delim ";"
 
-      @current_resource = Chef::Resource::Env.new("FOO")
+      @current_resource = Chef::Resource::WindowsEnv.new("FOO")
       @current_resource.value "C:/foo/bin"
       @provider.current_resource = @current_resource
     end
@@ -307,4 +320,81 @@ describe Chef::Provider::Env do
       expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar")
     end
   end
+
+  context "when environment variable is not PATH" do
+    let(:new_resource) do
+      new_resource = Chef::Resource::WindowsEnv.new("CHEF_WINDOWS_ENV_TEST")
+      new_resource.value("foo")
+      new_resource
+    end
+    let(:provider) do
+      provider = Chef::Provider::WindowsEnv.new(new_resource, run_context)
+      allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object)
+      provider
+    end
+
+    describe "action_create" do
+      before do
+        ENV.delete("CHEF_WINDOWS_ENV_TEST")
+        provider.key_exists = false
+      end
+
+      it "should update the ruby ENV object when it creates the key" do
+        provider.action_create
+        expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foo")
+      end
+    end
+
+    describe "action_modify" do
+      before do
+        ENV["CHEF_WINDOWS_ENV_TEST"] = "foo"
+      end
+
+      it "should update the ruby ENV object when it updates the value" do
+        expect(provider).to receive(:requires_modify_or_create?).and_return(true)
+        new_resource.value("foobar")
+        provider.action_modify
+        expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foobar")
+      end
+
+      describe "action_delete" do
+        before do
+          ENV["CHEF_WINDOWS_ENV_TEST"] = "foo"
+        end
+
+        it "should update the ruby ENV object when it deletes the key" do
+          provider.action_delete
+          expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql(nil)
+        end
+      end
+    end
+  end
+
+  context "when environment is PATH" do
+    describe "for PATH" do
+      let(:system_root) { "%SystemRoot%" }
+      let(:system_root_value) { 'D:\Windows' }
+      let(:new_resource) do
+        new_resource = Chef::Resource::WindowsEnv.new("PATH")
+        new_resource.value(system_root)
+        new_resource
+      end
+      let(:provider) do
+        provider = Chef::Provider::WindowsEnv.new(new_resource, run_context)
+        allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object)
+        provider
+      end
+
+      before do
+        stub_const("ENV", { "PATH" => "" })
+      end
+
+      it "replaces Windows system variables" do
+        expect(provider).to receive(:requires_modify_or_create?).and_return(true)
+        expect(provider).to receive(:expand_path).with(system_root).and_return(system_root_value)
+        provider.action_modify
+        expect(ENV["PATH"]).to eql(system_root_value)
+      end
+    end
+  end
 end

data/spec/unit/provider/zypper_repository_spec.rb

@@ -35,10 +35,12 @@ EOF
 
 describe Chef::Provider::ZypperRepository do
   let(:new_resource) { Chef::Resource::ZypperRepository.new("Nginx Repository") }
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
   let(:provider) do
     node = Chef::Node.new
     events = Chef::EventDispatch::Dispatcher.new
     run_context = Chef::RunContext.new(node, {}, events)
+    allow(run_context).to receive(:logger).and_return(logger)
     Chef::Provider::ZypperRepository.new(new_resource, run_context)
   end
 
@@ -58,7 +60,7 @@ describe Chef::Provider::ZypperRepository do
     it "skips key import if gpgautoimportkeys is false" do
       new_resource.gpgautoimportkeys(false)
       expect(provider).to receive(:declare_resource)
-      expect(Chef::Log).to receive(:debug)
+      expect(logger).to receive(:trace)
       provider.run_action(:create)
     end
   end
@@ -117,7 +119,7 @@ describe Chef::Provider::ZypperRepository do
 
   describe "#install_gpg_key" do
     it "skips installing the key if a nil value for key is passed" do
-      expect(Chef::Log).to receive(:debug)
+      expect(logger).to receive(:trace)
       provider.install_gpg_key(nil)
     end
   end

data/spec/unit/provider_resolver_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Lamont Granquist (<lamont@chef.io>)
-# Copyright:: Copyright 2014-2016, Chef Software Inc.
+# Copyright:: Copyright 2014-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -553,15 +553,18 @@ describe Chef::ProviderResolver do
 
     PROVIDERS =
       {
+        aix_user:               [ Chef::Resource::User::AixUser, Chef::Provider::User::Aix ],
+        apt_package:            [ Chef::Resource::AptPackage, Chef::Provider::Package::Apt ],
         bash:                   [ Chef::Resource::Bash, Chef::Provider::Script ],
+        bff_package:            [ Chef::Resource::BffPackage, Chef::Provider::Package::Bff ],
         breakpoint:             [ Chef::Resource::Breakpoint, Chef::Resource::Breakpoint.action_class ],
         chef_gem:               [ Chef::Resource::ChefGem, Chef::Provider::Package::Rubygems ],
         cookbook_file:          [ Chef::Resource::CookbookFile, Chef::Provider::CookbookFile ],
         csh:                    [ Chef::Resource::Csh, Chef::Provider::Script ],
-        deploy:                 [ Chef::Resource::Deploy, Chef::Provider::Deploy::Timestamped ],
-        deploy_revision:        [ Chef::Resource::DeployRevision, Chef::Provider::Deploy::Revision ],
         directory:              [ Chef::Resource::Directory, Chef::Provider::Directory ],
-        erl_call:               [ Chef::Resource::ErlCall, Chef::Provider::ErlCall ],
+        dpkg_package:           [ Chef::Resource::DpkgPackage, Chef::Provider::Package::Dpkg ],
+        dsc_script:             [ Chef::Resource::DscScript, Chef::Provider::DscScript ],
+        dscl_user:              [ Chef::Resource::User::DsclUser, Chef::Provider::User::Dscl ],
         execute:                [ Chef::Resource::Execute, Chef::Provider::Execute ],
         file:                   [ Chef::Resource::File, Chef::Provider::File ],
         gem_package:            [ Chef::Resource::GemPackage, Chef::Provider::Package::Rubygems ],
@@ -570,53 +573,37 @@ describe Chef::ProviderResolver do
         homebrew_package:       [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
         http_request:           [ Chef::Resource::HttpRequest, Chef::Provider::HttpRequest ],
         ifconfig:               [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+        ips_package:            [ Chef::Resource::IpsPackage, Chef::Provider::Package::Ips ],
         link:                   [ Chef::Resource::Link, Chef::Provider::Link ],
+        linux_user:             [ Chef::Resource::User::LinuxUser, Chef::Provider::User::Linux ],
         log:                    [ Chef::Resource::Log, Chef::Provider::Log::ChefLog ],
         macports_package:       [ Chef::Resource::MacportsPackage, Chef::Provider::Package::Macports ],
         mdadm:                  [ Chef::Resource::Mdadm, Chef::Provider::Mdadm ],
         mount:                  [ Chef::Resource::Mount, Chef::Provider::Mount::Mount ],
+        pacman_package:         [ Chef::Resource::PacmanPackage, Chef::Provider::Package::Pacman ],
+        paludis_package:        [ Chef::Resource::PaludisPackage, Chef::Provider::Package::Paludis ],
         perl:                   [ Chef::Resource::Perl, Chef::Provider::Script ],
         portage_package:        [ Chef::Resource::PortagePackage, Chef::Provider::Package::Portage ],
+        pw_user:                [ Chef::Resource::User::PwUser, Chef::Provider::User::Pw ],
         python:                 [ Chef::Resource::Python, Chef::Provider::Script ],
         remote_directory:       [ Chef::Resource::RemoteDirectory, Chef::Provider::RemoteDirectory ],
         route:                  [ Chef::Resource::Route, Chef::Provider::Route ],
-        ruby:                   [ Chef::Resource::Ruby, Chef::Provider::Script ],
+        rpm_package:            [ Chef::Resource::Package::RpmPackage, Chef::Provider::Package::Rpm ],
         ruby_block:             [ Chef::Resource::RubyBlock, Chef::Provider::RubyBlock ],
+        ruby:                   [ Chef::Resource::Ruby, Chef::Provider::Script ],
         script:                 [ Chef::Resource::Script, Chef::Provider::Script ],
+        smartos_package:        [ Chef::Resource::SmartosPackage, Chef::Provider::Package::SmartOS ],
+        solaris_package:        [ Chef::Resource::SolarisPackage, Chef::Provider::Package::Solaris ],
+        solaris_user:           [ Chef::Resource::User::SolarisUser, Chef::Provider::User::Solaris ],
         subversion:             [ Chef::Resource::Subversion, Chef::Provider::Subversion ],
         template:               [ Chef::Resource::Template, Chef::Provider::Template ],
-        timestamped_deploy:     [ Chef::Resource::TimestampedDeploy, Chef::Provider::Deploy::Timestamped ],
-        aix_user:               [ Chef::Resource::User::AixUser, Chef::Provider::User::Aix ],
-        dscl_user:              [ Chef::Resource::User::DsclUser, Chef::Provider::User::Dscl ],
-        linux_user:             [ Chef::Resource::User::LinuxUser, Chef::Provider::User::Linux ],
-        pw_user:                [ Chef::Resource::User::PwUser, Chef::Provider::User::Pw ],
-        solaris_user:           [ Chef::Resource::User::SolarisUser, Chef::Provider::User::Solaris ],
-        windows_user:           [ Chef::Resource::User::WindowsUser, Chef::Provider::User::Windows ],
         whyrun_safe_ruby_block: [ Chef::Resource::WhyrunSafeRubyBlock, Chef::Provider::WhyrunSafeRubyBlock ],
-
-        # We want to check that these are unsupported:
-        apt_package: nil,
-        bff_package: nil,
-        dpkg_package: nil,
-        dsc_script: nil,
-        ips_package: nil,
-        pacman_package: nil,
-        paludis_package: nil,
-        rpm_package: nil,
-        smartos_package: nil,
-        solaris_package: nil,
-        yum_package: nil,
-        windows_package: nil,
-        windows_service: nil,
+        windows_package:        [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
+        windows_service:        [ Chef::Resource::WindowsService, Chef::Provider::Service::Windows ],
+        windows_user:           [ Chef::Resource::User::WindowsUser, Chef::Provider::User::Windows ],
+        yum_package:            [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
 
         "linux" => {
-          apt_package:     [ Chef::Resource::AptPackage, Chef::Provider::Package::Apt ],
-          dpkg_package:    [ Chef::Resource::DpkgPackage, Chef::Provider::Package::Dpkg ],
-          pacman_package:  [ Chef::Resource::PacmanPackage, Chef::Provider::Package::Pacman ],
-          paludis_package: [ Chef::Resource::PaludisPackage, Chef::Provider::Package::Paludis ],
-          rpm_package:     [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
-          yum_package:     [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
-
           "debian" => {
             ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Debian ],
             package:  [ Chef::Resource::AptPackage, Chef::Provider::Package::Apt ],
@@ -766,7 +753,7 @@ describe Chef::ProviderResolver do
         "windows" => {
           batch:             [ Chef::Resource::Batch, Chef::Provider::Batch ],
           dsc_script:        [ Chef::Resource::DscScript, Chef::Provider::DscScript ],
-          env:               [ Chef::Resource::Env, Chef::Provider::Env::Windows ],
+          windows_env:       [ Chef::Resource::WindowsEnv, Chef::Provider::WindowsEnv ],
           group:             [ Chef::Resource::Group, Chef::Provider::Group::Windows ],
           mount:             [ Chef::Resource::Mount, Chef::Provider::Mount::Windows ],
           package:           [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
@@ -785,13 +772,11 @@ describe Chef::ProviderResolver do
         },
 
         "aix" => {
-          bff_package: [ Chef::Resource::BffPackage, Chef::Provider::Package::Aix ],
           cron: [ Chef::Resource::Cron, Chef::Provider::Cron::Aix ],
           group: [ Chef::Resource::Group, Chef::Provider::Group::Aix ],
           ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Aix ],
           mount: [ Chef::Resource::Mount, Chef::Provider::Mount::Aix ],
-          # TODO should be Chef::Resource::BffPackage
-          package: [ Chef::Resource::Package, Chef::Provider::Package::Aix ],
+          package: [ Chef::Resource::Package, Chef::Provider::Package::Bff ],
           rpm_package: [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
           user: [ Chef::Resource::User::AixUser, Chef::Provider::User::Aix ],
     #      service: [ Chef::Resource::AixService, Chef::Provider::Service::Aix ],