rspec-puppet 2.11.0 → 4.0.0

data/lib/rspec-puppet/adapters.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'rspec-puppet/facter_impl'
 
 module RSpec::Puppet
   module Adapters
-
     class Base
       # Set up all Puppet settings applicable for this Puppet version as
       # application defaults.
@@ -11,12 +12,6 @@ module RSpec::Puppet
       # executing RSpec context. When a setting is specified both in the global configuration and in
       # the example group, the setting in the example group is preferred.
       #
-      # @example Configuring a Puppet setting from a global RSpec configuration value
-      #   RSpec.configure do |config|
-      #     config.parser = "future"
-      #   end
-      #   # => Puppet[:parser] will be future
-      #
       # @example Configuring a Puppet setting from within an RSpec example group
       #   RSpec.describe 'my_module::my_class', :type => :class do
       #     let(:module_path) { "/Users/luke/modules" }
@@ -41,98 +36,51 @@ module RSpec::Puppet
       # @param example_group [RSpec::Core::ExampleGroup] The RSpec context to use for local settings
       # @return [void]
       def setup_puppet(example_group)
+        case RSpec.configuration.facter_implementation.to_sym
+        when :rspec
+          # Lazily instantiate FacterTestImpl here to optimize memory
+          # allocation, as the proc will only be called if FacterImpl is unset
+          set_facter_impl(proc { RSpec::Puppet::FacterTestImpl.new })
+        when :facter
+          set_facter_impl(Facter)
+        else
+          raise "Unsupported facter_implementation '#{RSpec.configuration.facter_implementation}'"
+        end
+
+        Puppet.runtime[:facter] = FacterImpl
+
         settings = settings_map.map do |puppet_setting, rspec_setting|
           [puppet_setting, get_setting(example_group, rspec_setting)]
         end.flatten
-        default_hash = {:confdir => '/dev/null', :vardir => '/dev/null' }
+        default_hash = { confdir: '/dev/null', vardir: '/dev/null' }
         if defined?(Puppet::Test::TestHelper) && Puppet::Test::TestHelper.respond_to?(:app_defaults_for_tests, true)
           default_hash.merge!(Puppet::Test::TestHelper.send(:app_defaults_for_tests))
         end
         settings_hash = default_hash.merge(Hash[*settings])
-        settings_hash.inject(settings_hash) { |h, (k, v)| h[k] = (v == '/dev/null') ? 'c:/nul/' : v; h } if Gem.win_platform?
-
-        if Puppet.settings.respond_to?(:initialize_app_defaults)
-          Puppet.settings.initialize_app_defaults(settings_hash)
-
-          # Forcefully apply the environmentpath setting instead of relying on
-          # the application defaults as Puppet::Test::TestHelper automatically
-          # sets this value as well, overriding our application default
-          Puppet.settings[:environmentpath] = settings_hash[:environmentpath] if settings_hash.key?(:environmentpath)
-        else
-          # Set settings the old way for Puppet 2.x, because that's how
-          # they're defaulted in that version of Puppet::Test::TestHelper and
-          # we won't be able to override them otherwise.
-          settings_hash.each do |setting, value|
-            Puppet.settings[setting] = value
+        if Gem.win_platform?
+          settings_hash.each_with_object(settings_hash) do |(k, v), h|
+            h[k] = v == '/dev/null' ? 'c:/nul/' : v
           end
         end
 
-        @environment_name = example_group.environment
-      end
-
-      def get_setting(example_group, rspec_setting)
-        if example_group.respond_to?(rspec_setting)
-          example_group.send(rspec_setting)
-        else
-          RSpec.configuration.send(rspec_setting)
-        end
-      end
+        Puppet.settings.initialize_app_defaults(settings_hash)
 
-      def catalog(node, exported)
-        if exported
-          # Use the compiler directly to skip the filtering done by the indirector
-          Puppet::Parser::Compiler.compile(node).filter { |r| !r.exported? }
-        else
-          Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
-        end
-      end
-
-      def current_environment
-        Puppet::Node::Environment.new(@environment_name)
-      end
+        # Forcefully apply the environmentpath setting instead of relying on
+        # the application defaults as Puppet::Test::TestHelper automatically
+        # sets this value as well, overriding our application default
+        Puppet.settings[:environmentpath] = settings_hash[:environmentpath] if settings_hash.key?(:environmentpath)
 
