puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/type/filebucket_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:filebucket) do
@@ -20,14 +21,14 @@ describe Puppet::Type.type(:filebucket) do
     expect(Puppet::Type.type(:filebucket).new(:name => "main")[:path]).to eq(Puppet[:clientbucketdir])
   end
 
-  it "should not have a default port" do
+  it "should use the masterport as the path by default port" do
     Puppet.settings[:masterport] = 50
-    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:port]).to eq(nil)
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:port]).to eq(Puppet[:masterport])
   end
 
-  it "should not have a default server" do
+  it "should use the server as the path by default server" do
     Puppet.settings[:server] = "myserver"
-    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:server]).to eq(nil)
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:server]).to eq(Puppet[:server])
   end
 
   it "be local by default" do
@@ -76,28 +77,26 @@ describe Puppet::Type.type(:filebucket) do
 
   describe "when creating the filebucket" do
     before do
-      @bucket = double('bucket', :name= => nil)
+      @bucket = stub 'bucket', :name= => nil
     end
 
     it "should use any provided path" do
       path = make_absolute("/foo/bar")
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => path
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Path => path).and_return(@bucket)
+      Puppet::FileBucket::Dipper.expects(:new).with(:Path => path).returns @bucket
       bucket.bucket
     end
 
     it "should use any provided server and port" do
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => "myserv", :Port => "myport").and_return(@bucket)
+      Puppet::FileBucket::Dipper.expects(:new).with(:Server => "myserv", :Port => "myport").returns @bucket
       bucket.bucket
     end
 
-    it "should not try to guess server or port if the path is unset and no server is provided" do
+    it "should use the default server if the path is unset and no server is provided" do
       Puppet.settings[:server] = "myserv"
-      Puppet.settings[:server_list] = ['server_list_0', 'server_list_1']
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => nil, :Port => nil).and_return(@bucket)
-
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+      Puppet::FileBucket::Dipper.expects(:new).with { |args| args[:Server] == "myserv" }.returns @bucket
       bucket.bucket
     end
   end

data/spec/unit/type/group_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:group) do
@@ -49,20 +50,20 @@ describe Puppet::Type.type(:group) do
 
   it "should call 'create' to create the group" do
     group = @class.new(:name => "foo", :ensure => :present)
-    expect(group.provider).to receive(:create)
+    group.provider.expects(:create)
     group.parameter(:ensure).sync
   end
 
   it "should call 'delete' to remove the group" do
     group = @class.new(:name => "foo", :ensure => :absent)
-    expect(group.provider).to receive(:delete)
+    group.provider.expects(:delete)
     group.parameter(:ensure).sync
   end
 
   it "delegates the existence check to its provider" do
     provider = @class.provide(:testing) {}
     provider_instance = provider.new
-    expect(provider_instance).to receive(:exists?).and_return(true)
+    provider_instance.expects(:exists?).returns true
 
     type = @class.new(:name => "group", :provider => provider_instance)
 
@@ -70,6 +71,7 @@ describe Puppet::Type.type(:group) do
   end
 
   describe "should delegate :members implementation to the provider:"  do
+
     let (:provider) do
       @class.provide(:testing) do
         has_features :manages_members
@@ -83,13 +85,13 @@ describe Puppet::Type.type(:group) do
     let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
     it "insync? calls members_insync?" do
-      expect(provider_instance).to receive(:members_insync?).with(['user1'], ['user1']).and_return(true)
+      provider_instance.expects(:members_insync?).with(['user1'], ['user1']).returns true
       expect(type.property(:members).insync?(['user1'])).to be_truthy
     end
 
     it "is_to_s and should_to_s call members_to_s" do
-      expect(provider_instance).to receive(:members_to_s).with(['user1', 'user2']).and_return("user1 (), user2 ()")
-      expect(provider_instance).to receive(:members_to_s).with(['user1']).and_return("user1 ()")
+      provider_instance.expects(:members_to_s).with(['user1', 'user2']).returns "user1 (), user2 ()"
+      provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
 
       expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
       expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')

data/spec/unit/type/noop_metaparam_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/type'
@@ -6,7 +7,7 @@ describe Puppet::Type.type(:file).attrclass(:noop) do
   include PuppetSpec::Files
 
   before do
