rspec-puppet-facts 2.0.5 → 3.0.0

data/lib/rspec-puppet-facts/version.rb

@@ -2,6 +2,6 @@ module RspecPuppetFacts
   # This module contains the current version constant
   module Version
     # The current version of this gem
-    STRING = '2.0.5'
+    STRING = '3.0.0'
   end
 end

data/lib/rspec-puppet-facts.rb

@@ -2,6 +2,7 @@ require 'puppet'
 require 'facter'
 require 'facterdb'
 require 'json'
+require 'deep_merge'
 
 # The purpose of this module is to simplify the Puppet
 # module's RSpec tests by looping through all supported
@@ -56,7 +57,7 @@ module RspecPuppetFacts
   #
   # @api private
   def on_supported_os_implementation(opts = {})
-    unless (facterversion = opts[:facterversion]) =~ /\A\d+\.\d+(?:\.\d+)*\z/
+    unless /\A\d+\.\d+(?:\.\d+)*\z/.match?((facterversion = opts[:facterversion]))
       raise ArgumentError, ":facterversion must be in the format 'n.n' or " \
         "'n.n.n' (n is numeric), not '#{facterversion}'"
     end
@@ -68,19 +69,20 @@ module RspecPuppetFacts
           opts[:hardwaremodels].each do |hardwaremodel|
 
             os_release_filter = "/^#{Regexp.escape(operatingsystemmajrelease.split(' ')[0])}/"
-            if os_sup['operatingsystem'] =~ /BSD/i
+            case os_sup['operatingsystem']
+            when /BSD/i
               hardwaremodel = 'amd64'
-            elsif os_sup['operatingsystem'] =~ /Solaris/i
+            when /Solaris/i
               hardwaremodel = 'i86pc'
-            elsif os_sup['operatingsystem'] =~ /AIX/i
+            when /AIX/i
               hardwaremodel = '/^IBM,.*/'
               os_release_filter = if operatingsystemmajrelease =~ /\A(\d+)\.(\d+)\Z/
                                     "/^#{$~[1]}#{$~[2]}00-/"
                                   else
                                     "/^#{operatingsystemmajrelease}-/"
                                   end
-            elsif os_sup['operatingsystem'] =~ /Windows/i
-              hardwaremodel = facterversion =~ /^[12]\./ ? 'x64' : 'x86_64'
+            when /Windows/i
+              hardwaremodel = /^[12]\./.match?(facterversion) ? 'x64' : 'x86_64'
               os_sup['operatingsystem'] = os_sup['operatingsystem'].downcase
               operatingsystemmajrelease = operatingsystemmajrelease[/\A(?:Server )?(.+)/i, 1]
 
@@ -90,7 +92,7 @@ module RspecPuppetFacts
               if operatingsystemmajrelease == '2016' && Puppet::Util::Package.versioncmp(facterversion, '3.4') < 0
                 os_release_filter = '/^10\\.0\\./'
               end
-            elsif os_sup['operatingsystem'] =~ /Amazon/i
+            when /Amazon/i
               # Tighten the regex for Amazon Linux 2 so that we don't pick up Amazon Linux 2016 or 2017 facts
               os_release_filter = "/^2$/" if operatingsystemmajrelease == '2'
             end
@@ -112,35 +114,33 @@ module RspecPuppetFacts
       end
     end
 
-    facterversion_obj = Gem::Version.new(facterversion)
+    strict_requirement = RspecPuppetFacts::facter_version_to_strict_requirement(facterversion)
+
+    loose_requirement = RspecPuppetFacts::facter_version_to_loose_requirement(facterversion)
+    received_facts = []
 
     # FacterDB may have newer versions of facter data for which it contains a subset of all possible
     # facter data (see FacterDB 0.5.2 for Facter releases 3.8 and 3.9). In this situation we need to
     # cycle through and downgrade Facter versions per platform type until we find matching Facter data.
     filter.each do |filter_spec|
-      facter_version_filter = RspecPuppetFacts.facter_version_to_filter(facterversion)
-      db = FacterDB.get_facts(filter_spec.merge({ :facterversion =>  facter_version_filter }))
-
-      if db.empty?
-        if RspecPuppetFacts.spec_facts_strict?
-          raise ArgumentError, "No facts were found in the FacterDB for Facter v#{facterversion} on #{filter_spec}, aborting"
-        end
+      versions = FacterDB.get_facts(filter_spec).to_h { |facts| [Gem::Version.new(facts[:facterversion]), facts] }
 
-        version = FacterDB.get_facts(filter_spec).map { |facts| Gem::Version.new(facts[:facterversion]) }.sort.reverse.detect { |v| v <= facterversion_obj }
+      version, facts = versions.select { |v, _f| strict_requirement =~ v }.max_by { |v, _f| v }
 
+      unless version
+        version, facts = versions.select { |v, _f| loose_requirement =~ v }.max_by { |v, _f| v } if loose_requirement
         next unless version
-        version = version.to_s
-        facter_version_filter = "/\\A#{Regexp.escape(version)}/"
 
-        unless version == facterversion
-          RspecPuppetFacts.warning "No facts were found in the FacterDB for Facter v#{facterversion} on #{filter_spec}, using v#{version} instead"
+        if RspecPuppetFacts.spec_facts_strict?
+          raise ArgumentError, "No facts were found in the FacterDB for Facter v#{facterversion} on #{filter_spec}, aborting"
         end
