puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/integration/network/formats_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/formats'

data/spec/integration/network/http/api/indirected_routes_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/api/indirected_routes'

data/spec/integration/node/environment_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'

data/spec/integration/node/facts_spec.rb

@@ -1,39 +1,38 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Node::Facts do
   describe "when using the indirector" do
     it "should expire any cached node instances when it is saved" do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
 
       expect(Puppet::Node::Facts.indirection.terminus(:yaml)).to equal(Puppet::Node::Facts.indirection.terminus(:yaml))
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
-      terminus.stubs :save
+      allow(terminus).to receive(:save)
 
-      Puppet::Node.indirection.expects(:expire).with("me", optionally(instance_of(Hash)))
+      expect(Puppet::Node.indirection).to receive(:expire).with("me", be_a(Hash).or(be_nil))
 
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.indirection.save(facts)
     end
 
     it "should be able to delegate to the :yaml terminus" do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
-      terminus.expects(:path).with("me").returns "/my/yaml/file"
-      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
+      expect(terminus).to receive(:path).with("me").and_return("/my/yaml/file")
+      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
 
       expect(Puppet::Node::Facts.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :facter terminus" do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :facter
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
 
-      Facter.expects(:to_hash).returns "facter_hash"
+      expect(Facter).to receive(:to_hash).and_return("facter_hash")
       facts = Puppet::Node::Facts.new("me")
-      Puppet::Node::Facts.expects(:new).with("me", "facter_hash").returns facts
+      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
 
       expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
     end

data/spec/integration/node_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/node'
@@ -14,14 +13,14 @@ describe Puppet::Node do
     end
 
     it "should be able to use the yaml terminus" do
-      Puppet::Node.indirection.stubs(:terminus_class).returns :yaml
+      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:yaml)
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node.indirection.terminus(:yaml)
 
-      terminus.expects(:path).with(@name).returns "/my/yaml/file"
+      expect(terminus).to receive(:path).with(@name).and_return("/my/yaml/file")
 
-      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
+      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
       expect(Puppet::Node.indirection.find(@name)).to be_nil
     end
 
@@ -30,12 +29,12 @@ describe Puppet::Node do
     end
 
     it "should be able to use the plain terminus" do
-      Puppet::Node.indirection.stubs(:terminus_class).returns :plain
+      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:plain)
 
       # Load now, before we stub the exists? method.
       Puppet::Node.indirection.terminus(:plain)
 
-      Puppet::Node.expects(:new).with(@name).returns @node
+      expect(Puppet::Node).to receive(:new).with(@name).and_return(@node)
 
       expect(Puppet::Node.indirection.find(@name)).to equal(@node)
     end
@@ -44,7 +43,7 @@ describe Puppet::Node do
       before do
         @name = "me"
         @terminus = Puppet::Node.indirection.terminus(:memory)
-        Puppet::Node.indirection.stubs(:terminus).returns @terminus
+        allow(Puppet::Node.indirection).to receive(:terminus).and_return(@terminus)
         @node = Puppet::Node.new(@name)
       end
 

data/spec/integration/parser/catalog_spec.rb

@@ -11,8 +11,11 @@ describe "A catalog" do
     let(:node) { Puppet::Node.new('test', :environment => env) }
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
+    before(:each) do
+      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
+    end
+
     around :each do |example|
-      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
       Puppet.override(:loaders => loaders, :current_environment => env) do
         example.run
         Puppet::Pops::Loaders.clear
@@ -20,7 +23,6 @@ describe "A catalog" do
     end
 
     context "when transmitted to the agent" do
-
       it "preserves the order in which the resources are added to the catalog" do
         resources_in_declaration_order = ["Class[First]",
                                           "Second[position]",

data/spec/integration/parser/collection_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -15,7 +14,7 @@ describe 'collectors' do
   def warnings
     @logs.select { |log| log.level == :warning }.map { |log| log.message }
   end
-  
+
   context "virtual resource collection" do
     it "matches everything when no query given" do
       expect_the_message_to_be(["the other message", "the message"], <<-MANIFEST)

data/spec/integration/parser/compiler_spec.rb

@@ -72,14 +72,14 @@ describe Puppet::Parser::Compiler do
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
-    Time.stubs(:now).returns(now)
+    allow(Time).to receive(:now).and_return(now)
 
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
-    @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
+    @scope = Puppet::Parser::Scope.new(@compiler, :source => double('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
@@ -145,8 +145,8 @@ describe Puppet::Parser::Compiler do
           }
         MANIFEST
 
-      Puppet::Parser::Resource::Catalog.any_instance.expects(:to_resource).with do |catalog|
-        Puppet.lookup(:current_environment).name == :production
+      expect_any_instance_of(Puppet::Parser::Resource::Catalog).to receive(:to_resource) do |catalog|
+        expect(Puppet.lookup(:current_environment).name).to eq(:production)
       end
 
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
@@ -447,10 +447,10 @@ describe Puppet::Parser::Compiler do
       Puppet[:code] = 'class foo { }'
       first_time = Time.at(1)
       second_time = Time.at(200)
-      Time.stubs(:now).returns(first_time)
+      allow(Time).to receive(:now).and_return(first_time)
       node = Puppet::Node.new('mynode')
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
-      Time.stubs(:now).returns(second_time)
+      allow(Time).to receive(:now).and_return(second_time)
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
       Puppet[:code] = nil
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)

data/spec/integration/parser/scope_spec.rb

@@ -14,7 +14,7 @@ describe "Two step scoping for variables" do
   end
 
   before :each do
-    Puppet.expects(:deprecation_warning).never
+    expect(Puppet).not_to receive(:deprecation_warning)
   end
 
   describe "using unsupported operators" do

data/spec/integration/parser/undef_param_spec.rb

@@ -7,7 +7,7 @@ describe "Parameter passing" do
   before :each do
     # DataBinding will be consulted before falling back to a default value,
     # but we aren't testing that here
-    Puppet::DataBinding.indirection.stubs(:find)
+    allow(Puppet::DataBinding.indirection).to receive(:find)
   end
 
   def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))

