chef 13.3.42-universal-mingw32 → 13.4.19-universal-mingw32

data/spec/unit/node/immutable_collections_spec.rb

@@ -21,10 +21,10 @@ require "chef/node/immutable_collections"
 
 describe Chef::Node::ImmutableMash do
   before do
-    @data_in = { :top => { :second_level => "some value" },
+    @data_in = { "top" => { "second_level" => "some value" },
                  "top_level_2" => %w{array of values},
-                 :top_level_3 => [{ :hash_array => 1, :hash_array_b => 2 }],
-                 :top_level_4 => { :level2 => { :key => "value" } },
+                 "top_level_3" => [{ "hash_array" => 1, "hash_array_b" => 2 }],
+                 "top_level_4" => { "level2" => { "key" => "value" } },
     }
     @immutable_mash = Chef::Node::ImmutableMash.new(@data_in)
   end
@@ -54,6 +54,14 @@ describe Chef::Node::ImmutableMash do
     expect(@immutable_mash[:top_level_4][:level2]).to be_a(Chef::Node::ImmutableMash)
   end
 
+  # we only ever absorb VividMashes from other precedence levels, which already have
+  # been coerced to only have string keys, so we do not need to do that work twice (performance).
+  it "does not call convert_value like Mash/VividMash" do
+    @mash = Chef::Node::ImmutableMash.new({ test: "foo", "test2" => "bar" })
+    expect(@mash[:test]).to eql("foo")
+    expect(@mash["test2"]).to eql("bar")
+  end
+
   describe "to_hash" do
     before do
       @copy = @immutable_mash.to_hash
@@ -168,7 +176,7 @@ describe Chef::Node::ImmutableArray do
 
   before do
     @immutable_array = Chef::Node::ImmutableArray.new(%w{foo bar baz} + Array(1..3) + [nil, true, false, [ "el", 0, nil ] ])
-    immutable_mash = Chef::Node::ImmutableMash.new({ :m => "m" })
+    immutable_mash = Chef::Node::ImmutableMash.new({ "m" => "m" })
     @immutable_nested_array = Chef::Node::ImmutableArray.new(["level1", @immutable_array, immutable_mash])
   end
 

data/spec/unit/node_spec.rb

@@ -337,6 +337,13 @@ describe Chef::Node do
         node.override_unless[:decontamination] = "foo"
         expect(node.override[:decontamination]).to eql("foo")
       end
+
+      it "consume_attributes does not exhibit chef/chef/issues/6302 bug" do
+        node.normal["a"]["r1"] = nil
+        node.consume_attributes({ "a" => { "r2" => nil } })
+        expect(node["a"]["r1"]).to be_nil
+        expect(node["a"]["r2"]).to be_nil
+      end
     end
 
     describe "default attributes" do

data/spec/unit/provider/git_spec.rb

@@ -83,6 +83,61 @@ describe Chef::Provider::Git do
     expect(@provider.new_resource).to equal(@resource)
   end
 
+  context "cast git version into gem version object" do
+    it "returns correct version with standard git" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version 2.14.1"))
+      expect(@provider.git_gem_version).to eq Gem::Version.new("2.14.1")
+    end
+
+    it "returns correct version with Apple git" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version 2.11.0 (Apple Git-81)"))
+      expect(@provider.git_gem_version).to eq Gem::Version.new("2.11.0")
+    end
+
+    it "maintains deprecated method name" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version 1.2.3"))
+      expect(@provider.git_minor_version).to eq Gem::Version.new("1.2.3")
+    end
+
+    it "does not know how to handle other version" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version home-grown-git-99"))
+      expect(@provider.git_gem_version).to be_nil
+    end
+
+    it "determines single branch option when it fails to parse git version" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version home-grown-git-99"))
+      expect(@provider.git_has_single_branch_option?).to be false
+    end
+
+    it "determines single branch option as true when it parses git version and version is large" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version 1.8.0"))
+      expect(@provider.git_has_single_branch_option?).to be true
+    end
+
+    it "determines single branch option as false when it parses git version and version is small" do
+      expect(@provider).to receive(:shell_out!)
+        .with("git --version", log_tag: "git[web2.0 app]")
+        .and_return(double("ShellOut result", stdout: "git version 1.7.4"))
+      expect(@provider.git_has_single_branch_option?).to be false
+    end
+
+    it "is compatible with git in travis" do
+      expect(@provider.git_gem_version).to be > Gem::Version.new("1.0")
+    end
+  end
+
   context "resolving revisions to a SHA" do
 
     before do

data/spec/unit/provider/ifconfig/redhat_spec.rb

@@ -31,6 +31,10 @@ describe Chef::Provider::Ifconfig::Redhat do
     @new_resource.metric "1"
     @new_resource.mtu "1500"
     @new_resource.device "eth0"
+    @new_resource.ethtool_opts "-A eth0 autoneg off"
+    @new_resource.bonding_opts "mode=active-backup miimon=100"
+    @new_resource.master "bond0"
+    @new_resource.slave "yes"
     @provider = Chef::Provider::Ifconfig::Redhat.new(@new_resource, @run_context)
     @current_resource = Chef::Resource::Ifconfig.new("10.0.0.1", @run_context)
 
@@ -52,6 +56,10 @@ describe Chef::Provider::Ifconfig::Redhat do
         expect(arg).to match(/^\s*DEVICE=eth0\s*$/)
         expect(arg).to match(/^\s*IPADDR=10\.0\.0\.1\s*$/)
         expect(arg).to match(/^\s*NETMASK=255\.255\.254\.0\s*$/)
+        expect(arg).to match(/^\s*ETHTOOL_OPTS="-A eth0 autoneg off"\s*$/)
+        expect(arg).to match(/^\s*BONDING_OPTS="mode=active-backup miimon=100"\s*$/)
+        expect(arg).to match(/^\s*MASTER=bond0\s*$/)
+        expect(arg).to match(/^\s*SLAVE=yes\s*$/)
       end
       expect(@config).to receive(:run_action).with(:create)
       expect(@config).to receive(:updated?).and_return(true)

data/spec/unit/provider/remote_file/fetcher_spec.rb

@@ -27,6 +27,7 @@ describe Chef::Provider::RemoteFile::Fetcher do
   describe "when passed a network share" do
     before do
       expect(Chef::Provider::RemoteFile::NetworkFile).to receive(:new).and_return(fetcher_instance)
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
     end
 
     context "when host is a name" do

data/spec/unit/provider/remote_file/network_file_spec.rb

@@ -1,3 +1,4 @@
+
 #
 # Author:: Jay Mundrawala (<jdm@chef.io>)
 # Copyright:: Copyright 2015-2016, Chef Software
@@ -19,7 +20,6 @@
 require "spec_helper"
 
 describe Chef::Provider::RemoteFile::NetworkFile do
-
   let(:source) { "\\\\foohost\\fooshare\\Foo.tar.gz" }
 
   let(:new_resource) { Chef::Resource::RemoteFile.new("network file (new_resource)") }
@@ -30,10 +30,15 @@ describe Chef::Provider::RemoteFile::NetworkFile do
 
     let(:tempfile) { double("Tempfile", :path => "/tmp/foo/bar/Foo.tar.gz", :close => nil) }
     let(:chef_tempfile) { double("Chef::FileContentManagement::Tempfile", :tempfile => tempfile) }
+    let(:source_file) { double("::File", :read => nil) }
+
+    before do
+      allow(fetcher).to receive(:node).and_return({ "platform_family" => "windows" })
+    end
 
     it "stages the local file to a temporary file" do
       expect(Chef::FileContentManagement::Tempfile).to receive(:new).with(new_resource).and_return(chef_tempfile)
-      expect(::FileUtils).to receive(:cp).with(source, tempfile.path)
+      expect(::File).to receive(:open).with(source, "rb").and_return(source_file)
       expect(tempfile).to receive(:close)
 
       result = fetcher.fetch

data/spec/unit/provider/service/macosx_spec.rb

@@ -74,7 +74,10 @@ XML
           let(:service_label) { "io.redis.redis-server" }
           before do
             allow(Dir).to receive(:glob).and_return([plist], [])
-            allow(Etc).to receive(:getlogin).and_return("igor")
+            @stat = double("File::Stat", { :uid => 501 })
+            allow(File).to receive(:stat).and_return(@stat)
+            @getpwuid = double("Etc::Passwd", { :name => "mikedodge04" })
+            allow(Etc).to receive(:getpwuid).and_return(@getpwuid)
             allow(node).to receive(:[]).with("platform_version").and_return(platform_version)
             cmd = "launchctl list #{service_label}"
             allow(provider).to receive(:shell_out_with_systems_locale).

data/spec/unit/provider/windows_path_spec.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Nimisha Sharad (<nimisha.sharad@msystechnologies.com>)
+# Copyright:: Copyright 2008-2017, 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::WindowsPath, :windows_only do
+  before(:all) do
+    @old_path = ENV["PATH"].dup
+  end
+
+  after(:all) do
+    ENV["PATH"] = @old_path
+  end
+
+  let(:new_resource) { Chef::Resource::WindowsPath.new("some_path") }
+
+  let(:provider) do
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    Chef::Provider::WindowsPath.new(new_resource, run_context)
+  end
+
+  describe "#load_current_resource" do
+    it "returns a current_resource" do
+      expect(provider.load_current_resource).to be_kind_of(Chef::Resource::WindowsPath)
+    end
+
+    it "sets the path of current resource as the path of new resource" do
+      current_resource = provider.load_current_resource
+      expect(current_resource.path).to eq("some_path")
+    end
+  end
+
+  describe "#action_add" do
+    it "uses env resource to add 'path' environment variable" do
+      allow(provider).to receive(:expand_env_vars)
+      expect(provider).to receive(:declare_resource).with(:env, "path")
+      provider.run_action(:add)
+    end
+  end
+
+  describe "#action_remove" do
+    it "uses env resource to remove 'path' environment variable" do
+      allow(provider).to receive(:expand_env_vars)
+      expect(provider).to receive(:declare_resource).with(:env, "path")
+      provider.run_action(:remove)
+    end
+  end
+end

data/spec/unit/resource/windows_path_spec.rb

@@ -0,0 +1,38 @@
+#
+# Author:: Nimisha Sharad (<nimisha.sharad@msystechnologies.com>)
+# Copyright:: Copyright 2008-2017, 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::Resource::WindowsPath do
+  subject { Chef::Resource::WindowsPath.new("some_path") }
+
+  it { is_expected.to be_a_kind_of(Chef::Resource) }
+  it { is_expected.to be_a_instance_of(Chef::Resource::WindowsPath) }
+
+  it "sets resource name as :windows_path" do
+    expect(subject.resource_name).to eql(:windows_path)
+  end
+
+  it "sets the path as it's name" do
+    expect(subject.path).to eql("some_path")
+  end
+
+  it "sets the default action as :add" do
+    expect(subject.action).to eql(:add)
+  end
+end

data/spec/unit/resource_spec.rb

@@ -377,6 +377,14 @@ describe Chef::Resource do
         expect(resource.to_text).to match(/foo "\*sensitive value suppressed\*"/)
       end
     end
+
+    context "when property is required" do
+      it "does not propagate vailidation errors" do
+        resource_class = Class.new(Chef::Resource) { property :foo, String, required: true }
+        resource = resource_class.new("required_property_tests")
+        expect { resource.to_text }.to_not raise_error Chef::Exceptions::ValidationFailed
+      end
+    end
   end
 
   describe "self.resource_name" do

data/spec/unit/shell/shell_session_spec.rb

@@ -47,119 +47,143 @@ describe Shell::ShellSession do
 end
 
 describe Shell::ClientSession do
+  let(:json_attribs) { { "a" => "b" } }
+  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:node) { Chef::Node.build("foo") }
+  let(:session) { Shell::ClientSession.instance }
+  let(:client) do
+    double("Chef::Client.new",
+      :run_ohai => true,
+      :load_node => true,
+      :build_node => true,
+      :register => true,
+      :sync_cookbooks => {}
+    )
+  end
+
   before do
     Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
