rspec-puppet 2.5.0 → 2.6.0

data/lib/rspec-puppet/example/function_example_group.rb

@@ -14,9 +14,9 @@ module RSpec::Puppet
       end
 
       # This method is used by the `run` matcher to trigger the function execution, and provides a uniform interface across all puppet versions.
-      def execute(*args)
+      def execute(*args, &block)
         Puppet.override(@overrides, "rspec-test scope") do
-          @func.call(@overrides[:global_scope], *args)
+          @func.call(@overrides[:global_scope], *freeze_arg(args), &block)
         end
       end
 
@@ -25,6 +25,24 @@ module RSpec::Puppet
         RSpec.deprecate("subject.call", :replacement => "is_expected.to run.with().and_raise_error(), or execute()")
         execute(*args)
       end
+
+      private
+
+      # Facts, keywords, single-quoted strings etc. are usually frozen in Puppet manifests, so freeze arguments to ensure functions are tested
+      # under worst-case conditions.
+      def freeze_arg(arg)
+        case arg
+        when Array
+          arg.each { |a| freeze_arg(a) }
+          arg.freeze
+        when Hash
+          arg.each { |k,v| freeze_arg(k); freeze_arg(v) }
+          arg.freeze
+        when String
+          arg.freeze
+        end
+        arg
+      end
     end
 
     class V3FunctionWrapper
@@ -61,18 +79,16 @@ module RSpec::Puppet
       @subject ||= find_function
     end
 
-    def find_function
-      function_name = self.class.top_level_description.downcase
-
+    def find_function(function_name = self.class.top_level_description)
       with_vardir do
         env = adapter.current_environment
 
         if Puppet.version.to_f >= 4.0
           context_overrides = compiler.context_overrides
           func = nil
+          loaders = Puppet.lookup(:loaders)
           Puppet.override(context_overrides, "rspec-test scope") do
-            loader = Puppet::Pops::Loaders.new(env)
-            func = V4FunctionWrapper.new(function_name, loader.private_environment_loader.load(:function, function_name), context_overrides)
+            func = V4FunctionWrapper.new(function_name, loaders.private_environment_loader.load(:function, function_name), context_overrides)
             @scope = context_overrides[:global_scope]
           end
 
@@ -86,7 +102,11 @@ module RSpec::Puppet
         end
       end
     end
-
+    def call_function(function_name, *args)
+#      function = find_function(function_name)
+#      function.execute(*args)
+     scope.call_function(function_name, args)
+    end
     def scope
       @scope ||= build_scope(compiler, nodename(:function))
     end
@@ -112,22 +132,47 @@ module RSpec::Puppet
     def build_compiler
       node_name   = nodename(:function)
       fact_values = facts_hash(node_name)
+      trusted_values = trusted_facts_hash(node_name)
+
+      # Allow different Hiera configurations:
+      HieraPuppet.instance_variable_set('@hiera', nil) if defined? HieraPuppet
 
       # if we specify a pre_condition, we should ensure that we compile that
       # code into a catalog that is accessible from the scope where the
       # function is called
       Puppet[:code] = pre_cond
 
+      node_facts = Puppet::Node::Facts.new(node_name, fact_values.dup)
+
       node_options = {
         :parameters => fact_values,
+        :facts => node_facts
       }
 
       stub_facts! fact_values
 
       node = build_node(node_name, node_options)
 
+      if Puppet::Util::Package.versioncmp(Puppet.version, '4.3.0') >= 0
+        Puppet.push_context(
+          {
+            :trusted_information => Puppet::Context::TrustedInformation.new('remote', node_name, trusted_values)
+          },
+          "Context for spec trusted hash"
+        )
+      end
+
       compiler = Puppet::Parser::Compiler.new(node)
       compiler.compile
+      if Puppet::Util::Package.versioncmp(Puppet.version, '4.0.0') >= 0
+        loaders = Puppet::Pops::Loaders.new(adapter.current_environment)
+        Puppet.push_context(
+          {
+            :loaders => loaders,
+            :global_scope => compiler.context_overrides[:global_scope]
+          },
+        "set globals")
+      end
       compiler
     end
 

