puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/spec_helper.rb

@@ -77,14 +77,7 @@ RSpec.configure do |config|
   exclude_filters[:benchmark] = true unless ENV['BENCHMARK']
   config.filter_run_excluding exclude_filters
 
-  config.filter_run_when_matching :focus
-
-  config.mock_with :rspec do |mocks|
-    # We really should have this on, but it breaks a _lot_ of tests. We'll
-    # need to go through and fix those tests first before it can be enabled
-    # for real.
-    mocks.verify_partial_doubles = false
-  end
+  config.mock_with :mocha
 
   tmpdir = Puppet::FileSystem.expand_path(Dir.mktmpdir("rspecrun"))
   oldtmpdir = Puppet::FileSystem.expand_path(Dir.tmpdir())
@@ -119,11 +112,6 @@ RSpec.configure do |config|
     # some platforms *cough* windows *cough* that are a little slower.
     GC.disable
 
-    # REVISIT: I think this conceals other bad tests, but I don't have time to
-    # fully diagnose those right now.  When you read this, please come tell me
-    # I suck for letting this float. --daniel 2011-04-21
-    allow(Signal).to receive(:trap)
-
     # TODO: in a more sane world, we'd move this logging redirection into our TestHelper class.
     #  Without doing so, external projects will all have to roll their own solution for
     #  redirecting logging, and for validating expected log messages.  However, because the
@@ -134,7 +122,6 @@ RSpec.configure do |config|
     # redirecting logging away from console, because otherwise the test output will be
     #  obscured by all of the log output
     @logs = []
-    Puppet::Util::Log.close_all
     if ENV["PUPPET_TEST_LOG_LEVEL"]
       Puppet::Util::Log.level = ENV["PUPPET_TEST_LOG_LEVEL"].intern
     end
@@ -164,7 +151,6 @@ RSpec.configure do |config|
     Puppet::Test::TestHelper.after_each_test()
 
     # TODO: would like to move this into puppetlabs_spec_helper, but there are namespace issues at the moment.
-    allow(Dir).to receive(:entries).and_call_original
     PuppetSpec::Files.cleanup
 
     # TODO: this should be abstracted in the future--see comments above the '@logs' block in the

data/spec/unit/agent/disabler_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/agent'
 require 'puppet/agent/locker'
@@ -26,7 +27,7 @@ describe Puppet::Agent::Disabler do
     lockfile = File.expand_path("/my/lock.disabled")
     Puppet[:agent_disabled_lockfile] = lockfile
     lock = Puppet::Util::JsonLockfile.new(lockfile)
-    expect(Puppet::Util::JsonLockfile).to receive(:new).with(lockfile).and_return(lock)
+    Puppet::Util::JsonLockfile.expects(:new).with(lockfile).returns lock
 
     @disabler.send(:disable_lockfile)
   end
@@ -36,19 +37,19 @@ describe Puppet::Agent::Disabler do
   end
 
   it "should lock the file when disabled" do
-    expect(@disabler.send(:disable_lockfile)).to receive(:lock)
+    @disabler.send(:disable_lockfile).expects(:lock)
 
     @disabler.disable
   end
 
   it "should unlock the file when enabled" do
-    expect(@disabler.send(:disable_lockfile)).to receive(:unlock)
+    @disabler.send(:disable_lockfile).expects(:unlock)
 
     @disabler.enable
   end
 
   it "should check the lock if it is disabled" do
-    expect(@disabler.send(:disable_lockfile)).to receive(:locked?)
+    @disabler.send(:disable_lockfile).expects(:locked?)
 
     @disabler.disabled?
   end

data/spec/unit/agent/locker_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/agent'
 require 'puppet/agent/locker'
@@ -26,7 +27,7 @@ describe Puppet::Agent::Locker do
     lockfile = File.expand_path("/my/lock")
     Puppet[:agent_catalog_run_lockfile] = lockfile
     lock = Puppet::Util::Pidlock.new(lockfile)
-    expect(Puppet::Util::Pidlock).to receive(:new).with(lockfile).and_return(lock)
+    Puppet::Util::Pidlock.expects(:new).with(lockfile).returns lock
 
     @locker.send(:lockfile)
   end
@@ -42,7 +43,7 @@ describe Puppet::Agent::Locker do
   end
 
   it "should have a method that yields when a lock is attained" do
