puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/transaction/event_manager_spec.rb

@@ -147,7 +147,7 @@ describe Puppet::Transaction::EventManager do
 
   describe "when processing events for a given resource" do
     before do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
       @manager = Puppet::Transaction::EventManager.new(@transaction)
       @manager.stubs(:queue_events)
 
@@ -271,7 +271,7 @@ describe Puppet::Transaction::EventManager do
 
   describe "when queueing then processing events for a given resource" do
     before do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
       @manager = Puppet::Transaction::EventManager.new(@transaction)
 
       @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")

data/spec/unit/transaction/event_spec.rb

@@ -140,4 +140,61 @@ describe Puppet::Transaction::Event do
       event.to_yaml_properties.should =~ Puppet::Transaction::Event::YAML_ATTRIBUTES
     end
   end
+
+  it "should round trip through pson" do
+      resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
+      event = Puppet::Transaction::Event.new(
+        :source_description => "/my/param",
+        :resource => resource,
+        :file => "/foo.rb",
+        :line => 27,
+        :tags => %w{one two},
+        :desired_value => 7,
+        :historical_value => 'Brazil',
+        :message => "Help I'm trapped in a spec test",
+        :name => :mode_changed,
+        :previous_value => 6,
+        :property => :mode,
+        :status => 'success')
+
+      tripped = Puppet::Transaction::Event.from_pson(PSON.parse(event.to_pson))
+
+      tripped.audited.should == event.audited
+      tripped.property.should == event.property
+      tripped.previous_value.should == event.previous_value
+      tripped.desired_value.should == event.desired_value
+      tripped.historical_value.should == event.historical_value
+      tripped.message.should == event.message
+      tripped.name.should == event.name
+      tripped.status.should == event.status
+      tripped.time.should == event.time
+  end
+
+  it "should round trip an event for an inspect report through pson" do
+      resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
+      event = Puppet::Transaction::Event.new(
+        :audited => true,
+        :source_description => "/my/param",
+        :resource => resource,
+        :file => "/foo.rb",
+        :line => 27,
+        :tags => %w{one two},
+        :message => "Help I'm trapped in a spec test",
+        :previous_value => 6,
+        :property => :mode,
+        :status => 'success')
+
+      tripped = Puppet::Transaction::Event.from_pson(PSON.parse(event.to_pson))
+
+      tripped.desired_value.should be_nil
+      tripped.historical_value.should be_nil
+      tripped.name.should be_nil
+
+      tripped.audited.should == event.audited
+      tripped.property.should == event.property
+      tripped.previous_value.should == event.previous_value
+      tripped.message.should == event.message
+      tripped.status.should == event.status
+      tripped.time.should == event.time
+  end
 end

data/spec/unit/transaction/report_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+require 'puppet'
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
@@ -32,12 +33,22 @@ describe Puppet::Transaction::Report do
     Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version.should == "some configuration version"
   end
 
+  it "should take a 'transaction_uuid' as an argument" do
+    Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment", "some transaction uuid").transaction_uuid.should == "some transaction uuid"
+  end
+
   it "should be able to set configuration_version" do
     report = Puppet::Transaction::Report.new("inspect")
     report.configuration_version = "some version"
     report.configuration_version.should == "some version"
   end
 
+  it "should be able to set transaction_uuid" do
+    report = Puppet::Transaction::Report.new("inspect")
+    report.transaction_uuid = "some transaction uuid"
+    report.transaction_uuid.should == "some transaction uuid"
+  end
+
   it "should take 'environment' as an argument" do
     Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment.should == "some environment"
   end
@@ -82,6 +93,18 @@ describe Puppet::Transaction::Report do
     end
   end
 
+  describe "#as_logging_destination" do
+    it "makes the report collect logs during the block " do
+      log_string = 'Hello test report!'
+      report = Puppet::Transaction::Report.new('test')
+      report.as_logging_destination do
+        Puppet.err(log_string)
+      end
+
+      expect(report.logs.collect(&:message)).to include(log_string)
+    end
+  end
+
   describe "when accepting resource statuses" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
