puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/transaction/event_manager_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/transaction/event_manager'
@@ -12,10 +13,10 @@ describe Puppet::Transaction::EventManager do
   end
 
   it "should delegate its relationship graph to the transaction" do
-    transaction = double('transaction')
+    transaction = stub 'transaction'
     manager = Puppet::Transaction::EventManager.new(transaction)
 
-    expect(transaction).to receive(:relationship_graph).and_return("mygraph")
+    transaction.expects(:relationship_graph).returns "mygraph"
 
     expect(manager.relationship_graph).to eq("mygraph")
   end
@@ -26,8 +27,8 @@ describe Puppet::Transaction::EventManager do
 
       @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
 
-      @graph = double('graph', :matching_edges => [], :resource => @resource)
-      allow(@manager).to receive(:relationship_graph).and_return(@graph)
+      @graph = stub 'graph', :matching_edges => [], :resource => @resource
+      @manager.stubs(:relationship_graph).returns @graph
 
       @event = Puppet::Transaction::Event.new(:name => :foo, :resource => @resource)
     end
@@ -41,63 +42,63 @@ describe Puppet::Transaction::EventManager do
     end
 
     it "should queue events for the target and callback of any matching edges" do
-      edge1 = double("edge1", :callback => :c1, :source => double("s1"), :target => double("t1", :c1 => nil))
-      edge2 = double("edge2", :callback => :c2, :source => double("s2"), :target => double("t2", :c2 => nil))
+      edge1 = stub("edge1", :callback => :c1, :source => stub("s1"), :target => stub("t1", :c1 => nil))
+      edge2 = stub("edge2", :callback => :c2, :source => stub("s2"), :target => stub("t2", :c2 => nil))
 
-      expect(@graph).to receive(:matching_edges).with(@event, anything).and_return([edge1, edge2])
+      @graph.expects(:matching_edges).with { |event, resource| event == @event }.returns [edge1, edge2]
 
-      expect(@manager).to receive(:queue_events_for_resource).with(@resource, edge1.target, edge1.callback, [@event])
-      expect(@manager).to receive(:queue_events_for_resource).with(@resource, edge2.target, edge2.callback, [@event])
+      @manager.expects(:queue_events_for_resource).with(@resource, edge1.target, edge1.callback, [@event])
+      @manager.expects(:queue_events_for_resource).with(@resource, edge2.target, edge2.callback, [@event])
 
       @manager.queue_events(@resource, [@event])
     end
 
     it "should queue events for the changed resource if the resource is self-refreshing and not being deleted" do
-      allow(@graph).to receive(:matching_edges).and_return([])
+      @graph.stubs(:matching_edges).returns []
 
-      expect(@resource).to receive(:self_refresh?).and_return(true)
-      expect(@resource).to receive(:deleting?).and_return(false)
-      expect(@manager).to receive(:queue_events_for_resource).with(@resource, @resource, :refresh, [@event])
+      @resource.expects(:self_refresh?).returns true
+      @resource.expects(:deleting?).returns false
+      @manager.expects(:queue_events_for_resource).with(@resource, @resource, :refresh, [@event])
 
       @manager.queue_events(@resource, [@event])
     end
 
     it "should not queue events for the changed resource if the resource is not self-refreshing" do
-      allow(@graph).to receive(:matching_edges).and_return([])
+      @graph.stubs(:matching_edges).returns []
 
-      expect(@resource).to receive(:self_refresh?).and_return(false)
-      allow(@resource).to receive(:deleting?).and_return(false)
-      expect(@manager).not_to receive(:queue_events_for_resource)
+      @resource.expects(:self_refresh?).returns false
+      @resource.stubs(:deleting?).returns false
+      @manager.expects(:queue_events_for_resource).never
 
       @manager.queue_events(@resource, [@event])
     end
 
     it "should not queue events for the changed resource if the resource is being deleted" do
-      allow(@graph).to receive(:matching_edges).and_return([])
+      @graph.stubs(:matching_edges).returns []
 
