puppet 4.10.12 → 5.0.0

data/spec/unit/settings_spec.rb

@@ -1308,10 +1308,9 @@ describe Puppet::Settings do
       @settings.to_catalog
     end
 
-    describe "on Microsoft Windows" do
+    describe "on Microsoft Windows", :if => Puppet.features.microsoft_windows? do
       before :each do
         Puppet.features.stubs(:root?).returns true
-        Puppet.features.stubs(:microsoft_windows?).returns true
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
@@ -1477,8 +1476,11 @@ describe Puppet::Settings do
 
       main = stub 'main_resource', :ref => "File[/maindir]"
       main.expects(:to_manifest).returns "maindir"
+      main.expects(:'[]').with(:alias).returns nil
       second = stub 'second_resource', :ref => "File[/seconddir]"
       second.expects(:to_manifest).returns "seconddir"
+      second.expects(:'[]').with(:alias).returns nil
+
       @settings.setting(:maindir).expects(:to_resource).returns main
       @settings.setting(:seconddir).expects(:to_resource).returns second
 

data/spec/unit/ssl/host_spec.rb

@@ -4,10 +4,10 @@ require 'spec_helper'
 require 'puppet/ssl/host'
 require 'matchers/json'
 
-def base_pson_comparison(result, pson_hash)
-  expect(result["fingerprint"]).to eq(pson_hash["fingerprint"])
-  expect(result["name"]).to        eq(pson_hash["name"])
-  expect(result["state"]).to       eq(pson_hash["desired_state"])
+def base_json_comparison(result, json_hash)
+  expect(result["fingerprint"]).to eq(json_hash["fingerprint"])
+  expect(result["name"]).to        eq(json_hash["name"])
+  expect(result["state"]).to       eq(json_hash["desired_state"])
 end
 
 describe Puppet::SSL::Host do
@@ -807,7 +807,7 @@ describe Puppet::SSL::Host do
     end
   end
 
-  describe "when handling PSON", :unless => Puppet.features.microsoft_windows? do
+  describe "when handling JSON", :unless => Puppet.features.microsoft_windows? do
     include PuppetSpec::Files
 
     before do
@@ -821,12 +821,12 @@ describe Puppet::SSL::Host do
       @ca=Puppet::SSL::CertificateAuthority.new
     end
 
-    describe "when converting to PSON" do
+    describe "when converting to JSON" do
       let(:host) do
         Puppet::SSL::Host.new("bazinga")
       end
 