-    expect(@locker.send(:lockfile)).to receive(:lock).and_return(true)
+    @locker.send(:lockfile).expects(:lock).returns true
 
     yielded = false
     @locker.lock do
@@ -52,19 +53,19 @@ describe Puppet::Agent::Locker do
   end
 
   it "should return the block result when the lock method successfully locked" do
-    expect(@locker.send(:lockfile)).to receive(:lock).and_return(true)
+    @locker.send(:lockfile).expects(:lock).returns true
 
     expect(@locker.lock { :result }).to eq(:result)
   end
 
   it "should raise LockError when the lock method does not receive the lock" do
-    expect(@locker.send(:lockfile)).to receive(:lock).and_return(false)
+    @locker.send(:lockfile).expects(:lock).returns false
 
     expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should not yield when the lock method does not receive the lock" do
-    expect(@locker.send(:lockfile)).to receive(:lock).and_return(false)
+    @locker.send(:lockfile).expects(:lock).returns false
 
     yielded = false
     expect { @locker.lock { yielded = true } }.to raise_error(Puppet::LockError)
@@ -72,28 +73,28 @@ describe Puppet::Agent::Locker do
   end
 
   it "should not unlock when a lock was not received" do
-    expect(@locker.send(:lockfile)).to receive(:lock).and_return(false)
-    expect(@locker.send(:lockfile)).not_to receive(:unlock)
+    @locker.send(:lockfile).expects(:lock).returns false
+    @locker.send(:lockfile).expects(:unlock).never
 
     expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should unlock after yielding upon obtaining a lock" do
-    allow(@locker.send(:lockfile)).to receive(:lock).and_return(true)
-    expect(@locker.send(:lockfile)).to receive(:unlock)
+    @locker.send(:lockfile).stubs(:lock).returns true
+    @locker.send(:lockfile).expects(:unlock)
 
     @locker.lock {}
   end
 
   it "should unlock after yielding upon obtaining a lock, even if the block throws an exception" do
-    allow(@locker.send(:lockfile)).to receive(:lock).and_return(true)
-    expect(@locker.send(:lockfile)).to receive(:unlock)
+    @locker.send(:lockfile).stubs(:lock).returns true
+    @locker.send(:lockfile).expects(:unlock)
 
     expect { @locker.lock { raise "foo" } }.to raise_error(RuntimeError)
   end
 
   it "should be considered running if the lockfile is locked" do
-    expect(@locker.send(:lockfile)).to receive(:locked?).and_return(true)
+    @locker.send(:lockfile).expects(:locked?).returns true
     expect(@locker).to be_running
   end
 end

data/spec/unit/agent_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/agent'
 require 'puppet/configurer'
@@ -20,13 +21,16 @@ end
 
 describe Puppet::Agent do
   before do
-    allow(Puppet::Status.indirection).to receive(:find).and_return(Puppet::Status.new("version" => Puppet.version))
+    Puppet::Status.indirection.stubs(:find).returns Puppet::Status.new("version" => Puppet.version)
 
     @agent = Puppet::Agent.new(AgentTestClient, false)
 
+    # So we don't actually try to hit the filesystem.
+    @agent.stubs(:lock).yields
+
     # make Puppet::Application safe for stubbing; restore in an :after block; silence warnings for this.
     without_warnings { Puppet::Application = Class.new(Puppet::Application) }
-    allow(Puppet::Application).to receive(:clear?).and_return(true)
+    Puppet::Application.stubs(:clear?).returns(true)
     Puppet::Application.class_eval do
       class << self
         def controlled_run(&block)
@@ -50,212 +54,205 @@ describe Puppet::Agent do
   end
 
   it "should create an instance of its client class and run it when asked to run" do
-    client = double('client')
-    expect(AgentTestClient).to receive(:new).and_return(client)
+    client = mock 'client'
+    AgentTestClient.expects(:new).returns client
 
-    expect(client).to receive(:run)
+    client.expects(:run)
 
-    allow(@agent).to receive(:disabled?).and_return(false)
+    @agent.stubs(:disabled?).returns false
     @agent.run
   end
 
   it "should initialize the client's transaction_uuid if passed as a client_option" do
-    client = double('client')
+    client = mock 'client'
     transaction_uuid = 'foo'
-    expect(AgentTestClient).to receive(:new).with(transaction_uuid, nil).and_return(client)
+    AgentTestClient.expects(:new).with(transaction_uuid, nil).returns client
 
