rspec-puppet-facts 3.0.0 → 5.0.0

data/spec/rspec_puppet_facts_spec.rb

@@ -8,7 +8,9 @@ describe RspecPuppetFacts do
   end
 
   describe '.stringify_keys' do
-    it { expect(described_class.stringify_keys({ os: { family: 'RedHat' } })).to eq({ 'os' => { 'family' => 'RedHat' } }) }
+    it {
+      expect(described_class.stringify_keys({ os: { family: 'RedHat' } })).to eq({ 'os' => { 'family' => 'RedHat' } })
+    }
   end
 
   describe '.facter_version_for_puppet_version' do
@@ -137,10 +139,10 @@ describe RspecPuppetFacts do
       subject(:result) do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                "operatingsystem"        => "Debian",
-                "operatingsystemrelease" => ['7'],
+                'operatingsystem' => 'Debian',
+                'operatingsystemrelease' => ['12'],
               },
             ],
           },
@@ -148,7 +150,7 @@ describe RspecPuppetFacts do
       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
@@ -161,7 +163,7 @@ describe RspecPuppetFacts do
         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
 
@@ -171,7 +173,7 @@ describe RspecPuppetFacts do
         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
@@ -209,26 +211,20 @@ describe RspecPuppetFacts do
             is_expected.to be_a Hash
           end
 
-          it 'has 5 elements' do
-            expect(subject.size).to eq 5
-          end
-
           it 'returns 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
+            expect(subject.keys).to contain_exactly(
+              'debian-11-x86_64',
+              'debian-12-x86_64',
+              'redhat-8-x86_64',
+              'redhat-9-x86_64',
             )
           end
 
           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.sort).to eq %w(
-              redhat-5-x86_64
-              redhat-6-x86_64
-              redhat-7-x86_64
+            expect(subject.keys).to contain_exactly(
+              'redhat-8-x86_64',
+              'redhat-9-x86_64',
             )
           end
         end
@@ -249,63 +245,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
                 ],
               },
             ],
           },
         )
-      }
+      end
 
       it 'returns a hash' do
         is_expected.to be_a Hash
       end
 
-      it 'has 4 elements' do
-        expect(subject.size).to eq 4
-      end
-
       it 'returns 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