-      let(:pson_hash) do
+      let(:json_hash) do
         {
           "fingerprint"   => host.certificate_request.fingerprint,
           "desired_state" => 'requested',
@@ -837,15 +837,15 @@ describe Puppet::SSL::Host do
       it "should be able to identify a host with an unsigned certificate request" do
         host.generate_certificate_request
 
-        result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
+        result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
 
-        base_pson_comparison result, pson_hash
+        base_json_comparison result, json_hash
       end
 
       it "should validate against the schema" do
         host.generate_certificate_request
 
-        expect(host.to_pson).to validate_against('api/schemas/host.json')
+        expect(host.to_json).to validate_against('api/schemas/host.json')
       end
 
       describe "explicit fingerprints" do
@@ -853,12 +853,12 @@ describe Puppet::SSL::Host do
           it "should include #{md}" do
             mds = md.to_s
             host.generate_certificate_request
-            pson_hash["fingerprints"] = {}
-            pson_hash["fingerprints"][mds] = host.certificate_request.fingerprint(md)
+            json_hash["fingerprints"] = {}
+            json_hash["fingerprints"][mds] = host.certificate_request.fingerprint(md)
 
-            result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
-            base_pson_comparison result, pson_hash
-            expect(result["fingerprints"][mds]).to eq(pson_hash["fingerprints"][mds])
+            result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
+            base_json_comparison result, json_hash
+            expect(result["fingerprints"][mds]).to eq(json_hash["fingerprints"][mds])
           end
         end
       end
@@ -867,11 +867,11 @@ describe Puppet::SSL::Host do
         describe "when not specified" do
           it "should include the dns_alt_names associated with the certificate" do
             host.generate_certificate_request
-            pson_hash["desired_alt_names"] = host.certificate_request.subject_alt_names
+            json_hash["desired_alt_names"] = host.certificate_request.subject_alt_names
 
-            result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
-            base_pson_comparison result, pson_hash
-            expect(result["dns_alt_names"]).to eq(pson_hash["desired_alt_names"])
+            result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
+            base_json_comparison result, json_hash
+            expect(result["dns_alt_names"]).to eq(json_hash["desired_alt_names"])
           end
         end
 
@@ -884,15 +884,15 @@ describe Puppet::SSL::Host do
             end
 
             it "should include the dns_alt_names associated with the certificate" do
-              pson_hash["desired_alt_names"] = host.certificate_request.subject_alt_names
+              json_hash["desired_alt_names"] = host.certificate_request.subject_alt_names
 
-              result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
-              base_pson_comparison result, pson_hash
-              expect(result["dns_alt_names"]).to eq(pson_hash["desired_alt_names"])
+              result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
+              base_json_comparison result, json_hash
+              expect(result["dns_alt_names"]).to eq(json_hash["desired_alt_names"])
             end
 
             it "should validate against the schema" do
-              expect(host.to_pson).to validate_against('api/schemas/host.json')
+              expect(host.to_json).to validate_against('api/schemas/host.json')
             end
           end
         end
@@ -901,37 +901,37 @@ describe Puppet::SSL::Host do
       it "should be able to identify a host with a signed certificate" do
         host.generate_certificate_request
         @ca.sign(host.name)
-        pson_hash = {
+        json_hash = {
           "fingerprint"          => Puppet::SSL::Certificate.indirection.find(host.name).fingerprint,
           "desired_state"        => 'signed',
           "name"                 => host.name,
         }
 
-        result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
-        base_pson_comparison result, pson_hash
+        result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
+        base_json_comparison result, json_hash
       end
 
       it "should be able to identify a host with a revoked certificate" do
         host.generate_certificate_request
         @ca.sign(host.name)
         @ca.revoke(host.name)
-        pson_hash["fingerprint"] = Puppet::SSL::Certificate.indirection.find(host.name).fingerprint
-        pson_hash["desired_state"] = 'revoked'
+        json_hash["fingerprint"] = Puppet::SSL::Certificate.indirection.find(host.name).fingerprint
+        json_hash["desired_state"] = 'revoked'
 
-        result = PSON.parse(Puppet::SSL::Host.new(host.name).to_pson)
-        base_pson_comparison result, pson_hash
+        result = JSON.parse(Puppet::SSL::Host.new(host.name).to_json)
+        base_json_comparison result, json_hash
       end
     end
 
-    describe "when converting from PSON" do
+    describe "when converting from JSON" do
       it "should return a Puppet::SSL::Host object with the specified desired state" do
         host = Puppet::SSL::Host.new("bazinga")
         host.desired_state="signed"
-        pson_hash = {
+        json_hash = {
           "name"  => host.name,
           "desired_state" => host.desired_state,
         }
-        generated_host = Puppet::SSL::Host.from_data_hash(pson_hash)
+        generated_host = Puppet::SSL::Host.from_data_hash(json_hash)
         expect(generated_host.desired_state).to eq(host.desired_state)
         expect(generated_host.name).to eq(host.name)
       end

data/spec/unit/status_spec.rb

@@ -15,15 +15,15 @@ describe Puppet::Status do
     expect(Puppet::Status.new.status["is_alive"]).to eq(true)
   end
 
-  it "should return a pson hash" do
-    expect(Puppet::Status.new.status.to_pson).to eq('{"is_alive":true}')
+  it "should return a json hash" do
+    expect(Puppet::Status.new.status.to_json).to eq('{"is_alive":true}')
   end
 
-  it "should render to a pson hash" do
-    expect(PSON::pretty_generate(Puppet::Status.new)).to match(/"is_alive":\s*true/)
+  it "should render to a json hash" do
+    expect(JSON::pretty_generate(Puppet::Status.new)).to match(/"is_alive":\s*true/)
   end
 
-  it "should accept a hash from pson" do
+  it "should accept a hash from json" do
     status = Puppet::Status.new( { "is_alive" => false } )
     expect(status.status).to eq({ "is_alive" => false })
   end
@@ -36,10 +36,10 @@ describe Puppet::Status do
     Puppet::Status.new.name = "status"
   end
 
-  it "serializes to PSON that conforms to the status schema" do
+  it "serializes to JSON that conforms to the status schema" do
     status = Puppet::Status.new
     status.version = Puppet.version
 
-    expect(status.render('pson')).to validate_against('api/schemas/status.json')
+    expect(status.render('json')).to validate_against('api/schemas/status.json')
   end
 end

data/spec/unit/transaction/event_spec.rb

@@ -121,21 +121,24 @@ describe Puppet::Transaction::Event do
   end
 
   describe "When converting to YAML" do
-    it "should include only documented attributes" do
-      resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
-      event = Puppet::Transaction::Event.new(:source_description => "/my/param", :resource => resource,
-                                             :file => "/foo.rb", :line => 27, :tags => %w{one two},
-                                             :desired_value => 7, :historical_value => 'Brazil',
-                                             :message => "Help I'm trapped in a spec test",
-                                             :name => :mode_changed, :previous_value => 6, :property => :mode,
-                                             :status => 'success',
-                                             :redacted => false,
-                                             :corrective_change => false)
-      expect(event.to_yaml_properties).to match_array(Puppet::Transaction::Event::YAML_ATTRIBUTES)
+    let(:resource) { Puppet::Type.type(:file).new(:title => make_absolute('/tmp/foo')) }
+    let(:event) do
+      Puppet::Transaction::Event.new(:source_description => "/my/param", :resource => resource,
+        :file => "/foo.rb", :line => 27, :tags => %w{one two},
+        :desired_value => 7, :historical_value => 'Brazil',
+        :message => "Help I'm trapped in a spec test",
+        :name => :mode_changed, :previous_value => 6, :property => :mode,
+        :status => 'success',
+        :redacted => false,
+        :corrective_change => false)
+    end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(event.to_data_hash)).to be_truthy
     end
   end
 
-  it "should round trip through pson" do
+  it "should round trip through json" do
       resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
       event = Puppet::Transaction::Event.new(
         :source_description => "/my/param",
@@ -151,7 +154,7 @@ describe Puppet::Transaction::Event do
         :property => :mode,
         :status => 'success')
 
-      tripped = Puppet::Transaction::Event.from_data_hash(PSON.parse(event.to_pson))
+      tripped = Puppet::Transaction::Event.from_data_hash(JSON.parse(event.to_json))
 
       expect(tripped.audited).to eq(event.audited)
       expect(tripped.property).to eq(event.property)
@@ -164,7 +167,7 @@ describe Puppet::Transaction::Event do
       expect(tripped.time).to eq(event.time)
   end
 
-  it "should round trip an event for an inspect report through pson" do
+  it "should round trip an event for an inspect report through json" do
       resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
       event = Puppet::Transaction::Event.new(
         :audited => true,
@@ -178,7 +181,7 @@ describe Puppet::Transaction::Event do
         :property => :mode,
         :status => 'success')
 
-      tripped = Puppet::Transaction::Event.from_data_hash(PSON.parse(event.to_pson))
+      tripped = Puppet::Transaction::Event.from_data_hash(JSON.parse(event.to_json))
 
       expect(tripped.desired_value).to be_nil
       expect(tripped.historical_value).to be_nil

data/spec/unit/transaction/report_spec.rb

@@ -15,97 +15,107 @@ describe Puppet::Transaction::Report do
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
-    expect(Puppet::Transaction::Report.new("apply").host).to eq("mynode")
+    expect(Puppet::Transaction::Report.new.host).to eq("mynode")
   end
 
   it "should return its host name as its name" do
-    r = Puppet::Transaction::Report.new("apply")
+    r = Puppet::Transaction::Report.new
     expect(r.name).to eq(r.host)
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
-    expect(Puppet::Transaction::Report.new("apply").time).to eq("mytime")
+    expect(Puppet::Transaction::Report.new.time).to eq("mytime")
   end
 
-  it "should take a 'kind' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect").kind).to eq("inspect")
+  it "should take a 'configuration_version' as an argument" do
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment").configuration_version).to eq("some configuration version")
   end
 
