chef 18.7.10 → 18.8.46

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

@@ -1,122 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@chef.io>)
-# 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.
-#
-
-require "tmpdir"
-require "fileutils"
-require "chef/config"
-require "chef/json_compat"
-require "chef/server_api"
-require "cheffish/rspec/chef_run_support"
-
-module Cheffish
-  class BasicChefClient
-    def_delegators :@run_context, :before_notifications
-  end
-end
-
-module IntegrationSupport
-  include ChefZero::RSpec
-
-  def self.included(includer_class)
-    includer_class.extend(Cheffish::RSpec::ChefRunSupport)
-    includer_class.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    include ChefZero::RSpec
-
-    def when_the_repository(desc, *tags, &block)
-      context("when the chef repo #{desc}", *tags) do
-        before :each do
-          raise "Can only create one directory per test" if @repository_dir
-
-          @repository_dir = Dir.mktmpdir("chef_repo")
-          Chef::Config.chef_repo_path = @repository_dir
-          %w{client cookbook data_bag environment node role user}.each do |object_name|
-            Chef::Config.delete("#{object_name}_path".to_sym)
-          end
-        end
-
-        after :each do
-          if @repository_dir
-            begin
-              # TODO: "force" actually means "silence all exceptions". this
-              # silences a weird permissions error on Windows that we should track
-              # down, but for now there's no reason for it to blow up our CI.
-              FileUtils.remove_entry_secure(@repository_dir, force = ChefUtils.windows?)
-            ensure
-              @repository_dir = nil
-            end
-          end
-          Dir.chdir(@old_cwd) if @old_cwd
-        end
-
-        module_eval(&block)
-      end
-    end
-  end
-
-  def api
-    Chef::ServerAPI.new
-  end
-
-  def directory(relative_path, &block)
-    old_parent_path = @parent_path
-    @parent_path = path_to(relative_path)
-    FileUtils.mkdir_p(@parent_path)
-    instance_eval(&block) if block
-    @parent_path = old_parent_path
-  end
-
-  def file(relative_path, contents)
-    filename = path_to(relative_path)
-    dir = File.dirname(filename)
-    FileUtils.mkdir_p(dir) unless dir == "."
-    File.open(filename, "w") do |file|
-      raw = case contents
-            when Hash, Array
-              Chef::JSONCompat.to_json_pretty(contents)
-            else
-              contents
-            end
-      file.write(raw)
-    end
-  end
-
-  def symlink(relative_path, relative_dest)
-    filename = path_to(relative_path)
-    dir = File.dirname(filename)
-    FileUtils.mkdir_p(dir) unless dir == "."
-    dest_filename = path_to(relative_dest)
-    File.symlink(dest_filename, filename)
-  end
-
-  def path_to(relative_path)
-    File.expand_path(relative_path, (@parent_path || @repository_dir))
-  end
-
-  def cb_metadata(name, version, extra_text = "")
-    "name #{name.inspect}; version #{version.inspect}#{extra_text}"
-  end
-
-  def cwd(relative_path)
-    @old_cwd = Dir.pwd
-    Dir.chdir(path_to(relative_path))
-  end
-end

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

@@ -1,192 +0,0 @@
-#
-# 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/matchers/exit_with_code.rb

@@ -1,32 +0,0 @@
-require "rspec/expectations"
-
-# Lifted from http://stackoverflow.com/questions/1480537/how-can-i-validate-exits-and-aborts-in-rspec
-RSpec::Matchers.define :exit_with_code do |exp_code|
-  actual = nil
-  match do |block|
-    begin
-      block.call
-    rescue SystemExit => e
-      actual = e.status
-    end
-    actual && actual == exp_code
-  end
-
-  failure_message do |block|
-    "expected block to call exit(#{exp_code}) but exit" +
-      (actual.nil? ? " not called" : "(#{actual}) was called")
-  end
-
-  failure_message_when_negated do |block|
-    "expected block not to call exit(#{exp_code})"
-  end
-
-  description do
-    "expect block to call exit(#{exp_code})"
-  end
-
-  def supports_block_expectations?
-    true
-  end
-
-end

data/spec/support/shared/matchers/match_environment_variable.rb

@@ -1,17 +0,0 @@
-
-require "rspec/expectations"
-require "spec/support/platform_helpers"
-
-RSpec::Matchers.define :match_environment_variable do |varname|
-  match do |actual|
-    expected = if windows? && ENV[varname].nil?
-                 # On Windows, if an environment variable is not set, the command
-                 # `echo %VARNAME%` outputs %VARNAME%
-                 "%#{varname}%"
-               else
-                 ENV[varname].to_s
-               end
-
-    actual == expected
-  end
-end

data/spec/support/shared/shared_examples.rb

@@ -1,14 +0,0 @@
-# For storing any examples shared between multiple tests
-
-# Any object which defines a .to_json should import this test
-shared_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-
-  let(:jsonable) do
-    raise "You must define the subject when including this test"
-  end
-
-  it "should allow consumers to call #to_json or Chef::JSONCompat.to_json" do
-    expect(jsonable.to_json).to eq(Chef::JSONCompat.to_json(jsonable))
-  end
-
-end

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