-    expect(client).to receive(:run)
+    client.expects(:run)
 
-    allow(@agent).to receive(:disabled?).and_return(false)
+    @agent.stubs(:disabled?).returns false
     @agent.run(:transaction_uuid => transaction_uuid)
   end
 
   it "should initialize the client's job_id if passed as a client_option" do
-    client = double('client')
+    client = mock 'client'
     job_id = '289'
-    expect(AgentTestClient).to receive(:new).with(anything, job_id).and_return(client)
+    AgentTestClient.expects(:new).with(anything, job_id).returns client
 
-    expect(client).to receive(:run)
+    client.expects(:run)
 
-    allow(@agent).to receive(:disabled?).and_return(false)
+    @agent.stubs(:disabled?).returns false
     @agent.run(:job_id => job_id)
   end
 
   it "should be considered running if the lock file is locked" do
-    lockfile = double('lockfile')
+    lockfile = mock 'lockfile'
 
-    expect(@agent).to receive(:lockfile).and_return(lockfile)
-    expect(lockfile).to receive(:locked?).and_return(true)
+    @agent.expects(:lockfile).returns(lockfile)
+    lockfile.expects(:locked?).returns true
 
     expect(@agent).to be_running
   end
 
   describe "when being run" do
     before do
-      allow(AgentTestClient).to receive(:lockfile_path).and_return("/my/lock")
-      allow(@agent).to receive(:disabled?).and_return(false)
+      AgentTestClient.stubs(:lockfile_path).returns "/my/lock"
+      @agent.stubs(:disabled?).returns false
     end
 
     it "should splay" do
-      expect(@agent).to receive(:splay)
+      @agent.expects(:splay)
 
       @agent.run
     end
 
     it "should do nothing if disabled" do
-      expect(@agent).to receive(:disabled?).and_return(true)
-      expect(AgentTestClient).not_to receive(:new)
+      @agent.expects(:disabled?).returns(true)
+      AgentTestClient.expects(:new).never
       @agent.run
     end
 
     it "(#11057) should notify the user about why a run is skipped" do
-      allow(Puppet::Application).to receive(:controlled_run).and_return(false)
-      allow(Puppet::Application).to receive(:run_status).and_return('MOCK_RUN_STATUS')
+      Puppet::Application.stubs(:controlled_run).returns(false)
+      Puppet::Application.stubs(:run_status).returns('MOCK_RUN_STATUS')
       # This is the actual test that we inform the user why the run is skipped.
       # We assume this information is contained in
       # Puppet::Application.run_status
-      expect(Puppet).to receive(:notice).with(/MOCK_RUN_STATUS/)
+      Puppet.expects(:notice).with(regexp_matches(/MOCK_RUN_STATUS/))
       @agent.run
     end
 
     it "should display an informative message if the agent is administratively disabled" do
-      expect(@agent).to receive(:disabled?).and_return(true)
-      expect(@agent).to receive(:disable_message).and_return("foo")
-      expect(Puppet).to receive(:notice).with(/Skipping run of .*; administratively disabled.*\(Reason: 'foo'\)/)
+      @agent.expects(:disabled?).returns true
+      @agent.expects(:disable_message).returns "foo"
+      Puppet.expects(:notice).with(regexp_matches(/Skipping run of .*; administratively disabled.*\(Reason: 'foo'\)/))
       @agent.run
     end
 
     it "should use Puppet::Application.controlled_run to manage process state behavior" do
-      expect(Puppet::Application).to receive(:controlled_run).ordered.and_yield
-      expect(AgentTestClient).to receive(:new).ordered.once
+      calls = sequence('calls')
+      Puppet::Application.expects(:controlled_run).yields.in_sequence(calls)
+      AgentTestClient.expects(:new).once.in_sequence(calls)
       @agent.run
     end
 
     it "should not fail if a client class instance cannot be created" do
-      expect(AgentTestClient).to receive(:new).and_raise("eh")
-      expect(Puppet).to receive(:err)
+      AgentTestClient.expects(:new).raises "eh"
+      Puppet.expects(:err)
       @agent.run
     end
 
     it "should not fail if there is an exception while running its client" do
       client = AgentTestClient.new