-      expect(@resource).to receive(:self_refresh?).and_return(true)
-      expect(@resource).to receive(:deleting?).and_return(true)
-      expect(@manager).not_to receive(:queue_events_for_resource)
+      @resource.expects(:self_refresh?).returns true
+      @resource.expects(:deleting?).returns true
+      @manager.expects(:queue_events_for_resource).never
 
       @manager.queue_events(@resource, [@event])
     end
 
     it "should ignore edges that don't have a callback" do
-      edge1 = double("edge1", :callback => :nil, :source => double("s1"), :target => double("t1", :c1 => nil))
+      edge1 = stub("edge1", :callback => :nil, :source => stub("s1"), :target => stub("t1", :c1 => nil))
 
-      expect(@graph).to receive(:matching_edges).and_return([edge1])
+      @graph.expects(:matching_edges).returns [edge1]
 
-      expect(@manager).not_to receive(:queue_events_for_resource)
+      @manager.expects(:queue_events_for_resource).never
 
       @manager.queue_events(@resource, [@event])
     end
 
     it "should ignore targets that don't respond to the callback" do
-      edge1 = double("edge1", :callback => :c1, :source => double("s1"), :target => double("t1"))
+      edge1 = stub("edge1", :callback => :c1, :source => stub("s1"), :target => stub("t1"))
 
-      expect(@graph).to receive(:matching_edges).and_return([edge1])
+      @graph.expects(:matching_edges).returns [edge1]
 
-      expect(@manager).not_to receive(:queue_events_for_resource)
+      @manager.expects(:queue_events_for_resource).never
 
       @manager.queue_events(@resource, [@event])
     end
@@ -105,9 +106,9 @@ describe Puppet::Transaction::EventManager do
     it "should dequeue events for the changed resource if an event with invalidate_refreshes is processed" do
       @event2 = Puppet::Transaction::Event.new(:name => :foo, :resource => @resource, :invalidate_refreshes => true)
 
-      allow(@graph).to receive(:matching_edges).and_return([])
+      @graph.stubs(:matching_edges).returns []
 
-      expect(@manager).to receive(:dequeue_events_for_resource).with(@resource, :refresh)
+      @manager.expects(:dequeue_events_for_resource).with(@resource, :refresh)
 
       @manager.queue_events(@resource, [@event, @event2])
     end
@@ -115,28 +116,28 @@ describe Puppet::Transaction::EventManager do
 
   describe "when queueing events for a resource" do
     before do
-      @transaction = double('transaction')
+      @transaction = stub 'transaction'
       @manager = Puppet::Transaction::EventManager.new(@transaction)
     end
 
     it "should do nothing if no events are queued" do
-      @manager.queued_events(double("target")) { |callback, events| raise "should never reach this" }
+      @manager.queued_events(stub("target")) { |callback, events| raise "should never reach this" }
     end
 
     it "should yield the callback and events for each callback" do
-      target = double("target")
+      target = stub("target")
 
       2.times do |i|
-        @manager.queue_events_for_resource(double("source", :info => nil), target, "callback#{i}", ["event#{i}"])
+        @manager.queue_events_for_resource(stub("source", :info => nil), target, "callback#{i}", ["event#{i}"])
       end
 
       @manager.queued_events(target) { |callback, events| }
     end
 
     it "should use the source to log that it's scheduling a refresh of the target" do
-      target = double("target")
-      source = double('source')
-      expect(source).to receive(:info)
+      target = stub("target")
+      source = stub 'source'
+      source.expects(:info)
 
       @manager.queue_events_for_resource(source, target, "callback", ["event"])
 
@@ -148,73 +149,62 @@ describe Puppet::Transaction::EventManager do
     before do
       @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
       @manager = Puppet::Transaction::EventManager.new(@transaction)
-      allow(@manager).to receive(:queue_events)
+      @manager.stubs(:queue_events)
 
       @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
       @event = Puppet::Transaction::Event.new(:name => :event, :resource => @resource)
     end
 
     it "should call the required callback once for each set of associated events" do
-      expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event]).and_yield(:callback2, [@event])
+      @manager.expects(:queued_events).with(@resource).multiple_yields([:callback1, [@event]], [:callback2, [@event]])
 