@@ -351,4 +374,47 @@ describe Puppet::Transaction::Report do
       report.to_yaml_properties.should_not include('@external_times')
     end
   end
+
+  it "can make a round trip through pson" do
+    status = Puppet::Resource::Status.new(Puppet::Type.type(:notify).new(:title => "a resource"))
+    status.changed = true
+
+    report = Puppet::Transaction::Report.new('testy', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
+    report.add_times("timing", 4)
+    report.add_resource_status(status)
+    report.finalize_report
+
+    tripped = Puppet::Transaction::Report.convert_from(:pson, report.render(:pson))
+
+    tripped.host.should == report.host
+    tripped.time.should == report.time
+    tripped.configuration_version.should == report.configuration_version
+    tripped.transaction_uuid.should == report.transaction_uuid
+    tripped.report_format.should == report.report_format
+    tripped.puppet_version.should == report.puppet_version
+    tripped.kind.should == report.kind
+    tripped.status.should == report.status
+    tripped.environment.should == report.environment
+
+    logs_as_strings(tripped).should == logs_as_strings(report)
+    metrics_as_hashes(tripped).should == metrics_as_hashes(report)
+    resource_statuses_as_hashes(tripped).should == resource_statuses_as_hashes(report)
+  end
+
+  def logs_as_strings(report)
+    report.logs.map(&:to_report)
+  end
+
+  def metrics_as_hashes(report)
+    Hash[*report.metrics.collect do |name, m|
+      [name, { :name => m.name, :label => m.label, :value => m.value }]
+    end.flatten]
+  end
+
+  def resource_statuses_as_hashes(report)
+    Hash[*report.resource_statuses.collect do |name, s|
+      [name, PSON.parse(s.to_pson)]
+    end.flatten]
+  end
 end

data/spec/unit/transaction/resource_harness_spec.rb

@@ -11,13 +11,11 @@ describe Puppet::Transaction::ResourceHarness do
     @mode_755 = Puppet.features.microsoft_windows? ? '644' : '755'
     path = make_absolute("/my/file")
 
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
     @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
-    @status = Puppet::Resource::Status.new(@resource)
-    Puppet::Resource::Status.stubs(:new).returns @status
   end
 
   it "should accept a transaction at initialization" do
@@ -31,28 +29,38 @@ describe Puppet::Transaction::ResourceHarness do
   end
 
   describe "when evaluating a resource" do
-    it "should create and return a resource status instance for the resource" do
-      @harness.evaluate(@resource).should be_instance_of(Puppet::Resource::Status)
-    end
-
-    it "should fail if no status can be created" do
-      Puppet::Resource::Status.expects(:new).raises ArgumentError
+    it "produces a resource state that describes what happened with the resource" do
+      status = @harness.evaluate(@resource)
 
-      lambda { @harness.evaluate(@resource) }.should raise_error
+      status.resource.should == @resource.ref
+      status.should_not be_failed
+      status.events.should be_empty
     end
 
-    it "should retrieve the current state of the resource" do
+    it "retrieves the current state of the resource" do
       @resource.expects(:retrieve).returns @current_state
+
       @harness.evaluate(@resource)
     end
 
-    it "should mark the resource as failed and return if the current state cannot be retrieved" do
-      @resource.expects(:retrieve).raises ArgumentError
-      @harness.evaluate(@resource).should be_failed
+    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))
+
+      status = @harness.evaluate(@resource)
+
+      status.should be_failed
+      events_to_hash(status.events).collect do |event|
+        { :@status => event[:@status], :@message => event[:@message] }
+      end.should == [{ :@status => "failure", :@message => the_message }]
     end
 
-    it "should store the resource's evaluation time in the resource status" do
-      @harness.evaluate(@resource).evaluation_time.should be_instance_of(Float)
+    it "records the time it took to evaluate the resource" do
+      before = Time.now
+      status = @harness.evaluate(@resource)
+      after = Time.now
+
+      status.evaluation_time.should be <= after - before
     end
   end
 
@@ -470,17 +478,16 @@ describe Puppet::Transaction::ResourceHarness do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
-      @status = Puppet::Resource::Status.new(@resource)
     end
 
     it "should return true if 'ignoreschedules' is set" do
       Puppet[:ignoreschedules] = true
       @resource[:schedule] = "meh"