-    allow(Puppet.settings).to receive(:use)
+    Puppet.settings.stubs(:use)
     @file = Puppet::Type.newfile :path => make_absolute("/what/ever")
   end
 

data/spec/unit/type/package/package_settings_spec.rb

@@ -1,8 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
+
   before do
-    allow(Puppet::Util::Storage).to receive(:store)
+    Puppet::Util::Storage.stubs(:store)
   end
 
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
@@ -17,81 +19,66 @@ describe Puppet::Type.type(:package) do
 
   context "when validating attribute values" do
     let(:provider) do
-      double('provider',
-             :class => described_class.defaultprovider,
-             :clear => nil,
-             :validate_source => false)
+      stub( 'provider',
+            :class => described_class.defaultprovider,
+            :clear => nil,
+            :validate_source => false )
     end
-
     before do
-      allow(provider.class).to receive(:supports_parameter?).and_return(true)
-      allow(described_class.defaultprovider).to receive(:new).and_return(provider)
+      provider.class.stubs(:supports_parameter?).returns(true)
+      described_class.defaultprovider.stubs(:new).returns(provider)
     end
-
     describe 'package_settings' do
       context "with a minimalistic provider supporting package_settings" do
         context "and {:package_settings => :settings}" do
           let(:resource) do 
             described_class.new :name => 'foo', :package_settings => :settings
           end
-
           it { expect { resource }.to_not raise_error }
-
           it "should set package_settings to :settings" do
             expect(resource.value(:package_settings)).to be :settings
           end
         end
       end
-
       context "with a provider that supports validation of the package_settings" do
         context "and {:package_settings => :valid_value}" do
           before do
-            expect(provider).to receive(:package_settings_validate).once.with(:valid_value).and_return(true)
+            provider.expects(:package_settings_validate).once.with(:valid_value).returns(true)
           end
-
           let(:resource) do 
             described_class.new :name => 'foo', :package_settings => :valid_value
           end
-
           it { expect { resource }.to_not raise_error }
-
           it "should set package_settings to :valid_value" do
             expect(resource.value(:package_settings)).to eq(:valid_value)
           end
         end
-
         context "and {:package_settings => :invalid_value}" do
           before do
             msg = "package_settings must be a Hash, not Symbol"
-            expect(provider).to receive(:package_settings_validate).once.
-              with(:invalid_value).and_raise(ArgumentError, msg)
+            provider.expects(:package_settings_validate).once.
+              with(:invalid_value).raises(ArgumentError, msg)
           end
-
           let(:resource) do 
             described_class.new :name => 'foo', :package_settings => :invalid_value
           end
-
           it do
             expect { resource }.to raise_error Puppet::Error,
               /package_settings must be a Hash, not Symbol/
           end
         end
       end
-
       context "with a provider that supports munging of the package_settings" do
         context "and {:package_settings => 'A'}" do
           before do
-            expect(provider).to receive(:package_settings_munge).once.with('A').and_return(:a)
+            provider.expects(:package_settings_munge).once.with('A').returns(:a)
           end
-
           let(:resource) do 
             described_class.new :name => 'foo', :package_settings => 'A'
           end
-
           it do
             expect { resource }.to_not raise_error 
           end
-
           it "should set package_settings to :a" do
             expect(resource.value(:package_settings)).to be :a
           end
@@ -99,55 +86,47 @@ describe Puppet::Type.type(:package) do
       end
     end
   end
-
   describe "package_settings property" do
     let(:provider) do
-      double('provider',
-             :class => described_class.defaultprovider,
-             :clear => nil,
-             :validate_source => false)
+      stub( 'provider',
+            :class => described_class.defaultprovider,
+            :clear => nil,
+            :validate_source => false )
     end
-
     before do
-      allow(provider.class).to receive(:supports_parameter?).and_return(true)
-      allow(described_class.defaultprovider).to receive(:new).and_return(provider)
+      provider.class.stubs(:supports_parameter?).returns(true)
+      described_class.defaultprovider.stubs(:new).returns(provider)
     end
-
     context "with {package_settings => :should}" do
       let(:resource) do 
         described_class.new :name => 'foo', :package_settings => :should
       end
-
       describe "#insync?(:is)" do
         it "returns the result of provider.package_settings_insync?(:should,:is)" do
