puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/type/filebucket_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:filebucket) do
@@ -77,26 +76,26 @@ describe Puppet::Type.type(:filebucket) do
 
   describe "when creating the filebucket" do
     before do
-      @bucket = stub 'bucket', :name= => nil
+      @bucket = double('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
-      Puppet::FileBucket::Dipper.expects(:new).with(:Path => path).returns @bucket
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Path => path).and_return(@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
-      Puppet::FileBucket::Dipper.expects(:new).with(:Server => "myserv", :Port => "myport").returns @bucket
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => "myserv", :Port => "myport").and_return(@bucket)
       bucket.bucket
     end
 
     it "should not try to guess server or port 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']
-      Puppet::FileBucket::Dipper.expects(:new).with(:Server => nil, :Port => nil).returns @bucket
+      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
       bucket.bucket

data/spec/unit/type/group_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:group) do
@@ -50,20 +49,20 @@ describe Puppet::Type.type(:group) do
 
   it "should call 'create' to create the group" do
     group = @class.new(:name => "foo", :ensure => :present)
-    group.provider.expects(:create)
+    expect(group.provider).to receive(:create)
     group.parameter(:ensure).sync
   end
 
   it "should call 'delete' to remove the group" do
     group = @class.new(:name => "foo", :ensure => :absent)
-    group.provider.expects(:delete)
+    expect(group.provider).to receive(:delete)
     group.parameter(:ensure).sync
   end
 
   it "delegates the existence check to its provider" do
     provider = @class.provide(:testing) {}
     provider_instance = provider.new
-    provider_instance.expects(:exists?).returns true
+    expect(provider_instance).to receive(:exists?).and_return(true)
 
     type = @class.new(:name => "group", :provider => provider_instance)
 
@@ -71,7 +70,6 @@ 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
@@ -85,13 +83,13 @@ describe Puppet::Type.type(:group) do
     let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
     it "insync? calls members_insync?" do
-      provider_instance.expects(:members_insync?).with(['user1'], ['user1']).returns true
+      expect(provider_instance).to receive(:members_insync?).with(['user1'], ['user1']).and_return(true)
       expect(type.property(:members).insync?(['user1'])).to be_truthy
     end
 
     it "is_to_s and should_to_s call members_to_s" do
-      provider_instance.expects(:members_to_s).with(['user1', 'user2']).returns "user1 (), user2 ()"
-      provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
+      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 ()")
 
       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,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/type'
@@ -7,7 +6,7 @@ describe Puppet::Type.type(:file).attrclass(:noop) do
   include PuppetSpec::Files
 
   before do
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
     @file = Puppet::Type.newfile :path => make_absolute("/what/ever")
   end
 

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

@@ -1,10 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
-
   before do
-    Puppet::Util::Storage.stubs(:store)
+    allow(Puppet::Util::Storage).to receive(:store)
   end
 
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
@@ -19,66 +17,81 @@ describe Puppet::Type.type(:package) do
 
   context "when validating attribute values" do
     let(:provider) do
-      stub( 'provider',
-            :class => described_class.defaultprovider,
-            :clear => nil,
-            :validate_source => false )
+      double('provider',
+             :class => described_class.defaultprovider,
+             :clear => nil,
+             :validate_source => false)
     end
+
     before do
-      provider.class.stubs(:supports_parameter?).returns(true)
-      described_class.defaultprovider.stubs(:new).returns(provider)
+      allow(provider.class).to receive(:supports_parameter?).and_return(true)
+      allow(described_class.defaultprovider).to receive(:new).and_return(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
-            provider.expects(:package_settings_validate).once.with(:valid_value).returns(true)
+            expect(provider).to receive(:package_settings_validate).once.with(:valid_value).and_return(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"
-            provider.expects(:package_settings_validate).once.
-              with(:invalid_value).raises(ArgumentError, msg)
+            expect(provider).to receive(:package_settings_validate).once.
+              with(:invalid_value).and_raise(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
-            provider.expects(:package_settings_munge).once.with('A').returns(:a)
+            expect(provider).to receive(:package_settings_munge).once.with('A').and_return(: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
@@ -86,47 +99,55 @@ describe Puppet::Type.type(:package) do
       end
     end
   end
+
   describe "package_settings property" do
     let(:provider) do
-      stub( 'provider',
-            :class => described_class.defaultprovider,
-            :clear => nil,
-            :validate_source => false )
+      double('provider',
+             :class => described_class.defaultprovider,
+             :clear => nil,
+             :validate_source => false)
     end
+
     before do
-      provider.class.stubs(:supports_parameter?).returns(true)
-      described_class.defaultprovider.stubs(:new).returns(provider)
+      allow(provider.class).to receive(:supports_parameter?).and_return(true)
+      allow(described_class.defaultprovider).to receive(:new).and_return(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
-          resource.provider.expects(:package_settings_insync?).once.with(:should,:is).returns :ok1
+          expect(resource.provider).to receive(:package_settings_insync?).once.with(:should,:is).and_return(: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
-          resource.provider.expects(:package_settings_should_to_s).once.with(:should,:newvalue).returns :ok2
+          expect(resource.provider).to receive(:package_settings_should_to_s).once.with(:should,:newvalue).and_return(: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
-          resource.provider.expects(:package_settings_is_to_s).once.with(:should,:currentvalue).returns :ok3
+          expect(resource.provider).to receive(:package_settings_is_to_s).once.with(:should,:currentvalue).and_return(: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
-          resource.provider.expects(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).returns :ok4
+          expect(resource.provider).to receive(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).and_return(:ok4)
           expect(resource.property(:package_settings).change_to_s(:currentvalue,:newvalue)).to be :ok4
         end
       end

data/spec/unit/type/package_spec.rb

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