puppet 6.0.7-universal-darwin → 6.0.8-universal-darwin

data/spec/unit/transaction/persistence_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'yaml'
@@ -14,7 +13,7 @@ describe Puppet::Transaction::Persistence do
 
   describe "when loading from file" do
     before do
-      Puppet.settings.stubs(:use).returns(true)
+      allow(Puppet.settings).to receive(:use).and_return(true)
     end
 
     describe "when the file/directory does not exist" do
@@ -48,7 +47,7 @@ describe Puppet::Transaction::Persistence do
         property = "my"
         value = "something"
 
-        Puppet.expects(:err).never
+        expect(Puppet).not_to receive(:err)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.set_system_value(resource, property, value)
@@ -62,7 +61,7 @@ describe Puppet::Transaction::Persistence do
         test_yaml = {"resources"=>{"a"=>"b"}}
         write_state_file(test_yaml.to_yaml)
 
-        Puppet.expects(:err).never
+        expect(Puppet).not_to receive(:err)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -73,7 +72,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain valid YAML" do
         write_state_file('{ invalid')
 
-        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
+        expect(Puppet).to receive(:send_log).with(:err, /Transaction store file .* is corrupt/)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -84,7 +83,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain a hash of data" do
         write_state_file("not_a_hash")
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is valid YAML but not returning a hash/))
+        expect(Puppet).to receive(:err).with(/Transaction store file .* is valid YAML but not returning a hash/)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -95,10 +94,10 @@ describe Puppet::Transaction::Persistence do
       it "should raise an error if the file does not contain valid YAML and cannot be renamed" do
         write_state_file('{ invalid')
 
-        File.expects(:rename).raises(SystemCallError)
+        expect(File).to receive(:rename).and_raise(SystemCallError)
 
-        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
-        Puppet.expects(:send_log).with(:err, regexp_matches(/Unable to rename/))
+        expect(Puppet).to receive(:send_log).with(:err, /Transaction store file .* is corrupt/)
+        expect(Puppet).to receive(:send_log).with(:err, /Unable to rename/)
 
         persistence = Puppet::Transaction::Persistence.new
         expect { persistence.load }.to raise_error(Puppet::Error, /Could not rename/)
@@ -107,9 +106,9 @@ describe Puppet::Transaction::Persistence do
       it "should attempt to rename the file if the file is corrupted" do
         write_state_file('{ invalid')
 
-        File.expects(:rename).at_least_once
+        expect(File).to receive(:rename).at_least(:once)
 
-        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
+        expect(Puppet).to receive(:send_log).with(:err, /Transaction store file .* is corrupt/)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -119,7 +118,7 @@ describe Puppet::Transaction::Persistence do
         FileUtils.rm_f(@tmpfile)
         Dir.mkdir(@tmpfile)
 
-        Puppet.expects(:warning).with(regexp_matches(/Transaction store file .* is not a file/))
+        expect(Puppet).to receive(:warning).with(/Transaction store file .* is not a file/)
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -178,7 +177,7 @@ describe Puppet::Transaction::Persistence do
 
   describe "when checking if persistence is enabled" do
     let(:mock_catalog) do
-      mock
+      double()
     end
 
     let (:persistence) do
@@ -195,25 +194,25 @@ describe Puppet::Transaction::Persistence do
 
     it "should not be enabled when not running in agent mode" do
       Puppet.settings.preferred_run_mode = :user
-      mock_catalog.stubs(:host_config?).returns(true)
+      allow(mock_catalog).to receive(:host_config?).and_return(true)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should not be enabled when the catalog is not the host catalog" do
       Puppet.settings.preferred_run_mode = :agent
-      mock_catalog.stubs(:host_config?).returns(false)
+      allow(mock_catalog).to receive(:host_config?).and_return(false)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should not be enabled outside of agent mode and the catalog is not the host catalog" do
       Puppet.settings.preferred_run_mode = :user
-      mock_catalog.stubs(:host_config?).returns(false)
+      allow(mock_catalog).to receive(:host_config?).and_return(false)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should be enabled in agent mode and when the catalog is the host catalog" do
       Puppet.settings.preferred_run_mode = :agent
-      mock_catalog.stubs(:host_config?).returns(true)
+      allow(mock_catalog).to receive(:host_config?).and_return(true)
       expect(persistence.enabled?(mock_catalog)).to be true
     end
   end

data/spec/unit/transaction/report_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet'
@@ -10,7 +9,7 @@ describe Puppet::Transaction::Report do
   include PuppetSpec::Files
 
   before do
-    Puppet::Util::Storage.stubs(:store)
+    allow(Puppet::Util::Storage).to receive(:store)
   end
 
   it "should set its host name to the node_name_value" do
@@ -24,7 +23,7 @@ describe Puppet::Transaction::Report do
   end
 
   it "should create an initialization timestamp" do