-      expect(@resource).to receive(:callback1)
-      expect(@resource).to receive(:callback2)
+      @resource.expects(:callback1)
+      @resource.expects(:callback2)
 
       @manager.process_events(@resource)
     end
 
     it "should set the 'restarted' state on the resource status" do
-      expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
+      @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
 
-      allow(@resource).to receive(:callback1)
+      @resource.stubs(:callback1)
 
       @manager.process_events(@resource)
 
       expect(@transaction.resource_status(@resource)).to be_restarted
     end
 
-    it "should have an event on the resource status" do
-      expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
-
-      allow(@resource).to receive(:callback1)
-
-      @manager.process_events(@resource) #x
-
-      expect(@transaction.resource_status(@resource).events.length).to eq(1)
-    end
-
     it "should queue a 'restarted' event generated by the resource" do
-      expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
+      @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
 
-      allow(@resource).to receive(:callback1)
+      @resource.stubs(:callback1)
 
-      expect(@resource).to receive(:event).with(:message => "Triggered 'callback1' from 1 event", :status => 'success', :name => 'callback1')
-      expect(@resource).to receive(:event).with(:name => :restarted, :status => "success").and_return("myevent")
-      expect(@manager).to receive(:queue_events).with(@resource, ["myevent"])
+      @resource.expects(:event).with(:name => :restarted, :status => "success").returns "myevent"
+      @manager.expects(:queue_events).with(@resource, ["myevent"])
 
       @manager.process_events(@resource)
     end
 
     it "should log that it restarted" do
-      expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
+      @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
 
-      allow(@resource).to receive(:callback1)
+      @resource.stubs(:callback1)
 
-      expect(@resource).to receive(:notice).with(/Triggered 'callback1'/)
+      @resource.expects(:notice).with { |msg| msg.include?("Triggered 'callback1'") }
 
       @manager.process_events(@resource)
     end
 
     describe "and the events include a noop event and at least one non-noop event" do
       before do
-        allow(@event).to receive(:status).and_return("noop")
+        @event.stubs(:status).returns "noop"
         @event2 = Puppet::Transaction::Event.new(:name => :event, :resource => @resource)
         @event2.status = "success"
-        expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event, @event2])
+        @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event, @event2])
       end
 
       it "should call the callback" do
-        expect(@resource).to receive(:callback1)
+        @resource.expects(:callback1)
 
         @manager.process_events(@resource)
       end
@@ -222,27 +212,27 @@ describe Puppet::Transaction::EventManager do
 
     describe "and the events are all noop events" do
       before do
-        allow(@event).to receive(:status).and_return("noop")
-        allow(@resource).to receive(:event).and_return(Puppet::Transaction::Event.new)
-        expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
+        @event.stubs(:status).returns "noop"
+        @resource.stubs(:event).returns(Puppet::Transaction::Event.new)
+        @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
       end
 
       it "should log" do
-        expect(@resource).to receive(:notice).with(/Would have triggered 'callback1'/)
+        @resource.expects(:notice).with { |msg| msg.include?("Would have triggered 'callback1'") }
 
         @manager.process_events(@resource)
       end
 
       it "should not call the callback" do
-        expect(@resource).not_to receive(:callback1)
+        @resource.expects(:callback1).never
 
         @manager.process_events(@resource)
       end
 
       it "should queue a new noop event generated from the resource" do
         event = Puppet::Transaction::Event.new
-        expect(@resource).to receive(:event).with(:status => "noop", :name => :noop_restart).and_return(event)
-        expect(@manager).to receive(:queue_events).with(@resource, [event])
+        @resource.expects(:event).with(:status => "noop", :name => :noop_restart).returns event
+        @manager.expects(:queue_events).with(@resource, [event])
 
         @manager.process_events(@resource)
       end
@@ -250,47 +240,46 @@ describe Puppet::Transaction::EventManager do
 
     describe "and the resource has noop set to true" do
       before do
