chef 18.8.11 → 18.8.54

data/spec/unit/mixin/default_paths_spec.rb

@@ -1,92 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@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 "spec_helper"
-
-class DefaultPathsTestHarness
-  include Chef::Mixin::DefaultPaths
-end
-
-describe Chef::Mixin::DefaultPaths do
-
-  before do
-    @default_paths = DefaultPathsTestHarness.new
-  end
-
-  describe "when enforcing default paths" do
-    before do
-      Chef::Config[:enforce_default_paths] = true
-      @ruby_bindir = "/some/ruby/bin"
-      @gem_bindir = "/some/gem/bin"
-      allow(Gem).to receive(:bindir).and_return(@gem_bindir)
-      allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(@ruby_bindir)
-      allow(ChefUtils).to receive(:windows?).and_return(false)
-    end
-
-    it "adds all useful PATHs even if environment is an empty hash" do
-      env = {}
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
-    end
-
-    it "adds all useful PATHs that are not yet in PATH to PATH" do
-      env = { "PATH" => "" }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
-    end
-
-    it "does not re-add paths that already exist in PATH" do
-      env = { "PATH" => "/usr/bin:/sbin:/bin" }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/bin:/sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin")
-    end
-
-    it "creates path with utf-8 encoding" do
-      env = { "PATH" => "/usr/bin:/sbin:/bin:/b#{0x81.chr}t".force_encoding("ISO-8859-1") }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"].encoding.to_s).to eq("UTF-8")
-    end
-
-    it "adds the current executing Ruby's bindir and Gem bindir to the PATH" do
-      env = { "PATH" => "" }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
-    end
-
-    it "does not create entries for Ruby/Gem bindirs if they exist in PATH" do
-      ruby_bindir = "/usr/bin"
-      gem_bindir = "/yo/gabba/gabba"
-      allow(Gem).to receive(:bindir).and_return(gem_bindir)
-      allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(ruby_bindir)
-      env = { "PATH" => gem_bindir }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("/usr/bin:/yo/gabba/gabba:/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin")
-    end
-
-    it "builds a valid windows path" do
-      ruby_bindir = 'C:\ruby\bin'
-      gem_bindir = 'C:\gems\bin'
-      allow(Gem).to receive(:bindir).and_return(gem_bindir)
-      allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(ruby_bindir)
-      allow(ChefUtils).to receive(:windows?).and_return(true)
-      env = { "PATH" => "C:\\Windows\\system32;C:\\mr\\softie" }
-      @default_paths.enforce_default_paths(env)
-      expect(env["PATH"]).to eq("#{gem_bindir};#{ruby_bindir};C:\\Windows\\system32;C:\\mr\\softie")
-    end
-  end
-end

data/spec/unit/mixin/deprecation_spec.rb