data/spec/integration/provider/cron/crontab_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 require 'puppet_spec/compiler'
@@ -9,17 +7,17 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
   include PuppetSpec::Compiler
 
   before :each do
-    Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
-    described_class.stubs(:suitable?).returns true
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to filebucket
+    allow(Puppet::Type.type(:cron)).to receive(:defaultprovider).and_return(described_class)
+    allow(described_class).to receive(:suitable?).and_return(true)
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # Don't backup to filebucket
 
     # I don't want to execute anything
-    described_class.stubs(:filetype).returns Puppet::Util::FileType::FileTypeFlat
-    described_class.stubs(:default_target).returns crontab_user1
+    allow(described_class).to receive(:filetype).and_return(Puppet::Util::FileType::FileTypeFlat)
+    allow(described_class).to receive(:default_target).and_return(crontab_user1)
 
     # I don't want to stub Time.now to get a static header because I don't know
     # where Time.now is used elsewhere, so just go with a very simple header
-    described_class.stubs(:header).returns "# HEADER: some simple\n# HEADER: header\n"
+    allow(described_class).to receive(:header).and_return("# HEADER: some simple\n# HEADER: header\n")
     FileUtils.cp(my_fixture('crontab_user1'), crontab_user1)
     FileUtils.cp(my_fixture('crontab_user2'), crontab_user2)
   end
@@ -117,9 +115,9 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
           MANIFEST
           apply_compiled_manifest(manifest) do |res|
             if res.ref == 'Cron[Entirely new resource]'
-              res.expects(:err).with(regexp_matches(/no command/))
+              expect(res).to receive(:err).with(/no command/)
             else
-              res.expects(:err).never
+              expect(res).not_to receive(:err)
             end
           end
         end

data/spec/integration/provider/mailalias/aliases_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 

data/spec/integration/provider/mount_spec.rb

@@ -20,13 +20,13 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     @current_options = "local"
     @current_device = "/dev/disk1s1"
     Puppet[:digest_algorithm] = 'md5' 
-    Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
-    Facter.stubs(:value).with(:hostname).returns('some_host')
-    Facter.stubs(:value).with(:domain).returns('some_domain')
-    Facter.stubs(:value).with(:kernel).returns('Linux')
-    Facter.stubs(:value).with(:operatingsystem).returns('RedHat')
-    Facter.stubs(:value).with(:osfamily).returns('RedHat')
-    Facter.stubs(:value).with(:fips_enabled).returns(false)
+    allow(Puppet::Type.type(:mount).defaultprovider).to receive(:default_target).and_return(@fake_fstab)
+    allow(Facter).to receive(:value).with(:hostname).and_return('some_host')
+    allow(Facter).to receive(:value).with(:domain).and_return('some_domain')
+    allow(Facter).to receive(:value).with(:kernel).and_return('Linux')
+    allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
+    allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+    allow(Facter).to receive(:value).with(:fips_enabled).and_return(false)
     Puppet::Util::ExecutionStub.set do |command, options|
       case command[0]
       when %r{/s?bin/mount}
@@ -75,8 +75,8 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
   def run_in_catalog(settings)
     resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
                                              :device => "/dev/disk1s1", :fstype => "msdos"))
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
-    resource.expects(:err).never
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # Don't backup to the filebucket
+    expect(resource).not_to receive(:err)
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false # Stop Puppet from doing a bunch of magic
     catalog.add_resource resource

data/spec/integration/provider/service/init_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 provider = Puppet::Type.type(:service).provider(:init)
@@ -6,7 +5,7 @@ provider = Puppet::Type.type(:service).provider(:init)
 describe provider do
   describe "when running on FreeBSD" do
     before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
     end
 
     it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
@@ -16,7 +15,7 @@ describe provider do
 
   describe "when running on HP-UX" do
     before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
     end
 
     it "should set its default path to include /sbin/init.d" do
