puppet 4.10.0 → 5.0.0

data/spec/unit/resource/type_collection_spec.rb

@@ -51,14 +51,14 @@ describe Puppet::Resource::TypeCollection do
     expect(@code.hostclass("foo")).to equal(klass)
   end
 
-  it "merge together hostclasses of the same name" do
+  it "errors if an attempt is made to merge hostclasses of the same name" do
     klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
     klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
 
-    @code.add(klass1)
-    @code.add(klass2)
-
-    expect(@code.hostclass("foo").doc).to eq("firstsecond")
+    expect {
+      @code.add(klass1)
+      @code.add(klass2)
+    }.to raise_error(/.*is already defined; cannot redefine/)
   end
 
   it "should store definitions as definitions" do

data/spec/unit/resource/type_spec.rb

@@ -25,73 +25,6 @@ describe Puppet::Resource::Type do
     end
   end
 
-  it "should indirect 'resource_type'" do
-    expect(Puppet::Resource::Type.indirection.name).to eq(:resource_type)
-  end
-
-  it "should default to 'parser' for its terminus class" do
-    expect(Puppet::Resource::Type.indirection.terminus_class).to eq(:parser)
-  end
-
-  describe "when converting to json" do
-    before do
-      @type = Puppet::Resource::Type.new(:hostclass, "foo")
-    end
-
-    def from_json(json)
-      Puppet::Resource::Type.from_data_hash(json)
-    end
-
-    def double_convert
-      Puppet::Resource::Type.from_data_hash(PSON.parse(@type.to_pson))
-    end
-
-    it "should include the name and type" do
-      expect(double_convert.name).to eq(@type.name)
-      expect(double_convert.type).to eq(@type.type)
-    end
-
-    it "should validate with only name and kind" do
-      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
-    end
-
-    it "should validate with all fields set" do
-      @type.set_arguments("one" => nil, "two" => "foo")
-      @type.line = 100
-      @type.doc = "A weird type"
-      @type.file = "/etc/manifests/thing.pp"
-      @type.parent = "one::two"
-
-      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
-    end
-
-    it "should include any arguments" do
-      @type.set_arguments("one" => nil, "two" => "foo")
-
-      expect(double_convert.arguments).to eq({"one" => nil, "two" => "foo"})
-    end
-
-    it "should not include arguments if none are present" do
-      expect(@type.to_pson["arguments"]).to be_nil
-    end
-
-    [:line, :doc, :file, :parent].each do |attr|
-      it "should include #{attr} when set" do
-        @type.send(attr.to_s + "=", "value")
-        expect(double_convert.send(attr)).to eq("value")
-      end
-
-      it "should not include #{attr} when not set" do
-        expect(@type.to_pson[attr.to_s]).to be_nil
-      end
-    end
-
-    it "should not include docs if they are empty" do
-      @type.doc = ""
-      expect(@type.to_pson["doc"]).to be_nil
-    end
-  end
-
   describe "when a node"  do
     it "should allow a regex as its name" do
       expect { Puppet::Resource::Type.new(:node, /foo/) }.not_to raise_error
@@ -243,7 +176,7 @@ describe Puppet::Resource::Type do
     let(:parser) { Puppet::Pops::Parser::Parser.new() }
 
     def wrap3x(expression)
-      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.current)
+      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.model)
     end
 
     def parse_expression(expr_string)
@@ -589,7 +522,7 @@ describe Puppet::Resource::Type do
       @type.stubs(:code).returns code
 
       subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
 
       elevel = 876
       subscope.expects(:with_guarded_scope).yields
@@ -615,7 +548,7 @@ describe Puppet::Resource::Type do
 
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :namespace => 'foo', :resource => @resource).returns subscope
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
@@ -903,7 +836,7 @@ describe Puppet::Resource::Type do
 
     it "should set the other class's code as its code if it has none" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
-      source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
+      source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar").model)
 
       dest.merge(source)
 

data/spec/unit/resource_spec.rb

@@ -399,11 +399,6 @@ describe Puppet::Resource do
             inject_and_set_defaults(resource, scope)
           end
 
