rspec-puppet-facts 2.0.5 → 4.0.0

data/spec/rspec_puppet_facts_spec.rb

@@ -7,6 +7,12 @@ describe RspecPuppetFacts do
     'spec/fixtures/metadata.json'
   end
 
+  describe '.stringify_keys' do
+    it {
+      expect(described_class.stringify_keys({ os: { family: 'RedHat' } })).to eq({ 'os' => { 'family' => 'RedHat' } })
+    }
+  end
+
   describe '.facter_version_for_puppet_version' do
     subject(:facter_version) do
       described_class.facter_version_for_puppet_version(puppet_version)
@@ -19,7 +25,7 @@ describe RspecPuppetFacts do
     let(:puppet_version) { Puppet.version }
 
     context 'when the component JSON file does not exist' do
-      before(:each) do
+      before do
         allow(File).to receive(:file?).with(component_json_path).and_return(false)
         allow(described_class).to receive(:warning)
       end
@@ -36,7 +42,7 @@ describe RspecPuppetFacts do
     end
 
     context 'when the component JSON file is unreadable' do
-      before(:each) do
+      before do
         allow(File).to receive(:readable?).with(component_json_path).and_return(false)
         allow(described_class).to receive(:warning)
       end
@@ -53,7 +59,7 @@ describe RspecPuppetFacts do
     end
 
     context 'when the component JSON file is unparseable' do
-      before(:each) do
+      before do
         io = StringIO.new('this is not JSON!')
         allow(File).to receive(:open).with(component_json_path, anything).and_return(io)
         allow(described_class).to receive(:warning)
@@ -112,7 +118,7 @@ describe RspecPuppetFacts do
     context 'when passed a Puppet version lower than any known version' do
       let(:puppet_version) { '1.0.0' }
 
-      before(:each) do
+      before do
         allow(described_class).to receive(:warning)
       end
 
@@ -133,41 +139,41 @@ describe RspecPuppetFacts do
       subject(:result) do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem"        => "Debian",
-                "operatingsystemrelease" => ['7'],
+                'operatingsystem' => 'Debian',
+                'operatingsystemrelease' => ['12'],
               },
             ],
-          }
+          },
         )
       end
 
       let(:get_keys) do
-        proc { |r| r.keys + r.select { |_,v| v.is_a?(Hash) }.map { |_,v| get_keys.call(v) }.flatten }
+        proc { |r| r.keys + r.select { |_, v| v.is_a?(Hash) }.map { |_, v| get_keys.call(v) }.flatten }
       end
 
       context 'set to true' do
-        before(:each) do
+        before do
           RSpec.configuration.facterdb_string_keys = true
         end
 
-        after(:each) do
+        after do
           RSpec.configuration.facterdb_string_keys = false
         end
 
         it 'returns a fact set with all the keys as Strings' do
-          expect(get_keys.call(result['debian-7-x86_64'])).to all(be_a(String))
+          expect(get_keys.call(result['debian-12-x86_64'])).to all(be_a(String))
         end
       end
 
       context 'set to false' do
-        before(:each) do
+        before do
           RSpec.configuration.facterdb_string_keys = false
         end
 
         it 'returns a fact set with all the keys as Symbols or Strings' do
-          expect(get_keys.call(result['debian-7-x86_64'])).to all(be_a(Symbol).or(be_a(String)))
+          expect(get_keys.call(result['debian-12-x86_64'])).to all(be_a(Symbol).or(be_a(String)))
         end
       end
     end
@@ -176,7 +182,7 @@ describe RspecPuppetFacts do
       subject { on_supported_os }
 
       context 'Without metadata.json' do
-        before(:each) do
+        before do
           expect(File).to receive(:file?).with('metadata.json').and_return false
         end
 
@@ -185,10 +191,10 @@ describe RspecPuppetFacts do
 
       context 'With a metadata.json' do
         it 'can load the metadata file' do
-          allow(RspecPuppetFacts).to receive(:metadata_file).and_return(metadata_file)
-          RspecPuppetFacts.reset
-          expect(RspecPuppetFacts.metadata).to be_a Hash
-          expect(RspecPuppetFacts.metadata['name']).to eq 'mcanevet-mymodule'
+          allow(described_class).to receive(:metadata_file).and_return(metadata_file)
+          described_class.reset
+          expect(described_class.metadata).to be_a Hash
+          expect(described_class.metadata['name']).to eq 'mcanevet-mymodule'
         end
 
         context 'With a valid metadata.json' do
@@ -197,41 +203,37 @@ describe RspecPuppetFacts do
             JSON.parse fixture
           end
 
