puppet 6.4.0-universal-darwin → 6.4.1-universal-darwin

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_pool_spec.rb

@@ -97,7 +97,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
           expect {
             http.get('/')
           }.to raise_error(Puppet::Error,
-                           %r{certificate verify failed.* .self signed certificate in certificate chain for /CN=Test CA.})
+                           %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
         end
       end
     end
@@ -166,12 +166,12 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         expect {
           http.get('/')
         }.to raise_error(Puppet::Error,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for /CN=Test CA.})
+                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
       end
     end
 
     it "warns when client has an incomplete client cert chain" do
-      Puppet.expects(:warning).with("The issuer '/CN=Test CA Agent Subauthority' of certificate '/CN=pluto' cannot be found locally")
+      expect(Puppet).to receive(:warning).with("The issuer 'CN=Test CA Agent Subauthority' of certificate 'CN=pluto' cannot be found locally")
 
       pluto = cert_fixture('pluto.pem')
 

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,24 +13,24 @@ 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
 
     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
@@ -40,7 +39,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

@@ -13,18 +13,14 @@ describe "A catalog" do
 
     before(:each) do
       Puppet.push_context({:loaders => loaders, :current_environment => env})
+      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
     end
 
     after(:each) do
       Puppet.pop_context()
     end
 
-    before(:each) do
-      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
-    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/service/init_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 test_title = 'Integration Tests for Puppet::Type::Service::Provider::Init'
@@ -8,7 +7,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? 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
@@ -18,7 +17,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? 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
@@ -28,7 +27,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? 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
@@ -38,7 +37,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? 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'
 
 test_title = 'Integration Tests for Puppet::Type::Service::Provider::Systemd'

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 test_title = 'Integration Tests for Puppet::Type::Service::Provider::Windows'
@@ -9,7 +8,7 @@ describe test_title, '(integration)', :if => Puppet::Util::Platform.windows? do
   require 'puppet/util/windows'
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
   end
 
   context 'should return valid values when querying a service that does not exist' do

data/spec/integration/reference/providers_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/reference'
@@ -15,7 +14,7 @@ describe reference do
     # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
     # This is only an issue if you're running these unit tests on a platform where upstart
     # is a default provider, like Ubuntu trusty.
-    Puppet::Util::Execution.stubs(:execute)
+    allow(Puppet::Util::Execution).to receive(:execute)
 
     reference.to_markdown
   end

data/spec/integration/reports_spec.rb

@@ -1,11 +1,10 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
 
 describe Puppet::Reports, " when using report types" do
   before do
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
   end
 
   it "should load report types as modules" do

data/spec/integration/resource/catalog_spec.rb

@@ -1,49 +1,46 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog do
   describe "when using the indirector" do
     before do
       # This is so the tests work w/out networking.
-      Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
-      Facter.stubs(:value).returns("eh")
+      allow(Facter).to receive(:to_hash).and_return({"hostname" => "foo.domain.com"})
+      allow(Facter).to receive(:value).and_return("eh")
     end
 
-
     it "should be able to delegate to the :yaml terminus" do
-      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :yaml
+      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:yaml)
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
-      terminus.expects(:path).with("me").returns "/my/yaml/file"
+      expect(terminus).to receive(:path).with("me").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::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :compiler terminus" do
-      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :compiler
+      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:compiler)
 
       # Load now, before we stub the exists? method.
       compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
-      node = mock 'node'
-      node.stub_everything
+      node = double('node', :add_server_facts => nil, :trusted_data= => nil, :environment => nil)
 
-      Puppet::Node.indirection.expects(:find).returns(node)
-      compiler.expects(:compile).with(node, anything).returns nil
+      expect(Puppet::Node.indirection).to receive(:find).and_return(node)
+      expect(compiler).to receive(:compile).with(node, anything).and_return(nil)
 
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should pass provided node information directly to the terminus" do
-      terminus = mock 'terminus'
+      node = double('node')
+      terminus = double('terminus')
+      allow(terminus).to receive(:validate)
+      expect(terminus).to receive(:find) { |request| expect(request.options[:use_node]).to eq(node) }
 
