chefspec 7.2.1 → 7.3.0

data/lib/chefspec/extensions/chef/run_context/cookbook_compiler.rb

@@ -0,0 +1,64 @@
+require 'chef/run_context/cookbook_compiler'
+
+Chef::RunContext::CookbookCompiler.prepend(Module.new do
+  # List of compile phases as of Chef 14:
+  # compile_libraries
+  # compile_ohai_plugins
+  # compile_attributes
+  # compile_lwrps
+  # compile_resource_definitions
+  # compile_recipes
+
+  #
+  # Compile phases that should only ever run once, globally.
+  #
+
+  def load_libraries_from_cookbook(cookbook)
+    return super unless $CHEFSPEC_MODE
+    $CHEFSPEC_LIBRARY_PRELOAD ||= {}
+    # Already loaded this once.
+    return if $CHEFSPEC_LIBRARY_PRELOAD[cookbook]
+    $CHEFSPEC_LIBRARY_PRELOAD[cookbook] = true
+    super
+  end
+
+  def load_lwrps_from_cookbook(cookbook)
+    return super unless $CHEFSPEC_MODE
+    $CHEFSPEC_LWRP_PRELOAD ||= {}
+    # Already loaded this once.
+    return if $CHEFSPEC_LWRP_PRELOAD[cookbook]
+    $CHEFSPEC_LWRP_PRELOAD[cookbook] = true
+    super
+  end
+
+  def load_resource_definitions_from_cookbook(cookbook)
+    return super unless $CHEFSPEC_MODE
+    $CHEFSPEC_DEFINITION_PRELOAD ||= {}
+    # Already loaded this once.
+    return if $CHEFSPEC_DEFINITION_PRELOAD[cookbook]
+    $CHEFSPEC_DEFINITION_PRELOAD[cookbook] = true
+    super
+  end
+
+  #
+  # Compile phases that should not run during preload
+  #
+
+  def compile_ohai_plugins
+    return super unless $CHEFSPEC_MODE
+    return if $CHEFSPEC_PRELOAD
+    super
+  end
+
+  def compile_attributes
+    return super unless $CHEFSPEC_MODE
+    return if $CHEFSPEC_PRELOAD
+    super
+  end
+
+  def compile_recipes
+    return super unless $CHEFSPEC_MODE
+    return if $CHEFSPEC_PRELOAD
+    super
+  end
+end)

data/lib/chefspec/matchers/render_file_matcher.rb

@@ -3,6 +3,7 @@ module ChefSpec::Matchers
     attr_reader :expected_content
     def initialize(path)
       @path = path
+      @expected_content = []
     end
 
     def matches?(runner)
@@ -20,9 +21,9 @@ module ChefSpec::Matchers
       if expected_content && block
         raise ArgumentError, "Cannot specify expected content and a block!"
       elsif expected_content
-        @expected_content = expected_content
+        @expected_content << expected_content
       elsif block_given?
-        @expected_content = block
+        @expected_content << block
       else
         raise ArgumentError, "Must specify expected content or a block!"
       end
@@ -32,11 +33,11 @@ module ChefSpec::Matchers
 
     def description
       message = %Q{render file "#{@path}"}
-      if @expected_content
-        if @expected_content.to_s.include?("\n")
+      @expected_content.each do |expected|
+        if expected.to_s.include?("\n")
           message << " with content <suppressed>"
         else
-          message << " with content #{@expected_content.inspect}"
+          message << " with content #{expected.inspect}"
         end
       end
       message
@@ -44,7 +45,7 @@ module ChefSpec::Matchers
 
     def failure_message
       message = %Q{expected Chef run to render "#{@path}"}
-      if @expected_content
+      unless @expected_content.empty?
         message << " matching:"
         message << "\n\n"
         message << expected_content_message
@@ -59,7 +60,7 @@ module ChefSpec::Matchers
 
     def failure_message_when_negated
       message = %Q{expected file "#{@path}"}
-      if @expected_content
+      unless @expected_content.empty?
         message << " matching:"
         message << "\n\n"
         message << expected_content_message
@@ -72,13 +73,16 @@ module ChefSpec::Matchers
     private
 
     def expected_content_message
-      if RSpec::Matchers.is_a_matcher?(@expected_content) && @expected_content.respond_to?(:description)
-        @expected_content.description
-      elsif @expected_content.is_a?(Proc)
-        "(the result of a proc)"
-      else
-        @expected_content.to_s
+      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
@@ -106,25 +110,31 @@ module ChefSpec::Matchers
     # @return [true, false]
     #
     def matches_content?
