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

data/spec/unit/mixin/powershell_exec_spec.rb

@@ -0,0 +1,43 @@
+#
+# Author:: Stuart Preston (<stuart@chef.io>)
+# Copyright:: Copyright 2018, 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 "chef/mixin/powershell_exec"
+
+describe Chef::Mixin::PowershellExec, :windows_only do
+  let(:powershell_mixin) { Class.new { include Chef::Mixin::PowershellExec } }
+  subject(:object) { powershell_mixin.new }
+
+  describe "#powershell_exec" do
+    it "runs a basic command and returns a Chef::PowerShell object" do
+      expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
+    end
+
+    it "runs a command that fails with a non-terminating error and can trap the error via .error?" do
+      execution = object.powershell_exec("this-should-error")
+      expect(execution.error?).to eql(true)
+    end
+
+    it "runs a command that fails with a non-terminating error and can list the errors" do
+      execution = object.powershell_exec("this-should-error")
+      expect(execution.errors).to be_a_kind_of(Array)
+      expect(execution.errors[0]).to be_a_kind_of(String)
+      expect(execution.errors[0]).to include("CommandNotFoundException")
+    end
+  end
+end

data/spec/unit/node/attribute_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: AJ Christensen (<aj@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -590,7 +590,7 @@ describe Chef::Node::Attribute do
 
     it "should yield each top level key" do
       collect = Array.new
-      @attributes.keys.each do |k|
+      @attributes.each_key do |k|
         collect << k
       end
       expect(collect.include?("one")).to eq(true)
@@ -603,7 +603,7 @@ describe Chef::Node::Attribute do
 
     it "should yield lower if we go deeper" do
       collect = Array.new
-      @attributes["one"].keys.each do |k|
+      @attributes["one"].each_key do |k|
         collect << k
       end
       expect(collect.include?("two")).to eq(true)

data/spec/unit/node/immutable_collections_spec.rb

@@ -29,6 +29,11 @@ describe Chef::Node::ImmutableMash do
     @immutable_mash = Chef::Node::ImmutableMash.new(@data_in)
   end
 
+  it "does not have any unaudited methods" do
+    unaudited_methods = Hash.instance_methods - Object.instance_methods - Chef::Node::Mixin::ImmutablizeHash::DISALLOWED_MUTATOR_METHODS - Chef::Node::Mixin::ImmutablizeHash::ALLOWED_METHODS
+    expect(unaudited_methods).to be_empty
+  end
+
   it "element references like regular hash" do
     expect(@immutable_mash[:top][:second_level]).to eq("some value")
   end
@@ -221,6 +226,11 @@ describe Chef::Node::ImmutableArray do
     end
   end
 
+  it "does not have any unaudited methods" do
+    unaudited_methods = Array.instance_methods - Object.instance_methods - Chef::Node::Mixin::ImmutablizeArray::DISALLOWED_MUTATOR_METHODS - Chef::Node::Mixin::ImmutablizeArray::ALLOWED_METHODS
+    expect(unaudited_methods).to be_empty
+  end
+
   it "can be duped even if some elements can't" do
     @immutable_array.dup
   end
@@ -275,7 +285,7 @@ describe Chef::Node::ImmutableArray do
     end
 
     it "should create an array with the same content" do
-      expect(@copy).to eql(@immutable_nested_array)
+      expect(@copy).to eq(@immutable_nested_array)
     end
 
     it "should allow mutation" do

data/spec/unit/node_map_spec.rb

@@ -129,10 +129,10 @@ describe Chef::NodeMap do
       expect(node_map.get(node, :thing)).to eql(Bar)
     end
 
-    it "orders them alphabetically when they're set in alphabetic order" do
+    it "last writer wins when its alphabetic order" do
       node_map.set(:thing, Bar)
       node_map.set(:thing, Foo)
-      expect(node_map.get(node, :thing)).to eql(Bar)
+      expect(node_map.get(node, :thing)).to eql(Foo)
     end
   end
 

data/spec/unit/node_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -186,7 +186,7 @@ describe Chef::Node do
       expect { node.policy_group = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyz0123456789-_:." }.to_not raise_error
     end
 
-    it "sets an environment with chef_environment(something)" do
+    it "sets a policy_group with policy_group(something)" do
       node.policy_group("staging")
       expect(node.policy_group).to eq("staging")
     end
@@ -303,20 +303,6 @@ describe Chef::Node do
         expect(node["tags"]).to eq(%w{one two three four})
       end
 
-      it "set is a deprecated alias for normal" do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        expect(Chef).to receive(:deprecated).with(:attributes, /set is deprecated/)
-        node.set[:snoopy][:is_a_puppy] = true
-        expect(node.normal[:snoopy][:is_a_puppy]).to eq(true)
-      end
-
-      it "set_unless is a deprecated alias for normal_unless" do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        expect(Chef).to receive(:deprecated).with(:attributes, /set_unless is deprecated/)
-        node.set_unless[:snoopy][:is_a_puppy] = false
-        expect(node.normal[:snoopy][:is_a_puppy]).to eq(false)
-      end
-
       it "normal_unless sets a value even if default or override attrs are set" do
         node.default[:decontamination] = true
         node.override[:decontamination] = false
@@ -967,6 +953,14 @@ describe Chef::Node do
       expect(node.automatic_attrs[:platform_version]).to eq("23.42")
     end
 
+    it "sets the chef guid attribute correctly" do
+      guid = Chef::Config[:chef_guid]
+      Chef::Config[:chef_guid] = "test-guid-guid"
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.automatic_attrs[:chef_guid]).to eq("test-guid-guid")
+      Chef::Config[:chef_guid] = guid
+    end
+
     it "consumes the run list from provided json attributes" do
       node.consume_external_attrs(@ohai_data, { "run_list" => ["recipe[unicorn]"] })
       expect(node.run_list).to eq(["recipe[unicorn]"])
@@ -1367,6 +1361,7 @@ describe Chef::Node do
 
         expect(round_tripped_node.policy_name).to eq("my-application")
         expect(round_tripped_node.policy_group).to eq("staging")
+        expect(round_tripped_node.chef_environment).to eq("staging")
       end
 
     end

data/spec/unit/platform/query_helpers_spec.rb

@@ -18,19 +18,6 @@
 
 require "spec_helper"
 
-describe "Chef::Platform#windows_server_2003?" do
-  it "returns false early when not on windows" do
-    allow(ChefConfig).to receive(:windows?).and_return(false)
-    expect(Chef::Platform).not_to receive(:require)
-    expect(Chef::Platform.windows_server_2003?).to be_falsey
-  end
-
-  # CHEF-4888: Need to call WIN32OLE.ole_initialize in new threads
-  it "does not raise an exception" do
-    expect { Thread.fork { Chef::Platform.windows_server_2003? }.join }.not_to raise_error
-  end
-end
-
 describe "Chef::Platform#windows_nano_server?" do
   include_context "Win32"
 

data/spec/unit/policy_builder/policyfile_spec.rb

@@ -70,8 +70,44 @@ describe Chef::PolicyBuilder::Policyfile do
     }
   end
 