-    Time.expects(:now).returns "mytime"
+    expect(Time).to receive(:now).and_return("mytime")
     expect(Puppet::Transaction::Report.new.time).to eq("mytime")
   end
 
@@ -116,7 +115,7 @@ describe Puppet::Transaction::Report do
   end
 
   it "should not include whits" do
-    Puppet::FileBucket::File.indirection.stubs(:save)
+    allow(Puppet::FileBucket::File.indirection).to receive(:save)
 
     filename = tmpfile('whit_test')
     file = Puppet::Type.type(:file).new(:path => filename)
@@ -167,7 +166,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should add each status to its status list" do
-      status = stub 'status', :resource => "foo"
+      status = double('status', :resource => "foo")
       @report.add_resource_status status
       expect(@report.resource_statuses["foo"]).to equal(status)
     end
@@ -175,11 +174,11 @@ describe Puppet::Transaction::Report do
 
   describe "when using the indirector" do
     it "should redirect :save to the indirection" do
-      Facter.stubs(:value).returns("eh")
-      @indirection = stub 'indirection', :name => :report
-      Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
+      allow(Facter).to receive(:value).and_return("eh")
+      @indirection = double('indirection', :name => :report)
+      allow(Puppet::Transaction::Report).to receive(:indirection).and_return(@indirection)
       report = Puppet::Transaction::Report.new
