puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/provider/service/base_spec.rb

@@ -91,24 +91,4 @@ describe "base service provider" do
       expect {subject.stop }.to raise_error(Puppet::Error, 'Could not stop Service[test]: failed to stop')
     end
   end
-
-  context "when hasstatus is false" do
-    subject do
-      type.new(
-         :name  => "status test",
-         :provider => :base,
-         :hasstatus => false,
-         :pattern => "majestik m\u00f8\u00f8se",
-      ).provider
-    end
-
-    it "retrieves a PID from the process table" do
-      Facter.stubs(:value).with(:operatingsystem).returns("CentOS")
-      ps_output = File.binread(my_fixture("ps_ef.mixed_encoding")).force_encoding(Encoding::UTF_8)
-
-      executor.expects(:execute).with("ps -ef").returns(ps_output)
-
-      expect(subject.status).to eq(:running)
-    end
-  end
 end

data/spec/unit/provider/service/smf_spec.rb

@@ -18,6 +18,8 @@ describe provider_class, :if => Puppet.features.posix? do
 
     FileTest.stubs(:file?).with('/usr/sbin/svcadm').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/svcadm').returns true
+    FileTest.stubs(:file?).with('/usr/sbin/svccfg').returns true
+    FileTest.stubs(:executable?).with('/usr/sbin/svccfg').returns true
     FileTest.stubs(:file?).with('/usr/bin/svcs').returns true
     FileTest.stubs(:executable?).with('/usr/bin/svcs').returns true
     Facter.stubs(:value).with(:operatingsystem).returns('Solaris')
@@ -74,9 +76,9 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.status
     end
-    it "should return stopped if svcs can't find the service" do
+    it "should return absent if svcs can't find the service" do
       @provider.stubs(:svcs).raises(Puppet::ExecutionFailure.new("no svc found"))
-      expect(@provider.status).to eq(:stopped)
+      expect(@provider.status).to eq(:absent)
     end
     it "should return running if online in svcs output" do
       @provider.stubs(:svcs).returns("online\t-")

data/spec/unit/provider/service/systemd_spec.rb

@@ -58,20 +58,6 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
-  it "should be the default provider on Amazon Linux 2.0" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2")
-    expect(described_class).to be_default
-  end
-
-  it "should not be the default provider on Amazon Linux 2017.09" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2017")
-    expect(described_class).not_to be_default
-  end
-
   it "should be the default provider on cumulus3" do
     Facter.stubs(:value).with(:osfamily).returns(:debian)
     Facter.stubs(:value).with(:operatingsystem).returns('CumulusLinux')
@@ -126,7 +112,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     expect(described_class).not_to be_default
   end
 
-  [ '15.04', '15.10', '16.04', '16.10', '17.04', '17.10' ].each do |ver|
+  [ '15.04', '15.10', '16.04', '16.10' ].each do |ver|
     it "should be the default provider on ubuntu#{ver}" do
       Facter.stubs(:value).with(:osfamily).returns(:debian)
       Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)

data/spec/unit/provider/user/directoryservice_spec.rb

@@ -157,7 +157,7 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     "9377c46908a1c8ac2c3e45c0d44da8ad0fcd85ec5c14d9a59ffc40c9da31f0ec"
   end
 
-  # The below value is a Fixnum iterations value used in the PBKDF2
+  # The below value is an Integer iterations value used in the PBKDF2
   # key stretching algorithm
   let(:pbkdf2_iterations_value) do
     24752
@@ -394,12 +394,12 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
       provider.class.prefetch({})
     end
 
-    it 'should return :uid values as a Fixnum' do
-      expect(provider.class.generate_attribute_hash(user_plist_hash)[:uid]).to be_a_kind_of Fixnum
+    it 'should return :uid values as an Integer' do
+      expect(provider.class.generate_attribute_hash(user_plist_hash)[:uid]).to be_a Integer
     end
 
-    it 'should return :gid values as a Fixnum' do
-      expect(provider.class.generate_attribute_hash(user_plist_hash)[:gid]).to be_a_kind_of Fixnum
+    it 'should return :gid values as an Integer' do
+      expect(provider.class.generate_attribute_hash(user_plist_hash)[:gid]).to be_a Integer
     end
 
     it 'should return a hash of resource attributes' do