-          before :each do
-            allow(RspecPuppetFacts).to receive(:metadata).and_return(metadata)
+          before do
+            allow(described_class).to receive(:metadata).and_return(metadata)
           end
 
-          it 'should return a hash' do
+          it 'returns a hash' do
             is_expected.to be_a Hash
           end
 
-          it 'should have 5 elements' do
-            expect(subject.size).to eq 5
-          end
-
-          it 'should return supported OS' do
-            expect(subject.keys.sort).to eq %w(
-              debian-7-x86_64
-              debian-8-x86_64
-              redhat-5-x86_64
-              redhat-6-x86_64
-              redhat-7-x86_64
+          it 'returns supported OS' do
+            expect(subject.keys).to contain_exactly(
+              'debian-11-x86_64',
+              'debian-12-x86_64',
+              'redhat-7-x86_64',
+              'redhat-8-x86_64',
+              'redhat-9-x86_64',
             )
           end
 
-          it 'should be able to filter the received OS facts' do
-            allow(RspecPuppetFacts).to receive(:spec_facts_os_filter).and_return('redhat')
-            expect(subject.keys.sort).to eq %w(
-              redhat-5-x86_64
-              redhat-6-x86_64
-              redhat-7-x86_64
+          it 'is able to filter the received OS facts' do
+            allow(described_class).to receive(:spec_facts_os_filter).and_return('redhat')
+            expect(subject.keys).to contain_exactly(
+              'redhat-7-x86_64',
+              'redhat-8-x86_64',
+              'redhat-9-x86_64',
             )
           end
         end
 
         context 'With a broken metadata.json' do
-          before :each do
-            allow(RspecPuppetFacts).to receive(:metadata).and_return(metadata)
+          before do
+            allow(described_class).to receive(:metadata).and_return(metadata)
           end
 
           context 'With a missing operatingsystem_support section' do
@@ -245,63 +247,58 @@ describe RspecPuppetFacts do
           context 'With a wrong operatingsystem_support section' do
             let(:metadata) do
               {
-                  'operatingsystem_support' => 'Ubuntu',
+                'operatingsystem_support' => 'Ubuntu',
               }
             end
 
             it { expect { subject }.to raise_error(StandardError, /Unknown operatingsystem support/) }
           end
         end
-
       end
     end
 
     context 'When specifying supported_os' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "Debian",
-                "operatingsystemrelease" => [
-                  "7",
-                  "8",
-                ]
+                'operatingsystem' => 'Debian',
+                'operatingsystemrelease' => %w[
+                  11
+                  12
+                ],
               },
               {
-                "operatingsystem" => "RedHat",
-                "operatingsystemrelease" => [
-                  "5",
-                  "6"
-                ]
-              }
-            ]
-          }
+                'operatingsystem' => 'RedHat',
+                'operatingsystemrelease' => %w[
+                  8
+                  9
+                ],
+              },
+            ],
+          },
         )
-      }
-
-      it 'should return a hash' do
-        is_expected.to be_a Hash
       end
 
-      it 'should have 4 elements' do
-        expect(subject.size).to eq 4
+      it 'returns a hash' do
+        is_expected.to be_a Hash
       end
 
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq %w(
-          debian-7-x86_64
-          debian-8-x86_64
-          redhat-5-x86_64
-          redhat-6-x86_64
+      it 'returns supported OS' do
+        expect(subject.keys).to contain_exactly(
+          'debian-11-x86_64',
+          'debian-12-x86_64',
+          'redhat-8-x86_64',
+          'redhat-9-x86_64',
         )
       end
 
-      it 'should be able to filter the received OS facts' do
-        allow(RspecPuppetFacts).to receive(:spec_facts_os_filter).and_return('redhat')
-        expect(subject.keys.sort).to eq %w(
-          redhat-5-x86_64
-          redhat-6-x86_64
+      it 'is able to filter the received OS facts' do
+        allow(described_class).to receive(:spec_facts_os_filter).and_return('redhat')
+        expect(subject.keys).to contain_exactly(
+          'redhat-8-x86_64',
+          'redhat-9-x86_64',
         )
       end
     end
@@ -310,10 +307,10 @@ describe RspecPuppetFacts do
       subject(:factsets) do
         on_supported_os(
           {
-            :supported_os => [
-              { 'operatingsystem' => 'RedHat', 'operatingsystemrelease' => '7' },
-            ]
-          }
+            supported_os: [
+              { 'operatingsystem' => 'RedHat', 'operatingsystemrelease' => '9' },
+            ],
+          },
         )
       end
 
@@ -321,304 +318,278 @@ describe RspecPuppetFacts do
         expect(factsets).to be_a(Hash)
       end
 
-      it 'returns a single fact set' do
-        expect(factsets.size).to eq(1)
-      end
-
       it 'returns a fact set for the specified release' do
-        expect(factsets).to include('redhat-7-x86_64' => include(:operatingsystemmajrelease => '7'))
+        expect(factsets).to match('redhat-9-x86_64' => include(operatingsystemmajrelease: '9'))
       end
     end
 
     context 'When testing Ubuntu' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "Ubuntu",
-                "operatingsystemrelease" => [
-                  "12.04",
-                  "14.04",
-                  "16.04",
+                'operatingsystem' => 'Ubuntu',
+                'operatingsystemrelease' => [
+                  '18.04',
+                  '20.04',
+                  '22.04',
                 ],
               },
             ],
