chefspec-chef 9.3.4

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

@@ -0,0 +1,29 @@
+# XXX: This monkeypatch is somewhat terrible and dumps all of the
+# resources in the sub-resource collection into the main resource
+# collection.  Chefspec needs to be taught how to deal with
+# sub-resource collections.
+
+if defined?(Chef::Provider::InlineResources)
+  Chef::Provider::InlineResources.prepend(Module.new do
+    def initialize(resource, run_context)
+      super
+      @run_context = run_context
+      @resource_collection = run_context.resource_collection
+    end
+  end)
+
+  Chef::Provider::InlineResources::ClassMethods.prepend(Module.new do
+    def action(name, &block)
+      # Note: This does not check $CHEFSPEC_MODE.
+      define_method("action_#{name}", &block)
+    end
+  end)
+else # >= 13.0
+  Chef::Provider.prepend(Module.new do
+    def compile_and_converge_action(&block)
+      return super unless $CHEFSPEC_MODE
+
+      instance_eval(&block)
+    end
+  end)
+end

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

@@ -0,0 +1,39 @@
+require "chef/provider"
+require_relative "../../api"
+
+Chef::Provider.prepend(Module.new do
+  def self.name
+    "ChefSpec extensions for Chef::Provider"
+  end
+
+  def self.inspect
+    "#<Module: #{name}>"
+  end
+
+  # Hook for the stubs_for system.
+  def initialize(*args, &block)
+    super(*args, &block)
+    ChefSpec::API::StubsFor.setup_stubs_for(self, :provider) if $CHEFSPEC_MODE
+  end
+
+  # Defang shell_out and friends so it can never run.
+  if ChefSpec::API::StubsFor::HAS_SHELLOUT_COMPACTED.satisfied_by?(Gem::Version.create(Chef::VERSION))
+    def shell_out_compacted(*args)
+      return super unless $CHEFSPEC_MODE
+
+      raise ChefSpec::Error::ShellOutNotStubbed.new(args: args, type: "provider", resource: new_resource)
+    end
+
+    def shell_out_compacted!(*args)
+      return super unless $CHEFSPEC_MODE
+
+      shell_out_compacted(*args).tap(&:error!)
+    end
+  else
+    def shell_out(*args)
+      return super unless $CHEFSPEC_MODE
+
+      raise ChefSpec::Error::ShellOutNotStubbed.new(args: args, type: "provider", resource: new_resource)
+    end
+  end
+end)

data/lib/chefspec/extensions/chef/resource/freebsd_package.rb

@@ -0,0 +1,17 @@
+require "chef/resource/freebsd_package"
+
+Chef::Resource::FreebsdPackage.prepend(Module.new do
+  #
+  # Chef decided it was a good idea to just shellout inside of a resource.
+  # Not only is that a horrible fucking idea, but I got flak when I asked
+  # to change it. So we are just going to monkey patch the fucking thing so
+  # it does not shell out.
+  #
+  # @return [false]
+  #
+  def supports_pkgng?
+    return super unless $CHEFSPEC_MODE
+
+    true
+  end
+end)

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

