puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/transaction/resource_harness_spec.rb

@@ -20,21 +20,21 @@ describe Puppet::Transaction::ResourceHarness do
 
   it "should accept a transaction at initialization" do
     harness = Puppet::Transaction::ResourceHarness.new(@transaction)
-    harness.transaction.should equal(@transaction)
+    expect(harness.transaction).to 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"
+    expect(Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph).to eq("relgraph")
   end
 
   describe "when evaluating a resource" do
     it "produces a resource state that describes what happened with the resource" do
       status = @harness.evaluate(@resource)
 
-      status.resource.should == @resource.ref
-      status.should_not be_failed
-      status.events.should be_empty
+      expect(status.resource).to eq(@resource.ref)
+      expect(status).not_to be_failed
+      expect(status.events).to be_empty
     end
 
     it "retrieves the current state of the resource" do
@@ -49,10 +49,10 @@ describe Puppet::Transaction::ResourceHarness do
 
       status = @harness.evaluate(@resource)
 
-      status.should be_failed
-      events_to_hash(status.events).collect do |event|
+      expect(status).to be_failed
+      expect(events_to_hash(status.events).collect do |event|
         { :@status => event[:@status], :@message => event[:@message] }
-      end.should == [{ :@status => "failure", :@message => the_message }]
+      end).to eq([{ :@status => "failure", :@message => the_message }])
     end
 
     it "records the time it took to evaluate the resource" do
@@ -60,7 +60,7 @@ describe Puppet::Transaction::ResourceHarness do
       status = @harness.evaluate(@resource)
       after = Time.now
 
-      status.evaluation_time.should be <= after - before
+      expect(status.evaluation_time).to be <= after - before
     end
   end
 
@@ -233,8 +233,8 @@ describe Puppet::Transaction::ResourceHarness do
         @harness.evaluate(resource)
       end.to raise_error(Exception)
 
-      @logs.first.message.should == "change from absent to present failed: Exception"
-      @logs.first.level.should == :err
+      expect(@logs.first.message).to eq("change from absent to present failed: Exception")
+      expect(@logs.first.level).to eq(:err)
     end
 
     it "ensure succeeds means that the rest doesn't happen" do
@@ -277,13 +277,13 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "should record previous successful events" do
-      @status.events[0].property.should == 'foo'
-      @status.events[0].status.should == 'success'
+      expect(@status.events[0].property).to eq('foo')
+      expect(@status.events[0].status).to eq('success')
     end
 
     it "should record a failure event" do
-      @status.events[1].property.should == 'bar'
-      @status.events[1].status.should == 'failure'
+      expect(@status.events[1].property).to eq('bar')
+      expect(@status.events[1].status).to eq('failure')
     end
   end
 
@@ -295,9 +295,9 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "should log and pass the exception through" do
-      lambda { @harness.evaluate(@resource) }.should raise_error(Exception, /baz/)
-      @logs.first.message.should == "change from absent to 1 failed: baz"
-      @logs.first.level.should == :err
+      expect { @harness.evaluate(@resource) }.to raise_error(Exception, /baz/)
+      expect(@logs.first.message).to eq("change from absent to 1 failed: baz")
+      expect(@logs.first.level).to eq(:err)
     end
   end
 
@@ -310,9 +310,9 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should record a failure event" do
       @status = @harness.evaluate(@resource)
-      @status.events[0].name.to_s.should == 'brillig_changed'
-      @status.events[0].property.should == 'brillig'
-      @status.events[0].status.should == 'failure'
+      expect(@status.events[0].name.to_s).to eq('brillig_changed')
+      expect(@status.events[0].property).to eq('brillig')
+      expect(@status.events[0].status).to eq('failure')
     end
   end
 
@@ -324,9 +324,9 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "should log and pass the exception through" do
-      lambda { @harness.evaluate(@resource) }.should raise_error(Exception, /slithy/)
-      @logs.first.message.should == "change from absent to 1 failed: slithy"
-      @logs.first.level.should == :err
+      expect { @harness.evaluate(@resource) }.to raise_error(Exception, /slithy/)
+      expect(@logs.first.message).to eq("change from absent to 1 failed: slithy")
+      expect(@logs.first.level).to eq(:err)
     end
   end
 
@@ -349,7 +349,7 @@ describe Puppet::Transaction::ResourceHarness do
       status = @harness.evaluate(resource)
 
       status.events.each do |event|
-        event.status.should != 'failure'
+        expect(event.status).to != 'failure'
       end
     end
 
@@ -379,9 +379,9 @@ describe Puppet::Transaction::ResourceHarness do
       # there should be an audit change recorded, since the two
       # timestamps differ by at least 1 microsecond
       status = @harness.evaluate(resource)
