chefspec-chef 9.3.4

data/lib/chefspec/matchers/render_file_matcher.rb

@@ -0,0 +1,140 @@
+module ChefSpec::Matchers
+  class RenderFileMatcher
+    attr_reader :expected_content
+    def initialize(path)
+      @path = path
+      @expected_content = []
+    end
+
+    def matches?(runner)
+      @runner = runner
+
+      if resource
+        ChefSpec::Coverage.cover!(resource)
+        has_create_action? && matches_content?
+      else
+        false
+      end
+    end
+
+    def with_content(expected_content = nil, &block)
+      if expected_content && block
+        raise ArgumentError, "Cannot specify expected content and a block!"
+      elsif expected_content
+        @expected_content << expected_content
+      elsif block_given?
+        @expected_content << block
+      else
+        raise ArgumentError, "Must specify expected content or a block!"
+      end
+
+      self
+    end
+
+    def description
+      message = %Q{render file "#{@path}"}
+      @expected_content.each do |expected|
+        if expected.to_s.include?("\n")
+          message << " with content <suppressed>"
+        else
+          message << " with content #{expected.inspect}"
+        end
+      end
+      message
+    end
+
+    def failure_message
+      message = %Q{expected Chef run to render "#{@path}"}
+      unless @expected_content.empty?
+        message << " matching:"
+        message << "\n\n"
+        message << expected_content_message
+        message << "\n\n"
+        message << "but got:"
+        message << "\n\n"
+        message << @actual_content.to_s
+        message << "\n "
+      end
+      message
+    end
+
+    def failure_message_when_negated
+      message = %Q{expected file "#{@path}"}
+      unless @expected_content.empty?
+        message << " matching:"
+        message << "\n\n"
+        message << expected_content_message
+        message << "\n\n"
+      end
+      message << " to not be in Chef run"
+      message
+    end
+
+    private
+
+    def expected_content_message
+      messages = @expected_content.collect do |expected|
+        if RSpec::Matchers.is_a_matcher?(expected) && expected.respond_to?(:description)
+          expected.description
+        elsif expected.is_a?(Proc)
+          "(the result of a proc)"
+        else
+          expected.to_s
+        end
+      end
+      messages.join("\n\n")
+    end
+
+    def resource
+      @resource ||= @runner.find_resource(:cookbook_file, @path) ||
+        @runner.find_resource(:file, @path) ||
+        @runner.find_resource(:template, @path)
+    end
+
+    #
+    # Determines if the given resource has a create-like action.
+    #
+    # @param [Chef::Resource] resource
+    #
+    # @return [true, false]
+    #
+    def has_create_action?
+      %i{create create_if_missing}.any? { |action| resource.performed_action?(action) }
+    end
+
+    #
+    # Determines if the resources content matches the expected content.
+    #
+    # @param [Chef::Resource] resource
+    #
+    # @return [true, false]
+    #
+    def matches_content?
+      return true if @expected_content.empty?
+
+      @actual_content = ChefSpec::Renderer.new(@runner, resource).content
+
+      return false if @actual_content.nil?
+
+      # Knock out matches that pass. When we're done, we pass if the list is
+      # empty. Otherwise, @expected_content is the list of matchers that
+      # failed
+      @expected_content.delete_if do |expected|
+        if expected.is_a?(Regexp)
+          @actual_content =~ expected
+        elsif RSpec::Matchers.is_a_matcher?(expected)
+          expected.matches?(@actual_content)
+        elsif expected.is_a?(Proc)
+          expected.call(@actual_content)
+          # Weird RSpecish, but that block will return false for a negated check,
+          # so we always return true. The block will raise an exception if the
+          # assertion fails.
+          true
+        else
+          @actual_content.include?(expected)
+        end
+      end
+      @expected_content.empty?
+    end
+  end
+end

data/lib/chefspec/matchers/resource_matcher.rb