-      def settings_map
-        [
-          [:modulepath, :module_path],
-          [:config, :config],
-          [:confdir, :confdir],
-        ]
-      end
-
-      def modulepath
-        Puppet[:modulepath].split(File::PATH_SEPARATOR)
-      end
-
-      # @return [String, nil] The path to the Puppet manifest if it is present and set, nil otherwise.
-      def manifest
-        Puppet[:manifest]
-      end
-    end
-
-    class Adapter40 < Base
-      #
-      # @api private
-      #
-      # Set the FacterImpl constant to the given Facter implementation.
-      # The method noops if the constant is already set
-      #
-      # @param impl [Object]
-      def set_facter_impl(impl)
-        Object.send(:const_set, :FacterImpl, impl) unless defined? FacterImpl
-      end
+        @environment_name = example_group.environment
 
-      def setup_puppet(example_group)
-        super
+        modulepath = if (rspec_modulepath = RSpec.configuration.module_path)
+                       rspec_modulepath.split(File::PATH_SEPARATOR)
+                     else
+                       Puppet[:environmentpath].split(File::PATH_SEPARATOR).map do |path|
+                         File.join(path, 'fixtures', 'modules')
+                       end
+                     end
 
-        if rspec_modulepath = RSpec.configuration.module_path
-          modulepath = rspec_modulepath.split(File::PATH_SEPARATOR)
-        else
-          modulepath = Puppet[:environmentpath].split(File::PATH_SEPARATOR).map do |path|
-            File.join(path, 'fixtures', 'modules')
-          end
-        end
-
-        if rspec_manifest = RSpec.configuration.manifest
+        if (rspec_manifest = RSpec.configuration.manifest)
           manifest = rspec_manifest
         else
           manifest_paths = Puppet[:environmentpath].split(File::PATH_SEPARATOR).map do |path|
@@ -151,29 +99,57 @@ module RSpec::Puppet
 
         Puppet.push_context(
           {
-            :environments => loader,
-            :current_environment => env,
-            :loaders => (Puppet::Pops::Loaders.new(env) if Gem::Version.new(Puppet.version) >= Gem::Version.new('6.0.0')),
+            environments: loader,
+            current_environment: env,
+            loaders: Puppet::Pops::Loaders.new(env)
           },
-          "Setup rspec-puppet environments"
+          'Setup rspec-puppet environments'
         )
       end
 
-      def settings_map
-        super.concat([
-          [:environmentpath, :environmentpath],
-          [:hiera_config, :hiera_config],
-          [:strict_variables, :strict_variables],
-          [:manifest, :manifest],
-        ])
+      def get_setting(example_group, rspec_setting)
+        if example_group.respond_to?(rspec_setting)
+          example_group.send(rspec_setting)
+        else
+          RSpec.configuration.send(rspec_setting)
+        end
       end
 
       def catalog(node, exported)
         node.environment = current_environment
         # Override $::environment to workaround PUP-5835, where Puppet otherwise
         # stores a symbol for the parameter
-        node.parameters['environment'] = current_environment.name.to_s if node.parameters['environment'] != node.parameters['environment'].to_s
-        super
+        if node.parameters['environment'] != node.parameters['environment'].to_s
+          node.parameters['environment'] = current_environment.name.to_s
+        end
+
+        catalog = if exported
+                    # Use the compiler directly to skip the filtering done by the indirector
+                    Puppet::Parser::Compiler.compile(node).filter { |r| !r.exported? }
+                  else
+                    Puppet::Resource::Catalog.indirection.find(node.name, use_node: node)
+                  end
+
+        Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(node.facts, catalog)
+
+        catalog
+      end
+
+      def current_environment
+        Puppet::Node::Environment.new(@environment_name)
+      end
+
+      def settings_map
+        [
+          %i[modulepath module_path],
+          %i[basemodulepath basemodulepath],
+          %i[config config],
+          %i[confdir confdir],
+          %i[environmentpath environmentpath],
+          %i[hiera_config hiera_config],
+          %i[strict_variables strict_variables],
+          %i[vendormoduledir vendormoduledir]
+        ]
       end
 
       def current_environment
@@ -184,9 +160,6 @@ module RSpec::Puppet
         current_environment.modulepath
       end
 
-      # Puppet 4.0 specially handles environments that don't have a manifest set, so we check for the no manifest value
-      # and return nil when it is set.
-      #
       # @return [String, nil] The path to the Puppet manifest if it is present and set, nil otherwise.
       def manifest
         m = current_environment.manifest
@@ -196,146 +169,27 @@ module RSpec::Puppet
           m
         end
       end
-    end
-
-    class Adapter4X < Adapter40
-      def setup_puppet(example_group)
-        super
-
-        set_facter_impl(Facter)
-      end
 
