puppet 7.27.0-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/provider/service/systemd_spec.rb

@@ -22,149 +22,149 @@ describe 'Puppet::Type::Service::Provider::Systemd',
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(osfamily)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("1234")
+      allow(Facter).to receive(:value).with('os.family').and_return(osfamily)
+      allow(Facter).to receive(:value).with('os.name').and_return(osfamily)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("1234")
       expect(provider_class).to be_default
     end
   end
 
   [7, 8, 9].each do |ver|
     it "should be the default provider on rhel#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver.to_s)
+      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.name').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.release.major').and_return(ver.to_s)
       expect(provider_class).to be_default
     end
   end
 
   [ 4, 5, 6 ].each do |ver|
     it "should not be the default provider on rhel#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.name').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
       expect(provider_class).not_to be_default
     end
   end
 
   [ 17, 18, 19, 20, 21, 22, 23 ].each do |ver|
     it "should be the default provider on fedora#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.name').and_return(:fedora)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
       expect(provider_class).to be_default
     end
   end
 
   it "should be the default provider on Amazon Linux 2.0" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:amazon)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("2")
+    allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+    allow(Facter).to receive(:value).with('os.name').and_return(:amazon)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("2")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on Amazon Linux 2017.09" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:amazon)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("2017")
+    allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+    allow(Facter).to receive(:value).with('os.name').and_return(:amazon)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("2017")
     expect(provider_class).not_to be_default
   end
 
   it "should be the default provider on cumulus3" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CumulusLinux')
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("3")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return('CumulusLinux')
+    allow(Facter).to receive(:value).with('os.release.major').and_return("3")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on sles12" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12")
+    allow(Facter).to receive(:value).with('os.family').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.name').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("12")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on opensuse13" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("13")
+    allow(Facter).to receive(:value).with('os.family').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.name').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("13")
     expect(provider_class).to be_default
   end
 
   # tumbleweed is a rolling release with date-based major version numbers
   it "should be the default provider on tumbleweed" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("20150829")
+    allow(Facter).to receive(:value).with('os.family').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.name').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("20150829")
     expect(provider_class).to be_default
   end
 
   # leap is the next generation suse release
   it "should be the default provider on leap" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:leap)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("42")
+    allow(Facter).to receive(:value).with('os.family').and_return(:suse)
+    allow(Facter).to receive(:value).with('os.name').and_return(:leap)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("42")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on debian7" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("7")
     expect(provider_class).not_to be_default
   end
 
   it "should be the default provider on debian8" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("8")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on debian11" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("11")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on debian bookworm/sid" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("bookworm/sid")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("bookworm/sid")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on ubuntu14.04" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:ubuntu)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("14.04")
+    allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+    allow(Facter).to receive(:value).with('os.name').and_return(:ubuntu)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("14.04")
     expect(provider_class).not_to be_default
   end
 
   [ '15.04', '15.10', '16.04', '16.10', '17.04', '17.10', '18.04' ].each do |ver|
     it "should be the default provider on ubuntu#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:ubuntu)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+      allow(Facter).to receive(:value).with('os.name').and_return(:ubuntu)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
       expect(provider_class).to be_default
     end
   end
 
   [ '10', '11', '12', '13', '14', '15', '16', '17' ].each do |ver|
     it "should not be the default provider on LinuxMint#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:LinuxMint)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+      allow(Facter).to receive(:value).with('os.name').and_return(:LinuxMint)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
       expect(provider_class).not_to be_default
     end
   end
 
   [ '18', '19' ].each do |ver|
     it "should be the default provider on LinuxMint#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:LinuxMint)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      allow(Facter).to receive(:value).with('os.family').and_return(:debian)
+      allow(Facter).to receive(:value).with('os.name').and_return(:LinuxMint)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
       expect(provider_class).to be_default
     end
   end

data/spec/unit/provider/service/upstart_spec.rb

@@ -23,8 +23,8 @@ describe 'Puppet::Type::Service::Provider::Upstart',
   end
 
   it "should be the default provider on Ubuntu" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return("Ubuntu")
-    expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12.04")
+    expect(Facter).to receive(:value).with('os.name').and_return("Ubuntu")
+    expect(Facter).to receive(:value).with('os.release.major').and_return("12.04")
     expect(provider_class.default?).to be_truthy
   end
 