-          }
+          },
         )
-      }
-
-      let(:expected_fact_sets) do
-        ['ubuntu-12.04-x86_64', 'ubuntu-14.04-x86_64', 'ubuntu-16.04-x86_64']
       end
 
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should have 3 elements' do
-        expect(subject.size).to eq(expected_fact_sets.size)
-      end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq(expected_fact_sets)
+
+      it 'returns supported OS' do
+        expect(subject.keys).to contain_exactly(
+          'ubuntu-18.04-x86_64',
+          'ubuntu-20.04-x86_64',
+          'ubuntu-22.04-x86_64',
+        )
       end
     end
 
     context 'When testing FreeBSD 10' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "FreeBSD",
-                "operatingsystemrelease" => [
-                  "10",
+                'operatingsystem' => 'FreeBSD',
+                'operatingsystemrelease' => [
+                  '13',
                 ],
               },
             ],
-            :facterversion => '2.4',
-          }
+            facterversion: '4.5',
+          },
         )
-      }
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 1 elements' do
-        expect(subject.size).to eq 1
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq [
-          'freebsd-10-amd64',
-        ]
+
+      it 'returns supported OS' do
+        expect(subject.keys).to contain_exactly(
+          'freebsd-13-amd64',
+        )
       end
     end
 
     context 'When testing OpenBSD' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "OpenBSD",
-                "operatingsystemrelease" => [
-                  "5.7",
+                'operatingsystem' => 'OpenBSD',
+                'operatingsystemrelease' => [
+                  '7.5',
                 ],
               },
             ],
-            :facterversion => '2.4',
-          }
+            facterversion: '4.7',
+          },
         )
-      }
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 1 elements' do
-        expect(subject.size).to eq 1
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq [
-          'openbsd-5.7-amd64',
-        ]
+
+      it 'returns supported OS' do
+        expect(subject.keys).to contain_exactly(
+          'openbsd-7-amd64',
+        )
       end
     end
 
-    context 'When testing Solaris 11', :if => Facter.version.to_f >= 2.0 do
-      subject {
+    context 'When testing Solaris 11' do
+      subject do
         on_supported_os(
-            {
-                :supported_os => [
-                    {
-                        "operatingsystem" => "Solaris",
-                        "operatingsystemrelease" => [
-                            "11",
-                        ],
-                    },
+          {
+            supported_os: [
+              {
+                'operatingsystem' => 'Solaris',
+                'operatingsystemrelease' => [
+                  '11',
                 ],
-            }
+              },
+            ],
+            facterversion: '4.0',
+          },
         )
-      }
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 1 elements' do
-        expect(subject.size).to eq 1
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq %w(
-          solaris-11-i86pc
+
+      it 'returns supported OS' do
+        pending('2024-06-07: we dont have a suitable solaris 11 factset in facterdb')
+        expect(subject.keys).to contain_exactly(
+          'solaris-11-i86pc',
         )
       end
     end
 
     context 'When testing AIX 7.1' do
-      subject {
+      subject do
         on_supported_os(
-            {
-                :supported_os => [
-                    {
-                        "operatingsystem" => "AIX",
-                        "operatingsystemrelease" => [
-                            "7.1", "7100"
-                        ],
-                    },
+          {
+            supported_os: [
+              {
+                'operatingsystem' => 'AIX',
+                'operatingsystemrelease' => [
+                  '7.1', '7100',
                 ],
-                :facterversion => '3.9'
-            }
+              },
+            ],
+            facterversion: '3.9',
+          },
         )
-      }
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 1 elements' do
-        expect(subject.size).to eq 1
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
+
+      it 'returns supported OS' do
         # NOTE: See FACT-1827 for details on the IBM,8284-22A part
         # That has to match whatever hardware generated the facts file.
-        expect(subject.keys.sort).to eq %w(
-          aix-7100-IBM,8284-22A
+        pending('2024-06-07: we dont have a suitable solaris 11 factset in facterdb')
+        expect(subject.keys).to contain_exactly(
+          'aix-7100-IBM,8284-22A',
         )
       end
     end
 
-    context 'When testing Windows', :if => Facter.version.to_f >= 2.4 do
+    context 'When testing Windows' do
       subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                'operatingsystem'        => 'Windows',
+                'operatingsystem' => 'Windows',
                 'operatingsystemrelease' => release,
-              }
+              },
             ],
-            :facterversion => facterversion,
-          }
+            facterversion: facterversion,
+          },
         )
       end
 