-      @harness.should be_scheduled(@status, @resource)
+      @harness.should be_scheduled(@resource)
     end
 
     it "should return true if the resource has no schedule set" do
-      @harness.should be_scheduled(@status, @resource)
+      @harness.should be_scheduled(@resource)
     end
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
@@ -493,7 +500,7 @@ describe Puppet::Transaction::ResourceHarness do
 
       sched.expects(:match?).with(t.to_i).returns "feh"
 
-      @harness.scheduled?(@status, @resource).should == "feh"
+      @harness.scheduled?(@resource).should == "feh"
     end
   end
 

data/spec/unit/transaction_spec.rb

@@ -1,50 +1,37 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'matchers/include_in_order'
+require 'puppet_spec/compiler'
 
 require 'puppet/transaction'
 require 'fileutils'
 
-def without_warnings
-  flag = $VERBOSE
-  $VERBOSE = nil
-  yield
-  $VERBOSE = flag
-end
-
 describe Puppet::Transaction do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
-  before do
-    @basepath = make_absolute("/what/ever")
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+  def catalog_with_resource(resource)
+    catalog = Puppet::Resource::Catalog.new
+    catalog.add_resource(resource)
+    catalog
   end
 
-  it "should delegate its event list to the event manager" do
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
-    @transaction.event_manager.expects(:events).returns %w{my events}
-    @transaction.events.should == %w{my events}
-  end
-
-  it "should delegate adding times to its report" do
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
-    @transaction.report.expects(:add_times).with(:foo, 10)
-    @transaction.report.expects(:add_times).with(:bar, 20)
-
-    @transaction.add_times :foo => 10, :bar => 20
+  def transaction_with_resource(resource)
+    transaction = Puppet::Transaction.new(catalog_with_resource(resource), nil, Puppet::Graph::RandomPrioritizer.new)
+    transaction
   end
 
-  it "should be able to accept resource status instances" do
-    resource = Puppet::Type.type(:notify).new :title => "foobar"
-    status = Puppet::Resource::Status.new(resource)
-    @transaction.add_resource_status(status)
-    @transaction.resource_status(resource).should equal(status)
+  before do
+    @basepath = make_absolute("/what/ever")
+    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, Puppet::Graph::RandomPrioritizer.new)
   end
 
   it "should be able to look resource status up by resource reference" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
-    status = Puppet::Resource::Status.new(resource)
-    @transaction.add_resource_status(status)
-    @transaction.resource_status(resource.to_s).should equal(status)
+    transaction = transaction_with_resource(resource)
+    transaction.evaluate
+
+    transaction.resource_status(resource.to_s).should be_changed
   end
 
   # This will basically only ever be used during testing.
@@ -55,86 +42,72 @@ describe Puppet::Transaction do
 
   it "should add provided resource statuses to its report" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
-    status = Puppet::Resource::Status.new(resource)
-    @transaction.add_resource_status(status)
-    @transaction.report.resource_statuses[resource.to_s].should equal(status)
-  end
-
-  it "should consider a resource to be failed if a status instance exists for that resource and indicates it is failed" do
-    resource = Puppet::Type.type(:notify).new :name => "yayness"
-    status = Puppet::Resource::Status.new(resource)
-    status.failed = "some message"
-    @transaction.add_resource_status(status)
-    @transaction.should be_failed(resource)
-  end
-
-  it "should not consider a resource to be failed if a status instance exists for that resource but indicates it is not failed" do
-    resource = Puppet::Type.type(:notify).new :name => "yayness"
-    status = Puppet::Resource::Status.new(resource)
-    @transaction.add_resource_status(status)
-    @transaction.should_not be_failed(resource)
-  end
+    transaction = transaction_with_resource(resource)
+    transaction.evaluate
 
-  it "should consider there to be failed resources if any statuses are marked failed" do
-    resource = Puppet::Type.type(:notify).new :name => "yayness"
-    status = Puppet::Resource::Status.new(resource)
-    status.failed = "some message"
-    @transaction.add_resource_status(status)
-    @transaction.should be_any_failed
+    status = transaction.resource_status(resource)
+    transaction.report.resource_statuses[resource.to_s].should equal(status)
   end
 
   it "should not consider there to be failed resources if no statuses are marked failed" do
