puppet 5.5.22 → 6.0.0

data/spec/unit/transaction_spec.rb

@@ -3,7 +3,6 @@ require 'matchers/include_in_order'
 require 'puppet_spec/compiler'
 
 require 'puppet/transaction'
-require 'puppet/type/notify'
 require 'fileutils'
 
 describe Puppet::Transaction do
@@ -17,13 +16,13 @@ describe Puppet::Transaction do
   end
 
   def transaction_with_resource(resource)
-    transaction = Puppet::Transaction.new(catalog_with_resource(resource), nil, Puppet::Graph::RandomPrioritizer.new)
+    transaction = Puppet::Transaction.new(catalog_with_resource(resource), nil, Puppet::Graph::SequentialPrioritizer.new)
     transaction
   end
 
   before do
     @basepath = make_absolute("/what/ever")
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, Puppet::Graph::RandomPrioritizer.new)
+    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, Puppet::Graph::SequentialPrioritizer.new)
   end
 
   it "should be able to look resource status up by resource reference" do
@@ -89,7 +88,7 @@ describe Puppet::Transaction do
       report = Puppet::Transaction::Report.new
       catalog.retrieval_duration = 5
 
-      expect(report).to receive(:add_times).with(:config_retrieval, 5)
+      report.expects(:add_times).with(:config_retrieval, 5)
 
       Puppet::Transaction.new(catalog, report, nil)
     end
@@ -101,8 +100,8 @@ describe Puppet::Transaction do
     it "should process events" do
       transaction = transaction_with_resource(resource)
 
-      expect(transaction).to receive(:skip?).with(resource).and_return(false)
-      expect(transaction.event_manager).to receive(:process_events).with(resource)
+      transaction.expects(:skip?).with(resource).returns false
+      transaction.event_manager.expects(:process_events).with(resource)
 
       transaction.evaluate
     end
@@ -111,7 +110,7 @@ describe Puppet::Transaction do
       it "should mark the resource's status as skipped" do
         transaction = transaction_with_resource(resource)
 
-        expect(transaction).to receive(:skip?).with(resource).and_return(true)
+        transaction.expects(:skip?).with(resource).returns true
 
         transaction.evaluate
         expect(transaction.resource_status(resource)).to be_skipped
@@ -119,15 +118,15 @@ describe Puppet::Transaction do
 
       it "does not process any scheduled events" do
         transaction = transaction_with_resource(resource)
