chef 17.0.242 → 17.1.35

data/spec/integration/client/client_spec.rb

@@ -349,26 +349,6 @@ describe "chef-client" do
       expect(result.stdout).to include("Run List is [recipe[x::default]]")
       result.error!
     end
-
-    it "should complete with success when using --profile-ruby and output a profile file", :not_supported_on_aix do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z --profile-ruby", cwd: chef_dir)
-      result.error!
-      expect(File.exist?(path_to("config/local-mode-cache/cache/graph_profile.out"))).to be true
-    end
-
-    it "doesn't produce a profile when --profile-ruby is not present" do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z", cwd: chef_dir)
-      result.error!
-      expect(File.exist?(path_to("config/local-mode-cache/cache/graph_profile.out"))).to be false
-    end
   end
 
   when_the_repository "has a cookbook that outputs some node attributes" do

data/spec/integration/recipes/unified_mode_spec.rb

@@ -874,4 +874,74 @@ describe "Unified Mode" do
       result.error!
     end
   end
+
+  when_the_repository "has a resource that uses edit_resource to create a subresource" do
+    before do
+      directory "cookbooks/x" do
+        file "recipes/default.rb", <<~EOM
+          my_resource "doit"
+        EOM
+
+        file "resources/my_resource.rb", <<~EOM
+          unified_mode true
+          provides :my_resource
+
+          action :doit do
+            edit_resource(:log, "name") do
+              message "GOOD"
+              level :warn
+            end
+          end
+        EOM
+      end
+    end
+
+    it "recipes should still have a compile/converge mode" do
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to("cookbooks")}"
+        log_level :warn
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" --no-color -F doc -o 'x::default'", cwd: chef_dir)
+      # in recipe mode we should still run normally with a compile/converge mode
+      expect(result.stdout).to include("GOOD")
+      result.error!
+    end
+  end
+
+  when_the_repository "has a resource that uses find_resource to create a subresource" do
+    before do
+      directory "cookbooks/x" do
+        file "recipes/default.rb", <<~EOM
+          my_resource "doit"
+        EOM
+
+        file "resources/my_resource.rb", <<~EOM
+          unified_mode true
+          provides :my_resource
+
+          action :doit do
+            find_resource(:log, "name") do
+              message "GOOD"
+              level :warn
+            end
+          end
+        EOM
+      end
+    end
+
+    it "recipes should still have a compile/converge mode" do
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to("cookbooks")}"
+        log_level :warn
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" --no-color -F doc -o 'x::default'", cwd: chef_dir)
+      # in recipe mode we should still run normally with a compile/converge mode
+      expect(result.stdout).to include("GOOD")
+      result.error!
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -24,6 +24,9 @@ module Shell
   IRB = nil unless defined? IRB
 end
 
+# show the deprecation warnings
+Warning[:deprecated] = true
+
 $LOAD_PATH.unshift File.expand_path("..", __dir__)
 
 $LOAD_PATH.unshift File.expand_path("../chef-config/lib", __dir__)

data/spec/support/chef_helpers.rb

@@ -43,7 +43,7 @@ end
 # This is a helper to canonicalize paths that we're using in the file
 # tests.
 def canonicalize_path(path)
-  windows? ? path.tr("/", '\\') : path
+  windows? ? path.tr("/", "\\") : path
 end
 
 # Makes a temp directory with a canonical path on any platform.

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

@@ -58,7 +58,7 @@ shared_context "a command that can be executed as an alternate user" do
   include Chef::Mixin::ShellOut
 
   before do
-    shell_out!("icacls \"#{script_output_dir.tr("/", '\\')}\" /grant \"authenticated users:(F)\"")
+    shell_out!("icacls \"#{script_output_dir.tr("/", "\\")}\" /grant \"authenticated users:(F)\"")
   end
 
   after do

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

