puppet 4.10.0 → 5.0.0

data/spec/unit/resource/catalog_spec.rb

@@ -14,6 +14,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
     Puppet::Util::Storage.stubs(:store)
   end
 
+  it "should support json, pson, dot, yaml" do
+    # msgpack is optional, so using include instead of eq
+    expect(Puppet::Resource::Catalog.supported_formats).to include(:json, :pson, :dot, :yaml)
+  end
+
   # audit only resources are unmanaged
   # as are resources without properties with should values
   it "should write its managed resources' types, namevars" do
@@ -790,43 +795,43 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting a resource catalog to pson" do
+describe Puppet::Resource::Catalog, "when converting a resource catalog to json" do
   include JSONMatchers
   include PuppetSpec::Compiler
 
   it "should validate an empty catalog against the schema" do
     empty_catalog = compile_to_catalog("")
-    expect(empty_catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(empty_catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a noop catalog against the schema" do
     noop_catalog = compile_to_catalog("create_resources('file', {})")
-    expect(noop_catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(noop_catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a single resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a virtual resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a single exported resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a single sensitive parameter resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present','content'=>Sensitive('hunter2')}})")
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a two resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   it "should validate a two parameter class catalog against the schema" do
@@ -842,38 +847,37 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         two => 'world',
       }
     MANIFEST
-    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
   end
 
   context 'when dealing with parameters that have non-Data values' do
     context 'and rich_data is enabled' do
       before(:each) do
+        Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])))
         Puppet[:rich_data] = true
       end
 
       after(:each) do
         Puppet[:rich_data] = false
+        Puppet.pop_context
       end
 
 
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
-      it 'should generate ext_parameters for parameter values that are not Data' do
-        expect(catalog_w_regexp.to_json).to include('"ext_parameters":{"message":[[48,"[a-z]+"]]}')
-      end
-
-      it 'should validate ext_parameters against the schema' do
-        expect(catalog_w_regexp.to_json).to validate_against('api/schemas/catalog.json')
+      it 'should generate rich value hash for parameter values that are not Data' do
+        s = catalog_w_regexp.to_json
+        expect(s).to include('"parameters":{"message":{"__pcore_type__":"Regexp","__pcore_value__":"[a-z]+"}}')
       end
 
-      it 'should read and convert ext_parameters containing Regexp from json' do
+      it 'should read and convert rich value hash containing Regexp from json' do
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog_w_regexp.to_json))
         message = catalog2.resource('notify', 'foo')['message']
         expect(message).to be_a(Regexp)
         expect(message).to eql(/[a-z]+/)
       end
 
-      it 'should read and convert ext_parameters containing Version from json' do
+      it 'should read and convert rich value hash containing Version from json' do
         catalog = compile_to_catalog("notify {'foo': message => SemVer('1.0.0') }")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -881,7 +885,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         expect(message).to eql(SemanticPuppet::Version.parse('1.0.0'))
       end
 
-      it 'should read and convert ext_parameters containing VersionRange from json' do
+      it 'should read and convert rich value hash containing VersionRange from json' do
         catalog = compile_to_catalog("notify {'foo': message => SemVerRange('>=1.0.0') }")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -889,7 +893,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         expect(message).to eql(SemanticPuppet::VersionRange.parse('>=1.0.0'))
       end
 
-      it 'should read and convert ext_parameters containing Timespan from json' do
+      it 'should read and convert rich value hash containing Timespan from json' do
         catalog = compile_to_catalog("notify {'foo': message => Timespan(1234) }")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -897,7 +901,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         expect(message).to eql(Puppet::Pops::Time::Timespan.parse('1234', '%S'))
       end
 
-      it 'should read and convert ext_parameters containing Timestamp from json' do
+      it 'should read and convert rich value hash containing Timestamp from json' do
         catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -905,7 +909,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         expect(message).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
       end
 