-      let(:facterversion) { '3.8.0' }
+      let(:facterversion) { '4.2' }
 
       context 'with a standard release' do
-        let(:release) { ['7'] }
+        let(:release) { ['10'] }
 
         it { is_expected.to be_a(Hash) }
-        it { is_expected.to have_attributes(:size => 1) }
-        it { is_expected.to include('windows-7-x86_64' => an_instance_of(Hash)) }
+        it { is_expected.to match('windows-10-x86_64' => an_instance_of(Hash)) }
       end
 
       context 'with a revision release' do
         let(:release) { ['2012 R2'] }
 
         it { is_expected.to be_a(Hash) }
-        it { is_expected.to have_attributes(:size => 1) }
-        it { is_expected.to include('windows-2012 R2-x86_64' => an_instance_of(Hash)) }
+        it { is_expected.to match('windows-2012 R2-x86_64' => an_instance_of(Hash)) }
       end
 
       context 'with a Server prefixed release' do
         let(:release) { ['Server 2012'] }
 
         it { is_expected.to be_a(Hash) }
-        it { is_expected.to have_attributes(:size => 1) }
-        it { is_expected.to include('windows-2012-x86_64' => an_instance_of(Hash)) }
+        it { is_expected.to match('windows-2012-x86_64' => an_instance_of(Hash)) }
       end
 
       context 'with a 2016 release' do
         let(:release) { ['2016'] }
 
         it { is_expected.to be_a(Hash) }
-        it { is_expected.to have_attributes(:size => 1) }
-        it { is_expected.to include('windows-2016-x86_64' => an_instance_of(Hash)) }
-      end
-
-      context 'with a 2016 release and Facter < 3.4' do
-        let(:release) { ['2016'] }
-        let(:facterversion) { '3.3.0' }
-
-        it { is_expected.to be_a(Hash) }
-        it { is_expected.to have_attributes(:size => 1) }
-        it 'munges the operatingsystemmajrelease to 2016' do
-          is_expected.to include('windows-2016-x86_64' => an_instance_of(Hash))
-        end
+        it { is_expected.to match('windows-2016-x86_64' => an_instance_of(Hash)) }
       end
     end
 
     context 'When operatingsystemrelease has space' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "SLES",
-                "operatingsystemrelease" => [
-                  "11 SP1"
-                ]
-              }
-            ]
-          }
+                'operatingsystem' => 'SLES',
+                'operatingsystemrelease' => [
+                  '11 SP1',
+                ],
+              },
+            ],
+          },
         )
-      }
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 1 elements' do
-        expect(subject.size).to eq 1
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to eq [
-          'sles-11-x86_64',
-        ]
+
+      it 'returns supported OS' do
+        pending('2024-06-7: facterdb has no factset with space in the system release')
+        expect(subject.keys).to contain_exactly('sles-11-x86_64')
       end
     end
 
     context 'When specifying wrong supported_os' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "Debian",
-                "operatingsystemrelease" => [
-                  "4",
+                'operatingsystem' => 'Debian',
+                'operatingsystemrelease' => [
+                  '4',
                 ],
               },
-            ]
-          }
+            ],
+          },
         )
-      }
+      end
 
-      it 'should output warning message' do
-        expect(RspecPuppetFacts).to receive(:warning).with(/No facts were found in the FacterDB/)
+      it 'outputs warning message' do
+        expect(described_class).to receive(:warning).with(/No facts were found in the FacterDB/)
         subject
       end
     end
 
     context 'When specifying rolling release operating system' do
-      subject {
+      subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem" => "Debian",
-                "operatingsystemrelease" => [
-                  "8",
+                'operatingsystem' => 'Debian',
+                'operatingsystemrelease' => [
+                  '12',
                 ],
               },
               {
-                "operatingsystem" => "Archlinux",
+                'operatingsystem' => 'Gentoo',
               },
             ],
-            :facterversion => '2.4',
-          }
+            facterversion: '4.6',
+          },
         )
-      }
-
-      it 'should return a hash' do
-        expect(subject.class).to eq Hash
       end
