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

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -72,7 +72,7 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
         }
       MANIFEST
 
-      find_vertex(graph, :whit, "completed_thing").must be_a(Puppet::Type.type(:whit))
+      expect(find_vertex(graph, :whit, "completed_thing")).to be_a(Puppet::Type.type(:whit))
     end
 
     it "should replace dependencies on the resource with dependencies on the sentinel" do
@@ -404,7 +404,7 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
       @containers.all? { |resource_ref| resource_ref == @containers[0] }
     end
 
-    def failure_message_for_should
+    def failure_message
       "expected #{@expected.join(', ')} to all be contained in the same resource but the containment was #{@expected.zip(@containers).collect { |(res, container)| res + ' => ' + container }.join(', ')}"
     end
   end

data/spec/unit/transaction/event_manager_spec.rb

@@ -8,7 +8,7 @@ describe Puppet::Transaction::EventManager do
 
   describe "at initialization" do
     it "should require a transaction" do
-      Puppet::Transaction::EventManager.new("trans").transaction.should == "trans"
+      expect(Puppet::Transaction::EventManager.new("trans").transaction).to eq("trans")
     end
   end
 
@@ -18,7 +18,7 @@ describe Puppet::Transaction::EventManager do
 
     transaction.expects(:relationship_graph).returns "mygraph"
 
-    manager.relationship_graph.should == "mygraph"
+    expect(manager.relationship_graph).to eq("mygraph")
   end
 
   describe "when queueing events" do
@@ -37,8 +37,8 @@ describe Puppet::Transaction::EventManager do
       @event2 = Puppet::Transaction::Event.new(:name => :bar, :resource => @resource)
       @manager.queue_events(@resource, [@event, @event2])
 
-      @manager.events.should include(@event)
-      @manager.events.should include(@event2)
+      expect(@manager.events).to include(@event)
+      expect(@manager.events).to include(@event2)
     end
 
     it "should queue events for the target and callback of any matching edges" do
@@ -171,7 +171,7 @@ describe Puppet::Transaction::EventManager do
 
       @manager.process_events(@resource)
 
-      @transaction.resource_status(@resource).should be_restarted
+      expect(@transaction.resource_status(@resource)).to be_restarted
     end
 
     it "should queue a 'restarted' event generated by the resource" do
@@ -238,6 +238,36 @@ describe Puppet::Transaction::EventManager do
       end
     end
 
+    describe "and the resource has noop set to true" do
+      before do
+        @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
+        @resource.expects(:notice).with { |msg| msg.include?("Would have triggered 'callback1'") }
+
+        @manager.process_events(@resource)
+      end
+
+      it "should not call the callback" do
+        @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
+        @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
         @resource.expects(:callback1).raises "a failure"
@@ -249,12 +279,12 @@ describe Puppet::Transaction::EventManager do
       it "should log but not fail" do
         @resource.expects(:err)
 
-        lambda { @manager.process_events(@resource) }.should_not raise_error
+        expect { @manager.process_events(@resource) }.not_to raise_error
       end
 
       it "should set the 'failed_restarts' state on the resource status" do
         @manager.process_events(@resource)
-        @transaction.resource_status(@resource).should be_failed_to_restart
+        expect(@transaction.resource_status(@resource)).to be_failed_to_restart
       end
 
       it "should not queue a 'restarted' event" do
@@ -264,7 +294,7 @@ describe Puppet::Transaction::EventManager do
 
       it "should set the 'restarted' state on the resource status" do
         @manager.process_events(@resource)
-        @transaction.resource_status(@resource).should_not be_restarted
+        expect(@transaction.resource_status(@resource)).not_to be_restarted
       end
     end
   end

data/spec/unit/transaction/event_spec.rb

@@ -18,45 +18,45 @@ describe Puppet::Transaction::Event do
   it "should support resource" do
     event = Puppet::Transaction::Event.new
     event.resource = TestResource.new
-    event.resource.should == "Foo[bar]"
+    expect(event.resource).to eq("Foo[bar]")
   end
 
   it "should always convert the property to a string" do
-    Puppet::Transaction::Event.new(:property => :foo).property.should == "foo"
+    expect(Puppet::Transaction::Event.new(:property => :foo).property).to eq("foo")
   end
 
   it "should always convert the resource to a string" do