-  it "should take a 'configuration_version' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version).to eq("some configuration version")
+  it "should take a 'transaction_uuid' as an argument" do
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
   end
 
   it "should take a 'transaction_uuid' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
+  end
+
+  it "should take a 'job_id' as an argument" do
+    expect(Puppet::Transaction::Report.new('cv', 'env', 'tid', 'some job id').job_id).to eq('some job id')
   end
 
   it "should be able to set configuration_version" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.configuration_version = "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 = Puppet::Transaction::Report.new
     report.transaction_uuid = "some transaction uuid"
     expect(report.transaction_uuid).to eq("some transaction uuid")
   end
 
+  it "should be able to set job_id" do
+    report = Puppet::Transaction::Report.new
+    report.job_id = "some job id"
+    expect(report.job_id).to eq("some job id")
+  end
+
   it "should be able to set code_id" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.code_id = "some code id"
     expect(report.code_id).to eq("some code id")
   end
 
   it "should be able to set catalog_uuid" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.catalog_uuid = "some catalog uuid"
     expect(report.catalog_uuid).to eq("some catalog uuid")
   end
 
   it "should be able to set cached_catalog_status" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.cached_catalog_status = "explicitly_requested"
     expect(report.cached_catalog_status).to eq("explicitly_requested")
   end
 
   it "should set noop to true if Puppet[:noop] is true" do
     Puppet[:noop] = true
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_truthy
   end
 
   it "should set noop to false if Puppet[:noop] is false" do
     Puppet[:noop] = false
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_falsey
   end
 
   it "should set noop to false if Puppet[:noop] is unset" do
     Puppet[:noop] = nil
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_falsey
   end
 
   it "should take 'environment' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment).to eq("some environment")