-    @chef_rest = double("Chef::ServerAPI")
-    @session = Shell::ClientSession.instance
-    @node = Chef::Node.build("foo")
-    @session.node = @node
-    @client = double("Chef::Client.new",
-                     :run_ohai => true,
-                     :load_node => true,
-                     :build_node => true,
-                     :register => true,
-                     :sync_cookbooks => {})
+    session.node = node
+    session.json_configuration = json_attribs
   end
 
   it "builds the node's run_context with the proper environment" do
-    @session.instance_variable_set(:@client, @client)
-    @expansion = Chef::RunList::RunListExpansion.new(@node.chef_environment, [])
+    session.instance_variable_set(:@client, client)
+    expansion = Chef::RunList::RunListExpansion.new(node.chef_environment, [])
 
-    expect(@node.run_list).to receive(:expand).with(@node.chef_environment).and_return(@expansion)
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(@chef_rest)
-    @session.rebuild_context
+    expect(node.run_list).to receive(:expand).with(node.chef_environment).and_return(expansion)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
+    session.rebuild_context
   end
 
   it "passes the shell CLI args to the client" do
-    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
-    @session.send(:rebuild_node)
+    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
+    session.send(:rebuild_node)
   end
 
 end
 
 describe Shell::SoloSession do
+  let(:json_attribs) { { "a" => "b" } }
+  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:node) { Chef::Node.build("foo") }
+  let(:session) { Shell::SoloSession.instance }
+  let(:client) do
+    double("Chef::Client.new",
+      :run_ohai => true,
+      :load_node => true,
+      :build_node => true,
+      :register => true,
+      :sync_cookbooks => {}
+    )
+  end
+
   before do
     Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
