chefspec-chef 9.3.4

data/lib/chefspec/formatter.rb

@@ -0,0 +1,282 @@
+require "chef/formatters/base"
+require "chef/formatters/error_mapper"
+
+module ChefSpec
+  class ChefFormatter < Chef::Formatters::Base
+    cli_name :chefspec
+
+    # Called at the very start of a Chef Run
+    def run_start(version); end
+
+    def run_started(run_status); end
+
+    # Called at the end a successful Chef run.
+    def run_completed(node); end
+
+    # Called at the end of a failed Chef run.
+    def run_failed(exception); end
+
+    # Called right after ohai runs.
+    def ohai_completed(node); end
+
+    # Already have a client key, assuming this node has registered.
+    def skipping_registration(node_name, config); end
+
+    # About to attempt to register as +node_name+
+    def registration_start(node_name, config); end
+
+    def registration_completed; end
+
+    # Failed to register this client with the server.
+    def registration_failed(node_name, exception, config)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.registration_failed(node_name, exception, config)
+        display_error(description)
+      end
+    end
+
+    # Called before Chef client loads the node data from the server
+    def node_load_start(node_name, config); end
+
+    # Failed to load node data from the server
+    def node_load_failed(node_name, exception, config)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.node_load_failed(node_name, exception, config)
+        display_error(description)
+      end
+    end
+
+    # Error expanding the run list
+    def run_list_expand_failed(node, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.run_list_expand_failed(node, exception)
+        display_error(description)
+      end
+    end
+
+    # Called after Chef client has loaded the node data.
+    # Default and override attrs from roles have been computed, but not yet applied.
+    # Normal attrs from JSON have been added to the node.
+    def node_load_completed(node, expanded_run_list, config); end
+
+    # Called before the cookbook collection is fetched from the server.
+    def cookbook_resolution_start(expanded_run_list); end
+
+    # Called when there is an error getting the cookbook collection from the
+    # server.
+    def cookbook_resolution_failed(expanded_run_list, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.cookbook_resolution_failed(expanded_run_list, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when the cookbook collection is returned from the server.
+    def cookbook_resolution_complete(cookbook_collection); end
+
+    # Called before unneeded cookbooks are removed
+    def cookbook_clean_start; end
+
+    # Called after the file at +path+ is removed. It may be removed if the
+    # cookbook containing it was removed from the run list, or if the file was
+    # removed from the cookbook.
+    def removed_cookbook_file(path); end
+
+    # Called when cookbook cleaning is finished.
+    def cookbook_clean_complete; end
+
+    # Called before cookbook sync starts
+    def cookbook_sync_start(cookbook_count); end
+
+    # Called when cookbook +cookbook_name+ has been sync'd
+    def synchronized_cookbook(cookbook_name); end
+
+    # Called when an individual file in a cookbook has been updated
+    def updated_cookbook_file(cookbook_name, path); end
+
+    # Called when an error occurs during cookbook sync
+    def cookbook_sync_failed(cookbooks, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.cookbook_sync_failed(cookbooks, exception)
+        display_error(description)
+      end
+    end
+
+    # Called after all cookbooks have been sync'd.
+    def cookbook_sync_complete; end
+
+    # Called when library file loading starts
+    def library_load_start(file_count); end
+
+    # Called when library file has been loaded
+    def library_file_loaded(path); end
+
+    # Called when a library file has an error on load.
+    def library_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when library file loading has finished
+    def library_load_complete; end
+
+    # Called when LWRP loading starts
+    def lwrp_load_start(lwrp_file_count); end
+
+    # Called after a LWR or LWP has been loaded
+    def lwrp_file_loaded(path); end
+
+    # Called after a LWR or LWP file errors on load
+    def lwrp_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when LWRPs are finished loading
+    def lwrp_load_complete; end
+
+    # Called when an ohai plugin file loading starts
+    def ohai_plugin_load_start(file_count); end
+
+    # Called when an ohai plugin file has been loaded
+    def ohai_plugin_file_loaded(path); end
+
+    # Called when an ohai plugin file has an error on load.
+    def ohai_plugin_file_load_failed(path, exception); end
+
+    # Called when an ohai plugin file loading has finished
+    def ohai_plugin_load_complete; end
+
+    # Called before attribute files are loaded
+    def attribute_load_start(attribute_file_count); end
+
+    # Called after the attribute file is loaded
+    def attribute_file_loaded(path); end
+
+    # Called when an attribute file fails to load.
+    def attribute_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when attribute file loading is finished
+    def attribute_load_complete; end
+
+    # Called before resource definitions are loaded
+    def definition_load_start(definition_file_count); end
+
+    # Called when a resource definition has been loaded
+    def definition_file_loaded(path); end
+
+    # Called when a resource definition file fails to load
+    def definition_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when resource defintions are done loading
+    def definition_load_complete; end
+
+    # Called before recipes are loaded
+    def recipe_load_start(recipe_count); end
+
+    # Called after the recipe has been loaded
+    def recipe_file_loaded(path); end
+
+    # Called after a recipe file fails to load
+    def recipe_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when a recipe cannot be resolved
+    def recipe_not_found(exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.file_load_failed(nil, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when recipes have been loaded.
+    def recipe_load_complete; end
+
+    # Called before convergence starts
+    def converge_start(run_context); end
+
+    # Called when the converge phase is finished.
+    def converge_complete; end
+
+    # Called before action is executed on a resource.
+    def resource_action_start(resource, action, notification_type = nil, notifier = nil); end
+
+    # Called when a resource fails, but will retry.
+    def resource_failed_retriable(resource, action, retry_count, exception); end
+
+    # Called when a resource fails and will not be retried.
+    def resource_failed(resource, action, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.resource_failed(resource, action, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when a resource action has been skipped b/c of a conditional
+    def resource_skipped(resource, action, conditional); end
+
+    # Called when a resource action has been completed
+    def resource_completed(resource); end
+
+    # Called after #load_current_resource has run.
+    def resource_current_state_loaded(resource, action, current_resource); end
+
+    # Called when resource current state load is skipped due to the provider
+    # not supporting whyrun mode.
+    def resource_current_state_load_bypassed(resource, action, current_resource); end
+
+    # Called when evaluating a resource that does not support whyrun in whyrun mode
+    def resource_bypassed(resource, action, current_resource); end
+
+    # Called when a resource has no converge actions, e.g., it was already correct.
+    def resource_up_to_date(resource, action); end
+
+    # Called when a change has been made to a resource. May be called multiple
+    # times per resource, e.g., a file may have its content updated, and then
+    # its permissions updated.
+    def resource_update_applied(resource, action, update); end
+
+    # Called after a resource has been completely converged, but only if
+    # modifications were made.
+    def resource_updated(resource, action); end
+
+    # Called before handlers run
+    def handlers_start(handler_count); end
+
+    # Called after an individual handler has run
+    def handler_executed(handler); end
+
+    # Called after all handlers have executed
+    def handlers_completed; end
+
+    # Called when an assertion declared by a provider fails
+    def provider_requirement_failed(action, resource, exception, message); end
+
+    # Called when a provider makes an assumption after a failed assertion
+    # in whyrun mode, in order to allow execution to continue
+    def whyrun_assumption(action, resource, message); end
+
+    # An uncategorized message. This supports the case that a user needs to
+    # pass output that doesn't fit into one of the callbacks above. Note that
+    # there's no semantic information about the content or importance of the
+    # message. That means that if you're using this too often, you should add a
+    # callback for it.
+    def msg(message); end
+
+    private
+
+    def file_load_failed(path, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.file_load_failed(path, exception)
+        display_error(description)
+      end
+    end
+
+    def expecting_exception(exception, &block)
+      yield unless ChefSpec::ExpectException.new(exception).expected?
+    end
+  end
+end

data/lib/chefspec/librarian.rb

@@ -0,0 +1,51 @@
+begin
+  require "librarian/chef/environment"
+  require "librarian/action/resolve"
+  require "librarian/action/install"
+rescue LoadError
+  raise ChefSpec::Error::GemLoadError.new(
+    gem: "librarian-chef", name: "Librarian"
+  )
+end
+
+module ChefSpec
+  class Librarian
+    class << self
+      extend Forwardable
+      def_delegators :instance, :setup!, :teardown!
+    end
+
+    include Singleton
+
+    def initialize
+      @tmpdir = Dir.mktmpdir
+    end
+
+    #
+    # Setup and install the necessary dependencies in the temporary directory.
+    #
+    def setup!
+      env = ::Librarian::Chef::Environment.new(project_path: Dir.pwd)
+      @originalpath, env.config_db.local["path"] = env.config_db.local["path"], @tmpdir
+      ::Librarian::Action::Resolve.new(env).run
+      ::Librarian::Action::Install.new(env).run
+
+      ::RSpec.configure { |config| config.cookbook_path = @tmpdir }
+    end
+
+    #
+    # Remove the temporary directory and restore the librarian-chef cookbook path.
+    #
+    def teardown!
+      env = ::Librarian::Chef::Environment.new(project_path: Dir.pwd)
+      env.config_db.local["path"] = @originalpath
+
+      FileUtils.rm_rf(@tmpdir) if File.exist?(@tmpdir)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) { ChefSpec::Librarian.setup! }
+  config.after(:suite)  { ChefSpec::Librarian.teardown! }
+end

data/lib/chefspec/matchers/do_nothing_matcher.rb

@@ -0,0 +1,52 @@
+module ChefSpec::Matchers
+  class DoNothingMatcher
+    def matches?(resource)
+      @resource = resource
+
+      if @resource
+        ChefSpec::Coverage.cover!(@resource)
+
+        actions = @resource.performed_actions
+        actions.empty? || actions == [:nothing]
+      else
+        false
+      end
+    end
+
+    def description
+      "do nothing"
+    end
+
+    def failure_message
+      if @resource
+        message =  %{expected #{@resource} to do nothing, but the following }
+        message << %{actions were performed:}
+        message << %{\n\n}
+        @resource.performed_actions.each do |action|
+          message << %{  :#{action}}
+        end
+        message
+      else
+        message =  %{expected _something_ to do nothing, but the _something_ }
+        message << %{you gave me was nil! If you are running a test like:}
+        message << %{\n\n}
+        message << %{  expect(_something_).to do_nothing}
+        message << %{\n\n}
+        message << %{make sure that `_something_` exists, because I got nil!}
+        message
+      end
+    end
+
+    def failure_message_when_negated
+      if @resource
+        message =  %{expected #{@resource} to do something, but no actions }
+        message << %{were performed.}
+        message
+      else
+        message =  %{expected _something_ to do something, but no actions }
+        message << %{were performed.}
+        message
+      end
+    end
+  end
+end

data/lib/chefspec/matchers/include_any_recipe_matcher.rb

@@ -0,0 +1,51 @@
+module ChefSpec::Matchers
+  class IncludeAnyRecipeMatcher
+    def matches?(runner)
+      @runner = runner
+      !(loaded_recipes - run_list_recipes).empty?
+    end
+
+    def description
+      "include any recipe"
+    end
+
+    def failure_message
+      "expected to include any recipe"
+    end
+
+    def failure_message_when_negated
+      "expected not to include any recipes"
+    end
+
+    private
+
+    #
+    # The list of run_list recipes on the Chef run (normalized)
+    #
+    # @return [Array<String>]
+    #
+    def run_list_recipes
+      @runner.run_context.node.run_list.run_list_items.map { |x| with_default(x.name) }
+    end
+
+    #
+    # Automatically appends "+::default+" to recipes that need them.
+    #
+    # @param [String] name
+    #
+    # @return [String]
+    #
+    def with_default(name)
+      name.include?("::") ? name : "#{name}::default"
+    end
+
+    #
+    # The list of loaded recipes on the Chef run (normalized)
+    #
+    # @return [Array<String>]
+    #
+    def loaded_recipes
+      @runner.run_context.loaded_recipes.map { |name| with_default(name) }
+    end
+  end
+end

data/lib/chefspec/matchers/include_recipe_matcher.rb

@@ -0,0 +1,46 @@
+module ChefSpec::Matchers
+  class IncludeRecipeMatcher
+    def initialize(recipe_name)
+      @recipe_name = with_default(recipe_name)
+    end
+
+    def matches?(runner)
+      @runner = runner
+      loaded_recipes.include?(@recipe_name)
+    end
+
+    def description
+      %Q{include recipe "#{@recipe_name}"}
+    end
+
+    def failure_message
+      %Q{expected #{loaded_recipes.inspect} to include "#{@recipe_name}"}
+    end
+
+    def failure_message_when_negated
+      %Q{expected "#{@recipe_name}" to not be included}
+    end
+
+    private
+
+    #
+    # Automatically appends "+::default+" to recipes that need them.
+    #
+    # @param [String] name
+    #
+    # @return [String]
+    #
+    def with_default(name)
+      name.include?("::") ? name : "#{name}::default"
+    end
+
+    #
+    # The list of loaded recipes on the Chef run (normalized)
+    #
+    # @return [Array<String>]
+    #
+    def loaded_recipes
+      @runner.run_context.loaded_recipes.map { |name| with_default(name) }
+    end
+  end
+end

data/lib/chefspec/matchers/link_to_matcher.rb

@@ -0,0 +1,37 @@
+module ChefSpec::Matchers
+  class LinkToMatcher
+    def initialize(path)
+      @path = path
+    end
+
+    def matches?(link)
+      @link = link
+
+      if @link
+        ChefSpec::Coverage.cover!(@link)
+
+        @link.is_a?(Chef::Resource::Link) &&
+          @link.performed_action?(:create) &&
+          @path === @link.to
+      else
+        false
+      end
+    end
+
+    def description
+      %Q{link to "#{@path}"}
+    end
+
+    def failure_message
+      if @link.nil?
+        %Q{expected "link[#{@path}]" with action :create to be in Chef run}
+      else
+        %Q{expected "#{@link}" to link to "#{@path}" but was "#{@link.to}"}
+      end
+    end
+
+    def failure_message_when_negated
+      %Q{expected "#{@link}" to not link to "#{@path}"}
+    end
+  end
+end

data/lib/chefspec/matchers/notifications_matcher.rb

@@ -0,0 +1,143 @@
+module ChefSpec::Matchers
+  class NotificationsMatcher
+    include ChefSpec::Normalize
+
+    def initialize(signature)
+      signature.match(/^([^\[]*)\[(.*)\]$/)
+      @expected_resource_type = $1
+      @expected_resource_name = $2
+    end
+
+    def matches?(resource)
+      @resource = resource
+
+      if @resource
+        block = Proc.new do |notified|
+          resource_name(notified.resource).to_s == @expected_resource_type &&
+            (@expected_resource_name === notified.resource.identity.to_s || @expected_resource_name === notified.resource.name.to_s) &&
+            matches_action?(notified)
+        end
+
+        if @immediately
+          immediate_notifications.any?(&block)
+        elsif @delayed
+          delayed_notifications.any?(&block)
+        elsif @before
+          before_notifications.any?(&block)
+        else
+          all_notifications.any?(&block)
+        end
+      end
+    end
+
+    def to(action)
+      @action = action.to_sym
+      self
+    end
+
+    def immediately
+      @immediately = true
+      self
+    end
+
+    def delayed
+      @delayed = true
+      self
+    end
+
+    def before
+      @before = true
+      self
+    end
+
+    def description
+      message = %Q{notify "#{@expected_resource_type}[#{@expected_resource_name}]"}
+      message << " with action :#{@action}" if @action
+      message << " immediately" if @immediately
+      message << " delayed" if @delayed
+      message << " before" if @before
+      message
+    end
+
+    def failure_message
+      if @resource
+        message = %Q{expected "#{@resource}" to notify "#{@expected_resource_type}[#{@expected_resource_name}]"}
+        message << " with action :#{@action}" if @action
+        message << " immediately" if @immediately
+        message << " delayed" if @delayed
+        message << " before" if @before
+        message << ", but did not."
+        message << "\n\n"
+        message << "Other notifications were:\n\n#{format_notifications}"
+        message << "\n "
+        message
+      else
+        message = %Q{expected _something_ to notify "#{@expected_resource_type}[#{@expected_resource_name}]"}
+        message << " with action :#{@action}" if @action
+        message << " immediately" if @immediately
+        message << " delayed" if @delayed
+        message << " before" if @before
+        message << ", but the _something_ you gave me was nil! If you are running a test like:"
+        message << "\n\n"
+        message << "  expect(_something_).to notify('...')"
+        message << "\n\n"
+        message << "Make sure that `_something_` exists, because I got nil"
+        message << "\n "
+        message
+      end
+    end
+
+    def failure_message_when_negated
+      if @resource
+        message = %Q{expected "#{@resource}" to not notify "#{@expected_resource_type}[#{@expected_resource_name}]"}
+        message << ", but it did."
+        message
+      end
+    end
+
+    private
+
+    def all_notifications
+      immediate_notifications + delayed_notifications + before_notifications
+    end
+
+    def immediate_notifications
+      @resource.immediate_notifications
+    end
+
+    def delayed_notifications
+      @resource.delayed_notifications
+    end
+
+    def before_notifications
+      @resource.before_notifications
+    end
+
+    def matches_action?(notification)
+      return true if @action.nil?
+
+      @action == notification.action.to_sym
+    end
+
+    def format_notification(notification)
+      notifying_resource = notification.notifying_resource
+      resource = notification.resource
+
+      if notifying_resource.immediate_notifications.include?(notification)
+        type = :immediately
+      elsif notifying_resource.before_notifications.include?(notification)
+        type = :before
+      else
+        type = :delayed
+      end
+
+      %Q{  "#{notifying_resource}" notifies "#{resource_name(resource)}[#{resource.name}]" to :#{notification.action}, :#{type}}
+    end
+
+    def format_notifications
+      all_notifications.map do |notification|
+        "  " + format_notification(notification)
+      end.join("\n")
+    end
+  end
+end