chef 18.8.11 → 18.8.54

data/spec/unit/run_lock_spec.rb

@@ -1,144 +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/client"
-
-# FIXME: these are disabled on MacOS due to timing issues in our anka build cluster
-# these issues should be fixed and the tests should be re-eenabled.  If we are getting
-# omnibus test phases on mac tests which are reasonable and not ~3 hours long, then the
-# condition to avoid this testing on macs can be deleted
-describe Chef::RunLock, :not_supported_on_macos do
-
-  default_cache_path = windows? ? 'C:\chef' : "/var/chef"
-  default_pid_location = windows? ? 'C:\chef\cache\chef-client-running.pid' : "/var/chef/cache/chef-client-running.pid"
-
-  describe "when first created" do
-    it "locates the lockfile in the file cache path by default" do
-      allow(Chef::Config).to receive(:cache_path).and_return(default_cache_path)
-      run_lock = Chef::RunLock.new(Chef::Config.lockfile)
-      expect(run_lock.runlock_file).to eq(default_pid_location)
-    end
-
-    it "locates the lockfile in the user-configured path when set" do
-      Chef::Config.lockfile = "/tmp/chef-client-running.pid"
-      run_lock = Chef::RunLock.new(Chef::Config.lockfile)
-      expect(run_lock.runlock_file).to eq("/tmp/chef-client-running.pid")
-    end
-  end
-
-  describe "acquire" do
-    let(:lockfile) { "/tmp/chef-client-running.pid" }
-    subject(:runlock) { Chef::RunLock.new(lockfile) }
-
-    def stub_unblocked_run
-      allow(runlock).to receive(:test).and_return(true)
-    end
-
-    def stub_blocked_run(duration)
-      allow(runlock).to receive(:test).and_return(false)
-      allow(runlock).to receive(:wait) { sleep(duration) }
-      allow(runlock).to receive(:runpid).and_return(666) # errors read blocking pid
-    end
-
-    describe "when Chef::Config[:run_lock_timeout] is not set (set to default)" do
-      describe "and the lockfile is not locked by another client run" do
-        it "should not wait" do
-          stub_unblocked_run
-          expect_any_instance_of(Chef::RunLock).not_to receive(:wait)
-          runlock.acquire
-        end
-      end
-
-      describe "and the lockfile is locked by another client run" do
-        it "should wait for the lock to be released" do
-          stub_blocked_run(0.001)
-          expect(runlock).to receive(:wait)
-          runlock.acquire
-        end
-      end
-    end
-
-    describe "when Chef::Config[:run_lock_timeout] is set to 0" do
-      before(:each) do
-        @default_timeout = Chef::Config[:run_lock_timeout]
-        Chef::Config[:run_lock_timeout] = 0
-      end
-
-      after(:each) do
-        Chef::Config[:run_lock_timeout] = @default_timeout
-      end
-
-      describe "and the lockfile is not locked by another client run" do
-        it "should acquire the lock" do
-          stub_unblocked_run
-          expect(runlock).not_to receive(:wait)
-          runlock.acquire
-        end
-      end
-
-      describe "and the lockfile is locked by another client run" do
-        it "should raise Chef::Exceptions::RunLockTimeout" do
-          stub_blocked_run(0.001)
-          expect(runlock).not_to receive(:wait)
-          expect { runlock.acquire }.to raise_error(Chef::Exceptions::RunLockTimeout)
-        end
-      end
-    end
-
-    describe "when Chef::Config[:run_lock_timeout] is set to >0" do
-      before(:each) do
-        @default_timeout = Chef::Config[:run_lock_timeout]
-        @timeout = 0.1
-        Chef::Config[:run_lock_timeout] = @timeout
-      end
-
-      after(:each) do
-        Chef::Config[:run_lock_timeout] = @default_timeout
-      end
-
-      describe "and the lockfile is not locked by another client run" do
-        it "should acquire the lock" do
-          stub_unblocked_run
-          expect(runlock).not_to receive(:wait)
-          runlock.acquire
-        end
-      end
-
-      describe "and the lockfile is locked by another client run" do
-        describe "and the lock is released before the timeout expires" do
-          it "should acquire the lock" do
-            stub_blocked_run(@timeout / 2.0)
-            expect(runlock).to receive(:wait)
-            expect { runlock.acquire }.not_to raise_error
-          end
-        end
-
-        describe "and the lock is not released before the timeout expires" do
-          it "should raise a RunLockTimeout exception" do
-            stub_blocked_run(2.0)
-            expect(runlock).to receive(:wait)
-            expect { runlock.acquire }.to raise_error(Chef::Exceptions::RunLockTimeout)
-          end
-        end
-      end
-    end
-  end
-
-  # See also: spec/functional/run_lock_spec
-
-end