+
+        RspecPuppetFacts.warning "No facts were found in the FacterDB for Facter v#{facterversion} on #{filter_spec}, using v#{version} instead"
       end
 
-      filter_spec[:facterversion] = facter_version_filter
+      received_facts << facts
     end
 
-    received_facts = FacterDB::get_facts(filter)
     unless received_facts.any?
       RspecPuppetFacts.warning "No facts were found in the FacterDB for: #{filter.inspect}"
       return {}
@@ -178,8 +178,9 @@ module RspecPuppetFacts
     os_facts_hash
   end
 
+  # @api private
   def stringify_keys(hash)
-    Hash[hash.collect { |k,v| [k.to_s, v.is_a?(Hash) ? stringify_keys(v) : v] }]
+    hash.to_h { |k, v| [k.to_s, v.is_a?(Hash) ? stringify_keys(v) : v] }
   end
 
   # Register a custom fact that will be included in the facts hash.
@@ -210,7 +211,8 @@ module RspecPuppetFacts
   # @api private
   def self.register_custom_fact(name, value, options)
     @custom_facts ||= {}
-    @custom_facts[name.to_s] = {:options => options, :value => value}
+    name = RSpec.configuration.facterdb_string_keys ? name.to_s : name.to_sym
+    @custom_facts[name] = {:options => options, :value => value}
   end
 
   # Adds any custom facts according to the rules defined for the operating
@@ -226,7 +228,13 @@ module RspecPuppetFacts
       next if fact[:options][:confine] && !fact[:options][:confine].include?(os)
       next if fact[:options][:exclude] && fact[:options][:exclude].include?(os)
 
-      facts[name] = fact[:value].respond_to?(:call) ? fact[:value].call(os, facts) : fact[:value]
+      value = fact[:value].respond_to?(:call) ? fact[:value].call(os, facts) : fact[:value]
+      # if merge_facts passed, merge supplied facts into facts hash
+      if fact[:options][:merge_facts]
+        facts.deep_merge!({name => value})
+      else
+        facts[name] = value
+      end
     end
 
     facts
@@ -352,13 +360,47 @@ module RspecPuppetFacts
     @metadata = nil
   end
 
-  # Generates a JGrep statement expression for a specific facter version
-  # @return [String] JGrep statement expression
-  # @param version [String] the Facter version
+  # Construct the strict facter version requirement
+  # @return [Gem::Requirement] The version requirement to match
   # @api private
-  def self.facter_version_to_filter(version)
-    major, minor = version.split('.')
-    "/\\A#{major}\\.#{minor}\\./"
+  def self.facter_version_to_strict_requirement(version)
+    Gem::Requirement.new(facter_version_to_strict_requirement_string(version))
+  end
+
+  # Construct the strict facter version requirement string
+  # @return [String] The version requirement to match
+  # @api private
+  def self.facter_version_to_strict_requirement_string(version)
+    if /\A[0-9]+(\.[0-9]+)*\Z/.match?(version)
+      # Interpret 3 as ~> 3.0
+      "~> #{version}.0"
+    else
+      version
+    end
+  end
+
+  # Construct the loose facter version requirement
+  # @return [Optional[Gem::Requirement]] The version requirement to match
+  # @api private
+  def self.facter_version_to_loose_requirement(version)
+    string = facter_version_to_loose_requirement_string(version)
+    Gem::Requirement.new(string) if string
+  end
+
+  # Construct the facter version requirement string
+  # @return [String] The version requirement to match
+  # @api private
+  def self.facter_version_to_loose_requirement_string(version)
+    if (m = /\A(?<major>[0-9]+)\.(?<minor>[0-9]+)(?:\.(?<patch>[0-9]+))?\Z/.match(version))
+      # Interpret 3.1 as < 3.2 and 3.2.1 as < 3.3
+      "< #{m[:major]}.#{m[:minor].to_i + 1}"
+    elsif /\A[0-9]+\Z/.match?(version)
+      # Interpret 3 as < 4
+      "< #{version.to_i + 1}"
+    else
+      # This would be the same as the strict requirement
+      nil
+    end
   end
 
   def self.facter_version_for_puppet_version(puppet_version)

data/rspec-puppet-facts.gemspec

@@ -13,18 +13,20 @@ Gem::Specification.new do |s|
   s.description = 'Contains facts from many Facter version on many Operating Systems'
   s.licenses    = 'Apache-2.0'
 
-  # see .travis.yml for the supported ruby versions
-  s.required_ruby_version = '>= 2.4.0'
+  s.required_ruby_version = '>= 2.7.0'
 
   s.files       = `git ls-files`.split("\n")
-  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
 
-  s.add_development_dependency 'mime-types'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'yard'
-  s.add_runtime_dependency 'puppet'
-  s.add_runtime_dependency 'facter'
-  s.add_runtime_dependency 'facterdb', '>= 0.5.0'
+  s.add_development_dependency 'mime-types', '~> 3.5', '>= 3.5.2'
+  s.add_development_dependency 'rake', '~> 13.1'
+  s.add_development_dependency 'rspec', '~> 3.12'
+  s.add_development_dependency 'yard', '~> 0.9.34'
+
+  s.add_development_dependency 'voxpupuli-rubocop', '~> 2.6.0'
+
+  s.add_runtime_dependency 'deep_merge', '~> 1.2'
+  s.add_runtime_dependency 'facter', '< 5'
+  s.add_runtime_dependency 'facterdb', '>= 0.5.0', '< 2'
+  s.add_runtime_dependency 'puppet', '>= 7', '< 9'
 end