-      def settings_map
-        super.concat([
-          [:trusted_server_facts, :trusted_server_facts]
-        ])
-      end
-    end
-
-    class Adapter6X < Adapter40
-      #
       # @api private
       #
-      # Check to see if Facter runtime implementations are supported in the
-      # current Puppet version
+      # Set the FacterImpl constant to the given Facter implementation or noop
+      # if the constant is already set. If a proc is given, it will only be
+      # called if FacterImpl is not defined.
       #
-      # @return [Boolean] true if runtime implementations are supported
-      def supports_facter_runtime?
-        unless defined?(@supports_facter_runtime)
-          begin
-            Puppet.runtime[:facter]
-            @supports_facter_runtime = true
-          rescue
-            @supports_facter_runtime = false
-          end
-        end
-
-        @supports_facter_runtime
-      end
-
-      def setup_puppet(example_group)
-        case RSpec.configuration.facter_implementation.to_sym
-        when :rspec
-          if supports_facter_runtime?
-            Puppet.runtime[:facter] = proc { RSpec::Puppet::FacterTestImpl.new }
-            set_facter_impl(Puppet.runtime[:facter])
-          else
-            warn "Facter runtime implementations are not supported in Puppet #{Puppet.version}, continuing with facter_implementation 'facter'"
-            RSpec.configuration.facter_implementation = 'facter'
-            set_facter_impl(Facter)
-          end
-        when :facter
-          set_facter_impl(Facter)
-        else
-          raise "Unsupported facter_implementation '#{RSpec.configuration.facter_implementation}'"
-        end
-
-        super
-      end
-
-      def settings_map
-        super.concat([
-          [:basemodulepath, :basemodulepath],
-          [:vendormoduledir, :vendormoduledir],
-        ])
-      end
-
-      def catalog(node, _exported)
-        super.tap do |c|
-          Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(node.facts, c)
-        end
-      end
-    end
-
-    class Adapter30 < Base
-      def settings_map
-        super.concat([
-          [:manifestdir, :manifest_dir],
-          [:manifest, :manifest],
-          [:templatedir, :template_dir],
-          [:hiera_config, :hiera_config],
-        ])
-      end
-    end
-
-    class Adapter32 < Adapter30
-      def settings_map
-        super.concat([
-          [:parser, :parser],
-        ])
-      end
-    end
-
-    class Adapter33 < Adapter32
-      def settings_map
-        super.concat([
-          [:ordering, :ordering],
-          [:stringify_facts, :stringify_facts],
-        ])
-      end
-    end
-
-    class Adapter34 < Adapter33
-      def settings_map
-        super.concat([
-          [:trusted_node_data, :trusted_node_data],
-        ])
-      end
-    end
-
-    class Adapter35 < Adapter34
-      def settings_map
-        super.concat([
-          [:strict_variables, :strict_variables],
-        ])
-      end
-    end
+      # @param impl [Object, Proc] An object or a proc that implements the Facter API
+      def set_facter_impl(impl)
+        return if defined?(FacterImpl)
 
-    class Adapter27 < Base
-      def settings_map
-        super.concat([
-          [:manifestdir, :manifest_dir],
-          [:manifest, :manifest],
-          [:templatedir, :template_dir],
-        ])
+        impl = impl.call if impl.is_a?(Proc)
+        Object.send(:const_set, :FacterImpl, impl)
       end
     end
 
     def self.get
       [
-        ['6.0', Adapter6X],
-        ['4.1', Adapter4X],
-        ['4.0', Adapter40],
-        ['3.5', Adapter35],
-        ['3.4', Adapter34],
-        ['3.3', Adapter33],
-        ['3.2', Adapter32],
-        ['3.0', Adapter30],
-        ['2.7', Adapter27]
+        ['7.11', Base]
       ].each do |(version, klass)|
-        if Puppet::Util::Package.versioncmp(Puppet.version, version) >= 0
-          return klass.new
-        end
+        return klass.new if Puppet::Util::Package.versioncmp(Puppet.version, version) >= 0
       end
       raise "Puppet version #{Puppet.version} is not supported."
     end

data/lib/rspec-puppet/cache.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   class Cache
-
     MAX_ENTRIES = 16
 
     # @param [Proc] default_proc The default proc to use to fetch objects on cache miss
@@ -12,7 +13,7 @@ module RSpec::Puppet
 
     def get(*args, &blk)
       key = Marshal.load(Marshal.dump(args))