data/spec/unit/run_status_spec.rb

@@ -1,144 +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::RunStatus do
-  before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @run_status = Chef::RunStatus.new(@node, @events)
-  end
-
-  describe "before the run context has been set" do
-    it "converts to a hash" do
-      @run_status.to_hash
-    end
-  end
-
-  describe "when the run context has been set" do
-    before do
-      @run_status.run_context = @run_context
-    end
-
-    it "has a run context" do
-      expect(@run_status.run_context).to equal(@run_context)
-    end
-
-    it "provides access to the run context's node" do
-      expect(@run_status.node).to equal(@node)
-    end
-
-    it "converts to a hash" do
-      expect(@run_status.to_hash[:node]).to equal(@node)
-      expect(@run_status.to_hash[:success]).to be_truthy
-    end
-
-    describe "after it has recorded timing information" do
-      before do
-        @start_time = Time.new
-        @end_time = @start_time + 23
-        allow(Time).to receive(:now).and_return(@start_time, @end_time)
-        @run_status.start_clock
-        @run_status.stop_clock
-      end
-
-      it "records the start time of the run" do
-        expect(@run_status.start_time).to eq(@start_time)
-      end
-
-      it "records the end time of the run" do
-        expect(@run_status.end_time).to eq(@end_time)
-      end
-
-      it "gives the elapsed time of the chef run" do
-        expect(@run_status.elapsed_time).to eq(23)
-      end
-
-      it "includes timing information in its hash form" do
-        expect(@run_status.to_hash[:start_time]).to eq(@start_time)
-        expect(@run_status.to_hash[:end_time]).to eq(@end_time)
-        expect(@run_status.to_hash[:elapsed_time]).to eq(23)
-      end
-
-    end
-
-    describe "with resources in the resource_collection" do
-      before do
-        @all_resources = [Chef::Resource::Cat.new("whiskers"), Chef::Resource::ZenMaster.new("dtz")]
-        @run_context.resource_collection.all_resources.replace(@all_resources)
-      end
-
-      it "lists all resources" do
-        expect(@run_status.all_resources).to eq(@all_resources)
-      end
-
-      it "has no updated resources" do
-        expect(@run_status.updated_resources).to be_empty
-      end
-
-      it "includes the list of all resources in its hash form" do
-        expect(@run_status.to_hash[:all_resources]).to eq(@all_resources)
-        expect(@run_status.to_hash[:updated_resources]).to be_empty
-      end
-
-      describe "and some have been updated" do
-        before do
-          @all_resources.first.updated_by_last_action true
-        end
-
-        it "lists the updated resources" do
-          expect(@run_status.updated_resources).to eq([@all_resources.first])
-        end
-
-        it "includes the list of updated resources in its hash form" do
-          expect(@run_status.to_hash[:updated_resources]).to eq([@all_resources.first])
-        end
-      end
-    end
-
-    describe "when the run failed" do
-      before do
-        @exception = Exception.new("just testing")
-        @backtrace = caller
-        @exception.set_backtrace(@backtrace)
-        @run_status.exception = @exception
-      end
-
-      it "stores the exception" do
-        expect(@run_status.exception).to equal(@exception)
-      end
-
-      it "stores the backtrace" do
-        expect(@run_status.backtrace).to eq(@backtrace)
-      end
-
-      it "says the run was not successful" do
-        expect(@run_status.success?).to be_falsey
-        expect(@run_status.failed?).to be_truthy
-      end
-
-      it "converts to a hash including the exception information" do
-        expect(@run_status.to_hash[:success]).to be_falsey
-        expect(@run_status.to_hash[:exception]).to eq("Exception: just testing")
-        expect(@run_status.to_hash[:backtrace]).to eq(@backtrace)
-      end
-    end
-  end
-end