-    resource = Puppet::Type.type(:notify).new :name => "yayness"
-    status = Puppet::Resource::Status.new(resource)
-    @transaction.add_resource_status(status)
-    @transaction.should_not be_any_failed
+    resource = Puppet::Type.type(:notify).new :title => "foobar"
+    transaction = transaction_with_resource(resource)
+    transaction.evaluate
+
+    transaction.should_not be_any_failed
   end
 
   it "should use the provided report object" do
     report = Puppet::Transaction::Report.new("apply")
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, report)
+    transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, report, nil)
 
-    @transaction.report.should == report
+    transaction.report.should == report
   end
 
   it "should create a report if none is provided" do
-    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+    transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
 
-    @transaction.report.should be_kind_of Puppet::Transaction::Report
+    transaction.report.should 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)
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
       @transaction.event_manager.should be_instance_of(Puppet::Transaction::EventManager)
       @transaction.event_manager.transaction.should equal(@transaction)
     end
 
     it "should create a resource harness" do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
       @transaction.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
       @transaction.resource_harness.transaction.should equal(@transaction)
     end
+
+    it "should set retrieval time on the report" do
+      catalog = Puppet::Resource::Catalog.new
+      report = Puppet::Transaction::Report.new("apply")
+      catalog.retrieval_duration = 5
+
+      report.expects(:add_times).with(:config_retrieval, 5)
+
+      transaction = Puppet::Transaction.new(catalog, report, nil)
+    end
   end
 
   describe "when evaluating a resource" do
     before do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
-      @transaction.stubs(:skip?).returns false
-
+      @catalog = Puppet::Resource::Catalog.new
       @resource = Puppet::Type.type(:file).new :path => @basepath
-    end
+      @catalog.add_resource(@resource)
 
-    it "should check whether the resource should be skipped" do
-      @transaction.expects(:skip?).with(@resource).returns false
-
-      @transaction.eval_resource(@resource)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      @transaction.stubs(:skip?).returns false
     end
 
     it "should process events" do
       @transaction.event_manager.expects(:process_events).with(@resource)
 
-      @transaction.eval_resource(@resource)
+      @transaction.evaluate
     end
 
     describe "and the resource should be skipped" do
@@ -143,7 +116,7 @@ describe Puppet::Transaction do
       end
 
       it "should mark the resource's status as skipped" do
-        @transaction.eval_resource(@resource)
+        @transaction.evaluate
         @transaction.resource_status(@resource).should be_skipped
       end
     end
@@ -151,149 +124,44 @@ describe Puppet::Transaction do
 
   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(Puppet::Resource::Catalog.new)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
       @transaction.event_manager.stubs(:queue_events)
-      @transaction.resource_harness.stubs(:evaluate).returns(@status)
     end
 
     it "should use its resource harness to apply the resource" do
       @transaction.resource_harness.expects(:evaluate).with(@resource)
-      @transaction.apply(@resource)
+      @transaction.evaluate
     end
 
     it "should add the resulting resource status to its status list" do
-      @transaction.apply(@resource)
+      @transaction.resource_harness.stubs(:evaluate).returns(@status)
+      @transaction.evaluate
       @transaction.resource_status(@resource).should 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"])
-      @transaction.apply(@resource)
+      @transaction.evaluate
     end
 
     it "should log and skip any resources that cannot be applied" do
-      @transaction.resource_harness.expects(:evaluate).raises ArgumentError
-      @resource.expects(:err)
-      @transaction.apply(@resource)
-      @transaction.report.resource_statuses[@resource.to_s].should be_nil
+      @resource.expects(:properties).raises ArgumentError
+      @transaction.evaluate
+      @transaction.report.resource_statuses[@resource.to_s].should be_failed
     end
-  end
 
-  describe "#eval_generate" do
-    let(:path) { tmpdir('eval_generate') }
-    let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
-    let(:graph) { @transaction.relationship_graph }
+    it "should report any_failed if any resources failed" do
+      @resource.expects(:properties).raises ArgumentError
+      @transaction.evaluate
 
