puppet 7.28.0-x86-mingw32 → 8.0.1-x86-mingw32

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

@@ -15,23 +15,23 @@ describe 'Puppet::Type::Service::Provider::Redhat',
     allow(@provider).to receive(:get).with(:hasstatus).and_return(false)
     allow(FileTest).to receive(:file?).with('/sbin/service').and_return(true)
     allow(FileTest).to receive(:executable?).with('/sbin/service').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CentOS')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+    allow(Facter).to receive(:value).with('os.name').and_return('CentOS')
+    allow(Facter).to receive(:value).with('os.family').and_return('RedHat')
   end
 
   osfamilies = [ 'RedHat' ]
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      expect(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
+      expect(Facter).to receive(:value).with('os.family').and_return(osfamily)
       expect(provider_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on sles11" 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("11")
+    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("11")
     expect(provider_class.default?).to be_truthy
   end
 
@@ -81,7 +81,7 @@ describe 'Puppet::Type::Service::Provider::Redhat',
 
   context "when checking enabled? on Suse" do
     before :each do
-      expect(Facter).to receive(:value).with(:osfamily).and_return('Suse')
+      expect(Facter).to receive(:value).with('os.family').and_return('Suse')
     end
 
     it "should check for on" do

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

@@ -24,9 +24,9 @@ describe 'Puppet::Type::Service::Provider::Smf',
     allow(FileTest).to receive(:executable?).with('/usr/sbin/svcadm').and_return(true)
     allow(FileTest).to receive(:file?).with('/usr/bin/svcs').and_return(true)
     allow(FileTest).to receive(:executable?).with('/usr/bin/svcs').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-    allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
+    allow(Facter).to receive(:value).with('os.name').and_return('Solaris')
+    allow(Facter).to receive(:value).with('os.family').and_return('Solaris')
+    allow(Facter).to receive(:value).with('os.release.full').and_return('11.2')
   end
   context ".instances" do
     it "should have an instances method" do
@@ -173,19 +173,19 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
 
     it 'returns the right command for restarting the service for Solaris versions newer than 11.2' do
-      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+      expect(Facter).to receive(:value).with('os.release.full').and_return('11.3')
 
       expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, '-s', fmri])
     end
 
     it 'returns the right command for restarting the service on Solaris 11.2' do
-      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
+      expect(Facter).to receive(:value).with('os.release.full').and_return('11.2')
 
       expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, '-s', fmri])
     end
 
     it 'returns the right command for restarting the service for Solaris versions older than Solaris 11.2' do
-      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.3')
+      expect(Facter).to receive(:value).with('os.release.full').and_return('10.3')
 
       expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, fmri])
     end
@@ -281,7 +281,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     before(:each) do
       allow(@provider).to receive(:service_states).and_return(states)
 
-      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.3')
+      allow(Facter).to receive(:value).with('os.release.full').and_return('10.3')
     end
 
     it "should run the status command if it's passed in" do
@@ -336,7 +336,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
 
     it "should return stopped for an incomplete service on Solaris 11" do
-      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+      allow(Facter).to receive(:value).with('os.release.full').and_return('11.3')
       allow(@provider).to receive(:complete_service?).and_return(false)
       allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_fmri.out')))
       expect(@provider.status).to eq(:stopped)

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

@@ -18,155 +18,153 @@ describe 'Puppet::Type::Service::Provider::Systemd',
     Puppet::Util::Execution::ProcessOutput.new('', 0)
   end
 
-  osfamilies = [ 'archlinux', 'coreos', 'gentoo' ]
+  osfamilies = [ 'archlinux', 'coreos' ]
 
   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
 
-  [ 2, 2023 ].each do |ver|
-    it "should be the default provider on Amazon Linux #{ver}" 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("#{ver}")
-      expect(provider_class).to be_default
-    end
+  it "should be the default provider on Amazon Linux 2.0" do
+    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'])