chefspec 2.0.1 → 3.0.0.beta.1

data/lib/chefspec/matchers.rb

@@ -0,0 +1,9 @@
+module ChefSpec
+  module Matchers
+    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'
+  end
+end

data/lib/chefspec/matchers/include_recipe_matcher.rb

@@ -0,0 +1,45 @@
+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
+      "include recipe '#{@recipe_name}'"
+    end
+
+    def failure_message_for_should
+      "expected #{loaded_recipes} to include '#{@recipe_name}'"
+    end
+
+    def failure_message_for_should_not
+      "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,28 @@
+module ChefSpec::Matchers
+  class LinkToMatcher
+    def initialize(path)
+      @path = path
+    end
+
+    def matches?(link)
+      @link = link
+      @link.is_a?(Chef::Resource::Link) && @path === @link.to
+    end
+
+    def description
+      "link to '#{@path}'"
+    end
+
+    def failure_message_for_should
+      if @link.nil?
+        "expected 'link[#{@path}]' with action ':create' to be in Chef run"
+      else
+        "expected '#{@link}' to link to '#{@path}' but was '#{@link.to}'"
+      end
+    end
+
+    def failure_message_for_should_not
+      "expected '#{@link}' to not link to '#{@path}'"
+    end
+  end
+end

data/lib/chefspec/matchers/notifications_matcher.rb

@@ -0,0 +1,92 @@
+module ChefSpec::Matchers
+  class NotificationsMatcher
+    def initialize(signature)
+      signature.match(/^([^\[]*)\[(.*)\]$/)
+      @expected_resource_type = $1
+      @expected_resource_name = $2
+    end
+
+    def matches?(resource)
+      @resource = resource
+
+      block = Proc.new do |notified|
+        notified.resource.resource_name.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)
+      else
+        all_notifications.any?(&block)
+      end
+    end
+
+    def to(action)
+      @action = action.to_sym
+      self
+    end
+
+    def immediately
+      @immediately = true
+      self
+    end
+
+    def delayed
+      @delayed = true
+      self
+    end
+
+    def description
+      message = "notify #{@expected_resource_type}[#{@expected_resource_name}]"
+      message << " with action #{@action.inspect}" if @action
+      message << " immediately" if @immediately
+      message << " delayed" if @delayed
+      message
+    end
+
+    def failure_message_for_should
+      message = "expected '#{@resource.resource_name}[#{@resource.name}]' to notify '#{@expected_resource_type}[#{@expected_resource_name}]'"
+      message << " with action #{@action.inspect}" if @action
+      message << " immediately" if @immediately
+      message << " delayed" if @delayed
+      message << ", but did not."
+      message << "\n\n"
+      message << "Other notifications were:\n#{format_notifications}"
+      message
+    end
+
+    private
+      def all_notifications
+        immediate_notifications + delayed_notifications
+      end
+
+      def immediate_notifications
+        @resource.immediate_notifications
+      end
+
+      def delayed_notifications
+        @resource.delayed_notifications
+      end
+
+      def matches_action?(notification)
+        return true if @action.nil?
+        @action == notification.action.to_sym
+      end
+
+      def format_notification(notification)
+        resource = notification.resource
+        type = notification.notifying_resource.immediate_notifications.include?(notification) ? :immediately : :delayed
+
+        "notifies :#{notification.action}, '#{resource.resource_name}[#{resource.name}]', :#{type}"
+      end
+
+      def format_notifications
+        all_notifications.map do |notification|
+          '  ' + format_notification(notification)
+        end.join("\n")
+      end
+  end
+end

data/lib/chefspec/matchers/render_file_matcher.rb

@@ -0,0 +1,72 @@
+module ChefSpec::Matchers
+  class RenderFileMatcher
+    def initialize(path)
+      @path = path
+    end
+
+    def matches?(runner)
+      @runner = runner
+      resource && has_create_action? && matches_content?
+    end
+
+    def with_content(expected_content)
+      @expected_content = expected_content
+      self
+    end
+
+    def description
+      "render file '#{@path}'"
+    end
+
+    def failure_message_for_should
+      message = "expected Chef run to render '#{@path}'"
+      message << " with:\n\n#{@expected_content}\n\nbut got:\n\n#{@actual_content}" if @expected_content
+      message
+    end
+
+    def failure_message_for_should_not
+      message = "expected file '#{@path}'"
+      message << " with:\n\n#{@expected_content}\n\n" if @expected_content
+      message << " to not be in Chef run"
+    end
+
+    private
+      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 [Boolean]
+      #
+      def has_create_action?
+        !([:create, :create_if_missing] & Array(resource.action).map(&:to_sym)).empty?
+      end
+
+      #
+      # Determines if the resources content matches the expected content.
+      #
+      # @param [Chef::Resource] resource
+      #
+      # @return [Boolean]
+      #
+      def matches_content?
+        return true if @expected_content.nil?
+
+        @actual_content = ChefSpec::Renderer.new(@runner, resource).content
+
+        return false if @actual_content.nil?
+
+        if @expected_content.is_a?(Regexp)
+          @actual_content =~ @expected_content
+        else
+          @actual_content.include?(@expected_content)
+        end
+      end
+  end
+end

data/lib/chefspec/matchers/resource_matcher.rb

@@ -0,0 +1,143 @@
+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
+
+    #
+    # 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 matches?(runner)
+      @runner = runner
+
+      if resource
+        resource_actions.include?(@expected_action) && unmatched_parameters.empty?
+      else
+        false
+      end
+    end
+
+    def failure_message_for_should
+      if resource
+        if resource_actions.include?(@expected_action)
+          "expected '#{resource.to_s}' to have parameters:" \
+          "\n\n" \
+          "  " + unmatched_parameters.collect { |parameter, h|
+            "#{parameter} #{h[:expected].inspect}, was #{h[:actual].inspect}"
+          }.join("\n  ")
+
+        else
+          "expected '#{resource.to_s}' actions #{resource_actions.inspect}" \
+          " to include ':#{@expected_action}'"
+        end
+      else
+        "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  ")
+      end
+    end
+
+    def failure_message_for_should_not
+      if resource
+        "expected '#{resource.to_s}' actions #{resource_actions.inspect} to not exist"
+      else
+        "expected '#{resource.to_s}' to not exist"
+      end
+    end
+
+    def description
+      "#{@expected_action} #{@resource_name}"
+    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)
+        # Chef 11+ stores the source parameter internally as an Array
+        if parameter == :source
+          Array(expected) == Array(safe_send(parameter))
+        else
+          expected === safe_send(parameter)
+        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::Runner#find_resource
+      #
+      # @return [Chef::Resource, nil]
+      #
+      def resource
+        @_resource ||= @runner.find_resource(@resource_name, @expected_identity)
+      end
+
+      #
+      # The list of actions on this resource.
+      #
+      # @return [Array<Symbol>]
+      #
+      def resource_actions
+        @_resource_actions ||= Array(resource.action).map(&:to_sym)
+      end
+
+      #
+      # The list of parameters passed to the {with} matcher.
+      #
+      # @return [Hash]
+      #
+      def params
+        @_params ||= {}
+      end
+  end
+end

data/lib/chefspec/renderer.rb

@@ -0,0 +1,137 @@
+begin
+  require 'chef/mixin/template'
+  require 'chef/provider/template_finder'
+rescue LoadError
+end
+
+module ChefSpec
+  class Renderer
+    # @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.resource_name.to_s
+      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))
+          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, cookbook_file.path))
+      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 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