-    def find_vertex(type, title)
-      graph.vertices.find {|v| v.type == type and v.title == title}
-    end
-
-    before :each do
-      @filenames = []
-
-      'a'.upto('c') do |x|
-        @filenames << File.join(path,x)
-
-        'a'.upto('c') do |y|
-          @filenames << File.join(path,x,y)
-          FileUtils.mkdir_p(File.join(path,x,y))
-
-          'a'.upto('c') do |z|
-            @filenames << File.join(path,x,y,z)
-            FileUtils.touch(File.join(path,x,y,z))
-          end
-        end
-      end
-
-      @transaction.catalog.add_resource(resource)
-    end
-
-    it "should add the generated resources to the catalog" do
-      @transaction.eval_generate(resource)
-
-      @filenames.each do |file|
-        @transaction.catalog.resource(:file, file).must be_a(Puppet::Type.type(:file))
-      end
-    end
-
-    it "should add a sentinel whit for the resource" do
-      @transaction.eval_generate(resource)
-
-      find_vertex(:whit, "completed_#{path}").must be_a(Puppet::Type.type(:whit))
-    end
-
-    it "should replace dependencies on the resource with dependencies on the sentinel" do
-      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-
-      @transaction.catalog.add_resource(dependent)
-
-      res = find_vertex(resource.type, resource.title)
-      generated = find_vertex(dependent.type, dependent.title)
-
-      graph.should be_edge(res, generated)
-
-      @transaction.eval_generate(resource)
-
-      sentinel = find_vertex(:whit, "completed_#{path}")
-
-      graph.should be_edge(sentinel, generated)
-      graph.should_not be_edge(res, generated)
-    end
-
-    it "should add an edge from the nearest ancestor to the generated resource" do
-      @transaction.eval_generate(resource)
-
-      @filenames.each do |file|
-        v = find_vertex(:file, file)
-        p = find_vertex(:file, File.dirname(file))
-
-        graph.should be_edge(p, v)
-      end
-    end
-
-    it "should add an edge from each generated resource to the sentinel" do
-      @transaction.eval_generate(resource)
-
-      sentinel = find_vertex(:whit, "completed_#{path}")
-      @filenames.each do |file|
-        v = find_vertex(:file, file)
-
-        graph.should be_edge(v, sentinel)
-      end
-    end
-
-    it "should add an edge from the resource to the sentinel" do
-      @transaction.eval_generate(resource)
-
-      res = find_vertex(:file, path)
-      sentinel = find_vertex(:whit, "completed_#{path}")
-
-      graph.should be_edge(res, sentinel)
-    end
-
-    it "should return false if an error occured when generating resources" do
-      resource.stubs(:eval_generate).raises(Puppet::Error)
-
-      @transaction.eval_generate(resource).should == false
-    end
-
-    it "should return true if resources were generated" do
-      @transaction.eval_generate(resource).should == true
-    end
-
-    it "should not add a sentinel if no resources are generated" do
-      path2 = tmpfile('empty')
-      other_file = Puppet::Type.type(:file).new(:path => path2)
-
-      @transaction.catalog.add_resource(other_file)
-
-      @transaction.eval_generate(other_file).should == false
-
-      find_vertex(:whit, "completed_#{path2}").should be_nil
+      expect(@transaction).to be_any_failed
     end
   end
 
@@ -343,41 +211,7 @@ describe Puppet::Transaction do
     end
   end
 
-  describe "#finish" do
-    let(:graph) { @transaction.relationship_graph }
-    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 unblock the resource's dependents and queue them if ready" do
-      dependent = Puppet::Type.type(:file).new(:path => tmpfile('dependent'), :require => resource)
-      more_dependent = Puppet::Type.type(:file).new(:path => tmpfile('more_dependent'), :require => [resource, dependent])
-      @transaction.catalog.add_resource(dependent, more_dependent)
-
-      graph.finish(resource)
-
-      graph.blockers[dependent].should == 0
-      graph.blockers[more_dependent].should == 1
-
-      key = graph.unguessable_deterministic_key[dependent]
-
-      graph.ready[key].must == dependent
-
-      graph.ready.should_not be_has_key(graph.unguessable_deterministic_key[more_dependent])
-    end
-
-    it "should mark the resource as done" do
-      graph.finish(resource)
-
-      graph.done[resource].should == true
-    end
-  end
-
   describe "when traversing" do