-    Puppet::Transaction::Event.new(:resource => TestResource.new).resource.should == "Foo[bar]"
+    expect(Puppet::Transaction::Event.new(:resource => TestResource.new).resource).to eq("Foo[bar]")
   end
 
   it "should produce the message when converted to a string" do
     event = Puppet::Transaction::Event.new
     event.expects(:message).returns "my message"
-    event.to_s.should == "my message"
+    expect(event.to_s).to eq("my message")
   end
 
   it "should support 'status'" do
     event = Puppet::Transaction::Event.new
     event.status = "success"
-    event.status.should == "success"
+    expect(event.status).to eq("success")
   end
 
   it "should fail if the status is not to 'audit', 'noop', 'success', or 'failure" do
     event = Puppet::Transaction::Event.new
-    lambda { event.status = "foo" }.should raise_error(ArgumentError)
+    expect { event.status = "foo" }.to raise_error(ArgumentError)
   end
 
   it "should support tags" do
-    Puppet::Transaction::Event.ancestors.should include(Puppet::Util::Tagging)
+    expect(Puppet::Transaction::Event.ancestors).to include(Puppet::Util::Tagging)
   end
 
   it "should create a timestamp at its creation time" do
-    Puppet::Transaction::Event.new.time.should be_instance_of(Time)
+    expect(Puppet::Transaction::Event.new.time).to be_instance_of(Time)
   end
 
   describe "audit property" do
     it "should default to false" do
-      Puppet::Transaction::Event.new.audited.should == false
+      expect(Puppet::Transaction::Event.new.audited).to eq(false)
     end
   end
 
@@ -93,7 +93,7 @@ describe Puppet::Transaction::Event do
     end
 
     it "should set the tags to the event tags" do
-      Puppet::Util::Log.expects(:new).with { |args| args[:tags].to_a.should =~ %w{one two} }
+      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
 
@@ -129,7 +129,7 @@ describe Puppet::Transaction::Event do
                                              :message => "Help I'm trapped in a spec test",
                                              :name => :mode_changed, :previous_value => 6, :property => :mode,
                                              :status => 'success')
-      event.to_yaml_properties.should =~ Puppet::Transaction::Event::YAML_ATTRIBUTES
+      expect(event.to_yaml_properties).to match_array(Puppet::Transaction::Event::YAML_ATTRIBUTES)
     end
   end
 
