chef 18.8.11 → 18.8.54

data/spec/unit/formatters/error_inspectors/run_list_expansion_error_inspector_spec.rb

@@ -1,91 +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"
-
-describe Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector do
-  before do
-    @node = Chef::Node.new.tap do |n|
-      n.name("unit-test.example.com")
-      n.run_list("role[base]")
-    end
-
-    @description = Chef::Formatters::ErrorDescription.new("Error Expanding RunList:")
-    @outputter = Chef::Formatters::IndentableOutputStream.new(StringIO.new, STDERR)
-    # @outputter = Chef::Formatters::IndentableOutputStream.new(STDOUT, STDERR)
-  end
-
-  describe "when explaining a missing role error" do
-
-    before do
-      @run_list_expansion = Chef::RunList::RunListExpansion.new("_default", @node.run_list)
-      @run_list_expansion.missing_roles_with_including_role << [ "role[missing-role]", "role[base]" ]
-      @run_list_expansion.missing_roles_with_including_role << [ "role[another-missing-role]", "role[base]" ]
-
-      @exception = Chef::Exceptions::MissingRole.new(@run_list_expansion)
-
-      @inspector = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a pretty message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining an HTTP 403 error" 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 = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
-      allow(@inspector).to receive(:config).and_return(node_name: "unit-test.example.com")
-
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a pretty message" do
-      @description.display(@outputter)
-    end
-
-  end
-
-  describe "when explaining an HTTP 401 error" 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 = Chef::Formatters::ErrorInspectors::RunListExpansionErrorInspector.new(@node, @exception)
-      allow(@inspector).to receive(:config).and_return(node_name: "unit-test.example.com",
-                                                       client_key: "/etc/chef/client.pem",
-                                                       chef_server_url: "http://chef.example.com")
-
-      @inspector.add_explanation(@description)
-    end
-
-    it "prints a pretty message" do
-      @description.display(@outputter)
-    end
-  end
-
-end

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -1,155 +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"
-
-describe Chef::GuardInterpreter::ResourceGuardInterpreter do
-  let(:node) do
-    node = Chef::Node.new
-
-    node.default["kernel"] = {}
-    node.default["kernel"][:machine] = :x86_64.to_s
-    node.automatic[:os] = "windows"
-    node
-  end
-
-  let(:run_context) { Chef::RunContext.new(node, nil, nil) }
-
-  let(:parent_resource) do
-    parent_resource = Chef::Resource.new("powershell_unit_test", run_context)
-    allow(parent_resource).to receive(:run_action)
-    allow(parent_resource).to receive(:updated).and_return(true)
-    parent_resource
-  end
-
-  let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "echo hi", nil) }
-
-  describe "get_interpreter_resource" do
-    it "allows the guard interpreter to be set to Chef::Resource::Script" do
-      parent_resource.guard_interpreter(:script)
-      expect { guard_interpreter }.not_to raise_error
-    end
-
-    it "allows the guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
-      parent_resource.guard_interpreter(:powershell_script)
-      expect { guard_interpreter }.not_to raise_error
-    end
-
-    it "raises an exception if guard_interpreter is set to a resource not derived from Chef::Resource::Script" do
-      parent_resource.guard_interpreter(:file)
-      expect { guard_interpreter }.to raise_error(ArgumentError, "Specified guard interpreter class Chef::Resource::File must be a kind of Chef::Resource::Execute resource")
-    end
-
-    context "when the resource cannot be found for the platform" do
-      before do
-        expect(Chef::Resource).to receive(:resource_for_node).with(:foobar, node).and_return(nil)
-      end
-
-      it "raises an exception" do
-        parent_resource.guard_interpreter(:foobar)
-        expect { guard_interpreter }.to raise_error(ArgumentError, "Specified guard_interpreter resource foobar unknown for this platform")
-      end
-    end
-
-    it "fails when parent_resource is nil" do
-      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(nil, "echo hi", nil) }.to raise_error(ArgumentError, /Node for guard resource parent must not be nil/)
-    end
-
-  end
-
-  describe "#evaluate" do
-    let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "echo hi", {}) }
-    let(:parent_resource) do
-      parent_resource = Chef::Resource.new("execute resource", run_context)
-      parent_resource.guard_interpreter(:execute)
-      parent_resource
-    end
-
-    it "successfully evaluates the resource" do
-      expect(guard_interpreter.evaluate).to eq(true)
-    end
-
-    it "does not corrupt the run_context of the node" do
-      node_run_context_before_guard_execution = parent_resource.run_context
-      expect(node_run_context_before_guard_execution.object_id).to eq(parent_resource.node.run_context.object_id)
-      guard_interpreter.evaluate
-      node_run_context_after_guard_execution = parent_resource.run_context
-      expect(node_run_context_after_guard_execution.object_id).to eq(parent_resource.node.run_context.object_id)
-    end
-
-    describe "script command opts switch" do
-      let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "exit 0", {}) }
-      let(:resource) { guard_interpreter.instance_variable_get(:@resource) }
-
-      context "resource is a Script" do
-        context "and guard_interpreter is a :script" do
-          let(:parent_resource) do
-            parent_resource = Chef::Resource::Script.new("resource", run_context)
-            # Ruby scripts are cross platform to both Linux and Windows
-            parent_resource.guard_interpreter(:ruby)
-            parent_resource
-          end
-
-          let(:shell_out) do
-            instance_double(Mixlib::ShellOut, live_stream: true, run_command: true, error!: nil)
-          end
-
-          before do
-            # TODO for some reason Windows is failing on executing a ruby script
-            expect(Mixlib::ShellOut).to receive(:new) do |*args|
-              expect(args[0]).to match(/^"ruby"/)
-              shell_out
-            end
-          end
-
-          it "assigns the comand to the resource's code property" do
-            guard_interpreter.evaluate
-            expect(resource.code).to eq("exit 0")
-          end
-        end
-
-        context "and guard_interpreter is :execute" do
-          let(:parent_resource) do
-            parent_resource = Chef::Resource::Script.new("resource", run_context)
-            parent_resource.guard_interpreter(:execute)
-            parent_resource
-          end
-
-          it "assigns the comand to the resource's command property" do
-            guard_interpreter.evaluate
-            expect(resource.command).to eq("exit 0")
-          end
-        end
-      end
-
-      context "resource is not a Script" do
-        let(:parent_resource) do
-          parent_resource = Chef::Resource::Execute.new("resource", run_context)
-          parent_resource.guard_interpreter(:execute)
-          parent_resource
-        end
-
-        it "assigns the comand to the resource's command property" do
-          guard_interpreter.evaluate
-          expect(resource.command).to eq("exit 0")
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/guard_interpreter_spec.rb