-    let(:graph) { @transaction.relationship_graph }
     let(:path) { tmpdir('eval_generate') }
     let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
 
@@ -385,26 +219,11 @@ describe Puppet::Transaction do
       @transaction.catalog.add_resource(resource)
     end
 
-    it "should clear blockers if resources are added" do
-      graph.blockers['foo'] = 3
-      graph.blockers['bar'] = 4
-
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
-
-      @transaction.expects(:eval_generate).with(resource).returns true
-
-      graph.traverse {}
-
-      graph.blockers.should be_empty
-    end
-
     it "should yield the resource even if eval_generate is called" do
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
-
-      @transaction.expects(:eval_generate).with(resource).returns true
+      Puppet::Transaction::AdditionalResourceGenerator.any_instance.expects(:eval_generate).with(resource).returns true
 
       yielded = false
-      graph.traverse do |res|
+      @transaction.evaluate do |res|
         yielded = true if res == resource
       end
 
@@ -414,89 +233,31 @@ describe Puppet::Transaction do
     it "should prefetch the provider if necessary" do
       @transaction.expects(:prefetch_if_necessary).with(resource)
 
-      graph.traverse {}
-    end
-
-    it "should not clear blockers if resources aren't added" do
-      graph.blockers['foo'] = 3
-      graph.blockers['bar'] = 4
-
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
-
-      @transaction.expects(:eval_generate).with(resource).returns false
-
-      graph.traverse {}
-
-      graph.blockers.should == {'foo' => 3, 'bar' => 4, resource => 0}
-    end
-
-    it "should unblock all dependents of the resource" do
-      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-      dependent2 = Puppet::Type.type(:notify).new(:name => "goodbye", :require => resource)
-
-      @transaction.catalog.add_resource(dependent, dependent2)
-
-      # We enqueue them here just so we can check their blockers. This is done
-      # again in traverse.
-      graph.enqueue_roots
-
-      graph.blockers[dependent].should == 1
-      graph.blockers[dependent2].should == 1
-
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
-
-      graph.traverse {}
-
-      graph.blockers[dependent].should == 0
-      graph.blockers[dependent2].should == 0
+      @transaction.evaluate {}
     end
 
-    it "should enqueue any unblocked dependents" do
+    it "traverses independent resources before dependent resources" do
       dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
-      dependent2 = Puppet::Type.type(:notify).new(:name => "goodbye", :require => resource)
-
-      @transaction.catalog.add_resource(dependent, dependent2)
-
-      graph.enqueue_roots
-
-      graph.blockers[dependent].should == 1
-      graph.blockers[dependent2].should == 1
-
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+      @transaction.catalog.add_resource(dependent)
 
       seen = []
-
-      graph.traverse do |res|
+      @transaction.evaluate do |res|
         seen << res
       end
 
-      seen.should =~ [resource, dependent, dependent2]
+      expect(seen).to include_in_order(resource, dependent)
     end
 
-    it "should mark the resource done" do
-      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
-
-      graph.traverse {}
+    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)
 
-      graph.done[resource].should == true
-    end
-
-    it "should not evaluate the resource if it's not suitable" do
-      resource.stubs(:suitable?).returns false
-
-      graph.traverse do |resource|
-        raise "evaluated a resource"
+      seen = []
+      @transaction.evaluate do |res|
+        seen << res
       end
-    end
-
-    it "should defer an unsuitable resource unless it can't go on" do
-      other = Puppet::Type.type(:notify).new(:name => "hello")
-      @transaction.catalog.add_resource(other)
-
-      # Show that we check once, then get the resource back and check again
-      resource.expects(:suitable?).twice.returns(false).then.returns(true)
 
-      graph.traverse {}
+      expect(seen).to include_in_order(resource, independent)
     end
 
     it "should fail unsuitable resources and go on if it gets blocked" do
