chef 12.15.19-universal-mingw32 → 12.16.42-universal-mingw32

data/spec/unit/node_spec.rb

@@ -243,6 +243,34 @@ describe Chef::Node do
       expect { node.sunshine = "is bright" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
 
+    it "does not allow modification of node attributes via hash methods" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      node.default["h4sh"] = { foo: "bar" }
+      expect { node["h4sh"].delete("foo") }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+      expect { node.h4sh.delete("foo") }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "does not allow modification of node attributes via array methods" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      node.default["array"] = []
+      expect { node["array"] << "boom" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+      expect { node.array << "boom" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "returns merged immutable attributes for arrays" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      node.default["array"] = []
+      expect( node["array"].class ).to eql(Chef::Node::ImmutableArray)
+      expect( node.array.class ).to eql(Chef::Node::ImmutableArray)
+    end
+
+    it "returns merged immutable attributes for hashes" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      node.default["h4sh"] = {}
+      expect( node["h4sh"].class ).to eql(Chef::Node::ImmutableMash)
+      expect( node.h4sh.class ).to eql(Chef::Node::ImmutableMash)
+    end
+
     it "should allow you get get an attribute via method_missing" do
       Chef::Config[:treat_deprecation_warnings_as_errors] = false
       node.default.sunshine = "is bright"
@@ -756,9 +784,9 @@ describe Chef::Node do
     # In Chef-12.0 there is a deep_merge cache on the top level attribute which had a bug
     # where it cached node[:foo] separate from node['foo'].  These tests exercise those edge conditions.
     #
-    # https://github.com/opscode/chef/issues/2700
-    # https://github.com/opscode/chef/issues/2712
-    # https://github.com/opscode/chef/issues/2745
+    # https://github.com/chef/chef/issues/2700
+    # https://github.com/chef/chef/issues/2712
+    # https://github.com/chef/chef/issues/2745
     #
     describe "deep merge attribute cache edge conditions" do
       it "does not error with complicated attribute substitution" do
@@ -1681,4 +1709,107 @@ describe Chef::Node do
     end
   end
 
+  describe "path tracking via __path__" do
+    it "works through hash keys" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    it "works through the default level" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node.default["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    it "works through arrays" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node["foo"][0].__path__).to eql(["foo", 0])
+      expect(node["foo"][0]["bar"].__path__).to eql(["foo", 0, "bar"])
+    end
+
+    it "works through arrays at the default level" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node.default["foo"][0].__path__).to eql(["foo", 0])
+      expect(node.default["foo"][0]["bar"].__path__).to eql(["foo", 0, "bar"])
+    end
+
+    # if we set __path__ in the initializer we'd get this wrong, this is why we
+    # update the path on every #[] or #[]= operator
+    it "works on access when the node has been rearranged" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      a = node.default["foo"]
+      node.default["fizz"] = a
+      expect(node["fizz"]["bar"].__path__).to eql(%w{fizz bar})
+      expect(node["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    # We have a problem because the __path__ is stored on in each node, but the
+    # node can be wired up at multiple locations in the tree via pointers.  One
+    # solution would be to deep-dup the value in `#[]=(key, value)` and fix the
+    # __path__ on all the dup'd nodes.  The problem is that this would create an
+    # unusual situation where after assignment, you couldn't mutate the thing you
+    # hand a handle on.  I'm not entirely positive this behavior is the correct
+    # thing to support, but it is more hash-like (although if we start with a hash
+    # then convert_value does its thing and we *do* get dup'd on assignment).  This
+    # behavior likely makes any implementation of a deep merge cache built over the
+    # top of __path__ tracking have edge conditions where it will fail.
+    #
+    # Removing this support would be a breaking change.  The test is included here
+    # because it seems most likely that someone would break this behavior while trying
+    # to fix __path__ behavior.
+    it "does not dup in the background when a node is assigned" do
+      # get a handle on a vividmash (can't be a hash or else we convert_value it)
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      a = node.default["foo"]
+      # assign that somewhere else in the tree
+      node.default["fizz"] = a
+      # now upate the source
+      a["duptest"] = true
+      # the tree should have been updated
+      expect(node.default["fizz"]["duptest"]).to be true
+      expect(node["fizz"]["duptest"]).to be true
+    end
+  end
+
+  describe "root tracking via __root__" do
+    it "works through hash keys" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node["foo"]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through the default level" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node.default["foo"]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through arrays" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node["foo"][0].__root__).to eql(node.attributes)
+      expect(node["foo"][0]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through arrays at the default level" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node.default["foo"][0].__root__).to eql(node.attributes)
+      expect(node.default["foo"][0]["bar"].__root__).to eql(node.attributes)
+    end
+  end
+
+  describe "ways of abusing Chef 12 node state" do
+    # these tests abuse the top_level_breadcrumb state in Chef 12
+    it "derived attributes work correctly" do
+      node.default["v1"] = 1
+      expect(node["a"]).to eql(nil)
+      node.default["a"] = node["v1"]
+      expect(node["a"]).to eql(1)
+    end
+
+    it "works when saving nodes to variables" do
+      a = node.default["a"]
+      expect(node["a"]).to eql({})
+      node.default["b"] = 0
+      a["key"] = 1
+
+      expect(node["a"]["key"]).to eql(1)
+    end
+  end
 end

data/spec/unit/provider/deploy_spec.rb

@@ -556,7 +556,7 @@ describe Chef::Provider::Deploy do
       @resource.deploy_to("/my/app")
       expect(mock_execution).to receive(:user).with("notCoolMan")
       expect(mock_execution).to receive(:group).with("Ggroup")
-      expect(mock_execution).to receive(:cwd) {|*args|
+      expect(mock_execution).to receive(:cwd) { |*args|
         if args.empty?
           nil
         else

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

@@ -0,0 +1,90 @@
+#
+# Author:: Tom Duffield (<tom@chef.io>)
+# 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"
+
+describe Chef::Provider::Group::Suse do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:new_members) { %w{root new_user} }
+  let(:new_resource) do
+    Chef::Resource::Group.new("new_group").tap do |r|
+      r.gid 50
+      r.members new_members
+      r.system false
+      r.non_unique false
+    end
+  end
+  let(:current_resource) do
+    Chef::Resource::Group.new("new_group").tap do |r|
+      r.gid 50
+      r.members %w{root}
+      r.system false
+      r.non_unique false
+    end
+  end
+  let(:provider) do
+    described_class.new(new_resource, run_context).tap do |p|
+      p.current_resource = current_resource
+    end
+  end
+
+  describe "when determining the current group state" do
+    before(:each) do
+      allow(File).to receive(:exists?).and_return(true)
+      provider.action = :create
+      provider.define_resource_requirements
+    end
+
+    # Checking for required binaries is already done in the spec
+    # for Chef::Provider::Group - no need to repeat it here.  We'll
+    # include only what's specific to this provider.
+    it "should raise an error if the required binary /usr/sbin/groupmod doesn't exist" do
+      expect(File).to receive(:exists?).with("/usr/sbin/groupmod").and_return(false)
+      expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
+    end
+
+    it "should raise error if one of the member users does not exist" do
+      expect(Etc).to receive(:getpwnam).with("new_user").and_raise ArgumentError
+      expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
+    end
+  end
+
+  describe "#set_members" do
+    it "should add missing members and remove deleted members" do
+      expect(provider).not_to receive(:remove_member)
+      expect(provider).to receive(:add_member).with("new_user")
+      provider.set_members(new_members)
+    end
+  end
+
+  describe "#add_member" do
+    it "should call out to groupmod to add user" do
+      expect(provider).to receive(:shell_out!).with("groupmod -A new_user new_group")
+      provider.add_member("new_user")
+    end
+  end
+
+  describe "#remove_member" do
+    it "should call out to groupmod to remove user" do
+      expect(provider).to receive(:shell_out!).with("groupmod -R new_user new_group")
+      provider.remove_member("new_user")
+    end
+  end
+end

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

@@ -395,6 +395,28 @@ mpg123 1.12.1-0ubuntu1
           end
         end
 
+        describe "when locking a package" do
+          it "should run apt-mark hold package" do
+            expect(@provider).to receive(:shell_out!).with(
+              "apt-mark hold irssi",
+              :env => { "DEBIAN_FRONTEND" => "noninteractive" },
+              :timeout => @timeout
+            )
+            @provider.lock_package("irssi", "0.8.12-7")
+          end
+        end
+
+        describe "when unlocking a package" do
+          it "should run apt-mark unhold package" do
+            expect(@provider).to receive(:shell_out!).with(
+              "apt-mark unhold irssi",
+              :env => { "DEBIAN_FRONTEND" => "noninteractive" },
+              :timeout => @timeout
+            )
+            @provider.unlock_package("irssi", "0.8.12-7")
+          end
+        end
+
         describe "when installing a virtual package" do
           it "should install the package without specifying a version" do
             @provider.package_data["libmysqlclient15-dev"][:virtual] = true

data/spec/unit/provider/package/windows/msi_spec.rb

@@ -121,7 +121,7 @@ describe Chef::Provider::Package::Windows::MSI do
       end
 
       it "removes installed package" do
-        expect(provider).to receive(:shell_out!).with(/MsiExec.exe \/X{guid} \/Q/, kind_of(Hash))
+        expect(provider).to receive(:shell_out!).with(/msiexec \/x {guid} \/q/, kind_of(Hash))
         provider.remove_package
       end
 
@@ -140,8 +140,8 @@ describe Chef::Provider::Package::Windows::MSI do
         end
 
         it "removes both installed package" do
-          expect(provider).to receive(:shell_out!).with(/MsiExec.exe \/X{guid} \/Q/, kind_of(Hash))
-          expect(provider).to receive(:shell_out!).with(/MsiExec.exe \/X{guid2} \/Q/, kind_of(Hash))
+          expect(provider).to receive(:shell_out!).with(/msiexec \/x {guid} \/q/, kind_of(Hash))
+          expect(provider).to receive(:shell_out!).with(/msiexec \/x {guid2} \/q/, kind_of(Hash))
           provider.remove_package
         end
       end
@@ -150,7 +150,16 @@ describe Chef::Provider::Package::Windows::MSI do
         before { new_resource.options("/Q") }
 
         it "does not duplicate quiet switch" do
-          expect(provider).to receive(:shell_out!).with(/MsiExec.exe \/X{guid} \/Q/, kind_of(Hash))
+          expect(provider).to receive(:shell_out!).with(/msiexec \/x {guid} \/Q/, kind_of(Hash))
+          provider.remove_package
+        end
+      end
+
+      context "custom options includes /qn" do
+        before { new_resource.options("/qn") }
+
+        it "does not duplicate quiet switch" do
+          expect(provider).to receive(:shell_out!).with(/msiexec \/x {guid} \/qn/, kind_of(Hash))
           provider.remove_package
         end
       end

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

@@ -26,9 +26,9 @@ describe Chef::Provider::Package::Windows, :windows_only do
     allow(Chef::FileCache).to receive(:create_cache_path).with("package/").and_return(cache_path)
   end
 
-  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(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource_source) { "calculator.msi" }
   let(:resource_name) { "calculator" }
   let(:installer_type) { nil }

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

@@ -785,6 +785,24 @@ describe Chef::Provider::Package::Yum do
     end
   end
 
+  describe "when locking a package" do
+    it "should run yum versionlock add with the package name" do
+      expect(@provider).to receive(:yum_command).with(
+        "-d0 -e0 -y versionlock add emacs"
+      )
+      @provider.lock_package("emacs", nil)
+    end
+  end
+
+  describe "when unlocking a package" do
+    it "should run yum versionlock delete with the package name" do
+      expect(@provider).to receive(:yum_command).with(
+        "-d0 -e0 -y versionlock delete emacs"
+      )
+      @provider.unlock_package("emacs", nil)
+    end
+  end
+
   describe "when running yum" do
     it "should run yum once if it exits with a return code of 0" do
       @status = double("Status", :exitstatus => 0, :stdout => "", :stderr => "")

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

@@ -231,6 +231,70 @@ describe Chef::Provider::Package::Zypper do
     end
   end
 
+  describe "lock_package" do
+    it "should run zypper addlock with the package name" do
+      allow(Chef::Config).to receive(:[]).with(:zypper_check_gpg).and_return(true)
+      shell_out_expectation!(
+        "zypper --non-interactive addlock emacs"
+      )
+      provider.lock_package(["emacs"], [nil])
+    end
+    it "should run zypper addlock without gpg checks" do
+      allow(Chef::Config).to receive(:[]).with(:zypper_check_gpg).and_return(false)
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks addlock emacs"
+      )
+      provider.lock_package(["emacs"], [nil])
+    end
+    it "should warn about gpg checks on zypper addlock" do
+      expect(Chef::Log).to receive(:warn).with(
+        /All packages will be installed without gpg signature checks/
+      )
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks addlock emacs"
+      )
+      provider.lock_package(["emacs"], [nil])
+    end
+    it "should run zypper addlock without gpg checks" do
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks addlock emacs"
+      )
+      provider.lock_package(["emacs"], [nil])
+    end
+  end
+
+  describe "unlock_package" do
+    it "should run zypper removelock with the package name" do
+      allow(Chef::Config).to receive(:[]).with(:zypper_check_gpg).and_return(true)
+      shell_out_expectation!(
+        "zypper --non-interactive removelock emacs"
+      )
+      provider.unlock_package(["emacs"], [nil])
+    end
+    it "should run zypper removelock without gpg checks" do
+      allow(Chef::Config).to receive(:[]).with(:zypper_check_gpg).and_return(false)
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks removelock emacs"
+      )
+      provider.unlock_package(["emacs"], [nil])
+    end
+    it "should warn about gpg checks on zypper removelock" do
+      expect(Chef::Log).to receive(:warn).with(
+        /All packages will be installed without gpg signature checks/
+      )
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks removelock emacs"
+      )
+      provider.unlock_package(["emacs"], [nil])
+    end
+    it "should run zypper removelock without gpg checks" do
+      shell_out_expectation!(
+        "zypper --non-interactive --no-gpg-checks removelock emacs"
+      )
+      provider.unlock_package(["emacs"], [nil])
+    end
+  end
+
   describe "on an older zypper" do
     before(:each) do
       allow(provider).to receive(:`).and_return("0.11.6")

data/spec/unit/provider/package_spec.rb

@@ -321,6 +321,56 @@ describe Chef::Provider::Package do
     end
   end
 
+  describe "When locking the package" do
+    before(:each) do
+      allow(provider).to receive(:lock_package).and_return(true)
+    end
+
+    it "should lock the package if it is unlocked" do
+      allow(provider).to receive(:package_locked).and_return(false)
+      expect(provider).to receive(:lock_package)
+      provider.run_action(:lock)
+    end
+
+    it "should not lock the package if it is already locked" do
+      allow(provider).to receive(:package_locked).and_return(true)
+      expect(provider).not_to receive(:lock_package)
+      provider.run_action(:lock)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    it "should set the resource to updated if it locks the package" do
+      allow(provider).to receive(:package_locked).and_return(false)
+      provider.run_action(:lock)
+      expect(new_resource).to be_updated
+    end
+  end
+
+  describe "When unlocking the package" do
+    before(:each) do
+      allow(provider).to receive(:unlock_package).and_return(true)
+    end
+
+    it "should unlock the package if it is locked" do
+      allow(provider).to receive(:package_locked).and_return(true)
+      expect(provider).to receive(:unlock_package)
+      provider.run_action(:unlock)
+    end
+
+    it "should not unlock the package if it is already unlocked" do
+      allow(provider).to receive(:package_locked).and_return(false)
+      expect(provider).not_to receive(:unlock_package)
+      provider.run_action(:unlock)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    it "should set the resource to updated if it unlocks the package" do
+      allow(provider).to receive(:package_locked).and_return(true)
+      provider.run_action(:unlock)
+      expect(new_resource).to be_updated
+    end
+  end
+
   describe "when running commands to be implemented by subclasses" do
     it "should raises UnsupportedAction for install" do
       expect { provider.install_package("emacs", "1.4.2") }.to raise_error(Chef::Exceptions::UnsupportedAction)
@@ -346,6 +396,14 @@ describe Chef::Provider::Package do
     it "should raise UnsupportedAction for reconfig" do
       expect { provider.reconfig_package("emacs", "1.4.2") }.to raise_error(Chef::Exceptions::UnsupportedAction)
     end
+
+    it "should raise UnsupportedAction for lock" do
+      expect { provider.lock_package("emacs", nil) }.to raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raise UnsupportedAction for unlock" do
+      expect { provider.unlock_package("emacs", nil) }.to raise_error(Chef::Exceptions::UnsupportedAction)
+    end
   end
 
   describe "when given a response file" do