-      @indirection.expects(:save)
+      expect(@indirection).to receive(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
 
@@ -189,7 +188,7 @@ describe Puppet::Transaction::Report do
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new
-      report.expects(:host).returns "me"
+      expect(report).to receive(:host).and_return("me")
       expect(report.name).to eq("me")
     end
   end
@@ -455,7 +454,7 @@ describe Puppet::Transaction::Report do
 
   describe "when producing a summary" do
     before do
-      Benchmark.stubs(:realtime).returns(5.05683418)
+      allow(Benchmark).to receive(:realtime).and_return(5.05683418)
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
@@ -474,7 +473,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should include the last run time in the raw summary hash" do
-      Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
+      allow(Time).to receive(:now).and_return(Time.utc(2010,11,10,12,0,24))
       expect(@report.raw_summary["time"]["last_run"]).to eq(1289390424)
     end
 

data/spec/unit/transaction/resource_harness_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/transaction/resource_harness'
@@ -15,7 +14,7 @@ describe Puppet::Transaction::ResourceHarness do
     @resource = Puppet::Type.type(:file).new :path => path
     @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     @current_state = Puppet::Resource.new(:file, path)
-    @resource.stubs(:retrieve).returns @current_state
+    allow(@resource).to receive(:retrieve).and_return(@current_state)
   end
 
   it "should accept a transaction at initialization" do
@@ -24,7 +23,7 @@ describe Puppet::Transaction::ResourceHarness do
   end
 
   it "should delegate to the transaction for its relationship graph" do
-    @transaction.expects(:relationship_graph).returns "relgraph"
+    expect(@transaction).to receive(:relationship_graph).and_return("relgraph")
     expect(Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph).to eq("relgraph")
   end
 
@@ -38,14 +37,14 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "retrieves the current state of the resource" do
-      @resource.expects(:retrieve).returns @current_state
+      expect(@resource).to receive(:retrieve).and_return(@current_state)
 
       @harness.evaluate(@resource)
     end
 
     it "produces a failure status for the resource when an error occurs" do
       the_message = "retrieve failed in testing"
-      @resource.expects(:retrieve).raises(ArgumentError.new(the_message))
+      expect(@resource).to receive(:retrieve).and_raise(ArgumentError.new(the_message))
 
       status = @harness.evaluate(@resource)
 
@@ -290,7 +289,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :foo => 1, :bar => 2
-      resource.expects(:err).never
+      expect(resource).not_to receive(:err)
       @status = @harness.evaluate(resource)
     end
 
@@ -309,7 +308,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :baz => 1
-      @resource.expects(:err).never
+      expect(@resource).not_to receive(:err)
     end
 
     it "should log and pass the exception through" do
@@ -323,7 +322,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :brillig => 1
-      @resource.expects(:err).never
+      expect(@resource).not_to receive(:err)
     end
 
     it "should record a failure event" do
@@ -338,7 +337,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :slithy => 1
-      @resource.expects(:err).never
+      expect(@resource).not_to receive(:err)
     end
 
     it "should log and pass the exception through" do
@@ -352,7 +351,7 @@ describe Puppet::Transaction::ResourceHarness do
     it "should not call insync? on parameters that are merely audited" do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :audit => ['foo']
-      resource.property(:foo).expects(:insync?).never
+      expect(resource.property(:foo)).not_to receive(:insync?)
       status = @harness.evaluate(resource)
 
       expect(status.events).to be_empty
@@ -362,7 +361,7 @@ describe Puppet::Transaction::ResourceHarness do
       test_file = tmpfile('foo')
       File.open(test_file, 'w').close
       resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['group'], :backup => false
-      resource.expects(:err).never # make sure no exceptions get swallowed
+      expect(resource).not_to receive(:err) # make sure no exceptions get swallowed
 
       status = @harness.evaluate(resource)
 
@@ -388,11 +387,9 @@ describe Puppet::Transaction::ResourceHarness do
       # set up the sequence of stubs; yeah, this is pretty
       # brittle, so this might need to be adjusted if the
       # resource_harness logic changes
-      resource.expects(:retrieve).returns(current_from_filesystem)
-      Puppet::Util::Storage.stubs(:cache).with(resource).
-        returns(historical_from_state_yaml).then.
-        returns(current_from_filesystem).then.
-        returns(current_from_filesystem)
+      expect(resource).to receive(:retrieve).and_return(current_from_filesystem)
+      allow(Puppet::Util::Storage).to receive(:cache).with(resource).
+        and_return(historical_from_state_yaml, current_from_filesystem, current_from_filesystem)
 
       # there should be an audit change recorded, since the two
       # timestamps differ by at least 1 microsecond
@@ -421,11 +418,9 @@ describe Puppet::Transaction::ResourceHarness do
       # set up the sequence of stubs; yeah, this is pretty
       # brittle, so this might need to be adjusted if the
       # resource_harness logic changes
-      resource.expects(:retrieve).returns(current_from_filesystem)
-      Puppet::Util::Storage.stubs(:cache).with(resource).
-        returns(historical_from_state_yaml).then.
-        returns(current_from_filesystem).then.
-        returns(current_from_filesystem)
+      expect(resource).to receive(:retrieve).and_return(current_from_filesystem)
+      allow(Puppet::Util::Storage).to receive(:cache).with(resource).
+        and_return(historical_from_state_yaml, current_from_filesystem, current_from_filesystem)
 
       # there should be no audit change recorded, despite the
       # slight difference in the two timestamps
@@ -476,19 +471,19 @@ describe Puppet::Transaction::ResourceHarness do
         end
 
         it "redacts notices when a parameter is newly audited" do
-          resource.property(:content).expects(:notice).with("audit change: newly-recorded value [redacted]")
+          expect(resource.property(:content)).to receive(:notice).with("audit change: newly-recorded value [redacted]")
           @harness.evaluate(resource)
         end
 
         it "redacts event messages for sensitive properties" do
-          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
+          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
           expect(sync_event.message).to eq 'changed [redacted] to [redacted] (previously recorded value was [redacted])'
         end
 
         it "redacts audit event messages for sensitive properties when simulating noop changes" do
-          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
+          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
           resource[:noop] = true
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
@@ -496,7 +491,7 @@ describe Puppet::Transaction::ResourceHarness do
         end
 
         it "redacts event contents for sensitive properties" do
-          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
+          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
           expect(sync_event.historical_value).to eq '[redacted]'
@@ -535,7 +530,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should warn and return nil if the resource has no catalog" do
       @resource.catalog = nil
-      @resource.expects(:warning)
+      expect(@resource).to receive(:warning)
 
       expect(@harness.schedule(@resource)).to be_nil
     end
@@ -546,7 +541,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should fail if the named schedule cannot be found" do
       @resource[:schedule] = "whatever"
-      @resource.expects(:fail)
+      expect(@resource).to receive(:fail)
       @harness.schedule(@resource)
     end
 
@@ -576,13 +571,13 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
       t = Time.now
-      @harness.expects(:cached).with(@resource, :checked).returns(t)
+      expect(@harness).to receive(:cached).with(@resource, :checked).and_return(t)
 
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
 
-      sched.expects(:match?).with(t.to_i).returns "feh"
+      expect(sched).to receive(:match?).with(t.to_i).and_return("feh")
 
       expect(@harness.scheduled?(@resource)).to eq("feh")
     end
@@ -590,7 +585,7 @@ describe Puppet::Transaction::ResourceHarness do
 
   it "should be able to cache data in the Storage module" do
     data = {}
-    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
+    expect(Puppet::Util::Storage).to receive(:cache).with(@resource).and_return(data)
     @harness.cache(@resource, :foo, "something")
 
     expect(data[:foo]).to eq("something")
@@ -598,7 +593,7 @@ describe Puppet::Transaction::ResourceHarness do
 
   it "should be able to retrieve data from the cache" do
     data = {:foo => "other"}
-    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
+    expect(Puppet::Util::Storage).to receive(:cache).with(@resource).and_return(data)
     expect(@harness.cached(@resource, :foo)).to eq("other")
   end
 
@@ -614,14 +609,14 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "contains (corrective) when corrective change" do
-      Puppet::Transaction::Event.any_instance.stubs(:corrective_change).returns(true)
+      allow_any_instance_of(Puppet::Transaction::Event).to receive(:corrective_change).and_return(true)
       status = @harness.evaluate(resource)
       sync_event = status.events[0]
       expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+' \(corrective\)/)
     end
 
     it "contains no modifier when intentional change" do
-      Puppet::Transaction::Event.any_instance.stubs(:corrective_change).returns(false)
+      allow_any_instance_of(Puppet::Transaction::Event).to receive(:corrective_change).and_return(false)
       status = @harness.evaluate(resource)
       sync_event = status.events[0]
       expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+'$/)

data/spec/unit/transaction_spec.rb

@@ -89,7 +89,7 @@ describe Puppet::Transaction do
       report = Puppet::Transaction::Report.new
       catalog.retrieval_duration = 5
 
-      report.expects(:add_times).with(:config_retrieval, 5)
+      expect(report).to receive(:add_times).with(:config_retrieval, 5)
 
       Puppet::Transaction.new(catalog, report, nil)
     end
@@ -101,8 +101,8 @@ describe Puppet::Transaction do
     it "should process events" do
       transaction = transaction_with_resource(resource)
 
-      transaction.expects(:skip?).with(resource).returns false
-      transaction.event_manager.expects(:process_events).with(resource)
+      expect(transaction).to receive(:skip?).with(resource).and_return(false)
+      expect(transaction.event_manager).to receive(:process_events).with(resource)
 
       transaction.evaluate
     end
@@ -111,7 +111,7 @@ describe Puppet::Transaction do
       it "should mark the resource's status as skipped" do
         transaction = transaction_with_resource(resource)
 
-        transaction.expects(:skip?).with(resource).returns true
+        expect(transaction).to receive(:skip?).with(resource).and_return(true)
 
         transaction.evaluate
         expect(transaction.resource_status(resource)).to be_skipped
@@ -119,15 +119,15 @@ describe Puppet::Transaction do
 
       it "does not process any scheduled events" do
         transaction = transaction_with_resource(resource)
-        transaction.expects(:skip?).with(resource).returns true
-        transaction.event_manager.expects(:process_events).with(resource).never
+        expect(transaction).to receive(:skip?).with(resource).and_return(true)
+        expect(transaction.event_manager).not_to receive(:process_events).with(resource)
         transaction.evaluate
       end
 
       it "dequeues all events scheduled on that resource" do
         transaction = transaction_with_resource(resource)
-        transaction.expects(:skip?).with(resource).returns true
-        transaction.event_manager.expects(:dequeue_all_events_for_resource).with(resource)
+        expect(transaction).to receive(:skip?).with(resource).and_return(true)
+        expect(transaction.event_manager).to receive(:dequeue_all_events_for_resource).with(resource)
         transaction.evaluate
       end
     end
@@ -136,7 +136,7 @@ describe Puppet::Transaction do
   describe "when evaluating a skipped resource for corrective change it" 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
 
     it "should persist in the transactionstore" do
@@ -148,8 +148,8 @@ describe Puppet::Transaction do
       expect(transaction.resource_status(resource)).to be_changed
 
       transaction = transaction_with_resource(resource)
-      transaction.expects(:skip?).with(resource).returns true
-      transaction.event_manager.expects(:process_events).with(resource).never
+      expect(transaction).to receive(:skip?).with(resource).and_return(true)
+      expect(transaction.event_manager).not_to receive(:process_events).with(resource)
       transaction.evaluate
       expect(transaction.resource_status(resource)).to be_skipped
 
@@ -167,35 +167,35 @@ describe Puppet::Transaction do
       @status = Puppet::Resource::Status.new(@resource)
 
       @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
-      @transaction.event_manager.stubs(:queue_events)
+      allow(@transaction.event_manager).to receive(:queue_events)
     end
 
     it "should use its resource harness to apply the resource" do
-      @transaction.resource_harness.expects(:evaluate).with(@resource)
+      expect(@transaction.resource_harness).to receive(:evaluate).with(@resource)
       @transaction.evaluate
     end
 
     it "should add the resulting resource status to its status list" do
-      @transaction.resource_harness.stubs(:evaluate).returns(@status)
+      allow(@transaction.resource_harness).to receive(:evaluate).and_return(@status)
       @transaction.evaluate
       expect(@transaction.resource_status(@resource)).to be_instance_of(Puppet::Resource::Status)
     end
 
     it "should queue any events added to the resource status" do
-      @transaction.resource_harness.stubs(:evaluate).returns(@status)
-      @status.expects(:events).returns %w{a b}
-      @transaction.event_manager.expects(:queue_events).with(@resource, ["a", "b"])
+      allow(@transaction.resource_harness).to receive(:evaluate).and_return(@status)
+      expect(@status).to receive(:events).and_return(%w{a b})
+      expect(@transaction.event_manager).to receive(:queue_events).with(@resource, ["a", "b"])
       @transaction.evaluate
     end
 
     it "should log and skip any resources that cannot be applied" do
-      @resource.expects(:properties).raises ArgumentError
+      expect(@resource).to receive(:properties).and_raise(ArgumentError)
       @transaction.evaluate
       expect(@transaction.report.resource_statuses[@resource.to_s]).to be_failed
     end
 
     it "should report any_failed if any resources failed" do
-      @resource.expects(:properties).raises ArgumentError
+      expect(@resource).to receive(:properties).and_raise(ArgumentError)
       @transaction.evaluate
 
       expect(@transaction).to be_any_failed
@@ -235,8 +235,8 @@ describe Puppet::Transaction do
     end
 
     it "should warn if there are no blockers" do
-      vertex = stub('vertex')
-      vertex.expects(:warning).with "appears to have a negative number of dependencies"
+      vertex = double('vertex')
+      expect(vertex).to receive(:warning).with("appears to have a negative number of dependencies")
       graph.blockers[vertex] = 0
 
       graph.unblock(vertex)
@@ -264,7 +264,7 @@ describe Puppet::Transaction do
     end
 
     it "should yield the resource even if eval_generate is called" do
-      Puppet::Transaction::AdditionalResourceGenerator.any_instance.expects(:eval_generate).with(resource).returns true
+      expect_any_instance_of(Puppet::Transaction::AdditionalResourceGenerator).to receive(:eval_generate).with(resource).and_return(true)
 
       yielded = false
       @transaction.evaluate do |res|
@@ -275,7 +275,7 @@ describe Puppet::Transaction do
     end
 
     it "should prefetch the provider if necessary" do
-      @transaction.expects(:prefetch_if_necessary).with(resource)
+      expect(@transaction).to receive(:prefetch_if_necessary).with(resource)
 
       @transaction.evaluate {}
     end
@@ -308,7 +308,7 @@ describe Puppet::Transaction do
       dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
       @transaction.catalog.add_resource(dependent)
 
-      resource.stubs(:suitable?).returns false
+      allow(resource).to receive(:suitable?).and_return(false)
 
       evaluated = []
       @transaction.evaluate do |res|
@@ -331,20 +331,20 @@ describe Puppet::Transaction do
 
     before :each do
       catalog.add_resource generator
-      generator.stubs(:generate).returns generated
+      allow(generator).to receive(:generate).and_return(generated)
       # avoid crude failures because of nil resources that result
       # from implicit containment and lacking containers
-      catalog.stubs(:container_of).returns generator
+      allow(catalog).to receive(:container_of).and_return(generator)
     end
 
     it "should call 'generate' on all created resources" do
-      generated.each { |res| res.expects(:generate) }
+      generated.each { |res| expect(res).to receive(:generate) }
 
       transaction.evaluate
     end
 
     it "should finish all resources" do
-      generated.each { |res| res.expects(:finish) }
+      generated.each { |res| expect(res).to receive(:finish) }
 
       transaction.evaluate
     end
@@ -369,30 +369,29 @@ describe Puppet::Transaction do
 
     before :each do
       generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer)
