chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/spec/functional/win32/sid_spec.rb

@@ -1,55 +1,55 @@
-#
-# Author:: Dan Bjorge (<dbjorge@gmail.com>)
-# Copyright:: Copyright 2015-2016, Dan Bjorge
-# 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"
-if Chef::Platform.windows?
-  require "chef/win32/security"
-end
-
-describe "Chef::ReservedNames::Win32::SID", :windows_only do
-  if Chef::Platform.windows?
-    SID ||= Chef::ReservedNames::Win32::Security::SID
-  end
-
-  it "should resolve default_security_object_group as a sane user group", :windows_not_domain_joined_only do
-    # Domain accounts: domain-specific Domain Users SID
-    # Microsoft Accounts: SID.current_user
-    # Else: SID.None
-    expect(SID.default_security_object_group).to eq(SID.None).or eq(SID.current_user)
-  end
-
-  context "running as an elevated administrator user" do
-    it "should resolve default_security_object_owner as the Administrators group" do
-      expect(SID.default_security_object_owner).to eq(SID.Administrators)
-    end
-  end
-
-  context "running as a non-elevated administrator user" do
-    it "should resolve default_security_object_owner as the current user" do
-      skip "requires user support in mixlib-shellout, see security_spec.rb"
-      expect(SID.default_security_object_owner).to eq(SID.Administrators)
-    end
-  end
-
-  context "running as a non-elevated, non-administrator user" do
-    it "should resolve default_security_object_owner as the current user" do
-      skip "requires user support in mixlib-shellout, see security_spec.rb"
-      expect(SID.default_security_object_owner).to eq(SID.current_user)
-    end
-  end
-end
+#
+# Author:: Dan Bjorge (<dbjorge@gmail.com>)
+# Copyright:: Copyright 2015-2016, Dan Bjorge
+# 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"
+if Chef::Platform.windows?
+  require "chef/win32/security"
+end
+
+describe "Chef::ReservedNames::Win32::SID", :windows_only do
+  if Chef::Platform.windows?
+    SID ||= Chef::ReservedNames::Win32::Security::SID
+  end
+
+  it "should resolve default_security_object_group as a sane user group", :windows_not_domain_joined_only do
+    # Domain accounts: domain-specific Domain Users SID
+    # Microsoft Accounts: SID.current_user
+    # Else: SID.None
+    expect(SID.default_security_object_group).to eq(SID.None).or eq(SID.current_user)
+  end
+
+  context "running as an elevated administrator user" do
+    it "should resolve default_security_object_owner as the Administrators group" do
+      expect(SID.default_security_object_owner).to eq(SID.Administrators)
+    end
+  end
+
+  context "running as a non-elevated administrator user" do
+    it "should resolve default_security_object_owner as the current user" do
+      skip "requires user support in mixlib-shellout, see security_spec.rb"
+      expect(SID.default_security_object_owner).to eq(SID.Administrators)
+    end
+  end
+
+  context "running as a non-elevated, non-administrator user" do
+    it "should resolve default_security_object_owner as the current user" do
+      skip "requires user support in mixlib-shellout, see security_spec.rb"
+      expect(SID.default_security_object_owner).to eq(SID.current_user)
+    end
+  end
+end

data/spec/functional/win32/version_info_spec.rb

@@ -1,50 +1,50 @@
-#
-# Author:: Matt Wrock (<matt@mattwrock.com>)
-# Copyright:: Copyright 2015-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"
-if Chef::Platform.windows?
-  require "chef/win32/file/version_info"
-end
-
-describe "Chef::ReservedNames::Win32::File::VersionInfo", :windows_only do
-  require "wmi-lite/wmi"
-  let(:file_path) { ENV["ComSpec"] }
-  let(:os_version) do
-    wmi = WmiLite::Wmi.new
-    os_info = wmi.first_of("Win32_OperatingSystem")
-    os_info["version"]
-  end
-
-  subject { Chef::ReservedNames::Win32::File::VersionInfo.new(file_path) }
-
-  it "file version has the same major.minor version as windows" do
-    expect(subject.FileVersion).to start_with(os_version.rpartition(".").first)
-  end
-
-  it "product version has the same major.minor version as windows" do
-    expect(subject.ProductVersion).to start_with(os_version.rpartition(".").first)
-  end
-
-  it "company is microsoft" do
-    expect(subject.CompanyName).to eq("Microsoft Corporation")
-  end
-
-  it "file description is command processor" do
-    expect(subject.FileDescription).to eq("Windows Command Processor")
-  end
-end
+#
+# Author:: Matt Wrock (<matt@mattwrock.com>)
+# Copyright:: Copyright 2015-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"
+if Chef::Platform.windows?
+  require "chef/win32/file/version_info"
+end
+
+describe "Chef::ReservedNames::Win32::File::VersionInfo", :windows_only do
+  require "wmi-lite/wmi"
+  let(:file_path) { ENV["ComSpec"] }
+  let(:os_version) do
+    wmi = WmiLite::Wmi.new
+    os_info = wmi.first_of("Win32_OperatingSystem")
+    os_info["version"]
+  end
+
+  subject { Chef::ReservedNames::Win32::File::VersionInfo.new(file_path) }
+
+  it "file version has the same version as windows" do
+    expect(subject.FileVersion).to start_with(os_version)
+  end
+
+  it "product version has the same version as windows" do
+    expect(subject.ProductVersion).to start_with(os_version)
+  end
+
+  it "company is microsoft" do
+    expect(subject.CompanyName).to eq("Microsoft Corporation")
+  end
+
+  it "file description is command processor" do
+    expect(subject.FileDescription).to eq("Windows Command Processor")
+  end
+end

data/spec/functional/win32/versions_spec.rb

