chef 16.13.16-universal-mingw32 → 17.0.242-universal-mingw32

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

@@ -1,37 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Author:: Ho-Sheng Hsiao (<hosh@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-module SpecHelpers
-  module Knife
-    def redefine_argv(value)
-      Object.send(:remove_const, :ARGV)
-      Object.send(:const_set, :ARGV, value)
-    end
-
-    def with_argv(*argv)
-      original_argv = ARGV
-      redefine_argv(argv.flatten)
-      begin
-        yield
-      ensure
-        redefine_argv(original_argv)
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-
-require "chef/application/windows_service_manager"
-
-shared_context "using Win32::Service" do
-  # Some helper methods.
-
-  def test_service_exists?
-    ::Win32::Service.exists?("spec-service")
-  end
-
-  def test_service_state
-    ::Win32::Service.status("spec-service").current_state
-  end
-
-  def service_manager
-    Chef::Application::WindowsServiceManager.new(test_service)
-  end
-
-  def cleanup
-    # Uninstall if the test service is installed.
-    if test_service_exists?
-
-      # We can only uninstall when the service is stopped.
-      if test_service_state != "stopped"
-        ::Win32::Service.send("stop", "spec-service")
-        sleep 1 while test_service_state != "stopped"
-      end
-
-      ::Win32::Service.delete("spec-service")
-    end
-
-    # Delete the test_service_file if it exists
-    if File.exist?(test_service_file)
-      File.delete(test_service_file)
-    end
-  end
-
-  # Definition for the test-service
-
-  let(:test_service) do
-    {
-      service_name: "spec-service",
-      service_display_name: "Spec Test Service",
-      service_description: "Service for testing Chef::Application::WindowsServiceManager.",
-      service_file_path: File.expand_path(File.join(__dir__, "../../platforms/win32/spec_service.rb")),
-      delayed_start: true,
-    }
-  end
-
-  # Test service creates a file for us to verify that it is running.
-  # Since our test service is running as Local System we should look
-  # for the file it creates under SYSTEM temp directory
-
-  let(:test_service_file) do
-    "#{ENV["SystemDrive"]}\\windows\\temp\\spec_service_file"
-  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/unit/knife_shared.rb

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

data/spec/unit/application/knife_spec.rb

@@ -1,241 +0,0 @@
-#
-# Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# 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 "spec_helper"
-require "#{CHEF_SPEC_DATA}/knife_subcommand/test_yourself"
-
-describe Chef::Application::Knife do
-  include SpecHelpers::Knife
-
-  before(:all) do
-    class NoopKnifeCommand < Chef::Knife
-      option :opt_with_default,
-        short: "-D VALUE",
-        long: "-optwithdefault VALUE",
-        default: "default-value"
-
-      def run; end
-    end
-  end
-
-  after(:each) do
-    # reset some really nasty global state
-    NoopKnifeCommand.reset_config_loader!
-  end
-
-  before(:each) do
-    # Prevent code from getting loaded on every test invocation.
-    allow(Chef::Knife).to receive(:load_commands)
-
-    @knife = Chef::Application::Knife.new
-    allow(@knife).to receive(:puts)
-    allow(@knife).to receive(:trap)
-    allow(Chef::Knife).to receive(:list_commands)
-  end
-
-  it "should exit 1 and print the options if no arguments are given at all" do
-    with_argv([]) do
-      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
-    end
-  end
-
-  it "should exit 2 if run without a sub command" do
-    with_argv("--user", "adam") do
-      expect(Chef::Log).to receive(:error).with(/you need to pass a sub\-command/i)
-      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(2) }
-    end
-  end
-
-  it "should run a sub command with the applications command line option prototype" do
-    with_argv(*%w{noop knife command with some args}) do
-      knife = double(Chef::Knife)
-      expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
-      expect(@knife).to receive(:exit).with(0)
-      @knife.run
-    end
-  end
-
-  it "should set the colored output to true by default on windows and true on all other platforms as well" do
-    with_argv(*%w{noop knife command}) do
-      expect(@knife).to receive(:exit).with(0)
-      @knife.run
-    end
-    expect(Chef::Config[:color]).to be_truthy
-  end
-
-  context "validate --format option" do
-    it "should set the default format summary" do
-      with_argv(*%w{noop knife command}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-        expect(@knife.default_config[:format]).to eq("summary")
-      end
-    end
-
-    it "should raise the error for invalid value" do
-      with_argv(*%w{noop knife command -F abc}) do
-        expect(STDOUT).to receive(:puts).at_least(2).times
-        expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(2) }
-      end
-    end
-  end
-
-  context "when given fips flags" do
-    context "when Chef::Config[:fips]=false" do
-      before do
-        # This is required because the chef-fips pipeline does
-        # has a default value of true for fips
-        Chef::Config[:fips] = false
-      end
-
-      it "does not initialize fips mode when no flags are passed" do
-        with_argv(*%w{noop knife command}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).not_to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(false)
-        end
-      end
-
-      it "overwrites the Chef::Config value when passed --fips" do
-        with_argv(*%w{noop knife command --fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(true)
-        end
-      end
-    end
-
-    context "when Chef::Config[:fips]=true" do
-      before do
-        Chef::Config[:fips] = true
-      end
-
-      it "initializes fips mode when passed --fips" do
-        with_argv(*%w{noop knife command --fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(true)
-        end
-      end
-
-      it "overwrites the Chef::Config value when passed --no-fips" do
-        with_argv(*%w{noop knife command --no-fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).not_to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(false)
-        end
-      end
-    end
-  end
-
-  describe "when given a path to the client key" do
-    it "expands a relative path relative to the CWD" do
-      relative_path = ".chef/client.pem"
-      allow(Dir).to receive(:pwd).and_return(CHEF_SPEC_DATA)
-      with_argv(*%W{noop knife command -k #{relative_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(File.join(CHEF_SPEC_DATA, relative_path))
-    end
-
-    it "expands a ~/home/path to the correct full path" do
-      home_path = "~/.chef/client.pem"
-      with_argv(*%W{noop knife command -k #{home_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(File.join(ENV["HOME"], ".chef/client.pem").gsub((File::ALT_SEPARATOR || '\\'), File::SEPARATOR))
-    end
-
-    it "does not expand a full path" do
-      full_path = if windows?
-                    "C:/chef/client.pem"
-                  else
-                    "/etc/chef/client.pem"
-                  end
-      with_argv(*%W{noop knife command -k #{full_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(full_path)
-    end
-  end
-
-  describe "with environment configuration" do
-    before do
-      Chef::Config[:environment] = nil
-    end
-
-    it "should default to no environment" do
-      with_argv(*%w{noop knife command}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq(nil)
-    end
-
-    it "should load the environment from the config file" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -c #{config_file}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("production")
-    end
-
-    it "should load the environment from the CLI options" do
-      with_argv(*%w{noop knife command -E development}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("development")
-    end
-
-    it "should override the config file environment with the CLI environment" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -c #{config_file} -E override}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("override")
-    end
-
-    it "should override the config file environment with the CLI environment regardless of order" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -E override -c #{config_file}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("override")
-    end
-
-    it "should run a sub command with the applications command line option prototype" do
-      with_argv(*%w{noop knife command with some args}) do
-        knife = double(Chef::Knife)
-        expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-    end
-  end
-
-end