data/lib/rspec-puppet/example/type_alias_example_group.rb

@@ -0,0 +1,14 @@
+module RSpec::Puppet
+  module TypeAliasExampleGroup
+    include RSpec::Puppet::TypeAliasMatchers
+    include RSpec::Puppet::Support
+
+    def catalogue(test_value)
+      load_catalogue(:type_alias, false, :test_value => test_value)
+    end
+
+    def subject
+      lambda { |test_value| catalogue(test_value) }
+    end
+  end
+end

data/lib/rspec-puppet/example.rb

@@ -4,46 +4,29 @@ require 'rspec-puppet/example/class_example_group'
 require 'rspec-puppet/example/function_example_group'
 require 'rspec-puppet/example/host_example_group'
 require 'rspec-puppet/example/type_example_group'
+require 'rspec-puppet/example/type_alias_example_group'
 require 'rspec-puppet/example/provider_example_group'
 require 'rspec-puppet/example/application_example_group'
 
 RSpec::configure do |c|
 
-  def c.escaped_path(*parts)
-    Regexp.compile(parts.join('[\\\/]'))
+  def c.rspec_puppet_include(group, type, file_path)
+    escaped_file_path = Regexp.compile(file_path.join('[\\\/]'))
+    if RSpec::Version::STRING < '3'
+      self.include group, :type => type, :example_group => { :file_path => escaped_file_path }, :spec_type => type
+    else
+      self.include group, :type => type, :file_path => lambda { |file_path, metadata| metadata[:type].nil? && escaped_file_path =~ file_path }
+    end
   end
 
-  if RSpec::Version::STRING < '3'
-    c.include RSpec::Puppet::DefineExampleGroup, :type => :define, :example_group => {
-      :file_path => c.escaped_path(%w[spec defines])
-    }
-    c.include RSpec::Puppet::ClassExampleGroup, :type => :class, :example_group => {
-      :file_path => c.escaped_path(%w[spec classes])
-    }
-    c.include RSpec::Puppet::FunctionExampleGroup, :type => :puppet_function, :example_group => {
-      :file_path => c.escaped_path(%w[spec functions])
-    }
-    c.include RSpec::Puppet::HostExampleGroup, :type => :host, :example_group => {
-      :file_path => c.escaped_path(%w[spec hosts])
-    }
-    c.include RSpec::Puppet::TypeExampleGroup, :type => :type, :example_group => {
-      :file_path => c.escaped_path(%w[spec types])
-    }
-    c.include RSpec::Puppet::ProviderExampleGroup, :type => :provider, :example_group => {
-      :file_path => c.escaped_path(%w[spec providers])
-    }
-    c.include RSpec::Puppet::ApplicationExampleGroup, :type => :application, :example_group => {
-      :file_path => c.escaped_path(%w[spec applications])
-    }
-  else
-    c.include RSpec::Puppet::DefineExampleGroup, :type => :define, :file_path => c.escaped_path(%w[spec defines])
-    c.include RSpec::Puppet::ClassExampleGroup, :type => :class, :file_path => c.escaped_path(%w[spec classes])
-    c.include RSpec::Puppet::FunctionExampleGroup, :type => :puppet_function, :file_path => c.escaped_path(%w[spec functions])
-    c.include RSpec::Puppet::HostExampleGroup, :type => :host, :file_path => c.escaped_path(%w[spec hosts])
-    c.include RSpec::Puppet::TypeExampleGroup, :type => :type, :file_path => c.escaped_path(%w[spec types])
-    c.include RSpec::Puppet::ProviderExampleGroup, :type => :provider, :file_path => c.escaped_path(%w[spec providers])
-    c.include RSpec::Puppet::ApplicationExampleGroup, :type => :application, :file_path => c.escaped_path(%w[spec applications])
-  end
+  c.rspec_puppet_include RSpec::Puppet::DefineExampleGroup, :define, %w[spec defines]
+  c.rspec_puppet_include RSpec::Puppet::ClassExampleGroup, :class, %w[spec classes]
+  c.rspec_puppet_include RSpec::Puppet::FunctionExampleGroup, :puppet_function, %w[spec functions]
+  c.rspec_puppet_include RSpec::Puppet::HostExampleGroup, :host, %w[spec hosts]
+  c.rspec_puppet_include RSpec::Puppet::TypeExampleGroup, :type, %w[spec types]
+  c.rspec_puppet_include RSpec::Puppet::TypeAliasExampleGroup, :type_alias, %w[spec type_aliases]
+  c.rspec_puppet_include RSpec::Puppet::ProviderExampleGroup, :provider, %w[spec providers]
+  c.rspec_puppet_include RSpec::Puppet::ApplicationExampleGroup, :application, %w[spec applications]
 
   # Hook for each example group type to remove any caches or instance variables, since they will remain
   # and cause a memory leak.  Can't be assigned per type by :file_path, so check for its presence.