-        allow(@event).to receive(:status).and_return("success")
-        allow(@resource).to receive(:event).and_return(Puppet::Transaction::Event.new)
-        allow(@resource).to receive(:noop?).and_return(true)
-        expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
+        @event.stubs(:status).returns "success"
+        @resource.stubs(:event).returns(Puppet::Transaction::Event.new)
+        @resource.stubs(:noop?).returns(true)
+        @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
       end
 
       it "should log" do
-        expect(@resource).to receive(:notice).with(/Would have triggered 'callback1'/)
+        @resource.expects(:notice).with { |msg| msg.include?("Would have triggered 'callback1'") }
 
         @manager.process_events(@resource)
       end
 
       it "should not call the callback" do
-        expect(@resource).not_to receive(:callback1)
+        @resource.expects(:callback1).never
 
         @manager.process_events(@resource)
       end
 
       it "should queue a new noop event generated from the resource" do
         event = Puppet::Transaction::Event.new
-        expect(@resource).to receive(:event).with(:status => "noop", :name => :noop_restart).and_return(event)
-        expect(@manager).to receive(:queue_events).with(@resource, [event])
+        @resource.expects(:event).with(:status => "noop", :name => :noop_restart).returns event
+        @manager.expects(:queue_events).with(@resource, [event])
 
         @manager.process_events(@resource)
       end
     end
 
+
     describe "and the callback fails" do
       before do
-        expect(@resource).to receive(:callback1).and_raise("a failure")
+        @resource.expects(:callback1).raises "a failure"
+        @resource.stubs(:err)
 
-        expect(@manager).to receive(:queued_events).and_yield(:callback1, [@event])
+        @manager.expects(:queued_events).yields(:callback1, [@event])
       end
 
-      it "should emit an error and log but not fail" do
-        expect(@resource).to receive(:err).with('Failed to call callback1: a failure').and_call_original
-        expect(@resource).to receive(:err).with('a failure').and_call_original
-
-        @manager.process_events(@resource)
+      it "should log but not fail" do
+        @resource.expects(:err)
 
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: 'a failure'))
+        expect { @manager.process_events(@resource) }.not_to raise_error
       end
 
       it "should set the 'failed_restarts' state on the resource status" do
@@ -311,7 +300,7 @@ describe Puppet::Transaction::EventManager do
       end
 
       it "should not queue a 'restarted' event" do
-        expect(@manager).not_to receive(:queue_events)
+        @manager.expects(:queue_events).never
         @manager.process_events(@resource)
       end
 
@@ -330,10 +319,10 @@ describe Puppet::Transaction::EventManager do
       @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
       @target = Puppet::Type.type(:file).new :path => make_absolute("/your/file")
 
-      @graph = allow('graph')
-      allow(@graph).to receive(:matching_edges).and_return([])
-      allow(@graph).to receive(:matching_edges).with(anything, @resource).and_return([double('edge', :target => @target, :callback => :refresh)])
-      allow(@manager).to receive(:relationship_graph).and_return(@graph)
+      @graph = stub 'graph'
+      @graph.stubs(:matching_edges).returns []
+      @graph.stubs(:matching_edges).with(anything, @resource).returns [stub('edge', :target => @target, :callback => :refresh)]
+      @manager.stubs(:relationship_graph).returns @graph
 
       @event  = Puppet::Transaction::Event.new(:name => :notify, :resource => @target)
       @event2 = Puppet::Transaction::Event.new(:name => :service_start, :resource => @target, :invalidate_refreshes => true)
@@ -345,13 +334,13 @@ describe Puppet::Transaction::EventManager do
 
     describe "and the events were dequeued/invalidated" do
       before do
-        expect(@resource).to receive(:info).with(/Scheduling refresh/)
-        expect(@target).to receive(:info).with(/Unscheduling/)
+        @resource.expects(:info).with { |msg| msg.include?("Scheduling refresh") }
+        @target.expects(:info).with { |msg| msg.include?("Unscheduling") }
       end
 
       it "should not run an event or log" do