-      it 'should have 2 elements' do
-        expect(subject.size).to eq 2
+
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
-      it 'should return supported OS' do
-        expect(subject.keys.sort).to include(a_string_matching(/\Aarchlinux-\d+-x86_64/), 'debian-8-x86_64')
+
+      it 'returns supported OS' do
+        expect(subject.keys).to contain_exactly(a_string_matching(/gentoo-\d+-x86_64/), 'debian-12-x86_64')
       end
     end
 
@@ -626,31 +597,28 @@ describe RspecPuppetFacts do
       subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                'operatingsystem'        => 'IOS',
+                'operatingsystem' => 'IOS',
                 'operatingsystemrelease' => ['12.2(25)EWA9'],
-              }
+              },
             ],
-          }
+          },
         )
       end
 
-      before(:each) do
-        allow(RspecPuppetFacts).to receive(:warning).with(a_string_matching(/no facts were found/i))
-        allow(FacterDB).to receive(:get_facts).and_call_original
+      before do
+        allow(described_class).to receive(:warning).with(a_string_matching(/no facts were found/i))
       end
 
       it 'escapes the parens in the filter' do
-        filter = [
-          include(
-            :operatingsystem        => "IOS",
-            :operatingsystemrelease => "/^12\\.2\\(25\\)EWA9/",
-            :hardwaremodel          => "x86_64",
-          ),
-        ]
+        filter = {
+          'os.name' => 'IOS',
+          'os.release.full' => '/^12\\.2\\(25\\)EWA9/',
+          'os.hardware' => 'x86_64',
+        }
 
-        expect(FacterDB).to receive(:get_facts).with(filter)
+        expect(FacterDB).to receive(:get_facts).with(filter, symbolize_keys: true).once
         subject
       end
 
@@ -660,146 +628,91 @@ describe RspecPuppetFacts do
     end
 
     context 'With a default Facter version specified in the RSpec configuration' do
-      before(:each) do
-        RSpec.configuration.default_facter_version = '3.1.0'
-      end
-
-      after(:each) do
-        RSpec.configuration.default_facter_version = Facter.version
-      end
-
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
-          ]
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
+          ],
         )
       end
 
-      it 'returns facts from the specified default Facter version' do
-        is_expected.to match(
-          'centos-7-x86_64' => include(
-            :facterversion => /\A3\.1\./
-          )
-        )
+      before do
+        RSpec.configuration.default_facter_version = '4.6.1'
       end
-    end
 
-    context 'With a version that is above the current gem' do
-      before(:each) do
-        allow(Facter).to receive(:version).and_return('2.4.5')
-      end
-
-      subject do
-        on_supported_os(
-          supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
-          ],
-          facterversion: "2.6"
-        )
+      after do
+        RSpec.configuration.default_facter_version = Facter.version
       end
 
-      it 'returns facts from a facter version matching future and below' do
-        major, minor = Facter.version.split('.')
+      it 'returns facts from the specified default Facter version' do
         is_expected.to match(
-          'centos-7-x86_64' => include(
-            :facterversion => /\A#{major}\.[#{minor}#{minor.to_i + 1}]\./
-          )
+          'centos-9-x86_64' => include(
+            facterversion: /\A4\.6\./,
+          ),
         )
       end
-
-      context 'With SPEC_FACTS_STRICT set to `yes`' do
-        before(:each) do
-          allow(RspecPuppetFacts).to receive(:spec_facts_strict?).and_return(true)
-        end
-        it 'errors' do
-          expect { subject }.to raise_error ArgumentError, /No facts were found in the FacterDB.*aborting/
-        end
-      end
     end
 
-    context 'With a custom facterversion (3.1) in the options hash' do
+    context 'With a version that is above the current gem' do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
           ],
-          facterversion: '3.1'
-        )
-      end
-
-      it 'returns facts from a facter version matching 3.1' do
-        is_expected.to match(
-          'centos-7-x86_64' => include(:facterversion => '3.1.6')
+          facterversion: '4.7.99',
         )
       end
-    end
 
-    context 'With a custom facterversion (3.1.2) in the options hash' do
-      subject do
-        on_supported_os(
-          supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
-          ],
-          facterversion: '3.1.2'
-        )
+      before do
+        allow(Facter).to receive(:version).and_return('4.6')
       end
 
-      it 'returns facts from a facter version matching 3.1' do
+      it 'returns facts from a facter version matching version and below' do
         is_expected.to match(
-          'centos-7-x86_64' => include(:facterversion => '3.1.6')
+          'centos-9-x86_64' => include(
+            facterversion: /\A4\.[0-7]\./,
+          ),
         )
       end