@@ -799,8 +799,8 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     it "should accept a hash containing a PBKDF2 password hash, salt, and iterations value and return the correct iterations value" do
         expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to eq(pbkdf2_iterations_value)
     end
-    it "should return a Fixnum value when looking up the PBKDF2 iterations value" do
-        expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to be_a_kind_of(Fixnum)
+    it "should return an Integer value when looking up the PBKDF2 iterations value" do
+        expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to be_a(Integer)
     end
     it "should raise an error if a field other than 'entropy', 'salt', or 'iterations' is passed" do
       expect { provider.class.get_salted_sha512_pbkdf2('othervalue', pbkdf2_embedded_bplist_hash) }.to raise_error(Puppet::Error, /Puppet has tried to read an incorrect value from the SALTED-SHA512-PBKDF2 hash. Acceptable fields are 'salt', 'entropy', or 'iterations'/)

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -81,9 +81,9 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group1').returns(group1)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group2').returns(group2)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group3').returns(group3)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group1').returns(group1)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group2').returns(group2)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group3').returns(group3)
     end
 
     it "should return true for same lists of members" do
@@ -267,7 +267,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   end
 
   it 'should be able to test whether a user exists' do
-    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
+    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
     Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'User')
     expect(provider).to be_exists
 

data/spec/unit/provider/zfs/zfs_spec.rb

@@ -49,7 +49,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
     end
 
     Puppet::Type.type(:zfs).validproperties.each do |prop|
-      next if [:ensure, :volsize].include?(prop)
+      next if prop == :ensure
       it "should include property #{prop}" do
         resource[prop] = prop
 
@@ -58,12 +58,6 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
         provider.create
       end
     end
-
-    it "should use -V for the volsize property" do
-      resource[:volsize] = "10"
-      provider.expects(:zfs).with(:create, '-V', "10", name)
-      provider.create
-    end
   end
 
   context "#destroy" do

data/spec/unit/puppet_spec.rb

@@ -2,14 +2,13 @@
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
-require 'semver'
 
 describe Puppet do
   include PuppetSpec::Files
 
   context "#version" do
     it "should be valid semver" do
-      expect(SemVer).to be_valid Puppet.version
+      expect(SemanticPuppet::Version).to be_valid Puppet.version
     end
   end
 
@@ -49,7 +48,7 @@ describe Puppet do
     end
 
     it "should match a semver version" do
-      expect(SemVer).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
+      expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
     end
   end
 

data/spec/unit/relationship_spec.rb

@@ -151,74 +151,53 @@ describe Puppet::Relationship, " when matching edges with a non-standard event"
   end
 end
 
-describe Puppet::Relationship, "when converting to pson" do
+describe Puppet::Relationship, "when converting to json" do
   before do
-    @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
+    @edge = Puppet::Relationship.new('a', 'b', :event => :random, :callback => :whatever)
   end
 
   it "should store the stringified source as the source in the data" do
-    expect(PSON.parse(@edge.to_pson)["source"]).to eq("a")
+    expect(JSON.parse(@edge.to_json)["source"]).to eq("a")
   end
 
   it "should store the stringified target as the target in the data" do
-    expect(PSON.parse(@edge.to_pson)['target']).to eq("b")
+    expect(JSON.parse(@edge.to_json)['target']).to eq("b")
   end
 
-  it "should store the psonified event as the event in the data" do
-    expect(PSON.parse(@edge.to_pson)["event"]).to eq("random")
+  it "should store the jsonified event as the event in the data" do
+    expect(JSON.parse(@edge.to_json)["event"]).to eq("random")
   end
 
   it "should not store an event when none is set" do
     @edge.event = nil
-    expect(PSON.parse(@edge.to_pson)["event"]).to be_nil
+    expect(JSON.parse(@edge.to_json)).not_to include('event')
   end
 
-  it "should store the psonified callback as the callback in the data" do
+  it "should store the jsonified callback as the callback in the data" do
     @edge.callback = "whatever"