-    @chef_rest = double("Chef::ServerAPI")
-    @session = Shell::SoloSession.instance
-    @node = Chef::Node.build("foo")
-    @session.node = @node
-    @client = double("Chef::Client.new",
-                     :run_ohai => true,
-                     :load_node => true,
-                     :build_node => true,
-                     :register => true,
-                     :sync_cookbooks => {})
+    session.node = node
+    session.json_configuration = json_attribs
   end
 
   it "builds the node's run_context with the proper environment" do
-    @session.instance_variable_set(:@client, @client)
-    @expansion = Chef::RunList::RunListExpansion.new(@node.chef_environment, [])
+    session.instance_variable_set(:@client, client)
+    expansion = Chef::RunList::RunListExpansion.new(node.chef_environment, [])
 
-    expect(@node.run_list).to receive(:expand).with(@node.chef_environment).and_return(@expansion)
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(@chef_rest)
-    @session.rebuild_context
+    expect(node.run_list).to receive(:expand).with(node.chef_environment).and_return(expansion)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
+    session.rebuild_context
   end
 
   it "passes the shell CLI args to the client" do
-    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
-    @session.send(:rebuild_node)
+    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
+    session.send(:rebuild_node)
   end
 
 end
 
 describe Shell::StandAloneSession do
+  let(:json_attribs) { { "a" => "b" } }
+  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:session) { Shell::StandAloneSession.instance }
+  let(:client) do
+    double("Chef::Client.new",
+      :run_ohai => true,
+      :load_node => true,
+      :build_node => true,
+      :register => true,
+      :sync_cookbooks => {}
+    )
+  end
+  let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+
   before do
     Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