@@ -1,41 +0,0 @@
-#
-# Author:: Steven Danna (steve@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"
-
-describe Chef::GuardInterpreter do
-  describe "#for_resource" do
-    let(:resource) { Chef::Resource.new("foo") }
-
-    it "returns a DefaultGuardInterpreter if the resource has guard_interpreter set to :default" do
-      resource.guard_interpreter :default
-      interpreter = Chef::GuardInterpreter.for_resource(resource, "", {})
-      expect(interpreter.class).to eq(Chef::GuardInterpreter::DefaultGuardInterpreter)
-    end
-
-    it "returns a ResourceGuardInterpreter if the resource has guard_interpreter set to !:default" do
-      resource.guard_interpreter :foobar
-      # Mock the resource guard interpreter to avoid having to set up a lot of state
-      # currently we are only testing that we get the correct class of object back
-      rgi = double("Chef::GuardInterpreter::ResourceGuardInterpreter")
-      allow(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:new).and_return(rgi)
-      interpreter = Chef::GuardInterpreter.for_resource(resource, "", {})
-      expect(interpreter).to eq(rgi)
-    end
-  end
-end

data/spec/unit/handler/json_file_spec.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-
-describe Chef::Handler::JsonFile do
-  before(:each) do
-    @handler = Chef::Handler::JsonFile.new(the_sun: "will rise", path: "/tmp/foobarbazqux")
-  end
-
-  it "accepts arbitrary config options" do
-    expect(@handler.config[:the_sun]).to eq("will rise")
-  end
-
-  it "creates the directory where the reports will be saved" do
-    expect(FileUtils).to receive(:mkdir_p).with("/tmp/foobarbazqux")
-    expect(File).to receive(:chmod).with(00700, "/tmp/foobarbazqux")
-    @handler.build_report_dir
-  end
-
-  describe "when reporting success" do
-    before(:each) do
-      @node = Chef::Node.new
-      @events = Chef::EventDispatch::Dispatcher.new
-      @run_status = Chef::RunStatus.new(@node, @events)
-      @expected_time = Time.now
-      allow(Time).to receive(:now).and_return(@expected_time, @expected_time + 5)
-      @run_status.start_clock
-      @run_status.stop_clock
-      @run_context = Chef::RunContext.new(@node, {}, @events)
-      @run_status.run_context = @run_context
-      @run_status.exception = Exception.new("Boy howdy!")
-      @file_mock = StringIO.new
-      allow(File).to receive(:open).and_yield(@file_mock)
-    end
-
-    it "saves run status data to a file as JSON" do
-      expect(@handler).to receive(:build_report_dir)
-      @handler.run_report_unsafe(@run_status)
-      reported_data = Chef::JSONCompat.parse(@file_mock.string)
-      expect(reported_data["exception"]).to eq("Exception: Boy howdy!")
-      expect(reported_data["start_time"]).to eq(@expected_time.to_s)
-      expect(reported_data["end_time"]).to eq((@expected_time + 5).to_s)
-      expect(reported_data["elapsed_time"]).to eq(5)
-    end
-
-  end
-end