-      it 'should read and convert ext_parameters containing hash with rich data from json' do
+      it 'should read and convert rich value hash containing hash with rich data from json' do
         catalog = compile_to_catalog("notify {'foo': message => { 'version' => SemVer('1.0.0'), 'time' => Timestamp('2016-09-15T08:32:16.123 UTC') }}")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -914,7 +918,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         expect(message['time']).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
       end
 
-      it 'should read and convert ext_parameters containing an array with rich data from json' do
+      it 'should read and convert rich value hash containing an array with rich data from json' do
         catalog = compile_to_catalog("notify {'foo': message => [ SemVer('1.0.0'), Timestamp('2016-09-15T08:32:16.123 UTC') ] }")
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
@@ -931,8 +935,8 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
 
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
-      it 'should not generate ext_parameters for parameter values that are not Data' do
-        expect(catalog_w_regexp.to_json).not_to include('"ext_parameters":{"message":[48,"[a-z]+"]}')
+      it 'should not generate rich value hash for parameter values that are not Data' do
+        expect(catalog_w_regexp.to_json).not_to include('"__pcore_type__"')
       end
 
       it 'should convert parameter containing Regexp into strings' do
@@ -971,14 +975,35 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
         message = catalog2.resource('notify', 'foo')['message']
         expect(message).to be_a(String)
-        expect(message).to eql('2016-09-15T08:32:16.123 UTC')
+        expect(message).to eql('2016-09-15T08:32:16.123000000 UTC')
+      end
+
+      it 'should convert param containing array with :undef entries' do
+        catalog = compile_to_catalog("notify {'foo': message => [ 10, undef, 20 ] }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Array)
+        expect(message[0]).to eql(10)
+        expect(message[1]).to eql(nil)
+        expect(message[2]).to eql(20)
+      end
+
+      it 'should convert param containing hash with :undef entries' do
+        catalog = compile_to_catalog("notify {'foo': message => {a => undef, b => 10}}")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Hash)
+        expect(message.has_key?('a')).to eql(true)
+        expect(message['a']).to eql(nil)
+        expect(message['b']).to eql(10)
       end
+
     end
 
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting to pson" do
+describe Puppet::Resource::Catalog, "when converting to json" do
   before do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
@@ -991,32 +1016,35 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
   }.each do |param, value|
     it "emits a #{param} equal to #{value.inspect}" do
       @catalog.send(param.to_s + "=", value)
-      pson = PSON.parse(@catalog.to_pson)
+      json = JSON.parse(@catalog.to_json)
 
-      expect(pson[param.to_s]).to eq(@catalog.send(param))
+      expect(json[param.to_s]).to eq(@catalog.send(param))
     end
   end
 
   it "emits an array of classes" do
     @catalog.add_class('foo')
-    pson = PSON.parse(@catalog.to_pson)
+    json = JSON.parse(@catalog.to_json)
 
-    expect(pson['classes']).to eq(['foo'])
+    expect(json['classes']).to eq(['foo'])
   end
 
-  it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
+  it "should convert its resources to a JSON-encoded array and store it as the 'resources' data" do
     one = stub 'one', :to_data_hash => "one_resource", :ref => "Foo[one]"
     two = stub 'two', :to_data_hash => "two_resource", :ref => "Foo[two]"
 
+    one.expects(:'[]').with(:alias).returns nil
+    two.expects(:'[]').with(:alias).returns nil
+
     @catalog.add_resource(one)
     @catalog.add_resource(two)
 
     # TODO this should really guarantee sort order
-    expect(PSON.parse(@catalog.to_pson,:create_additions => false)['resources'].sort).to eq(["one_resource", "two_resource"].sort)
+    expect(JSON.parse(@catalog.to_json,:create_additions => false)['resources'].sort).to eq(["one_resource", "two_resource"].sort)
 
   end
 
-  it "should convert its edges to a PSON-encoded array and store it as the 'edges' data" do
+  it "should convert its edges to a JSON-encoded array and store it as the 'edges' data" do
     one   = stub 'one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]'
     two   = stub 'two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]'
     three = stub 'three', :to_data_hash => "three_resource", :ref => 'Foo[three]'