data/lib/rspec-puppet/matchers/allow_value.rb

@@ -0,0 +1,45 @@
+module RSpec::Puppet
+  module TypeAliasMatchers
+    class AllowValue
+      def initialize(values)
+        @values = values
+        @error_msgs = []
+      end
+
+      def matches?(catalogue)
+        matches = @values.map do |test_value|
+          begin
+            catalogue.call(test_value)
+            true
+          rescue Puppet::Error => e
+            @error_msgs << e.message
+            false
+          end
+        end
+        matches.all?
+      end
+
+      def description
+        if @values.length == 1
+          "match value #{@values.first.inspect}"
+        else
+          "match values #{@values.map(&:inspect).join(', ')}"
+        end
+      end
+
+      def failure_message
+        "expected that the type alias would " + description + " but it raised the #{@error_msgs.length == 1 ? 'error' : 'errors'} #{@error_msgs.join(', ')}"
+      end
+
+      def failure_message_when_negated
+        "expected that the type alias would not " + description + " but it does"
+      end
+    end
+
+    def allow_value(*values)
+      RSpec::Puppet::TypeAliasMatchers::AllowValue.new(values)
+    end
+
+    alias_method :allow_values, :allow_value
+  end
+end

data/lib/rspec-puppet/matchers/compile.rb

@@ -108,6 +108,10 @@ module RSpec::Puppet
               if vertex[:alias]
                 res_hash["#{vertex.type.to_s}[#{vertex[:alias]}]"] = 1
               end
+
+              if vertex.uniqueness_key != [vertex.title]
+                res_hash["#{vertex.type.to_s}[#{vertex.uniqueness_key.first}]"] = 1
+              end
             end
           end
           res_hash
@@ -134,6 +138,7 @@ module RSpec::Puppet
       end
 
       def cycles_found?
+        Puppet::Type.suppress_provider
         cat = @catalogue.to_ral.relationship_graph
         cat.write_graph(:resources)
         if cat.respond_to? :find_cycles_in_graph
@@ -141,6 +146,8 @@ module RSpec::Puppet
         else
           find_cycles_legacy(cat)
         end
+        Puppet::Type.unsuppress_provider
+
         !@cycles.empty?
       end
 

data/lib/rspec-puppet/matchers/create_generic.rb

@@ -1,4 +1,6 @@
+require 'set'
 require 'rspec-puppet/matchers/parameter_matcher'
+
 module RSpec::Puppet
   module ManifestMatchers
     class CreateGeneric
@@ -79,7 +81,7 @@ module RSpec::Puppet
 
       def matches?(catalogue)
         ret = true
-        @catalogue = catalogue.call
+        @catalogue = catalogue.is_a?(Puppet::Resource::Catalog) ? catalogue : catalogue.call
         resource = @catalogue.resource(@referenced_type, @title)
 
         if resource.nil?
@@ -87,6 +89,17 @@ module RSpec::Puppet
         else
           RSpec::Puppet::Coverage.cover!(resource)
           rsrc_hsh = resource.to_hash