-        expect(transaction).to receive(:skip?).with(resource).and_return(true)
-        expect(transaction.event_manager).not_to receive(:process_events).with(resource)
+        transaction.expects(:skip?).with(resource).returns true
+        transaction.event_manager.expects(:process_events).with(resource).never
         transaction.evaluate
       end
 
       it "dequeues all events scheduled on that resource" do
         transaction = transaction_with_resource(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.expects(:skip?).with(resource).returns true
+        transaction.event_manager.expects(:dequeue_all_events_for_resource).with(resource)
         transaction.evaluate
       end
     end
@@ -136,7 +135,7 @@ describe Puppet::Transaction do
   describe "when evaluating a skipped resource for corrective change it" 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
 
     it "should persist in the transactionstore" do
@@ -148,8 +147,8 @@ describe Puppet::Transaction do
       expect(transaction.resource_status(resource)).to be_changed
 
       transaction = transaction_with_resource(resource)
-      expect(transaction).to receive(:skip?).with(resource).and_return(true)
-      expect(transaction.event_manager).not_to receive(:process_events).with(resource)
+      transaction.expects(:skip?).with(resource).returns true
+      transaction.event_manager.expects(:process_events).with(resource).never
       transaction.evaluate
       expect(transaction.resource_status(resource)).to be_skipped
 
@@ -166,36 +165,36 @@ describe Puppet::Transaction do
       @catalog.add_resource(@resource)
       @status = Puppet::Resource::Status.new(@resource)
 
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
-      allow(@transaction.event_manager).to receive(:queue_events)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
+      @transaction.event_manager.stubs(:queue_events)
     end
 
     it "should use its resource harness to apply the resource" do
-      expect(@transaction.resource_harness).to receive(:evaluate).with(@resource)
+      @transaction.resource_harness.expects(:evaluate).with(@resource)
       @transaction.evaluate
     end
 
     it "should add the resulting resource status to its status list" do
-      allow(@transaction.resource_harness).to receive(:evaluate).and_return(@status)
+      @transaction.resource_harness.stubs(:evaluate).returns(@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
-      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.resource_harness.stubs(:evaluate).returns(@status)
+      @status.expects(:events).returns %w{a b}
+      @transaction.event_manager.expects(:queue_events).with(@resource, ["a", "b"])
       @transaction.evaluate
     end
 
     it "should log and skip any resources that cannot be applied" do
-      expect(@resource).to receive(:properties).and_raise(ArgumentError)
+      @resource.expects(:properties).raises 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
-      expect(@resource).to receive(:properties).and_raise(ArgumentError)
+      @resource.expects(:properties).raises ArgumentError
       @transaction.evaluate
 
       expect(@transaction).to be_any_failed
@@ -235,8 +234,8 @@ describe Puppet::Transaction do
     end
 
     it "should warn if there are no blockers" do
-      vertex = double('vertex')
-      expect(vertex).to receive(:warning).with("appears to have a negative number of dependencies")
+      vertex = stub('vertex')
+      vertex.expects(:warning).with "appears to have a negative number of dependencies"
       graph.blockers[vertex] = 0
 
       graph.unblock(vertex)
@@ -264,7 +263,7 @@ describe Puppet::Transaction do
     end
 
     it "should yield the resource even if eval_generate is called" do
-      expect_any_instance_of(Puppet::Transaction::AdditionalResourceGenerator).to receive(:eval_generate).with(resource).and_return(true)
+      Puppet::Transaction::AdditionalResourceGenerator.any_instance.expects(:eval_generate).with(resource).returns true
 
       yielded = false
       @transaction.evaluate do |res|
@@ -275,7 +274,7 @@ describe Puppet::Transaction do
     end
 
     it "should prefetch the provider if necessary" do
-      expect(@transaction).to receive(:prefetch_if_necessary).with(resource)
+      @transaction.expects(:prefetch_if_necessary).with(resource)
 
       @transaction.evaluate {}
     end
@@ -308,7 +307,7 @@ describe Puppet::Transaction do
       dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
       @transaction.catalog.add_resource(dependent)
 
-      allow(resource).to receive(:suitable?).and_return(false)
+      resource.stubs(:suitable?).returns false
 
       evaluated = []
       @transaction.evaluate do |res|
@@ -323,7 +322,7 @@ describe Puppet::Transaction do
 
   describe "when generating resources before traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) { Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new) }
+    let(:transaction) { Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new) }
     let(:generator) { Puppet::Type.type(:notify).new :title => "generator" }
     let(:generated) do
       %w[a b c].map { |name| Puppet::Type.type(:notify).new(:name => name) }
@@ -331,20 +330,20 @@ describe Puppet::Transaction do
 
     before :each do
       catalog.add_resource generator
-      allow(generator).to receive(:generate).and_return(generated)
+      generator.stubs(:generate).returns generated
       # avoid crude failures because of nil resources that result
       # from implicit containment and lacking containers
-      allow(catalog).to receive(:container_of).and_return(generator)
+      catalog.stubs(:container_of).returns generator
     end
 
     it "should call 'generate' on all created resources" do
-      generated.each { |res| expect(res).to receive(:generate) }
+      generated.each { |res| res.expects(:generate) }
 
       transaction.evaluate
     end
 
     it "should finish all resources" do
-      generated.each { |res| expect(res).to receive(:finish) }
+      generated.each { |res| res.expects(:finish) }
 
       transaction.evaluate
     end
@@ -362,36 +361,37 @@ describe Puppet::Transaction do
 
   describe "after resource traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:prioritizer) { Puppet::Graph::RandomPrioritizer.new }
+    let(:prioritizer) { Puppet::Graph::SequentialPrioritizer.new }
     let(:report) { Puppet::Transaction::Report.new }
     let(:transaction) { Puppet::Transaction.new(catalog, report, prioritizer) }
     let(:generator) { Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer) }
 
     before :each do
       generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer)