@@ -1,115 +1,115 @@
-#
-# Author:: Chirag Jog (<chirag@clogeny.com>)
-# Copyright:: Copyright 2013-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"
-if Chef::Platform.windows?
-  require "chef/win32/version"
-end
-
-describe "Chef::ReservedNames::Win32::Version", :windows_only do
-  before do
-
-    wmi = WmiLite::Wmi.new
-    host = wmi.first_of("Win32_OperatingSystem")
-
-    # Use WMI to determine current OS version.
-    # On Win2k8R2 and later, we can dynamically obtain marketing
-    # names for comparison from WMI so the test should not
-    # need to be modified when new Windows releases arise.
-    # For Win2k8 we use static names in this test based on the
-    # version number information from WMI. The names from WMI
-    # contain extended characters such as registered trademark
-    # on Win2k8 that we're not using in our library, so we have
-    # to set the expectation statically.
-    if is_windows_server_2008?(host)
-      @current_os_version = "Windows Server 2008"
-    else
-      # The name from WMI is actually what we want in Win2k8R2+.
-      # So this expectation sould continue to hold without modification
-      # as new versions of Windows are released.
-      @current_os_version = host["caption"]
-    end
-
-    @version = Chef::ReservedNames::Win32::Version.new
-  end
-
-  def for_each_windows_version
-    @version.methods.each do |method_name|
-      if Chef::ReservedNames::Win32::Version::WIN_VERSIONS.keys.find { |key| method_name.to_s == Chef::ReservedNames::Win32::Version.send(:method_name_from_marketing_name, key) }
-        yield method_name
-      end
-    end
-  end
-
-  context "Win32 version object" do
-    it "should have have one method for each marketing version" do
-      versions = 0
-      for_each_windows_version { versions += 1 }
-      expect(versions).to be > 0
-      expect(versions).to eq(Chef::ReservedNames::Win32::Version::WIN_VERSIONS.length)
-    end
-
-    it "should only contain version methods with legal method names" do
-      method_name_pattern = /[a-z]+([a-z]|[0-9]|_)*\?{0,1}/
-
-      for_each_windows_version do |method_name|
-        method_match = method_name_pattern.match(method_name.to_s)
-        expect(method_match).not_to be_nil
-        expect(method_name.to_s).to eq(method_match[0])
-      end
-    end
-
-    it "should have exactly one method that returns true" do
-      true_versions = 0
-      for_each_windows_version do |method_name|
-        true_versions += 1 if @version.send(method_name)
-      end
-      expect(true_versions).to eq(1)
-    end
-
-    it "should successfully execute all version methods" do
-      for_each_windows_version { |method_name| @version.send(method_name.to_sym) }
-    end
-  end
-
-  context "Windows Operating System version" do
-    it "should match the version from WMI" do
-      expect(@current_os_version).to include(@version.marketing_name)
-    end
-  end
-
-  def is_windows_server_2008?(wmi_host)
-    is_win2k8 = false
-
-    os_version = wmi_host["version"]
-
-    # The operating system version is a string in the following form
-    # that can be split into components based on the '.' delimiter:
-    # MajorVersionNumber.MinorVersionNumber.BuildNumber
-    os_version_components = os_version.split(".")
-
-    if os_version_components.length < 2
-      raise "WMI returned a Windows version from Win32_OperatingSystem.Version " +
-        "with an unexpected format. The Windows version could not be determined."
-    end
-
-    # Windows 6.0 is Windows Server 2008, so test the major and
-    # minor version components
-    is_win2k8 = os_version_components[0] == "6" && os_version_components[1] == "0"
-  end
-end
+#
+# Author:: Chirag Jog (<chirag@clogeny.com>)
+# Copyright:: Copyright 2013-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"
+if Chef::Platform.windows?
+  require "chef/win32/version"
+end
+
+describe "Chef::ReservedNames::Win32::Version", :windows_only do
+  before do
+
+    wmi = WmiLite::Wmi.new
+    host = wmi.first_of("Win32_OperatingSystem")
+
+    # Use WMI to determine current OS version.
+    # On Win2k8R2 and later, we can dynamically obtain marketing
+    # names for comparison from WMI so the test should not
+    # need to be modified when new Windows releases arise.
+    # For Win2k8 we use static names in this test based on the
+    # version number information from WMI. The names from WMI
+    # contain extended characters such as registered trademark
+    # on Win2k8 that we're not using in our library, so we have
+    # to set the expectation statically.
+    if is_windows_server_2008?(host)
+      @current_os_version = "Windows Server 2008"
+    else
+      # The name from WMI is actually what we want in Win2k8R2+.
+      # So this expectation sould continue to hold without modification
+      # as new versions of Windows are released.
+      @current_os_version = host["caption"]
+    end
+
+    @version = Chef::ReservedNames::Win32::Version.new
+  end
+
+  def for_each_windows_version
+    @version.methods.each do |method_name|
+      if Chef::ReservedNames::Win32::Version::WIN_VERSIONS.keys.find { |key| method_name.to_s == Chef::ReservedNames::Win32::Version.send(:method_name_from_marketing_name, key) }
+        yield method_name
+      end
+    end
+  end
+
+  context "Win32 version object" do
+    it "should have have one method for each marketing version" do
+      versions = 0
+      for_each_windows_version { versions += 1 }
+      expect(versions).to be > 0
+      expect(versions).to eq(Chef::ReservedNames::Win32::Version::WIN_VERSIONS.length)
+    end
+
+    it "should only contain version methods with legal method names" do
+      method_name_pattern = /[a-z]+([a-z]|[0-9]|_)*\?{0,1}/
+
+      for_each_windows_version do |method_name|
+        method_match = method_name_pattern.match(method_name.to_s)
+        expect(method_match).not_to be_nil
+        expect(method_name.to_s).to eq(method_match[0])
+      end
+    end
+
+    it "should have exactly one method that returns true" do
+      true_versions = 0
+      for_each_windows_version do |method_name|
+        true_versions += 1 if @version.send(method_name)
+      end
+      expect(true_versions).to eq(1)
+    end
+
+    it "should successfully execute all version methods" do
+      for_each_windows_version { |method_name| @version.send(method_name.to_sym) }
+    end
+  end
+
+  context "Windows Operating System version" do
+    it "should match the version from WMI" do
+      expect(@current_os_version).to include(@version.marketing_name)
+    end
+  end
+
+  def is_windows_server_2008?(wmi_host)
+    is_win2k8 = false
+
+    os_version = wmi_host["version"]
+
+    # The operating system version is a string in the following form
+    # that can be split into components based on the '.' delimiter:
+    # MajorVersionNumber.MinorVersionNumber.BuildNumber
+    os_version_components = os_version.split(".")
+
+    if os_version_components.length < 2
+      raise "WMI returned a Windows version from Win32_OperatingSystem.Version " +
+        "with an unexpected format. The Windows version could not be determined."
+    end
+
+    # Windows 6.0 is Windows Server 2008, so test the major and
+    # minor version components
+    is_win2k8 = os_version_components[0] == "6" && os_version_components[1] == "0"
+  end
+end

data/spec/integration/client/client_spec.rb