+    expect(Puppet::Transaction::Report.new("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 = Puppet::Transaction::Report.new
     report.environment = "some environment"
     expect(report.environment).to eq("some environment")
   end
 
   it "should be able to set resources_failed_to_generate" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     report.resources_failed_to_generate = true
     expect(report.resources_failed_to_generate).to be_truthy
   end
 
   it "resources_failed_to_generate should not be true by default" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.resources_failed_to_generate).to be_falsey
   end
 
@@ -118,7 +128,7 @@ describe Puppet::Transaction::Report do
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(file)
 
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
 
     catalog.apply(:report => report)
     report.finalize_report
@@ -129,7 +139,7 @@ describe Puppet::Transaction::Report do
 
   describe "when accepting logs" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     it "should add new logs to the log list" do
@@ -146,7 +156,7 @@ describe Puppet::Transaction::Report do
   describe "#as_logging_destination" do
     it "makes the report collect logs during the block " do
       log_string = 'Hello test report!'
-      report = Puppet::Transaction::Report.new('test')
+      report = Puppet::Transaction::Report.new
       report.as_logging_destination do
         Puppet.err(log_string)
       end
@@ -157,7 +167,7 @@ describe Puppet::Transaction::Report do
 
   describe "when accepting resource statuses" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     it "should add each status to its status list" do
@@ -172,7 +182,7 @@ describe Puppet::Transaction::Report do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
@@ -182,7 +192,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should delegate its name attribute to its host method" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.expects(:host).returns "me"
       expect(report.name).to eq("me")
     end
@@ -190,21 +200,21 @@ describe Puppet::Transaction::Report do
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       expect(report.exit_status).to eq(2)
     end
 
     it "should produce 4 if failures are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       expect(report.exit_status).to eq(4)
     end
 
     it "should produce 4 if failures to restart are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 0})
       report.add_metric("resources", {"failed_to_restart" => 1})
@@ -212,7 +222,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should produce 6 if both changes and failures are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       expect(report.exit_status).to eq(6)
@@ -221,14 +231,14 @@ describe Puppet::Transaction::Report do
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       expect(report.status).to eq('failed')
     end
   end
 
   describe "when finalizing the report" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     def metric(name, value)
@@ -247,19 +257,6 @@ describe Puppet::Transaction::Report do
       end
     end
 
-    it "should be unchanged if there are no other failures or changes and the transaction completed" do
-      @report.transaction_completed = true
-      @report.finalize_report
-
-      expect(@report.status).to eq("unchanged")
-    end
-
-    it "should be failed if there are no other failures or changes and the transaction did not complete" do
-      @report.finalize_report
-
-      expect(@report.status).to eq("failed")
-    end
-
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
@@ -291,14 +288,18 @@ describe Puppet::Transaction::Report do
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
-        @report.transaction_completed = true
+        @report.finalize_report
+        expect(@report.status).to eq('failed')
+      end
+
+      it "should mark the report as 'failed' if resources failed to restart" do
+        add_statuses(1) { |status| status.failed_to_restart = true }
         @report.finalize_report
         expect(@report.status).to eq('failed')
       end
 
       it "should mark the report as 'failed' if resources_failed_to_generate" do
         @report.resources_failed_to_generate = true
-        @report.transaction_completed = true
         @report.finalize_report
         expect(@report.status).to eq('failed')
       end
@@ -307,14 +308,12 @@ describe Puppet::Transaction::Report do
     describe "for changes" 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.transaction_completed = true
         @report.finalize_report
         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.transaction_completed = true
         @report.finalize_report
         expect(metric(:changes, "total")).to eq(0)
         expect(@report.status).to eq('unchanged')
@@ -485,67 +484,89 @@ describe Puppet::Transaction::Report do
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
-      report = Puppet::Transaction::Report.new('apply')
+      report = Puppet::Transaction::Report.new
       report.add_times('config_retrieval', 1.0)
-      expect(report.to_yaml_properties).not_to include('@external_times')
+      expect(report.to_data_hash.keys).not_to include('external_times')
     end
 
     it "should not include @resources_failed_to_generate" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.resources_failed_to_generate = true
-      expect(report.to_yaml_properties).not_to include('@resources_failed_to_generate')
+      expect(report.to_data_hash.keys).not_to include('resources_failed_to_generate')
+    end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(generate_report.to_data_hash)).to be_truthy
     end
   end
 