-      status.events.should_not be_empty
+      expect(status.events).not_to be_empty
       status.events.each do |event|
-        event.message.should =~ /audit change: previously recorded/
+        expect(event.message).to match(/audit change: previously recorded/)
       end
     end
 
@@ -413,7 +413,7 @@ describe Puppet::Transaction::ResourceHarness do
       # slight difference in the two timestamps
       status = @harness.evaluate(resource)
       status.events.each do |event|
-        event.message.should_not =~ /audit change: previously recorded/
+        expect(event.message).not_to match(/audit change: previously recorded/)
       end
     end
   end
@@ -425,7 +425,7 @@ describe Puppet::Transaction::ResourceHarness do
       resource.expects(:err).never # make sure no exceptions get swallowed
       @harness.expects(:allow_changes?).with(resource).returns false
       status = @harness.evaluate(resource)
-      Puppet::FileSystem.exist?(test_file).should == false
+      expect(Puppet::FileSystem.exist?(test_file)).to eq(false)
     end
   end
 
@@ -437,31 +437,31 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should be true if the resource is not being purged" do
       @resource.expects(:purging?).returns false
-      @harness.should be_allow_changes(@resource)
+      expect(@harness).to 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)
+      expect(@harness).to 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)
+      expect(@harness).to 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)
+      expect(@harness).to 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)
+      expect(@harness).not_to be_allow_changes(@resource)
     end
   end
 
@@ -475,11 +475,11 @@ describe Puppet::Transaction::ResourceHarness do
       @resource.catalog = nil
       @resource.expects(:warning)
 
-      @harness.schedule(@resource).should be_nil
+      expect(@harness.schedule(@resource)).to be_nil
     end
 
     it "should return nil if the resource specifies no schedule" do
-      @harness.schedule(@resource).should be_nil
+      expect(@harness.schedule(@resource)).to be_nil
     end
 
     it "should fail if the named schedule cannot be found" do
@@ -492,7 +492,7 @@ describe Puppet::Transaction::ResourceHarness 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
+      expect(@harness.schedule(@resource).to_s).to eq(sched.to_s)
     end
   end
 
@@ -505,11 +505,11 @@ describe Puppet::Transaction::ResourceHarness do
     it "should return true if 'ignoreschedules' is set" do
       Puppet[:ignoreschedules] = true
       @resource[:schedule] = "meh"
-      @harness.should be_scheduled(@resource)
+      expect(@harness).to be_scheduled(@resource)
     end
 
     it "should return true if the resource has no schedule set" do
-      @harness.should be_scheduled(@resource)
+      expect(@harness).to be_scheduled(@resource)
     end
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
@@ -522,7 +522,7 @@ describe Puppet::Transaction::ResourceHarness do
 
       sched.expects(:match?).with(t.to_i).returns "feh"
 
-      @harness.scheduled?(@resource).should == "feh"
+      expect(@harness.scheduled?(@resource)).to eq("feh")
     end
   end
 
@@ -531,12 +531,12 @@ describe Puppet::Transaction::ResourceHarness do
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cache(@resource, :foo, "something")
 
-    data[:foo].should == "something"
+    expect(data[:foo]).to eq("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"
+    expect(@harness.cached(@resource, :foo)).to eq("other")
   end
 end

data/spec/unit/transaction_spec.rb

@@ -31,14 +31,14 @@ describe Puppet::Transaction do
     transaction = transaction_with_resource(resource)
     transaction.evaluate
 
-    transaction.resource_status(resource.to_s).should be_changed
+    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)
-    transaction.resource_status(resource).should be_instance_of(Puppet::Resource::Status)
+    expect(transaction.resource_status(resource)).to be_instance_of(Puppet::Resource::Status)
   end
 
   it "should add provided resource statuses to its report" do
@@ -47,7 +47,7 @@ describe Puppet::Transaction do
     transaction.evaluate
 
     status = transaction.resource_status(resource)
-    transaction.report.resource_statuses[resource.to_s].should equal(status)
+    expect(transaction.report.resource_statuses[resource.to_s]).to equal(status)
   end
 
   it "should not consider there to be failed resources if no statuses are marked failed" do
@@ -55,33 +55,33 @@ describe Puppet::Transaction do
     transaction = transaction_with_resource(resource)
     transaction.evaluate
 
-    transaction.should_not be_any_failed
+    expect(transaction).not_to 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, nil)
 
-    transaction.report.should == report
+    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)
 
