chef 18.8.11 → 18.8.54

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

@@ -1,82 +0,0 @@
-#
-# 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 "an application that loads a dot d" do
-  before do
-    Chef::Config[dot_d_config_name] = client_d_dir
-  end
-
-  context "when client_d_dir is set to nil" do
-    let(:client_d_dir) { nil }
-
-    it "does not raise an exception" do
-      expect { app.reconfigure }.not_to raise_error
-    end
-  end
-
-  context "when client_d_dir is set to a directory with configuration" do
-    # We're not going to mock out globbing the directory. We want to
-    # make sure that we are correctly globbing.
-    let(:client_d_dir) do
-      Chef::Util::PathHelper.cleanpath(
-        File.join(__dir__, "../../../data/client.d_00")
-      )
-    end
-
-    it "loads the configuration in order" do
-      etc_chef_client_rb = Chef::Config.platform_specific_path("#{ChefConfig::Config.etc_chef_dir}/client.rb")
-      expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_return("foo 0")
-      expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_return("bar 0")
-      expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_return("strings 0")
-      allow(app).to receive(:apply_config).with("", etc_chef_client_rb) # for chef-client managed nodes running this spec
-      expect(app).to receive(:apply_config).with("foo 0", Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_call_original.ordered
-      expect(app).to receive(:apply_config).with("bar 0", Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_call_original.ordered
-      expect(app).to receive(:apply_config).with("strings 0", Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_call_original.ordered
-      app.reconfigure
-    end
-  end
-
-  context "when client_d_dir is set to a directory without configuration" do
-    let(:client_d_dir) do
-      Chef::Util::PathHelper.cleanpath(
-        File.join(__dir__, "../../data/client.d_01")
-      )
-    end
-
-    # client.d_01 has a nested folder with a rb file that if
-    # executed, would raise an exception. If it is executed,
-    # it means we are loading configs that are deeply nested
-    # inside of client.d. For example, client.d/foo/bar.rb
-    # should not run, but client.d/foo.rb should.
-    it "does not raise an exception" do
-      expect { app.reconfigure }.not_to raise_error
-    end
-  end
-
-  context "when client_d_dir is set to a directory containing a directory named foo.rb" do
-    # foo.rb as a directory should be ignored
-    let(:client_d_dir) do
-      Chef::Util::PathHelper.cleanpath(
-        File.join(__dir__, "../../data/client.d_02")
-      )
-    end
-
-    it "does not raise an exception" do
-      expect { app.reconfigure }.not_to raise_error
-    end
-  end
-end

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

@@ -1,166 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# 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 "an execute resource" do
-
-  before(:each) do
-    @resource = resource
-  end
-
-  it "should create a new Chef::Resource::Execute" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Execute)
-  end
-
-  it "should set the command to the first argument to new" do
-    expect(@resource.command).to eql(resource_instance_name)
-  end
-
-  it "should accept an array on instantiation, too" do
-    resource = Chef::Resource::Execute.new(%w{something else})
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::Execute)
-    expect(resource.command).to eql(%w{something else})
-  end
-
-  it "should accept a string for the command to run" do
-    @resource.command "something"
-    expect(@resource.command).to eql("something")
-  end
-
-  it "should accept an array for the command to run" do
-    @resource.command %w{something else}
-    expect(@resource.command).to eql(%w{something else})
-  end
-
-  it "should accept a string for the cwd" do
-    @resource.cwd "something"
-    expect(@resource.cwd).to eql("something")
-  end
-
-  it "should accept a hash for the environment" do
-    test_hash = { one: :two }
-    @resource.environment(test_hash)
-    expect(@resource.environment).to eql(test_hash)
-  end
-
-  it "allows the environment to be specified with #env" do
-    expect(@resource).to respond_to(:env)
-  end
-
-  it "should accept a string for the group" do
-    @resource.group "something"
-    expect(@resource.group).to eql("something")
-  end
-
-  it "should accept an integer for the group" do
-    @resource.group 1
-    expect(@resource.group).to eql(1)
-  end
-
-  it "the old path property (that never worked) is not supported in chef >= 13" do
-    expect(@resource).not_to respond_to(:path)
-  end
-
-  it "should accept an integer for the return code" do
-    @resource.returns 1
-    expect(@resource.returns).to eql(1)
-  end
-
-  it "should accept an integer for the timeout" do
-    @resource.timeout 1
-    expect(@resource.timeout).to eql(1)
-  end
-
-  it "should accept a string for the user" do
-    @resource.user "something"
-    expect(@resource.user).to eql("something")
-  end
-
-  it "should accept an integer for the user" do
-    @resource.user 1
-    expect(@resource.user).to eql(1)
-  end
-
-  it "should accept a string for the domain" do
-    @resource.domain "mothership"
-    expect(@resource.domain).to eql("mothership")
-  end
-
-  it "should accept a string for the password" do
-    @resource.password "we.funk!"
-    expect(@resource.password).to eql("we.funk!")
-  end
-
-  it "should accept a string for creates" do
-    @resource.creates "something"
-    expect(@resource.creates).to eql("something")
-  end
-
-  it "should accept a boolean for live streaming" do
-    @resource.live_stream true
-    expect(@resource.live_stream).to be true
-  end
-
-  describe "the resource's sensitive attribute" do
-    it "should be false by default" do
-      expect(@resource.sensitive).to eq(false)
-    end
-
-    it "should be true if set to true" do
-      expect(@resource.sensitive).to eq(false)
-      @resource.sensitive true
-      expect(@resource.sensitive).to eq(true)
-    end
-
-    it "should be true if the password is non-nil" do
-      @resource.password("we.funk!")
-      expect(@resource.sensitive).to eq(true)
-    end
-
-    it "should be true if the password is non-nil but the value is explicitly set to false" do
-      @resource.password("we.funk!")
-      @resource.sensitive false
-      expect(@resource.sensitive).to eq(false)
-    end
-
-    # added this test to ensure setting of password property after or before sensitive does not matter
-    it "should be false if the sensitive is set before password property" do
-      @resource.sensitive false
-      @resource.password("we.funk!")
-      expect(@resource.sensitive).to eq(false)
-    end
-
-  end
-
-  describe "when it has cwd, environment, group, path, return value, and a user" do
-    before do
-      @resource.command("grep")
-      @resource.cwd("/tmp/")
-      @resource.environment({ one: :two })
-      @resource.group("legos")
-      @resource.returns(1)
-      @resource.user("root")
-    end
-
-    it "returns the command as its identity" do
-      expect(@resource.identity).to eq("grep")
-    end
-  end
-end

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

@@ -1,70 +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/chef_fs/file_system"
-require "chef/chef_fs/file_system/memory/memory_root"
-require "chef/chef_fs/file_system/memory/memory_dir"
-require "chef/chef_fs/file_system/memory/memory_file"
-
-module FileSystemSupport
-  def memory_fs(pretty_name, value, cannot_be_in_regex = nil)
-    unless value.is_a?(Hash)
-      raise "memory_fs() must take a Hash"
-    end
-
-    dir = Chef::ChefFS::FileSystem::Memory::MemoryRoot.new(pretty_name, cannot_be_in_regex)
-    value.each do |key, child|
-      dir.add_child(memory_fs_value(child, key.to_s, dir))
-    end
-    dir
-  end
-
-  def memory_fs_value(value, name = "", parent = nil)
-    if value.is_a?(Hash)
-      dir = Chef::ChefFS::FileSystem::Memory::MemoryDir.new(name, parent)
-      value.each do |key, child|
-        dir.add_child(memory_fs_value(child, key.to_s, dir))
-      end
-      dir
-    else
-      Chef::ChefFS::FileSystem::Memory::MemoryFile.new(name, parent, value || "#{name}\n")
-    end
-  end
-
-  def pattern(p)
-    Chef::ChefFS::FilePattern.new(p)
-  end
-
-  def return_paths(*expected)
-    ReturnPaths.new(expected)
-  end
-
-  def no_blocking_calls_allowed
-    [ Chef::ChefFS::FileSystem::Memory::MemoryFile, Chef::ChefFS::FileSystem::Memory::MemoryDir ].each do |c|
-      %i{children exists? read}.each do |m|
-        allow_any_instance_of(c).to receive(m).and_raise("#{m} should not be called")
-      end
-    end
-  end
-
-  def list_should_yield_paths(fs, pattern_str, *expected_paths)
-    result_paths = []
-    Chef::ChefFS::FileSystem.list(fs, pattern(pattern_str)).each { |result| result_paths << result.path }
-    expect(result_paths).to match_array(expected_paths)
-  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/support/shared/unit/mock_shellout.rb

@@ -1,49 +0,0 @@
-#
-# Author:: John Keiser <jkeiser@chef.io>
-# Copyright:: Copyright 2015-2016, John Keiser.
-# 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.
-#
-
-#
-# Mocks shellout results. Examples:
-#   mock_shellout_command("systemctl --all", exitstatus: 1)
-#
-class MockShellout
-  module RSpec
-    def mock_shellout_command(command, **result)
-      allow(::Mixlib::ShellOut).to receive(:new).with(command, anything).and_return MockShellout.new(**result)
-    end
-  end
-
-  def initialize(**properties)
-    @properties = {
-      stdout: "",
-      stderr: "",
-      exitstatus: 0,
-    }.merge(properties)
-  end
-
-  def method_missing(name, *args)
-    @properties[name.to_sym]
-  end
-
-  def error?
-    exitstatus != 0
-  end
-
-  def error!
-    raise Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with 0, but received #{exitstatus}" if error?
-  end
-end

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

@@ -1,189 +0,0 @@
-#
-# Author:: Seth Falcon (<seth@chef.io>)
-# 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.
-#
-
-shared_examples_for "a platform introspector" do
-  before(:each) do
-    @platform_hash = {}
-    %w{openbsd freebsd}.each do |x|
-      @platform_hash[x] = {
-        "default" => x,
-        "1.2.3" => "#{x}-1.2.3",
-      }
-    end
-    @platform_hash["debian"] = { %w{5 6} => "debian-5/6", "default" => "debian" }
-    @platform_hash["default"] = "default"
-    # The following @platform_hash keys are used for testing version constraints
-    @platform_hash["exact_match"] = { "1.2.3" => "exact", ">= 1.0" => "not exact" }
-    @platform_hash["multiple_matches"] = { "~> 2.3.4" => "matched ~> 2.3.4", ">= 2.3" => "matched >=2.3" }
-    @platform_hash["invalid_cookbook_version"] = { ">= 21" => "Matches a single number" }
-    @platform_hash["successful_matches"] = { "< 3.0" => "matched < 3.0", ">= 3.0" => "matched >= 3.0" }
-
-    @platform_family_hash = {
-      "debian" => "debian value",
-      %i{rhel fedora} => "redhatty value",
-      "suse" => "suse value",
-      :default => "default value",
-    }
-  end
-
-  it "returns a default value when there is no known platform" do
-    node = {}
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
-  end
-
-  it "returns a default value when there is no known platform family" do
-    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
-  end
-
-  it "returns a default value when the current platform doesn't match" do
-    node.automatic_attrs[:platform] = "not-a-known-platform"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
-  end
-
-  it "returns a default value when current platform_family doesn't match" do
-    node.automatic_attrs[:platform_family] = "ultra-derived-linux"
-    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
-  end
-
-  it "returns a value based on the current platform" do
-    node.automatic_attrs[:platform] = "openbsd"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
-  end
-
-  it "returns a value based on the current platform family" do
-    node.automatic_attrs[:platform_family] = "debian"
-    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("debian value")
-  end
-
-  it "returns a version-specific value based on the current platform" do
-    node.automatic_attrs[:platform] = "openbsd"
-    node.automatic_attrs[:platform_version] = "1.2.3"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd-1.2.3")
-  end
-
-  it "returns a value based on the current platform if version not found" do
-    node.automatic_attrs[:platform] = "openbsd"
-    node.automatic_attrs[:platform_version] = "0.0.0"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
-  end
-
-  it "returns the exact match" do
-    node.automatic_attrs[:platform] = "exact_match"
-    node.automatic_attrs[:platform_version] = "1.2.3"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("exact")
-  end
-
-  it "raises RuntimeError" do
-    node.automatic_attrs[:platform] = "multiple_matches"
-    node.automatic_attrs[:platform_version] = "2.3.4"
-    expect { platform_introspector.value_for_platform(@platform_hash) }.to raise_error(RuntimeError)
-  end
-
-  it "should not require .0 to match >= 21.0" do
-    node.automatic_attrs[:platform] = "invalid_cookbook_version"
-    node.automatic_attrs[:platform_version] = "21"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("Matches a single number")
-  end
-
-  it "should return the value for that match" do
-    node.automatic_attrs[:platform] = "successful_matches"
-    node.automatic_attrs[:platform_version] = "2.9"
-    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("matched < 3.0")
-  end
-
-  describe "when platform versions is an array" do
-    it "returns a version-specific value based on the current platform" do
-      node.automatic_attrs[:platform] = "debian"
-      node.automatic_attrs[:platform_version] = "6"
-      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian-5/6")
-    end
-
-    it "returns a value based on the current platform if version not found" do
-      node.automatic_attrs[:platform] = "debian"
-      node.automatic_attrs[:platform_version] = "0.0.0"
-      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian")
-    end
-  end
-
-  describe "when checking platform?" do
-
-    it "returns true if the node is a provided platform and platforms are provided as symbols" do
-      node.automatic_attrs[:platform] = "ubuntu"
-      expect(platform_introspector.platform?(%i{redhat ubuntu})).to eq(true)
-    end
-
-    it "returns true if the node is a provided platform and platforms are provided as strings" do
-      node.automatic_attrs[:platform] = "ubuntu"
-      expect(platform_introspector.platform?(%w{redhat ubuntu})).to eq(true)
-    end
-
-    it "returns false if the node is not of the provided platforms" do
-      node.automatic_attrs[:platform] = "ubuntu"
-      expect(platform_introspector.platform?(:splatlinux)).to eq(false)
-    end
-  end
-
-  describe "when checking platform_family?" do
-
-    it "returns true if the node is in a provided platform family and families are provided as symbols" do
-      node.automatic_attrs[:platform_family] = "debian"
-      expect(platform_introspector.platform_family?(%i{rhel debian})).to eq(true)
-    end
-
-    it "returns true if the node is a provided platform and platforms are provided as strings" do
-      node.automatic_attrs[:platform_family] = "rhel"
-      expect(platform_introspector.platform_family?(%w{rhel debian})).to eq(true)
-    end
-
-    it "returns false if the node is not of the provided platforms" do
-      node.automatic_attrs[:platform_family] = "suse"
-      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
-    end
-
-    it "returns false if the node is not of the provided platforms and platform_family is not set" do
-      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
-    end
-
-  end
-  # NOTE: this is a regression test for bug CHEF-1514
-  describe "when the value is an array" do
-    before do
-      @platform_hash = {
-        "debian" => { "4.0" => %i{restart reload}, "default" => %i{restart reload status} },
-        "ubuntu" => { "default" => %i{restart reload status} },
-        "centos" => { "default" => %i{restart reload status} },
-        "redhat" => { "default" => %i{restart reload status} },
-        "fedora" => { "default" => %i{restart reload status} },
-        "default" => { "default" => %i{restart reload} } }
-    end
-
-    it "returns the correct default for a given platform" do
-      node.automatic_attrs[:platform] = "debian"
-      node.automatic_attrs[:platform_version] = "9000"
-      expect(platform_introspector.value_for_platform(@platform_hash)).to eq(%i{restart reload status})
-    end
-
-    it "returns the correct platform+version specific value " do
-      node.automatic_attrs[:platform] = "debian"
-      node.automatic_attrs[:platform_version] = "4.0"
-      expect(platform_introspector.value_for_platform(@platform_hash)).to eq(%i{restart reload})
-    end
-  end
-
-end