-    @session = Shell::StandAloneSession.instance
-    @node = @session.node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = @session.run_context = Chef::RunContext.new(@node, {}, @events)
-    @recipe = @session.recipe = Chef::Recipe.new(nil, nil, @run_context)
-    Shell::Extensions.extend_context_recipe(@recipe)
+    session.node = node
+    session.json_configuration = json_attribs
+    session.run_context = run_context
+    session.recipe = recipe
+    Shell::Extensions.extend_context_recipe(recipe)
   end
 
   it "has a run_context" do
-    expect(@session.run_context).to equal(@run_context)
+    expect(session.run_context).to equal(run_context)
   end
 
   it "returns a collection based on it's standalone recipe file" do
-    expect(@session.resource_collection).to eq(@recipe.run_context.resource_collection)
+    expect(session.resource_collection).to eq(recipe.run_context.resource_collection)
   end
 
   it "gives nil for the definitions (for now)" do
-    expect(@session.definitions).to be_nil
+    expect(session.definitions).to be_nil
   end
 
   it "gives nil for the cookbook_loader" do
-    expect(@session.cookbook_loader).to be_nil
+    expect(session.cookbook_loader).to be_nil
   end
 
   it "runs chef with the standalone recipe" do
-    allow(@session).to receive(:node_built?).and_return(true)
+    allow(session).to receive(:node_built?).and_return(true)
     allow(Chef::Log).to receive(:level)
     chef_runner = double("Chef::Runner.new", :converge => :converged)
     # pre-heat resource collection cache
-    @session.resource_collection
+    session.resource_collection
 
-    expect(Chef::Runner).to receive(:new).with(@session.recipe.run_context).and_return(chef_runner)
-    expect(@recipe.run_chef).to eq(:converged)
+    expect(Chef::Runner).to receive(:new).with(session.recipe.run_context).and_return(chef_runner)
+    expect(recipe.run_chef).to eq(:converged)
   end
 
   it "passes the shell CLI args to the client" do
-    @client = double("Chef::Client.new",
-                     :run_ohai => true,
-                     :load_node => true,
-                     :build_node => true,
-                     :register => true,
-                     :sync_cookbooks => {})
-    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
-    @session.send(:rebuild_node)
+    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
+    session.send(:rebuild_node)
   end
 
 end
 
 describe Shell::SoloLegacySession do
+  let(:json_attribs) { { "a" => "b" } }
+
   before do
     Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
     Chef::Config[:shell_solo] = true
@@ -219,8 +243,8 @@ describe Shell::SoloLegacySession do
                      :build_node => true,
                      :register => true,
                      :sync_cookbooks => {})
-    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
+    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(@client)
+    @session.json_configuration = json_attribs
     @session.send(:rebuild_node)
   end
-
 end