+
+          if resource.builtin_type?
+            namevar = resource.resource_type.key_attributes.first.to_s
+          else
+            namevar = 'name'
+          end
+
+          unless @expected_params.any? { |param| param.first.to_s == namevar }
+            rsrc_hsh.delete(namevar.to_sym) if rsrc_hsh.has_key?(namevar.to_sym)
+          end
+
           if @expected_params_count
             unless rsrc_hsh.size == @expected_params_count
               ret = false
@@ -201,7 +214,7 @@ module RSpec::Puppet
 
       def check_befores(catalogue, resource)
         @befores.each do |ref|
-          unless precedes?(resource, catalogue.resource(ref))
+          unless precedes?(resource, canonicalize_resource(ref))
             @errors << BeforeRelationshipError.new(resource.to_ref, ref)
           end
         end
@@ -209,7 +222,7 @@ module RSpec::Puppet
 
       def check_requires(catalogue, resource)
         @requires.each do |ref|
-          unless precedes?(catalogue.resource(ref), resource)
+          unless precedes?(canonicalize_resource(ref), resource)
             @errors << RequireRelationshipError.new(resource.to_ref, ref)
           end
         end
@@ -217,7 +230,7 @@ module RSpec::Puppet
 
       def check_notifies(catalogue, resource)
         @notifies.each do |ref|
-          unless notifies?(resource, catalogue.resource(ref))
+          unless notifies?(resource, canonicalize_resource(ref))
             @errors << NotifyRelationshipError.new(resource.to_ref, ref)
           end
         end
@@ -225,7 +238,7 @@ module RSpec::Puppet
 
       def check_subscribes(catalogue, resource)
         @subscribes.each do |ref|
-          unless notifies?(catalogue.resource(ref), resource)
+          unless notifies?(canonicalize_resource(ref), resource)
             @errors << SubscribeRelationshipError.new(resource.to_ref, ref)
           end
         end
@@ -240,34 +253,62 @@ module RSpec::Puppet
       end
 
       def canonicalize_resource(resource)
-        resource_from_ref(resource_ref(resource))
+        res = resource_from_ref(resource_ref(resource))
+        if res.nil?
+          resource = Struct.new(:type, :title).new(*@catalogue.title_key_for_ref(resource)) if resource.is_a?(String)
+          res = @catalogue.resource_keys.select { |type, name|
+            type == resource.type
+          }.map { |type, name|
+            @catalogue.resource(type, name)
+          }.compact.find { |cat_res|
+            cat_res.builtin_type? && cat_res.uniqueness_key.first == resource.title
+          }
+        end
+        res
       end
 
       def canonicalize_resource_ref(ref)
         resource_ref(resource_from_ref(ref))
       end
 
-      def relationship_refs(resource, type)
+      def relationship_refs(resource, type, visited = Set.new)
         resource = canonicalize_resource(resource)
-        results = []
+        results = Set.new
         return results unless resource
+
+        # guard to prevent infinite recursion
+        if visited.include?(resource.object_id)
+          return [canonicalize_resource_ref(resource)]
+        else
+          visited << resource.object_id
+        end
+
         Array[resource[type]].flatten.compact.each do |r|
           results << canonicalize_resource_ref(r)
-          results << relationship_refs(r, type)
+          results << relationship_refs(r, type, visited)
+
+          res = canonicalize_resource(r)
+          if res && res.builtin_type?
+            results << res.to_ref
+            results << "#{res.type.to_s.capitalize}[#{res.uniqueness_key.first}]"
+          end
         end
 
+        Puppet::Type.suppress_provider
         # Add autorequires if any
         if type == :require and resource.resource_type.respond_to? :eachautorequire
           resource.resource_type.eachautorequire do |t, b|
             Array(resource.to_ral.instance_eval(&b)).each do |dep|
               res = "#{t.to_s.capitalize}[#{dep}]"
-              if r = relationship_refs(res, type)
+              if r = relationship_refs(res, type, visited)
                 results << res
                 results << r
               end
             end
           end
         end
+        Puppet::Type.unsuppress_provider
+
         results.flatten
       end
 