-  let(:policyfile_default_attributes) { { "policyfile_default_attr" => "policyfile_default_value" } }
-  let(:policyfile_override_attributes) { { "policyfile_override_attr" => "policyfile_override_value" } }
+  let(:policyfile_default_attributes) do
+    {
+        "policyfile_default_attr" => "policyfile_default_value",
+        "top_level_attr" => "hat",
+        "baseline_attr" => {
+          "one" => 1,
+          "two" => 2,
+          "deep" => {
+              "three" => 3,
+              "four" => [4],
+              "five" => [5],
+          },
+        },
+        "policy_group_value" => {
+          "baseline_attr" => {
+            "one" => 111,
+          },
+        },
+      }
+  end
+
+  let(:policyfile_override_attributes) do
+    {
+       "policyfile_override_attr" => "policyfile_override_value",
+       "baseline_attr" => {
+         "deep" => {
+           "three" => 333 },
+       },
+       "policy_group_value" => {
+         "top_level_attr" => "cat",
+         "baseline_attr" => {
+           "deep" => {
+             "four" => [444],
+           },
+         },
+       },
+    }
+  end
 
   let(:policyfile_run_list) { ["recipe[example1::default]", "recipe[example2::server]"] }
 
@@ -538,6 +574,10 @@ describe Chef::PolicyBuilder::Policyfile do
               expect(Chef::Config[:policy_group]).to eq("policy_group_from_node_json")
               expect(node.policy_name).to eq("policy_name_from_node_json")
               expect(node.policy_group).to eq("policy_group_from_node_json")
+              expect(node.automatic_attrs[:policy_name]).to eq("policy_name_from_node_json")
+              expect(node.automatic_attrs[:policy_group]).to eq("policy_group_from_node_json")
+              expect(node.automatic_attrs[:chef_environment]).to eq("policy_group_from_node_json")
+
             end
 
           end