@@ -506,7 +267,7 @@ describe Puppet::Transaction do
       resource.stubs(:suitable?).returns false
 
       evaluated = []
-      graph.traverse do |res|
+      @transaction.evaluate do |res|
         evaluated << res
       end
 
@@ -518,7 +279,7 @@ describe Puppet::Transaction do
 
   describe "when generating resources before traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) { Puppet::Transaction.new(catalog) }
+    let(:transaction) { Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.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) }
@@ -532,30 +293,19 @@ describe Puppet::Transaction do
     it "should call 'generate' on all created resources" do
       generated.each { |res| res.expects(:generate) }
 
-      transaction.add_dynamically_generated_resources
+      transaction.evaluate
     end
 
     it "should finish all resources" do
       generated.each { |res| res.expects(:finish) }
 
-      transaction.add_dynamically_generated_resources
-    end
-
-    it "should skip generated resources that conflict with existing resources" do
-      duplicate = generated.first
-      catalog.add_resource(duplicate)
-
-      duplicate.expects(:finish).never
-
-      duplicate.expects(:info).with { |msg| msg =~ /Duplicate generated resource/ }
-
-      transaction.add_dynamically_generated_resources
+      transaction.evaluate
     end
 
     it "should copy all tags to the newly generated resources" do
       generator.tag('one', 'two')
 
-      transaction.add_dynamically_generated_resources
+      transaction.evaluate
 
       generated.each do |res|
         res.must be_tagged(generator.tags)
@@ -568,7 +318,7 @@ describe Puppet::Transaction do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
-      @transaction = Puppet::Transaction.new(@catalog)
+      @transaction = Puppet::Transaction.new(@catalog, nil, nil)
     end
 
     it "should skip resource with missing tags" do
@@ -592,22 +342,39 @@ describe Puppet::Transaction do
     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
       @transaction.for_network_device = false
       @transaction.should 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
       @transaction.for_network_device = true
       @transaction.should_not 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
       @transaction.for_network_device = true
       @transaction.should 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
+      @transaction.for_network_device = true
+      @transaction.should_not 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
+      @transaction.for_network_device = false
+      @transaction.should_not be_skip(@resource)
+    end
   end
 
   describe "when determining if tags are missing" do
@@ -615,7 +382,7 @@ describe Puppet::Transaction do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
-      @transaction = Puppet::Transaction.new(@catalog)
+      @transaction = Puppet::Transaction.new(@catalog, nil, nil)
 
       @transaction.stubs(:ignore_tags?).returns false
     end
@@ -646,27 +413,28 @@ describe Puppet::Transaction 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)
+      @catalog.add_resource(@resource)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     end
 
     it "should always schedule resources if 'ignoreschedules' is set" do
       @transaction.ignoreschedules = true
       @transaction.resource_harness.expects(:scheduled?).never
 
-      @transaction.should be_scheduled(@resource)
+      @transaction.evaluate
+      @transaction.resource_status(@resource).should be_changed
     end
 
     it "should let the resource harness determine whether the resource should be scheduled" do
-      @transaction.resource_harness.expects(:scheduled?).with(@transaction.resource_status(@resource), @resource).returns "feh"
+      @transaction.resource_harness.expects(:scheduled?).with(@resource).returns "feh"
 
-      @transaction.scheduled?(@resource).should == "feh"
+      @transaction.evaluate
     end
   end
 
   describe "when prefetching" do
     let(:catalog) { Puppet::Resource::Catalog.new }
-    let(:transaction) { Puppet::Transaction.new(catalog) }
+    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" }
 
@@ -675,30 +443,6 @@ describe Puppet::Transaction do
       catalog.add_resource resource2
     end
 