-      Puppet::Transaction::AdditionalResourceGenerator.stubs(:new).returns(generator)
+      allow(Puppet::Transaction::AdditionalResourceGenerator).to receive(:new).and_return(generator)
     end
 
     it "should should query the generator for whether resources failed to generate" do
       relationship_graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
-      catalog.stubs(:relationship_graph).returns(relationship_graph)
+      allow(catalog).to receive(:relationship_graph).and_return(relationship_graph)
 
-      sequence = sequence(:traverse_first)
-      relationship_graph.expects(:traverse).in_sequence(sequence)
-      generator.expects(:resources_failed_to_generate).in_sequence(sequence)
+      expect(relationship_graph).to receive(:traverse).ordered
+      expect(generator).to receive(:resources_failed_to_generate).ordered
 
       transaction.evaluate
     end
 
     it "should report that resources failed to generate" do
-      generator.expects(:resources_failed_to_generate).returns(true)
-      report.expects(:resources_failed_to_generate=).with(true)
+      expect(generator).to receive(:resources_failed_to_generate).and_return(true)
+      expect(report).to receive(:resources_failed_to_generate=).with(true)
 
       transaction.evaluate
     end
 
     it "should not report that resources failed to generate if none did" do
-      generator.expects(:resources_failed_to_generate).returns(false)
-      report.expects(:resources_failed_to_generate=).never
+      expect(generator).to receive(:resources_failed_to_generate).and_return(false)
+      expect(report).not_to receive(:resources_failed_to_generate=)
 
       transaction.evaluate
     end