@@ -587,6 +627,7 @@ describe Chef::PolicyBuilder::Policyfile do
           it "create node.automatic_attrs[:recipes]" do
             expect(node.automatic_attrs[:recipes]).to eq(["example1::default", "example2::server"])
           end
+
         end
 
         context "when a named run_list is given" do
@@ -636,6 +677,42 @@ describe Chef::PolicyBuilder::Policyfile do
           end
 
         end
+
+        describe "hoisting attribute values" do
+          context "with no policy group set" do
+            it "does not hoist policy_group specific attributes" do
+              expect( node["top_level_attr"] ).to eql("hat")
+              expect( node["baseline_attr"]["one"] ).to eql(1)
+              expect( node["baseline_attr"]["two"] ).to eql(2)
+              expect( node["baseline_attr"]["deep"]["three"] ).to eql(333)
+              expect( node["baseline_attr"]["deep"]["four"] ).to eql([4])
+              expect( node["baseline_attr"]["deep"]["five"] ).to eql([5])
+            end
+          end
+
+          context "with a policy group set" do
+            before do
+              Chef::Config[:policy_group] = "policy_group_value"
+              policy_builder.finish_load_node(node)
+              policy_builder.build_node
+            end
+
+            it "hoists default attributes" do
+              expect( node["top_level_attr"] ).to eql("cat")
+              expect( node["baseline_attr"]["one"]).to eql(111)
+              expect( node["baseline_attr"]["two"] ).to eql(2)
+              expect( node["baseline_attr"]["deep"]["five"] ).to eql([5])
+            end
+
+            it "hoists override attributes" do
+              expect( node["top_level_attr"] ).to eql("cat")
+              expect( node["baseline_attr"]["two"] ).to eql(2)
+              expect( node["baseline_attr"]["deep"]["three"] ).to eql(333)
+              expect( node["baseline_attr"]["deep"]["four"] ).to eql([444])
+              expect( node["baseline_attr"]["deep"]["five"] ).to eql([5])
+            end
+          end
+        end
       end
 
       describe "fetching the desired cookbook set" do

data/spec/unit/property/validation_spec.rb

@@ -617,8 +617,9 @@ describe "Chef::Resource.property validation" do
         expect(resource.x 1).to eq 1
         expect(resource.x).to eq 1
       end
-      it "value nil is invalid" do
-        expect { resource.x nil }.to raise_error Chef::Exceptions::ValidationFailed
+      it "value nil sets to the default" do
+        # this mildly complicated because the default of a name property is a lazy evaluator to the actual resource.name
+        expect(resource.x nil).to be_a(Chef::DelayedEvaluator)
       end
     end
 
@@ -630,8 +631,54 @@ describe "Chef::Resource.property validation" do
         expect(resource.x 1).to eq 1
         expect(resource.x).to eq 1
       end
-      it "value nil is invalid" do
-        expect { resource.x nil }.to raise_error Chef::Exceptions::ValidationFailed
+      it "value nil sets the default" do
+        expect(resource.x nil).to eq 10
+        expect(resource.x).to eq 10
+      end
+    end
+  end
+
+  context "nil setting default" do
+    with_property ":x, String" do
+      it "if x is not specified, the default is returned" do
+        expect(resource.x).to eq nil
+      end
+      it "value '2' is valid" do
+        expect(resource.x "2").to eq "2"
+        expect(resource.x).to eq "2"
+      end
+      it "value nil sets the default" do
+        resource.x "2"
+        expect(resource.x nil).to eq nil
+        expect(resource.x).to eq nil
+      end
+    end
+    with_property ":x, String, default: '1'" do
+      it "if x is not specified, the default is returned" do
+        expect(resource.x).to eq "1"
+      end
+      it "value '2' is valid" do
+        expect(resource.x "2").to eq "2"
+        expect(resource.x).to eq "2"
+      end
+      it "value nil sets the default" do
+        resource.x "2"
+        expect(resource.x nil).to eq "1"
+        expect(resource.x).to eq "1"
+      end
+    end
+    with_property ":x, [ String, nil ] , default: '1'" do
+      it "if x is not specified, the default is returned" do
+        expect(resource.x).to eq "1"
+      end
+      it "value '2' is valid" do
+        expect(resource.x "2").to eq "2"
+        expect(resource.x).to eq "2"
+      end
+      it "value nil sets to nil" do
+        resource.x "2"
+        expect(resource.x nil).to eq nil
+        expect(resource.x).to eq nil
       end
     end
   end

data/spec/unit/provider/apt_repository_spec.rb