@@ -1,57 +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.
-#
-
-require "spec_helper"
-require "chef/mixin/deprecation"
-
-describe Chef::Mixin do
-  describe "deprecating constants (Class/Module)" do
-    before do
-      Chef::Mixin.deprecate_constant(:DeprecatedClass, Chef::Node, "This is a test deprecation")
-      @log_io = StringIO.new
-      Chef::Log.init(@log_io)
-    end
-
-    it "has a list of deprecated constants" do
-      expect(Chef::Mixin.deprecated_constants).to have_key(:DeprecatedClass)
-    end
-
-    it "returns the replacement when accessing the deprecated constant" do
-      expect(Chef::Mixin::DeprecatedClass).to eq(Chef::Node)
-    end
-
-    it "warns when accessing the deprecated constant" do
-      Chef::Mixin::DeprecatedClass # rubocop:disable Lint/Void
-      expect(@log_io.string).to include("This is a test deprecation")
-    end
-  end
-end
-
-describe Chef::Mixin::Deprecation::DeprecatedInstanceVariable do
-  before do
-    Chef::Log.logger = Logger.new(StringIO.new)
-
-    @deprecated_ivar = Chef::Mixin::Deprecation::DeprecatedInstanceVariable.new("value", "an_ivar")
-  end
-
-  it "forward method calls to the target object" do
-    expect(@deprecated_ivar.length).to eq(5)
-    expect(@deprecated_ivar.to_sym).to eq(:value)
-  end
-
-end

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -1,96 +0,0 @@
-#
-# Author:: Mark Mzyk (<mmzyk@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 "spec_helper"
-require "etc"
-require "ostruct"
-
-describe Chef::Mixin::EnforceOwnershipAndPermissions do
-
-  before(:each) do
-    @node = Chef::Node.new
-    @node.name "make_believe"
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @tmpdir = Dir.mktmpdir
-    @resource = Chef::Resource::File.new("#{@tmpdir}/madeup.txt")
-    FileUtils.touch @resource.path
-    @resource.owner "adam"
-    @provider = Chef::Provider::File.new(@resource, @run_context)
-    @provider.current_resource = @resource
-  end
-
-  after(:each) do
-    FileUtils.rm_rf(@tmpdir)
-  end
-
-  it "should call set_all on the file access control object" do
-    expect_any_instance_of(Chef::FileAccessControl).to receive(:set_all)
-    @provider.enforce_ownership_and_permissions
-  end
-
-  context "when nothing was updated" do
-    before do
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:uid_from_resource).and_return(0)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:requires_changes?).and_return(false)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:define_resource_requirements)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
-
-      passwd_struct = OpenStruct.new(name: "root", passwd: "x",
-                                     uid: 0, gid: 0, dir: "/root",
-                                     shell: "/bin/bash")
-
-      group_struct = OpenStruct.new(name: "root", passwd: "x", gid: 0)
-      allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
-      allow(Etc).to receive(:getgrgid).and_return(group_struct)
-    end
-
-    it "does not set updated_by_last_action on the new resource" do
-      expect(@provider.new_resource).not_to receive(:updated_by_last_action)
-
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:set_all)
-      @provider.run_action(:create)
-    end
-
-  end
-
-  context "when something was modified" do
-    before do
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:requires_changes?).and_return(true)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:uid_from_resource).and_return(0)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
-
-      passwd_struct = OpenStruct.new(name: "root", passwd: "x",
-                                     uid: 0, gid: 0, dir: "/root",
-                                     shell: "/bin/bash")
-
-      group_struct = OpenStruct.new(name: "root", passwd: "x", gid: 0)
-      allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
-      allow(Etc).to receive(:getgrgid).and_return(group_struct)
-    end
-
-    it "sets updated_by_last_action on the new resource" do
-      @provider.new_resource.owner(0) # CHEF-3557 hack - Set these because we don't for windows
-      @provider.new_resource.group(0) # CHEF-3557 hack - Set these because we don't for windows
-      expect(@provider.new_resource).to receive(:updated_by_last_action)
-      allow_any_instance_of(Chef::FileAccessControl).to receive(:set_all)
-      @provider.run_action(:create)
-    end
-  end
-
-end

data/spec/unit/mixin/homebrew_spec.rb