-      allow(Puppet::Transaction::AdditionalResourceGenerator).to receive(:new).and_return(generator)
+      Puppet::Transaction::AdditionalResourceGenerator.stubs(:new).returns(generator)
     end
 
     it "should should query the generator for whether resources failed to generate" do
       relationship_graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
-      allow(catalog).to receive(:relationship_graph).and_return(relationship_graph)
+      catalog.stubs(:relationship_graph).returns(relationship_graph)
 
-      expect(relationship_graph).to receive(:traverse).ordered
-      expect(generator).to receive(:resources_failed_to_generate).ordered
+      sequence = sequence(:traverse_first)
+      relationship_graph.expects(:traverse).in_sequence(sequence)
+      generator.expects(:resources_failed_to_generate).in_sequence(sequence)
 
       transaction.evaluate
     end
 
     it "should report that resources failed to generate" do
-      expect(generator).to receive(:resources_failed_to_generate).and_return(true)
-      expect(report).to receive(:resources_failed_to_generate=).with(true)
+      generator.expects(:resources_failed_to_generate).returns(true)
+      report.expects(:resources_failed_to_generate=).with(true)
 
       transaction.evaluate
     end
 
     it "should not report that resources failed to generate if none did" do
-      expect(generator).to receive(:resources_failed_to_generate).and_return(false)
-      expect(report).not_to receive(:resources_failed_to_generate=)
+      generator.expects(:resources_failed_to_generate).returns(false)
+      report.expects(:resources_failed_to_generate=).never
 
       transaction.evaluate
     end
@@ -403,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
-      expect(resource).to receive(:pre_run_check)
+      resource.expects(:pre_run_check)
 
       transaction.evaluate
     end
 
     it "should abort the transaction on failure" do
-      expect(resource).to receive(:pre_run_check).and_raise(Puppet::Error, spec_exception)
+      resource.expects(:pre_run_check).raises(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
-      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}/)))
+      resource.expects(:pre_run_check).raises(Puppet::Error, spec_exception)
+      resource.expects(:log_exception).with(responds_with(:message, spec_exception))
 
       expect { transaction.evaluate }.to raise_error(Puppet::Error)
     end
@@ -431,61 +431,61 @@ describe Puppet::Transaction do
     end
 
     it "should skip resource with missing tags" do