@@ -0,0 +1,37 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: AJ Christensen (<aj@junglist.gen.nz>)
+# Author:: Ho-Sheng Hsiao (<hosh@chef.io>)
+# Copyright:: Copyright (c) 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.
+#
+module SpecHelpers
+  module Knife
+    def redefine_argv(value)
+      Object.send(:remove_const, :ARGV)
+      Object.send(:const_set, :ARGV, value)
+    end
+
+    def with_argv(*argv)
+      original_argv = ARGV
+      redefine_argv(argv.flatten)
+      begin
+        yield
+      ensure
+        redefine_argv(original_argv)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright (c) 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 "chef/config"
+require "chef/knife"
+require "chef/application/knife"
+require "logger"
+require "chef/log"
+require "chef/chef_fs/file_system_cache"
+
+module KnifeSupport
+  DEBUG = ENV["DEBUG"]
+  def knife(*args, input: nil, instance_filter: nil)
+    # Allow knife('role from file roles/blah.json') rather than requiring the
+    # arguments to be split like knife('role', 'from', 'file', 'roles/blah.json')
+    # If any argument will have actual spaces in it, the long form is required.
+    # (Since knife commands always start with the command name, and command
+    # names with spaces are always multiple args, this is safe.)
+    if args.length == 1
+      args = args[0].split(/\s+/)
+    end
+
+    # Make output stable
+    Chef::Config[:concurrency] = 1
+
+    # Work on machines where we can't access /var
+    Dir.mktmpdir("checksums") do |checksums_cache_dir|
+      Chef::Config[:syntax_check_cache_path] = checksums_cache_dir
+
+      # This is Chef::Knife.run without load_commands--we'll load stuff
+      # ourselves, thank you very much
+      stdout = StringIO.new
+      stderr = StringIO.new
+
+      stdin = if input
+                StringIO.new(input)
+              else
+                STDIN
+              end
+
+      begin
+        puts "knife: #{args.join(" ")}" if DEBUG
+        subcommand_class = Chef::Knife.subcommand_class_from(args)
+        subcommand_class.options = Chef::Application::Knife.options.merge(subcommand_class.options)
+        subcommand_class.load_deps
+        instance = subcommand_class.new(args)
+
+        # Load configs
+        instance.merge_configs
+
+        # Capture stdout/stderr
+        instance.ui = Chef::Knife::UI.new(stdout, stderr, stdin, instance.config.merge(disable_editing: true))
+
+        # Don't print stuff
+        Chef::Config[:verbosity] = ( DEBUG ? 2 : 0 )
+        instance.config[:config_file] = File.join(CHEF_SPEC_DATA, "null_config.rb")
+
+        # Ensure the ChefFS cache is empty
+        Chef::ChefFS::FileSystemCache.instance.reset!
+
+        # Configure chef with a (mostly) blank knife.rb
+        # We set a global and then mutate it in our stub knife.rb so we can be
+        # extra sure that we're not loading someone's real knife.rb and then
+        # running test scenarios against a real chef server. If things don't
+        # smell right, abort.
+
+        # To ensure that we don't pick up a user's credentials file we lie through our teeth about
+        # it's existence.
+        allow(File).to receive(:file?).and_call_original
+        allow(File).to receive(:file?).with(File.expand_path("~/.chef/credentials")).and_return(false)
+
+        # Set a canary that is modified by the default null_config.rb config file.
+        $__KNIFE_INTEGRATION_FAILSAFE_CHECK = "ole"
+
+        # Allow tweaking the knife instance before configuration.
+        instance_filter.call(instance) if instance_filter
+
+        instance.configure_chef
+
+        # The canary is incorrect, meaning the normal null_config.rb didn't run. Something is wrong.
+        unless $__KNIFE_INTEGRATION_FAILSAFE_CHECK == "ole ole"
+          raise Exception, "Potential misconfiguration of integration tests detected. Aborting test."
+        end
+
+        logger = Logger.new(stderr)
+        logger.formatter = proc { |severity, datetime, progname, msg| "#{severity}: #{msg}\n" }
+        Chef::Log.use_log_devices([logger])
+        Chef::Log.level = ( DEBUG ? :debug : :warn )
+        Chef::Log::Formatter.show_time = false
+
+        instance.run_with_pretty_exceptions(true)
+
+        exit_code = 0
+
+      # This is how rspec catches exit()
+      rescue SystemExit => e
+        exit_code = e.status
+      ensure
+        Chef::Config.delete(:syntax_check_cache_path)
+        Chef::Config.delete(:concurrency)
+      end
+
+      KnifeResult.new(stdout.string, stderr.string, exit_code)
+    end
+  end
+
+  class KnifeResult
+
+    include ::RSpec::Matchers
+
+    def initialize(stdout, stderr, exit_code)
+      @stdout = stdout
+      @stderr = stderr
+      @exit_code = exit_code
+    end
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :exit_code
+
+    def should_fail(*args)
+      expected = {}
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          expected.merge!(arg)
+        elsif arg.is_a?(Integer)
+          expected[:exit_code] = arg
+        else
+          expected[:stderr] = arg
+        end
+      end
+      expected[:exit_code] = 1 unless expected[:exit_code]
+      should_result_in(expected)
+    end
+
+    def should_succeed(*args)
+      expected = {}
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          expected.merge!(arg)
+        else
+          expected[:stdout] = arg
+        end
+      end
+      should_result_in(expected)
+    end
+
+    private
+
+    def should_result_in(expected)
+      expected[:stdout] = "" unless expected[:stdout]
+      expected[:stdout] = expected[:stdout].is_a?(String) ? expected[:stdout].gsub(/[ \t\f\v]+$/, "") : expected[:stdout]
+      expected[:stderr] = "" unless expected[:stderr]
+      expected[:stderr] = expected[:stderr].is_a?(String) ? expected[:stderr].gsub(/[ \t\f\v]+$/, "") : expected[:stderr]
+      expected[:exit_code] = 0 unless expected[:exit_code]
+      # TODO make this go away
+      stderr_actual = @stderr.sub(/^WARNING: No knife configuration file found\n/, "")
+      stderr_actual = stderr_actual.gsub(/[ \t\f\v]+$/, "")
+      stdout_actual = @stdout
+      stdout_actual = stdout_actual.gsub(/[ \t\f\v]+$/, "")
+      if ChefUtils.windows?
+        stderr_actual = stderr_actual.gsub("\r\n", "\n")
+        stdout_actual = stdout_actual.gsub("\r\n", "\n")
+      end
+      if expected[:stderr].is_a?(Regexp)
+        expect(stderr_actual).to match(expected[:stderr])
+      else
+        expect(stderr_actual).to eq(expected[:stderr])
+      end
+      expect(@exit_code).to eq(expected[:exit_code])
+      if expected[:stdout].is_a?(Regexp)
+        expect(stdout_actual).to match(expected[:stdout])
+      else
+        expect(stdout_actual).to eq(expected[:stdout])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+#
+# Author:: Tyler Cloke (<tyler@chef.io>)
+# Copyright:: Copyright (c) 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.
+#
+
+shared_examples_for "mandatory field missing" do
+  context "when field is nil" do
+    before do
+      knife.name_args = name_args
+    end
+
+    it "exits 1" do
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "prints the usage" do
+      expect(knife).to receive(:show_usage)
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "prints a relevant error message" do
+      expect { knife.run }.to raise_error(SystemExit)
+      expect(stderr.string).to match(/You must specify a #{fieldname}/)
+    end
+  end
+end

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

@@ -36,7 +36,7 @@ end
 
 # forwards-vs-reverse slashes on windows sucks
 def windows_path
-  windows? ? normalized_path.tr('\\', "/") : normalized_path
+  windows? ? normalized_path.tr("\\", "/") : normalized_path
 end
 
 # this is all getting a bit stupid, CHEF-4802 cut to remove all this

data/spec/unit/chef_fs/file_system/repository/directory_spec.rb

@@ -64,7 +64,7 @@ describe Chef::ChefFS::FileSystem::Repository::Directory do
   end
 
   let(:file_double) do
-    double(TestFile, create: true, exists?: false)
+    double(TestFile, create: true, exist?: false, exists?: false)
   end
 
   context "#make_child_entry" do

data/spec/unit/compliance/runner_spec.rb

@@ -234,7 +234,7 @@ describe Chef::Compliance::Runner do
       inputs = runner.inspec_opts[:inputs]
 
       expect(inputs["tacos"]).to eq("lunch")
-      expect(inputs["chef_node"]["audit"]["reporter"]).to eq("json-file")
+      expect(inputs["chef_node"]["audit"]["reporter"]).to eq(%w{json-file cli})
       expect(inputs["chef_node"]["chef_environment"]).to eq("_default")
     end
   end

data/spec/unit/provider/link_spec.rb

@@ -41,7 +41,7 @@ describe Chef::Resource::Link do
   end
 
   def canonicalize(path)
-    ChefUtils.windows? ? path.tr("/", '\\') : path
+    ChefUtils.windows? ? path.tr("/", "\\") : path
   end
 
   describe "when the target is a symlink" do

data/spec/unit/provider/package/dnf/python_helper_spec.rb

@@ -23,6 +23,7 @@ require "spec_helper"
 exclude_test = !(%w{rhel fedora amazon}.include?(ohai[:platform_family]) && File.exist?("/usr/bin/dnf"))
 describe Chef::Provider::Package::Dnf::PythonHelper, :requires_root, external: exclude_test do
   let(:helper) { Chef::Provider::Package::Dnf::PythonHelper.instance }
+  before(:each) { Singleton.__init__(Chef::Provider::Package::Dnf::PythonHelper) }
 
   it "propagates stacktraces on stderr from the forked subprocess", :rhel do
     allow(helper).to receive(:dnf_command).and_return("ruby -e 'raise \"your hands in the air\"'")