-    transaction.report.should be_kind_of Puppet::Transaction::Report
+    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)
-      transaction.event_manager.should be_instance_of(Puppet::Transaction::EventManager)
-      transaction.event_manager.transaction.should equal(transaction)
+      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)
-      transaction.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
-      transaction.resource_harness.transaction.should equal(transaction)
+      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
@@ -114,7 +114,21 @@ describe Puppet::Transaction do
         transaction.expects(:skip?).with(resource).returns true
 
         transaction.evaluate
-        transaction.resource_status(resource).should be_skipped
+        expect(transaction.resource_status(resource)).to be_skipped
+      end
+
+      it "does not process any scheduled events" do
+        transaction = transaction_with_resource(resource)
+        transaction.expects(:skip?).with(resource).returns true
+        transaction.event_manager.expects(:process_events).with(resource).never
+        transaction.evaluate
+      end
+
+      it "dequeues all events scheduled on that resource" do
+        transaction = transaction_with_resource(resource)
+        transaction.expects(:skip?).with(resource).returns true
+        transaction.event_manager.expects(:dequeue_all_events_for_resource).with(resource)
+        transaction.evaluate
       end
     end
   end
@@ -138,7 +152,7 @@ describe Puppet::Transaction do
     it "should add the resulting resource status to its status list" do
       @transaction.resource_harness.stubs(:evaluate).returns(@status)
       @transaction.evaluate
-      @transaction.resource_status(@resource).should be_instance_of(Puppet::Resource::Status)
+      expect(@transaction.resource_status(@resource)).to be_instance_of(Puppet::Resource::Status)
     end
 
     it "should queue any events added to the resource status" do
@@ -151,7 +165,7 @@ describe Puppet::Transaction do
     it "should log and skip any resources that cannot be applied" do
       @resource.expects(:properties).raises ArgumentError
       @transaction.evaluate
-      @transaction.report.resource_statuses[@resource.to_s].should be_failed
+      expect(@transaction.report.resource_statuses[@resource.to_s]).to be_failed
     end
 
     it "should report any_failed if any resources failed" do
@@ -176,7 +190,7 @@ describe Puppet::Transaction do
 
       graph.unblock(resource)
 
-      graph.blockers[resource].should == 2
+      expect(graph.blockers[resource]).to eq(2)
     end
 
     it "should decrement the number of blockers if there are any" do
@@ -184,7 +198,7 @@ describe Puppet::Transaction do
 
       graph.unblock(resource)
 
-      graph.blockers[resource].should == 39
+      expect(graph.blockers[resource]).to eq(39)
     end
 
     it "should warn if there are no blockers" do
@@ -198,13 +212,13 @@ describe Puppet::Transaction do
     it "should return true if the resource is now unblocked" do
       graph.blockers[resource] = 1
 
-      graph.unblock(resource).should == true
+      expect(graph.unblock(resource)).to eq(true)
     end
 
     it "should return false if the resource is still blocked" do
       graph.blockers[resource] = 2
 
-      graph.unblock(resource).should == false
+      expect(graph.unblock(resource)).to eq(false)
     end
   end
 
@@ -224,7 +238,7 @@ describe Puppet::Transaction do
         yielded = true if res == resource
       end
 
-      yielded.should == true
+      expect(yielded).to eq(true)
     end
 
     it "should prefetch the provider if necessary" do
@@ -269,8 +283,8 @@ describe Puppet::Transaction do
       end
 
       # We should have gone on to evaluate the children
-      evaluated.should == [dependent]
-      @transaction.resource_status(resource).should be_failed
+      expect(evaluated).to eq([dependent])
+      expect(@transaction.resource_status(resource)).to be_failed
     end
   end
 
@@ -308,7 +322,7 @@ describe Puppet::Transaction do
       transaction.evaluate
 
       generated.each do |res|
-        res.must be_tagged(*generator.tags)
+        expect(res).to be_tagged(*generator.tags)
       end
     end
   end
@@ -348,57 +362,57 @@ describe Puppet::Transaction do
 
     it "should skip resource with missing tags" do
       @transaction.stubs(:missing_tags?).returns(true)
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip unscheduled resources" do
       @transaction.stubs(:scheduled?).returns(false)
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip resources with failed dependencies" do
       @transaction.stubs(:failed_dependencies?).returns(true)
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip virtual resource" do
       @resource.stubs(:virtual?).returns true
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should skip device only resouce on normal host" do
       @resource.stubs(:appliable_to_host?).returns false
       @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = false
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should not skip device only resouce on remote device" do
       @resource.stubs(:appliable_to_host?).returns false
       @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = true