-    end
 
-    context 'With a custom facterversion (3.3) in the options hash' do
-      subject do
-        on_supported_os(
-          supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
-          ],
-          facterversion: '3.3'
-        )
-      end
+      context 'With SPEC_FACTS_STRICT set to `yes`' do
+        before do
+          allow(described_class).to receive(:spec_facts_strict?).and_return(true)
+        end
 
-      it 'returns facts from a facter version matching 3.3' do
-        is_expected.to match(
-          'centos-7-x86_64' => include(:facterversion => '3.3.0')
-        )
+        it 'errors' do
+          expect { subject }.to raise_error ArgumentError, /No facts were found in the FacterDB.*aborting/
+        end
       end
     end
 
-    context 'With a custom facterversion (3.3.2) in the options hash' do
+    context 'With a custom facterversion (4.6) in the options hash' do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
           ],
-          facterversion: '3.3.2'
+          facterversion: '4.6',
         )
       end
 
-      it 'returns facts from a facter version matching 3.3' do
-        is_expected.to match(
-          'centos-7-x86_64' => include(:facterversion => '3.3.0')
-        )
+      it 'returns facts from a facter version matching 4.6' do
+        is_expected.to match('centos-9-x86_64' => include(facterversion: '4.6.1'))
       end
     end
 
-    context 'When querying a fact set that does not have an operatingsystemmajrelease fact' do
+    context 'With a custom facterversion (4.6.1) in the options hash' do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'SLES', 'operatingsystemrelease' => ['11'] }
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
           ],
-          facterversion: '2.1.0'
+          facterversion: '4.6.1',
         )
       end
 
-      it 'splits the operatingsystemrelease fact value to get the major release' do
-        is_expected.to match(
-          'sles-11-x86_64' => include(:operatingsystemrelease => '11.3')
-        )
+      it 'returns facts from a facter version matching 4.6.1' do
+        is_expected.to match('centos-9-x86_64' => include(facterversion: '4.6.1'))
       end
     end
 
@@ -807,9 +720,9 @@ describe RspecPuppetFacts do
       let(:method_call) do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] }
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] },
           ],
-          facterversion: '3'
+          facterversion: '3',
         )
       end
 
@@ -823,125 +736,152 @@ describe RspecPuppetFacts do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] },
-            { 'operatingsystem' => 'OpenSuSE', 'operatingsystemrelease' => %w[42] }
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
+            { 'operatingsystem' => 'Debian', 'operatingsystemrelease' => %w[12] },
           ],
-          facterversion: '3.9.5'
+          facterversion: '4.6.1',
         )
       end
 
-      before(:each) do
+      before do
         allow(FacterDB).to receive(:get_facts).and_call_original
         allow(FacterDB).to receive(:get_facts).with(
-          a_hash_including(facterversion: "/\\A3\\.9\\./", operatingsystem: 'CentOS')
-        ).and_return([])
+          { 'os.name' => 'CentOS', 'os.release.full' => '/^9/', 'os.hardware' => 'x86_64' }, symbolize_keys: true
+        ).and_wrap_original do |m, *args|
+          m.call(*args).reject { |facts| facts[:facterversion].start_with?('4.6.') }
+        end
       end
 
-      it 'returns CentOS facts from a facter version matching 3.8' do
-        is_expected.to include(
-          'centos-7-x86_64' => include(:facterversion => '3.8.0')
-        )
+      it 'returns CentOS facts from a facter version matching 4.5' do
+        is_expected.to include('centos-9-x86_64' => include(facterversion: '4.5.2'))
       end
-      it 'returns OpenSuSE facts from a facter version matching 3.9' do
-        is_expected.to include(
-          'opensuse-42-x86_64' => include(:facterversion => '3.9.2')
-        )
+
+      it 'returns Debian facts from a facter version matching 4.6.1' do
+        is_expected.to include('debian-12-x86_64' => include(facterversion: '4.6.1'))
       end
     end
   end
 
-  context '#add_custom_fact' do
-    subject {
+  describe '#add_custom_fact' do
+    subject do
       on_supported_os(
         {
-          :supported_os => [
+          supported_os: [
             {
-              "operatingsystem" => "RedHat",
-              "operatingsystemrelease" => [
-                "6",
-                "7"
-              ]
-            }
-          ]
-        }
+              'operatingsystem' => 'RedHat',
+              'operatingsystemrelease' => %w[
+                8
+                9
+              ],
+            },
+          ],
+        },
       )
-    }
+    end
 
-    before(:each) do
-      RspecPuppetFacts.reset
+    before do
+      described_class.reset
     end
 
     it 'adds a simple fact and value' do
       add_custom_fact 'root_home', '/root'