@@ -1,118 +0,0 @@
-#
-# Author:: Joshua Timberman (<joshua@chef.io>)
-#
-# Copyright:: Copyright (c) Chef Software Inc.
-#
-# 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"
-
-describe Chef::Mixin::Homebrew do
-  let(:homebrew) { Class.new { include Chef::Mixin::Homebrew }.new }
-  let(:uid) { 1001 }
-  let(:username) { "foobar" }
-  let(:alt_brew_path) { "/foo" }
-
-  describe "#find_homebrew_uid" do
-    it "returns the provided UID when an integer is given" do
-      expect(File).to receive(:exist?).exactly(0).times
-      expect(homebrew.find_homebrew_uid(uid)).to eq(uid)
-    end
-
-    it "returns the provided UID when username is given" do
-      expect(File).to receive(:exist?).exactly(0).times
-      allow(Etc).to receive(:getpwnam).with(username).and_return(OpenStruct.new(uid: uid))
-      expect(homebrew.find_homebrew_uid(username)).to eq(uid)
-    end
-
-    it "raises an error when the brew executable is not found" do
-      allow(homebrew).to receive(:homebrew_bin_path).and_raise(Chef::Exceptions::CannotDetermineHomebrewPath)
-      expect { homebrew.find_homebrew_uid }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewPath)
-    end
-
-    it "returns the UID of the owner based on the brew executable" do
-      allow(homebrew).to receive(:homebrew_bin_path).and_return(alt_brew_path)
-      allow(File).to receive(:stat).with(alt_brew_path).and_return(OpenStruct.new(uid: uid))
-      allow(Etc).to receive(:getpwuid).with(uid).and_return(OpenStruct.new(name: username))
-      expect(homebrew.find_homebrew_uid).to eq(uid)
-    end
-  end
-
-  describe "#find_homebrew_username" do
-    it "returns the username for the provided UID" do
-      allow(homebrew).to receive(:find_homebrew_uid).and_return(uid)
-      allow(Etc).to receive(:getpwuid).with(uid).and_return(OpenStruct.new(name: username))
-      expect(homebrew.find_homebrew_username(uid)).to eq(username)
-    end
-  end
-
-  describe "#homebrew_bin_path" do
-    it "returns the correct path when a valid path is provided" do
-      allow(File).to receive(:exist?).with(alt_brew_path).and_return(true)
-      expect(homebrew.homebrew_bin_path(alt_brew_path)).to eq(alt_brew_path)
-    end
-
-    it "raises an error when the brew executable is not found" do
-      allow(homebrew).to receive(:which).and_return(false)
-      expect { homebrew.homebrew_bin_path }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewPath)
-    end
-  end
-
-  shared_examples "successfully find executable" do
-    let(:default_brew_path) { "/usr/local/bin/brew" }
-    let(:default_brew_path_arm) { "/opt/homebrew/bin/brew" }
-    let(:default_brew_path_linux) { "/home/linuxbrew/.linuxbrew/bin/brew" }
-
-    context "debug statement prints owner name" do
-
-      before do
-        expect(Etc).to receive(:getpwuid).with(uid).and_return(OpenStruct.new(name: username))
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for x86_64 machines" do
-        allow(homebrew).to receive(:homebrew_bin_path).and_return(default_brew_path)
-        allow(File).to receive(:stat).with(default_brew_path).and_return(OpenStruct.new(uid: uid))
-        expect(homebrew.find_homebrew_uid).to eq(uid)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for arm machines" do
-        allow(homebrew).to receive(:homebrew_bin_path).and_return(default_brew_path_arm)
-        allow(File).to receive(:stat).with(default_brew_path_arm).and_return(OpenStruct.new(uid: uid))
-        expect(homebrew.find_homebrew_uid).to eq(uid)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for linux machines" do
-        allow(homebrew).to receive(:homebrew_bin_path).and_return(default_brew_path_linux)
-        allow(File).to receive(:stat).with(default_brew_path_linux).and_return(OpenStruct.new(uid: uid))
-        expect(homebrew.find_homebrew_uid).to eq(uid)
-      end
-
-      it "returns the owner of the brew executable when it is not at a default location" do
-        allow(homebrew).to receive(:homebrew_bin_path).and_return(alt_brew_path)
-        allow(File).to receive(:stat).with(alt_brew_path).and_return(OpenStruct.new(uid: uid))
-        expect(homebrew.find_homebrew_uid).to eq(uid)
-      end
-    end
-  end
-
-  describe "#When the homebrew user is not provided" do
-
-    include_examples "successfully find executable"
-
-    context "the executable is owned by root" do
-      include_examples "successfully find executable" do
-        let(:uid) { 0 }
-      end
-    end
-  end
-end

data/spec/unit/mixin/lazy_module_include.rb

@@ -1,71 +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.
-#
-
-require "spec_helper"
-
-module TestA
-  extend Chef::Mixin::LazyModuleInclude
-end
-
-module TestB
-  include TestA
-  extend Chef::Mixin::LazyModuleInclude
-end
-
-class TestC
-  include TestB
-end
-
-module Monkey
-  def monkey
-    "monkey"
-  end
-end
-
-module Klowns
-  def klowns
-    "klowns"
-  end
-end
-
-TestA.send(:include, Monkey)
-
-TestB.send(:include, Klowns)
-
-describe Chef::Mixin::LazyModuleInclude do
-
-  it "tracks descendant classes of TestA" do
-    expect(TestA.descendants).to include(TestB)
-    expect(TestA.descendants).to include(TestC)
-  end
-
-  it "tracks descendent classes of TestB" do
-    expect(TestB.descendants).to eql([TestC])
-  end
-
-  it "including into A mixins in methods into B and C" do
-    expect(TestA.instance_methods).to include(:monkey)
-    expect(TestB.instance_methods).to include(:monkey)
-    expect(TestC.instance_methods).to include(:monkey)
-  end
-
-  it "including into B only mixins in methods into C" do
-    expect(TestA.instance_methods).not_to include(:klowns)
-    expect(TestB.instance_methods).to include(:klowns)
-    expect(TestC.instance_methods).to include(:klowns)
-  end
-end