@@ -52,7 +52,7 @@ describe 'Puppet::Type::Service::Provider::Upstart',
 
   describe "excluding services" do
     it "ignores tty and serial on Redhat systems" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+      allow(Facter).to receive(:value).with('os.family').and_return('RedHat')
       expect(provider_class.excludes).to include 'serial'
       expect(provider_class.excludes).to include 'tty'
     end

data/spec/unit/provider/user/directoryservice_spec.rb

@@ -1142,9 +1142,9 @@ end
       provider.class.instance_variable_set(:@os_version, nil) if provider.class.instance_variable_defined? :@os_version
     end
 
-    it 'should call Puppet.runtime[:facter].value(:macosx_productversion_major) ONLY ONCE no matter how ' +
+    it 'should call Puppet.runtime[:facter].value(os.macosx.version.major) ONLY ONCE no matter how ' +
        'many times get_os_version() is called' do
-      expect(Facter).to receive(:value).with(:macosx_productversion_major).once.and_return('10.8')
+      expect(Facter).to receive(:value).with('os.macosx.version.major').once.and_return('10.8')
       expect(provider.class.get_os_version).to eq('10.8')
       expect(provider.class.get_os_version).to eq('10.8')
       expect(provider.class.get_os_version).to eq('10.8')

data/spec/unit/provider/user/openbsd_spec.rb

@@ -44,8 +44,8 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
 
   describe "#addcmd" do
     it "should return an array with the full command and expiry as MM/DD/YY" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+      allow(Facter).to receive(:value).with('os.family').and_return('OpenBSD')
+      allow(Facter).to receive(:value).with('os.release.major')
       resource[:expiry] = "1997-06-01"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
     end

data/spec/unit/provider/user/useradd_spec.rb

@@ -76,8 +76,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     context "when setting groups" do
       it "uses -G to set groups" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        allow(Facter).to receive(:value).with('os.family').and_return('Solaris')
+        allow(Facter).to receive(:value).with('os.release.major')
         resource[:ensure] = :present
         resource[:groups] = ['group1', 'group2']
         expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
@@ -85,8 +85,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       end
 
       it "uses -G to set groups with -M on supported systems" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        allow(Facter).to receive(:value).with('os.family').and_return('RedHat')
+        allow(Facter).to receive(:value).with('os.release.major')
         resource[:ensure] = :present
         resource[:groups] = ['group1', 'group2']
         expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
@@ -304,14 +304,14 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
   describe "#expiry=" do
     it "should pass expiry to usermod as MM/DD/YY when on Solaris" do
-      expect(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+      expect(Facter).to receive(:value).with('os.name').and_return('Solaris')
       resource[:expiry] = '2012-10-31'
       expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '10/31/2012', 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = '2012-10-31'
     end
 
     it "should pass expiry to usermod as YYYY-MM-DD when not on Solaris" do
-      expect(Facter).to receive(:value).with(:operatingsystem).and_return('not_solaris')
+      expect(Facter).to receive(:value).with('os.name').and_return('not_solaris')
       resource[:expiry] = '2012-10-31'
       expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '2012-10-31', 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = '2012-10-31'
@@ -324,8 +324,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should use -e with -1 when the expiry property is removed on SLES11" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('SLES')
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('11')
+      allow(Facter).to receive(:value).with('os.name').and_return('SLES')
+      allow(Facter).to receive(:value).with('os.release.major').and_return('11')
       resource[:expiry] = :absent
       expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', -1, 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = :absent
@@ -543,16 +543,16 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should use -M flag if home is not managed on a supported system" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("RedHat")
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+      allow(Facter).to receive(:value).with('os.family').and_return("RedHat")
+      allow(Facter).to receive(:value).with('os.release.major')
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(include('-M'), kind_of(Hash))
       provider.create
     end
 
     it "should not use -M flag if home is not managed on an unsupported system" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("Suse")
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
+      allow(Facter).to receive(:value).with('os.family').and_return("Suse")
+      allow(Facter).to receive(:value).with('os.release.major').and_return("11")
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(excluding('-M'), kind_of(Hash))
       provider.create
@@ -613,14 +613,14 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should return an array with the full command and expiry as MM/DD/YY when on Solaris" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+      allow(Facter).to receive(:value).with('os.name').and_return('Solaris')
       expect(described_class).to receive(:system_users?).and_return(true)
       resource[:expiry] = "2012-08-18"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '08/18/2012', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])
     end
 
     it "should return an array with the full command and expiry as YYYY-MM-DD when not on Solaris" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('not_solaris')
