chef 18.8.11 → 18.8.54

data/spec/unit/mixin/unformatter_spec.rb

@@ -1,60 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@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/unformatter"
-
-class Chef::UnformatterTest
-  include Chef::Mixin::Unformatter
-
-  def foo; end
-
-end
-
-describe Chef::Mixin::Unformatter do
-  let(:unformatter) { Chef::UnformatterTest.new }
-  let(:message) { "Test Message" }
-
-  describe "#write" do
-    context "with a timestamp" do
-      it "sends foo to itself when the message is of severity foo" do
-        expect(unformatter).to receive(:foo).with(message)
-        unformatter.write("[time] foo: #{message}")
-      end
-
-      it "sends foo to itself when the message is of severity FOO" do
-        expect(unformatter).to receive(:foo).with(message)
-        unformatter.write("[time] FOO: #{message}")
-      end
-    end
-
-    context "without a timestamp" do
-      it "sends foo to itself when the message is of severity foo" do
-        expect(unformatter).to receive(:foo).with(message)
-        unformatter.write("foo: #{message}")
-      end
-
-      it "sends foo to itself when the message is of severity FOO" do
-        expect(unformatter).to receive(:foo).with(message)
-        unformatter.write("FOO: #{message}")
-      end
-    end
-
-  end
-
-end

data/spec/unit/mixin/uris_spec.rb

@@ -1,57 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@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/uris"
-
-class Chef::UrisTest
-  include Chef::Mixin::Uris
-end
-
-describe Chef::Mixin::Uris do
-  let(:uris) { Chef::UrisTest.new }
-
-  describe "#uri_scheme?" do
-    it "matches 'scheme://foo.com'" do
-      expect(uris.uri_scheme?("scheme://foo.com")).to eq(true)
-    end
-
-    it "does not match 'c:/foo.com'" do
-      expect(uris.uri_scheme?("c:/foo.com")).to eq(false)
-    end
-
-    it "does not match '/usr/bin/foo.com'" do
-      expect(uris.uri_scheme?("/usr/bin/foo.com")).to eq(false)
-    end
-
-    it "does not match 'c:/foo.com://bar.com'" do
-      expect(uris.uri_scheme?("c:/foo.com://bar.com")).to eq(false)
-    end
-  end
-
-  describe "#as_uri" do
-    it "parses a file scheme uri with spaces" do
-      expect { uris.as_uri("file:///c:/foo bar.txt") }.not_to raise_exception
-    end
-
-    it "returns a URI object" do
-      expect( uris.as_uri("file:///c:/foo bar.txt") ).to be_a(URI)
-    end
-  end
-
-end

data/spec/unit/mixin/user_context_spec.rb