-      expect(AgentTestClient).to receive(:new).and_return(client)
-      expect(client).to receive(:run).and_raise("eh")
-      expect(Puppet).to receive(:err)
+      AgentTestClient.expects(:new).returns client
+      client.expects(:run).raises "eh"
+      Puppet.expects(:err)
       @agent.run
     end
 
     it "should use a filesystem lock to restrict multiple processes running the agent" do
       client = AgentTestClient.new
-      expect(AgentTestClient).to receive(:new).and_return(client)
+      AgentTestClient.expects(:new).returns client
 
-      expect(@agent).to receive(:lock)
+      @agent.expects(:lock)
 
-      expect(client).not_to receive(:run) # if it doesn't run, then we know our yield is what triggers it
+      client.expects(:run).never # if it doesn't run, then we know our yield is what triggers it
       @agent.run
     end
 
     it "should make its client instance available while running" do
       client = AgentTestClient.new
-      expect(AgentTestClient).to receive(:new).and_return(client)
+      AgentTestClient.expects(:new).returns client
 
-      expect(client).to receive(:run) { expect(@agent.client).to equal(client); nil }
+      client.expects(:run).with { expect(@agent.client).to equal(client); true }
       @agent.run
     end
 
     it "should run the client instance with any arguments passed to it" do
       client = AgentTestClient.new
-      expect(AgentTestClient).to receive(:new).and_return(client)
+      AgentTestClient.expects(:new).returns client
 
-      expect(client).to receive(:run).with(:pluginsync => true, :other => :options)
+      client.expects(:run).with(:pluginsync => true, :other => :options)
       @agent.run(:other => :options)
     end
 
     it "should return the agent result" do
       client = AgentTestClient.new
-      expect(AgentTestClient).to receive(:new).and_return(client)
+      AgentTestClient.expects(:new).returns client
 
-      expect(@agent).to receive(:lock).and_return(:result)
+      @agent.expects(:lock).returns(:result)
       expect(@agent.run).to eq(:result)
     end
 
-    describe "when should_fork is true", :if => Puppet.features.posix? do
+    describe "when should_fork is true", :if => Puppet.features.posix? && RUBY_PLATFORM != 'java' do
       before do
         @agent = Puppet::Agent.new(AgentTestClient, true)
 
         # So we don't actually try to hit the filesystem.
-        allow(@agent).to receive(:lock).and_yield
+        @agent.stubs(:lock).yields
+
+        Kernel.stubs(:fork)
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 0)]
+        @agent.stubs(:exit)
       end
 
       it "should run the agent in a forked process" do
         client = AgentTestClient.new
-        expect(AgentTestClient).to receive(:new).and_return(client)
+        AgentTestClient.expects(:new).returns client
 
-        expect(client).to receive(:run).and_return(0)
+        client.expects(:run)
 
-        expect(Kernel).to receive(:fork).and_yield
-        expect { @agent.run }.to exit_with(0)
+        Kernel.expects(:fork).yields
+        @agent.run
       end
 
       it "should exit child process if child exit" do
         client = AgentTestClient.new
-        expect(AgentTestClient).to receive(:new).and_return(client)
+        AgentTestClient.expects(:new).returns client
 
-        expect(client).to receive(:run).and_raise(SystemExit.new(-1))
+        client.expects(:run).raises(SystemExit)
 
-        expect(Kernel).to receive(:fork).and_yield
-        expect { @agent.run }.to exit_with(-1)
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(-1)
+        @agent.run
       end
 
       it 'should exit with 1 if an exception is raised' do
         client = AgentTestClient.new
-        expect(AgentTestClient).to receive(:new).and_return(client)
+        AgentTestClient.expects(:new).returns client
 
-        expect(client).to receive(:run).and_raise(StandardError)
+        client.expects(:run).raises(StandardError)
 
-        expect(Kernel).to receive(:fork).and_yield
-        expect { @agent.run }.to exit_with(1)
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(1)
+        @agent.run
       end
 
-      it 'should exit with 254 if NoMemoryError exception is raised' do
-        client = AgentTestClient.new
-        expect(AgentTestClient).to receive(:new).and_return(client)
-
-        expect(client).to receive(:run).and_raise(NoMemoryError)
-
-        expect(Kernel).to receive(:fork).and_yield
-        expect { @agent.run }.to exit_with(254)
+      it "should re-raise exit happening in the child" do
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -1)]
+        expect { @agent.run }.to raise_error(SystemExit)
       end
 
