puppet 0.25.5 → 2.6.0

data/spec/unit/transaction/resource_harness_spec.rb

@@ -0,0 +1,401 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/resource_harness'
+
+describe Puppet::Transaction::ResourceHarness do
+  before do
+    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+    @resource = Puppet::Type.type(:file).new :path => "/my/file"
+    @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
+    @current_state = Puppet::Resource.new(:file, "/my/file")
+    @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
+    harness = Puppet::Transaction::ResourceHarness.new(@transaction)
+    harness.transaction.should equal(@transaction)
+  end
+
+  it "should delegate to the transaction for its relationship graph" do
+    @transaction.expects(:relationship_graph).returns "relgraph"
+    Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph.should == "relgraph"
+  end
+
+  describe "when copying audited parameters" do
+    before do
+      @resource = Puppet::Type.type(:file).new :path => "/foo/bar", :audit => :mode
+    end
+
+    it "should do nothing if no parameters are being audited" do
+      @resource[:audit] = []
+      @harness.expects(:cached).never
+      @harness.copy_audited_parameters(@resource, {}).should == []
+    end
+
+    it "should do nothing if an audited parameter already has a desired value set" do
+      @resource[:mode] = "755"
+      @harness.expects(:cached).never
+      @harness.copy_audited_parameters(@resource, {}).should == []
+    end
+
+    it "should copy any cached values to the 'should' values" do
+      @harness.cache(@resource, :mode, "755")
+      @harness.copy_audited_parameters(@resource, {}).should == [:mode]
+
+      @resource[:mode].should == 0755
+    end
+
+    it "should cache and log the current value if no cached values are present" do
+      @resource.expects(:info)
+      @harness.copy_audited_parameters(@resource, {:mode => "755"}).should == []
+
+      @harness.cached(@resource, :mode).should == "755"
+    end
+  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
+
+      lambda { @harness.evaluate(@resource) }.should raise_error
+    end
+
+    it "should retrieve 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
+    end
+
+    it "should use the status and retrieved state to determine which changes need to be made" do
+      @harness.expects(:changes_to_perform).with(@status, @resource).returns []
+      @harness.evaluate(@resource)
+    end
+
+    it "should mark the status as out of sync and apply the created changes if there are any" do
+      changes = %w{mychanges}
+      @harness.expects(:changes_to_perform).returns changes
+      @harness.expects(:apply_changes).with(@status, changes)
+      @harness.evaluate(@resource).should be_out_of_sync
+    end
+
+    it "should cache the last-synced time" do
+      changes = %w{mychanges}
+      @harness.stubs(:changes_to_perform).returns changes
+      @harness.stubs(:apply_changes)
+      @harness.expects(:cache).with { |resource, name, time| name == :synced and time.is_a?(Time) }
+      @harness.evaluate(@resource)
+    end
+
+    it "should flush the resource when applying changes if appropriate" do
+      changes = %w{mychanges}
+      @harness.stubs(:changes_to_perform).returns changes
+      @harness.stubs(:apply_changes)
+      @resource.expects(:flush)
+      @harness.evaluate(@resource)
+    end
+
+    it "should use the status and retrieved state to determine which changes need to be made" do
+      @harness.expects(:changes_to_perform).with(@status, @resource).returns []
+      @harness.evaluate(@resource)
+    end
+
+    it "should not attempt to apply changes if none need to be made" do
+      @harness.expects(:changes_to_perform).returns []
+      @harness.expects(:apply_changes).never
+      @harness.evaluate(@resource).should_not be_out_of_sync
+    end
+
+    it "should store the resource's evaluation time in the resource status" do
+      @harness.evaluate(@resource).evaluation_time.should be_instance_of(Float)
+    end
+
+    it "should set the change count to the total number of changes" do
+      changes = %w{a b c d}
+      @harness.expects(:changes_to_perform).returns changes
+      @harness.expects(:apply_changes).with(@status, changes)
+      @harness.evaluate(@resource).change_count.should == 4
+    end
+  end
+
+  describe "when creating changes" do
+    before do
+      @current_state = Puppet::Resource.new(:file, "/my/file")
+      @resource.stubs(:retrieve).returns @current_state
+      Puppet.features.stubs(:root?).returns true
+    end
+
+    it "should retrieve the current values from the resource" do
+      @resource.expects(:retrieve).returns @current_state
+      @harness.changes_to_perform(@status, @resource)
+    end
+
+    it "should cache that the resource was checked" do
+      @harness.expects(:cache).with { |resource, name, time| name == :checked and time.is_a?(Time) }
+      @harness.changes_to_perform(@status, @resource)
+    end
+
+    it "should create changes with the appropriate property and current value" do
+      @resource[:ensure] = :present
+      @current_state[:ensure] = :absent
+
+      change = stub 'change'
+      Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:ensure), :absent).returns change
+
+      @harness.changes_to_perform(@status, @resource)[0].should equal(change)
+    end
+
+    it "should not attempt to manage properties that do not have desired values set" do
+      mode = @resource.newattr(:mode)
+      @current_state[:mode] = :absent
+
+      mode.expects(:insync?).never
+
+      @harness.changes_to_perform(@status, @resource)
+    end
+
+    it "should copy audited parameters" do
+      @resource[:audit] = :mode
+      @harness.cache(@resource, :mode, "755")
+      @harness.changes_to_perform(@status, @resource)
+      @resource[:mode].should == 0755
+    end
+
+    it "should mark changes created as a result of auditing as auditing changes" do
+      @current_state[:mode] = 0644
+      @resource[:audit] = :mode
+      @harness.cache(@resource, :mode, "755")
+      @harness.changes_to_perform(@status, @resource)[0].must be_auditing
+    end
+
+    describe "and the 'ensure' parameter is present but not in sync" do
+      it "should return a single change for the 'ensure' parameter" do
+        @resource[:ensure] = :present
+        @resource[:mode] = "755"
+        @current_state[:ensure] = :absent
+        @current_state[:mode] = :absent
+
+        @resource.stubs(:retrieve).returns @current_state
+
+        changes = @harness.changes_to_perform(@status, @resource)
+        changes.length.should == 1
+        changes[0].property.name.should == :ensure
+      end
+    end
+
+    describe "and the 'ensure' parameter should be set to 'absent', and is correctly set to 'absent'" do
+      it "should return no changes" do
+        @resource[:ensure] = :absent
+        @resource[:mode] = "755"
+        @current_state[:ensure] = :absent
+        @current_state[:mode] = :absent
+
+        @harness.changes_to_perform(@status, @resource).should == []
+      end
+    end
+
+    describe "and the 'ensure' parameter is 'absent' and there is no 'desired value'" do
+      it "should return no changes" do
+        @resource.newattr(:ensure)
+        @resource[:mode] = "755"
+        @current_state[:ensure] = :absent
+        @current_state[:mode] = :absent
+
+        @harness.changes_to_perform(@status, @resource).should == []
+      end
+    end
+
+    describe "and non-'ensure' parameters are not in sync" do
+      it "should return a change for each parameter that is not in sync" do
+        @resource[:ensure] = :present
+        @resource[:mode] = "755"
+        @resource[:owner] = 0
+        @current_state[:ensure] = :present
+        @current_state[:mode] = 0444
+        @current_state[:owner] = 50
+
+        mode = stub 'mode_change'
+        owner = stub 'owner_change'
+        Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:mode), 0444).returns mode
+        Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:owner), 50).returns owner
+
+        changes = @harness.changes_to_perform(@status, @resource)
+        changes.length.should == 2
+        changes.should be_include(mode)
+        changes.should be_include(owner)
+      end
+    end
+
+    describe "and all parameters are in sync" do
+      it "should return an empty array" do
+        @resource[:ensure] = :present
+        @resource[:mode] = "755"
+        @current_state[:ensure] = :present
+        @current_state[:mode] = 0755
+        @harness.changes_to_perform(@status, @resource).should == []
+      end
+    end
+  end
+
+  describe "when applying changes" do
+    before do
+      @change1 = stub 'change1', :apply => stub("event", :status => "success"), :auditing? => false
+      @change2 = stub 'change2', :apply => stub("event", :status => "success"), :auditing? => false
+      @changes = [@change1, @change2]
+    end
+
+    it "should apply the change" do
+      @change1.expects(:apply).returns( stub("event", :status => "success") )
+      @change2.expects(:apply).returns( stub("event", :status => "success") )
+
+      @harness.apply_changes(@status, @changes)
+    end
+
+    it "should mark the resource as changed" do
+      @harness.apply_changes(@status, @changes)
+
+      @status.should be_changed
+    end
+
+    it "should queue the resulting event" do
+      @harness.apply_changes(@status, @changes)
+
+      @status.events.should be_include(@change1.apply)
+      @status.events.should be_include(@change2.apply)
+    end
+
+    it "should cache the new value if it is an auditing change" do
+      @change1.expects(:auditing?).returns true
+      property = stub 'property', :name => "foo", :resource => "myres"
+      @change1.stubs(:property).returns property
+      @change1.stubs(:is).returns "myval"
+
+      @harness.apply_changes(@status, @changes)
+
+      @harness.cached("myres", "foo").should == "myval"
+    end
+  end
+
+  describe "when determining whether the resource can be changed" do
+    before do
+      @resource.stubs(:purging?).returns true
+      @resource.stubs(:deleting?).returns true
+    end
+
+    it "should be true if the resource is not being purged" do
+      @resource.expects(:purging?).returns false
+      @harness.should be_allow_changes(@resource)
+    end
+
+    it "should be true if the resource is not being deleted" do
+      @resource.expects(:deleting?).returns false
+      @harness.should be_allow_changes(@resource)
+    end
+
+    it "should be true if the resource has no dependents" do
+      @harness.relationship_graph.expects(:dependents).with(@resource).returns []
+      @harness.should be_allow_changes(@resource)
+    end
+
+    it "should be true if all dependents are being deleted" do
+      dep = stub 'dependent', :deleting? => true
+      @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
+      @resource.expects(:purging?).returns true
+      @harness.should be_allow_changes(@resource)
+    end
+
+    it "should be false if the resource's dependents are not being deleted" do
+      dep = stub 'dependent', :deleting? => false, :ref => "myres"
+      @resource.expects(:warning)
+      @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
+      @harness.should_not be_allow_changes(@resource)
+    end
+  end
+
+  describe "when finding the schedule" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new
+      @resource.catalog = @catalog
+    end
+
+    it "should warn and return nil if the resource has no catalog" do
+      @resource.catalog = nil
+      @resource.expects(:warning)
+
+      @harness.schedule(@resource).should be_nil
+    end
+
+    it "should return nil if the resource specifies no schedule" do
+      @harness.schedule(@resource).should be_nil
+    end
+
+    it "should fail if the named schedule cannot be found" do
+      @resource[:schedule] = "whatever"
+      @resource.expects(:fail)
+      @harness.schedule(@resource)
+    end
+
+    it "should return the named schedule if it exists" do
+      sched = Puppet::Type.type(:schedule).new(:name => "sched")
+      @catalog.add_resource(sched)
+      @resource[:schedule] = "sched"
+      @harness.schedule(@resource).to_s.should == sched.to_s
+    end
+  end
+
+  describe "when determining if a resource is scheduled" 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)
+    end
+
+    it "should return true if the resource has no schedule set" do
+      @harness.should be_scheduled(@status, @resource)
+    end
+
+    it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
+      t = Time.now
+      @harness.expects(:cached).with(@resource, :checked).returns(t)
+
+      sched = Puppet::Type.type(:schedule).new(:name => "sched")
+      @catalog.add_resource(sched)
+      @resource[:schedule] = "sched"
+
+      sched.expects(:match?).with(t.to_i).returns "feh"
+
+      @harness.scheduled?(@status, @resource).should == "feh"
+    end
+  end
+
+  it "should be able to cache data in the Storage module" do
+    data = {}
+    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
+    @harness.cache(@resource, :foo, "something")
+
+    data[:foo].should == "something"
+  end
+
+  it "should be able to retrieve data from the cache" do
+    data = {:foo => "other"}
+    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
+    @harness.cached(@resource, :foo).should == "other"
+  end
+end