+      allow(Facter).to receive(:value).with('os.name').and_return('not_solaris')
       expect(described_class).to receive(:system_users?).and_return(true)
       resource[:expiry] = "2012-08-18"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '2012-08-18', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])

data/spec/unit/provider_spec.rb

@@ -222,20 +222,20 @@ describe Puppet::Provider do
       { :true => false } => false,
       { :false => false } => true,
       { :false => true } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem) } => true,
-      { :operatingsystem => :yayness } => false,
+      { 'os.name' => Puppet.runtime[:facter].value('os.name') } => true,
+      { 'os.name' => :yayness } => false,
       { :nothing => :yayness } => false,
       { :exists => Puppet::Util.which(existing_command) } => true,
       { :exists => "/this/file/does/not/exist" } => false,
       { :true => true, :exists => Puppet::Util.which(existing_command) } => true,
       { :true => true, :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { 'os.name' => Puppet.runtime[:facter].value('os.name'),
         :exists => Puppet::Util.which(existing_command) } => true,
-      { :operatingsystem => :yayness,
+      { 'os.name' => :yayness,
         :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { 'os.name' => Puppet.runtime[:facter].value('os.name'),
         :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => :yayness,
+      { 'os.name' => :yayness,
         :exists => "/this/file/does/not/exist" } => false,
     }.each do |confines, result|
       it "should confine #{confines.inspect} to #{result}" do
@@ -269,32 +269,32 @@ describe Puppet::Provider do
   end
 
   context "default providers" do
-    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
+    let :os do Puppet.runtime[:facter].value('os.name') end
 
     it { is_expected.to respond_to :specificity }
 
     it "should find the default provider" do
       type.provide(:nondefault) {}
-      subject.defaultfor :operatingsystem => os
+      subject.defaultfor 'os.name' => os
       expect(subject.name).to eq(type.defaultprovider.name)
     end
 
     describe "regex matches" do
       it "should match a singular regex" do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
+        expect(Facter).to receive(:value).with('os.family').at_least(:once).and_return("solaris")
 
         one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
+          defaultfor 'os.family' => /solaris/
         end
 
         expect(one).to be_default
       end
 
       it "should not match a non-matching regex " do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
+        expect(Facter).to receive(:value).with('os.family').at_least(:once).and_return("redhat")
 
         one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
+          defaultfor 'os.family' => /solaris/
         end
 
         expect(one).to_not be_default
@@ -302,15 +302,15 @@ describe Puppet::Provider do
 
       it "should allow a mix of regex and string" do
 
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
         one = type.provide(:one) do
-          defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
+          defaultfor 'os.name' => "fedora", 'os.release.major' => /^2[2-9]$/
         end
 
         two = type.provide(:two) do
-          defaultfor :operatingsystem => /fedora/, :operatingsystemmajrelease => '24'
+          defaultfor 'os.name' => /fedora/, 'os.release.major' => '24'
         end
 
         expect(one).to be_default
@@ -320,21 +320,21 @@ describe Puppet::Provider do
 
     describe "when there are multiple defaultfor's of equal specificity" do
       before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2
+        subject.defaultfor 'os.name' => :os1
+        subject.defaultfor 'os.name' => :os2
       end
 
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for the first defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for the last defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os2)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -343,31 +343,31 @@ describe Puppet::Provider do
 
     describe "when there are multiple defaultfor's with different specificity" do
       before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2, :operatingsystemmajrelease => "42"
-        subject.defaultfor :operatingsystem => :os3, :operatingsystemmajrelease => /^4[2-9]$/
+        subject.defaultfor 'os.name' => :os1
+        subject.defaultfor 'os.name' => :os2, 'os.release.major' => "42"
+        subject.defaultfor 'os.name' => :os3, 'os.release.major' => /^4[2-9]$/
       end
 
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for a more specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a more specific, but matching, defaultfor with regex" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os3)
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a less specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -377,7 +377,7 @@ describe Puppet::Provider do
     it "should consider any true value enough to be default" do
       alternate = type.provide(:alternate) {}
 
-      subject.defaultfor :operatingsystem => [:one, :two, :three, os]
+      subject.defaultfor 'os.name' => [:one, :two, :three, os]
       expect(subject.name).to eq(type.defaultprovider.name)
 
       expect(subject).to be_default
@@ -386,29 +386,29 @@ describe Puppet::Provider do
 
     it "should not be default if the defaultfor doesn't match" do
       expect(subject).not_to be_default
-      subject.defaultfor :operatingsystem => :one
+      subject.defaultfor 'os.name' => :one
       expect(subject).not_to be_default
     end
 
     it "should not be default if the notdefaultfor does match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+      expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
       one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 24
+        defaultfor 'os.name' => "fedora"
+        notdefaultfor 'os.name' => "fedora", 'os.release.major' => 24
       end
 
       expect(one).not_to be_default
     end
 
     it "should be default if the notdefaultfor doesn't match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+      expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
       one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 42
+        defaultfor 'os.name' => "fedora"
+        notdefaultfor 'os.name' => "fedora", 'os.release.major' => 42
       end
 
       expect(one).to be_default
@@ -519,18 +519,18 @@ describe Puppet::Provider do
         end
 
         it "with the specification: %{spec}" % { spec: thisspec.join(', ') } do
-          allow(Facter).to receive(:value).with(:osfamily).and_return("redhat")
-          allow(Facter).to receive(:value).with(:operatingsystem).and_return("centos")
-          allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return("27")
+          allow(Facter).to receive(:value).with('os.family').and_return("redhat")
+          allow(Facter).to receive(:value).with('os.name').and_return("centos")
+          allow(Facter).to receive(:value).with('os.release.full').and_return("27")
 
           one = type.provide(:one) do
             if defaultforspec[:one].key?(:defaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:one][:defaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:one][:defaultfor]
+              defaultfor    'os.family'               => "redhat" if  defaultforspec[:one][:defaultfor]
+              defaultfor    'os.family'               => "ubuntu" if !defaultforspec[:one][:defaultfor]
             end
             if defaultforspec[:one].key?(:notdefaultfor)
-              notdefaultfor :operatingsystem        => "centos" if  defaultforspec[:one][:notdefaultfor]
-              notdefaultfor :operatingsystem        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
+              notdefaultfor 'os.name'        => "centos" if  defaultforspec[:one][:notdefaultfor]
+              notdefaultfor 'os.name'        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
             end
           end
 
@@ -538,14 +538,14 @@ describe Puppet::Provider do
           provider_options[:parent] = one if defaultforspec[:two][:derived] # :two inherits from one, if spec'd
           two = type.provide(:two, provider_options) do
             if defaultforspec[:two].key?(:defaultfor) || defaultforspec[:two].key?(:extradefaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:two][:defaultfor]
-              defaultfor    :osfamily               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
-                            :operatingsystem        => "centos" if  defaultforspec[:two][:extradefaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:two][:defaultfor]
+              defaultfor    'os.family'               => "redhat" if  defaultforspec[:two][:defaultfor]
+              defaultfor    'os.family'               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
+                            'os.name'        => "centos" if  defaultforspec[:two][:extradefaultfor]
+              defaultfor    'os.family'               => "ubuntu" if !defaultforspec[:two][:defaultfor]
             end
             if defaultforspec[:two].key?(:notdefaultfor)
-              notdefaultfor :operatingsystemrelease => "27" if  defaultforspec[:two][:notdefaultfor]
-              notdefaultfor :operatingsystemrelease => "99" if !defaultforspec[:two][:notdefaultfor]
+              notdefaultfor 'os.release.full' => "27" if  defaultforspec[:two][:notdefaultfor]
+              notdefaultfor 'os.release.full' => "99" if !defaultforspec[:two][:notdefaultfor]
             end
           end
 

data/spec/unit/reports/store_spec.rb

@@ -15,10 +15,12 @@ describe Puppet::Reports.report(:store) do
     end
 
     let(:report) do
-      if RUBY_VERSION < "3.0"
-        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
-      else
+      # It's possible to install Psych 5 with Ruby 2.7, so check whether underlying YAML supports
+      # unsafe_load_file. This check can be removed in PUP-11718
+      if YAML.respond_to?(:unsafe_load_file)
         report = YAML.unsafe_load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      else
+        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
       end
       report.extend(described_class)
       report