@@ -47,7 +47,6 @@ EOF
 describe Chef::Provider::AptRepository do
   let(:new_resource) { Chef::Resource::AptRepository.new("multiverse") }
 
-  let(:shellout_env) { { env: { "LANG" => "en_US", "LANGUAGE" => "en_US" } } }
   let(:provider) do
     node = Chef::Node.new
     events = Chef::EventDispatch::Dispatcher.new
@@ -60,15 +59,22 @@ describe Chef::Provider::AptRepository do
   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)
-    r
+    double("shell_out", stdout: APT_KEY_FINGER, exitstatus: 0, error?: false)
   end
 
   let(:gpg_finger) do
-    r = double("Mixlib::ShellOut", stdout: GPG_FINGER, exitstatus: 0, live_stream: true)
-    allow(r).to receive(:run_command)
-    r
+    double("shell_out", stdout: GPG_FINGER, exitstatus: 0, error?: false)
+  end
+
+  let(:gpg_shell_out_success) do
+    double("shell_out", :stdout => "pub  2048R/7BD9BF62 2011-08-19 nginx signing key <signing-key@nginx.com>",
+                        :exitstatus => 0, :error? => false)
+  end
+
+  let(:gpg_shell_out_failure) do
+    double("shell_out", :stderr => "gpg: no valid OpenPGP data found.\n
+                                    gpg: processing message failed: eof",
+                        :exitstatus => 1, :error? => true)
   end
 
   let(:apt_fingerprints) do
@@ -83,35 +89,39 @@ C5986B4F1257FFA86632CBA746181433FBB75451
   end
 
   describe "#is_key_id?" do
-    it "should detect a key" do
+    it "detects a key" do
       expect(provider.is_key_id?("A4FF2279")).to be_truthy
     end
-    it "should detect a key with a hex signifier" do
+    it "detects a key with a hex signifier" do
       expect(provider.is_key_id?("0xA4FF2279")).to be_truthy
     end
-    it "should reject a key with the wrong length" do
+    it "rejects a key with the wrong length" do
       expect(provider.is_key_id?("4FF2279")).to be_falsey
     end
-    it "should reject a key with non-hex characters" do
+    it "rejects a key with non-hex characters" do
       expect(provider.is_key_id?("A4KF2279")).to be_falsey
     end
   end
 
   describe "#extract_fingerprints_from_cmd" do
-    before do
-      expect(Mixlib::ShellOut).to receive(:new).and_return(apt_key_finger)
-    end
-
-    it "should run the desired command" do
-      expect(apt_key_finger).to receive(:run_command)
+    it "runs the desired command" do
+      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
       provider.extract_fingerprints_from_cmd(apt_key_finger_cmd)
     end
 
-    it "should return a list of key fingerprints" do
+    it "returns a list of key fingerprints" do
+      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
       expect(provider.extract_fingerprints_from_cmd(apt_key_finger_cmd)).to eql(apt_fingerprints)
     end
   end
 
+  describe "#cookbook_name" do
+    it "returns 'test' when the cookbook property is set" do
+      new_resource.cookbook("test")
+      expect(provider.cookbook_name).to eq("test")
+    end
+  end
+
   describe "#no_new_keys?" do
     before do
       allow(provider).to receive(:extract_fingerprints_from_cmd).with(apt_key_finger_cmd).and_return(apt_fingerprints)
@@ -119,14 +129,14 @@ C5986B4F1257FFA86632CBA746181433FBB75451
 
     let(:file) { "/tmp/remote-gpg-keyfile" }
 
-    it "should match a set of keys" do
+    it "matches a set of keys" do
       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
+    it "notices missing keys" do
       allow(provider).to receive(:extract_fingerprints_from_cmd)
         .with("gpg --with-fingerprint --with-colons #{file}")
         .and_return(%w{ F36A89E33CC1BD0F71079007327574EE02A818DD })
@@ -134,11 +144,71 @@ C5986B4F1257FFA86632CBA746181433FBB75451
     end
   end
 