-
-    describe "#resources_by_provider" do
-      it "should fetch resources by their type and provider" do
-        transaction.resources_by_provider(:sshkey, :parsed).should == {
-          resource.name => resource,
-        }
-
-        transaction.resources_by_provider(:package, :apt).should == {
-          resource2.name => resource2,
-        }
-      end
-
-      it "should omit resources whose types don't use providers" do
-        # faking the sshkey type not to have a provider
-        resource.class.stubs(:attrclass).returns nil
-
-        transaction.resources_by_provider(:sshkey, :parsed).should == {}
-      end
-
-      it "should return empty hash for providers with no resources" do
-        transaction.resources_by_provider(:package, :yum).should == {}
-      end
-    end
-
     it "should match resources by name, not title" do
       resource.provider.class.expects(:prefetch).with("bar" => resource)
 
@@ -734,37 +478,25 @@ describe Puppet::Transaction do
     end
   end
 
-  it "should return all resources for which the resource status indicates the resource has changed when determinig changed resources" do
-    @catalog = Puppet::Resource::Catalog.new
-    @transaction = Puppet::Transaction.new(@catalog)
-    names = []
-    2.times do |i|
-      name = File.join(@basepath, "file#{i}")
-      resource = Puppet::Type.type(:file).new :path => name
-      names << resource.to_s
-      @catalog.add_resource resource
-      @transaction.add_resource_status Puppet::Resource::Status.new(resource)
-    end
-
-    @transaction.resource_status(names[0]).changed = true
-
-    @transaction.changed?.should == [@catalog.resource(names[0])]
-  end
-
   describe 'when checking application run state' do
     before do
-      without_warnings { Puppet::Application = Class.new(Puppet::Application) }
       @catalog = Puppet::Resource::Catalog.new
-      @transaction = Puppet::Transaction.new(@catalog)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
     end
 
-    after do
-      without_warnings { Puppet::Application = Puppet::Application.superclass }
-    end
+    context "when stop is requested" do
+      before :each do
+        Puppet::Application.stubs(:stop_requested?).returns(true)
+      end
 
-    it 'should return true for :stop_processing? if Puppet::Application.stop_requested? is true' do
-      Puppet::Application.stubs(:stop_requested?).returns(true)
-      @transaction.stop_processing?.should be_true
+      it 'should return true for :stop_processing?' do
+        @transaction.should be_stop_processing
+      end
+
+      it 'always evaluates non-host_config catalogs' do
+        @catalog.host_config = false
+        @transaction.should_not be_stop_processing
+      end
     end
 
     it 'should return false for :stop_processing? if Puppet::Application.stop_requested? is false' do
@@ -792,12 +524,72 @@ describe Puppet::Transaction do
       end
     end
   end
+
+  it "errors with a dependency cycle for a resource that requires itself" do
+    expect do
+      apply_compiled_manifest(<<-MANIFEST)
+        notify { cycle: require => Notify[cycle] }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+  end
+
+  it "errors with a dependency cycle for a self-requiring resource also required by another resource" do
+    expect do
+      apply_compiled_manifest(<<-MANIFEST)
+        notify { cycle: require => Notify[cycle] }
+        notify { other: require => Notify[cycle] }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+  end
+
+  it "errors with a dependency cycle for a resource that requires itself and another resource" do
+    expect do
+      apply_compiled_manifest(<<-MANIFEST)
+        notify { cycle:
+          require => [Notify[other], Notify[cycle]]
+        }
+        notify { other: }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+  end
+
+  it "errors with a dependency cycle for a resource that is later modified to require itself" do
+    expect do
+      apply_compiled_manifest(<<-MANIFEST)
+        notify { cycle: }
+        Notify <| title == 'cycle' |> {
+          require => Notify[cycle]
+        }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+  end
+
+  it "reports a changed resource with a successful run" do
+    transaction = apply_compiled_manifest("notify { one: }")
+
+    transaction.report.status.should == 'changed'
+    transaction.report.resource_statuses['Notify[one]'].should 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
+
+      transaction.report.resource_statuses['Notify[a]'].should be_skipped
+      transaction.report.resource_statuses['Notify[b]'].should be_skipped
+    end
+  end
 end
 
 describe Puppet::Transaction, " when determining tags" do
   before do
     @config = Puppet::Resource::Catalog.new
-    @transaction = Puppet::Transaction.new(@config)
+    @transaction = Puppet::Transaction.new(@config, nil, nil)
   end
 
   it "should default to the tags specified in the :tags setting" do