@@ -0,0 +1,175 @@
+require "rspec/matchers/expecteds_for_multiple_diffs"
+require "rspec/expectations/fail_with"
+
+module ChefSpec::Matchers
+  class ResourceMatcher
+    def initialize(resource_name, expected_action, expected_identity)
+      @resource_name     = resource_name
+      @expected_action   = expected_action
+      @expected_identity = expected_identity
+    end
+
+    def with(parameters = {})
+      params.merge!(parameters)
+      self
+    end
+
+    def at_compile_time
+      raise ArgumentError, "Cannot specify both .at_converge_time and .at_compile_time!" if @converge_time
+
+      @compile_time = true
+      self
+    end
+
+    def at_converge_time
+      raise ArgumentError, "Cannot specify both .at_compile_time and .at_converge_time!" if @compile_time
+
+      @converge_time = true
+      self
+    end
+
+    #
+    # Allow users to specify fancy #with matchers.
+    #
+    def method_missing(m, *args, &block)
+      if m.to_s =~ /^with_(.+)$/
+        with($1.to_sym => args.first)
+        self
+      else
+        super
+      end
+    end
+
+    def description
+      %Q{#{@expected_action} #{@resource_name} "#{@expected_identity}"}
+    end
+
+    def matches?(runner)
+      @runner = runner
+
+      if resource
+        ChefSpec::Coverage.cover!(resource)
+        unmatched_parameters.empty? && correct_phase?
+      end
+    end
+
+    def failure_message
+      if resource
+        if unmatched_parameters.empty?
+          if @compile_time
+            %Q{expected "#{resource}" to be run at compile time}
+          else
+            %Q{expected "#{resource}" to be run at converge time}
+          end
+        else
+          message = %Q{expected "#{resource}" to have parameters:} \
+            "\n\n" \
+            "  " + unmatched_parameters.collect { |parameter, h|
+              msg = "#{parameter} #{h[:expected].inspect}, was #{h[:actual].inspect}"
+              diff = ::RSpec::Matchers::ExpectedsForMultipleDiffs.from(h[:expected]) \
+                .message_with_diff(message, ::RSpec::Expectations.differ, h[:actual])
+              msg += diff if diff
+              msg
+            }.join("\n  ")
+        end
+      else
+        %Q{expected "#{@resource_name}[#{@expected_identity}]"} \
+          " with action :#{@expected_action} to be in Chef run." \
+          " Other #{@resource_name} resources:" \
+          "\n\n" \
+          "  " + similar_resources.map(&:to_s).join("\n  ") + "\n "
+      end
+    end
+
+    def failure_message_when_negated
+      if resource
+        message = %Q{expected "#{resource}" actions #{resource.performed_actions.inspect} to not exist}
+      else
+        message = %Q{expected "#{resource}" to not exist}
+      end
+
+      message << " at compile time"  if @compile_time
+      message << " at converge time" if @converge_time
+      message
+    end
+
+    private
+
+    def unmatched_parameters
+      return @_unmatched_parameters if @_unmatched_parameters
+
+      @_unmatched_parameters = {}
+
+      params.each do |parameter, expected|
+        unless matches_parameter?(parameter, expected)
+          @_unmatched_parameters[parameter] = {
+            expected: expected,
+            actual:   safe_send(parameter),
+          }
+        end
+      end
+
+      @_unmatched_parameters
+    end
+
+    def matches_parameter?(parameter, expected)
+      value = safe_send(parameter)
+      if parameter == :source
+        # Chef 11+ stores the source parameter internally as an Array
+        Array(expected) == Array(value)
+      elsif expected.is_a?(Class)
+        # Ruby can't compare classes with ===
+        expected == value
+      else
+        expected === value
+      end
+    end
+
+    def correct_phase?
+      if @compile_time
+        resource.performed_action(@expected_action)[:compile_time]
+      elsif @converge_time
+        resource.performed_action(@expected_action)[:converge_time]
+      else
+        true
+      end
+    end
+
+    def safe_send(parameter)
+      resource.send(parameter)
+    rescue NoMethodError
+      nil
+    end
+
+    #
+    # Any other resources in the Chef run that have the same resource
+    # type. Used by {failure_message} to be ultra helpful.
+    #
+    # @return [Array<Chef::Resource>]
+    #
+    def similar_resources
+      @_similar_resources ||= @runner.find_resources(@resource_name)
+    end
+
+    #
+    # Find the resource in the Chef run by the given class name and
+    # resource identity/name.
+    #
+    # @see ChefSpec::SoloRunner#find_resource
+    #
+    # @return [Chef::Resource, nil]
+    #
+    def resource
+      @_resource ||= @runner.find_resource(@resource_name, @expected_identity, @expected_action)
+    end
+
+    #
+    # The list of parameters passed to the {with} matcher.
+    #
+    # @return [Hash]
+    #
+    def params
+      @_params ||= {}
+    end
+  end
+end

data/lib/chefspec/matchers/state_attrs_matcher.rb

@@ -0,0 +1,71 @@
+module ChefSpec::Matchers
+  class StateAttrsMatcher
+    #
+    # Create a new state_attrs matcher.
+    #
+    # @param [Array] state_attrs
+    #
+    def initialize(state_attrs)
+      @expected_attrs = state_attrs.map(&:to_sym)
+    end
+
+    def matches?(resource)
+      @resource = resource
+      @resource && matches_state_attrs?
+    end
+
+    def description
+      %Q{have state attributes #{@expected_attrs.inspect}}
+    end
+
+    def failure_message
+      if @resource
+        "expected #{state_attrs.inspect} to equal #{@expected_attrs.inspect}"
+      else
+        "expected _something_ to have state attributes, but the " \
+        "_something_ you gave me was nil!" \
+        "\n" \
+        "Ensure the resource exists before making assertions:" \
+        "\n\n" \
+        "  expect(resource).to be" \
+        "\n "
+      end
+    end
+
+    def failure_message_when_negated
+      if @resource
+        "expected #{state_attrs.inspect} to not equal " \
+        "#{@expected_attrs.inspect}"
+      else
+        "expected _something_ to not have state attributes, but the " \
+        "_something_ you gave me was nil!" \
+        "\n" \
+        "Ensure the resource exists before making assertions:" \
+        "\n\n" \
+        "  expect(resource).to be" \
+        "\n "
+      end
+    end
+
+    private
+
+    #
+    # Determine if all the expected state attributes are present on the
+    # given resource.
+    #
+    # @return [true, false]
+    #
+    def matches_state_attrs?
+      @expected_attrs == state_attrs
+    end
+
+    #
+    # The list of state attributes declared on the given resource.
+    #
+    # @return [Array<Symbol>]
+    #
+    def state_attrs
+      @resource.class.state_attrs.map(&:to_sym)
+    end
+  end
+end

data/lib/chefspec/matchers/subscribes_matcher.rb

@@ -0,0 +1,72 @@
+module ChefSpec::Matchers
+  class SubscribesMatcher
+    include ChefSpec::Normalize
+
+    def initialize(signature)
+      signature.match(/^([^\[]*)\[(.*)\]$/)
+      @expected_resource_type = $1
+      @expected_resource_name = $2
+    end
+
+    def matches?(resource)
+      @instance = ChefSpec::Matchers::NotificationsMatcher.new(resource.to_s)
+
+      if @action
+        @instance.to(@action)
+      end
+
+      if @immediately
+        @instance.immediately
+      end
+
+      if @delayed
+        @instance.delayed
+      end
+
+      if @before
+        @instance.before
+      end
+
+      if resource
+        runner   = resource.run_context.node.runner
+        expected = runner.find_resource(@expected_resource_type, @expected_resource_name)
+
+        @instance.matches?(expected)
+      else
+        @instance.matches?(nil)
+      end
+    end
+
+    def on(action)
+      @action = action
+      self
+    end
+
+    def immediately
+      @immediately = true
+      self
+    end
+
+    def delayed
+      @delayed = true
+      self
+    end
+
+    def before
+      @before = true
+      self
+    end
+
+    def description
+      @instance.description
+    end
+
+    def failure_message
+      @instance.failure_message
+    end
+
+    def failure_message_when_negated
+      @instance.failure_message_when_negated
+    end
+  end
+end

data/lib/chefspec/matchers.rb

@@ -0,0 +1,13 @@
+module ChefSpec
+  module Matchers
+    require_relative "matchers/do_nothing_matcher"
+    require_relative "matchers/include_any_recipe_matcher"
+    require_relative "matchers/include_recipe_matcher"
+    require_relative "matchers/link_to_matcher"
+    require_relative "matchers/notifications_matcher"
+    require_relative "matchers/render_file_matcher"
+    require_relative "matchers/resource_matcher"
+    require_relative "matchers/state_attrs_matcher"
+    require_relative "matchers/subscribes_matcher"
+  end
+end

data/lib/chefspec/mixins/normalize.rb

@@ -0,0 +1,22 @@
+module ChefSpec
+  module Normalize
+    #
+    # Calculate the name of a resource, replacing dashes with underscores
+    # and converting symbols to strings and back again.
+    #
+    # @param [String, Chef::Resource] thing
+    #
+    # @return [Symbol]
+    #
+    def resource_name(thing)
+      if thing.respond_to?(:declared_type) && thing.declared_type
+        name = thing.declared_type
+      elsif thing.respond_to?(:resource_name)
+        name = thing.resource_name
+      else
+        name = thing
+      end
+      name.to_s.gsub("-", "_").to_sym
+    end
+  end
+end

data/lib/chefspec/policyfile.rb

@@ -0,0 +1,69 @@
+begin
+  require "chef-cli/policyfile_services/export_repo"
+  require "chef-cli/policyfile_services/install"
+  require "chef/workstation_config_loader"
+rescue LoadError
+  raise ChefSpec::Error::GemLoadError.new(gem: "chef-cli", name: "ChefCLI")
+end
+
+module ChefSpec
+  class Policyfile
+    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!
+      policyfile_path = RSpec.configuration.policyfile_path
+      if policyfile_path.nil?
+        policyfile_path = File.join(Dir.pwd, "Policyfile.rb")
+      end
+
+      Chef::WorkstationConfigLoader.new(nil).load
+
+      installer = ChefCLI::PolicyfileServices::Install.new(
+        policyfile: policyfile_path,
+        ui: ChefCLI::UI.null,
+        config: Chef::Config
+      )
+
+      installer.run
+
+      exporter = ChefCLI::PolicyfileServices::ExportRepo.new(
+        policyfile: policyfile_path,
+        export_dir: @tmpdir
+      )
+
+      FileUtils.rm_rf(@tmpdir)
+      exporter.run
+
+      ::RSpec.configure do |config|
+        config.cookbook_path = [
+          File.join(@tmpdir, "cookbooks"),
+          File.join(@tmpdir, "cookbook_artifacts"),
+        ]
+      end
+    end
+
+    #
+    # Remove the temporary directory
+    #
+    def teardown!
+      FileUtils.rm_rf(@tmpdir) if File.exist?(@tmpdir)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) { ChefSpec::Policyfile.setup! }
+  config.after(:suite)  { ChefSpec::Policyfile.teardown! }
+end

data/lib/chefspec/renderer.rb

@@ -0,0 +1,145 @@
+begin
+  require "chef/mixin/template"
+  require "chef/provider/template_finder"
+rescue LoadError
+end
+
+module ChefSpec
+  class Renderer
+    include ChefSpec::Normalize
+
+    # @return [Chef::Runner]
+    attr_reader :chef_run
+
+    # @return [Chef::Resource]
+    attr_reader :resource
+
+    #
+    # Create a new Renderer for the given Chef run and resource.
+    #
+    # @param [Chef::Runner] chef_run
+    #   the Chef run containing the resources
+    # @param [Chef::Resource] resource
+    #   the resource to render content from
+    #
+    def initialize(chef_run, resource)
+      @chef_run = chef_run
+      @resource = resource
+    end
+
+    #
+    # The content of the resource (this method delegates to the)
+    # various private rendering methods.
+    #
+    # @return [String, nil]
+    #   the contents of the file as a string, or nil if the resource
+    #   does not contain or respond to a content renderer.
+    #
+    def content
+      case resource_name(resource)
+      when :template
+        content_from_template(chef_run, resource)
+      when :file
+        content_from_file(chef_run, resource)
+      when :cookbook_file
+        content_from_cookbook_file(chef_run, resource)
+      else
+        nil
+      end
+    end
+
+    private
+
+    #
+    # Compute the contents of a template using Chef's templating logic.
+    #
+    # @param [Chef::RunContext] chef_run
+    #   the run context for the node
+    # @param [Chef::Provider::Template] template
+    #   the template resource
+    #
+    # @return [String]
+    #
+    def content_from_template(chef_run, template)
+      cookbook_name = template.cookbook || template.cookbook_name
+      template_location = cookbook_collection(chef_run.node)[cookbook_name].preferred_filename_on_disk_location(chef_run.node, :templates, template.source)
+
+      if Chef::Mixin::Template.const_defined?(:TemplateContext) # Chef 11+
+        template_context = Chef::Mixin::Template::TemplateContext.new([])
+        template_context.update({
+          node: chef_run.node,
+          template_finder: template_finder(chef_run, cookbook_name),
+        }.merge(template.variables))
+        if template.respond_to?(:helper_modules) # Chef 11.4+
+          template_context._extend_modules(template.helper_modules)
+        end
+        template_context.render_template(template_location)
+      else
+        template.provider.new(template, chef_run.run_context).send(:render_with_context, template_location) do |file|
+          File.read(file.path)
+        end
+      end
+    end
+
+    #
+    # Get the contents of a file resource.
+    #
+    # @param [Chef::RunContext] chef_run
+    #   the run context for the node
+    # @param [Chef::Provider::File] file
+    #   the file resource
+    #
+    # @return [String]
+    #
+    def content_from_file(chef_run, file)
+      file.content
+    end
+
+    #
+    # Get the contents of a cookbook file using Chef.
+    #
+    # @param [Chef::RunContext] chef_run
+    #   the run context for the node
+    # @param [Chef::Provider::CookbookFile] cookbook_file
+    #   the file resource
+    #
+    def content_from_cookbook_file(chef_run, cookbook_file)
+      cookbook_name = cookbook_file.cookbook || cookbook_file.cookbook_name
+      cookbook = cookbook_collection(chef_run.node)[cookbook_name]
+      File.read(cookbook.preferred_filename_on_disk_location(chef_run.node, :files, cookbook_file.source))
+    end
+
+    # The cookbook collection for the current Chef run context. Handles
+    # the differing cases between Chef 10 and Chef 11.
+    #
+    # @param [Chef::Node] node
+    #   the Chef node to get the cookbook collection from
+    #
+    # @return [Array<Chef::Cookbook>]
+    def cookbook_collection(node)
+      if chef_run.respond_to?(:run_context)
+        chef_run.run_context.cookbook_collection # Chef 11.8+
+      elsif node.respond_to?(:run_context)
+        node.run_context.cookbook_collection # Chef 11+
+      else
+        node.cookbook_collection # Chef 10
+      end
+    end
+
+    # Return a new instance of the TemplateFinder if we are running on Chef 11.
+    #
+    # @param [Chef::RunContext] chef_run
+    #   the run context for the noe
+    # @param [String] cookbook_name
+    #   the name of the cookbook
+    #
+    # @return [Chef::Provider::TemplateFinder, nil]
+    def template_finder(chef_run, cookbook_name)
+      if Chef::Provider.const_defined?(:TemplateFinder) # Chef 11+
+        Chef::Provider::TemplateFinder.new(chef_run.run_context, cookbook_name, chef_run.node)
+      else
+        nil
+      end
+    end
+  end
+end