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

data/spec/integration/network/formats_spec.rb

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

data/spec/integration/node/environment_spec.rb

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

data/spec/integration/node/facts_spec.rb

@@ -1,38 +1,39 @@
+#! /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
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       expect(Puppet::Node::Facts.indirection.terminus(:yaml)).to equal(Puppet::Node::Facts.indirection.terminus(:yaml))
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
-      allow(terminus).to receive(:save)
+      terminus.stubs :save
 
-      expect(Puppet::Node.indirection).to receive(:expire).with("me", be_a(Hash).or(be_nil))
+      Puppet::Node.indirection.expects(:expire).with("me", optionally(instance_of(Hash)))
 
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.indirection.save(facts)
     end
 
     it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
-      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)
+      terminus.expects(:path).with("me").returns "/my/yaml/file"
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
 
       expect(Puppet::Node::Facts.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :facter terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :facter
 
-      expect(Facter).to receive(:to_hash).and_return("facter_hash")
+      Facter.expects(:to_hash).returns "facter_hash"
       facts = Puppet::Node::Facts.new("me")
-      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
+      Puppet::Node::Facts.expects(:new).with("me", "facter_hash").returns facts
 
       expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
     end

data/spec/integration/node_spec.rb

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

data/spec/integration/parser/catalog_spec.rb

@@ -13,14 +13,18 @@ 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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -14,7 +15,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
-    allow(Time).to receive(:now).and_return(now)
+    Time.stubs(:now).returns(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 => double('source'))
+    @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('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
 
-      expect_any_instance_of(Puppet::Parser::Resource::Catalog).to receive(:to_resource) do |catalog|
-        expect(Puppet.lookup(:current_environment).name).to eq(:production)
+      Puppet::Parser::Resource::Catalog.any_instance.expects(:to_resource).with do |catalog|
+        Puppet.lookup(:current_environment).name == :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)
-      allow(Time).to receive(:now).and_return(first_time)
+      Time.stubs(:now).returns(first_time)
       node = Puppet::Node.new('mynode')
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
-      allow(Time).to receive(:now).and_return(second_time)
+      Time.stubs(:now).returns(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
-    expect(Puppet).not_to receive(:deprecation_warning)
+    Puppet.expects(:deprecation_warning).never
   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
-    allow(Puppet::DataBinding.indirection).to receive(:find)
+    Puppet::DataBinding.indirection.stubs(:find)
   end
 
   def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 test_title = 'Integration Tests for Puppet::Type::Service::Provider::Init'
@@ -7,7 +8,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? do
 
   describe "when running on FreeBSD" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
+      Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'
     end
 
     it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
@@ -17,7 +18,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? do
 
   describe "when running on HP-UX" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
+      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
     end
 
     it "should set its default path to include /sbin/init.d" do
@@ -27,7 +28,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? do
 
   describe "when running on Archlinux" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
+      Facter.stubs(:value).with(:operatingsystem).returns 'Archlinux'
     end
 
     it "should set its default path to include /etc/rc.d" do
@@ -37,7 +38,7 @@ describe test_title, unless: Puppet::Util::Platform.jruby? do
 
   describe "when not running on FreeBSD, HP-UX or Archlinux" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
+      Facter.stubs(:value).with(:operatingsystem).returns 'RedHat'
     end
 
     it "should set its default path to include /etc/init.d" do

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

@@ -1,3 +1,5 @@
+#! /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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 test_title = 'Integration Tests for Puppet::Type::Service::Provider::Windows'
@@ -8,7 +9,7 @@ describe test_title, '(integration)', :if => Puppet::Util::Platform.windows? do
   require 'puppet/util/windows'
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns 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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/reference'
@@ -14,7 +15,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.
-    allow(Puppet::Util::Execution).to receive(:execute)
+    Puppet::Util::Execution.stubs(:execute)
 
     reference.to_markdown
   end

data/spec/integration/reports_spec.rb

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

data/spec/integration/resource/catalog_spec.rb

@@ -1,46 +1,49 @@
+#! /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.
-      allow(Facter).to receive(:to_hash).and_return({"hostname" => "foo.domain.com"})
-      allow(Facter).to receive(:value).and_return("eh")
+      Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
+      Facter.stubs(:value).returns("eh")
     end
 
+
     it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
-      expect(terminus).to receive(:path).with("me").and_return("/my/yaml/file")
+      terminus.expects(:path).with("me").returns "/my/yaml/file"
 
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :compiler terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:compiler)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :compiler
 
       # Load now, before we stub the exists? method.
       compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
-      node = double('node', :add_server_facts => nil, :trusted_data= => nil, :environment => nil)
+      node = mock 'node'
+      node.stub_everything
 
-      expect(Puppet::Node.indirection).to receive(:find).and_return(node)
-      expect(compiler).to receive(:compile).with(node, anything).and_return(nil)
+      Puppet::Node.indirection.expects(:find).returns(node)
+      compiler.expects(:compile).with(node, anything).returns nil
 
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should pass provided node information directly to the terminus" do
-      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) }
+      terminus = mock 'terminus'
 
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus).and_return(terminus)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus).returns 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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -12,12 +13,12 @@ describe Puppet::Resource::TypeCollection do
       FileUtils.mkdir_p @dir
 
       loader = Object.new
-      allow(loader).to receive(:load).and_return(nil)
-      allow(loader).to receive(:set_entry)
+      loader.stubs(:load).returns nil
+      loader.stubs(:set_entry)
 
       loaders = Object.new
-      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)
+      loaders.expects(:runtime3_type_loader).at_most_once.returns loader
+      Puppet::Pops::Loaders.expects(:loaders).at_most_once.returns loaders
 
       environment = Puppet::Node::Environment.create(:env, [@dir])
       @code = environment.known_resource_types

data/spec/integration/ssl/certificate_request_spec.rb

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

data/spec/integration/ssl/host_spec.rb

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

data/spec/integration/ssl/key_spec.rb

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

data/spec/integration/test/test_helper_spec.rb

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