RubyGems - puppet - Versions diffs - 7.28.0-universal-darwin → 7.29.1-universal-darwin - Mend

puppet 7.28.0-universal-darwin → 7.29.1-universal-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1258) hide show

data/spec/unit/transaction_spec.rb DELETED Viewed

@@ -1,1037 +0,0 @@
-require 'spec_helper'
-require 'matchers/include_in_order'
-require 'puppet_spec/compiler'
-require 'puppet/transaction'
-require 'fileutils'
-describe Puppet::Transaction do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-  def catalog_with_resource(resource)
-    catalog = Puppet::Resource::Catalog.new
-    catalog.add_resource(resource)
-    catalog
-  end
-  def transaction_with_resource(resource)
-    transaction = Puppet::Transaction.new(catalog_with_resource(resource), nil, Puppet::Graph::SequentialPrioritizer.new)
-    transaction
-  end
-  before(:all) do
-    Puppet::Type.newtype(:transaction_generator) do
-      newparam(:name) { isnamevar }
-      def generate
-      end
-    end
-  end
-  after(:all) do
-    Puppet::Type.rmtype(:transaction_generator)
-  end
-  before do
-    @basepath = make_absolute("/what/ever")
-    @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
-    resource = Puppet::Type.type(:notify).new :title => "foobar"
-    transaction = transaction_with_resource(resource)
-    transaction.evaluate
-    expect(transaction.resource_status(resource.to_s)).to be_changed
-  end
-  # This will basically only ever be used during testing.
-  it "should automatically create resource statuses if asked for a non-existent status" do
-    resource = Puppet::Type.type(:notify).new :title => "foobar"
-    transaction = transaction_with_resource(resource)
-    expect(transaction.resource_status(resource)).to be_instance_of(Puppet::Resource::Status)
-  end
-  it "should add provided resource statuses to its report" do
-    resource = Puppet::Type.type(:notify).new :title => "foobar"
-    transaction = transaction_with_resource(resource)
-    transaction.evaluate
-    status = transaction.resource_status(resource)
-    expect(transaction.report.resource_statuses[resource.to_s]).to equal(status)
-  end
-  it "should not consider there to be failed or failed_to_restart resources if no statuses are marked failed" do
-    resource = Puppet::Type.type(:notify).new :title => "foobar"
-    transaction = transaction_with_resource(resource)
-    transaction.evaluate
-    expect(transaction).not_to be_any_failed
-  end
-  it "should use the provided report object" do
-    report = Puppet::Transaction::Report.new
-    transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, report, nil)
-    expect(transaction.report).to eq(report)
-  end
-  it "should create a report if none is provided" do
-    transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
-    expect(transaction.report).to be_kind_of Puppet::Transaction::Report
-  end
-  describe "when initializing" do
-    it "should create an event manager" do
-      transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
-      expect(transaction.event_manager).to be_instance_of(Puppet::Transaction::EventManager)
-      expect(transaction.event_manager.transaction).to equal(transaction)
-    end
-    it "should create a resource harness" do
-      transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
-      expect(transaction.resource_harness).to be_instance_of(Puppet::Transaction::ResourceHarness)
-      expect(transaction.resource_harness.transaction).to equal(transaction)
-    end
-    it "should set retrieval time on the report" do
-      catalog = Puppet::Resource::Catalog.new
-      report = Puppet::Transaction::Report.new
-      catalog.retrieval_duration = 5
-      expect(report).to receive(:add_times).with(:config_retrieval, 5)
-      Puppet::Transaction.new(catalog, report, nil)
-    end
-  end
-  describe "when evaluating a resource" do
-    let(:resource) { Puppet::Type.type(:file).new :path => @basepath }
-    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.evaluate
-    end
-    describe "and the resource should be skipped" 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.evaluate
-        expect(transaction.resource_status(resource)).to be_skipped
-      end
-      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.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.evaluate
-      end
-    end
-  end
-  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)
-    end
-    it "should persist in the transactionstore" do
-      Puppet[:transactionstorefile] = tmpfile('persistence_test')
-      resource = Puppet::Type.type(:notify).new :title => "foobar"
-      transaction = transaction_with_resource(resource)
-      transaction.evaluate
-      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.evaluate
-      expect(transaction.resource_status(resource)).to be_skipped
-      persistence = Puppet::Transaction::Persistence.new
-      persistence.load
-      expect(persistence.get_system_value(resource.ref, "message")).to eq(["foobar"])
-    end
-  end
-  describe "when applying a resource" do
-    before do
-      @catalog = Puppet::Resource::Catalog.new
-      @resource = Puppet::Type.type(:file).new :path => @basepath
-      @catalog.add_resource(@resource)
-      @status = Puppet::Resource::Status.new(@resource)
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
-      allow(@transaction.event_manager).to receive(:queue_events)
-    end
-    it "should use its resource harness to apply the resource" do
-      expect(@transaction.resource_harness).to receive(: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.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.evaluate
-    end
-    it "should log and skip any resources that cannot be applied" do
-      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
-      expect(@resource).to receive(:properties).and_raise(ArgumentError)
-      @transaction.evaluate
-      expect(@transaction).to be_any_failed
-    end
-    it "should report any_failed if any resources failed to restart" do
-      @transaction.evaluate
-      @transaction.report.resource_statuses[@resource.to_s].failed_to_restart = true
-      expect(@transaction).to be_any_failed
-    end
-  end
-  describe "#unblock" do
-    let(:graph) { @transaction.relationship_graph }
-    let(:resource) { Puppet::Type.type(:notify).new(:name => 'foo') }
-    it "should calculate the number of blockers if it's not known" do
-      graph.add_vertex(resource)
-      3.times do |i|
-        other = Puppet::Type.type(:notify).new(:name => i.to_s)
-        graph.add_vertex(other)
-        graph.add_edge(other, resource)
-      end
-      graph.unblock(resource)
-      expect(graph.blockers[resource]).to eq(2)
-    end
-    it "should decrement the number of blockers if there are any" do
-      graph.blockers[resource] = 40
-      graph.unblock(resource)
-      expect(graph.blockers[resource]).to eq(39)
-    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")
-      graph.blockers[vertex] = 0
-      graph.unblock(vertex)
-    end
-    it "should return true if the resource is now unblocked" do
-      graph.blockers[resource] = 1
-      expect(graph.unblock(resource)).to eq(true)
-    end
-    it "should return false if the resource is still blocked" do
-      graph.blockers[resource] = 2
-      expect(graph.unblock(resource)).to eq(false)
-    end
-  end
-  describe "when traversing" do
-    let(:path) { tmpdir('eval_generate') }
-    let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
-    before :each do
-      @transaction.catalog.add_resource(resource)
-    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)
-      yielded = false
-      @transaction.evaluate do |res|
-        yielded = true if res == resource
-      end
-      expect(yielded).to eq(true)
-    end
-    it "should prefetch the provider if necessary" do
-      expect(@transaction).to receive(:prefetch_if_necessary).with(resource)
-      @transaction.evaluate {}
-    end
-    it "traverses independent resources before dependent resources" do
-      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-      @transaction.catalog.add_resource(dependent)
-      seen = []
-      @transaction.evaluate do |res|
-        seen << res
-      end
-      expect(seen).to include_in_order(resource, dependent)
-    end
-    it "traverses completely independent resources in the order they appear in the catalog" do
-      independent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-      @transaction.catalog.add_resource(independent)
-      seen = []
-      @transaction.evaluate do |res|
-        seen << res
-      end
-      expect(seen).to include_in_order(resource, independent)
-    end
-    it "should fail unsuitable resources and go on if it gets blocked" do
-      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-      @transaction.catalog.add_resource(dependent)
-      allow(resource).to receive(:suitable?).and_return(false)
-      evaluated = []
-      @transaction.evaluate do |res|
-        evaluated << res
-      end
-      # We should have gone on to evaluate the children
-      expect(evaluated).to eq([dependent])
-      expect(@transaction.resource_status(resource)).to be_failed
-    end
-  end
-  describe "when generating resources before traversal" do
-    let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) { Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new) }
-    let(:generator) { Puppet::Type.type(:transaction_generator).new :title => "generator" }
-    let(:generated) do
-      %w[a b c].map { |name| Puppet::Type.type(:transaction_generator).new(:name => name) }
-    end
-    before :each do
-      catalog.add_resource generator
-      allow(generator).to receive(:generate).and_return(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)
-    end
-    it "should call 'generate' on all created resources" do
-      generated.each { |res| expect(res).to receive(:generate) }
-      transaction.evaluate
-    end
-    it "should finish all resources" do
-      generated.each { |res| expect(res).to receive(:finish) }
-      transaction.evaluate
-    end
-    it "should copy all tags to the newly generated resources" do
-      generator.tag('one', 'two')
-      transaction.evaluate
-      generated.each do |res|
-        expect(res).to be_tagged(*generator.tags)
-      end
-    end
-  end
-  describe "after resource traversal" do
-    let(:catalog) { Puppet::Resource::Catalog.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)
-    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)
-      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
-      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
-      expect(generator).to receive(:resources_failed_to_generate).and_return(false)
-      expect(report).not_to receive(:resources_failed_to_generate=)
-      transaction.evaluate
-    end
-  end
-  describe "when performing pre-run checks" do
-    let(:resource) { Puppet::Type.type(:notify).new(:title => "spec") }
-    let(:transaction) { transaction_with_resource(resource) }
-    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)
-      transaction.evaluate
-    end
-    it "should abort the transaction on failure" do
-      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
-      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
-  end
-  describe "when skipping a resource" do
-    before :each do
-      @resource = Puppet::Type.type(:notify).new :name => "foo"
-      @catalog = Puppet::Resource::Catalog.new
-      @resource.catalog = @catalog
-      @transaction = Puppet::Transaction.new(@catalog, nil, nil)
-    end
-    it "should skip resource with missing tags" do
-      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
-      allow(@transaction).to receive(:skip_tags?).and_return(true)
-      expect(@transaction).to be_skip(@resource)
-    end
-    it "should skip unscheduled resources" do
-      allow(@transaction).to receive(:scheduled?).and_return(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)
-      expect(@transaction).to be_skip(@resource)
-    end
-    it "should skip virtual resource" do
-      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
-      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
-      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
-      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
-      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
-      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
-  end
-  describe "when determining if tags are missing" do
-    before :each do
-      @resource = Puppet::Type.type(:notify).new :name => "foo"
-      @catalog = Puppet::Resource::Catalog.new
-      @resource.catalog = @catalog
-      @transaction = Puppet::Transaction.new(@catalog, nil, nil)
-      allow(@transaction).to receive(:ignore_tags?).and_return(false)
-    end
-    it "should not be missing tags if tags are being ignored" do
-      expect(@transaction).to receive(:ignore_tags?).and_return(true)
-      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 = []
-      expect(@resource).not_to receive(:tagged?)
-      expect(@transaction).not_to be_missing_tags(@resource)
-    end
-    it "should otherwise let the resource determine if it is missing tags" do
-      tags = ['one', 'two']
-      @transaction.tags = tags
-      expect(@transaction).to be_missing_tags(@resource)
-    end
-  end
-  describe "when determining if a resource should be scheduled" do
-    before :each 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::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.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.evaluate
-    end
-  end
-  describe "when prefetching" do
-    let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) { Puppet::Transaction.new(catalog, nil, nil) }
-    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
-      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
-      expect(resource.provider.class).to receive(: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[:package][:pkgng] = true
-      expect(resource.provider.class).not_to receive(:prefetch)
-      transaction.prefetch_if_necessary(resource)
-    end
-    it "should mark the provider prefetched" do
-      allow(resource.provider.class).to receive(:prefetch)
-      transaction.prefetch_if_necessary(resource)
-      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(:package).new :name => "other"
-      other.instance_variable_set(:@provider, nil)
-      catalog.add_resource 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
-    it "should not prefetch a provider which has failed" do
-      transaction.prefetch_failed_providers[:package][:pkgng] = true
-      expect(resource.provider.class).not_to receive(:prefetch)
-      transaction.prefetch_if_necessary(resource)
-    end
-    it "should not rescue SystemExit" do
-      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 mark resources as failed when prefetching raises LoadError" do
-      expect(resource.provider.class).to receive(:prefetch).and_raise(LoadError, "LoadMessage")
-      transaction.prefetch_if_necessary(resource)
-      expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
-    end
-    describe "and prefetching raises Puppet::Error" do
-      before :each do
-        expect(resource.provider.class).to receive(:prefetch).and_raise(Puppet::Error, "message")
-      end
-      it "should rescue prefetch executions" do
-        transaction.prefetch_if_necessary(resource)
-        expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
-      end
-      it "should mark resources as failed", :unless => RUBY_PLATFORM == 'java' do
-        transaction.evaluate
-        expect(transaction.resource_status(resource).failed?).to be_truthy
-      end
-      it "should mark a provider that has failed prefetch" do
-        transaction.prefetch_if_necessary(resource)
-        expect(transaction.prefetch_failed_providers[:package][:pkgng]).to be_truthy
-      end
-      describe "and new resources are generated" do
-        let(:generator) { Puppet::Type.type(:transaction_generator).new :title => "generator" }
-        let(:generated) do
-          %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)
-        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.evaluate
-        end
-        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)
-          transaction.evaluate
-          expect(transaction.resource_status(new_resource).failed?).to be_falsey
-        end
-        it "should fail other resources that require the failing resource" do
-          new_resource = Puppet::Type.type(:notify).new(:name => "baz", :require => resource)
-          catalog.add_resource(new_resource)
-          catalog.remove_resource resource2
-          expect(transaction).to receive(:apply).once
-          transaction.evaluate
-          expect(transaction.resource_status(resource).failed?).to be_truthy
-          expect(transaction.resource_status(new_resource).dependency_failed?).to be_truthy
-          expect(transaction.skip?(new_resource)).to be_truthy
-        end
-      end
-    end
-  end
-  describe "during teardown" do
-    let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) do
-      Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
-    end
-    let(:teardown_type) do
-      Puppet::Type.newtype(:teardown_test) do
-        newparam(:name) {}
-      end
-    end
-    before :each do
-      teardown_type.provide(:teardown_provider) do
-        class << self
-          attr_reader :result
-          def post_resource_eval
-            @result = 'passed'
-          end
-        end
-      end
-    end
-    it "should call ::post_resource_eval on provider classes that support it" do
-      resource = teardown_type.new(:title => "foo", :provider => :teardown_provider)
-      transaction = transaction_with_resource(resource)
-      transaction.evaluate
-      expect(resource.provider.class.result).to eq('passed')
-    end
-    it "should call ::post_resource_eval even if other providers' ::post_resource_eval fails" do
-      teardown_type.provide(:always_fails) do
-        class << self
-          attr_reader :result
-          def post_resource_eval
-            @result = 'failed'
-            raise Puppet::Error, "This provider always fails"
-          end
-        end
-      end
-      good_resource = teardown_type.new(:title => "bloo", :provider => :teardown_provider)
-      bad_resource  = teardown_type.new(:title => "blob", :provider => :always_fails)
-      catalog.add_resource(bad_resource)
-      catalog.add_resource(good_resource)
-      transaction.evaluate
-      expect(good_resource.provider.class.result).to eq('passed')
-      expect(bad_resource.provider.class.result).to eq('failed')
-    end
-    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
-      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
-      selinux = double('selinux', is_selinux_enabled: true, matchpathcon_fini: nil)
-      stub_const('Selinux', selinux)
-      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)
-      transaction.evaluate
-    end
-  end
-  describe 'when checking application run state' do
-    before do
-      @catalog = Puppet::Resource::Catalog.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)
-      end
-      it 'should return true for :stop_processing?' do
-        expect(@transaction).to be_stop_processing
-      end
-      it 'always evaluates non-host_config catalogs' do
-        @catalog.host_config = false
-        expect(@transaction).not_to be_stop_processing
-      end
-    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)
-      expect(@transaction.stop_processing?).to be_falsey
-    end
-    describe 'within an evaluate call' do
-      before do
-        @resource = Puppet::Type.type(:notify).new :title => "foobar"
-        @catalog.add_resource @resource
-      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.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.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)
-    expect do
-      apply_compiled_manifest(<<-MANIFEST)
-        notify { cycle: require => Notify[cycle] }
-      MANIFEST
-    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
-  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)
-    expect do
-      apply_compiled_manifest(<<-MANIFEST)
-        notify { cycle: require => Notify[cycle] }
-        notify { other: require => Notify[cycle] }
-      MANIFEST
-    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
-  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)
-    expect do
-      apply_compiled_manifest(<<-MANIFEST)
-        notify { cycle:
-          require => [Notify[other], Notify[cycle]]
-        }
-        notify { other: }
-      MANIFEST
-    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
-  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)
-    expect do
-      apply_compiled_manifest(<<-MANIFEST)
-        notify { cycle: }
-        Notify <| title == 'cycle' |> {
-          require => Notify[cycle]
-        }
-      MANIFEST
-    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
-  end
-  context "when generating a report for a transaction with a dependency cycle" do
-    let(:catalog) do
-      compile_to_ral(<<-MANIFEST)
-        notify { foo: require => Notify[bar] }
-        notify { bar: require => Notify[foo] }
-      MANIFEST
-    end
-    let(:prioritizer) { Puppet::Graph::SequentialPrioritizer.new }
-    let(:transaction) { Puppet::Transaction.new(catalog,
-                                          Puppet::Transaction::Report.new("apply"),
-                                          prioritizer) }
-    before(:each) do
-      expect { transaction.evaluate }.to raise_error(Puppet::Error)
-      transaction.report.finalize_report
-    end
-    it "should report resources involved in a dependency cycle as failed" do
-      expect(transaction.report.resource_statuses['Notify[foo]']).to be_failed
-      expect(transaction.report.resource_statuses['Notify[bar]']).to be_failed
-    end
-    it "should generate a failure event for a resource in a dependency cycle" do
-      status = transaction.report.resource_statuses['Notify[foo]']
-      expect(status.events.first.status).to eq('failure')
-      expect(status.events.first.message).to eq('resource is part of a dependency cycle')
-    end
-    it "should report that the transaction is failed" do
-      expect(transaction.report.status).to eq('failed')
-    end
-  end
-  it "reports a changed resource with a successful run" do
-    transaction = apply_compiled_manifest("notify { one: }")
-    expect(transaction.report.status).to eq('changed')
-    expect(transaction.report.resource_statuses['Notify[one]']).to be_changed
-  end
-  describe "when interrupted" do
-    it "marks unprocessed resources as skipped" do
-      Puppet::Application.stop!
-      transaction = apply_compiled_manifest(<<-MANIFEST)
-        notify { a: } ->
-        notify { b: }
-      MANIFEST
-      expect(transaction.report.resource_statuses['Notify[a]']).to be_skipped
-      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
-  describe "failed dependency is depended on multiple times" do
-    it "notifies and warns the failed class dependency once" do
-      Puppet.settings[:merge_dependency_warnings] = true
-      command_string = File.expand_path('/my/command')
-      allow(Puppet::Util::Execution).to receive(:execute).with([command_string]).and_raise(Puppet::ExecutionFailure, "Failed")
-      # Exec['exec1'] is outside of a class, so it's warning is not subject to being coalesced.
-      times_send_log_with_skipping_called = 0
-      allow_any_instance_of(Puppet::Type::Exec).to receive(:send_log) {times_send_log_with_skipping_called += 1; nil}.with(:warning, "Skipping because of failed dependencies")
-      # Class['declared_class'] depends upon Class['required_class'] which contains a resource with a failure.
-      times_send_log_with_class_dependency_called = 0
-      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_dependency_called += 1; nil}.with(:notice, "Class dependency Exec[exec2] has failures: true")
-      times_send_log_with_class_skipping_called = 0
-      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_skipping_called += 1; nil}.with(:warning, "Skipping resources in class because of failed class dependencies")
-      apply_compiled_manifest(<<-MANIFEST)
-        class required_class {
-          exec { 'exec2':
-            command => '#{command_string}'
-          }
-        }
-        class declared_class {
-          require required_class
-          exec { 'exec3':
-            command => '#{command_string}'
-          }
-          exec { 'exec4':
-            command => '#{command_string}'
-          }
-        }
-        exec { 'exec1':
-          command => '#{command_string}',
-          require => Exec['exec2']
-        }
-        include declared_class
-      MANIFEST
-      expect(times_send_log_with_skipping_called).to eq(1)
-      expect(times_send_log_with_class_dependency_called).to eq(1)
-      expect(times_send_log_with_class_skipping_called).to eq(1)
-    end
-  end
-end
-describe Puppet::Transaction, " when determining tags" do
-  before do
-    @config = Puppet::Resource::Catalog.new
-    @transaction = Puppet::Transaction.new(@config, nil, nil)
-  end
-  it "should default to the tags specified in the :tags setting" do
-    Puppet[:tags] = "one"
-    expect(@transaction).to be_tagged("one")
-  end
-  it "should split tags based on ','" do
-    Puppet[:tags] = "one,two"
-    expect(@transaction).to be_tagged("one")
-    expect(@transaction).to be_tagged("two")
-  end
-  it "should use any tags set after creation" do
-    Puppet[:tags] = ""
-    @transaction.tags = %w{one two}
-    expect(@transaction).to be_tagged("one")
-    expect(@transaction).to be_tagged("two")
-  end
-  it "should always convert assigned tags to an array" do
-    @transaction.tags = "one::two"
-    expect(@transaction).to be_tagged("one::two")
-  end
-  it "should tag one::two only as 'one::two' and not 'one', 'two', and 'one::two'" do
-    @transaction.tags = "one::two"
-    expect(@transaction).to be_tagged("one::two")
-    expect(@transaction).to_not be_tagged("one")
-    expect(@transaction).to_not be_tagged("two")
-  end
-  it "should accept a comma-delimited string" do
-    @transaction.tags = "one, two"
-    expect(@transaction).to be_tagged("one")
-    expect(@transaction).to be_tagged("two")
-  end
-  it "should accept an empty string" do
-    @transaction.tags = "one, two"
-    expect(@transaction).to be_tagged("one")
-    @transaction.tags = ""
-    expect(@transaction).not_to be_tagged("one")
-  end
-end