@@ -151,15 +151,15 @@ describe Puppet::Transaction::Event do
 
       tripped = Puppet::Transaction::Event.from_data_hash(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
+      expect(tripped.audited).to eq(event.audited)
+      expect(tripped.property).to eq(event.property)
+      expect(tripped.previous_value).to eq(event.previous_value)
+      expect(tripped.desired_value).to eq(event.desired_value)
+      expect(tripped.historical_value).to eq(event.historical_value)
+      expect(tripped.message).to eq(event.message)
+      expect(tripped.name).to eq(event.name)
+      expect(tripped.status).to eq(event.status)
+      expect(tripped.time).to eq(event.time)
   end
 
   it "should round trip an event for an inspect report through pson" do
@@ -178,15 +178,15 @@ describe Puppet::Transaction::Event do
 
       tripped = Puppet::Transaction::Event.from_data_hash(PSON.parse(event.to_pson))
 
-      tripped.desired_value.should be_nil
-      tripped.historical_value.should be_nil
-      tripped.name.should be_nil
+      expect(tripped.desired_value).to be_nil
+      expect(tripped.historical_value).to be_nil
+      expect(tripped.name).to 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
+      expect(tripped.audited).to eq(event.audited)
+      expect(tripped.property).to eq(event.property)
+      expect(tripped.previous_value).to eq(event.previous_value)
+      expect(tripped.message).to eq(event.message)
+      expect(tripped.status).to eq(event.status)
+      expect(tripped.time).to eq(event.time)
   end
 end

data/spec/unit/transaction/report_spec.rb

@@ -15,51 +15,51 @@ describe Puppet::Transaction::Report do
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
-    Puppet::Transaction::Report.new("apply").host.should == "mynode"
+    expect(Puppet::Transaction::Report.new("apply").host).to eq("mynode")
   end
 
   it "should return its host name as its name" do
     r = Puppet::Transaction::Report.new("apply")
-    r.name.should == r.host
+    expect(r.name).to eq(r.host)
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
-    Puppet::Transaction::Report.new("apply").time.should == "mytime"
+    expect(Puppet::Transaction::Report.new("apply").time).to eq("mytime")
   end
 
   it "should take a 'kind' as an argument" do
-    Puppet::Transaction::Report.new("inspect").kind.should == "inspect"
+    expect(Puppet::Transaction::Report.new("inspect").kind).to eq("inspect")
   end
 
   it "should take a 'configuration_version' as an argument" do
-    Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version.should == "some configuration version"
+    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version).to eq("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"
+    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("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"
+    expect(report.configuration_version).to eq("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"
+    expect(report.transaction_uuid).to eq("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"
+    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment).to eq("some environment")
   end
 
   it "should be able to set environment" do
     report = Puppet::Transaction::Report.new("inspect")
     report.environment = "some environment"
-    report.environment.should == "some environment"
+    expect(report.environment).to eq("some environment")
   end
 
   it "should not include whits" do
@@ -76,8 +76,8 @@ describe Puppet::Transaction::Report do
     catalog.apply(:report => report)
     report.finalize_report
 
-    report.resource_statuses.values.any? {|res| res.resource_type =~ /whit/i}.should be_false
-    report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}.should be_false
+    expect(report.resource_statuses.values.any? {|res| res.resource_type =~ /whit/i}).to be_falsey
+    expect(report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}).to be_falsey
   end
 
   describe "when accepting logs" do
@@ -87,12 +87,12 @@ describe Puppet::Transaction::Report do
 
     it "should add new logs to the log list" do
       @report << "log"
-      @report.logs[-1].should == "log"
+      expect(@report.logs[-1]).to eq("log")
     end
 
     it "should return self" do
       r = @report << "log"
-      r.should equal(@report)
+      expect(r).to equal(@report)
     end
   end
 
@@ -116,7 +116,7 @@ describe Puppet::Transaction::Report do
     it "should add each status to its status list" do
       status = stub 'status', :resource => "foo"
       @report.add_resource_status status
-      @report.resource_statuses["foo"].should equal(status)
+      expect(@report.resource_statuses["foo"]).to equal(status)
     end
   end
 
@@ -131,13 +131,13 @@ describe Puppet::Transaction::Report do
     end
 
     it "should default to the 'processor' terminus" do
-      Puppet::Transaction::Report.indirection.terminus_class.should == :processor
+      expect(Puppet::Transaction::Report.indirection.terminus_class).to eq(:processor)
     end
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new("apply")
       report.expects(:host).returns "me"
-      report.name.should == "me"
+      expect(report.name).to eq("me")
     end
   end
 
@@ -146,14 +146,14 @@ describe Puppet::Transaction::Report do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
-      report.exit_status.should == 2
+      expect(report.exit_status).to eq(2)
     end
 
     it "should produce 4 if failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
-      report.exit_status.should == 4
+      expect(report.exit_status).to eq(4)
     end
 
     it "should produce 4 if failures to restart are present" do
@@ -161,21 +161,21 @@ describe Puppet::Transaction::Report do
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 0})
       report.add_metric("resources", {"failed_to_restart" => 1})
-      report.exit_status.should == 4
+      expect(report.exit_status).to eq(4)
     end
 
     it "should produce 6 if both changes and failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
-      report.exit_status.should == 6
+      expect(report.exit_status).to eq(6)
     end
   end
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
       report = Puppet::Transaction::Report.new("apply")
-      report.status.should == 'failed'
+      expect(report.status).to eq('failed')
     end
   end
 
@@ -204,7 +204,7 @@ describe Puppet::Transaction::Report do
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
-        @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
+        expect(@report.metrics[type.to_s]).to be_instance_of(Puppet::Transaction::Metric)
       end
     end
 
@@ -213,7 +213,7 @@ describe Puppet::Transaction::Report do
         add_statuses(3)
 
         @report.finalize_report
-        metric(:resources, "total").should == 3
+        expect(metric(:resources, "total")).to eq(3)
       end
 
       Puppet::Resource::Status::STATES.each do |state|
@@ -221,19 +221,19 @@ describe Puppet::Transaction::Report do
           add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
           @report.finalize_report
-          metric(:resources, state.to_s).should == 3
+          expect(metric(:resources, state.to_s)).to eq(3)
         end
 
         it "should provide 0 for states not in status" do
           @report.finalize_report
-          metric(:resources, state.to_s).should == 0
+          expect(metric(:resources, state.to_s)).to eq(0)
         end
       end
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
         @report.finalize_report