@@ -1024,54 +1052,54 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
-    @catalog.edges_between(one, two  )[0].expects(:to_data_hash).returns "one_two_pson"
-    @catalog.edges_between(two, three)[0].expects(:to_data_hash).returns "two_three_pson"
+    @catalog.edges_between(one, two  )[0].expects(:to_data_hash).returns "one_two_json"
+    @catalog.edges_between(two, three)[0].expects(:to_data_hash).returns "two_three_json"
 
-    expect(PSON.parse(@catalog.to_pson,:create_additions => false)['edges'].sort).to eq(%w{one_two_pson two_three_pson}.sort)
+    expect(JSON.parse(@catalog.to_json,:create_additions => false)['edges'].sort).to eq(%w{one_two_json two_three_json}.sort)
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting from pson" do
+describe Puppet::Resource::Catalog, "when converting from json" do
   before do
     @data = {
       'name' => "myhost"
     }
   end
 
-  it "should create it with the provided name" do
+  it 'should create it with the provided name' do
     @data['version'] = 50
     @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
     @data['catalog_uuid'] = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
     @data['catalog_format'] = 42
     @data['tags'] = %w{one two}
     @data['classes'] = %w{one two}
-    @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
-                                               :event => "one",
-                                               :callback => "refresh").to_data_hash]
-    @data['resources'] = [Puppet::Resource.new(:file, "/foo").to_data_hash,
-                          Puppet::Resource.new(:file, "/bar").to_data_hash]
+    @data['edges'] = [Puppet::Relationship.new('File[/foo]', 'File[/bar]',
+                                               :event => :one,
+                                               :callback => :refresh).to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, '/foo').to_data_hash,
+                          Puppet::Resource.new(:file, '/bar').to_data_hash]
 
 
-    catalog = Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson
+    catalog = Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json
 
     expect(catalog.name).to eq('myhost')
     expect(catalog.version).to eq(@data['version'])
     expect(catalog.code_id).to eq(@data['code_id'])
     expect(catalog.catalog_uuid).to eq(@data['catalog_uuid'])
     expect(catalog.catalog_format).to eq(@data['catalog_format'])
-    expect(catalog).to be_tagged("one")
-    expect(catalog).to be_tagged("two")
+    expect(catalog).to be_tagged('one')
+    expect(catalog).to be_tagged('two')
 
     expect(catalog.classes).to eq(@data['classes'])
-    expect(catalog.resources.collect(&:ref)).to eq(["File[/foo]", "File[/bar]"])
+    expect(catalog.resources.collect(&:ref)).to eq(['File[/foo]', 'File[/bar]'])
 
-    expect(catalog.edges.collect(&:event)).to eq(["one"])
-    expect(catalog.edges[0].source).to eq(catalog.resource(:file, "/foo"))
-    expect(catalog.edges[0].target).to eq(catalog.resource(:file, "/bar"))
+    expect(catalog.edges.collect(&:event)).to eq([:one])
+    expect(catalog.edges[0].source).to eq(catalog.resource(:file, '/foo'))
+    expect(catalog.edges[0].target).to eq(catalog.resource(:file, '/bar'))
   end
 
   it "defaults the catalog_format to 0" do
-    catalog = Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson
+    catalog = Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json
     expect(catalog.catalog_format).to eq(0)
   end
 
@@ -1079,13 +1107,13 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
     @data['edges'] = [Puppet::Relationship.new("File[/missing]", "File[/bar]").to_data_hash]
     @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
 
-    expect { Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson }.to raise_error(ArgumentError, /Could not find relationship source/)
+    expect { Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json }.to raise_error(ArgumentError, /Could not find relationship source/)
   end
 
   it "should fail if the target resource cannot be found" do
     @data['edges'] = [Puppet::Relationship.new("File[/bar]", "File[/missing]").to_data_hash]
     @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
 
