chefspec-chef 9.3.4

data/lib/chefspec/cacher.rb

@@ -0,0 +1,64 @@
+module ChefSpec
+  #
+  # The cacher module allows for ultra-fast tests by caching the results of a
+  # CCR in memory across an example group. In testing, this can reduce the
+  # total testing time by a factor of 10x. This strategy is _not_ the default
+  # behavior, because it has implications surrounding stubbing and is _not_
+  # threadsafe!
+  #
+  # The credit for this approach and code belongs to Juri Timošin (DracoAter).
+  # Please see his original blog post below for an in-depth explanation of how
+  # and why this approach is faster.
+  #
+  # @example Using the Cacher module
+  #   First, require the Cacher module in your +spec_helper.rb+:
+  #
+  #     RSpec.configure do |config|
+  #       config.extend(ChefSpec::Cacher)
+  #     end
+  #
+  #   Next, change your +let+ blocks to +cached+ blocks:
+  #
+  #     let(:chef_run) { ... } #=> cached(:chef_run) { ... }
+  #
+  #   Finally, celebrate!
+  #
+  # @warn
+  #   This strategy is only recommended for advanced users, as it makes
+  #   stubbing slightly more difficult and indirect!
+  #
+  # @see http://dracoater.blogspot.com/2013/12/testing-chef-cookbooks-part-25-speeding.html
+  #
+  module Cacher
+    @@cache = {}
+    FINALIZER = lambda { |id| @@cache.delete(id) }
+
+    def cached(name, &block)
+      location = ancestors.first.metadata[:location]
+      unless location.nil?
+        location += ancestors.first.metadata[:description] unless ancestors.first.metadata[:description].nil?
+        location += ancestors.first.metadata[:scoped_id] unless ancestors.first.metadata[:scoped_id].nil?
+      end
+      location ||= ancestors.first.metadata[:parent_example_group][:location]
+
+      define_method(name) do
+        key = [location, name.to_s].join(".")
+        unless @@cache.key?(Thread.current.object_id)
+          ObjectSpace.define_finalizer(Thread.current, FINALIZER)
+        end
+        @@cache[Thread.current.object_id] ||= {}
+        @@cache[Thread.current.object_id][key] ||= instance_eval(&block)
+      end
+    end
+
+    def cached!(name, &block)
+      cached(name, &block)
+
+      before { send(name) }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend(ChefSpec::Cacher)
+end

data/lib/chefspec/coverage/filters.rb