-  it "defaults to serializing to pson" do
-    expect(Puppet::Transaction::Report.default_format).to eq(:pson)
+  it "defaults to serializing to json" do
+    expect(Puppet::Transaction::Report.default_format).to eq(:json)
   end
 
-  it "supports both yaml and pson" do
-    expect(Puppet::Transaction::Report.supported_formats).to eq([:pson, :yaml])
+  it "supports both json, pson and yaml" do
+    # msgpack is optional, so using include instead of eq
+    expect(Puppet::Transaction::Report.supported_formats).to include(:json, :pson, :yaml)
   end
 
-  it "can make a round trip through pson" do
-    report = generate_report
+  context 'can make a round trip through' do
+    before(:each) do
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:current_environment)))
+    end
+
+    after(:each) { Puppet.pop_context }
+
+    it 'pson' do
+      report = generate_report
 
-    tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)
+      tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)
 
-    expect_equivalent_reports(tripped, report)
+      expect_equivalent_reports(tripped, report)
+    end
+
+    it 'json' do
+      report = generate_report
+
+      tripped = Puppet::Transaction::Report.convert_from(:json, report.render)
+
+      expect_equivalent_reports(tripped, report)
+    end
+
+    it 'yaml' do
+      report = generate_report
+
+      yaml_output = report.render(:yaml)
+      tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
+
+      expect(yaml_output).to match(/^--- /)
+      expect_equivalent_reports(tripped, report)
+    end
   end
 
-  it "generates pson which validates against the report schema" do
+  it "generates json which validates against the report schema" do
     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
+  it "generates json for error report which validates against the report schema" do
     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
-    report = generate_report
-
-    yaml_output = report.render(:yaml)
-    tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
-
-    expect(yaml_output).to match(/^--- /)
-    expect_equivalent_reports(tripped, report)
-  end
-
   def expect_equivalent_reports(tripped, 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.job_id).to eq(report.job_id)
     expect(tripped.code_id).to eq(report.code_id)
     expect(tripped.catalog_uuid).to eq(report.catalog_uuid)
     expect(tripped.cached_catalog_status).to eq(report.cached_catalog_status)
     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(tripped.corrective_change).to eq(report.corrective_change)
 
     expect(logs_as_strings(tripped)).to eq(logs_as_strings(report))
     expect(metrics_as_hashes(tripped)).to eq(metrics_as_hashes(report))
@@ -583,7 +604,7 @@ describe Puppet::Transaction::Report do
       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.map(&:to_data_hash)).to eq(expected.events.map(&:to_data_hash))
+      expect(status.events).to eq(expected.events)
     end
   end
 
@@ -591,8 +612,8 @@ describe Puppet::Transaction::Report do
     event_hash = {
       :audited => false,
       :property => 'message',
-      :previous_value => 'absent',
-      :desired_value => 'a resource',
+      :previous_value => SemanticPuppet::VersionRange.parse('>=1.0.0'),
+      :desired_value => SemanticPuppet::VersionRange.parse('>=1.2.0'),
       :historical_value => nil,
       :message => "defined 'message' as 'a resource'",
       :name => :message_changed,
@@ -604,7 +625,7 @@ describe Puppet::Transaction::Report do
     status.changed = true
     status.add_event(event)
 
-    report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report = Puppet::Transaction::Report.new(1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749", '42')
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
     report.code_id = "some code id"
@@ -612,7 +633,6 @@ describe Puppet::Transaction::Report do
     report.cached_catalog_status = "not_used"
     report.master_used = "test:000"
     report.add_resource_status(status)
-    report.transaction_completed = true
     report.finalize_report
     report
   end
@@ -622,7 +642,7 @@ describe Puppet::Transaction::Report do
     status.changed = true
     status.failed_because("bad stuff happened")
 
-    report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report = Puppet::Transaction::Report.new(1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749", '42')
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
     report.code_id = "some code id"
@@ -630,7 +650,6 @@ describe Puppet::Transaction::Report do
     report.cached_catalog_status = "not_used"
     report.master_used = "test:000"
     report.add_resource_status(status)
-    report.transaction_completed = true
     report.finalize_report
     report
   end