-      @transaction.should_not be_skip(@resource)
+      expect(@transaction).not_to be_skip(@resource)
     end
 
     it "should skip host resouce on device" do
       @resource.stubs(:appliable_to_host?).returns true
       @resource.stubs(:appliable_to_device?).returns false
       @transaction.for_network_device = true
-      @transaction.should be_skip(@resource)
+      expect(@transaction).to be_skip(@resource)
     end
 
     it "should not skip resouce available on both device and host when on device" do
       @resource.stubs(:appliable_to_host?).returns true
       @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = true
-      @transaction.should_not be_skip(@resource)
+      expect(@transaction).not_to be_skip(@resource)
     end
 
     it "should not skip resouce available on both device and host when on host" do
       @resource.stubs(:appliable_to_host?).returns true
       @resource.stubs(:appliable_to_device?).returns true
       @transaction.for_network_device = false
-      @transaction.should_not be_skip(@resource)
+      expect(@transaction).not_to be_skip(@resource)
     end
   end
 
@@ -417,19 +431,19 @@ describe Puppet::Transaction do
 
       @resource.expects(:tagged?).never
 
-      @transaction.should_not be_missing_tags(@resource)
+      expect(@transaction).not_to be_missing_tags(@resource)
     end
 
     it "should not be missing tags if the transaction tags are empty" do
       @transaction.tags = []
       @resource.expects(:tagged?).never
-      @transaction.should_not be_missing_tags(@resource)
+      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
-      @transaction.should be_missing_tags(@resource)
+      expect(@transaction).to be_missing_tags(@resource)
     end
   end
 
@@ -446,7 +460,7 @@ describe Puppet::Transaction do
       @transaction.resource_harness.expects(:scheduled?).never
 
       @transaction.evaluate
-      @transaction.resource_status(@resource).should be_changed
+      expect(@transaction.resource_status(@resource)).to be_changed
     end
 
     it "should let the resource harness determine whether the resource should be scheduled" do
@@ -486,7 +500,7 @@ describe Puppet::Transaction do
 
       transaction.prefetch_if_necessary(resource)
 
-      transaction.prefetched_providers[:sshkey][:parsed].should be_true
+      expect(transaction.prefetched_providers[:sshkey][:parsed]).to be_truthy
     end
 
     it "should prefetch resources without a provider if prefetching the default provider" do
@@ -582,18 +596,18 @@ describe Puppet::Transaction do
       end
 
       it 'should return true for :stop_processing?' do
-        @transaction.should be_stop_processing
+        expect(@transaction).to be_stop_processing
       end
 
       it 'always evaluates non-host_config catalogs' do
         @catalog.host_config = false
-        @transaction.should_not be_stop_processing
+        expect(@transaction).not_to be_stop_processing
       end
     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
+      expect(@transaction.stop_processing?).to be_falsey
     end
 
     describe 'within an evaluate call' do
@@ -659,8 +673,8 @@ describe Puppet::Transaction do
   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
+    expect(transaction.report.status).to eq('changed')
+    expect(transaction.report.resource_statuses['Notify[one]']).to be_changed
   end
 
   describe "when interrupted" do
@@ -672,8 +686,8 @@ describe Puppet::Transaction do
         notify { b: }
       MANIFEST
 
-      transaction.report.resource_statuses['Notify[a]'].should be_skipped
-      transaction.report.resource_statuses['Notify[b]'].should be_skipped
+      expect(transaction.report.resource_statuses['Notify[a]']).to be_skipped
+      expect(transaction.report.resource_statuses['Notify[b]']).to be_skipped
     end
   end
 end
@@ -686,44 +700,37 @@ describe Puppet::Transaction, " when determining tags" do
 
   it "should default to the tags specified in the :tags setting" do
     Puppet[:tags] = "one"
-    @transaction.should be_tagged("one")
+    expect(@transaction).to be_tagged("one")
   end
 
   it "should split tags based on ','" do
     Puppet[:tags] = "one,two"
-    @transaction.should be_tagged("one")
-    @transaction.should be_tagged("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}
-    @transaction.should be_tagged("one")
-    @transaction.should be_tagged("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"
-    @transaction.should 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"
-    @transaction.should be_tagged("one::two")
-    @transaction.should_not be_tagged("one")
-    @transaction.should_not be_tagged("two")
+    expect(@transaction).to be_tagged("one::two")
   end
 
   it "should accept a comma-delimited string" do
     @transaction.tags = "one, two"
-    @transaction.should be_tagged("one")
-    @transaction.should be_tagged("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"
-    @transaction.should be_tagged("one")
+    expect(@transaction).to be_tagged("one")
     @transaction.tags = ""
-    @transaction.should_not be_tagged("one")
+    expect(@transaction).not_to be_tagged("one")
   end
 end