-          expect(resource.provider).to receive(:package_settings_insync?).once.with(:should,:is).and_return(:ok1)
+          resource.provider.expects(:package_settings_insync?).once.with(:should,:is).returns :ok1
           expect(resource.property(:package_settings).insync?(:is)).to be :ok1
         end
       end
-
       describe "#should_to_s(:newvalue)" do
         it "returns the result of provider.package_settings_should_to_s(:should,:newvalue)" do
-          expect(resource.provider).to receive(:package_settings_should_to_s).once.with(:should,:newvalue).and_return(:ok2)
+          resource.provider.expects(:package_settings_should_to_s).once.with(:should,:newvalue).returns :ok2
           expect(resource.property(:package_settings).should_to_s(:newvalue)).to be :ok2
         end
       end
-
       describe "#is_to_s(:currentvalue)" do
         it "returns the result of provider.package_settings_is_to_s(:should,:currentvalue)" do
-          expect(resource.provider).to receive(:package_settings_is_to_s).once.with(:should,:currentvalue).and_return(:ok3)
+          resource.provider.expects(:package_settings_is_to_s).once.with(:should,:currentvalue).returns :ok3
           expect(resource.property(:package_settings).is_to_s(:currentvalue)).to be :ok3
         end
       end
     end
-
     context "with any non-nil package_settings" do
       describe "#change_to_s(:currentvalue,:newvalue)" do
         let(:resource) do 
           described_class.new :name => 'foo', :package_settings => {}
         end
-
         it "returns the result of provider.package_settings_change_to_s(:currentvalue,:newvalue)" do
-          expect(resource.provider).to receive(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).and_return(:ok4)
+          resource.provider.expects(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).returns :ok4
           expect(resource.property(:package_settings).change_to_s(:currentvalue,:newvalue)).to be :ok4
         end
       end

data/spec/unit/type/package_spec.rb

@@ -1,9 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
   before do
-    allow(Process).to receive(:euid).and_return(0)
-    allow(Puppet::Util::Storage).to receive(:store)
+    Process.stubs(:euid).returns 0
+    Puppet::Util::Storage.stubs(:store)
   end
 
   it "should have a :reinstallable feature that requires the :reinstall method" do
@@ -57,13 +58,13 @@ describe Puppet::Type.type(:package) do
 
   describe "when validating attribute values" do
     before :each do
-      @provider = double(
+      @provider = stub(
         'provider',
         :class           => Puppet::Type.type(:package).defaultprovider,
         :clear           => nil,
         :validate_source => nil
       )
-      allow(Puppet::Type.type(:package).defaultprovider).to receive(:new).and_return(@provider)
+      Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
     end
 
     after :each do
@@ -84,32 +85,32 @@ describe Puppet::Type.type(:package) do
     end
 
     it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
-      expect(@provider).to receive(:satisfies?).with([:purgeable]).and_return(true)
+      @provider.expects(:satisfies?).with([:purgeable]).returns(true)
       Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged)
     end
 
     it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
-      expect(@provider).to receive(:satisfies?).with([:purgeable]).and_return(false)
+      @provider.expects(:satisfies?).with([:purgeable]).returns(false)
       expect { Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged) }.to raise_error(Puppet::Error)
     end
 
     it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
-      expect(@provider).to receive(:satisfies?).with([:upgradeable]).and_return(true)
+      @provider.expects(:satisfies?).with([:upgradeable]).returns(true)
       Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest)
     end
 
     it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
-      expect(@provider).to receive(:satisfies?).with([:upgradeable]).and_return(false)
+      @provider.expects(:satisfies?).with([:upgradeable]).returns(false)
       expect { Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest) }.to raise_error(Puppet::Error)
     end
 
     it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
-      expect(@provider).to receive(:satisfies?).with([:versionable]).and_return(true)
+      @provider.expects(:satisfies?).with([:versionable]).returns(true)
       Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0")
     end
 
     it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