+        expect(subject.keys).to contain_exactly(
+          'debian-11-x86_64',
+          'debian-12-x86_64',
+          'redhat-8-x86_64',
+          'redhat-9-x86_64',
         )
       end
 
       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.sort).to eq %w(
-          redhat-5-x86_64
-          redhat-6-x86_64
+        expect(subject.keys).to contain_exactly(
+          'redhat-8-x86_64',
+          'redhat-9-x86_64',
         )
       end
     end
@@ -314,8 +305,8 @@ describe RspecPuppetFacts do
       subject(:factsets) do
         on_supported_os(
           {
-            :supported_os => [
-              { 'operatingsystem' => 'RedHat', 'operatingsystemrelease' => '7' },
+            supported_os: [
+              { 'operatingsystem' => 'RedHat', 'operatingsystemrelease' => '9' },
             ],
           },
         )
@@ -325,287 +316,245 @@ 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 a_hash_including('redhat-9-x86_64' => hash_including({ os: hash_including({ 'release' => hash_including({ 'major' => '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 'returns a hash' do
-        expect(subject.class).to eq Hash
-      end
-
-      it 'has 3 elements' do
-        expect(subject.size).to eq(expected_fact_sets.size)
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to eq(expected_fact_sets)
+        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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 1 elements' do
-        expect(subject.size).to eq 1
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to eq [
-          'freebsd-10-amd64',
-        ]
+        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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 1 elements' do
-        expect(subject.size).to eq 1
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to eq [
-          'openbsd-5.7-amd64',
-        ]
+        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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 1 elements' do
-        expect(subject.size).to eq 1
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to eq %w(
-          solaris-11-i86pc
+        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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 1 elements' do
-        expect(subject.size).to eq 1
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 1 elements' do
-        expect(subject.size).to eq 1
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to eq [
-          'sles-11-x86_64',
-        ]
+        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 'outputs warning message' do
         expect(described_class).to receive(:warning).with(/No facts were found in the FacterDB/)
@@ -614,35 +563,31 @@ describe RspecPuppetFacts do
     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 'returns a hash' do
-        expect(subject.class).to eq Hash
       end
 
-      it 'has 2 elements' do
-        expect(subject.size).to eq 2
+      it 'returns a hash' do
+        expect(subject).to be_a Hash
       end
 
       it 'returns supported OS' do
-        expect(subject.keys.sort).to include(a_string_matching(/\Aarchlinux-\d+-x86_64/), 'debian-8-x86_64')
+        expect(subject.keys).to contain_exactly(a_string_matching(/gentoo-\d+-x86_64/), 'debian-12-x86_64')
       end
     end
 
@@ -650,9 +595,9 @@ describe RspecPuppetFacts do
       subject do
         on_supported_os(
           {
-            :supported_os => [
+            supported_os: [
               {
-                'operatingsystem'        => 'IOS',
+                'operatingsystem' => 'IOS',
                 'operatingsystemrelease' => ['12.2(25)EWA9'],
               },
             ],
@@ -666,12 +611,12 @@ describe RspecPuppetFacts do
 
       it 'escapes the parens in the filter' do
         filter = {
-          :operatingsystem        => "IOS",
-          :operatingsystemrelease => "/^12\\.2\\(25\\)EWA9/",
-          :hardwaremodel          => "x86_64",
+          'os.name' => 'IOS',
+          'os.release.full' => '/^12\\.2\\(25\\)EWA9/',
+          'os.hardware' => 'x86_64',
         }
 
-        expect(FacterDB).to receive(:get_facts).with(filter).once
+        expect(FacterDB).to receive(:get_facts).with(filter, symbolize_keys: true).once
         subject
       end
 
@@ -684,24 +629,23 @@ describe RspecPuppetFacts do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] },
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
           ],
         )
       end
 
       before do
-        RSpec.configuration.default_facter_version = '3.1.6'
+        RSpec.configuration.default_facter_version = '4.6.1'
       end
 
       after do
         RSpec.configuration.default_facter_version = Facter.version
       end
 
-
       it 'returns facts from the specified default Facter version' do
         is_expected.to match(
-          'centos-7-x86_64' => include(
-            :facterversion => /\A3\.1\./,
+          'centos-9-x86_64' => include(
+            facterversion: /\A4\.6\./,
           ),
         )
       end
@@ -711,21 +655,20 @@ describe RspecPuppetFacts do
       subject do
         on_supported_os(
           supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] },
+            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[9] },
           ],
-          facterversion: "2.6",
+          facterversion: '4.7.99',
         )
       end
 
       before do
-        allow(Facter).to receive(:version).and_return('2.4.5')
+        allow(Facter).to receive(:version).and_return('4.6')
       end
 
-
       it 'returns facts from a facter version matching version and below' do
         is_expected.to match(
-          'centos-7-x86_64' => include(
-            :facterversion => /\A2\.[0-6]\./,
+          'centos-9-x86_64' => include(
+            facterversion: /\A4\.[0-7]\./,
           ),
         )
       end
@@ -741,88 +684,33 @@ describe RspecPuppetFacts do
       end
     end
 
-    context 'With a custom facterversion (3.1) in the options hash' do
-      subject do
-        on_supported_os(
-          supported_os: [
-            { 'operatingsystem' => 'CentOS', 'operatingsystemrelease' => %w[7] },
-          ],
-          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'),
-        )
-      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',
-        )
-      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'),
-        )
-      end
-    end
-
-    context 'With a custom facterversion (3.3) 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',
+          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 'With a custom facterversion (3.3.2) in the options hash' do
+    context 'With a custom facterversion (4.6.1) 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.1',
         )
       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'),
-        )
-      end
-    end
-
-    context 'When querying a fact set that does not have an operatingsystemmajrelease fact' do
-      subject do
-        on_supported_os(
-          supported_os: [
-            { 'operatingsystem' => 'SLES', 'operatingsystemrelease' => ['11'] },
-          ],
-          facterversion: '2.1.0',
-        )
-      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
 
@@ -846,52 +734,48 @@ 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 do
         allow(FacterDB).to receive(:get_facts).and_call_original
         allow(FacterDB).to receive(:get_facts).with(
-          {:operatingsystem=>"CentOS", :operatingsystemrelease=>"/^7/", :hardwaremodel=>"x86_64"},
+          { '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?('3.9.') }
+          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
 
   describe '#add_custom_fact' do
-    subject {
+    subject do
       on_supported_os(
         {
-          :supported_os => [
+          supported_os: [
             {
-              "operatingsystem" => "RedHat",
-              "operatingsystemrelease" => [
-                "6",
-                "7",
+              'operatingsystem' => 'RedHat',
+              'operatingsystemrelease' => %w[
+                8
+                9
               ],
             },
           ],
         },
       )
-    }
+    end
 
     before do
       described_class.reset
@@ -899,49 +783,51 @@ describe RspecPuppetFacts do
 
     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-7-x86_64'][:identity]).to eq(
-      {
-        "gid"=>0,
-        "group"=>"root",
-        "privileged"=>true,
-        "uid"=>0,
-        "user"=>"test_user"
-      })
+      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-7-x86_64'][:identity]).to eq(
-      {
-        "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-7-x86_64'][:root_home]).to eq '/root'
+      expect(subject['redhat-9-x86_64'][:root_home]).to eq '/root'
     end
   end
 
@@ -964,6 +850,7 @@ describe RspecPuppetFacts do
         def self.open(*_args)
           self
         end
+
         def self.get(*_args)
           'my_version'
         end
@@ -987,7 +874,7 @@ describe RspecPuppetFacts do
       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