-        expect(@target).not_to receive(:notice).with(/Would have triggered 'refresh'/)
-        expect(@target).not_to receive(:refresh)
+        @target.expects(:notice).with { |msg| msg.include?("Would have triggered 'refresh'") }.never
+        @target.expects(:refresh).never
 
         @manager.queue_events(@resource, [@event])
         @manager.queue_events(@target, [@event2])

data/spec/unit/transaction/event_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/transaction/event'
@@ -30,7 +31,7 @@ describe Puppet::Transaction::Event do
 
   it "should produce the message when converted to a string" do
     event = Puppet::Transaction::Event.new
-    expect(event).to receive(:message).and_return("my message")
+    event.expects(:message).returns "my message"
     expect(event.to_s).to eq("my message")
   end
 
@@ -61,62 +62,60 @@ describe Puppet::Transaction::Event do
 
   describe "when sending logs" do
     before do
-      allow(Puppet::Util::Log).to receive(:new)
+      Puppet::Util::Log.stubs(:new)
     end
 
     it "should set the level to the resources's log level if the event status is 'success' and a resource is available" do
-      resource = double('resource')
-      expect(resource).to receive(:[]).with(:loglevel).and_return(:myloglevel)
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(level: :myloglevel))
+      resource = stub 'resource'
+      resource.expects(:[]).with(:loglevel).returns :myloglevel
+      Puppet::Util::Log.expects(:create).with { |args| args[:level] == :myloglevel }
       Puppet::Transaction::Event.new(:status => "success", :resource => resource).send_log
     end
 
     it "should set the level to 'notice' if the event status is 'success' and no resource is available" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(level: :notice))
+      Puppet::Util::Log.expects(:new).with { |args| args[:level] == :notice }
       Puppet::Transaction::Event.new(:status => "success").send_log
     end
 
     it "should set the level to 'notice' if the event status is 'noop'" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(level: :notice))
+      Puppet::Util::Log.expects(:new).with { |args| args[:level] == :notice }
       Puppet::Transaction::Event.new(:status => "noop").send_log
     end
 
     it "should set the level to 'err' if the event status is 'failure'" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(level: :err))
+      Puppet::Util::Log.expects(:new).with { |args| args[:level] == :err }
       Puppet::Transaction::Event.new(:status => "failure").send_log
     end
 
     it "should set the 'message' to the event log" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(message: "my message"))
+      Puppet::Util::Log.expects(:new).with { |args| args[:message] == "my message" }
       Puppet::Transaction::Event.new(:message => "my message").send_log
     end
 
     it "should set the tags to the event tags" do
-      expect(Puppet::Util::Log).to receive(:new) do |args|
-        expect(args[:tags].to_a).to match_array(%w{one two})
-      end
+      Puppet::Util::Log.expects(:new).with { |args| expect(args[:tags].to_a).to match_array(%w{one two}) }
       Puppet::Transaction::Event.new(:tags => %w{one two}).send_log
     end
 
     [:file, :line].each do |attr|
       it "should pass the #{attr}" do
-        expect(Puppet::Util::Log).to receive(:new).with(hash_including(attr => "my val"))
+        Puppet::Util::Log.expects(:new).with { |args| args[attr] == "my val" }
         Puppet::Transaction::Event.new(attr => "my val").send_log
       end
     end
 
     it "should use the source description as the source if one is set" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(source: "/my/param"))
+      Puppet::Util::Log.expects(:new).with { |args| args[:source] == "/my/param" }
       Puppet::Transaction::Event.new(:source_description => "/my/param", :resource => TestResource.new, :property => "foo").send_log
     end
 
     it "should use the property as the source if one is available and no source description is set" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(source: "foo"))
+      Puppet::Util::Log.expects(:new).with { |args| args[:source] == "foo" }
       Puppet::Transaction::Event.new(:resource => TestResource.new, :property => "foo").send_log
     end
 
     it "should use the property as the source if one is available and no property or source description is set" do
-      expect(Puppet::Util::Log).to receive(:new).with(hash_including(source: "Foo[bar]"))
+      Puppet::Util::Log.expects(:new).with { |args| args[:source] == "Foo[bar]" }
       Puppet::Transaction::Event.new(:resource => TestResource.new).send_log
     end
   end