-      expect(subject['redhat-7-x86_64']['root_home']).to eq '/root'
+      expect(subject['redhat-9-x86_64'][:root_home]).to eq '/root'
+    end
+
+    it 'merges a fact value into fact when merge_facts passed' do
+      add_custom_fact :identity, { 'user' => 'test_user' }, merge_facts: true
+      expect(subject['redhat-9-x86_64'][:identity]).to eq(
+        {
+          'gid' => 0,
+          'group' => 'root',
+          'privileged' => true,
+          'uid' => 0,
+          'user' => 'test_user',
+        },
+      )
+    end
+
+    it 'overwrites fact' do
+      add_custom_fact :identity, { 'user' => 'other_user' }
+      expect(subject['redhat-9-x86_64'][:identity]).to eq(
+        {
+          'user' => 'other_user',
+        },
+      )
     end
 
     it 'confines a fact to a particular operating system' do
-      add_custom_fact 'root_home', '/root', :confine => 'redhat-7-x86_64'
-      expect(subject['redhat-7-x86_64']['root_home']).to eq '/root'
-      expect(subject['redhat-6-x86_64']['root_home']).to be_nil
+      add_custom_fact 'root_home', '/root', confine: 'redhat-9-x86_64'
+      expect(subject['redhat-9-x86_64'][:root_home]).to eq '/root'
+      expect(subject['redhat-8-x86_64'][:root_home]).to be_nil
     end
 
     it 'excludes a fact from a particular operating system' do
-      add_custom_fact 'root_home', '/root', :exclude => 'redhat-7-x86_64'
-      expect(subject['redhat-7-x86_64']['root_home']).to be_nil
-      expect(subject['redhat-6-x86_64']['root_home']).to eq '/root'
+      add_custom_fact 'root_home', '/root', exclude: 'redhat-9-x86_64'
+      expect(subject['redhat-9-x86_64'][:root_home]).to be_nil
+      expect(subject['redhat-8-x86_64'][:root_home]).to eq '/root'
     end
 
     it 'takes a proc as a value' do
       add_custom_fact 'root_home', ->(_os, _facts) { '/root' }
-      expect(subject['redhat-7-x86_64']['root_home']).to eq '/root'
+      expect(subject['redhat-9-x86_64'][:root_home]).to eq '/root'
+    end
+
+    it 'accepts sym fact key and stores fact key as sym' do
+      add_custom_fact :root_home, ->(_os, _facts) { '/root' }
+      expect(subject['redhat-9-x86_64'][:root_home]).to eq '/root'
     end
   end
 
-  context '#misc' do
-    it 'should have a common facts structure' do
-      RspecPuppetFacts.reset
+  describe '#misc' do
+    it 'has a common facts structure' do
+      described_class.reset
       expect(subject.common_facts).to be_a Hash
       expect(subject.common_facts).not_to be_empty
     end
 
-    it 'should not add "augeasversion" if Augeas is supported' do
+    it 'does not add "augeasversion" if Augeas is supported' do
       allow(described_class).to receive(:augeas?).and_return(false)
-      RspecPuppetFacts.reset
+      described_class.reset
       expect(subject.common_facts).not_to include(:augeasversion)
     end
 
-    it 'should determine the Augeas version if Augeas is supported' do
-      module Augeas_stub
+    it 'determines the Augeas version if Augeas is supported' do
+      module AugeasStub # rubocop:todo Lint/ConstantDefinitionInBlock
         NO_MODL_AUTOLOAD = true
         def self.open(*_args)
           self
         end
+
         def self.get(*_args)
           'my_version'
         end
       end
 
       allow(described_class).to receive(:augeas?).and_return(true)
-      stub_const('Augeas', Augeas_stub)
-      RspecPuppetFacts.reset
+      stub_const('Augeas', AugeasStub)
+      described_class.reset
       expect(subject.common_facts[:augeasversion]).to eq 'my_version'
     end
 
     context 'when mcollective is available' do
-      module MCollective_stub
+      module MCollectiveStub # rubocop:todo Lint/ConstantDefinitionInBlock
         VERSION = 'my_version'
       end
 
-      before(:each) do
+      before do
         allow(described_class).to receive(:mcollective?).and_return(true)
-        stub_const('MCollective', MCollective_stub)
+        stub_const('MCollective', MCollectiveStub)
         described_class.reset
       end
 
       it 'includes an "mco_version" fact' do
-        expect(subject.common_facts).to include(:mco_version => 'my_version')
+        expect(subject.common_facts).to include(mco_version: 'my_version')
       end
     end
 
     context 'when mcollective is not available' do