-        @report.status.should == 'failed'
+        expect(@report.status).to eq('failed')
       end
     end
 
@@ -241,14 +241,14 @@ describe Puppet::Transaction::Report do
       it "should provide the number of changes from the resource statuses and mark the report as 'changed'" do
         add_statuses(3) { |status| 3.times { status << Puppet::Transaction::Event.new(:status => 'success') } }
         @report.finalize_report
-        metric(:changes, "total").should == 9
-        @report.status.should == 'changed'
+        expect(metric(:changes, "total")).to eq(9)
+        expect(@report.status).to eq('changed')
       end
 
       it "should provide a total even if there are no changes, and mark the report as 'unchanged'" do
         @report.finalize_report
-        metric(:changes, "total").should == 0
-        @report.status.should == 'unchanged'
+        expect(metric(:changes, "total")).to eq(0)
+        expect(@report.status).to eq('unchanged')
       end
     end
 
@@ -266,15 +266,15 @@ describe Puppet::Transaction::Report do
 
         @report.finalize_report
 
-        metric(:time, "file").should == 3
-        metric(:time, "exec").should == 6
-        metric(:time, "tidy").should == 9
+        expect(metric(:time, "file")).to eq(3)
+        expect(metric(:time, "exec")).to eq(6)
+        expect(metric(:time, "tidy")).to eq(9)
       end
 
       it "should add any provided times from external sources" do
         @report.add_times :foobar, 50
         @report.finalize_report
-        metric(:time, "foobar").should == 50
+        expect(metric(:time, "foobar")).to eq(50)
       end
 
       it "should have a total time" do
@@ -283,7 +283,7 @@ describe Puppet::Transaction::Report do
         end
         @report.add_times :config_retrieval, 0.5
         @report.finalize_report
-        metric(:time, "total").should == 4.25
+        expect(metric(:time, "total")).to eq(4.25)
       end
     end
 
@@ -293,12 +293,12 @@ describe Puppet::Transaction::Report do
           3.times { |i| status.add_event(Puppet::Transaction::Event.new :status => 'success') }
         end
         @report.finalize_report
-        metric(:events, "total").should == 9
+        expect(metric(:events, "total")).to eq(9)
       end
 
       it "should provide the total even if there are no events" do
         @report.finalize_report
-        metric(:events, "total").should == 0
+        expect(metric(:events, "total")).to eq(0)
       end
 
       Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
@@ -312,7 +312,7 @@ describe Puppet::Transaction::Report do
           end
 
           @report.finalize_report
-          metric(:events, status_name).should == 9
+          expect(metric(:events, status_name)).to eq(9)
         end
       end
     end
@@ -332,40 +332,40 @@ describe Puppet::Transaction::Report do
 
     %w{changes time resources events version}.each do |main|
       it "should include the key #{main} in the raw summary hash" do
-        @report.raw_summary.should be_key main
+        expect(@report.raw_summary).to be_key main
       end
     end
 
     it "should include the last run time in the raw summary hash" do
       Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
-      @report.raw_summary["time"]["last_run"].should == 1289390424
+      expect(@report.raw_summary["time"]["last_run"]).to eq(1289390424)
     end
 
     it "should include all resource statuses" do
       resources_report = @report.raw_summary["resources"]
       Puppet::Resource::Status::STATES.each do |state|
-        resources_report.should be_include(state.to_s)
+        expect(resources_report).to be_include(state.to_s)
       end
     end
 
     %w{total failure success}.each do |r|
       it "should include event #{r}" do
         events_report = @report.raw_summary["events"]
-        events_report.should be_include(r)
+        expect(events_report).to be_include(r)
       end
     end
 
     it "should include config version" do
-      @report.raw_summary["version"]["config"].should == 1234567
+      expect(@report.raw_summary["version"]["config"]).to eq(1234567)
     end
 
     it "should include puppet version" do
-      @report.raw_summary["version"]["puppet"].should == Puppet.version
+      expect(@report.raw_summary["version"]["puppet"]).to eq(Puppet.version)
     end
 
     %w{Changes Total Resources Time Events}.each do |main|
       it "should include information on #{main} in the textual summary" do
-        @report.summary.should be_include(main)
+        expect(@report.summary).to be_include(main)
       end
     end
   end