@@ -280,8 +321,8 @@ module RSpec::Puppet
 
         self_or_upstream(first).each do |u|
           self_or_upstream(second).each do |v|
-            before_refs = relationship_refs(u, :before)
-            require_refs = relationship_refs(v, :require)
+            before_refs = relationship_refs(u, :before) + relationship_refs(u, :notify)
+            require_refs = relationship_refs(v, :require) + relationship_refs(u, :subscribe)
 
             if before_refs.include?(v.to_ref) || require_refs.include?(u.to_ref) || (before_refs & require_refs).any?
               return true
@@ -320,7 +361,7 @@ module RSpec::Puppet
 
           if value.nil? then
             unless resource[param].nil?
-              @errors << "#{param} undefined"
+              @errors << "#{param} undefined but it is set to #{resource[param].inspect}"
             end
           else
             m = ParameterMatcher.new(param, value, type)

data/lib/rspec-puppet/matchers/parameter_matcher.rb

@@ -30,7 +30,7 @@ module RSpec::Puppet
         # Puppet flattens an array with a single value into just the value and
         # this can cause confusion when testing as people expect when you put
         # an array in, you'll get an array out.
-        actual = [*actual] if expected.is_a?(Array)
+        actual = [actual] if expected.is_a?(Array) && !actual.is_a?(Array)
 
         retval = check(expected, actual)
 
@@ -55,7 +55,7 @@ module RSpec::Puppet
       #
       # @return [true, false] If the resource matched
       def check(expected, actual)
-        return false if actual.nil? && !expected.nil?
+        return false if !expected.is_a?(Proc) && actual.nil? && !expected.nil?
         case expected
         when Proc
           check_proc(expected, actual)

data/lib/rspec-puppet/matchers/run.rb

@@ -7,7 +7,7 @@ module RSpec::Puppet
         @has_returned = false
         begin
           # `*nil` does not evaluate to "no params" on ruby 1.8 :-(
-          @actual_return = @params.nil? ? @func_obj.execute : @func_obj.execute(*@params)
+          @actual_return = @params.nil? ? @func_obj.execute(&@block) : @func_obj.execute(*@params, &@block)
           @has_returned = true
         rescue Exception => e
           @actual_error = e
@@ -52,6 +52,11 @@ module RSpec::Puppet
         self
       end
 
+      def with_lambda(&block)
+        @block = block
+        self
+      end
+
       def and_return(value)
         @has_expected_return = true
         @expected_return = value

data/lib/rspec-puppet/matchers.rb

@@ -5,3 +5,4 @@ require 'rspec-puppet/matchers/run'
 require 'rspec-puppet/matchers/count_generic'
 require 'rspec-puppet/matchers/dynamic_matchers'
 require 'rspec-puppet/matchers/type_matchers'
+require 'rspec-puppet/matchers/allow_value'

data/lib/rspec-puppet/monkey_patches.rb