-      it "should return the block exit code as the child exit code" do
-        expect(Kernel).to receive(:fork).and_yield
-        expect {
-          @agent.run_in_fork {
-            777
-          }
-        }.to exit_with(777)
+      it "should re-raise NoMoreMemory happening in the child" do
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -2)]
+        expect { @agent.run }.to raise_error(NoMemoryError)
       end
 
-      it "should return `1` exit code if the block returns `nil`" do
-        expect(Kernel).to receive(:fork).and_yield
-        expect {
-          @agent.run_in_fork {
-            nil
-          }
-        }.to exit_with(1)
+      it "should return the child exit code" do
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 777)]
+        expect(@agent.run).to eq(777)
       end
 
-      it "should return `1` exit code if the block returns `false`" do
-        expect(Kernel).to receive(:fork).and_yield
-        expect {
-          @agent.run_in_fork {
-            false
-          }
-        }.to exit_with(1)
+      it "should return the block exit code as the child exit code" do
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(777)
+        @agent.run_in_fork {
+          777
+        }
       end
     end
 
-    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows", :if => Puppet::Util::Platform.windows? do
       it "should never fork" do
         agent = Puppet::Agent.new(AgentTestClient, true)
         expect(agent.should_fork).to be_falsey
@@ -285,13 +282,13 @@ describe Puppet::Agent do
           end
         end
 
-        expect(AgentTestClient).to receive(:new).and_return(client)
+        AgentTestClient.expects(:new).returns client
 
-        expect(client).not_to receive(:processing)
-        expect(client).not_to receive(:handling)
-        expect(Puppet).to receive(:log_exception).with(be_an_instance_of(Puppet::Agent::RunTimeoutError), anything)
+        client.expects(:processing).never
+        client.expects(:handling).never
+        Puppet.expects(:log_exception).with(instance_of(Puppet::Agent::RunTimeoutError), anything)
 
-        expect(@agent.run).to eq(nil)
+        expect(@agent.run).to eq(1)
       end
     end
   end
@@ -299,10 +296,10 @@ describe Puppet::Agent do
   describe "when checking execution state" do
     describe 'with regular run status' do
       before :each do
-        allow(Puppet::Application).to receive(:restart_requested?).and_return(false)
-        allow(Puppet::Application).to receive(:stop_requested?).and_return(false)
-        allow(Puppet::Application).to receive(:interrupted?).and_return(false)
-        allow(Puppet::Application).to receive(:clear?).and_return(true)
+        Puppet::Application.stubs(:restart_requested?).returns(false)
+        Puppet::Application.stubs(:stop_requested?).returns(false)
+        Puppet::Application.stubs(:interrupted?).returns(false)
+        Puppet::Application.stubs(:clear?).returns(true)
       end
 
       it 'should be false for :stopping?' do
@@ -316,10 +313,10 @@ describe Puppet::Agent do
 
     describe 'with a stop requested' do
       before :each do
-        allow(Puppet::Application).to receive(:clear?).and_return(false)
-        allow(Puppet::Application).to receive(:restart_requested?).and_return(false)
-        allow(Puppet::Application).to receive(:stop_requested?).and_return(true)
-        allow(Puppet::Application).to receive(:interrupted?).and_return(true)
+        Puppet::Application.stubs(:clear?).returns(false)
+        Puppet::Application.stubs(:restart_requested?).returns(false)
+        Puppet::Application.stubs(:stop_requested?).returns(true)
+        Puppet::Application.stubs(:interrupted?).returns(true)
       end
 
       it 'should be true for :stopping?' do
@@ -333,10 +330,10 @@ describe Puppet::Agent do
 
     describe 'with a restart requested' do
       before :each do
-        allow(Puppet::Application).to receive(:clear?).and_return(false)
-        allow(Puppet::Application).to receive(:restart_requested?).and_return(true)
-        allow(Puppet::Application).to receive(:stop_requested?).and_return(false)
-        allow(Puppet::Application).to receive(:interrupted?).and_return(true)
+        Puppet::Application.stubs(:clear?).returns(false)
+        Puppet::Application.stubs(:restart_requested?).returns(true)
+        Puppet::Application.stubs(:stop_requested?).returns(false)
+        Puppet::Application.stubs(:interrupted?).returns(true)
       end
 
       it 'should be false for :stopping?' do