data/spec/unit/transaction_spec.rb

@@ -0,0 +1,452 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/transaction'
+
+def without_warnings
+  flag = $VERBOSE
+  $VERBOSE = nil
+  yield
+  $VERBOSE = flag
+end
+
+describe Puppet::Transaction do
+  before do
+    @basepath = Puppet.features.posix? ? "/what/ever" : "C:/tmp"
+    @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+  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
+  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)
+  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)
+  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.resource_status(resource).should 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"
+    status = Puppet::Resource::Status.new(resource)
+    @transaction.add_resource_status(status)
+    @transaction.report.resource_statuses[resource.to_s].should equal(status)
+  end
+
+  it "should calculate metrics on and report the report when asked to generate a report" do
+    @transaction.report.expects(:calculate_metrics)
+    @transaction.generate_report.should equal(@transaction.report)
+  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
+
+  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
+  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
+  end
+
+  it "should be possible to replace the report object" do
+    report = Puppet::Transaction::Report.new
+    @transaction.report = report
+
+    @transaction.report.should == report
+  end
+
+  it "should consider a resource to have failed dependencies if any of its dependencies are failed"
+
+  describe "when initializing" do
+    it "should create an event manager" do
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+      @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.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
+      @transaction.resource_harness.transaction.should equal(@transaction)
+    end
+  end
+
+  describe "when evaluating a resource" do
+    before do
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
+      @transaction.stubs(:eval_children_and_apply_resource)
+      @transaction.stubs(:skip?).returns false
+
+      @resource = Puppet::Type.type(:file).new :path => @basepath
+    end
+
+    it "should check whether the resource should be skipped" do
+      @transaction.expects(:skip?).with(@resource).returns false
+
+      @transaction.eval_resource(@resource)
+    end
+
+    it "should eval and apply children" do
+      @transaction.expects(:eval_children_and_apply_resource).with(@resource, nil)
+
+      @transaction.eval_resource(@resource)
+    end
+
+    it "should process events" do
+      @transaction.event_manager.expects(:process_events).with(@resource)
+
+      @transaction.eval_resource(@resource)
+    end
+
+    describe "and the resource should be skipped" do
+      before do
+        @transaction.expects(:skip?).with(@resource).returns true
+      end
+
+      it "should mark the resource's status as skipped" do
+        @transaction.eval_resource(@resource)
+        @transaction.resource_status(@resource).should be_skipped
+      end
+    end
+  end
+
+  describe "when applying a resource" do
+    before do
+      @resource = Puppet::Type.type(:file).new :path => @basepath
+      @status = Puppet::Resource::Status.new(@resource)
+
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.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)
+    end
+
+    it "should add the resulting resource status to its status list" do
+      @transaction.apply(@resource)
+      @transaction.resource_status(@resource).should be_instance_of(Puppet::Resource::Status)
+    end
+
+    it "should queue any events added to the resource status" do
+      @status.expects(:events).returns %w{a b}
+      @transaction.event_manager.expects(:queue_events).with(@resource, ["a", "b"])
+      @transaction.apply(@resource)
+    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
+    end
+  end
+
+  describe "when generating resources" do
+    it "should call 'generate' on all created resources" do
+      first = Puppet::Type.type(:notify).new(:name => "first")
+      second = Puppet::Type.type(:notify).new(:name => "second")
+      third = Puppet::Type.type(:notify).new(:name => "third")
+
+      @catalog = Puppet::Resource::Catalog.new
+      @transaction = Puppet::Transaction.new(@catalog)
+
+      first.expects(:generate).returns [second]
+      second.expects(:generate).returns [third]
+      third.expects(:generate)
+
+      @transaction.generate_additional_resources(first, :generate)
+    end
+
+    it "should finish all resources" do
+      generator = stub 'generator', :depthfirst? => true, :tags => []
+      resource = stub 'resource', :tag => nil
+
+      @catalog = Puppet::Resource::Catalog.new
+      @transaction = Puppet::Transaction.new(@catalog)
+
+      generator.expects(:generate).returns [resource]
+
+      @catalog.expects(:add_resource).yields(resource)
+
+      resource.expects(:finish)
+
+      @transaction.generate_additional_resources(generator, :generate)
+    end
+
+    it "should skip generated resources that conflict with existing resources" do
+      generator = mock 'generator', :tags => []
+      resource = stub 'resource', :tag => nil
+
+      @catalog = Puppet::Resource::Catalog.new
+      @transaction = Puppet::Transaction.new(@catalog)
+
+      generator.expects(:generate).returns [resource]
+
+      @catalog.expects(:add_resource).raises(Puppet::Resource::Catalog::DuplicateResourceError.new("foo"))
+
+      resource.expects(:finish).never
+      resource.expects(:info) # log that it's skipped
+
+      @transaction.generate_additional_resources(generator, :generate).should be_empty
+    end
+
+    it "should copy all tags to the newly generated resources" do
+      child = stub 'child'
+      generator = stub 'resource', :tags => ["one", "two"]
+
+      @catalog = Puppet::Resource::Catalog.new
+      @transaction = Puppet::Transaction.new(@catalog)
+
+      generator.stubs(:generate).returns [child]
+      @catalog.stubs(:add_resource)
+
+      child.expects(:tag).with("one", "two")
+
+      @transaction.generate_additional_resources(generator, :generate)
+    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)
+    end
+
+    it "should skip resource with missing tags" do
+      @transaction.stubs(:missing_tags?).returns(true)
+      @transaction.should be_skip(@resource)
+    end
+
+    it "should skip unscheduled resources" do
+      @transaction.stubs(:scheduled?).returns(false)
+      @transaction.should be_skip(@resource)
+    end
+
+    it "should skip resources with failed dependencies" do
+      @transaction.stubs(:failed_dependencies?).returns(true)
+      @transaction.should be_skip(@resource)
+    end
+
+    it "should skip virtual resource" do
+      @resource.stubs(:virtual?).returns true
+      @transaction.should 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)
+
+      @transaction.stubs(:ignore_tags?).returns false
+    end
+
+    it "should not be missing tags if tags are being ignored" do
+      @transaction.expects(:ignore_tags?).returns true
+
+      @resource.expects(:tagged?).never
+
+      @transaction.should_not be_missing_tags(@resource)
+    end
+
+    it "should not be missing tags if the transaction tags are empty" do
+      @transaction.tags = []
+      @resource.expects(:tagged?).never
+      @transaction.should_not be_missing_tags(@resource)
+    end
+
+    it "should otherwise let the resource determine if it is missing tags" do
+      tags = ['one', 'two']
+      @transaction.tags = tags
+      @resource.expects(:tagged?).with(*tags).returns(false)
+      @transaction.should 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
+      @resource.catalog = @catalog
+      @transaction = Puppet::Transaction.new(@catalog)
+    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)
+    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.scheduled?(@resource).should == "feh"
+    end
+  end
+
+  describe "when prefetching" do
+    it "should match resources by name, not title" do
+      @catalog = Puppet::Resource::Catalog.new
+      @transaction = Puppet::Transaction.new(@catalog)
+
+      # Have both a title and name
+      resource = Puppet::Type.type(:sshkey).create :title => "foo", :name => "bar", :type => :dsa, :key => "eh"
+      @catalog.add_resource resource
+
+      resource.provider.class.expects(:prefetch).with("bar" => resource)
+
+      @transaction.prefetch
+    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)
+    end
+
+    after do
+      without_warnings { Puppet::Application = Puppet::Application.superclass }
+    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
+    end
+
+    it 'should return false for :stop_processing? if Puppet::Application.stop_requested? is false' do
+      Puppet::Application.stubs(:stop_requested?).returns(false)
+      @transaction.stop_processing?.should be_false
+    end
+
+    describe 'within an evaluate call' do
+      before do
+        @resource = stub 'resource', :ref => 'some_ref'
+        @catalog.add_resource @resource
+        @transaction.stubs(:prepare)
+        @transaction.sorted_resources = [@resource]
+      end
+
+      it 'should stop processing if :stop_processing? is true' do
+        @transaction.expects(:stop_processing?).returns(true)
+        @transaction.expects(:eval_resource).never
+        @transaction.evaluate
+      end
+
+      it 'should continue processing if :stop_processing? is false' do
+        @transaction.expects(:stop_processing?).returns(false)
+        @transaction.expects(:eval_resource).returns(nil)
+        @transaction.evaluate
+      end
+    end
+  end
+end
+
+describe Puppet::Transaction, " when determining tags" do
+  before do
+    @config = Puppet::Resource::Catalog.new
+    @transaction = Puppet::Transaction.new(@config)
+  end
+
+  it "should default to the tags specified in the :tags setting" do
+    Puppet.expects(:[]).with(:tags).returns("one")
+    @transaction.tags.should == %w{one}
+  end
+
+  it "should split tags based on ','" do
+    Puppet.expects(:[]).with(:tags).returns("one,two")
+    @transaction.tags.should == %w{one two}
+  end
+
+  it "should use any tags set after creation" do
+    Puppet.expects(:[]).with(:tags).never
+    @transaction.tags = %w{one two}
+    @transaction.tags.should == %w{one two}
+  end
+
+  it "should always convert assigned tags to an array" do
+    @transaction.tags = "one::two"
+    @transaction.tags.should == %w{one::two}
+  end
+
+  it "should accept a comma-delimited string" do
+    @transaction.tags = "one, two"
+    @transaction.tags.should == %w{one two}
+  end
+
+  it "should accept an empty string" do
+    @transaction.tags = ""
+    @transaction.tags.should == []
+  end
+end