-      if @cache.has_key?(key)
+      if @cache.key?(key)
         # Cache hit
         # move that entry last to make it "most recenty used"
         @lra.insert(-1, @lra.delete_at(@lra.index(args)))

data/lib/rspec-puppet/consts.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet::Consts
   STUBBED_CONSTS = {
-    :posix => {
+    posix: {
       'File::PATH_SEPARATOR' => ':',
       'File::ALT_SEPARATOR' => nil,
-      'Pathname::SEPARATOR_PAT' => /#{Regexp.quote('/')}/,
+      'Pathname::SEPARATOR_PAT' => /#{Regexp.quote('/')}/
     },
-    :windows => {
+    windows: {
       'File::PATH_SEPARATOR' => ';',
-      'File::ALT_SEPARATOR' => "\\",
-      'Pathname::SEPARATOR_PAT' => /[#{Regexp.quote("\\")}#{Regexp.quote('/')}]/,
+      'File::ALT_SEPARATOR' => '\\',
+      'Pathname::SEPARATOR_PAT' => /[#{Regexp.quote('\\')}#{Regexp.quote('/')}]/
     }
-  }
+  }.freeze
 
   FEATURES = {
-    :posix   => {
-      :posix             => true,
-      :microsoft_windows => false,
-    },
-    :windows => {
-      :posix             => false,
-      :microsoft_windows => true,
+    posix: {
+      posix: true,
+      microsoft_windows: false
     },
-  }
+    windows: {
+      posix: false,
+      microsoft_windows: true
+    }
+  }.freeze
 
   def self.stub_consts_for(platform)
     STUBBED_CONSTS[platform].each do |const_name, const_value|

data/lib/rspec-puppet/coverage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tmpdir'
 require 'digest'
 require 'json'
@@ -16,23 +18,22 @@ end
 
 module RSpec::Puppet
   class Coverage
-
     attr_accessor :filters, :filters_regex
 
     class << self
       extend Forwardable
 
-      delegated_methods = [
-        :instance,
-        :add,
-        :cover!,
-        :report!,
-        :filters,
-        :filters_regex,
-        :add_filter,
-        :add_filter_regex,
-        :add_from_catalog,
-        :results,
+      delegated_methods = %i[
+        instance
+        add
+        cover!
+        report!
+        filters
+        filters_regex
+        add_filter
+        add_filter_regex
+        add_from_catalog
+        results
       ]
 
       def_delegators(*delegated_methods)
@@ -112,23 +113,21 @@ module RSpec::Puppet
     end
 
     def add(resource)
-      if !exists?(resource) && !filtered?(resource)
-        @collection[resource.to_s] = ResourceWrapper.new(resource)
-      end
+      return unless !exists?(resource) && !filtered?(resource)
+
+      @collection[resource.to_s] = ResourceWrapper.new(resource)
     end
 
     def add_filter(type, title)
       type = capitalize_name(type)
 
-      if type == 'Class'
-        title = capitalize_name(title)
-      end
+      title = capitalize_name(title) if type == 'Class'
 
       @filters << "#{type}[#{title}]"
     end
 
     def add_filter_regex(type, pattern)
-      raise ArgumentError.new('pattern argument must be a Regexp') unless pattern.is_a?(Regexp)
+      raise ArgumentError, 'pattern argument must be a Regexp' unless pattern.is_a?(Regexp)
 
       type = capitalize_name(type)
 
@@ -145,7 +144,7 @@ module RSpec::Puppet
 
       # match an even number of backslashes before the anchor - this indicates that the anchor was not escaped
       # note the necessity for the negative lookbehind `(?<!)` to assert that there is no backslash before this
-      src = if src.match(/(?<!\\)(\\\\)*(?:\\[zZ]|\$)\z/)
+      src = if /(?<!\\)(\\\\)*(?:\\[zZ]|\$)\z/.match?(src)
               src.gsub(/(?:\\[zZ]|\$)\z/, '')
             else
               # no anchor at the end
@@ -157,7 +156,9 @@ module RSpec::Puppet
 
     # add all resources from catalog declared in module test_module
     def add_from_catalog(catalog, test_module)
-      coverable_resources = catalog.to_a.reject { |resource| !test_module.nil? && filter_resource?(resource, test_module) }
+      coverable_resources = catalog.to_a.reject do |resource|
+        !test_module.nil? && filter_resource?(resource, test_module)
+      end
       coverable_resources.each do |resource|
         add(resource)
       end
@@ -171,9 +172,9 @@ module RSpec::Puppet
     end
 
     def cover!(resource)
-      if !filtered?(resource) && (wrapper = find(resource))
-        wrapper.touch!
-      end
+      return unless !filtered?(resource) && (wrapper = find(resource))
+
+      wrapper.touch!
     end
 
     def report!(coverage_desired = nil)
@@ -213,9 +214,9 @@ module RSpec::Puppet
       coverage_desired ||= 0
 
       if coverage_desired.is_a?(Numeric) && coverage_desired.to_f <= 100.00 && coverage_desired.to_f >= 0.0
-        coverage_test = RSpec.describe("Code coverage")
+        coverage_test = RSpec.describe('Code coverage')
         coverage_results = coverage_test.example("must cover at least #{coverage_desired}% of resources") do
-          expect( coverage_actual.to_f ).to be >= coverage_desired.to_f
+          expect(coverage_actual.to_f).to be >= coverage_desired.to_f
         end
         coverage_test.run(RSpec.configuration.reporter)
 
@@ -248,8 +249,8 @@ module RSpec::Puppet
       report[:touched] = @collection.count { |_, resource| resource.touched? }
       report[:untouched] = report[:total] - report[:touched]
 
-      coverage = report[:total].to_f > 0 ? ((report[:touched].to_f / report[:total].to_f) * 100) : 100.0
-      report[:coverage] = "%5.2f" % coverage
+      coverage = report[:total].to_f.positive? ? ((report[:touched].to_f / report[:total]) * 100) : 100.0
+      report[:coverage] = '%5.2f' % coverage
 
       report[:resources] = Hash[*@collection.map do |name, wrapper|
         [name, wrapper.to_hash]
@@ -258,10 +259,10 @@ module RSpec::Puppet
       text = [
         "Total resources:   #{report[:total]}",
         "Touched resources: #{report[:touched]}",
-        "Resource coverage: #{report[:coverage]}%",
+        "Resource coverage: #{report[:coverage]}%"
       ]
 
-      if report[:untouched] > 0
+      if (report[:untouched]).positive?
         text += ['', 'Untouched resources:']
         untouched_resources = report[:resources].reject { |_, r| r[:touched] }
         text += untouched_resources.map { |name, _| "  #{name}" }.sort
@@ -288,25 +289,19 @@ module RSpec::Puppet
     # @param test_module [String] The name of the module under test
     # @return [true, false]
     def filter_resource?(resource, test_module)
-      if filtered?(resource)
-        return true
-      end
+      return true if filtered?(resource)
 
       if resource.type == 'Class'
         module_name = resource.title.split('::').first.downcase
-        if module_name != test_module
-          return true
-        end
+        return true if module_name != test_module
       end
 
       if resource.file
         paths = module_paths(test_module)
-        unless paths.any? { |path| resource.file.include?(path) }
-          return true
-        end
+        return true unless paths.any? { |path| resource.file.include?(path) }
       end
 
-      return false
+      false
     end
 
     # Find all paths that may contain testable resources for a module.
@@ -330,7 +325,7 @@ module RSpec::Puppet
     end
 
     def capitalize_name(name)
-      name.split('::').map { |subtitle| subtitle.capitalize }.join('::')
+      name.split('::').map(&:capitalize).join('::')
     end
 
     class ResourceWrapper
@@ -346,7 +341,7 @@ module RSpec::Puppet
 
       def to_hash
         {
-          :touched => touched?,
+          touched: touched?
         }
       end
 

data/lib/rspec-puppet/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module Errors
     class MatchError < StandardError
@@ -11,18 +13,16 @@ module RSpec::Puppet
       end
 
       def message
-        if @param.to_s == 'content' and expected.is_a?( String )
+        if (@param.to_s == 'content') && expected.is_a?(String)
           if negative == true
             "#{param} not set to supplied string"
           else
             "#{param} set to supplied string"
           end
+        elsif negative == true
+          "#{param} not set to #{expected.inspect} but it is set to #{actual.inspect}"
         else
-          if negative == true
-            "#{param} not set to #{expected.inspect} but it is set to #{actual.inspect}"
-          else
-            "#{param} set to #{expected.inspect} but it is set to #{actual.inspect}"
-          end
+          "#{param} set to #{expected.inspect} but it is set to #{actual.inspect}"
         end
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module ClassExampleGroup
     include RSpec::Puppet::ManifestMatchers
@@ -8,7 +10,7 @@ module RSpec::Puppet
     end
 
     def exported_resources
-      lambda { load_catalogue(:class, true) }
+      -> { load_catalogue(:class, true) }
     end
 
     def rspec_puppet_cleanup