@@ -0,0 +1,188 @@
+require "chef/resource"
+require "chef/version"
+require_relative "../../api"
+
+#
+# Three concerns:
+#   - no-op'ing so that the action does not run the provider
+#   - tracking the actions that were performed
+#   - auto registering helper methods
+#
+
+module ChefSpec::Extensions::Chef::Resource
+
+  #
+  # Hooks for the stubs_for system
+  #
+  def initialize(*args, &block)
+    super(*args, &block)
+    if $CHEFSPEC_MODE
+      # Here be dragons.
+      # If we're directly inside a `load_current_resource`, this is probably
+      # something like `new_resource.class.new` so we want to call this a current_resource,
+      # Otherwise it's probably a normal resource instantiation.
+      mode = :resource
+      mode = :current_value if caller.any? { |x| x.include?("`load_current_resource'") || x.include?("`load_after_resource'") }
+      ChefSpec::API::StubsFor.setup_stubs_for(self, mode)
+    end
+  end
+
+  def dup
+    return super unless $CHEFSPEC_MODE
+
+    # Also here be dragons.
+    super.tap do |dup_resource|
+      # We're directly inside a load_current_resource, which is probably via
+      # the load_current_value DSL system, so call this a current resource.
+      ChefSpec::API::StubsFor.setup_stubs_for(dup_resource, :current_value) if caller.any? { |x| x.include?("`load_current_resource'") || x.include?("`load_after_resource'") }
+    end
+  end
+
+  # mix of no-op and tracking concerns
+  def run_action(action, notification_type = nil, notifying_resource = nil)
+    return super unless $CHEFSPEC_MODE
+
+    resolve_notification_references
+    validate_action(action)
+
+    Chef::Log.info("Processing #{self} action #{action} (#{defined_at})")
+
+    ChefSpec::Coverage.add(self)
+
+    unless should_skip?(action)
+      if node.runner.step_into?(self)
+        instance_eval { @not_if = []; @only_if = [] }
+        super
+      end
+
+      if node.runner.compiling?
+        perform_action(action, compile_time: true)
+      else
+        perform_action(action, converge_time: true)
+      end
+    end
+  end
+
+  #
+  # Defang shell_out and friends so it can never run.
+  #
+  if ChefSpec::API::StubsFor::HAS_SHELLOUT_COMPACTED.satisfied_by?(Gem::Version.create(Chef::VERSION))
+    def shell_out_compacted(*args)
+      return super unless $CHEFSPEC_MODE
+
+      raise ChefSpec::Error::ShellOutNotStubbed.new(args: args, type: "resource", resource: self)
+    end
+
+    def shell_out_compacted!(*args)
+      return super unless $CHEFSPEC_MODE
+
+      shell_out_compacted(*args).tap(&:error!)
+    end
+  else
+    def shell_out(*args)
+      return super unless $CHEFSPEC_MODE
+
+      raise ChefSpec::Error::ShellOutNotStubbed.new(args: args, type: "resource", resource: self)
+    end
+  end
+
+  #
+  # tracking
+  #
+
+  def perform_action(action, options = {})
+    @performed_actions ||= {}
+    @performed_actions[action.to_sym] ||= {}
+    @performed_actions[action.to_sym].merge!(options)
+  end
+
+  def performed_action(action)
+    @performed_actions ||= {}
+    @performed_actions[action.to_sym]
+  end
+
+  def performed_action?(action)
+    if action == :nothing
+      performed_actions.empty?
+    else
+      !!performed_action(action)
+    end
+  end
+
+  def performed_actions
+    @performed_actions ||= {}
+    @performed_actions.keys
+  end
+
+  #
+  # auto-registration
+  #
+
+  def self.prepended(base)
+    class << base
+      prepend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    # XXX: kind of a crappy way to find all the names of a resource
+    def provides_names
+      @provides_names ||= []
+    end
+
+    def resource_name(name = ::Chef::NOT_PASSED)
+      unless name == ::Chef::NOT_PASSED
+        provides_names << name unless provides_names.include?(name)
+        inject_actions(*allowed_actions)
+      end
+      super
+    end
+
+    def provides(name, **options, &block)
+      provides_names << name unless provides_names.include?(name)
+      inject_actions(*allowed_actions)
+      super
+    end
+
+    def action(sym, description: nil, &block)
+      inject_actions(sym)
+      super(sym, &block)
+    end
+
+    def allowed_actions(*actions)
+      inject_actions(*actions) unless actions.empty?
+      super
+    end
+
+    def allowed_actions=(value)
+      inject_actions(*Array(value))
+      super
+    end
+
+    private
+
+    def inject_method(method, resource_name, action)
+      unless ChefSpec::API.respond_to?(method)
+        ChefSpec::API.send(:define_method, method) do |name|
+          ChefSpec::Matchers::ResourceMatcher.new(resource_name, action, name)
+        end
+      end
+    end
+
+    def inject_actions(*actions)
+      provides_names.each do |resource_name|
+        next unless resource_name
+
+        ChefSpec.define_matcher(resource_name)
+        actions.each do |action|
+          inject_method(:"#{action}_#{resource_name}", resource_name, action)
+          if action == :create_if_missing
+            inject_method(:"create_#{resource_name}_if_missing", resource_name, action)
+          end
+        end
+      end
+    end
+  end
+end
+
+Chef::Resource.prepend(ChefSpec::Extensions::Chef::Resource)

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

@@ -0,0 +1,84 @@
+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_ohai_plugins_from_cookbook(cookbook)
+    return super unless $CHEFSPEC_MODE
+
+    $CHEFSPEC_OHAI_PRELOAD ||= {}
+    # Already loaded this once.
+    return if $CHEFSPEC_OHAI_PRELOAD[cookbook]
+
+    $CHEFSPEC_OHAI_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/extensions/chef/securable.rb

@@ -0,0 +1,19 @@
+require "chef/mixin/securable"
+
+class Chef
+  module Mixin
+    module Securable
+      # In Chef, this module is only included if the RUBY_PLATFORM is
+      # Windows-like. In ChefSpec, we want to include this, regardless of the
+      # platform, becuase this module holds the `inherits` attribute, which is
+      # critical in testing Windows resources.
+      include WindowsSecurableAttributes
+
+      def self.included(including_class)
+        including_class.extend(WindowsMacros)
+        including_class.rights_attribute(:rights)
+        including_class.rights_attribute(:deny_rights)
+      end
+    end
+  end
+end

data/lib/chefspec/extensions/ohai/system.rb

@@ -0,0 +1,11 @@
+require "ohai/system"
+
+Ohai::System.prepend(Module.new do
+  # If an Ohai segment exists, don't actually pull data in for ohai.
+  # (we have fake data for that)
+  # @see Ohai::System#run_additional_plugins
+  def run_additional_plugins(plugin_path)
+    return super unless $CHEFSPEC_MODE
+    # noop
+  end
+end)

data/lib/chefspec/extensions.rb

@@ -0,0 +1,21 @@
+require "rspec"
+
+module ChefSpec::Extensions
+  module Chef
+  end
+end
+
+# STOP! DO NOT ALPHABETIZE!
+require_relative "extensions/chef/data_query" # must be before Chef::Resource loads
+require_relative "extensions/chef/resource"  # must come before client extensions or anything that winds up loading resources
+require_relative "extensions/chef/provider"
+require_relative "extensions/chef/securable"
+require_relative "extensions/chef/client"
+require_relative "extensions/chef/conditional"
+require_relative "extensions/chef/cookbook_uploader"
+require_relative "extensions/chef/cookbook/gem_installer"
+require_relative "extensions/chef/lwrp_base"
+require_relative "extensions/chef/resource/freebsd_package"
+require_relative "extensions/chef/run_context/cookbook_compiler"
+require_relative "extensions/chef/cookbook_loader"
+require_relative "extensions/ohai/system"

data/lib/chefspec/file_cache_path_proxy.rb

@@ -0,0 +1,15 @@
+require "fileutils" unless defined?(FileUtils)
+require "singleton" unless defined?(Singleton)
+
+module ChefSpec
+  class FileCachePathProxy
+    include Singleton
+
+    attr_reader :file_cache_path
+
+    def initialize
+      @file_cache_path = Dir.mktmpdir(%w{chefspec file_cache_path})
+      at_exit { FileUtils.rm_rf(@file_cache_path) }
+    end
+  end
+end