@@ -374,7 +374,7 @@ describe Puppet::Transaction::Report do
     it "should not include @external_times" do
       report = Puppet::Transaction::Report.new('apply')
       report.add_times('config_retrieval', 1.0)
-      report.to_yaml_properties.should_not include('@external_times')
+      expect(report.to_yaml_properties).not_to include('@external_times')
     end
   end
 
@@ -387,7 +387,6 @@ describe Puppet::Transaction::Report do
   end
 
   it "can make a round trip through pson" do
-    Puppet[:report_serialization_format] = "pson"
     report = generate_report
 
     tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)
@@ -396,41 +395,28 @@ describe Puppet::Transaction::Report do
   end
 
   it "generates pson which validates against the report schema" do
-    Puppet[:report_serialization_format] = "pson"
     report = generate_report
     expect(report.render).to validate_against('api/schemas/report.json')
   end
 
   it "generates pson for error report which validates against the report schema" do
-    Puppet[:report_serialization_format] = "pson"
     error_report = generate_report_with_error
     expect(error_report.render).to validate_against('api/schemas/report.json')
   end
 
-  it "can make a round trip through yaml" do
-    Puppet[:report_serialization_format] = "yaml"
-    report = generate_report
-
-    yaml_output = report.render
-    tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
-
-    yaml_output.should =~ /^--- /
-    expect_equivalent_reports(tripped, report)
-  end
-
   def expect_equivalent_reports(tripped, report)
-    tripped.host.should == report.host
-    tripped.time.to_i.should == report.time.to_i
-    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)
+    expect(tripped.host).to eq(report.host)
+    expect(tripped.time.to_i).to eq(report.time.to_i)
+    expect(tripped.configuration_version).to eq(report.configuration_version)
+    expect(tripped.transaction_uuid).to eq(report.transaction_uuid)
+    expect(tripped.report_format).to eq(report.report_format)
+    expect(tripped.puppet_version).to eq(report.puppet_version)
+    expect(tripped.kind).to eq(report.kind)
+    expect(tripped.status).to eq(report.status)
+    expect(tripped.environment).to eq(report.environment)
+
+    expect(logs_as_strings(tripped)).to eq(logs_as_strings(report))
+    expect(metrics_as_hashes(tripped)).to eq(metrics_as_hashes(report))
     expect_equivalent_resource_statuses(tripped.resource_statuses, report.resource_statuses)
   end
 
@@ -445,27 +431,27 @@ describe Puppet::Transaction::Report do
   end
 
   def expect_equivalent_resource_statuses(tripped, report)
-    tripped.keys.sort.should == report.keys.sort
+    expect(tripped.keys.sort).to eq(report.keys.sort)
 
     tripped.each_pair do |name, status|
       expected = report[name]
 
-      status.title.should == expected.title
-      status.file.should == expected.file
-      status.line.should == expected.line
-      status.resource.should == expected.resource
-      status.resource_type.should == expected.resource_type
-      status.containment_path.should == expected.containment_path
-      status.evaluation_time.should == expected.evaluation_time
-      status.tags.should == expected.tags
-      status.time.to_i.should == expected.time.to_i
-      status.failed.should == expected.failed
-      status.changed.should == expected.changed
-      status.out_of_sync.should == expected.out_of_sync
-      status.skipped.should == expected.skipped
-      status.change_count.should == expected.change_count
-      status.out_of_sync_count.should == expected.out_of_sync_count
-      status.events.should == expected.events
+      expect(status.title).to eq(expected.title)
+      expect(status.file).to eq(expected.file)
+      expect(status.line).to eq(expected.line)
+      expect(status.resource).to eq(expected.resource)
+      expect(status.resource_type).to eq(expected.resource_type)
+      expect(status.containment_path).to eq(expected.containment_path)
+      expect(status.evaluation_time).to eq(expected.evaluation_time)
+      expect(status.tags).to eq(expected.tags)
+      expect(status.time.to_i).to eq(expected.time.to_i)
+      expect(status.failed).to eq(expected.failed)
+      expect(status.changed).to eq(expected.changed)
+      expect(status.out_of_sync).to eq(expected.out_of_sync)
+      expect(status.skipped).to eq(expected.skipped)
+      expect(status.change_count).to eq(expected.change_count)
+      expect(status.out_of_sync_count).to eq(expected.out_of_sync_count)
+      expect(status.events).to eq(expected.events)
     end
   end