@@ -1,714 +1,721 @@
-require "support/shared/integration/integration_helper"
-require "chef/mixin/shell_out"
-require "tiny_server"
-require "tmpdir"
-
-describe "chef-client" do
-
-  def recipes_filename
-    File.join(CHEF_SPEC_DATA, "recipes.tgz")
-  end
-
-  def start_tiny_server(server_opts = {})
-    @server = TinyServer::Manager.new(server_opts)
-    @server.start
-    @api = TinyServer::API.instance
-    @api.clear
-    #
-    # trivial endpoints
-    #
-    # just a normal file
-    # (expected_content should be uncompressed)
-    @api.get("/recipes.tgz", 200) do
-      File.open(recipes_filename, "rb", &:read)
-    end
-  end
-
-  def stop_tiny_server
-    @server.stop
-    @server = @api = nil
-  end
-
-  include IntegrationSupport
-  include Chef::Mixin::ShellOut
-
-  let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
-
-  # Invoke `chef-client` as `ruby PATH/TO/chef-client`. This ensures the
-  # following constraints are satisfied:
-  # * Windows: windows can only run batch scripts as bare executables. Rubygems
-  # creates batch wrappers for installed gems, but we don't have batch wrappers
-  # in the source tree.
-  # * Other `chef-client` in PATH: A common case is running the tests on a
-  # machine that has omnibus chef installed. In that case we need to ensure
-  # we're running `chef-client` from the source tree and not the external one.
-  # cf. CHEF-4914
-  let(:chef_client) { "ruby '#{chef_dir}/chef-client' --minimal-ohai" }
-  let(:chef_solo) { "ruby '#{chef_dir}/chef-solo' --legacy-mode --minimal-ohai" }
-
-  let(:critical_env_vars) { %w{_ORIGINAL_GEM_PATH GEM_PATH GEM_HOME GEM_ROOT BUNDLE_BIN_PATH BUNDLE_GEMFILE RUBYLIB RUBYOPT RUBY_ENGINE RUBY_ROOT RUBY_VERSION PATH}.map { |o| "#{o}=#{ENV[o]}" } .join(" ") }
-
-  when_the_repository "has a cookbook with a no-op recipe" do
-    before { file "cookbooks/x/recipes/default.rb", "" }
-
-    it "should complete with success" do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-
-      shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-    end
-
-    it "should complete successfully with --no-listen" do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-
-      result = shell_out("#{chef_client} --no-listen -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      result.error!
-    end
-
-    it "should be able to node.save with bad utf8 characters in the node data" do
-      file "cookbooks/x/attributes/default.rb", 'default["badutf8"] = "Elan Ruusam\xE4e"'
-      result = shell_out("#{chef_client} -z -r 'x::default' --disable-config", cwd: path_to(""))
-      result.error!
-    end
-
-    context "and no config file" do
-      it "should complete with success when cwd is just above cookbooks and paths are not specified" do
-        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: path_to(""))
-        result.error!
-      end
-
-      it "should complete with success when cwd is below cookbooks and paths are not specified" do
-        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: path_to("cookbooks/x"))
-        result.error!
-      end
-
-      it "should fail when cwd is below high above and paths are not specified" do
-        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: File.expand_path("..", path_to("")))
-        expect(result.exitstatus).to eq(1)
-      end
-    end
-
-    context "and a config file under .chef/knife.rb" do
-      before { file ".chef/knife.rb", "xxx.xxx" }
-
-      it "should load .chef/knife.rb when -z is specified" do
-        result = shell_out("#{chef_client} -z -o 'x::default'", cwd: path_to(""))
-        # FATAL: Configuration error NoMethodError: undefined method `xxx' for nil:NilClass
-        expect(result.stdout).to include("xxx")
-      end
-
-    end
-
-    it "should complete with success" 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'", cwd: chef_dir)
-      result.error!
-    end
-
-    context "and a private key" do
-      before do
-        file "mykey.pem", <<~EOM
-          -----BEGIN RSA PRIVATE KEY-----
-          MIIEogIBAAKCAQEApubutqtYYQ5UiA9QhWP7UvSmsfHsAoPKEVVPdVW/e8Svwpyf
-          0Xef6OFWVmBE+W442ZjLOe2y6p2nSnaq4y7dg99NFz6X+16mcKiCbj0RCiGqCvCk
-          NftHhTgO9/RFvCbmKZ1RKNob1YzLrFpxBHaSh9po+DGWhApcd+I+op+ZzvDgXhNn
-          0nauZu3rZmApI/r7EEAOjFedAXs7VPNXhhtZAiLSAVIrwU3ZajtSzgXOxbNzgj5O
-          AAAMmThK+71qPdffAdO4J198H6/MY04qgtFo7vumzCq0UCaGZfmeI1UNE4+xQWwP
-          HJ3pDAP61C6Ebx2snI2kAd9QMx9Y78nIedRHPwIDAQABAoIBAHssRtPM1GacWsom
-          8zfeN6ZbI4KDlbetZz0vhnqDk9NVrpijWlcOP5dwZXVNitnB/HaqCqFvyPDY9JNB
-          zI/pEFW4QH59FVDP42mVEt0keCTP/1wfiDDGh1vLqVBYl/ZphscDcNgDTzNkuxMx
-          k+LFVxKnn3w7rGc59lALSkpeGvbbIDjp3LUMlUeCF8CIFyYZh9ZvXe4OCxYdyjxb
-          i8tnMLKvJ4Psbh5jMapsu3rHQkfPdqzztQUz8vs0NYwP5vWge46FUyk+WNm/IhbJ
-          G3YM22nwUS8Eu2bmTtADSJolATbCSkOwQ1D+Fybz/4obfYeGaCdOqB05ttubhenV
-          ShsAb7ECgYEA20ecRVxw2S7qA7sqJ4NuYOg9TpfGooptYNA1IP971eB6SaGAelEL
-          awYkGNuu2URmm5ElZpwJFFTDLGA7t2zB2xI1FeySPPIVPvJGSiZoFQOVlIg9WQzK
-          7jTtFQ/tOMrF+bigEUJh5bP1/7HzqSpuOsPjEUb2aoCTp+tpiRGL7TUCgYEAwtns
-          g3ysrSEcTzpSv7fQRJRk1lkBhatgNd0oc+ikzf74DaVLhBg1jvSThDhiDCdB59mr
-          Jh41cnR1XqE8jmdQbCDRiFrI1Pq6TPaDZFcovDVE1gue9x86v3FOH2ukPG4d2/Xy
-          HevXjThtpMMsWFi0JYXuzXuV5HOvLZiP8sN3lSMCgYANpdxdGM7RRbE9ADY0dWK2
-          V14ReTLcxP7fyrWz0xLzEeCqmomzkz3BsIUoouu0DCTSw+rvAwExqcDoDylIVlWO
-          fAifz7SeZHbcDxo+3TsXK7zwnLYsx7YNs2+aIv6hzUUbMNmNmXMcZ+IEwx+mRMTN
-          lYmZdrA5mr0V83oDFPt/jQKBgC74RVE03pMlZiObFZNtheDiPKSG9Bz6wMh7NWMr
-          c37MtZLkg52mEFMTlfPLe6ceV37CM8WOhqe+dwSGrYhOU06dYqUR7VOZ1Qr0aZvo
-          fsNPu/Y0+u7rMkgv0fs1AXQnvz7kvKaF0YITVirfeXMafuKEtJoH7owRbur42cpV
-          YCAtAoGAP1rHOc+w0RUcBK3sY7aErrih0OPh9U5bvJsrw1C0FIZhCEoDVA+fNIQL
-          syHLXYFNy0OxMtH/bBAXBGNHd9gf5uOnqh0pYcbe/uRAxumC7Rl0cL509eURiA2T
-          +vFmf54y9YdnLXaqv+FhJT6B6V7WX7IpU9BMqJY1cJYXHuHG2KA=
-          -----END RSA PRIVATE KEY-----
-        EOM
-      end
-
-      it "should complete with success even with a client key" do
-        file "config/client.rb", <<~EOM
-          local_mode true
-          client_key #{path_to("mykey.pem").inspect}
-          cookbook_path #{path_to("cookbooks").inspect}
-        EOM
-
-        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-        result.error!
-      end
-
-      it "should run recipes specified directly on the command line" do
-        file "config/client.rb", <<~EOM
-          local_mode true
-          client_key #{path_to("mykey.pem").inspect}
-          cookbook_path #{path_to("cookbooks").inspect}
-        EOM
-
-        file "arbitrary.rb", <<~EOM
-          file #{path_to("tempfile.txt").inspect} do
-            content '1'
-          end
-        EOM
-
-        file "arbitrary2.rb", <<~EOM
-          file #{path_to("tempfile2.txt").inspect} do
-            content '2'
-          end
-        EOM
-
-        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" #{path_to("arbitrary.rb")} #{path_to("arbitrary2.rb")}", cwd: chef_dir)
-        result.error!
-
-        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
-        expect(IO.read(path_to("tempfile2.txt"))).to eq("2")
-      end
-
-      it "should run recipes specified as relative paths directly on the command line" do
-        file "config/client.rb", <<~EOM
-          local_mode true
-          client_key #{path_to("mykey.pem").inspect}
-          cookbook_path #{path_to("cookbooks").inspect}
-        EOM
-
-        file "arbitrary.rb", <<~EOM
-          file #{path_to("tempfile.txt").inspect} do
-            content '1'
-          end
-        EOM
-
-        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" arbitrary.rb", cwd: path_to(""))
-        result.error!
-
-        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
-      end
-
-      it "should run recipes specified directly on the command line AFTER recipes in the run list" do
-        file "config/client.rb", <<~EOM
-          local_mode true
-          client_key #{path_to("mykey.pem").inspect}
-          cookbook_path #{path_to("cookbooks").inspect}
-        EOM
-
-        file "cookbooks/x/recipes/constant_definition.rb", <<~EOM
-          class ::Blah
-            THECONSTANT = '1'
-          end
-        EOM
-        file "arbitrary.rb", <<~EOM
-          file #{path_to("tempfile.txt").inspect} do
-            content ::Blah::THECONSTANT
-          end
-        EOM
-
-        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o x::constant_definition arbitrary.rb", cwd: path_to(""))
-        result.error!
-
-        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
-      end
-
-    end
-
-    it "should complete with success when passed the -z flag" do
-      file "config/client.rb", <<~EOM
-        chef_server_url 'http://omg.com/blah'
-        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!
-    end
-
-    it "should complete with success when passed the --local-mode flag" do
-      file "config/client.rb", <<~EOM
-        chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --local-mode", cwd: chef_dir)
-      result.error!
-    end
-
-    it "should not print SSL warnings when running in local-mode" do
-      file "config/client.rb", <<~EOM
-        chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --local-mode", cwd: chef_dir)
-      expect(result.stdout).not_to include("SSL validation of HTTPS requests is disabled.")
-      result.error!
-    end
-
-    it "should complete with success when passed -z and --chef-zero-port" do
-      file "config/client.rb", <<~EOM
-        chef_server_url 'http://omg.com/blah'
-        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!
-    end
-
-    it "should complete with success when setting the run list with -r" do
-      file "config/client.rb", <<~EOM
-        chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -r 'x::default' -z -l info", cwd: chef_dir)
-      expect(result.stdout).not_to include("Overridden Run List")
-      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 should fail chef_version checks" do
-    before do
-      file "cookbooks/x/recipes/default.rb", ""
-      file "cookbooks/x/metadata.rb", <<~EOM
-        name 'x'
-        version '0.0.1'
-        chef_version '~> 999.99'
-      EOM
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-    it "should fail the chef client run" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      expect(command.exitstatus).to eql(1)
-      expect(command.stdout).to match(/Chef::Exceptions::CookbookChefVersionMismatch/)
-    end
-  end
-
-  when_the_repository "has a cookbook that uses cheffish resources" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<-EOM
-        raise "Cheffish was loaded before we used any cheffish things!" if defined?(Cheffish::VERSION)
-        ran_block = false
-        got_server = with_chef_server 'https://blah.com' do
-          ran_block = true
-          run_context.cheffish.current_chef_server
-        end
-        raise "with_chef_server block was not run!" if !ran_block
-        raise "Cheffish was not loaded when we did cheffish things!" if !defined?(Cheffish::VERSION)
-        raise "current_chef_server did not return its value!" if got_server[:chef_server_url] != 'https://blah.com'
-      EOM
-      file "config/client.rb", <<-EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "the cheffish DSL is loaded lazily" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      expect(command.exitstatus).to eql(0)
-    end
-  end
-
-  when_the_repository "has a cookbook that uses chef-provisioning resources" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<-EOM
-        with_driver 'blah'
-      EOM
-      file "config/client.rb", <<-EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "the cheffish DSL tries to load but fails (because chef-provisioning is not there)" do
-      # we'd need to have a custom bundle to fix this that omitted chef-provisioning, but that would dig our crazy even deeper, so lets not
-      skip "but if chef-provisioning is in our bundle or in our gemset then this test, very annoyingly, always fails"
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      expect(command.exitstatus).to eql(1)
-      expect(command.stdout).to match(%r{cannot load such file -- chef/provisioning})
-    end
-  end
-
-  when_the_repository "has a cookbook that generates deprecation warnings" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<-EOM
-        Chef.deprecated(:internal_api, "Test deprecation")
-        Chef.deprecated(:internal_api, "Test deprecation")
-      EOM
-    end
-
-    def match_indices(regex, str)
-      result = []
-      pos = 0
-      while match = regex.match(str, pos)
-        result << match.begin(0)
-        pos = match.end(0) + 1
-      end
-      result
-    end
-
-    it "should output each deprecation warning only once, at the end of the run" do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-        # Mimick what happens when you are on the console
-        formatters << :doc
-        log_level :warn
-      EOM
-
-      ENV.delete("CHEF_TREAT_DEPRECATION_WARNINGS_AS_ERRORS")
-
-      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      expect(result.error?).to be_falsey
-
-      # Search to the end of the client run in the output
-      run_complete = result.stdout.index("Running handlers complete")
-      expect(run_complete).to be >= 0
-
-      # Make sure there is exactly one result for each, and that it occurs *after* the complete message.
-      expect(match_indices(/Test deprecation/, result.stdout)).to match([ be > run_complete ])
-    end
-  end
-
-  when_the_repository "has a cookbook with only an audit recipe" do
-
-    before do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-        audit_mode :enabled
-        silence_deprecation_warnings %w{chef-27}
-      EOM
-    end
-
-    it "should exit with a zero code when there is not an audit failure" do
-      file "cookbooks/audit_test/recipes/succeed.rb", <<~RECIPE
-        control_group "control group without top level control" do
-          it "should succeed" do
-            expect(2 - 2).to eq(0)
-          end
-        end
-      RECIPE
-
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'audit_test::succeed' -l info", cwd: chef_dir)
-      expect(result.error?).to be_falsey
-      expect(result.stdout).to include("Successfully executed all `control_group` blocks and contained examples")
-    end
-
-    it "should exit with a non-zero code when there is an audit failure" do
-      file "cookbooks/audit_test/recipes/fail.rb", <<~RECIPE
-        control_group "control group without top level control" do
-          it "should fail" do
-            expect(2 - 2).to eq(1)
-          end
-        end
-      RECIPE
-
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'audit_test::fail'", cwd: chef_dir)
-      expect(result.error?).to be_truthy
-      expect(result.stdout).to include("Failure/Error: expect(2 - 2).to eq(1)")
-    end
-  end
-
-  when_the_repository "has a cookbook that deploys a file" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<~RECIPE
-        cookbook_file #{path_to("tempfile.txt").inspect} do
-          source "my_file"
-        end
-      RECIPE
-
-      file "cookbooks/x/files/my_file", <<~FILE
-        this is my file
-      FILE
-    end
-
-    [true, false].each do |lazy|
-      context "with no_lazy_load set to #{lazy}" do
-        it "should create the file" do
-          file "config/client.rb", <<~EOM
-            no_lazy_load #{lazy}
-            local_mode true
-            cookbook_path "#{path_to("cookbooks")}"
-          EOM
-          result = shell_out("#{chef_client} -l debug -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-          result.error!
-
-          expect(IO.read(path_to("tempfile.txt")).strip).to eq("this is my file")
-        end
-      end
-    end
-  end
-
-  when_the_repository "has a cookbook with an ohai plugin" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<~RECIPE
-        file #{path_to("tempfile.txt").inspect} do
-          content node["english"]["version"]
-        end
-      RECIPE
-
-      file "cookbooks/x/ohai/english.rb", <<-OHAI
-        Ohai.plugin(:English) do
-          provides 'english'
-
-          collect_data do
-            english Mash.new
-            english[:version] = "2014"
-          end
-        end
-      OHAI
-
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "should run the ohai plugin" do
-      result = shell_out("#{chef_client} -l debug -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      result.error!
-
-      expect(IO.read(path_to("tempfile.txt"))).to eq("2014")
-    end
-  end
-
-  # Fails on appveyor, but works locally on windows and on windows hosts in Ci.
-  context "when using recipe-url", :skip_appveyor do
-    before(:each) do
-      start_tiny_server
-    end
-
-    after(:each) do
-      stop_tiny_server
-    end
-
-    let(:tmp_dir) { Dir.mktmpdir("recipe-url") }
-
-    it "should complete with success when passed -z and --recipe-url" do
-      file "config/client.rb", <<~EOM
-        chef_repo_path "#{tmp_dir}"
-      EOM
-      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" --recipe-url=http://localhost:9000/recipes.tgz -o 'x::default' -z", cwd: tmp_dir)
-      result.error!
-    end
-
-    it "should fail when passed --recipe-url and not passed -z" do
-      result = shell_out("#{chef_client} --recipe-url=http://localhost:9000/recipes.tgz", cwd: tmp_dir)
-      expect(result.exitstatus).not_to eq(0)
-    end
-
-    it "should fail when passed --recipe-url with a file that doesn't exist" do
-      broken_path = File.join(CHEF_SPEC_DATA, "recipes_dont_exist.tgz")
-      result = shell_out("#{chef_client} --recipe-url=#{broken_path}", cwd: tmp_dir)
-      expect(result.exitstatus).not_to eq(0)
-    end
-  end
-
-  when_the_repository "has a cookbook with broken metadata.rb, but has metadata.json" do
-    before do
-      file "cookbooks/x/recipes/default.rb", ""
-      file "cookbooks/x/metadata.rb", <<~EOM
-        name 'x'
-        version '0.0.1'
-        raise "TEH SADNESS"
-      EOM
-      file "cookbooks/x/metadata.json", <<~EOM
-        {
-          "name": "x",
-          "version": "0.0.1"
-        }
-      EOM
-
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "the chef client run should succeed" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-    end
-
-    it "a chef-solo run should succeed" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-    end
-  end
-
-  when_the_repository "has a cookbook that logs at the info level" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<EOM
-      log "info level" do
-        level :info
-      end
-EOM
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "a chef client run should not log to info by default" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).not_to include("INFO")
-    end
-
-    it "a chef client run to a pipe should not log to info by default" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork | tee #{path_to("chefrun.out")}", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).not_to include("INFO")
-    end
-
-    it "a chef solo run should not log to info by default" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).not_to include("INFO")
-    end
-
-    it "a chef solo run to a pipe should not log to info by default" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork | tee #{path_to("chefrun.out")}", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).not_to include("INFO")
-    end
-  end
-
-  when_the_repository "has a cookbook that knows if we're running forked" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<~EOM
-        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-      EOM
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-      EOM
-    end
-
-    it "chef-client runs by default with no supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-
-    it "chef-solo runs by default with no supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-
-    it "chef-client --no-fork does not fork" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-
-    it "chef-solo --no-fork does not fork" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-
-    it "chef-client with --fork uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("WITHFORK")
-    end
-
-    it "chef-solo with --fork uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --fork", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("WITHFORK")
-    end
-  end
-
-  when_the_repository "has a cookbook that knows if we're running forked, and configures forking in config.rb" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<~EOM
-        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-      EOM
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-        client_fork true
-      EOM
-    end
-
-    it "chef-client uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("WITHFORK")
-    end
-
-    it "chef-solo uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("WITHFORK")
-    end
-  end
-
-  when_the_repository "has a cookbook that knows if we're running forked, and configures no-forking in config.rb" do
-    before do
-      file "cookbooks/x/recipes/default.rb", <<~EOM
-        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-      EOM
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to("cookbooks")}"
-        client_fork false
-      EOM
-    end
-
-    it "chef-client uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-
-    it "chef-solo uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
-      command.error!
-      expect(command.stdout).to include("NOFORK")
-    end
-  end
-end
+require "support/shared/integration/integration_helper"
+require "chef/mixin/shell_out"
+require "tiny_server"
+require "tmpdir"
+
+describe "chef-client" do
+
+  def recipes_filename
+    File.join(CHEF_SPEC_DATA, "recipes.tgz")
+  end
+
+  def start_tiny_server(server_opts = {})
+    @server = TinyServer::Manager.new(server_opts)
+    @server.start
+    @api = TinyServer::API.instance
+    @api.clear
+    #
+    # trivial endpoints
+    #
+    # just a normal file
+    # (expected_content should be uncompressed)
+    @api.get("/recipes.tgz", 200) do
+      File.open(recipes_filename, "rb") do |f|
+        f.read
+      end
+    end
+  end
+
+  def stop_tiny_server
+    @server.stop
+    @server = @api = nil
+  end
+
+  include IntegrationSupport
+  include Chef::Mixin::ShellOut
+
+  let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
+
+  # Invoke `chef-client` as `ruby PATH/TO/chef-client`. This ensures the
+  # following constraints are satisfied:
+  # * Windows: windows can only run batch scripts as bare executables. Rubygems
+  # creates batch wrappers for installed gems, but we don't have batch wrappers
+  # in the source tree.
+  # * Other `chef-client` in PATH: A common case is running the tests on a
+  # machine that has omnibus chef installed. In that case we need to ensure
+  # we're running `chef-client` from the source tree and not the external one.
+  # cf. CHEF-4914
+  let(:chef_client) { "bundle exec chef-client --minimal-ohai" }
+  let(:chef_solo) { "bundle exec chef-solo --legacy-mode --minimal-ohai" }
+
+  when_the_repository "has a cookbook with a no-op recipe" do
+    before { file "cookbooks/x/recipes/default.rb", "" }
+
+    it "should complete with success" do
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+
+      shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+    end
+
+    it "should complete successfully with --no-listen" do
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+
+      result = shell_out("#{chef_client} --no-listen -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      result.error!
+    end
+
+    it "should be able to node.save with bad utf8 characters in the node data" do
+      file "cookbooks/x/attributes/default.rb", 'default["badutf8"] = "Elan Ruusam\xE4e"'
+      result = shell_out("#{chef_client} -z -r 'x::default' --disable-config", cwd: path_to(""))
+      result.error!
+    end
+
+    context "and no config file" do
+      it "should complete with success when cwd is just above cookbooks and paths are not specified" do
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: path_to(""))
+        result.error!
+      end
+
+      it "should complete with success when cwd is below cookbooks and paths are not specified" do
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: path_to("cookbooks/x"))
+        result.error!
+      end
+
+      it "should fail when cwd is below high above and paths are not specified" do
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", cwd: File.expand_path("..", path_to("")))
+        expect(result.exitstatus).to eq(1)
+      end
+    end
+
+    context "and a config file under .chef/knife.rb" do
+      before { file ".chef/knife.rb", "xxx.xxx" }
+
+      it "should load .chef/knife.rb when -z is specified" do
+        result = shell_out("#{chef_client} -z -o 'x::default'", cwd: path_to(""))
+        # FATAL: Configuration error NoMethodError: undefined method `xxx' for nil:NilClass
+        expect(result.stdout).to include("xxx")
+      end
+
+    end
+
+    it "should complete with success" 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'", cwd: chef_dir)
+      result.error!
+    end
+
+    context "and a private key" do
+      before do
+        file "mykey.pem", <<~EOM
+          -----BEGIN RSA PRIVATE KEY-----
+          MIIEogIBAAKCAQEApubutqtYYQ5UiA9QhWP7UvSmsfHsAoPKEVVPdVW/e8Svwpyf
+          0Xef6OFWVmBE+W442ZjLOe2y6p2nSnaq4y7dg99NFz6X+16mcKiCbj0RCiGqCvCk
+          NftHhTgO9/RFvCbmKZ1RKNob1YzLrFpxBHaSh9po+DGWhApcd+I+op+ZzvDgXhNn
+          0nauZu3rZmApI/r7EEAOjFedAXs7VPNXhhtZAiLSAVIrwU3ZajtSzgXOxbNzgj5O
+          AAAMmThK+71qPdffAdO4J198H6/MY04qgtFo7vumzCq0UCaGZfmeI1UNE4+xQWwP
+          HJ3pDAP61C6Ebx2snI2kAd9QMx9Y78nIedRHPwIDAQABAoIBAHssRtPM1GacWsom
+          8zfeN6ZbI4KDlbetZz0vhnqDk9NVrpijWlcOP5dwZXVNitnB/HaqCqFvyPDY9JNB
+          zI/pEFW4QH59FVDP42mVEt0keCTP/1wfiDDGh1vLqVBYl/ZphscDcNgDTzNkuxMx
+          k+LFVxKnn3w7rGc59lALSkpeGvbbIDjp3LUMlUeCF8CIFyYZh9ZvXe4OCxYdyjxb
+          i8tnMLKvJ4Psbh5jMapsu3rHQkfPdqzztQUz8vs0NYwP5vWge46FUyk+WNm/IhbJ
+          G3YM22nwUS8Eu2bmTtADSJolATbCSkOwQ1D+Fybz/4obfYeGaCdOqB05ttubhenV
+          ShsAb7ECgYEA20ecRVxw2S7qA7sqJ4NuYOg9TpfGooptYNA1IP971eB6SaGAelEL
+          awYkGNuu2URmm5ElZpwJFFTDLGA7t2zB2xI1FeySPPIVPvJGSiZoFQOVlIg9WQzK
+          7jTtFQ/tOMrF+bigEUJh5bP1/7HzqSpuOsPjEUb2aoCTp+tpiRGL7TUCgYEAwtns
+          g3ysrSEcTzpSv7fQRJRk1lkBhatgNd0oc+ikzf74DaVLhBg1jvSThDhiDCdB59mr
+          Jh41cnR1XqE8jmdQbCDRiFrI1Pq6TPaDZFcovDVE1gue9x86v3FOH2ukPG4d2/Xy
+          HevXjThtpMMsWFi0JYXuzXuV5HOvLZiP8sN3lSMCgYANpdxdGM7RRbE9ADY0dWK2
+          V14ReTLcxP7fyrWz0xLzEeCqmomzkz3BsIUoouu0DCTSw+rvAwExqcDoDylIVlWO
+          fAifz7SeZHbcDxo+3TsXK7zwnLYsx7YNs2+aIv6hzUUbMNmNmXMcZ+IEwx+mRMTN
+          lYmZdrA5mr0V83oDFPt/jQKBgC74RVE03pMlZiObFZNtheDiPKSG9Bz6wMh7NWMr
+          c37MtZLkg52mEFMTlfPLe6ceV37CM8WOhqe+dwSGrYhOU06dYqUR7VOZ1Qr0aZvo
+          fsNPu/Y0+u7rMkgv0fs1AXQnvz7kvKaF0YITVirfeXMafuKEtJoH7owRbur42cpV
+          YCAtAoGAP1rHOc+w0RUcBK3sY7aErrih0OPh9U5bvJsrw1C0FIZhCEoDVA+fNIQL
+          syHLXYFNy0OxMtH/bBAXBGNHd9gf5uOnqh0pYcbe/uRAxumC7Rl0cL509eURiA2T
+          +vFmf54y9YdnLXaqv+FhJT6B6V7WX7IpU9BMqJY1cJYXHuHG2KA=
+          -----END RSA PRIVATE KEY-----
+        EOM
+      end
+
+      it "should complete with success even with a client key" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+        result.error!
+      end
+
+      it "should run recipes specified directly on the command line" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+        EOM
+
+        file "arbitrary.rb", <<~EOM
+          file #{path_to('tempfile.txt').inspect} do
+            content '1'
+          end
+        EOM
+
+        file "arbitrary2.rb", <<~EOM
+          file #{path_to('tempfile2.txt').inspect} do
+            content '2'
+          end
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" #{path_to('arbitrary.rb')} #{path_to('arbitrary2.rb')}", cwd: chef_dir)
+        result.error!
+
+        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
+        expect(IO.read(path_to("tempfile2.txt"))).to eq("2")
+      end
+
+      it "should run recipes specified as relative paths directly on the command line" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+        EOM
+
+        file "arbitrary.rb", <<~EOM
+          file #{path_to('tempfile.txt').inspect} do
+            content '1'
+          end
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" arbitrary.rb", cwd: path_to(""))
+        result.error!
+
+        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
+      end
+
+      it "should run recipes specified directly on the command line AFTER recipes in the run list" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+        EOM
+
+        file "cookbooks/x/recipes/constant_definition.rb", <<~EOM
+          class ::Blah
+            THECONSTANT = '1'
+          end
+        EOM
+
+        file "arbitrary.rb", <<~EOM
+          file #{path_to('tempfile.txt').inspect} do
+            content ::Blah::THECONSTANT
+          end
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o x::constant_definition arbitrary.rb", cwd: path_to(""))
+        result.error!
+
+        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
+      end
+
+      it "should run recipes specified directly on the command line AFTER recipes in the run list (without an override_runlist this time)" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+        EOM
+
+        file "config/dna.json", <<~EOM
+          {
+            "run_list": [ "recipe[x::constant_definition]" ]
+          }
+        EOM
+
+        file "cookbooks/x/recipes/constant_definition.rb", <<~EOM
+          class ::Blah
+            THECONSTANT = '1'
+          end
+        EOM
+
+        file "arbitrary.rb", <<~EOM
+          file #{path_to('tempfile.txt').inspect} do
+            content ::Blah::THECONSTANT
+          end
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -j \"#{path_to('config/dna.json')}\" arbitrary.rb", cwd: path_to(""))
+        result.error!
+
+        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
+      end
+
+      it "an override_runlist of an empty string should allow a recipe specified directly on the command line to be the only one run" do
+        file "config/client.rb", <<~EOM
+          local_mode true
+          client_key #{path_to('mykey.pem').inspect}
+          cookbook_path #{path_to('cookbooks').inspect}
+          class ::Blah
+            THECONSTANT = "1"
+          end
+        EOM
+
+        file "config/dna.json", <<~EOM
+          {
+            "run_list": [ "recipe[x::constant_definition]" ]
+          }
+        EOM
+
+        file "cookbooks/x/recipes/constant_definition.rb", <<~EOM
+          class ::Blah
+            THECONSTANT = "2"
+          end
+        EOM
+
+        file "arbitrary.rb", <<~EOM
+          raise "this test failed" unless ::Blah::THECONSTANT == "1"
+          file #{path_to('tempfile.txt').inspect} do
+            content ::Blah::THECONSTANT
+          end
+        EOM
+
+        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -j \"#{path_to('config/dna.json')}\" -o \"\" arbitrary.rb", cwd: path_to(""))
+        result.error!
+
+        expect(IO.read(path_to("tempfile.txt"))).to eq("1")
+      end
+
+    end
+
+    it "should complete with success when passed the -z flag" do
+      file "config/client.rb", <<~EOM
+        chef_server_url 'http://omg.com/blah'
+        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!
+    end
+
+    it "should complete with success when passed the --local-mode flag" do
+      file "config/client.rb", <<~EOM
+        chef_server_url 'http://omg.com/blah'
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", cwd: chef_dir)
+      result.error!
+    end
+
+    it "should not print SSL warnings when running in local-mode" do
+      file "config/client.rb", <<~EOM
+        chef_server_url 'http://omg.com/blah'
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", cwd: chef_dir)
+      expect(result.stdout).not_to include("SSL validation of HTTPS requests is disabled.")
+      result.error!
+    end
+
+    it "should complete with success when passed -z and --chef-zero-port" do
+      file "config/client.rb", <<~EOM
+        chef_server_url 'http://omg.com/blah'
+        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!
+    end
+
+    it "should complete with success when setting the run list with -r" do
+      file "config/client.rb", <<~EOM
+        chef_server_url 'http://omg.com/blah'
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -r 'x::default' -z -l info", cwd: chef_dir)
+      expect(result.stdout).not_to include("Overridden Run List")
+      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 should fail chef_version checks" do
+    before do
+      file "cookbooks/x/recipes/default.rb", ""
+      file "cookbooks/x/metadata.rb", <<~EOM
+        name 'x'
+        version '0.0.1'
+        chef_version '~> 999.99'
+      EOM
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+    it "should fail the chef client run" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      expect(command.exitstatus).to eql(1)
+      expect(command.stdout).to match(/Chef::Exceptions::CookbookChefVersionMismatch/)
+    end
+  end
+
+  when_the_repository "has a cookbook that uses cheffish resources" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<-EOM
+        raise "Cheffish was loaded before we used any cheffish things!" if defined?(Cheffish::VERSION)
+        ran_block = false
+        got_server = with_chef_server 'https://blah.com' do
+          ran_block = true
+          run_context.cheffish.current_chef_server
+        end
+        raise "with_chef_server block was not run!" if !ran_block
+        raise "Cheffish was not loaded when we did cheffish things!" if !defined?(Cheffish::VERSION)
+        raise "current_chef_server did not return its value!" if got_server[:chef_server_url] != 'https://blah.com'
+      EOM
+      file "config/client.rb", <<-EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+
+    it "the cheffish DSL is loaded lazily" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      expect(command.exitstatus).to eql(0)
+    end
+  end
+
+  when_the_repository "has a cookbook that generates deprecation warnings" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<-EOM
+        Chef.deprecated(:internal_api, "Test deprecation")
+        Chef.deprecated(:internal_api, "Test deprecation")
+      EOM
+    end
+
+    def match_indices(regex, str)
+      result = []
+      pos = 0
+      while match = regex.match(str, pos)
+        result << match.begin(0)
+        pos = match.end(0) + 1
+      end
+      result
+    end
+
+    it "should output each deprecation warning only once, at the end of the run" do
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+        # Mimick what happens when you are on the console
+        formatters << :doc
+        log_level :warn
+      EOM
+
+      ENV.delete("CHEF_TREAT_DEPRECATION_WARNINGS_AS_ERRORS")
+
+      result = shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      expect(result.error?).to be_falsey
+
+      # Search to the end of the client run in the output
+      run_complete = result.stdout.index("Running handlers complete")
+      expect(run_complete).to be >= 0
+
+      # Make sure there is exactly one result for each, and that it occurs *after* the complete message.
+      expect(match_indices(/Test deprecation/, result.stdout)).to match([ be > run_complete ])
+    end
+  end
+
+  when_the_repository "has a cookbook that deploys a file" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<~RECIPE
+        cookbook_file #{path_to('tempfile.txt').inspect} do
+          source "my_file"
+        end
+      RECIPE
+
+      file "cookbooks/x/files/my_file", <<~FILE
+        this is my file
+      FILE
+    end
+
+    [true, false].each do |lazy|
+      context "with no_lazy_load set to #{lazy}" do
+        it "should create the file" do
+          file "config/client.rb", <<~EOM
+            no_lazy_load #{lazy}
+            local_mode true
+            cookbook_path "#{path_to('cookbooks')}"
+          EOM
+          result = shell_out("#{chef_client} -l debug -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+          result.error!
+
+          expect(IO.read(path_to("tempfile.txt")).strip).to eq("this is my file")
+        end
+      end
+    end
+  end
+
+  when_the_repository "has a cookbook with an ohai plugin" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<~RECIPE
+        file #{path_to('tempfile.txt').inspect} do
+          content node["english"]["version"]
+        end
+      RECIPE
+
+      file "cookbooks/x/ohai/english.rb", <<-OHAI
+        Ohai.plugin(:English) do
+          provides 'english'
+
+          collect_data do
+            english Mash.new
+            english[:version] = "2014"
+          end
+        end
+      OHAI
+
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+
+    it "should run the ohai plugin" do
+      result = shell_out("#{chef_client} -l debug -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      result.error!
+
+      expect(IO.read(path_to("tempfile.txt"))).to eq("2014")
+    end
+  end
+
+  # Fails on appveyor, but works locally on windows and on windows hosts in Ci.
+  context "when using recipe-url", :skip_appveyor do
+    before(:each) do
+      start_tiny_server
+    end
+
+    after(:each) do
+      stop_tiny_server
+    end
+
+    let(:tmp_dir) { Dir.mktmpdir("recipe-url") }
+
+    it "should complete with success when passed -z and --recipe-url" do
+      file "config/client.rb", <<~EOM
+        chef_repo_path "#{tmp_dir}"
+      EOM
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" --recipe-url=http://localhost:9000/recipes.tgz -o 'x::default' -z", cwd: tmp_dir)
+      result.error!
+    end
+
+    it "should fail when passed --recipe-url and not passed -z" do
+      result = shell_out("#{chef_client} --recipe-url=http://localhost:9000/recipes.tgz", cwd: tmp_dir)
+      expect(result.exitstatus).not_to eq(0)
+    end
+
+    it "should fail when passed --recipe-url with a file that doesn't exist" do
+      broken_path = File.join(CHEF_SPEC_DATA, "recipes_dont_exist.tgz")
+      result = shell_out("#{chef_client} --recipe-url=#{broken_path}", cwd: tmp_dir)
+      expect(result.exitstatus).not_to eq(0)
+    end
+  end
+
+  when_the_repository "has a cookbook with broken metadata.rb, but has metadata.json" do
+    before do
+      file "cookbooks/x/recipes/default.rb", ""
+      file "cookbooks/x/metadata.rb", <<~EOM
+        name 'x'
+        version '0.0.1'
+        raise "TEH SADNESS"
+      EOM
+      file "cookbooks/x/metadata.json", <<~EOM
+        {
+          "name": "x",
+          "version": "0.0.1"
+        }
+      EOM
+
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+
+    it "the chef client run should succeed" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+    end
+
+    it "a chef-solo run should succeed" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+    end
+  end
+
+  when_the_repository "has a cookbook that logs at the info level" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<EOM
+      log "info level" do
+        level :info
+      end
+EOM
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+
+    it "a chef client run should not log to info by default" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef client run to a pipe should not log to info by default" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef solo run should not log to info by default" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef solo run to a pipe should not log to info by default" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+  end
+
+  when_the_repository "has a cookbook that knows if we're running forked" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<~EOM
+        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
+      EOM
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+      EOM
+    end
+
+    it "chef-client runs by default with no supervisor" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+
+    it "chef-solo runs by default with no supervisor" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+
+    it "chef-client --no-fork does not fork" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+
+    it "chef-solo --no-fork does not fork" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+
+    it "chef-client with --fork uses a supervisor" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("WITHFORK")
+    end
+
+    it "chef-solo with --fork uses a supervisor" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --fork", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("WITHFORK")
+    end
+  end
+
+  when_the_repository "has a cookbook that knows if we're running forked, and configures forking in config.rb" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<~EOM
+        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
+      EOM
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+        client_fork true
+      EOM
+    end
+
+    it "chef-client uses a supervisor" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("WITHFORK")
+    end
+
+    it "chef-solo uses a supervisor" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("WITHFORK")
+    end
+  end
+
+  when_the_repository "has a cookbook that knows if we're running forked, and configures no-forking in config.rb" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<~EOM
+        puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
+      EOM
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+        client_fork false
+      EOM
+    end
+
+    it "chef-client uses a supervisor" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+
+    it "chef-solo uses a supervisor" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command.error!
+      expect(command.stdout).to include("NOFORK")
+    end
+  end
+end