-      expect(@provider).to receive(:satisfies?).with([:versionable]).and_return(false)
+      @provider.expects(:satisfies?).with([:versionable]).returns(false)
       expect { Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0") }.to raise_error(Puppet::Error)
     end
 
@@ -126,13 +127,13 @@ describe Puppet::Type.type(:package) do
 
   module PackageEvaluationTesting
     def setprops(properties)
-      allow(@provider).to receive(:properties).and_return(properties)
+      @provider.stubs(:properties).returns(properties)
     end
   end
 
   describe Puppet::Type.type(:package) do
     before :each do
-      @provider = double(
+      @provider = stub(
         'provider',
         :class           => Puppet::Type.type(:package).defaultprovider,
         :clear           => nil,
@@ -140,8 +141,8 @@ describe Puppet::Type.type(:package) do
         :name            => :mock,
         :validate_source => nil
       )
-      allow(Puppet::Type.type(:package).defaultprovider).to receive(:new).and_return(@provider)
-      allow(Puppet::Type.type(:package).defaultprovider).to receive(:instances).and_return([])
+      Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
+      Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
       @package = Puppet::Type.type(:package).new(:name => "yay")
 
       @catalog = Puppet::Resource::Catalog.new
@@ -154,14 +155,14 @@ describe Puppet::Type.type(:package) do
       before { @package[:ensure] = :purged }
 
       it "should do nothing if it is :purged" do
-        expect(@provider).to receive(:properties).and_return(:ensure => :purged).at_least(:once)
+        @provider.expects(:properties).returns(:ensure => :purged).at_least_once
         @catalog.apply
       end
 
       [:absent, :installed, :present, :latest].each do |state|
         it "should purge if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
-          expect(@provider).to receive(:purge)
+          @provider.stubs(:properties).returns(:ensure => state)
+          @provider.expects(:purge)
           @catalog.apply
         end
       end
@@ -174,15 +175,15 @@ describe Puppet::Type.type(:package) do
 
       [:purged, :absent].each do |state|
         it "should do nothing if it is #{state.to_s}" do
-          expect(@provider).to receive(:properties).and_return(:ensure => state).at_least(:once)
+          @provider.expects(:properties).returns(:ensure => state).at_least_once
           @catalog.apply
         end
       end
 
       [:installed, :present, :latest].each do |state|
         it "should uninstall if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
-          expect(@provider).to receive(:uninstall)
+          @provider.stubs(:properties).returns(:ensure => state)
+          @provider.expects(:uninstall)
           @catalog.apply
         end
       end
@@ -195,15 +196,15 @@ describe Puppet::Type.type(:package) do
 
       [:present, :latest, "1.0"].each do |state|
         it "should do nothing if it is #{state.to_s}" do
-          expect(@provider).to receive(:properties).and_return(:ensure => state).at_least(:once)
+          @provider.expects(:properties).returns(:ensure => state).at_least_once
           @catalog.apply
         end
       end
 
       [:purged, :absent].each do |state|
         it "should install if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
-          expect(@provider).to receive(:install)
+          @provider.stubs(:properties).returns(:ensure => state)
+          @provider.expects(:install)
           @catalog.apply
         end
       end
@@ -216,30 +217,30 @@ describe Puppet::Type.type(:package) do
 
       [:purged, :absent].each do |state|
         it "should upgrade if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
-          expect(@provider).to receive(:update)
+          @provider.stubs(:properties).returns(:ensure => state)
+          @provider.expects(:update)
           @catalog.apply
         end
       end
 
       it "should upgrade if the current version is not equal to the latest version" do
-        allow(@provider).to receive(:properties).and_return(:ensure => "1.0")
-        allow(@provider).to receive(:latest).and_return("2.0")
-        expect(@provider).to receive(:update)
+        @provider.stubs(:properties).returns(:ensure => "1.0")
+        @provider.stubs(:latest).returns("2.0")
+        @provider.expects(:update)
         @catalog.apply
       end
 
       it "should do nothing if it is equal to the latest version" do
-        allow(@provider).to receive(:properties).and_return(:ensure => "1.0")
-        allow(@provider).to receive(:latest).and_return("1.0")
-        expect(@provider).not_to receive(:update)
+        @provider.stubs(:properties).returns(:ensure => "1.0")
+        @provider.stubs(:latest).returns("1.0")
+        @provider.expects(:update).never
         @catalog.apply
       end
 
       it "should do nothing if the provider returns :present as the latest version" do
-        allow(@provider).to receive(:properties).and_return(:ensure => :present)
-        allow(@provider).to receive(:latest).and_return("1.0")
-        expect(@provider).not_to receive(:update)
+        @provider.stubs(:properties).returns(:ensure => :present)
+        @provider.stubs(:latest).returns("1.0")
+        @provider.expects(:update).never
         @catalog.apply
       end
     end
@@ -251,24 +252,24 @@ describe Puppet::Type.type(:package) do
 
       [:purged, :absent].each do |state|
         it "should install if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
+          @provider.stubs(:properties).returns(:ensure => state)
           expect(@package.property(:ensure).insync?(state)).to be_falsey
-          expect(@provider).to receive(:install)
+          @provider.expects(:install)
           @catalog.apply
         end
       end
 
       it "should do nothing if the current version is equal to the desired version" do
-        allow(@provider).to receive(:properties).and_return(:ensure => "1.0")
+        @provider.stubs(:properties).returns(:ensure => "1.0")
         expect(@package.property(:ensure).insync?('1.0')).to be_truthy
-        expect(@provider).not_to receive(:install)
+        @provider.expects(:install).never
         @catalog.apply
       end
 
       it "should install if the current version is not equal to the specified version" do
-        allow(@provider).to receive(:properties).and_return(:ensure => "2.0")
+        @provider.stubs(:properties).returns(:ensure => "2.0")
         expect(@package.property(:ensure).insync?('2.0')).to be_falsey
-        expect(@provider).to receive(:install)
+        @provider.expects(:install)
         @catalog.apply
       end
 
@@ -276,29 +277,29 @@ describe Puppet::Type.type(:package) do
         let(:installed_versions) { ["1.0", "2.0", "3.0"] }
 
         before (:each) do
-          allow(@provider).to receive(:properties).and_return(:ensure => installed_versions)
+          @provider.stubs(:properties).returns(:ensure => installed_versions)
         end
 
         it "should install if value not in the array" do
           @package[:ensure] = "1.5"
           expect(@package.property(:ensure).insync?(installed_versions)).to be_falsey
-          expect(@provider).to receive(:install)
+          @provider.expects(:install)
           @catalog.apply
         end
 
         it "should not install if value is in the array" do
           @package[:ensure] = "2.0"
           expect(@package.property(:ensure).insync?(installed_versions)).to be_truthy
-          expect(@provider).not_to receive(:install)
+          @provider.expects(:install).never
           @catalog.apply
         end
 
         describe "when ensure is set to 'latest'" do
           it "should not install if the value is in the array" do
-            expect(@provider).to receive(:latest).and_return("3.0")
+            @provider.expects(:latest).returns("3.0")
             @package[:ensure] = "latest"
             expect(@package.property(:ensure).insync?(installed_versions)).to be_truthy
-            expect(@provider).not_to receive(:install)
+            @provider.expects(:install).never
             @catalog.apply
           end
         end
@@ -327,16 +328,16 @@ describe Puppet::Type.type(:package) do
         it "should reinstall if it should be #{state.to_s} and reinstall_on_refresh is true" do
           @package[:ensure] = state
           @package[:reinstall_on_refresh] = :true
-          allow(@provider).to receive(:reinstallable?).and_return(true)
-          expect(@provider).to receive(:reinstall).once
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).once
           @package.refresh
         end
 
         it "should reinstall if it should be #{state.to_s} and reinstall_on_refresh is false" do
           @package[:ensure] = state
           @package[:reinstall_on_refresh] = :false
-          allow(@provider).to receive(:reinstallable?).and_return(true)
-          expect(@provider).not_to receive(:reinstall)
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
           @package.refresh
         end
       end
@@ -344,15 +345,15 @@ describe Puppet::Type.type(:package) do
       [:purged, :absent, :held].each do |state|
         it "should not reinstall if it should be #{state.to_s} and reinstall_on_refresh is true" do
           @package[:ensure] = state
-          allow(@provider).to receive(:reinstallable?).and_return(true)
-          expect(@provider).not_to receive(:reinstall)
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
           @package.refresh
         end
 
         it "should not reinstall if it should be #{state.to_s} and reinstall_on_refresh is false" do
           @package[:ensure] = state
-          allow(@provider).to receive(:reinstallable?).and_return(true)
-          expect(@provider).not_to receive(:reinstall)
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
           @package.refresh
         end
       end
@@ -362,9 +363,9 @@ describe Puppet::Type.type(:package) do
   it "should select dnf over yum for dnf supported fedora versions" do
     dnf = Puppet::Type.type(:package).provider(:dnf)
     yum = Puppet::Type.type(:package).provider(:yum)
-    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("22")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("22")
 
     expect(dnf.specificity).to be > yum.specificity
   end