-      allow(@transaction).to receive(:missing_tags?).and_return(true)
+      @transaction.stubs(:missing_tags?).returns(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip resources tagged with the skip tags" do
-      allow(@transaction).to receive(:skip_tags?).and_return(true)
+      @transaction.stubs(:skip_tags?).returns(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip unscheduled resources" do
-      allow(@transaction).to receive(:scheduled?).and_return(false)
+      @transaction.stubs(:scheduled?).returns(false)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip resources with failed dependencies" do
-      allow(@transaction).to receive(:failed_dependencies?).and_return(true)
+      @transaction.stubs(:failed_dependencies?).returns(true)
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip virtual resource" do
-      allow(@resource).to receive(:virtual?).and_return(true)
+      @resource.stubs(:virtual?).returns true
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip device only resouce on normal host" do
-      allow(@resource).to receive(:appliable_to_host?).and_return(false)
-      allow(@resource).to receive(:appliable_to_device?).and_return(true)
+      @resource.stubs(:appliable_to_host?).returns false
+      @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = false
       expect(@transaction).to be_skip(@resource)
     end
 
     it "should not skip device only resouce on remote device" do
-      allow(@resource).to receive(:appliable_to_host?).and_return(false)
-      allow(@resource).to receive(:appliable_to_device?).and_return(true)
+      @resource.stubs(:appliable_to_host?).returns false
+      @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = true
       expect(@transaction).not_to be_skip(@resource)
     end
 
     it "should skip host resouce on device" do
-      allow(@resource).to receive(:appliable_to_host?).and_return(true)
-      allow(@resource).to receive(:appliable_to_device?).and_return(false)
+      @resource.stubs(:appliable_to_host?).returns true
+      @resource.stubs(:appliable_to_device?).returns 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
-      allow(@resource).to receive(:appliable_to_host?).and_return(true)
-      allow(@resource).to receive(:appliable_to_device?).and_return(true)
+      @resource.stubs(:appliable_to_host?).returns true
+      @resource.stubs(:appliable_to_device?).returns 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
-      allow(@resource).to receive(:appliable_to_host?).and_return(true)
-      allow(@resource).to receive(:appliable_to_device?).and_return(true)
+      @resource.stubs(:appliable_to_host?).returns true
+      @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = false
       expect(@transaction).not_to be_skip(@resource)
     end
@@ -498,20 +498,20 @@ describe Puppet::Transaction do
       @resource.catalog = @catalog
       @transaction = Puppet::Transaction.new(@catalog, nil, nil)
 
-      allow(@transaction).to receive(:ignore_tags?).and_return(false)
+      @transaction.stubs(:ignore_tags?).returns false
     end
 
     it "should not be missing tags if tags are being ignored" do
-      expect(@transaction).to receive(:ignore_tags?).and_return(true)
+      @transaction.expects(:ignore_tags?).returns true
 
-      expect(@resource).not_to receive(:tagged?)
+      @resource.expects(:tagged?).never
 
       expect(@transaction).not_to be_missing_tags(@resource)
     end
 
     it "should not be missing tags if the transaction tags are empty" do
       @transaction.tags = []
-      expect(@resource).not_to receive(:tagged?)
+      @resource.expects(:tagged?).never
       expect(@transaction).not_to be_missing_tags(@resource)
     end
 
@@ -527,19 +527,19 @@ describe Puppet::Transaction do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource(@resource)
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
     end
 
     it "should always schedule resources if 'ignoreschedules' is set" do
       @transaction.ignoreschedules = true
-      expect(@transaction.resource_harness).not_to receive(:scheduled?)
+      @transaction.resource_harness.expects(:scheduled?).never
 
       @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
-      expect(@transaction.resource_harness).to receive(:scheduled?).with(@resource).and_return("feh")
+      @transaction.resource_harness.expects(:scheduled?).with(@resource).returns "feh"
 
       @transaction.evaluate
     end
@@ -548,83 +548,60 @@ describe Puppet::Transaction do
   describe "when prefetching" do
     let(:catalog) { Puppet::Resource::Catalog.new }
     let(:transaction) { Puppet::Transaction.new(catalog, nil, nil) }
-    let(:resource) { Puppet::Type.type(:sshkey).new :title => "foo", :name => "bar", :type => :dsa, :key => "eh", :provider => :parsed }
-    let(:resource2) { Puppet::Type.type(:package).new :title => "blah", :provider => "apt" }
+    let(:resource) { Puppet::Type.type(:package).new :title => "foo", :name => "bar", :provider => :pkgng }
+    let(:resource2) { Puppet::Type.type(:package).new :title => "blah", :provider => :apt }
 
     before :each do
+      resource.stubs(:suitable?).returns(true)
       catalog.add_resource resource
       catalog.add_resource resource2
     end
 
     it "should match resources by name, not title" do
-      expect(resource.provider.class).to receive(:prefetch).with("bar" => resource)
+      resource.provider.class.expects(:prefetch).with("bar" => resource)
 
       transaction.prefetch_if_necessary(resource)
     end
 
     it "should not prefetch a provider which has already been prefetched" do
-      transaction.prefetched_providers[:sshkey][:parsed] = true
+      transaction.prefetched_providers[:package][:pkgng] = true
 
-      expect(resource.provider.class).not_to receive(:prefetch)
+      resource.provider.class.expects(:prefetch).never
 
       transaction.prefetch_if_necessary(resource)
     end
 
     it "should mark the provider prefetched" do
-      allow(resource.provider.class).to receive(:prefetch)
+      resource.provider.class.stubs(:prefetch)
 
       transaction.prefetch_if_necessary(resource)
 
-      expect(transaction.prefetched_providers[:sshkey][:parsed]).to be_truthy
+      expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
     end
 
     it "should prefetch resources without a provider if prefetching the default provider" do
-      other = Puppet::Type.type(:sshkey).new :name => "other"
-
+      other = Puppet::Type.type(:package).new :name => "other"
       other.instance_variable_set(:@provider, nil)
 
       catalog.add_resource other
 
-      expect(resource.provider.class).to receive(:prefetch).with('bar' => resource, 'other' => other)
+      resource.class.stubs(:defaultprovider).returns(resource.provider.class)
+      resource.provider.class.expects(:prefetch).with('bar' => resource, 'other' => other)
 
       transaction.prefetch_if_necessary(resource)
     end
 
     it "should not prefetch a provider which has failed" do
-      transaction.prefetch_failed_providers[:sshkey][:parsed] = true
+      transaction.prefetch_failed_providers[:package][:pkgng] = true
 
-      expect(resource.provider.class).not_to receive(:prefetch)
+      resource.provider.class.expects(:prefetch).never
 
       transaction.prefetch_if_necessary(resource)
     end
 
-    it "should not rescue SystemExit without future_features flag" do
-      Puppet.settings[:future_features] = false
-      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
-      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
-      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
-      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
-        expect(resource.provider.class).to receive(:prefetch).and_raise(Puppet::Error, "message")
+        resource.provider.class.expects(:prefetch).raises(Puppet::Error, "message")
       end
 
       context "without future_features flag" do
@@ -635,11 +612,6 @@ describe Puppet::Transaction do
         it "should not rescue prefetch executions" do
           expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error)
         end
-
-        it "should log the exception during prefetch" do
-          expect(Puppet).to receive(:log_exception).with(anything, "Could not prefetch sshkey provider 'parsed': message")
-          expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error, "message")
-        end
       end
 
       context "with future_features flag" do