-    expect { Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson }.to raise_error(ArgumentError, /Could not find relationship target/)
+    expect { Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json }.to raise_error(ArgumentError, /Could not find relationship target/)
   end
 end

data/spec/unit/resource/status_spec.rb

@@ -6,67 +6,68 @@ require 'puppet/resource/status'
 describe Puppet::Resource::Status do
   include PuppetSpec::Files
 
+  let(:resource) { Puppet::Type.type(:file).new(:path => make_absolute("/my/file")) }
+  let(:containment_path) { ["foo", "bar", "baz"] }
+  let(:status) { Puppet::Resource::Status.new(resource) }
+
   before do
-    @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
-    @containment_path = ["foo", "bar", "baz"]
-    @resource.stubs(:pathbuilder).returns @containment_path
-    @status = Puppet::Resource::Status.new(@resource)
+    resource.stubs(:pathbuilder).returns(containment_path)
   end
 
   it "should compute type and title correctly" do
-    expect(@status.resource_type).to eq("File")
-    expect(@status.title).to eq(make_absolute("/my/file"))
+    expect(status.resource_type).to eq("File")
+    expect(status.title).to eq(make_absolute("/my/file"))
   end
 
   [:file, :line, :evaluation_time].each do |attr|
     it "should support #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status.send(attr)).to eq("foo")
+      status.send(attr.to_s + "=", "foo")
+      expect(status.send(attr)).to eq("foo")
     end
   end
 
   [:skipped, :failed, :restarted, :failed_to_restart, :changed, :out_of_sync, :scheduled].each do |attr|
     it "should support #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status.send(attr)).to eq("foo")
+      status.send(attr.to_s + "=", "foo")
+      expect(status.send(attr)).to eq("foo")
     end
 
     it "should have a boolean method for determining whehter it was #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status).to send("be_#{attr}")
+      status.send(attr.to_s + "=", "foo")
+      expect(status).to send("be_#{attr}")
     end
   end
 
   it "should accept a resource at initialization" do
-    expect(Puppet::Resource::Status.new(@resource).resource).not_to be_nil
+    expect(Puppet::Resource::Status.new(resource).resource).not_to be_nil
   end
 
   it "should set its source description to the resource's path" do
-    @resource.expects(:path).returns "/my/path"
-    expect(Puppet::Resource::Status.new(@resource).source_description).to eq("/my/path")
+    resource.expects(:path).returns "/my/path"
+    expect(Puppet::Resource::Status.new(resource).source_description).to eq("/my/path")
   end
 
   it "should set its containment path" do
-    expect(Puppet::Resource::Status.new(@resource).containment_path).to eq(@containment_path)
+  expect(Puppet::Resource::Status.new(resource).containment_path).to eq(containment_path)
   end
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
-      @resource.expects(attr).returns "foo"
-      expect(Puppet::Resource::Status.new(@resource).send(attr)).to eq("foo")
+      resource.expects(attr).returns "foo"
+      expect(Puppet::Resource::Status.new(resource).send(attr)).to eq("foo")
     end
   end
 
   it "should copy the resource's tags" do
-    @resource.expects(:tags).returns %w{foo bar}
-    status = Puppet::Resource::Status.new(@resource)
+    resource.expects(:tags).returns %w{foo bar}
+    status = Puppet::Resource::Status.new(resource)
     expect(status).to be_tagged("foo")
     expect(status).to be_tagged("bar")
   end
 
   it "should always convert the resource to a string" do
-    @resource.expects(:to_s).returns "foo"
-    expect(Puppet::Resource::Status.new(@resource).resource).to eq("foo")
+    resource.expects(:to_s).returns "foo"
+    expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
   end
 
   it "should support tags" do
@@ -74,121 +75,131 @@ describe Puppet::Resource::Status do
   end
 
   it "should create a timestamp at its creation time" do
-    expect(@status.time).to be_instance_of(Time)
+    expect(status.time).to be_instance_of(Time)
   end
 
   it "should support adding events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