-      return true if @expected_content.nil?
+      return true if @expected_content.empty?
 
       @actual_content = ChefSpec::Renderer.new(@runner, resource).content
 
       return false if @actual_content.nil?
 
-      if @expected_content.is_a?(Regexp)
-        @actual_content =~ @expected_content
-      elsif RSpec::Matchers.is_a_matcher?(@expected_content)
-        @expected_content.matches?(@actual_content)
-      elsif @expected_content.is_a?(Proc)
-        @expected_content.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_content)
+      # 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

@@ -39,7 +39,7 @@ module ChefSpec::Matchers
     end
 
     def description
-      %Q{#{@expected_actioe} #{@resource_name} "#{@expected_identity}"}
+      %Q{#{@expected_action} #{@resource_name} "#{@expected_identity}"}
     end
 
     def matches?(runner)

data/lib/chefspec/rspec.rb

@@ -1,16 +1,11 @@
 RSpec.configure do |config|
-  config.include(ChefSpec::API)
-  config.include(ChefSpec::Macros)
-
-  config.after(:each) do
-    ChefSpec::Stubs::CommandRegistry.reset!
-    ChefSpec::Stubs::DataBagRegistry.reset!
-    ChefSpec::Stubs::DataBagItemRegistry.reset!
-    ChefSpec::Stubs::SearchRegistry.reset!
+  unless ENV['CHEFSPEC_NO_INCLUDE']
+    config.include(ChefSpec::API)
   end
 
   config.add_setting :berkshelf_options, default: {}
   config.add_setting :file_cache_path
+  config.add_setting :cookbook_root
   config.add_setting :cookbook_path
   config.add_setting :role_path
   config.add_setting :environment_path

data/lib/chefspec/runner.rb

@@ -0,0 +1,8 @@
+require "chefspec/solo_runner"
+
+module ChefSpec
+  # As we start to migrate back to only SoloRunner, include this alias for now.
+  #
+  # @since 7.3
+  Runner = SoloRunner
+end

data/lib/chefspec/server_methods.rb

@@ -118,7 +118,7 @@ module ChefSpec
     #
     # @example Create a node from a +Chef::Node+ object
     #
-    #   node = stub_node('bacon', platform: 'ubuntu', version: '16.04')
+    #   node = stub_node('bacon', platform: 'ubuntu', version: '18.04')
     #   create_node(node)
     #
     # @param [String, Chef::Node] object

data/lib/chefspec/server_runner.rb

@@ -23,15 +23,6 @@ module ChefSpec
       # our yielding.
       super(options, &nil)
 
-      Chef::Config[:client_key]      = client_key
-      Chef::Config[:client_name]     = 'chefspec'
-      Chef::Config[:node_name]       = 'chefspec'
-      Chef::Config[:solo]            = false
-      Chef::Config[:solo_legacy_mode] = false
-
-      Chef::Config[:chef_server_url]  = server.url
-      Chef::Config[:http_retry_count] = 0
-
       # Unlike the SoloRunner, the node AND server object are yielded for
       # customization
       yield node, self if block_given?
@@ -68,5 +59,18 @@ module ChefSpec
       at_exit { FileUtils.rm_rf(tmp) }
       path
     end
+
+    # (see SoloRunner#apply_chef_config!)
+    def apply_chef_config!
+      super
+      Chef::Config[:client_key]       = client_key
+      Chef::Config[:client_name]      = 'chefspec'
+      Chef::Config[:node_name]        = 'chefspec'
+      Chef::Config[:solo]             = false
+      Chef::Config[:solo_legacy_mode] = false
+
+      Chef::Config[:chef_server_url]  = server.url
+      Chef::Config[:http_retry_count] = 0
+    end
   end
 end

data/lib/chefspec/solo_runner.rb

@@ -1,5 +1,6 @@
 require 'fauxhai'
 require 'chef/client'
+require 'chef/cookbook/metadata'
 require 'chef/mash'
 require 'chef/providers'
 require 'chef/resources'
@@ -34,7 +35,7 @@ module ChefSpec
     #   ChefSpec::SoloRunner.new
     #
     # @example Specifying the platform and version
-    #   ChefSpec::SoloRunner.new(platform: 'ubuntu', version: '16.04')
+    #   ChefSpec::SoloRunner.new(platform: 'ubuntu', version: '18.04')
     #
     # @example Specifying the cookbook path
     #   ChefSpec::SoloRunner.new(cookbook_path: ['/cookbooks'])
@@ -63,26 +64,7 @@ module ChefSpec
     #
     def initialize(options = {})
       @options = with_default_options(options)
-
-      Chef::Log.level = @options[:log_level]
-
-      Chef::Config.reset!
-      Chef::Config.formatters.clear
-      Chef::Config.add_formatter('chefspec')
-      Chef::Config[:cache_type]      = 'Memory'
-      Chef::Config[:client_key]      = nil
-      Chef::Config[:client_name]     = nil
-      Chef::Config[:node_name]       = nil
-      Chef::Config[:file_cache_path] = @options[:file_cache_path] || file_cache_path
-      Chef::Config[:cookbook_path]   = Array(@options[:cookbook_path])
-      Chef::Config[:no_lazy_load]    = true
-      Chef::Config[:role_path]       = Array(@options[:role_path])
-      Chef::Config[:force_logger]    = true
-      Chef::Config[:solo]            = true
-      Chef::Config[:solo_legacy_mode] = true
-      Chef::Config[:use_policyfile]  = false
-      Chef::Config[:environment_path] = @options[:environment_path]
-
+      apply_chef_config!
       yield node if block_given?
     end
 
@@ -105,6 +87,10 @@ module ChefSpec
     #   A reference to the calling Runner (for chaining purposes)
     #
     def converge(*recipe_names)
+      # Re-apply the Chef config before converging in case something else
+      # called Config.reset too.
+      apply_chef_config!
+      @converging = false
       node.run_list.reset!
       recipe_names.each { |recipe_name| node.run_list.add(recipe_name) }
 
@@ -113,6 +99,14 @@ module ChefSpec
       # Expand the run_list
       expand_run_list!
 
+      # Merge in provided node attributes. Default and override use the role_
+      # levels so they win over the relevant bits from cookbooks since otherwise
+      # they would not and that would be confusing.
+      node.attributes.role_default = Chef::Mixin::DeepMerge.merge(node.attributes.role_default, options[:default_attributes]) if options[:default_attributes]
+      node.attributes.normal = Chef::Mixin::DeepMerge.merge(node.attributes.normal, options[:normal_attributes]) if options[:normal_attributes]
+      node.attributes.role_override = Chef::Mixin::DeepMerge.merge(node.attributes.role_override, options[:override_attributes]) if options[:override_attributes]
+      node.attributes.automatic = Chef::Mixin::DeepMerge.merge(node.attributes.automatic, options[:automatic_attributes]) if options[:automatic_attributes]
+
       # Setup the run_context, rescuing the exception that happens when a
       # resource is not defined on a particular platform
       begin
@@ -132,18 +126,53 @@ module ChefSpec
       self
     end
 
+    #
+    # Execute a block of recipe code.
+    #
+    # @param [Proc] block
+    #   A block containing Chef recipe code
+    #
+    # @return [ChefSpec::SoloRunner]
+    #
+    def converge_block(&block)
+      converge do
+        recipe = Chef::Recipe.new(cookbook_name, '_test', run_context)
+        recipe.instance_exec(&block)
+      end
+    end
+
+    #
+    # Run a static preload of the cookbook under test. This will load libraries
+    # and resources, but not attributes or recipes.
+    #
+    # @return [void]
+    #
+    def preload!
+      # Flag to disable preloading for situations where it doesn't make sense.
+      return if ENV['CHEFSPEC_NO_PRELOAD']
+      begin
+        old_preload = $CHEFSPEC_PRELOAD
+        $CHEFSPEC_PRELOAD = true
+        converge("recipe[#{cookbook_name}]")
+        node.run_list.reset!
+      ensure
+        $CHEFSPEC_PRELOAD = old_preload
+      end
+    end
+
     #
     # The +Chef::Node+ corresponding to this Runner.
     #
     # @return [Chef::Node]
     #
     def node
-      return @node if @node
-
-      @node = client.build_node
-      @node.instance_variable_set(:@runner, self)
-      @node.class.send(:attr_reader, :runner)
-      @node
+      runner = self
+      @node ||= begin
+        apply_chef_config!
+        client.build_node.tap do |node|
+          node.define_singleton_method(:runner) { runner }
+        end
+      end
     end
 
     #
@@ -306,7 +335,8 @@ module ChefSpec
       config = RSpec.configuration
 
       {
-        cookbook_path: config.cookbook_path || calling_cookbook_path(caller),
+        cookbook_root: config.cookbook_root || calling_cookbook_root(options, caller),
+        cookbook_path: config.cookbook_path || calling_cookbook_path(options, caller),
         role_path:     config.role_path || default_role_path,
         environment_path: config.environment_path || default_environment_path,
         file_cache_path: config.file_cache_path,
@@ -318,21 +348,37 @@ module ChefSpec
     end
 
     #
-    # The inferred path from the calling spec.
+    # The inferred cookbook root from the calling spec.
     #
+    # @param [Hash<Symbol, Object>] options
+    #   initial runner options
     # @param [Array<String>] kaller
     #   the calling trace
     #
     # @return [String]
     #
-    def calling_cookbook_path(kaller)
-      calling_spec = kaller.find { |line| line =~ /\/spec/ }
+    def calling_cookbook_root(options, kaller)
+      calling_spec = options[:spec_declaration_locations] || kaller.find { |line| line =~ /\/spec/ }
       raise Error::CookbookPathNotFound if calling_spec.nil?
 
       bits = calling_spec.split(/:[0-9]/, 2).first.split(File::SEPARATOR)
       spec_dir = bits.index('spec') || 0
 
-      File.expand_path(File.join(bits.slice(0, spec_dir), '..'))
+      File.join(bits.slice(0, spec_dir))
+    end
+
+    #
+    # The inferred path from the calling spec.
+    #
+    # @param [Hash<Symbol, Object>] options
+    #   initial runner options
+    # @param [Array<String>] kaller
+    #   the calling trace
+    #
+    # @return [String]
+    #
+    def calling_cookbook_path(options, kaller)
+      File.expand_path(File.join(calling_cookbook_root(options, kaller), '..'))
     end
 
     #
@@ -406,5 +452,63 @@ module ChefSpec
         end
       end
     end
+
+    #
+    # Try to load the cookbook metadata for the cookbook under test.
+    #
+    # @return [Chef::Cookbook::Metadata]
+    #
+    def cookbook
+      @cookbook ||= Chef::Cookbook::Metadata.new.tap {|m| m.from_file("#{options[:cookbook_root]}/metadata.rb") }
+    end
+
+    #
+    # Try to figure out the name for the cookbook under test.
+    #
+    # @return [String]
+    #
+    def cookbook_name
+      # Try to figure out the name of this cookbook, pretending this block
+      # is in the name context as the cookbook under test.
+      begin
+        cookbook.name
+      rescue IOError
+        # Old cookbook, has no metadata, use the folder name I guess.
+        File.basename(options[:cookbook_root])
+      end
+    end
+
+    #
+    # Apply the required options to {Chef::Config}.
+    #
+    # @api private
+    # @return [void]
+    #
+    def apply_chef_config!
+      Chef::Log.level = @options[:log_level]
+
+      Chef::Config.reset!
+      Chef::Config.formatters.clear
+      Chef::Config.add_formatter('chefspec')
+      Chef::Config[:cache_type]      = 'Memory'
+      Chef::Config[:client_key]      = nil
+      Chef::Config[:client_name]     = nil
+      Chef::Config[:node_name]       = nil
+      Chef::Config[:file_cache_path] = @options[:file_cache_path] || file_cache_path
+      Chef::Config[:cookbook_path]   = Array(@options[:cookbook_path])
+      # If the word cookbook is in the folder name, treat it as the path. Otherwise
+      # it's probably not a cookbook path and so we activate the gross hack mode.
+      if Chef::Config[:cookbook_path].size == 1 && Chef::Config[:cookbook_path].first !~ /cookbook/
+        Chef::Config[:chefspec_cookbook_root] = @options[:cookbook_root]
+      end
+      Chef::Config[:no_lazy_load]    = true
+      Chef::Config[:role_path]       = Array(@options[:role_path])
+      Chef::Config[:force_logger]    = true
+      Chef::Config[:solo]            = true
+      Chef::Config[:solo_legacy_mode] = true
+      Chef::Config[:use_policyfile]  = false
+      Chef::Config[:environment_path] = @options[:environment_path]
+    end
+
   end
 end