@@ -650,10 +622,10 @@ describe Puppet::Transaction do
         it "should rescue prefetch executions" do
           transaction.prefetch_if_necessary(resource)
 
-          expect(transaction.prefetched_providers[:sshkey][:parsed]).to be_truthy
+          expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
         end
 
-        it "should mark resources as failed" do
+        it "should mark resources as failed", :unless => RUBY_PLATFORM == 'java' do
           transaction.evaluate
 
           expect(transaction.resource_status(resource).failed?).to be_truthy
@@ -662,30 +634,30 @@ describe Puppet::Transaction do
         it "should mark a provider that has failed prefetch" do
           transaction.prefetch_if_necessary(resource)
 
-          expect(transaction.prefetch_failed_providers[:sshkey][:parsed]).to be_truthy
+          expect(transaction.prefetch_failed_providers[:package][:pkgng]).to be_truthy
         end
 
         describe "and new resources are generated" do
           let(:generator) { Puppet::Type.type(:notify).new :title => "generator" }
           let(:generated) do
-            %w[a b c].map { |name| Puppet::Type.type(:sshkey).new :title => "foo", :name => name, :type => :dsa, :key => "eh", :provider => :parsed }
+            %w[a b c].map { |name| Puppet::Type.type(:package).new :title => "foo", :name => name, :provider => :apt }
           end
 
           before :each do
             catalog.add_resource generator
-            allow(generator).to receive(:generate).and_return(generated)
-            allow(catalog).to receive(:container_of).and_return(generator)
+            generator.stubs(:generate).returns generated
+            catalog.stubs(:container_of).returns 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
-            expect(transaction).to receive(:apply).once
+            transaction.expects(:apply).once
 
             transaction.evaluate
           end
 
-          it "should not fail other resources added after the failing resource" do
+          it "should not fail other resources added after the failing resource", :unless => RUBY_PLATFORM == 'java' do
             new_resource = Puppet::Type.type(:notify).new :name => "baz"
             catalog.add_resource(new_resource)
 
@@ -699,7 +671,7 @@ describe Puppet::Transaction do
             catalog.add_resource(new_resource)
 
             catalog.remove_resource resource2