-    @status.add_event(event)
-    expect(@status.events).to eq([event])
+    status.add_event(event)
+    expect(status.events).to eq([event])
   end
 
   it "should use '<<' to add events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
-    expect(@status << event).to equal(@status)
-    expect(@status.events).to eq([event])
+    expect(status << event).to equal(status)
+    expect(status.events).to eq([event])
   end
 
-  it "records an event for a failure caused by an error" do
-    @status.failed_because(StandardError.new("the message"))
+  it "fails and records a failure event with a given message" do
+    status.fail_with_event("foo fail")
+    event = status.events[0]
 
-    expect(@status.events[0].message).to eq("the message")
-    expect(@status.events[0].status).to eq("failure")
-    expect(@status.events[0].name).to eq(:resource_error)
+    expect(event.message).to eq("foo fail")
+    expect(event.status).to eq("failure")
+    expect(event.name).to eq(:resource_error)
+    expect(status.failed?).to be_truthy
+  end
+
+  it "fails and records a failure event with a given exception" do
+    error = StandardError.new("the message")
+    resource.expects(:log_exception).with(error, "Could not evaluate: the message")
+    status.expects(:fail_with_event).with("the message")
+
+    status.failed_because(error)
   end
 
   it "should count the number of successful events and set changed" do
-    3.times{ @status << Puppet::Transaction::Event.new(:status => 'success') }
-    expect(@status.change_count).to eq(3)
+    3.times{ status << Puppet::Transaction::Event.new(:status => 'success') }
+    expect(status.change_count).to eq(3)
 
-    expect(@status.changed).to eq(true)
-    expect(@status.out_of_sync).to eq(true)
+    expect(status.changed).to eq(true)
+    expect(status.out_of_sync).to eq(true)
   end
 
   it "should not start with any changes" do
-    expect(@status.change_count).to eq(0)
+    expect(status.change_count).to eq(0)
 
-    expect(@status.changed).to eq(false)
-    expect(@status.out_of_sync).to eq(false)
+    expect(status.changed).to eq(false)
+    expect(status.out_of_sync).to eq(false)
   end
 
   it "should not treat failure, audit, or noop events as changed" do
-    ['failure', 'audit', 'noop'].each do |s| @status << Puppet::Transaction::Event.new(:status => s) end
-    expect(@status.change_count).to eq(0)
-    expect(@status.changed).to eq(false)
+    ['failure', 'audit', 'noop'].each do |s| status << Puppet::Transaction::Event.new(:status => s) end
+    expect(status.change_count).to eq(0)
+    expect(status.changed).to eq(false)
   end
 
   it "should not treat audit events as out of sync" do
-    @status << Puppet::Transaction::Event.new(:status => 'audit')
-    expect(@status.out_of_sync_count).to eq(0)
-    expect(@status.out_of_sync).to eq(false)
+    status << Puppet::Transaction::Event.new(:status => 'audit')
+    expect(status.out_of_sync_count).to eq(0)
+    expect(status.out_of_sync).to eq(false)
   end
 
   ['failure', 'noop', 'success'].each do |event_status|
     it "should treat #{event_status} events as out of sync" do
-      3.times do @status << Puppet::Transaction::Event.new(:status => event_status) end
-      expect(@status.out_of_sync_count).to eq(3)
-      expect(@status.out_of_sync).to eq(true)
+      3.times do status << Puppet::Transaction::Event.new(:status => event_status) end
+      expect(status.out_of_sync_count).to eq(3)
+      expect(status.out_of_sync).to eq(true)
     end
   end
 