@@ -26,7 +25,7 @@ describe provider do
 
   describe "when running on Archlinux" do
     before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'Archlinux'
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
     end
 
     it "should set its default path to include /etc/rc.d" do
@@ -36,7 +35,7 @@ describe provider do
 
   describe "when not running on FreeBSD, HP-UX or Archlinux" do
     before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'RedHat'
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
     end
 
     it "should set its default path to include /etc/init.d" do

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:systemd), '(integration)' do

data/spec/integration/provider/service/windows_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:windows), '(integration)',
@@ -7,7 +6,7 @@ describe Puppet::Type.type(:service).provider(:windows), '(integration)',
   require 'puppet/util/windows'
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_class)
   end
 
   context 'should return valid values when querying a service that does not exist' do

data/spec/integration/provider/ssh_authorized_key_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 
@@ -47,9 +45,9 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
   end
 
   before :each do
-    File.stubs(:chown)
-    File.stubs(:chmod)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    allow(File).to receive(:chown)
+    allow(File).to receive(:chmod)
+    allow(Puppet::Util::SUIDManager).to receive(:asuser).and_yield
   end
 
   after :each do
@@ -72,18 +70,18 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
   end
 
   def run_in_catalog(*resources)
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # Don't backup to the filebucket
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     resources.each do |resource|
-      resource.expects(:err).never
+      expect(resource).not_to receive(:err)
       catalog.add_resource(resource)
     end
     catalog.apply
   end
 
   it "should not complain about empty lines and comments" do
-    described_class.expects(:flush).never
+    expect(described_class).not_to receive(:flush)
     sample = ['',sample_lines[0],'   ',sample_lines[1],'# just a comment','#and another']
     create_fake_key(:user,sample)
     run_in_catalog(dummy)

data/spec/integration/provider/sshkey_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 require 'puppet_spec/files'
@@ -12,10 +10,10 @@ describe Puppet::Type.type(:sshkey).provider(:parsed), '(integration)',
 
   before :each do
     # Don't backup to filebucket
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup)
     # We don't want to execute anything
-    described_class.stubs(:filetype).
-      returns Puppet::Util::FileType::FileTypeFlat
+    allow(described_class).to receive(:filetype).
+      and_return(Puppet::Util::FileType::FileTypeFlat)
 
     @sshkey_file = tmpfile('sshkey_integration_specs')
     FileUtils.cp(my_fixture('sample'), @sshkey_file)
@@ -145,15 +143,11 @@ describe Puppet::Type.type(:sshkey).provider(:parsed), '(integration)',
     it "should fetch an entry from resources" do
       @resource_app = Puppet::Application[:resource]
       @resource_app.preinit
-      @resource_app.command_line.stubs(:args).
-        returns([type_under_test, sshkey_name, "target=#{@sshkey_file}"])
+      allow(@resource_app.command_line).to receive(:args).
+        and_return([type_under_test, sshkey_name, "target=#{@sshkey_file}"])
 
-      @resource_app.expects(:puts).with do |args|
-        expect(args).to match(/#{sshkey_name}/)
-      end
+      expect(@resource_app).to receive(:puts).with(/#{sshkey_name}/)
       @resource_app.main
     end
-
   end
-
 end

data/spec/integration/provider/yumrepo_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 require 'puppet_spec/files'
@@ -12,18 +10,18 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
 
   before :each do
     # Don't backup to filebucket
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup)
     # We don't want to execute anything
-    described_class.stubs(:filetype).
-      returns Puppet::Util::FileType::FileTypeFlat
+    allow(described_class).to receive(:filetype).
+      and_return(Puppet::Util::FileType::FileTypeFlat)
 
     @yumrepo_dir  = tmpdir('yumrepo_integration_specs')
     @yumrepo_file = tmpfile('yumrepo_file', @yumrepo_dir)
     @yumrepo_conf_file = tmpfile('yumrepo_conf_file', @yumrepo_dir)
     # this mocks the reposdir logic in the provider and thus won't test for
     # issues like PUP-2916. Cover these types of issues in acceptance
-    described_class.stubs(:reposdir).returns [@yumrepo_dir]
-    described_class.stubs(:repofiles).returns [@yumrepo_conf_file]
+    allow(described_class).to receive(:reposdir).and_return([@yumrepo_dir])
+    allow(described_class).to receive(:repofiles).and_return([@yumrepo_conf_file])
   end
 
   after :each do
@@ -118,12 +116,10 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
     it "should fetch the yumrepo entries from resource face" do
       @resource_app = Puppet::Application[:resource]
       @resource_app.preinit
-      @resource_app.command_line.stubs(:args).
-        returns([type_under_test, super_creative])
+      allow(@resource_app.command_line).to receive(:args).
+        and_return([type_under_test, super_creative])
 
-      @resource_app.expects(:puts).with  do |args|
-        expect(args).to match(/#{super_creative}/)
-      end
+      allow(@resource_app).to receive(:puts).with(/#{super_creative}/)
       @resource_app.main
     end
   end