@@ -0,0 +1,162 @@
+require 'pathname'
+
+module Puppet
+  # Allow rspec-puppet to prevent Puppet::Type from automatically picking
+  # a provider for a resource. We need to do this because in order to fully
+  # resolve the graph edges, we have to convert the Puppet::Resource objects
+  # into Puppet::Type objects so that their autorequires are evaluated. We need
+  # to prevent provider code from being called during this process as it's very
+  # platform specific.
+  class Type
+    old_set_default = instance_method(:set_default)
+
+    define_method(:set_default) do |attr|
+      old_posix = nil
+      old_microsoft_windows = nil
+
+      if attr == :provider
+        old_posix = Puppet.features.posix?
+        old_microsoft_windows = Puppet.features.microsoft_windows?
+
+        if Puppet::Util::Platform.pretend_windows?
+          Puppet.features.add(:posix) { false }
+          Puppet.features.add(:microsoft_windows) { true }
+        else
+          Puppet.features.add(:posix) { true }
+          Puppet.features.add(:microsoft_windows) { false }
+        end
+      end
+
+      retval = old_set_default.bind(self).call(attr)
+
+      unless old_posix.nil?
+        Puppet.features.add(:posix) { old_posix }
+      end
+      unless old_microsoft_windows.nil?
+        Puppet.features.add(:microsoft_windows) { old_microsoft_windows }
+      end
+
+      retval
+    end
+
+    def self.suppress_provider?
+      @suppress_provider ||= false
+    end
+
+    def self.suppress_provider
+      @suppress_provider = true
+    end
+
+    def self.unsuppress_provider
+      @suppress_provider = false
+    end
+  end
+
+  # If Puppet::Node::Environment has a validate_dirs instance method (i.e.
+  # Puppet < 3.x), wrap the method to check if rspec-puppet is pretending to be
+  # running under windows. The original method uses Puppet::Util.absolute_path?
+  # (which in turn calls Puppet::Util::Platform.windows?) to validate the path
+  # to the manifests on disk during compilation, so we have to temporarily
+  # disable the pretending when running it.
+  class Node::Environment
+    if instance_methods.include?("validate_dirs")
+      old_validate_dirs = instance_method(:validate_dirs)
+
+      define_method(:validate_dirs) do |dirs|
+        pretending = Puppet::Util::Platform.pretend_platform
+
+        if pretending
+          Puppet::Util::Platform.pretend_to_be nil
+        end
+
+        output = old_validate_dirs.bind(self).call(dirs)
+
+        Puppet::Util::Platform.pretend_to_be pretending
+
+        output
+      end
+    end
+  end
+
+  module Util
+    # Allow rspec-puppet to pretend to be different platforms.
+    module Platform
+      def windows?
+        pretend_platform.nil? ? (actual_platform == :windows) : pretend_windows?
+      end
+      module_function :windows?
+
+      def actual_platform
+        @actual_platform ||= !!File::ALT_SEPARATOR ? :windows : :posix
+      end
+      module_function :actual_platform
+
+      def pretend_windows?
+        pretend_platform == :windows
+      end
+      module_function :pretend_windows?
+
+      def pretend_to_be(platform)
+        # Ensure that we cache the real platform before pretending to be
+        # a different one
+        actual_platform
+
+        @pretend_platform = platform
+      end
+      module_function :pretend_to_be
+
+      def pretend_platform
+        @pretend_platform ||= nil
+      end
+      module_function :pretend_platform
+    end
+  end
+end
+
+class Pathname
+  def rspec_puppet_basename(path)
+    raise ArgumentError, 'pathname stubbing not enabled' unless RSpec.configuration.enable_pathname_stubbing
+
+    if path =~ /\A[a-zA-Z]:(#{SEPARATOR_PAT}.*)\z/
+      path = path[2..-1]
+    end
+    path.split(SEPARATOR_PAT).last || path[/(#{SEPARATOR_PAT})/, 1] || path
+  end
+
+  if instance_methods.include?("chop_basename")
+    old_chop_basename = instance_method(:chop_basename)
+
+    define_method(:chop_basename) do |path|
+      if RSpec.configuration.enable_pathname_stubbing
+        base = rspec_puppet_basename(path)
+        if /\A#{SEPARATOR_PAT}?\z/o =~ base
+          return nil
+        else
+          return path[0, path.rindex(base)], base
+        end
+      else
+        old_chop_basename.bind(self).call(path)
+      end
+    end
+  end
+end
+
+# Prevent the File type from munging paths (which uses File.expand_path to
+# normalise paths, which does very bad things to *nix paths on Windows.
+Puppet::Type.type(:file).paramclass(:path).munge { |value| value }
+
+# Prevent the Exec type from validating the user. This parameter isn't
+# supported under Windows at all and only under *nix when the current user is
+# root.
+Puppet::Type.type(:exec).paramclass(:user).validate { |value| true }
+
+# Prevent Puppet from requiring 'puppet/util/windows' if we're pretending to be
+# windows, otherwise it will require other libraries that probably won't be
+# available on non-windows hosts.
+module Kernel
+  alias :old_require :require
+  def require(path)
+    return if path == 'puppet/util/windows' && Puppet::Util::Platform.pretend_windows?
+    old_require(path)
+  end
+end