+  describe "#key_type" do
+    it "returns :remote_file with an http URL" do
+      expect(provider.key_type("https://www.chef.io/key")).to eq(:remote_file)
+    end
+
+    it "returns :cookbook_file with a chef managed file" do
+      expect(provider).to receive(:has_cookbook_file?).and_return(true)
+      expect(provider.key_type("/foo/bar.key")).to eq(:cookbook_file)
+    end
+
+    it "throws exception if an unknown file specified" do
+      expect(provider).to receive(:has_cookbook_file?).and_return(false)
+      expect { provider.key_type("/foo/bar.key") }.to raise_error(Chef::Exceptions::FileNotFound)
+    end
+  end
+
+  describe "#keyserver_install_cmd" do
+    it "returns keyserver install command" do
+      expect(provider.keyserver_install_cmd("ABC", "gpg.mit.edu")).to eq("apt-key adv --recv --keyserver hkp://gpg.mit.edu:80 ABC")
+    end
+
+    it "uses proxy if key_proxy property is set" do
+      new_resource.key_proxy("proxy.mycorp.dmz:3128")
+      expect(provider.keyserver_install_cmd("ABC", "gpg.mit.edu")).to eq("apt-key adv --recv --keyserver-options http-proxy=proxy.mycorp.dmz:3128 --keyserver hkp://gpg.mit.edu:80 ABC")
+    end
+
+    it "properly handles keyservers passed with hkp:// URIs" do
+      expect(provider.keyserver_install_cmd("ABC", "hkp://gpg.mit.edu")).to eq("apt-key adv --recv --keyserver hkp://gpg.mit.edu ABC")
+    end
+  end
+
+  describe "#is_ppa_url" do
+    it "returns true if the URL starts with ppa:" do
+      expect(provider.is_ppa_url?("ppa://example.com")).to be_truthy
+    end
+
+    it "returns false if the URL does not start with ppa:" do
+      expect(provider.is_ppa_url?("example.com")).to be_falsey
+    end
+  end
+
+  describe "#repo_components" do
+    it "returns 'main' if a PPA and components property not set" do
+      expect(provider).to receive(:is_ppa_url?).and_return(true)
+      expect(provider.repo_components).to eq("main")
+    end
+
+    it "returns components property if a PPA and components is set" do
+      new_resource.components(["foo"])
+      expect(provider).to receive(:is_ppa_url?).and_return(true)
+      expect(provider.repo_components).to eq(["foo"])
+    end
+
+    it "returns components property if not a PPA" do
+      new_resource.components(["foo"])
+      expect(provider).to receive(:is_ppa_url?).and_return(false)
+      expect(provider.repo_components).to eq(["foo"])
+    end
+  end
+
   describe "#install_ppa_key" do
     let(:url) { "https://launchpad.net/api/1.0/~chef/+archive/main" }
     let(:key) { "C5986B4F1257FFA86632CBA746181433FBB75451" }
 
-    it "should get a key" do
+    it "gets a key" do
       simples = double("HTTP")
       allow(simples).to receive(:get).and_return("\"#{key}\"")
       expect(Chef::HTTP::Simple).to receive(:new).with(url).and_return(simples)
@@ -148,42 +218,37 @@ C5986B4F1257FFA86632CBA746181433FBB75451
   end
 
   describe "#make_ppa_url" do
-    it "should ignore non-ppa repositories" do
-      expect(provider.make_ppa_url("some_string")).to be_nil
-    end
-
-    it "should create a URL" do
+    it "creates a URL" do
       expect(provider).to receive(:install_ppa_key).with("chef", "main").and_return(true)
       expect(provider.make_ppa_url("ppa:chef/main")).to eql("http://ppa.launchpad.net/chef/main/ubuntu")
     end
   end
 
   describe "#build_repo" do
-    it "should create a repository string" do
+    it "creates a repository string" do
       target = %Q{deb      "http://test/uri" unstable main\n}
       expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil)).to eql(target)
     end
 
-    it "should create a repository string with no distribution" do
+    it "creates a repository string with no distribution" do
       target = %Q{deb      "http://test/uri" main\n}
       expect(provider.build_repo("http://test/uri", nil, "main", false, nil)).to eql(target)
     end
 
-    it "should create a repository string with source" do
+    it "creates a repository string with source" do
       target = %Q{deb      "http://test/uri" unstable main\ndeb-src  "http://test/uri" unstable main\n}
       expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, true)).to eql(target)
     end
 
-    it "should create a repository string with options" do
+    it "creates a repository string with options" do
       target = %Q{deb      [trusted=yes] "http://test/uri" unstable main\n}
       expect(provider.build_repo("http://test/uri", "unstable", "main", true, nil)).to eql(target)
     end
 
-    it "should handle a ppa repo" do
+    it "handles a ppa repo" do
       target = %Q{deb      "http://ppa.launchpad.net/chef/main/ubuntu" unstable main\n}
       expect(provider).to receive(:make_ppa_url).with("ppa:chef/main").and_return("http://ppa.launchpad.net/chef/main/ubuntu")
       expect(provider.build_repo("ppa:chef/main", "unstable", "main", false, nil)).to eql(target)
     end
   end
-
 end