-    expect(PSON.parse(@edge.to_pson)["callback"]).to eq("whatever")
+    expect(JSON.parse(@edge.to_json)["callback"]).to eq("whatever")
   end
 
   it "should not store a callback when none is set in the edge" do
     @edge.callback = nil
-    expect(PSON.parse(@edge.to_pson)["callback"]).to be_nil
+    expect(JSON.parse(@edge.to_json)).not_to include('callback')
   end
 end
 
-describe Puppet::Relationship, "when converting from pson" do
-  before do
-    @event = "random"
-    @callback = "whatever"
-    @data = {
-      "source" => "mysource",
-      "target" => "mytarget",
-      "event" => @event,
-      "callback" => @callback
-    }
-    @pson = {
-      "type" => "Puppet::Relationship",
-      "data" => @data
-    }
-  end
-
-  def pson_result_should
-    Puppet::Relationship.expects(:new).with { |*args| yield args }
-  end
-
-  # LAK:NOTE For all of these tests, we convert back to the edge so we can
-  # trap the actual data structure then.
+describe Puppet::Relationship, "when converting from json" do
   it "should pass the source in as the first argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source).to eq("mysource")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source).to eq('mysource')
   end
 
   it "should pass the target in as the second argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target).to eq("mytarget")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target).to eq('mytarget')
   end
 
   it "should pass the event as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event).to eq("myevent")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event).to eq(:myevent)
   end
 
   it "should pass the callback as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback).to eq("mycallback")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback).to eq(:mycallback)
   end
 end

data/spec/unit/reports/http_spec.rb

@@ -5,7 +5,7 @@ require 'puppet/reports'
 processor = Puppet::Reports.report(:http)
 
 describe processor do
-  subject { Puppet::Transaction::Report.new("apply").extend(processor) }
+  subject { Puppet::Transaction::Report.new.extend(processor) }
 
   describe "when setting up the connection" do
     let(:http) { stub_everything "http" }
@@ -39,6 +39,7 @@ describe processor do
   describe "when making a request" do
     let(:connection) { stub_everything "connection" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+    let(:options) { {:metric_id => [:puppet, :report, :http]} }
 
     before :each do
       Puppet::Network::HttpPool.expects(:http_instance).returns(connection)
@@ -46,7 +47,7 @@ describe processor do
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      connection.expects(:post).with(report_path, anything, anything, {}).returns(httpok)
+      connection.expects(:post).with(report_path, anything, anything, options).returns(httpok)
 
       subject.process
     end
@@ -54,22 +55,24 @@ describe processor do
     it "should use the username and password specified by the 'reporturl' setting" do
       Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
 
-      connection.expects(:post).with(anything, anything, anything, :basic_auth => {
-        :user => 'user',
-        :password => 'pass'
-      }).returns(httpok)
+      connection.expects(:post).with(anything, anything, anything,
+                                     {:metric_id => [:puppet, :report, :http],
+                                      :basic_auth => {
+                                        :user => 'user',
+                                        :password => 'pass'
+                                      }}).returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      connection.expects(:post).with(anything, subject.to_yaml, anything, {}).returns(httpok)
+      connection.expects(:post).with(anything, subject.to_yaml, anything, options).returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), {}).returns(httpok)
+      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), options).returns(httpok)
 
       subject.process
     end

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
@@ -653,16 +658,6 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.apply(:ignoreschedules => true)
     end
 
-    it "should detect transaction failure and report it" do
-      @transaction.stubs(:evaluate).raises(RuntimeError, 'transaction failed.')
-      report = Puppet::Transaction::Report.new('apply')
-
-      expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
-      report.finalize_report
-
-      expect(report.status).to eq('failed')
-    end
-
     describe "host catalogs" do
 
       # super() doesn't work in the setup method for some reason
@@ -800,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
@@ -852,7 +847,7 @@ 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
@@ -872,7 +867,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
 
       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","value":"[a-z]+"}}')
+        expect(s).to include('"parameters":{"message":{"__pcore_type__":"Regexp","__pcore_value__":"[a-z]+"}}')
       end
 
       it 'should read and convert rich value hash containing Regexp from json' do
@@ -980,7 +975,7 @@ 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
@@ -1008,7 +1003,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
   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
@@ -1021,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]'
@@ -1054,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
 
@@ -1109,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