-      Puppet::Resource::Catalog.indirection.stubs(:terminus).returns terminus
+      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus).and_return(terminus)
 
-      node = mock 'node'
-      terminus.stubs(:validate)
-      terminus.expects(:find).with { |request| request.options[:use_node] == node }
       Puppet::Resource::Catalog.indirection.find("me", :use_node => node)
     end
   end

data/spec/integration/resource/type_collection_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -13,12 +12,12 @@ describe Puppet::Resource::TypeCollection do
       FileUtils.mkdir_p @dir
 
       loader = Object.new
-      loader.stubs(:load).returns nil
-      loader.stubs(:set_entry)
+      allow(loader).to receive(:load).and_return(nil)
+      allow(loader).to receive(:set_entry)
 
       loaders = Object.new
-      loaders.expects(:runtime3_type_loader).at_most_once.returns loader
-      Puppet::Pops::Loaders.expects(:loaders).at_most_once.returns loaders
+      expect(loaders).to receive(:runtime3_type_loader).at_most(:once).and_return(loader)
+      expect(Puppet::Pops::Loaders).to receive(:loaders).at_most(:once).and_return(loaders)
 
       environment = Puppet::Node::Environment.create(:env, [@dir])
       @code = environment.known_resource_types

data/spec/integration/rest/client_spec.rb

@@ -50,7 +50,7 @@ describe Puppet::Rest::Client, unless: Puppet::Util::Platform.jruby? do
       expect {
         client.get(uri)
       }.to raise_error(Puppet::Error,
-                       %r{certificate verify failed.* .self signed certificate in certificate chain for /CN=Test CA.})
+                       %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
     end
   end
 

data/spec/integration/ssl/certificate_request_spec.rb

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

data/spec/integration/ssl/host_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/test_ca'
 
@@ -16,7 +15,7 @@ describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
     Puppet.settings.use :main, :ssl
 
     @host = Puppet::SSL::Host.new("luke.madstop.com")
-    @host.stubs(:submit_certificate_request)
+    allow(@host).to receive(:submit_certificate_request)
 
     @ca = Puppet::TestCa.new
     Puppet::Util.replace_file(Puppet[:localcacert], 0644) do |f|

data/spec/integration/ssl/key_spec.rb

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

data/spec/integration/test/test_helper_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "Windows UTF8 environment variables", :if => Puppet::Util::Platform.windows? do

data/spec/integration/transaction/report_spec.rb

@@ -1,28 +1,23 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 
 describe Puppet::Transaction::Report do
   before :each do
     # Enable persistence during tests
-    Puppet::Transaction::Persistence.any_instance.stubs(:enabled?).returns(true)
+    allow_any_instance_of(Puppet::Transaction::Persistence).to receive(:enabled?).and_return(true)
   end
 
   describe "when using the indirector" do
-    after do
-      Puppet.settings.stubs(:use)
-    end
-
     it "should be able to delegate to the :processor terminus" do
-      Puppet::Transaction::Report.indirection.stubs(:terminus_class).returns :processor
+      allow(Puppet::Transaction::Report.indirection).to receive(:terminus_class).and_return(:processor)
 
       terminus = Puppet::Transaction::Report.indirection.terminus(:processor)
 
-      Facter.stubs(:value).returns "host.domain.com"
+      allow(Facter).to receive(:value).and_return("host.domain.com")
 
       report = Puppet::Transaction::Report.new
 
-      terminus.expects(:process).with(report)
+      expect(terminus).to receive(:process).with(report)
 
       Puppet::Transaction::Report.indirection.save(report)
     end
@@ -50,10 +45,10 @@ describe Puppet::Transaction::Report do
 
     def run_catalogs(resources1, resources2, noop1 = false, noop2 = false, &block)
       last_run_report = nil
-      Puppet::Transaction::Report.indirection.expects(:save).twice.with do |report, x|
+      expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
         last_run_report = report
         true
-      end
+      end.twice
 
       Puppet[:report] = true
       Puppet[:noop] = noop1