@@ -404,20 +403,20 @@ describe Puppet::Transaction do
     let(:spec_exception) { 'spec-exception' }
 
     it "should invoke each resource's hook and apply the catalog after no failures" do
-      resource.expects(:pre_run_check)
+      expect(resource).to receive(:pre_run_check)
 
       transaction.evaluate
     end
 
     it "should abort the transaction on failure" do
-      resource.expects(:pre_run_check).raises(Puppet::Error, spec_exception)
+      expect(resource).to receive(:pre_run_check).and_raise(Puppet::Error, spec_exception)
 
       expect { transaction.evaluate }.to raise_error(Puppet::Error, /Some pre-run checks failed/)
     end
 
     it "should log the resource-specific exception" do
-      resource.expects(:pre_run_check).raises(Puppet::Error, spec_exception)
-      resource.expects(:log_exception).with(responds_with(:message, spec_exception))
+      expect(resource).to receive(:pre_run_check).and_raise(Puppet::Error, spec_exception)
+      expect(resource).to receive(:log_exception).with(have_attributes(message: match(/#{spec_exception}/)))
 
       expect { transaction.evaluate }.to raise_error(Puppet::Error)
     end
@@ -432,61 +431,61 @@ describe Puppet::Transaction do
     end
 
     it "should skip resource with missing tags" do
-      @transaction.stubs(:missing_tags?).returns(true)
+      allow(@transaction).to receive(:missing_tags?).and_return(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip resources tagged with the skip tags" do
-      @transaction.stubs(:skip_tags?).returns(true)
+      allow(@transaction).to receive(:skip_tags?).and_return(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip unscheduled resources" do
-      @transaction.stubs(:scheduled?).returns(false)
+      allow(@transaction).to receive(:scheduled?).and_return(false)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip resources with failed dependencies" do
-      @transaction.stubs(:failed_dependencies?).returns(true)
+      allow(@transaction).to receive(:failed_dependencies?).and_return(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip virtual resource" do
-      @resource.stubs(:virtual?).returns true
+      allow(@resource).to receive(:virtual?).and_return(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip device only resouce on normal host" do
-      @resource.stubs(:appliable_to_host?).returns false
-      @resource.stubs(:appliable_to_device?).returns true
+      allow(@resource).to receive(:appliable_to_host?).and_return(false)
+      allow(@resource).to receive(:appliable_to_device?).and_return(true)
       @transaction.for_network_device = false
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should not skip device only resouce on remote device" do
-      @resource.stubs(:appliable_to_host?).returns false
-      @resource.stubs(:appliable_to_device?).returns true
+      allow(@resource).to receive(:appliable_to_host?).and_return(false)
+      allow(@resource).to receive(:appliable_to_device?).and_return(true)
       @transaction.for_network_device = true
       expect(@transaction).not_to be_skip(@resource)
     end
 
     it "should skip host resouce on device" do
-      @resource.stubs(:appliable_to_host?).returns true
-      @resource.stubs(:appliable_to_device?).returns false
+      allow(@resource).to receive(:appliable_to_host?).and_return(true)
+      allow(@resource).to receive(:appliable_to_device?).and_return(false)
       @transaction.for_network_device = true
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should not skip resouce available on both device and host when on device" do
-      @resource.stubs(:appliable_to_host?).returns true
-      @resource.stubs(:appliable_to_device?).returns true
+      allow(@resource).to receive(:appliable_to_host?).and_return(true)
+      allow(@resource).to receive(:appliable_to_device?).and_return(true)
       @transaction.for_network_device = true
       expect(@transaction).not_to be_skip(@resource)
     end
 
     it "should not skip resouce available on both device and host when on host" do
-      @resource.stubs(:appliable_to_host?).returns true
-      @resource.stubs(:appliable_to_device?).returns true
+      allow(@resource).to receive(:appliable_to_host?).and_return(true)
+      allow(@resource).to receive(:appliable_to_device?).and_return(true)
       @transaction.for_network_device = false
       expect(@transaction).not_to be_skip(@resource)
     end
@@ -499,20 +498,20 @@ describe Puppet::Transaction do
       @resource.catalog = @catalog
       @transaction = Puppet::Transaction.new(@catalog, nil, nil)
 
-      @transaction.stubs(:ignore_tags?).returns false
+      allow(@transaction).to receive(:ignore_tags?).and_return(false)
     end
 
     it "should not be missing tags if tags are being ignored" do
-      @transaction.expects(:ignore_tags?).returns true
+      expect(@transaction).to receive(:ignore_tags?).and_return(true)
 
-      @resource.expects(:tagged?).never
+      expect(@resource).not_to receive(:tagged?)
 
       expect(@transaction).not_to be_missing_tags(@resource)
     end
 
     it "should not be missing tags if the transaction tags are empty" do
       @transaction.tags = []
-      @resource.expects(:tagged?).never
+      expect(@resource).not_to receive(:tagged?)
       expect(@transaction).not_to be_missing_tags(@resource)
     end
 
@@ -533,14 +532,14 @@ describe Puppet::Transaction do
 
     it "should always schedule resources if 'ignoreschedules' is set" do
       @transaction.ignoreschedules = true
-      @transaction.resource_harness.expects(:scheduled?).never
+      expect(@transaction.resource_harness).not_to receive(:scheduled?)
 
       @transaction.evaluate
       expect(@transaction.resource_status(@resource)).to be_changed
     end
 
     it "should let the resource harness determine whether the resource should be scheduled" do
-      @transaction.resource_harness.expects(:scheduled?).with(@resource).returns "feh"
+      expect(@transaction.resource_harness).to receive(:scheduled?).with(@resource).and_return("feh")
 
       @transaction.evaluate
     end
@@ -553,13 +552,13 @@ describe Puppet::Transaction do
     let(:resource2) { Puppet::Type.type(:package).new :title => "blah", :provider => :apt }
 
     before :each do
-      resource.stubs(:suitable?).returns(true)
+      allow(resource).to receive(:suitable?).and_return(true)
       catalog.add_resource resource
       catalog.add_resource resource2
     end
 
     it "should match resources by name, not title" do
-      resource.provider.class.expects(:prefetch).with("bar" => resource)
+      expect(resource.provider.class).to receive(:prefetch).with("bar" => resource)
 
       transaction.prefetch_if_necessary(resource)
     end
@@ -567,13 +566,13 @@ describe Puppet::Transaction do
     it "should not prefetch a provider which has already been prefetched" do
       transaction.prefetched_providers[:package][:pkgng] = true
 
-      resource.provider.class.expects(:prefetch).never
+      expect(resource.provider.class).not_to receive(:prefetch)
 
       transaction.prefetch_if_necessary(resource)
     end
 
     it "should mark the provider prefetched" do
-      resource.provider.class.stubs(:prefetch)
+      allow(resource.provider.class).to receive(:prefetch)
 
       transaction.prefetch_if_necessary(resource)
 
@@ -586,8 +585,8 @@ describe Puppet::Transaction do
 
       catalog.add_resource other
 
-      resource.class.stubs(:defaultprovider).returns(resource.provider.class)
-      resource.provider.class.expects(:prefetch).with('bar' => resource, 'other' => other)
+      allow(resource.class).to receive(:defaultprovider).and_return(resource.provider.class)
+      expect(resource.provider.class).to receive(:prefetch).with('bar' => resource, 'other' => other)
 
       transaction.prefetch_if_necessary(resource)
     end
@@ -595,38 +594,38 @@ describe Puppet::Transaction do
     it "should not prefetch a provider which has failed" do
       transaction.prefetch_failed_providers[:package][:pkgng] = true
 
-      resource.provider.class.expects(:prefetch).never
+      expect(resource.provider.class).not_to receive(:prefetch)
 
       transaction.prefetch_if_necessary(resource)
     end
 
     it "should not rescue SystemExit without future_features flag" do
       Puppet.settings[:future_features] = false
-      resource.provider.class.expects(:prefetch).raises(SystemExit, "SystemMessage")
+      expect(resource.provider.class).to receive(:prefetch).and_raise(SystemExit, "SystemMessage")
       expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
     end
 
     it "should not rescue SystemExit with future_features flag" do
       Puppet.settings[:future_features] = true
-      resource.provider.class.expects(:prefetch).raises(SystemExit, "SystemMessage")
+      expect(resource.provider.class).to receive(:prefetch).and_raise(SystemExit, "SystemMessage")
       expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
     end
 
     it "should rescue LoadError without future_features flag" do
       Puppet.settings[:future_features] = false
-      resource.provider.class.expects(:prefetch).raises(LoadError, "LoadMessage")
+      expect(resource.provider.class).to receive(:prefetch).and_raise(LoadError, "LoadMessage")
       expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
     end
 
     it "should rescue LoadError with future_features flag" do
       Puppet.settings[:future_features] = true
-      resource.provider.class.expects(:prefetch).raises(LoadError, "LoadMessage")
+      expect(resource.provider.class).to receive(:prefetch).and_raise(LoadError, "LoadMessage")
       expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
     end
 
     describe "and prefetching fails" do
       before :each do
-        resource.provider.class.expects(:prefetch).raises(Puppet::Error, "message")
+        expect(resource.provider.class).to receive(:prefetch).and_raise(Puppet::Error, "message")
       end
 
       context "without future_features flag" do
@@ -639,7 +638,7 @@ describe Puppet::Transaction do
         end
 
         it "should log the exception during prefetch" do
-          Puppet.expects(:log_exception).with(anything, "Could not prefetch package provider 'pkgng': message")
+          expect(Puppet).to receive(:log_exception).with(anything, "Could not prefetch package provider 'pkgng': message")
           expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error, "message")
         end
       end
@@ -675,14 +674,14 @@ describe Puppet::Transaction do
 
           before :each do
             catalog.add_resource generator
-            generator.stubs(:generate).returns generated
-            catalog.stubs(:container_of).returns generator
+            allow(generator).to receive(:generate).and_return(generated)
+            allow(catalog).to receive(:container_of).and_return(generator)
           end
 
           it "should not evaluate resources with a failed provider, even if the prefetch is rescued" do
             #Only the generator resource should be applied, all the other resources are failed, and skipped.
             catalog.remove_resource resource2
-            transaction.expects(:apply).once
+            expect(transaction).to receive(:apply).once
 
             transaction.evaluate
           end
@@ -701,7 +700,7 @@ describe Puppet::Transaction do
             catalog.add_resource(new_resource)
 
             catalog.remove_resource resource2
-            transaction.expects(:apply).once
+            expect(transaction).to receive(:apply).once
 
             transaction.evaluate
 
@@ -773,10 +772,10 @@ describe Puppet::Transaction do
 
     it "should call ::post_resource_eval even if one of the resources fails" do
       resource = teardown_type.new(:title => "foo", :provider => :teardown_provider)
-      resource.stubs(:retrieve_resource).raises
+      allow(resource).to receive(:retrieve_resource).and_raise
       catalog.add_resource resource
 
-      resource.provider.class.expects(:post_resource_eval)
+      expect(resource.provider.class).to receive(:post_resource_eval)
 
       transaction.evaluate
     end
@@ -790,7 +789,7 @@ describe Puppet::Transaction do
 
     context "when stop is requested" do
       before :each do
-        Puppet::Application.stubs(:stop_requested?).returns(true)
+        allow(Puppet::Application).to receive(:stop_requested?).and_return(true)
       end
 
       it 'should return true for :stop_processing?' do
@@ -804,7 +803,7 @@ describe Puppet::Transaction do
     end
 
     it 'should return false for :stop_processing? if Puppet::Application.stop_requested? is false' do
-      Puppet::Application.stubs(:stop_requested?).returns(false)
+      allow(Puppet::Application).to receive(:stop_requested?).and_return(false)
       expect(@transaction.stop_processing?).to be_falsey
     end
 
@@ -812,25 +811,25 @@ describe Puppet::Transaction do
       before do
         @resource = Puppet::Type.type(:notify).new :title => "foobar"
         @catalog.add_resource @resource
-        @transaction.stubs(:add_dynamically_generated_resources)
+        allow(@transaction).to receive(:add_dynamically_generated_resources)
       end
 
       it 'should stop processing if :stop_processing? is true' do
-        @transaction.stubs(:stop_processing?).returns(true)
-        @transaction.expects(:eval_resource).never
+        allow(@transaction).to receive(:stop_processing?).and_return(true)
+        expect(@transaction).not_to receive(:eval_resource)
         @transaction.evaluate
       end
 
       it 'should continue processing if :stop_processing? is false' do
-        @transaction.stubs(:stop_processing?).returns(false)
-        @transaction.expects(:eval_resource).returns(nil)
+        allow(@transaction).to receive(:stop_processing?).and_return(false)
+        expect(@transaction).to receive(:eval_resource).and_return(nil)
         @transaction.evaluate
       end
     end
   end
 
   it "errors with a dependency cycle for a resource that requires itself" do
-    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
+    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
@@ -839,7 +838,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a self-requiring resource also required by another resource" do
-    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
+    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
@@ -849,7 +848,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that requires itself and another resource" do
-    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
+    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle:
@@ -861,7 +860,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that is later modified to require itself" do
-    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
+    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: }
@@ -930,15 +929,16 @@ describe Puppet::Transaction do
   describe "failed dependency is depended on multiple times" do
     it "notifies the failed dependency once" do
       command_string = File.expand_path('/my/command')
-      Puppet::Util::Execution.stubs(:execute).with([command_string]).raises(Puppet::ExecutionFailure, "Failed")
+      allow(Puppet::Util::Execution).to receive(:execute).with([command_string]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:notice, "Dependency Exec[exec1] has failures: true")
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:notice, "Dependency Exec[exec2] has failures: true")
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:notice, "Dependency Exec[exec3] has failures: true")
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:notice, "Dependency Exec[exec4] has failures: true")
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:notice, "Dependency Exec[exec5] has failures: true")
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log).with(:notice, "Dependency Exec[exec1] has failures: true")
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log).with(:notice, "Dependency Exec[exec2] has failures: true")
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log).with(:notice, "Dependency Exec[exec3] has failures: true")
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log).with(:notice, "Dependency Exec[exec4] has failures: true")
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log).with(:notice, "Dependency Exec[exec5] has failures: true")
 
-      Puppet::Type::Notify.any_instance.expects(:send_log).with(:warning, "Skipping because of failed dependencies").times(3)
+      times_send_log_with_skipping_called = 0
+      allow_any_instance_of(Puppet::Type::Notify).to receive(:send_log) {times_send_log_with_skipping_called += 1; nil}.with(:warning, "Skipping because of failed dependencies")
 
       apply_compiled_manifest(<<-MANIFEST)
         exec { ['exec1', 'exec2', 'exec3', 'exec4', 'exec5']:
@@ -946,10 +946,9 @@ describe Puppet::Transaction do
         } ->
         notify { ['notify1', 'notify2', 'notify3']: }
       MANIFEST
-
+      expect(times_send_log_with_skipping_called).to eq(3)
     end
   end
-
 end
 
 describe Puppet::Transaction, " when determining tags" do