-            expect(transaction).to receive(:apply).once
+            transaction.expects(:apply).once
 
             transaction.evaluate
 
@@ -715,7 +687,7 @@ describe Puppet::Transaction do
   describe "during teardown" do
     let(:catalog) { Puppet::Resource::Catalog.new }
     let(:transaction) do
-      Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
     end
 
     let(:teardown_type) do
@@ -771,28 +743,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)
-      allow(resource).to receive(:retrieve_resource).and_raise
+      resource.stubs(:retrieve_resource).raises
       catalog.add_resource resource
 
-      expect(resource.provider.class).to receive(:post_resource_eval)
-
-      transaction.evaluate
-    end
-
-    it "should call Selinux.matchpathcon_fini in case Selinux is enabled ", :if => Puppet.features.posix? do
-      unless defined?(Selinux)
-        module Selinux
-          def self.is_selinux_enabled
-            true
-          end
-        end
-      end
-
-      resource = Puppet::Type.type(:file).new(:path => make_absolute("/tmp/foo"))
-      transaction = transaction_with_resource(resource)
-
-      expect(Selinux).to receive(:matchpathcon_fini)
-      expect(Puppet::Util::SELinux).to receive(:selinux_support?).and_return(true)
+      resource.provider.class.expects(:post_resource_eval)
 
       transaction.evaluate
     end
@@ -801,12 +755,12 @@ describe Puppet::Transaction do
   describe 'when checking application run state' do
     before do
       @catalog = Puppet::Resource::Catalog.new
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
     end
 
     context "when stop is requested" do
       before :each do
-        allow(Puppet::Application).to receive(:stop_requested?).and_return(true)
+        Puppet::Application.stubs(:stop_requested?).returns(true)
       end
 
       it 'should return true for :stop_processing?' do
@@ -820,7 +774,7 @@ describe Puppet::Transaction do
     end
 
     it 'should return false for :stop_processing? if Puppet::Application.stop_requested? is false' do
-      allow(Puppet::Application).to receive(:stop_requested?).and_return(false)
+      Puppet::Application.stubs(:stop_requested?).returns(false)
       expect(@transaction.stop_processing?).to be_falsey
     end
 
@@ -828,25 +782,25 @@ describe Puppet::Transaction do
       before do
         @resource = Puppet::Type.type(:notify).new :title => "foobar"
         @catalog.add_resource @resource
-        allow(@transaction).to receive(:add_dynamically_generated_resources)
+        @transaction.stubs(:add_dynamically_generated_resources)
       end
 
       it 'should stop processing if :stop_processing? is true' do
-        allow(@transaction).to receive(:stop_processing?).and_return(true)
-        expect(@transaction).not_to receive(:eval_resource)
+        @transaction.stubs(:stop_processing?).returns(true)
+        @transaction.expects(:eval_resource).never
         @transaction.evaluate
       end
 
       it 'should continue processing if :stop_processing? is false' do
-        allow(@transaction).to receive(:stop_processing?).and_return(false)
-        expect(@transaction).to receive(:eval_resource).and_return(nil)
+        @transaction.stubs(:stop_processing?).returns(false)
+        @transaction.expects(:eval_resource).returns(nil)
         @transaction.evaluate
       end
     end
   end
 
   it "errors with a dependency cycle for a resource that requires itself" do
-    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
@@ -855,7 +809,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a self-requiring resource also required by another resource" do
-    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
@@ -865,7 +819,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that requires itself and another resource" do
-    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle:
@@ -877,7 +831,7 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that is later modified to require itself" do
-    expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: }
@@ -942,30 +896,6 @@ describe Puppet::Transaction do
       expect(transaction.report.resource_statuses['Notify[b]']).to be_skipped
     end
   end
-
-  describe "failed dependency is depended on multiple times" do
-    it "notifies the failed dependency once" do
-      command_string = File.expand_path('/my/command')
-      allow(Puppet::Util::Execution).to receive(:execute).with([command_string]).and_raise(Puppet::ExecutionFailure, "Failed")
-
-      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")
-
-      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']:
-          command => '#{command_string}'
-        } ->
-        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