-  describe "When converting to YAML" do
-    it "should include only documented attributes" do
-      @status.file = "/foo.rb"
-      @status.line = 27
-      @status.evaluation_time = 2.7
-      @status.tags = %w{one two}
-      expect(@status.to_yaml_properties).to match_array(Puppet::Resource::Status::YAML_ATTRIBUTES)
+  context 'when serializing' do
+    let(:status) do
+      s = Puppet::Resource::Status.new(resource)
+      s.file = "/foo.rb"
+      s.line = 27
+      s.evaluation_time = 2.7
+      s.tags = %w{one two}
+      s << Puppet::Transaction::Event.new(:name => :mode_changed, :status => 'audit')
+      s.failed = false
+      s.changed = true
+      s.out_of_sync = true
+      s.skipped = false
+      s
+    end
+
+    it "should round trip through json" do
+      expect(status.containment_path).to eq(containment_path)
+
+      tripped = Puppet::Resource::Status.from_data_hash(JSON.parse(status.to_json))
+
+      expect(tripped.title).to eq(status.title)
+      expect(tripped.containment_path).to eq(status.containment_path)
+      expect(tripped.file).to eq(status.file)
+      expect(tripped.line).to eq(status.line)
+      expect(tripped.resource).to eq(status.resource)
+      expect(tripped.resource_type).to eq(status.resource_type)
+      expect(tripped.evaluation_time).to eq(status.evaluation_time)
+      expect(tripped.tags).to eq(status.tags)
+      expect(tripped.time).to eq(status.time)
+      expect(tripped.failed).to eq(status.failed)
+      expect(tripped.changed).to eq(status.changed)
+      expect(tripped.out_of_sync).to eq(status.out_of_sync)
+      expect(tripped.skipped).to eq(status.skipped)
+
+      expect(tripped.change_count).to eq(status.change_count)
+      expect(tripped.out_of_sync_count).to eq(status.out_of_sync_count)
+      expect(events_as_hashes(tripped)).to eq(events_as_hashes(status))
+    end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(status.to_data_hash)).to be_truthy
     end
-  end
 
-  it "should round trip through pson" do
-    @status.file = "/foo.rb"
-    @status.line = 27
-    @status.evaluation_time = 2.7
-    @status.tags = %w{one two}
-    @status << Puppet::Transaction::Event.new(:name => :mode_changed, :status => 'audit')
-    @status.failed = false
-    @status.changed = true
-    @status.out_of_sync = true
-    @status.skipped = false
-
-    expect(@status.containment_path).to eq(@containment_path)
-
-    tripped = Puppet::Resource::Status.from_data_hash(PSON.parse(@status.to_pson))
-
-    expect(tripped.title).to eq(@status.title)
-    expect(tripped.containment_path).to eq(@status.containment_path)
-    expect(tripped.file).to eq(@status.file)
-    expect(tripped.line).to eq(@status.line)
-    expect(tripped.resource).to eq(@status.resource)
-    expect(tripped.resource_type).to eq(@status.resource_type)
-    expect(tripped.evaluation_time).to eq(@status.evaluation_time)
-    expect(tripped.tags).to eq(@status.tags)
-    expect(tripped.time).to eq(@status.time)
-    expect(tripped.failed).to eq(@status.failed)
-    expect(tripped.changed).to eq(@status.changed)
-    expect(tripped.out_of_sync).to eq(@status.out_of_sync)
-    expect(tripped.skipped).to eq(@status.skipped)
-
-    expect(tripped.change_count).to eq(@status.change_count)
-    expect(tripped.out_of_sync_count).to eq(@status.out_of_sync_count)
-    expect(events_as_hashes(tripped)).to eq(events_as_hashes(@status))
-  end
-
-  def events_as_hashes(report)
-    report.events.collect do |e|
-      {
-        :audited => e.audited,
-        :property => e.property,
-        :previous_value => e.previous_value,
-        :desired_value => e.desired_value,
-        :historical_value => e.historical_value,
-        :message => e.message,
-        :name => e.name,
-        :status => e.status,
-        :time => e.time,
-      }
+    def events_as_hashes(report)
+      report.events.collect do |e|
+        {
+          :audited => e.audited,
+          :property => e.property,
+          :previous_value => e.previous_value,
+          :desired_value => e.desired_value,
+          :historical_value => e.historical_value,
+          :message => e.message,
+          :name => e.name,
+          :status => e.status,
+          :time => e.time,
+        }
+      end
     end
   end
 end