@@ -1,99 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@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/user_context"
-require "chef/util/windows/logon_session"
-
-describe "a class that mixes in user_context" do
-  let(:instance_with_user_context) do
-    class UserContextConsumer
-      include ::Chef::Mixin::UserContext
-      def with_context(user, domain, password, &block)
-        with_user_context(user, password, domain, &block)
-      end
-    end
-    UserContextConsumer.new
-  end
-
-  shared_examples_for "a method that requires a block" do
-    it "raises an ArgumentError exception if a block is not supplied" do
-      expect { instance_with_user_context.with_context(nil, nil, nil) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "when running on Windows" do
-    before do
-      allow(ChefUtils).to receive(:windows?).and_return(true)
-      allow(::Chef::Util::Windows::LogonSession).to receive(:new).and_return(logon_session)
-    end
-
-    let(:logon_session) { instance_double("::Chef::Util::Windows::LogonSession", set_user_context: nil, open: nil, close: nil) }
-
-    it "does not raise an exception when the user and all parameters are nil" do
-      expect { instance_with_user_context.with_context(nil, nil, nil) {} }.not_to raise_error
-    end
-
-    context "when given valid user credentials" do
-      before do
-        expect(::Chef::Util::Windows::LogonSession).to receive(:new).and_return(logon_session)
-      end
-
-      let(:block_object) do
-        class BlockClass
-          def block_method; end
-        end
-        BlockClass.new
-      end
-
-      let(:block_parameter) { Proc.new { block_object.block_method } }
-
-      context "when the block doesn't raise an exception" do
-        before do
-          expect( block_object ).to receive(:block_method)
-        end
-        it "calls the supplied block" do
-          expect { instance_with_user_context.with_context("kamilah", nil, "chef4life", &block_parameter) }.not_to raise_error
-        end
-
-        it "does not raise an exception if the user, password, and domain are specified" do
-          expect { instance_with_user_context.with_context("kamilah", "xanadu", "chef4life", &block_parameter) }.not_to raise_error
-        end
-      end
-
-      context "when the block raises an exception" do
-        it "closes the logon session so resources are not leaked" do
-          expect(logon_session).to receive(:close)
-          expect { instance_with_user_context.with_context("kamilah", nil, "chef4life") { 1 / 0 } }.to raise_error(ZeroDivisionError)
-        end
-      end
-    end
-
-    it_behaves_like "a method that requires a block"
-  end
-
-  context "when not running on Windows" do
-    before do
-      allow(ChefUtils).to receive(:windows?).and_return(false)
-    end
-
-    it "raises a ::Chef::Exceptions::UnsupportedPlatform exception" do
-      expect { instance_with_user_context.with_context(nil, nil, nil) {} }.to raise_error(::Chef::Exceptions::UnsupportedPlatform)
-    end
-  end
-end

data/spec/unit/mixin/versioned_api_spec.rb

@@ -1,128 +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"
-require "chef/mixin/versioned_api"
-
-describe Chef::Mixin::VersionedAPI do
-  let(:dummy_class) { Class.new { extend Chef::Mixin::VersionedAPI } }
-
-  it "allows a class to declare the minimum supported API version" do
-    dummy_class.minimum_api_version 3
-    expect(dummy_class.minimum_api_version).to eq(3)
-  end
-end
-
-describe Chef::Mixin::VersionedAPIFactory do
-  class V1Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 1; end
-  class V2Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 2; end
-  class V3Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 3; end
-
-  let(:factory_class) { Class.new { extend Chef::Mixin::VersionedAPIFactory } }
-
-  before do
-    Chef::ServerAPIVersions.instance.reset!
-  end
-
-  describe "#add_versioned_api_class" do
-    it "adds a target class" do
-      factory_class.add_versioned_api_class V1Class
-      expect(factory_class.versioned_interfaces).to eq([V1Class])
-    end
-
-    it "can be called many times" do
-      factory_class.add_versioned_api_class V1Class
-      factory_class.add_versioned_api_class V2Class
-      expect(factory_class.versioned_interfaces).to eq([V1Class, V2Class])
-    end
-  end
-
-  describe "#versioned_api_class" do
-    describe "with no known versions" do
-      it "with one class it returns that class" do
-        factory_class.add_versioned_api_class V2Class
-        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
-      end
-
-      it "with many classes it returns the highest minimum version" do
-        factory_class.add_versioned_api_class V1Class
-        factory_class.add_versioned_api_class V2Class
-        factory_class.add_versioned_api_class V3Class
-        expect(factory_class.versioned_api_class.minimum_api_version).to eq(3)
-      end
-    end
-
-    describe "with a known version" do
-      it "with one class it returns that class" do
-        Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
-        factory_class.add_versioned_api_class V2Class
-        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
-      end
-
-      it "with a maximum version it returns the highest possible versioned class" do
-        Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
-        factory_class.add_versioned_api_class V1Class
-        factory_class.add_versioned_api_class V2Class
-        factory_class.add_versioned_api_class V3Class
-        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
-      end
-    end
-
-    it "with no classes it returns nil" do
-      expect(factory_class.versioned_api_class).to be_nil
-    end
-  end
-
-  describe "#best_request_version" do
-    it "returns a String" do
-      factory_class.add_versioned_api_class V2Class
-      expect(factory_class.best_request_version).to be_a(String)
-    end
-
-    it "returns the most relevant version" do
-      factory_class.add_versioned_api_class V2Class
-      factory_class.add_versioned_api_class V3Class
-      expect(factory_class.best_request_version).to eq("3")
-    end
-  end
-
-  describe "#possible_requests" do
-    it "returns the number of registered classes" do
-      factory_class.add_versioned_api_class V2Class
-      factory_class.add_versioned_api_class V3Class
-      expect(factory_class.possible_requests).to eq(2)
-    end
-  end
-
-  describe "#new" do
-    it "creates an instance of the versioned class" do
-      factory_class.add_versioned_api_class V2Class
-      expect { factory_class.new }.to_not raise_error
-      expect(factory_class.new.class).to eq(V2Class)
-    end
-  end
-
-  describe "#def_versioned_delegator" do
-    it "delegates the method to the correct class" do
-      factory_class.add_versioned_api_class V2Class
-      factory_class.def_versioned_delegator("test_method")
-      expect(V2Class).to receive(:test_method).with("test message").and_return(true)
-
-      factory_class.test_method("test message")
-    end
-  end
-end

data/spec/unit/mixin/which.rb

@@ -1,170 +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"
-
-class TestClass
-  include Chef::Mixin::Which
-end
-
-describe Chef::Mixin::Which do
-
-  let(:test) { TestClass.new }
-
-  describe "#which" do
-    def self.test_which(description, *args, finds: nil, others: [], directory: false, &block)
-      it description do
-        # stub the ENV['PATH']
-        expect(test).to receive(:env_path).and_return(["/dir1", "/dir2" ].join(File::PATH_SEPARATOR))
-
-        # most files should not be found
-        allow(File).to receive(:executable?).and_return(false)
-        allow(File).to receive(:directory?).and_return(false)
-
-        # stub the expectation
-        expect(File).to receive(:executable?).with(finds).and_return(true) if finds
-
-        # if the file we find is a directory
-        expect(File).to receive(:directory?).with(finds).and_return(true) if finds && directory
-
-        # allow for stubbing other paths to exist that we should not find
-        others.each do |other|
-          allow(File).to receive(:executable?).with(other).and_return(true)
-        end
-
-        # setup the actual expectation on the return value
-        if finds && !directory
-          expect(test.which(*args, &block)).to eql(finds)
-        else
-          expect(test.which(*args, &block)).to eql(false)
-        end
-      end
-    end
-
-    context "simple usage" do
-      test_which("returns false when it does not find anything", "foo1")
-
-      ["/dir1", "/dir2", "/bin", "/usr/bin", "/sbin", "/usr/sbin" ].each do |dir|
-        test_which("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: "#{dir}/foo1")
-      end
-
-      test_which("does not find an executable directory", "foo1", finds: "/dir1/foo1", directory: true)
-    end
-
-    context "with an array of args" do
-      test_which("finds the first arg", "foo1", "foo2", finds: "/dir2/foo1")
-
-      test_which("finds the second arg", "foo1", "foo2", finds: "/dir2/foo2")
-
-      test_which("finds the first arg when there's both", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ])
-
-      test_which("and the directory order can be reversed", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir2/foo2" ])
-
-      test_which("or be the same", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir1/foo2" ])
-    end
-
-    context "with a block" do
-      test_which("doesnt find it if its false", "foo1", others: [ "/dir1/foo1" ]) do |f|
-        false
-      end
-
-      test_which("finds it if its true", "foo1", finds: "/dir1/foo1") do |f|
-        true
-      end
-
-      test_which("passes in the filename as the arg", "foo1", finds: "/dir1/foo1") do |f|
-        raise "bad arg to block" unless f == "/dir1/foo1"
-
-        true
-      end
-
-      test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
-        raise "bad arg to block" unless ["/dir2/foo1", "/dir1/foo2"].include?(f)
-
-        true
-      end
-    end
-  end
-
-  describe "#where" do
-    def self.test_where(description, *args, finds: [], others: [], &block)
-      it description do
-        # stub the ENV['PATH']
-        expect(test).to receive(:env_path).and_return(["/dir1", "/dir2" ].join(File::PATH_SEPARATOR))
-
-        # most files should not be found
-        allow(File).to receive(:executable?).and_return(false)
-        allow(File).to receive(:directory?).and_return(false)
-
-        # allow for stubbing other paths to exist that we should not return
-        others.each do |other|
-          allow(File).to receive(:executable?).with(other).and_return(true)
-        end
-
-        # stub the expectation
-        finds.each do |path|
-          expect(File).to receive(:executable?).with(path).and_return(true)
-        end
-
-        # setup the actual expectation on the return value
-        expect(test.where(*args, &block)).to eql(finds)
-      end
-    end
-
-    context "simple usage" do
-      test_where("returns empty array when it doesn't find anything", "foo1")
-
-      ["/dir1", "/dir2", "/bin", "/usr/bin", "/sbin", "/usr/sbin" ].each do |dir|
-        test_where("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: [ "#{dir}/foo1" ])
-      end
-
-      test_where("finds `foo1` in all directories", "foo1", finds: [ "/dir1/foo1", "/dir2/foo1" ])
-    end
-
-    context "with an array of args" do
-      test_where("finds the first arg", "foo1", "foo2", finds: [ "/dir2/foo1" ])
-
-      test_where("finds the second arg", "foo1", "foo2", finds: [ "/dir2/foo2" ])
-
-      test_where("finds foo1 before foo2", "foo1", "foo2", finds: [ "/dir2/foo1", "/dir1/foo2" ])
-
-      test_where("finds foo1 before foo2 if the dirs are reversed", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir2/foo2" ])
-
-      test_where("finds them both in the same directory", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir1/foo2" ])
-
-      test_where("finds foo2 first if they're reversed", "foo2", "foo1", finds: [ "/dir1/foo2", "/dir1/foo1" ])
-    end
-
-    context "with a block do" do
-      test_where("finds foo1 and foo2 if they exist and the block is true", "foo1", "foo2", finds: [ "/dir1/foo2", "/dir2/foo2" ]) do
-        true
-      end
-
-      test_where("does not finds foo1 and foo2 if they exist and the block is false", "foo1", "foo2", others: [ "/dir1/foo2", "/dir2/foo2" ]) do
-        false
-      end
-    end
-  end
-
-  describe "useful non-stubbed tests" do
-    it "works even when the PATH is nuked via adding default_paths", unix_only: true do
-      old_path = ENV["PATH"]
-      expect(test.which("ls")).to be_truthy
-      ENV["PATH"] = old_path
-    end
-  end
-end

data/spec/unit/mixin/why_run_spec.rb

@@ -1,53 +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"
-
-describe Chef::Mixin::WhyRun::ResourceRequirements do
-  class TestResource < Chef::Resource
-    action_class do
-      def define_resource_requirements
-        requirements.assert(:boom) do |a|
-          a.assertion { raise "boom1" }
-          a.failure_message("#{raise "boom2"}")
-          a.whyrun("#{raise "boom3"}")
-        end
-      end
-    end
-
-    action :boom do
-      # nothing
-    end
-
-    action :noboom do
-      # nothing
-    end
-  end
-
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { TestResource.new("name", run_context) }
-
-  it "raises an exception for an action where the assertions raise exceptions" do
-    expect { resource.run_action(:boom) }.to raise_error(StandardError, /boom2/)
-  end
-
-  it "does not raise an exception for an action which has no assertions" do
-    resource.run_action(:noboom)
-  end
-end

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -1,85 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@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/windows_architecture_helper"
-
-describe Chef::Mixin::WindowsArchitectureHelper do
-  include Chef::Mixin::WindowsArchitectureHelper
-
-  before do
-    @valid_architectures = %i{i386 x86_64}
-    @invalid_architectures = [ "i386", "x86_64", :x64, :x86, :arm ]
-
-    @node_i386 = Chef::Node.new
-    @node_x86_64 = Chef::Node.new
-  end
-
-  it "returns true when valid architectures are passed to valid_windows_architecture?" do
-    @valid_architectures.each do |architecture|
-      expect(valid_windows_architecture?(architecture)).to eq(true)
-    end
-  end
-
-  it "returns false when invalid architectures are passed to valid_windows_architecture?" do
-    @invalid_architectures.each do |architecture|
-      expect(valid_windows_architecture?(architecture)).to eq(false)
-    end
-  end
-
-  it "does not raise an exception when a valid architecture is passed to assert_valid_windows_architecture!" do
-    @valid_architectures.each do |architecture|
-      assert_valid_windows_architecture!(architecture)
-    end
-  end
-
-  it "raises an error if an invalid architecture is passed to assert_valid_windows_architecture!" do
-    @invalid_architectures.each do |architecture|
-
-      expect(assert_valid_windows_architecture!(architecture)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
-    rescue Chef::Exceptions::Win32ArchitectureIncorrect
-
-    end
-  end
-
-  it "returns true only for supported desired architecture passed to node_supports_windows_architecture" do
-    with_node_architecture_combinations do |node, desired_arch|
-      expect(node_supports_windows_architecture?(node, desired_arch)).to be true if node_windows_architecture(node) == :x86_64 || desired_arch == :i386
-      expect(node_supports_windows_architecture?(node, desired_arch)).to be false if node_windows_architecture(node) == :i386 && desired_arch == :x86_64
-    end
-  end
-
-  it "returns true only when forced_32bit_override_required? has 64-bit node architecture and 32-bit desired architecture" do
-    with_node_architecture_combinations do |node, desired_arch|
-      expect(forced_32bit_override_required?(node, desired_arch)).to be true if (node_windows_architecture(node) == :x86_64) && (desired_arch == :i386) && !is_i386_process_on_x86_64_windows?
-      expect(forced_32bit_override_required?(node, desired_arch)).to be false unless (node_windows_architecture(node) == :x86_64) && (desired_arch == :i386)
-    end
-  end
-
-  def with_node_architecture_combinations
-    @valid_architectures.each do |node_architecture|
-      new_node = Chef::Node.new
-      new_node.default["kernel"] = {}
-      new_node.default["kernel"][:machine] = node_architecture.to_s
-
-      @valid_architectures.each do |architecture|
-        yield new_node, architecture if block_given?
-      end
-    end
-  end
-end