data/spec/unit/handler_spec.rb

@@ -1,308 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-
-describe Chef::Handler do
-  before(:each) do
-    @handler = Chef::Handler.new
-
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_status = Chef::RunStatus.new(@node, @events)
-
-    @handler.instance_variable_set(:@run_status, @run_status)
-  end
-
-  describe "when accessing the run status" do
-    before do
-      @backtrace = caller
-      @exception = Exception.new("epic_fail")
-      @exception.set_backtrace(@backtrace)
-      @run_status.exception = @exception
-      @run_context = Chef::RunContext.new(@node, {}, @events)
-      @all_resources = [Chef::Resource::Cat.new("lolz"), Chef::Resource::ZenMaster.new("tzu")]
-      @all_resources.first.updated_by_last_action true
-      @handler.instance_variable_set(:@all_resources, @all_resources)
-      @handler.instance_variable_set(:@updated_resources, [@all_resources.first])
-      @run_context.resource_collection.all_resources.replace(@all_resources)
-      @run_status.run_context = @run_context
-      @start_time = Time.now
-      @end_time = @start_time + 4.2
-      allow(Time).to receive(:now).and_return(@start_time, @end_time)
-      @run_status.start_clock
-      @run_status.stop_clock
-    end
-
-    it "has a shortcut for the exception" do
-      expect(@handler.exception).to eq(@exception)
-    end
-
-    it "has a shortcut for the backtrace" do
-      expect(@handler.backtrace).to eq(@backtrace)
-    end
-
-    it "has a shortcut for all resources" do
-      expect(@handler.all_resources).to eq(@all_resources)
-    end
-
-    it "has a shortcut for just the updated resources" do
-      expect(@handler.updated_resources).to eq([@all_resources.first])
-    end
-
-    it "has a shortcut for the start time" do
-      expect(@handler.start_time).to eq(@start_time)
-    end
-
-    it "has a shortcut for the end time" do
-      expect(@handler.end_time).to eq(@end_time)
-    end
-
-    it "has a shortcut for the elapsed time" do
-      expect(@handler.elapsed_time).to eq(4.2)
-    end
-
-    it "has a shortcut for the node" do
-      expect(@handler.node).to eq(@node)
-    end
-
-    it "has a shortcut for the run context" do
-      expect(@handler.run_context).to eq(@run_context)
-    end
-
-    it "has a shortcut for the success? and failed? predicates" do
-      expect(@handler.success?).to be_falsey # because there's an exception
-      expect(@handler.failed?).to be_truthy
-    end
-
-    it "has a shortcut to the hash representation of the run status" do
-      expect(@handler.data).to eq(@run_status.to_hash)
-    end
-  end
-
-  describe "when running the report" do
-    it "does not fail if the report handler raises an exception" do
-      $report_ran = false
-      def @handler.report
-        $report_ran = true
-        raise Exception, "I died the deth"
-      end
-      expect { @handler.run_report_safely(@run_status) }.not_to raise_error
-      expect($report_ran).to be_truthy
-    end
-    it "does not fail if the report handler does not raise an exception" do
-      $report_ran = false
-      def @handler.report
-        $report_ran = true
-      end
-      expect { @handler.run_report_safely(@run_status) }.not_to raise_error
-      expect($report_ran).to be_truthy
-    end
-  end
-
-  # Hmm, no tests for report handlers, looks like
-  describe "when running a report handler" do
-    before do
-      @run_context = Chef::RunContext.new(@node, {}, @events)
-      @all_resources = [Chef::Resource::Cat.new("foo"), Chef::Resource::ZenMaster.new("moo")]
-      @all_resources.first.updated_by_last_action true
-      @handler.instance_variable_set(:@all_resources, @all_resources)
-      @handler.instance_variable_set(:@updated_resources, [@all_resources.first])
-      @run_context.resource_collection.all_resources.replace(@all_resources)
-      @run_status.run_context = @run_context
-      @start_time = Time.now
-      @end_time = @start_time + 4.2
-      allow(Time).to receive(:now).and_return(@start_time, @end_time)
-      @run_status.start_clock
-      @run_status.stop_clock
-    end
-
-    it "has a shortcut for all resources" do
-      expect(@handler.all_resources).to eq(@all_resources)
-    end
-
-    it "has a shortcut for just the updated resources" do
-      expect(@handler.updated_resources).to eq([@all_resources.first])
-    end
-
-    it "has a shortcut for the start time" do
-      expect(@handler.start_time).to eq(@start_time)
-    end
-
-    it "has a shortcut for the end time" do
-      expect(@handler.end_time).to eq(@end_time)
-    end
-
-    it "has a shortcut for the elapsed time" do
-      expect(@handler.elapsed_time).to eq(4.2)
-    end
-
-    it "has a shortcut for the node" do
-      expect(@handler.node).to eq(@node)
-    end
-
-    it "has a shortcut for the run context" do
-      expect(@handler.run_context).to eq(@run_context)
-    end
-
-    it "has a shortcut for the success? and failed? predicates" do
-      expect(@handler.success?).to be_truthy
-      expect(@handler.failed?).to be_falsey
-    end
-
-    it "has a shortcut to the hash representation of the run status" do
-      expect(@handler.data).to eq(@run_status.to_hash)
-    end
-  end
-
-  # and this would test the start handler
-  describe "when running a start handler" do
-    before do
-      @handler.instance_variable_set(:@all_resources, [])
-      @handler.instance_variable_set(:@updated_resources, [])
-      @start_time = Time.now
-      allow(Time).to receive(:now).and_return(@start_time)
-      @run_status.start_clock
-    end
-
-    it "should not have all resources" do
-      expect(@handler.all_resources).to be_empty
-    end
-
-    it "should not have updated resources" do
-      expect(@handler.updated_resources).to be_empty
-    end
-
-    it "has a shortcut for the start time" do
-      expect(@handler.start_time).to eq(@start_time)
-    end
-
-    it "does not have a shortcut for the end time" do
-      expect(@handler.end_time).to be_falsey
-    end
-
-    it "does not have a shortcut for the elapsed time" do
-      expect(@handler.elapsed_time).to be_falsey
-    end
-
-    it "has a shortcut for the node" do
-      expect(@handler.node).to eq(@node)
-    end
-
-    it "does not have a shortcut for the run context" do
-      expect(@handler.run_context).to be_falsey
-    end
-
-    it "has a shortcut for the success? and failed? predicates" do
-      expect(@handler.success?).to be_truthy # for some reason this is true
-      expect(@handler.failed?).to be_falsey
-    end
-
-    it "has a shortcut to the hash representation of the run status" do
-      expect(@handler.data).to eq(@run_status.to_hash)
-    end
-  end
-
-  describe "library report handler" do
-    before do
-      # we need to lazily declare this after we have reset Chef::Config in the default rspec before handler
-      class MyTestHandler < Chef::Handler
-        handler_for :report, :exception, :start
-
-        class << self
-          attr_accessor :ran_report
-        end
-
-        def report
-          self.class.ran_report = true
-        end
-      end
-    end
-
-    it "gets added to Chef::Config[:report_handlers]" do
-      expect(Chef::Config[:report_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "gets added to Chef::Config[:exception_handlers]" do
-      expect(Chef::Config[:exception_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "gets added to Chef::Config[:start_handlers]" do
-      expect(Chef::Config[:start_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "runs the report handler" do
-      Chef::Handler.run_report_handlers(@run_status)
-      expect(MyTestHandler.ran_report).to be true
-    end
-
-    it "runs the exception handler" do
-      Chef::Handler.run_exception_handlers(@run_status)
-      expect(MyTestHandler.ran_report).to be true
-    end
-
-    it "runs the start handler" do
-      Chef::Handler.run_start_handlers(@run_status)
-      expect(MyTestHandler.ran_report).to be true
-    end
-  end
-
-  describe "library singleton report handler" do
-    before do
-      # we need to lazily declare this after we have reset Chef::Config in the default rspec before handler
-      class MyTestHandler < Chef::Handler
-        handler_for :report, :exception, :start
-
-        include Singleton
-
-        attr_accessor :ran_report
-
-        def report
-          self.ran_report = true
-        end
-      end
-    end
-
-    it "gets added to Chef::Config[:report_handlers]" do
-      expect(Chef::Config[:report_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "gets added to Chef::Config[:exception_handlers]" do
-      expect(Chef::Config[:exception_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "gets added to Chef::Config[:start_handlers]" do
-      expect(Chef::Config[:start_handlers].include?(MyTestHandler)).to be true
-    end
-
-    it "runs the report handler" do
-      Chef::Handler.run_report_handlers(@run_status)
-      expect(MyTestHandler.instance.ran_report).to be true
-    end
-
-    it "runs the exception handler" do
-      Chef::Handler.run_exception_handlers(@run_status)
-      expect(MyTestHandler.instance.ran_report).to be true
-    end
-
-    it "runs the start handler" do
-      Chef::Handler.run_start_handlers(@run_status)
-      expect(MyTestHandler.instance.ran_report).to be true
-    end
-  end
-end