-          it "should not query the injector" do
-            compiler.injector.expects(:find).never
-            inject_and_set_defaults(resource, scope)
-          end
-
           it "should use the value provided" do
             Puppet::DataBinding.indirection.expects(:find).never
             expect(resource.set_default_parameters(scope)).to eq([])
@@ -653,11 +648,11 @@ describe Puppet::Resource do
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
 
-    # PUP-3272, since serialization to network is done in pson, not yaml
-    it "should produce an equivalent pson object" do
-      text = @resource.render('pson')
+    # PUP-3272, since serialization to network is done in json, not yaml
+    it "should produce an equivalent json object" do
+      text = @resource.render('json')
 
-      newresource = Puppet::Resource.convert_from('pson', text)
+      newresource = Puppet::Resource.convert_from('json', text)
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
   end
@@ -674,15 +669,20 @@ describe Puppet::Resource do
     end
 
     it "doesn't include transient instance variables (#4506)" do
-      expect(@resource.to_yaml_properties).to_not include(:@rstype)
+      expect(@resource.to_data_hash.keys).to_not include('rstype')
     end
 
-    it "produces an equivalent pson object" do
-      text = @resource.render('pson')
+    it "produces an equivalent json object" do
+      text = @resource.render('json')
 
-      newresource = Puppet::Resource.convert_from('pson', text)
+      newresource = Puppet::Resource.convert_from('json', text)
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      Puppet::Pops::Types::TypeAsserter.assert_instance_of('', Puppet::Pops::Types::TypeFactory.data, @resource.to_data_hash)
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(@resource.to_data_hash)).to be_truthy
+    end
   end
 
   describe "when converting to a RAL resource" do
@@ -732,7 +732,7 @@ describe Puppet::Resource do
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
-          noop   => 'true',
+          noop   => true,
         }
       HEREDOC
     end
@@ -754,54 +754,54 @@ describe Puppet::Resource do
           /my/file:
             ensure: 'present'
             foo   : ['one', 'two']
-            noop  : 'true'
+            noop  : true
       HEREDOC
     end
   end
-  describe "when converting to pson" do
+  describe "when converting to json" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
-      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type).to eq("File")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(Puppet::Resource.new("File", "/foo").to_json)).type).to eq("File")
     end
 
     it "should set its title to the provided title" do
-      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title).to eq("/foo")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(Puppet::Resource.new("File", "/foo").to_json)).title).to eq("/foo")
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).tags).to eq(resource.tags)
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).tags).to eq(resource.tags)
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).file).to eq("/my/file")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).file).to eq("/my/file")
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).line).to eq(50)
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_truthy
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).exported?).to be_truthy
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_falsey
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).exported?).to be_falsey
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
@@ -809,37 +809,33 @@ describe Puppet::Resource do
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
-      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result["foo"]).to eq(%w{bar eh})
       expect(result["fee"]).to eq(%w{baz})
     end
 
     it "should set sensitive parameters as an array of strings" do
       resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
-      result = PSON.parse(resource.to_pson)
+      result = JSON.parse(resource.to_json)
       expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
     end
 
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
-      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result[:requires]).to eq("File[/bar]")
     end
 
     it "should serialize multiple relationships as arrays of reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
-      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result[:requires]).to eq([ "File[/bar]",  "File[/baz]" ])
     end
   end
 
-  describe "when converting from pson" do
-    def pson_result_should
-      Puppet::Resource.expects(:new).with { |hash| yield hash }
-    end
-
+  describe "when converting from json" do
     before do
       @data = {
         'type' => "file",
@@ -872,12 +868,12 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(@data).line).to eq(50)
     end
 
-    it "should 'exported' to true if set in the pson data" do
+    it "should 'exported' to true if set in the json data" do
       @data['exported'] = true
       expect(Puppet::Resource.from_data_hash(@data).exported).to be_truthy
     end
 
-    it "should 'exported' to false if not set in the pson data" do
+    it "should 'exported' to false if not set in the json data" do
       expect(Puppet::Resource.from_data_hash(@data).exported).to be_falsey
     end
 

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