@@ -1,190 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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.
-#
-
-# == API Error Inspector Examples
-# These tests are work in progress. They exercise the code enough to ensure it
-# runs without error, but don't make assertions about the output. This is
-# because aspects such as how information gets formatted, what's included, etc.
-# are still in flux. When testing an inspector, change the outputter to use
-# STDOUT and manually check the output.
-
-shared_examples_for "an api error inspector" do
-
-  before do
-    @node_name = "test-node.example.com"
-    @config = {
-      validation_client_name: "testorg-validator",
-      validation_key: "/etc/chef/testorg-validator.pem",
-      chef_server_url: "https://chef-api.example.com",
-      node_name: "testnode-name",
-      client_key: "/etc/chef/client.pem",
-    }
-    @description = Chef::Formatters::ErrorDescription.new("Error registering the node:")
-    @outputter = Chef::Formatters::IndentableOutputStream.new(StringIO.new, STDERR)
-    # @outputter = Chef::Formatters::IndentableOutputStream.new(STDOUT, STDERR)
-
-  end
-
-  describe "when explaining a network error" do
-    before do
-      @exception = Errno::ECONNREFUSED.new("connection refused")
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 'private key missing' error" do
-    before do
-      @exception = Chef::Exceptions::PrivateKeyMissing.new("no private key yo")
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 401 caused by clock skew" do
-    before do
-      @response_body = "synchronize the clock on your host"
-      @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPClientException.new("(exception) unauthorized", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 401 (no clock skew)" do
-    before do
-      @response_body = "check your key and node name"
-      @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPClientException.new("(exception) unauthorized", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 403" do
-    before do
-      @response_body = "forbidden"
-      @response = Net::HTTPForbidden.new("1.1", "403", "(response) forbidden")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPClientException.new("(exception) forbidden", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 400" do
-    before do
-      @response_body = "didn't like your data"
-      @response = Net::HTTPBadRequest.new("1.1", "400", "(response) bad request")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPClientException.new("(exception) bad request", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining a 404" do
-    before do
-      @response_body = "probably caused by a redirect to a get"
-      @response = Net::HTTPNotFound.new("1.1", "404", "(response) not found")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPClientException.new("(exception) not found", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-  end
-
-  describe "when explaining a 500" do
-    before do
-      @response_body = "sad trombone"
-      @response = Net::HTTPInternalServerError.new("1.1", "500", "(response) internal server error")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPFatalError.new("(exception) internal server error", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-  end
-
-  describe "when explaining a 503" do
-    before do
-      @response_body = "sad trombone orchestra"
-      @response = Net::HTTPBadGateway.new("1.1", "502", "(response) bad gateway")
-      allow(@response).to receive(:body).and_return(@response_body)
-      @exception = Net::HTTPFatalError.new("(exception) bad gateway", @response)
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-  end
-
-  describe "when explaining an unknown error" do
-    before do
-      @exception = RuntimeError.new("(exception) something went wrong")
-      @inspector = described_class.new(@node_name, @exception, @config)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a nice message" do
-      @description.display(@outputter)
-    end
-  end
-
-end

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

@@ -1,77 +0,0 @@
-#
-# 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.
-#
-
-require "chef/exceptions"
-
-shared_examples_for "version handling" do
-  let(:response_406) { OpenStruct.new(code: "406") }
-  let(:exception_406) { Net::HTTPClientException.new("406 Not Acceptable", response_406) }
-
-  before do
-    allow(rest_v1).to receive(http_verb).and_raise(exception_406)
-  end
-
-  context "when the server does not support the min or max server API version that Chef::UserV1 supports" do
-    before do
-      allow(object).to receive(:server_client_api_version_intersection).and_return([])
-    end
-
-    it "raises the original exception" do
-      expect { object.send(method) }.to raise_error(exception_406)
-    end
-  end # when the server does not support the min or max server API version that Chef::UserV1 supports
-end # version handling
-
-shared_examples_for "user and client reregister" do
-  let(:response_406) { OpenStruct.new(code: "406") }
-  let(:exception_406) { Net::HTTPClientException.new("406 Not Acceptable", response_406) }
-  let(:generic_exception) { Exception.new }
-  let(:min_version) { "2" }
-  let(:max_version) { "5" }
-  let(:return_hash_406) do
-    {
-      "min_version" => min_version,
-      "max_version" => max_version,
-      "request_version" => "30",
-    }
-  end
-
-  context "when V0 is not supported by the server" do
-    context "when the exception is 406 and returns x-ops-server-api-version header" do
-      before do
-        allow(rest_v0).to receive(:put).and_raise(exception_406)
-        allow(response_406).to receive(:[]).with("x-ops-server-api-version").and_return(Chef::JSONCompat.to_json(return_hash_406))
-      end
-
-      it "raises an error about only V0 being supported" do
-        expect(object).to receive(:reregister_only_v0_supported_error_msg).with(max_version, min_version)
-        expect { object.reregister }.to raise_error(Chef::Exceptions::OnlyApiVersion0SupportedForAction)
-      end
-
-    end
-    context "when the exception is not versioning related" do
-      before do
-        allow(rest_v0).to receive(:put).and_raise(generic_exception)
-      end
-
-      it "raises the original error" do
-        expect { object.reregister }.to raise_error(generic_exception)
-      end
-    end
-  end
-end