data/spec/unit/runner_spec.rb

@@ -1,397 +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"
-
-class SnitchyProvider < Chef::Provider
-  def self.all_actions_called
-    @all_actions_called ||= []
-  end
-
-  def self.action_called(action)
-    all_actions_called << action
-  end
-
-  def self.clear_action_record
-    @all_actions_called = nil
-  end
-
-  def load_current_resource
-    true
-  end
-
-  def action_first_action
-    @new_resource.updated_by_last_action(true)
-    self.class.action_called(:first)
-  end
-
-  def action_second_action
-    @new_resource.updated_by_last_action(true)
-    self.class.action_called(:second)
-  end
-
-  def action_third_action
-    @new_resource.updated_by_last_action(true)
-    self.class.action_called(:third)
-  end
-
-end
-
-class FailureResource < Chef::Resource
-
-  attr_accessor :action
-
-  def initialize(*args)
-    super
-    @action = :fail
-  end
-
-  def provider
-    FailureProvider
-  end
-end
-
-class FailureProvider < Chef::Provider
-
-  class ChefClientFail < StandardError; end
-
-  def load_current_resource
-    true
-  end
-
-  def action_fail
-    raise ChefClientFail, "chef had an error of some sort"
-  end
-end
-
-describe Chef::Runner do
-
-  let(:node) do
-    node = Chef::Node.new
-    node.name "latte"
-    node.automatic[:platform] = "mac_os_x"
-    node.automatic[:platform_version] = "10.5.1"
-    node
-  end
-
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, Chef::CookbookCollection.new({}), events) }
-  let(:first_resource) { Chef::Resource::Cat.new("loulou1", run_context) }
-  let(:runner) { Chef::Runner.new(run_context) }
-
-  before do
-    run_context.resource_collection << first_resource
-  end
-
-  it "runner sets up a pointer back to itself in the run_context" do
-    expect(runner).to eql(run_context.runner)
-  end
-
-  context "when we are doing dynamic provider resolution" do
-
-    it "should pass each resource in the collection to a provider" do
-      expect(run_context.resource_collection).to receive(:execute_each_resource).once
-      runner.converge
-    end
-
-    it "should use the provider specified by the resource (if it has one)" do
-      provider = Chef::Provider::Easy.new(run_context.resource_collection[0], run_context)
-      expect(run_context.resource_collection[0]).to receive(:provider).once.and_return(Chef::Provider::Easy)
-      expect(Chef::Provider::Easy).to receive(:new).once.and_return(provider)
-      runner.converge
-    end
-
-    it "should run the action for each resource" do
-      provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      expect(provider).to receive(:action_sell).once.and_return(true)
-      expect(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      runner.converge
-    end
-
-    it "should raise exceptions as thrown by a provider" do
-      provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      expect(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      expect(provider).to receive(:action_sell).once.and_raise(ArgumentError)
-      expect { runner.converge }.to raise_error(ArgumentError)
-    end
-
-    it "should not raise exceptions thrown by providers if the resource has ignore_failure set to true" do
-      allow(run_context.resource_collection[0]).to receive(:ignore_failure).and_return(true)
-      provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      expect(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      expect(provider).to receive(:action_sell).once.and_raise(ArgumentError)
-      expect { runner.converge }.not_to raise_error
-    end
-
-    it "should retry with the specified delay if retries are specified" do
-      num_retries = 3
-      allow(run_context.resource_collection[0]).to receive(:retries).and_return(num_retries)
-      provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      expect(Chef::Provider::SnakeOil).to receive(:new).exactly(num_retries + 1).times.and_return(provider)
-      expect(provider).to receive(:action_sell).exactly(num_retries + 1).times.and_raise(ArgumentError)
-      expect(run_context.resource_collection[0]).to receive(:sleep).with(2).exactly(num_retries).times
-      expect { runner.converge }.to raise_error(ArgumentError)
-    end
-
-    it "should execute immediate actions on changed resources" do
-      notifying_resource = Chef::Resource::Cat.new("peanut", run_context)
-      notifying_resource.action = :purr # only action that will set updated on the resource
-
-      run_context.resource_collection << notifying_resource
-      first_resource.action = :nothing # won't be updated unless notified by other resource
-
-      notifying_resource.notifies(:purr, first_resource, :immediately)
-
-      runner.converge
-
-      expect(first_resource).to be_updated
-    end
-
-    it "should follow a chain of actions" do
-      first_resource.action = :nothing
-
-      middle_resource = Chef::Resource::Cat.new("peanut", run_context)
-      middle_resource.action = :nothing
-      run_context.resource_collection << middle_resource
-      middle_resource.notifies(:purr, first_resource, :immediately)
-
-      last_resource = Chef::Resource::Cat.new("snuffles", run_context)
-      last_resource.action = :purr
-      run_context.resource_collection << last_resource
-      last_resource.notifies(:purr, middle_resource, :immediately)
-
-      runner.converge
-
-      expect(last_resource).to be_updated   # by action(:purr)
-      expect(middle_resource).to be_updated # by notification from last_resource
-      expect(first_resource).to be_updated # by notification from middle_resource
-    end
-
-    it "should execute delayed actions on changed resources" do
-      first_resource.action = :nothing
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :purr
-
-      run_context.resource_collection << second_resource
-      second_resource.notifies(:purr, first_resource, :delayed)
-
-      runner.converge
-
-      expect(first_resource).to be_updated
-    end
-
-    it "should execute delayed notifications when a failure occurs in the chef client run" do
-      first_resource.action = :nothing
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :purr
-
-      run_context.resource_collection << second_resource
-      second_resource.notifies(:purr, first_resource, :delayed)
-
-      third_resource = FailureResource.new("explode", run_context)
-      run_context.resource_collection << third_resource
-
-      expect { runner.converge }.to raise_error(FailureProvider::ChefClientFail)
-
-      expect(first_resource).to be_updated
-    end
-
-    it "should execute delayed notifications when a failure occurs in a notification" do
-      first_resource.action = :nothing
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :purr
-
-      run_context.resource_collection << second_resource
-
-      third_resource = FailureResource.new("explode", run_context)
-      third_resource.action = :nothing
-      run_context.resource_collection << third_resource
-
-      second_resource.notifies(:fail, third_resource, :delayed)
-      second_resource.notifies(:purr, first_resource, :delayed)
-
-      expect { runner.converge }.to raise_error(FailureProvider::ChefClientFail)
-
-      expect(first_resource).to be_updated
-    end
-
-    it "should execute delayed notifications when a failure occurs in multiple notifications" do
-      first_resource.action = :nothing
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :purr
-
-      run_context.resource_collection << second_resource
-
-      third_resource = FailureResource.new("explode", run_context)
-      third_resource.action = :nothing
-      run_context.resource_collection << third_resource
-
-      fourth_resource = FailureResource.new("explode again", run_context)
-      fourth_resource.action = :nothing
-      run_context.resource_collection << fourth_resource
-
-      second_resource.notifies(:fail, third_resource, :delayed)
-      second_resource.notifies(:fail, fourth_resource, :delayed)
-      second_resource.notifies(:purr, first_resource, :delayed)
-
-      exception = nil
-      begin
-        runner.converge
-      rescue => e
-        exception = e
-      end
-      expect(exception).to be_a(Chef::Exceptions::MultipleFailures)
-
-      expected_message = <<~E
-        Multiple failures occurred:
-        * FailureProvider::ChefClientFail occurred in delayed notification: [explode] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
-        * FailureProvider::ChefClientFail occurred in delayed notification: [explode again] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
-      E
-      expect(exception.message).to eq(expected_message)
-
-      expect(first_resource).to be_updated
-    end
-
-    it "does not duplicate delayed notifications" do
-      SnitchyProvider.clear_action_record
-
-      first_resource.action = :nothing
-      first_resource.provider = SnitchyProvider
-
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :first_action
-      second_resource.provider = SnitchyProvider
-      run_context.resource_collection << second_resource
-
-      third_resource = Chef::Resource::Cat.new("snickers", run_context)
-      third_resource.action = :first_action
-      third_resource.provider = SnitchyProvider
-      run_context.resource_collection << third_resource
-
-      second_resource.notifies(:second_action, first_resource, :delayed)
-      second_resource.notifies(:third_action, first_resource, :delayed)
-
-      third_resource.notifies(:second_action, first_resource, :delayed)
-      third_resource.notifies(:third_action, first_resource, :delayed)
-
-      runner.converge
-      # resources 2 and 3 call :first_action in the course of normal resource
-      # execution, and schedule delayed actions :second and :third on the first
-      # resource. The duplicate actions should "collapse" to a single notification
-      # and order should be preserved.
-      expect(SnitchyProvider.all_actions_called).to eq(%i{first first second third})
-    end
-
-    it "executes delayed notifications in the order they were declared" do
-      SnitchyProvider.clear_action_record
-
-      first_resource.action = :nothing
-      first_resource.provider = SnitchyProvider
-
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :first_action
-      second_resource.provider = SnitchyProvider
-      run_context.resource_collection << second_resource
-
-      third_resource = Chef::Resource::Cat.new("snickers", run_context)
-      third_resource.action = :first_action
-      third_resource.provider = SnitchyProvider
-      run_context.resource_collection << third_resource
-
-      second_resource.notifies(:second_action, first_resource, :delayed)
-      second_resource.notifies(:second_action, first_resource, :delayed)
-
-      third_resource.notifies(:third_action, first_resource, :delayed)
-      third_resource.notifies(:third_action, first_resource, :delayed)
-
-      runner.converge
-      expect(SnitchyProvider.all_actions_called).to eq(%i{first first second third})
-    end
-
-    it "does not fire notifications if the resource was not updated by the last action executed" do
-      # REGRESSION TEST FOR CHEF-1452
-      SnitchyProvider.clear_action_record
-
-      first_resource.action = :first_action
-      first_resource.provider = SnitchyProvider
-
-      second_resource = Chef::Resource::Cat.new("peanut", run_context)
-      second_resource.action = :nothing
-      second_resource.provider = SnitchyProvider
-      run_context.resource_collection << second_resource
-
-      third_resource = Chef::Resource::Cat.new("snickers", run_context)
-      third_resource.action = :nothing
-      third_resource.provider = SnitchyProvider
-      run_context.resource_collection << third_resource
-
-      first_resource.notifies(:second_action, second_resource, :immediately)
-      second_resource.notifies(:third_action, third_resource, :immediately)
-
-      runner.converge
-
-      # All of the resources should only fire once:
-      expect(SnitchyProvider.all_actions_called).to eq(%i{first second third})
-
-      # all of the resources should be marked as updated for reporting purposes
-      expect(first_resource).to be_updated
-      expect(second_resource).to be_updated
-      expect(third_resource).to be_updated
-    end
-
-    it "should check a resource's only_if and not_if if notified by another resource" do
-      first_resource.action = :buy
-
-      only_if_called_times = 0
-      first_resource.only_if { only_if_called_times += 1; true }
-
-      not_if_called_times = 0
-      first_resource.not_if { not_if_called_times += 1; false }
-
-      second_resource = Chef::Resource::Cat.new("carmel", run_context)
-      run_context.resource_collection << second_resource
-      second_resource.notifies(:purr, first_resource, :delayed)
-      second_resource.action = :purr
-
-      # hits only_if first time when the resource is run in order, second on notify
-      runner.converge
-
-      expect(only_if_called_times).to eq(2)
-      expect(not_if_called_times).to eq(2)
-    end
-
-    it "should resolve resource references in notifications when resources are defined lazily" do
-      first_resource.action = :nothing
-
-      lazy_resources = lambda do
-        last_resource = Chef::Resource::Cat.new("peanut", run_context)
-        run_context.resource_collection << last_resource
-        last_resource.notifies(:purr, first_resource.to_s, :delayed)
-        last_resource.action = :purr
-      end
-      second_resource = Chef::Resource::RubyBlock.new("myblock", run_context)
-      run_context.resource_collection << second_resource
-      second_resource.block { lazy_resources.call }
-
-      runner.converge
-
-      expect(first_resource).to be_updated
-    end
-
-  end
-end