@@ -0,0 +1,82 @@
+module ChefSpec
+  class Coverage
+    class Filter
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def matches?
+        raise "Must override Filter#matches?"
+      end
+    end
+
+    #
+    # @example Match resources based on a regular expression.
+    #   add_filter /^test/
+    #
+    class RegexpFilter < Filter
+      def matches?(resource)
+        return true if resource.source_line.nil?
+
+        @filter =~ resource.source_line
+      end
+    end
+
+    #
+    # @example Match resources based on a regular expression.
+    #   add_filter 'test/bar/zip'
+    #
+    class StringFilter < RegexpFilter
+      def initialize(filter)
+        super(Regexp.new("^#{filter}"))
+      end
+    end
+
+    #
+    # @example Match resources based on a custom block.
+    #   # Ignore internal cookbooks
+    #   add_filter do |resource|
+    #     resource.name =~ /^acme-(.+)/
+    #   end
+    #
+    class BlockFilter < Filter
+      def matches?(resource)
+        return true if resource.source_line.nil?
+
+        @filter.call(resource)
+      end
+    end
+
+    #
+    # @example Ignore dependent cookbooks (via Berkshelf)
+    #   add_filter BerkshelfFilter.new(berksfile)
+    #
+    class BerkshelfFilter < Filter
+      def initialize(berksfile)
+        @berksfile = berksfile
+
+        @metadatas = if berksfile.respond_to?(:dependencies)
+                       berksfile.dependencies
+                         .select(&:metadata?)
+                         .map(&:name)
+                     else
+                       berksfile.sources.collect do |source|
+                         location = source.location
+                         if location.respond_to?(:metadata?) && location.metadata?
+                           source
+                         else
+                           nil
+                         end
+                       end.compact.map(&:name)
+                     end
+      end
+
+      def matches?(resource)
+        return true if resource.source_line.nil?
+
+        normalized_source_line = resource.source_line.gsub("\\", "/")
+        normalized_source_line =~ %r{cookbooks/(?!#{@metadatas.join('|')})}
+      end
+    end
+  end
+end

data/lib/chefspec/coverage.rb

@@ -0,0 +1,247 @@
+require_relative "coverage/filters"
+
+module ChefSpec
+  class Coverage
+    EXIT_FAILURE = 1
+    EXIT_SUCCESS = 0
+
+    class << self
+      def method_added(name)
+        # Only delegate public methods
+        if method_defined?(name)
+          instance_eval <<-EOH, __FILE__, __LINE__ + 1
+            def #{name}(*args, &block)
+              instance.public_send(:#{name}, *args, &block)
+            end
+          EOH
+        end
+      end
+    end
+
+    include Singleton
+
+    attr_reader :filters
+
+    #
+    # Create a new coverage object singleton.
+    #
+    def initialize
+      @collection = {}
+      @filters    = {}
+      @outputs    = []
+      add_output do |report|
+
+        erb = Erubis::Eruby.new(File.read(@template))
+        puts erb.evaluate(report)
+      rescue NameError => e
+        raise Error::ErbTemplateParseError.new(original_error: e.message)
+
+      end
+      @template = ChefSpec.root.join("templates", "coverage", "human.erb")
+    end
+
+    #
+    # Start the coverage reporting analysis. This method also adds the the
+    # +at_exit+ handler for printing the coverage report.
+    #
+    def start!(&block)
+      warn("ChefSpec's coverage reporting is deprecated and will be removed in a future version")
+      instance_eval(&block) if block
+      at_exit { ChefSpec::Coverage.report! }
+    end
+
+    #
+    # Add a filter to the coverage analysis.
+    #
+    # @param [Filter, String, Regexp] filter
+    #   the filter to add
+    # @param [Proc] block
+    #   the block to use as a filter
+    #
+    # @return [true]
+    #
+    def add_filter(filter = nil, &block)
+      id = "#{filter.inspect}/#{block.inspect}".hash
+
+      @filters[id] = if filter.is_a?(Filter)
+                       filter
+                     elsif filter.is_a?(String)
+                       StringFilter.new(filter)
+                     elsif filter.is_a?(Regexp)
+                       RegexpFilter.new(filter)
+                     elsif block
+                       BlockFilter.new(block)
+                     else
+                       raise ArgumentError, "Please specify either a string, " \
+                         "filter, or block to filter source files with!"
+                     end
+
+      true
+    end
+
+    #
+    # Add an output to send the coverage results to.
+    # @param [Proc] block
+    #   the block to use as the output
+    #
+    # @return [true]
+    #
+    def add_output(&block)
+      @outputs << block
+    end
+
+    #
+    # Change the template for reporting of converage analysis.
+    #
+    # @param [string] path
+    #   The template file to use for the output of the report
+    #
+    # @return [true]
+    #
+    def set_template(file = "human.erb")
+      @template = [
+        ChefSpec.root.join("templates", "coverage", file),
+        File.expand_path(file, Dir.pwd),
+      ].find { |f| File.exist?(f) }
+      raise Error::TemplateNotFound.new(path: file) unless @template
+    end
+
+    #
+    # Add a resource to the resource collection. Only new resources are added
+    # and only resources that match the given filter are covered (which is *
+    # by default).
+    #
+    # @param [Chef::Resource] resource
+    #
+    def add(resource)
+      if !exists?(resource) && !filtered?(resource)
+        @collection[resource.to_s] = ResourceWrapper.new(resource)
+      end
+    end
+
+    #
+    # Called when a resource is matched to indicate it has been tested.
+    #
+    # @param [Chef::Resource] resource
+    #
+    def cover!(resource)
+      wrapper = find(resource)
+      wrapper.touch! if wrapper
+    end
+
+    #
+    # Called to check if a resource belongs to a cookbook from the specified
+    # directories.
+    #
+    # @param [Chef::Resource] resource
+    #
+    def filtered?(resource)
+      filters.any? { |_, filter| filter.matches?(resource) }
+    end
+
+    #
+    # Generate a coverage report. This report **must** be generated +at_exit+
+    # or else the entire resource collection may not be complete!
+    #
+    # @example Generating a report
+    #
+    #   ChefSpec::Coverage.report!
+    #
+    def report!
+      # Borrowed from simplecov#41
+      #
+      # If an exception is thrown that isn't a "SystemExit", we need to capture
+      # that error and re-raise.
+      if $!
+        exit_status = $!.is_a?(SystemExit) ? $!.status : EXIT_FAILURE
+      else
+        exit_status = EXIT_SUCCESS
+      end
+
+      report = {}.tap do |h|
+        h[:total]     = @collection.size
+        h[:touched]   = @collection.count { |_, resource| resource.touched? }
+        h[:coverage]  = ((h[:touched] / h[:total].to_f) * 100).round(2)
+      end
+
+      report[:untouched_resources] = @collection.collect do |_, resource|
+        resource unless resource.touched?
+      end.compact
+      report[:all_resources] = @collection.values
+
+      @outputs.each do |block|
+        instance_exec(report, &block)
+      end
+
+      # Ensure we exit correctly (#351)
+      Kernel.exit(exit_status) if exit_status && exit_status > 0
+    end
+
+    private
+
+    def find(resource)
+      @collection[resource.to_s]
+    end
+
+    def exists?(resource)
+      !find(resource).nil?
+    end
+
+    class ResourceWrapper
+      attr_reader :resource
+
+      def initialize(resource = nil)
+        @resource = resource
+      end
+
+      def to_s
+        @resource.to_s
+      end
+
+      def to_json
+        {
+          "source_file" => source_file,
+          "source_line" => source_line,
+          "touched" => touched?,
+          "resource" => to_s,
+        }.to_json
+      end
+
+      def source_file
+        @source_file ||= if @resource.source_line
+                           shortname(@resource.source_line.split(":").first)
+                         else
+                           "Unknown"
+                         end
+      end
+
+      def source_line
+        @source_line ||= if @resource.source_line
+                           @resource.source_line.split(":", 2).last.to_i
+                         else
+                           "Unknown"
+                         end
+      end
+
+      def touch!
+        @touched = true
+      end
+
+      def touched?
+        !!@touched
+      end
+
+      private
+
+      def shortname(file)
+        if file.include?(Dir.pwd)
+          file.split(Dir.pwd, 2).last
+        elsif file.include?("cookbooks")
+          file.split("cookbooks/", 2).last
+        else
+          file
+        end
+      end
+    end
+  end
+end

data/lib/chefspec/deprecations.rb

@@ -0,0 +1,46 @@
+module Kernel
+  # Kernel extension to print deprecation notices.
+  #
+  # @example printing a deprecation warning
+  #   deprecated 'no longer in use' #=> "[DEPRECATION] no longer in use"
+  #
+  # @param [Array<String>] messages
+  def deprecated(*messages)
+    messages.each do |message|
+      calling_spec = caller.find { |line| line =~ %r{(/spec)|(_spec\.rb)} }
+      if calling_spec
+        calling_spec = "spec/" + calling_spec.split("/spec/").last
+        warn "[DEPRECATION] #{message} (called from #{calling_spec})"
+      else
+        warn "[DEPRECATION] #{message}"
+      end
+    end
+  end
+end
+
+module ChefSpec
+  class SoloRunner
+    # @deprecated {ChefSpec::Runner.define_runner_method} is deprecated. Please
+    #   use {ChefSpec.define_matcher} instead.
+    def self.define_runner_method(resource_name)
+      deprecated "`ChefSpec::Runner.define_runner_method' is deprecated." \
+        " It is being used in the #{resource_name} resource matcher." \
+        " Please use `ChefSpec.define_matcher' instead."
+
+      ChefSpec.define_matcher(resource_name)
+    end
+  end
+
+  class Server
+    def self.method_missing(m, *args, &block)
+      deprecated "`ChefSpec::Server.#{m}' is deprecated. There is no longer" \
+        " a global Chef Server instance. Please use a ChefSpec::SoloRunner" \
+        " instead. More documentation can be found in the ChefSpec README."
+      raise ChefSpec::Error::NoConversionError
+    end
+  end
+end
+
+module ChefSpec::Error
+  class NoConversionError < ChefSpecError; end
+end

data/lib/chefspec/errors.rb

@@ -0,0 +1,48 @@
+module ChefSpec
+  module Error
+    class ChefSpecError < StandardError
+      def initialize(options = {})
+        class_name = self.class.to_s.split("::").last
+        filename   = options.delete(:_template) || Util.underscore(class_name)
+        template   = ChefSpec.root.join("templates", "errors", "#{filename}.erb")
+
+        erb = Erubis::Eruby.new(File.read(template))
+        super erb.evaluate(options)
+      end
+    end
+
+    class NotStubbed < ChefSpecError
+      def initialize(options = {})
+        name  = self.class.name.to_s.split("::").last
+        type  = Util.underscore(name).gsub("_not_stubbed", "")
+        klass = Stubs.const_get(name.gsub("NotStubbed", "") + "Stub")
+        stub  = klass.new(*options[:args]).and_return("...").signature
+
+        signature = "#{type}(#{options[:args].map(&:inspect).join(", ")})"
+
+        super({
+          type:      type,
+          signature: signature,
+          stub:      stub,
+          _template: :not_stubbed,
+        }.merge(options))
+      end
+    end
+
+    class CommandNotStubbed < NotStubbed; end
+    class SearchNotStubbed < NotStubbed; end
+    class DataBagNotStubbed < NotStubbed; end
+    class DataBagItemNotStubbed < NotStubbed; end
+    class ShellOutNotStubbed < ChefSpecError; end
+
+    class CookbookPathNotFound < ChefSpecError; end
+    class GemLoadError < ChefSpecError; end
+
+    class MayNeedToSpecifyPlatform < ChefSpecError; end
+
+    class InvalidBerkshelfOptions < ChefSpecError; end
+
+    class TemplateNotFound < ChefSpecError; end
+    class ErbTemplateParseError < ChefSpecError; end
+  end
+end

data/lib/chefspec/expect_exception.rb

@@ -0,0 +1,51 @@
+class RSpec::Matchers::BuiltIn::RaiseError
+  class << self
+    attr_accessor :last_run
+  end
+
+  attr_reader :expected_message
+
+  def last_error_for_chefspec
+    @expected_error
+  end
+
+  alias_method :old_matches?, :matches?
+  def matches?(*args)
+    self.class.last_run = self
+    old_matches?(*args)
+  end
+end
+
+module ChefSpec
+  class ExpectException
+    def initialize(formatter_exception, formatter_message = nil)
+      @formatter_exception = formatter_exception
+      @formatter_message   = formatter_message
+      @matcher             = RSpec::Matchers::BuiltIn::RaiseError.last_run
+    end
+
+    def expected?
+      return false if @matcher.nil?
+
+      exception_matched? && message_matched?
+    end
+
+    private
+
+    def exception_matched?
+      @formatter_exception == @matcher.last_error_for_chefspec ||
+        @matcher.last_error_for_chefspec === @formatter_exception
+    end
+
+    def message_matched?
+      case @formatter_message
+      when nil
+        true
+      when Regexp
+        @matcher.expected_message =~ @formatter_message
+      else
+        @matcher.expected_message == @formatter_message
+      end
+    end
+  end
+end

data/lib/chefspec/extensions/chef/client.rb

@@ -0,0 +1,21 @@
+# Force loading Chef Config to fix a bad dependency tree. See
+# https://github.com/opscode/chef/issues/2703 for more information.
+require "chef/config"
+
+# Providers has to be included before client... probably a weird
+# include missing in Chef-land, but we can make sure we get it right anyway.
+require "chef/providers"
+require "chef/client"
+
+# @private
+Chef::Client.prepend(Module.new do
+  #
+  # Don't actually run ohai (we have fake data for that)
+  #
+  # @see Chef::Client#run_ohai
+  #
+  def run_ohai
+    return super unless $CHEFSPEC_MODE
+    # noop
+  end
+end)

data/lib/chefspec/extensions/chef/conditional.rb

@@ -0,0 +1,16 @@
+require "chef/resource/conditional"
+
+Chef::Resource::Conditional.prepend(Module.new do
+  # @see Chef::Resource::Conditional#evaluate_command
+  def evaluate_command
+    return super unless $CHEFSPEC_MODE
+
+    stub = ChefSpec::Stubs::CommandRegistry.stub_for(@command)
+
+    if stub.nil?
+      raise ChefSpec::Error::CommandNotStubbed.new(args: [@command])
+    end
+
+    stub.result
+  end
+end)

data/lib/chefspec/extensions/chef/cookbook/gem_installer.rb

@@ -0,0 +1,33 @@
+require "chef/cookbook/gem_installer"
+
+Chef::Cookbook::GemInstaller.prepend(Module.new do
+  # Installs the gems into the omnibus gemset.
+  def install
+    return super unless $CHEFSPEC_MODE
+
+    cookbook_gems = Hash.new { |h, k| h[k] = [] }
+
+    cookbook_collection.each do |cookbook_name, cookbook_version|
+      cookbook_version.metadata.gems.each do |args|
+        cookbook_gems[args.first] += args[1..-1]
+      end
+    end
+
+    events.cookbook_gem_start(cookbook_gems)
+    cookbook_gems.each { |gem_name, gem_requirements| locate_gem(gem_name, gem_requirements) }
+    events.cookbook_gem_finished
+  end
+
+  private
+
+  def locate_gem(gem_name, gem_requirements)
+    ::Gem::Specification.find_by_name(gem_name, gem_requirements)
+  rescue ::Gem::MissingSpecError
+    gem_cmd = "gem install #{gem_name} --version '#{gem_requirements.join(", ")}'"
+    gemfile_line = "gem '#{[gem_name, *gem_requirements].join("', '")}'"
+    warn "No matching version found for '#{gem_name}' in your gem environment.\n" \
+         " - if you are using Chef Workstation, run the following command: \"chef #{gem_cmd}\"\n" \
+         " - if you are using bundler, append \"#{gemfile_line}\" to your Gemfile and run \"bundle install\"\n" \
+         " - otherwise run: \"#{gem_cmd}\""
+  end
+end)

data/lib/chefspec/extensions/chef/cookbook_loader.rb

@@ -0,0 +1,14 @@
+require "chef/cookbook_loader"
+
+Chef::CookbookLoader.prepend(Module.new do
+  def all_directories_in_repo_paths
+    return super unless $CHEFSPEC_MODE
+
+    if Chef::Config[:chefspec_cookbook_root]
+      # Hax.
+      [Chef::Config[:chefspec_cookbook_root]]
+    else
+      super
+    end
+  end
+end)

data/lib/chefspec/extensions/chef/cookbook_uploader.rb

@@ -0,0 +1,12 @@
+require "chef/cookbook_uploader"
+
+Chef::CookbookUploader.prepend(Module.new do |variable|
+  #
+  # Don't validate uploaded cookbooks. Validating a cookbook takes *forever*
+  # to complete. It's just not worth it...
+  #
+  def validate_cookbooks
+    return super unless $CHEFSPEC_MODE
+    # noop
+  end
+end)

data/lib/chefspec/extensions/chef/data_query.rb

@@ -0,0 +1,49 @@
+require "chef/dsl/data_query"
+
+Chef::DSL::DataQuery.prepend(Module.new do
+  # @see Chef::DSL::DataQuery#search
+  def search(*args, &block)
+    return super unless Chef::Config[:solo] && $CHEFSPEC_MODE
+
+    type  = args[0]
+    query = args[1] || "*:*"
+    stub = ChefSpec::Stubs::SearchRegistry.stub_for(type, query)
+
+    if stub.nil?
+      raise ChefSpec::Error::SearchNotStubbed.new(args: [type, query])
+    end
+
+    if block
+      Array(stub.result).each { |r| block.call(r) }
+      true
+    else
+      stub.result
+    end
+  end
+
+  # @see Chef::DSL::DataQuery#data_bag
+  def data_bag(bag)
+    return super unless Chef::Config[:solo] && $CHEFSPEC_MODE
+
+    stub = ChefSpec::Stubs::DataBagRegistry.stub_for(bag)
+
+    if stub.nil?
+      raise ChefSpec::Error::DataBagNotStubbed.new(args: [bag])
+    end
+
+    stub.result
+  end
+
+  # @see Chef::DSL::DataQuery#data_bag_item
+  def data_bag_item(bag, id, secret = nil)
+    return super unless Chef::Config[:solo] && $CHEFSPEC_MODE
+
+    stub = ChefSpec::Stubs::DataBagItemRegistry.stub_for(bag, id)
+
+    if stub.nil?
+      raise ChefSpec::Error::DataBagItemNotStubbed.new(args: [bag, id])
+    end
+
+    stub.result
+  end
+end)