-      before(:each) do
+      before do
         allow(described_class).to receive(:mcollective?).and_return(false)
         described_class.reset
       end
@@ -952,69 +892,145 @@ describe RspecPuppetFacts do
     end
   end
 
-  describe '.facter_version_to_filter' do
+  describe '.facter_version_to_strict_requirement' do
+    subject { described_class.facter_version_to_strict_requirement(version) }
+
+    context 'when passed a version that is a complex requirement' do
+      let(:version) { '~> 2.4' }
+
+      it { is_expected.to be_instance_of(Gem::Requirement) }
+    end
+
+    context 'when passed a version that is major' do
+      let(:version) { '1' }
+
+      it { is_expected.to be_instance_of(Gem::Requirement) }
+    end
+  end
+
+  describe '.facter_version_to_strict_requirement_string' do
+    subject { described_class.facter_version_to_strict_requirement_string(version) }
+
+    context 'when passed a version that is a complex requirement' do
+      let(:version) { '~> 2.4' }
+
+      it { is_expected.to eq('~> 2.4') }
+    end
+
+    context 'when passed a version that is major' do
+      let(:version) { '1' }
+
+      it { is_expected.to eq('~> 1.0') }
+    end
+
+    context 'when passed a version that is major.minor' do
+      let(:version) { '1.2' }
+
+      it { is_expected.to eq('~> 1.2.0') }
+    end
+
+    context 'when passed a version that is major.minor.patch' do
+      let(:version) { '1.2.3' }
+
+      it { is_expected.to eq('~> 1.2.3.0') }
+    end
+  end
+
+  describe '.facter_version_to_loose_requirement' do
+    subject { described_class.facter_version_to_loose_requirement(version) }
+
+    context 'when passed a version that is a complex requirement' do
+      let(:version) { '~> 2.4' }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when passed a version that is major' do
+      let(:version) { '1' }
+
+      it { is_expected.to be_instance_of(Gem::Requirement) }
+    end
+  end
+
+  describe '.facter_version_to_loose_requirement_string' do
+    subject { described_class.facter_version_to_loose_requirement_string(version) }
+
+    context 'when passed a version that is a complex requirement (1)' do
+      let(:version) { '~> 2.4' }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when passed a version that is a complex requirement (2)' do
+      let(:version) { '>= 3 < 5' }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when passed a version that is major (1)' do
+      let(:version) { '1' }
+
+      it { is_expected.to eq('< 2') }
+    end
+
+    context 'when passed a version that is major (2)' do
+      let(:version) { '9' }
+
+      it { is_expected.to eq('< 10') }
+    end
+
+    context 'when passed a version that is major (3)' do
+      let(:version) { '10' }
+
+      it { is_expected.to eq('< 11') }
+    end
+
     context 'when passed a version that is major.minor (1)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('1.2') }
+      let(:version) { '1.2' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A1\.2\./')
-      end
+      it { is_expected.to eq('< 1.3') }
     end
 
     context 'when passed a version that is major.minor (2)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('10.2') }
+      let(:version) { '10.2' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A10\.2\./')
-      end
+      it { is_expected.to eq('< 10.3') }
     end
 
     context 'when passed a version that is major.minor (3)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('1.20') }
+      let(:version) { '1.20' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A1\.20\./')
-      end
+      it { is_expected.to eq('< 1.21') }
     end
 
     context 'when passed a version that is major.minor (4)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('10.20') }
+      let(:version) { '10.20' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A10\.20\./')
-      end
+      it { is_expected.to eq('< 10.21') }
     end
 
     context 'when passed a version that is major.minor.patch (1)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('1.2.3') }
+      let(:version) { '1.2.3' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A1\.2\./')
-      end
+      it { is_expected.to eq('< 1.3') }
     end
 
     context 'when passed a version that is major.minor.patch (2)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('10.2.3') }
+      let(:version) { '10.2.3' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A10\.2\./')
-      end
+      it { is_expected.to eq('< 10.3') }
     end
 
     context 'when passed a version that is major.minor.patch (3)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('1.20.3') }
+      let(:version) { '1.20.3' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A1\.20\./')
-      end
+      it { is_expected.to eq('< 1.21') }
     end
 
     context 'when passed a version that is major.minor.patch (4)' do
-      subject { RspecPuppetFacts.facter_version_to_filter('10.20.3') }
+      let(:version) { '10.20.3' }
 
-      it 'returns the correct JGrep statement expression' do
-        is_expected.to eq('/\A10\.20\./')
-      end
+      it { is_expected.to eq('< 10.21') }
     end
   end
 end