puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/spec/unit/network/format_handler_spec.rb

@@ -50,7 +50,7 @@ describe Puppet::Network::FormatHandler do
     end
   end
 
-  describe "#most_suitable_format_for" do
+  describe "#most_suitable_formats_for" do
     before :each do
       Puppet::Network::FormatHandler.create(:one, :extension => "foo", :mime => "text/one")
       Puppet::Network::FormatHandler.create(:two, :extension => "bar", :mime => "application/two")
@@ -60,35 +60,35 @@ describe Puppet::Network::FormatHandler do
     let(:format_two) { Puppet::Network::FormatHandler.format(:two) }
 
     def suitable_in_setup_formats(accepted)
-      Puppet::Network::FormatHandler.most_suitable_format_for(accepted, [:one, :two])
+      Puppet::Network::FormatHandler.most_suitable_formats_for(accepted, [:one, :two])
     end
 
     it "finds the most preferred format when anything is acceptable" do
-      expect(Puppet::Network::FormatHandler.most_suitable_format_for(["*/*"], [:two, :one])).to eq(format_two)
+      expect(Puppet::Network::FormatHandler.most_suitable_formats_for(["*/*"], [:two, :one])).to eq([format_two])
     end
 
     it "finds no format when none are acceptable" do
-      expect(suitable_in_setup_formats(["three"])).to be_nil
+      expect(suitable_in_setup_formats(["three"])).to eq([])
     end
 
-    it "skips unsupported, but accepted, formats" do
-      expect(suitable_in_setup_formats(["three", "two"])).to eq(format_two)
+    it "returns only the accepted and supported format" do
+      expect(suitable_in_setup_formats(["three", "two"])).to eq([format_two])
     end
 
-    it "gives the first acceptable and suitable format" do
-      expect(suitable_in_setup_formats(["three", "one", "two"])).to eq(format_one)
+    it "returns only accepted and supported formats, in order of accepted" do
+      expect(suitable_in_setup_formats(["three", "two", "one"])).to eq([format_two, format_one])
     end
 
     it "allows specifying acceptable formats by mime type" do
-      expect(suitable_in_setup_formats(["text/one"])).to eq(format_one)
+      expect(suitable_in_setup_formats(["text/one"])).to eq([format_one])
     end
 
     it "ignores quality specifiers" do
-      expect(suitable_in_setup_formats(["two;q=0.8", "text/one;q=0.9"])).to eq(format_two)
+      expect(suitable_in_setup_formats(["two;q=0.8", "text/one;q=0.9"])).to eq([format_two, format_one])
     end
 
     it "allows specifying acceptable formats by canonical name" do
-      expect(suitable_in_setup_formats([:one])).to eq(format_one)
+      expect(suitable_in_setup_formats([:one])).to eq([format_one])
     end
   end
 end

data/spec/unit/network/format_spec.rb

@@ -129,6 +129,15 @@ describe Puppet::Network::Format do
     it "should support overriding the extension" do
       expect(Puppet::Network::Format.new(:foo, :extension => "bar").extension).to eq("bar")
     end
+
+    it "doesn't support charset by default" do
+      expect(Puppet::Network::Format.new(:foo).charset).to be_nil
+    end
+
+    it "allows charset to be set to 'utf-8'" do
+      expect(Puppet::Network::Format.new(:foo, :charset => Encoding::UTF_8).charset).to eq(Encoding::UTF_8)
+    end
+
     [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
       it "should allow assignment of the #{method}" do
         expect(Puppet::Network::Format.new(:foo, method => :foo).send(method)).to eq(:foo)

data/spec/unit/network/formats_spec.rb

@@ -2,26 +2,36 @@
 require 'spec_helper'
 
 require 'puppet/network/formats'
+require 'puppet/network/format_support'
+
+class FormatsTest
+  include Puppet::Network::FormatSupport
 
-class PsonTest
   attr_accessor :string
   def ==(other)
     string == other.string
   end
 
   def self.from_data_hash(data)
-    new(data)
+    new(data['string'])
   end
 
   def initialize(string)
     @string = string
   end
 
-  def to_pson(*args)
+  def to_data_hash(*args)
     {
-      'type' => self.class.name,
-      'data' => @string
-    }.to_pson(*args)
+      'string' => @string
+    }
+  end
+
+  def to_binary
+    string
+  end
+
+  def self.from_binary(data)
+    self.new(data)
   end
 end
 
@@ -31,21 +41,23 @@ describe "Puppet Network Format" do
   end
 
   describe "msgpack", :if => Puppet.features.msgpack? do
-    before do
-      @msgpack = Puppet::Network::FormatHandler.format(:msgpack)
-    end
+    let(:msgpack) { Puppet::Network::FormatHandler.format(:msgpack) }
 
     it "should have its mime type set to application/x-msgpack" do
-      expect(@msgpack.mime).to eq("application/x-msgpack")
+      expect(msgpack.mime).to eq("application/x-msgpack")
+    end
+
+    it "should have a nil charset" do
+      expect(msgpack.charset).to be_nil
     end
 
     it "should have a weight of 20" do
-      expect(@msgpack.weight).to eq(20)
+      expect(msgpack.weight).to eq(20)
     end
 
     it "should fail when one element does not have a from_data_hash" do
       expect do
-        @msgpack.intern_multiple(Hash, MessagePack.pack(["foo"]))
+        msgpack.intern_multiple(Hash, MessagePack.pack(["foo"]))
       end.to raise_error(NoMethodError)
     end
 
@@ -74,240 +86,389 @@ describe "Puppet Network Format" do
   end
 
   describe "yaml" do
-    before do
-      @yaml = Puppet::Network::FormatHandler.format(:yaml)
-    end
+    let(:yaml) { Puppet::Network::FormatHandler.format(:yaml) }
 
     it "should have its mime type set to text/yaml" do
-      expect(@yaml.mime).to eq("text/yaml")
+      expect(yaml.mime).to eq("text/yaml")
+    end
+
+    # we shouldn't be using yaml on the network
+    it "should have a nil charset" do
+      expect(yaml.charset).to be_nil
     end
 
     it "should be supported on Strings" do
-      expect(@yaml).to be_supported(String)
+      expect(yaml).to be_supported(String)
     end
 
     it "should render by calling 'to_yaml' on the instance" do
       instance = mock 'instance'
       instance.expects(:to_yaml).returns "foo"
-      expect(@yaml.render(instance)).to eq("foo")
+      expect(yaml.render(instance)).to eq("foo")
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
       instances = [mock('instance')]
       instances.expects(:to_yaml).returns "foo"
-      expect(@yaml.render_multiple(instances)).to eq("foo")
+      expect(yaml.render_multiple(instances)).to eq("foo")
     end
 
     it "should deserialize YAML" do
-      expect(@yaml.intern(String, YAML.dump("foo"))).to eq("foo")
+      expect(yaml.intern(String, YAML.dump("foo"))).to eq("foo")
     end
 
     it "should deserialize symbols as strings" do
-      expect { @yaml.intern(String, YAML.dump(:foo))}.to raise_error(Puppet::Network::FormatHandler::FormatError)
+      expect { yaml.intern(String, YAML.dump(:foo))}.to raise_error(Puppet::Network::FormatHandler::FormatError)
+    end
+
+    it "should skip data_to_hash if data is already an instance of the specified class" do
+      # The rest terminus for the report indirected type relies on this behavior
+      data = YAML.dump([1, 2])
+      instance = yaml.intern(Array, data)
+      expect(instance).to eq([1, 2])
     end
 
     it "should load from yaml when deserializing an array" do
       text = YAML.dump(["foo"])
-      expect(@yaml.intern_multiple(String, text)).to eq(["foo"])
+      expect(yaml.intern_multiple(String, text)).to eq(["foo"])
     end
 
-    it "fails intelligibly instead of calling to_pson with something other than a hash" do
+    it "fails intelligibly instead of calling to_json with something other than a hash" do
       expect do
-        @yaml.intern(Puppet::Node, '')
+        yaml.intern(Puppet::Node, '')
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, /did not contain a valid instance/)
     end
 
     it "fails intelligibly when intern_multiple is called and yaml doesn't decode to an array" do
       expect do
-        @yaml.intern_multiple(Puppet::Node, '')
+        yaml.intern_multiple(Puppet::Node, '')
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, /did not contain a collection/)
     end
 
-    it "fails intelligibly instead of calling to_pson with something other than a hash when interning multiple" do
+    it "fails intelligibly instead of calling to_json with something other than a hash when interning multiple" do
       expect do
-        @yaml.intern_multiple(Puppet::Node, YAML.dump(["hello"]))
+        yaml.intern_multiple(Puppet::Node, YAML.dump(["hello"]))
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, /did not contain a valid instance/)
     end
   end
 
   describe "plaintext" do
-    before do
-      @text = Puppet::Network::FormatHandler.format(:s)
-    end
+    let(:text) { Puppet::Network::FormatHandler.format(:s) }
 
     it "should have its mimetype set to text/plain" do
-      expect(@text.mime).to eq("text/plain")
+      expect(text.mime).to eq("text/plain")
+    end
+
+    it "should use 'utf-8' charset" do
+      expect(text.charset).to eq(Encoding::UTF_8)
     end
 
     it "should use 'txt' as its extension" do
-      expect(@text.extension).to eq("txt")
+      expect(text.extension).to eq("txt")
     end
   end
 
   describe "dot" do
-    before do
-      @dot = Puppet::Network::FormatHandler.format(:dot)
-    end
+    let(:dot) { Puppet::Network::FormatHandler.format(:dot) }
 
     it "should have its mimetype set to text/dot" do
-      expect(@dot.mime).to eq("text/dot")
+      expect(dot.mime).to eq("text/dot")
     end
   end
 
   describe Puppet::Network::FormatHandler.format(:binary) do
-    before do
-      @format = Puppet::Network::FormatHandler.format(:binary)
-    end
+    let(:binary) { Puppet::Network::FormatHandler.format(:binary) }
 
     it "should exist" do
-      expect(@format).not_to be_nil
+      expect(binary).not_to be_nil
     end
 
     it "should have its mimetype set to application/octet-stream" do
-      expect(@format.mime).to eq("application/octet-stream")
+      expect(binary.mime).to eq("application/octet-stream")
     end
 
-    it "should always be supported" do
-      expect(@format).to be_supported(String)
+    it "should have a nil charset" do
+      expect(binary.charset).to be_nil
+    end
+
+    it "should not be supported by default" do
+      expect(binary).to_not be_supported(String)
+    end
+
+    it "should render an instance as binary" do
+      instance = FormatsTest.new("foo")
+      expect(binary.render(instance)).to eq("foo")
+    end
+
+    it "should intern an instance from a JSON hash" do
+      instance = binary.intern(FormatsTest, "foo")
+      expect(instance.string).to eq("foo")
     end
 
     it "should fail if its multiple_render method is used" do
-      expect { @format.render_multiple("foo") }.to raise_error(NotImplementedError)
+      expect {
+        binary.render_multiple("foo")
+      }.to raise_error(NotImplementedError, /can not render multiple instances to application\/octet-stream/)
     end
 
     it "should fail if its multiple_intern method is used" do
-      expect { @format.intern_multiple(String, "foo") }.to raise_error(NotImplementedError)
+      expect {
+        binary.intern_multiple(String, "foo")
+      }.to raise_error(NotImplementedError, /can not intern multiple instances from application\/octet-stream/)
     end
 
     it "should have a weight of 1" do
-      expect(@format.weight).to eq(1)
+      expect(binary.weight).to eq(1)
     end
   end
 
-  it "should include a pson format" do
-    expect(Puppet::Network::FormatHandler.format(:pson)).not_to be_nil
-  end
-
   describe "pson" do
-    before do
-      @pson = Puppet::Network::FormatHandler.format(:pson)
+    let(:pson) { Puppet::Network::FormatHandler.format(:pson) }
+
+    it "should include a pson format" do
+      expect(pson).not_to be_nil
     end
 
     it "should have its mime type set to text/pson" do
-      expect(Puppet::Network::FormatHandler.format(:pson).mime).to eq("text/pson")
+      expect(pson.mime).to eq("text/pson")
+    end
+
+    it "should have a nil charset" do
+      expect(pson.charset).to be_nil
     end
 
     it "should require the :render_method" do
-      expect(Puppet::Network::FormatHandler.format(:pson).required_methods).to be_include(:render_method)
+      expect(pson.required_methods).to be_include(:render_method)
     end
 
     it "should require the :intern_method" do
-      expect(Puppet::Network::FormatHandler.format(:pson).required_methods).to be_include(:intern_method)
+      expect(pson.required_methods).to be_include(:intern_method)
     end
 
     it "should have a weight of 10" do
-      expect(@pson.weight).to eq(10)
+      expect(pson.weight).to eq(10)
     end
 
-    describe "when supported" do
-      it "should render by calling 'to_pson' on the instance" do
-        instance = PsonTest.new("foo")
-        instance.expects(:to_pson).returns "foo"
-        expect(@pson.render(instance)).to eq("foo")
-      end
+    it "should render an instance as pson" do
+      instance = FormatsTest.new("foo")
+      expect(pson.render(instance)).to eq({"string" => "foo"}.to_pson)
+    end
 
-      it "should render multiple instances by calling 'to_pson' on the array" do
-        instances = [mock('instance')]
+    it "should render multiple instances as pson" do
+      instances = [FormatsTest.new("foo")]
+      expect(pson.render_multiple(instances)).to eq([{"string" => "foo"}].to_pson)
+    end
 
-        instances.expects(:to_pson).returns "foo"
+    it "should intern an instance from a pson hash" do
+      text = PSON.dump({"string" => "parsed_pson"})
+      instance = pson.intern(FormatsTest, text)
+      expect(instance.string).to eq("parsed_pson")
+    end
 
-        expect(@pson.render_multiple(instances)).to eq("foo")
-      end
+    it "should skip data_to_hash if data is already an instance of the specified class" do
+      # The rest terminus for the report indirected type relies on this behavior
+      data = PSON.dump([1, 2])
+      instance = pson.intern(Array, data)
+      expect(instance).to eq([1, 2])
+    end
 
-      it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the data into an instance" do
-        text = "foo"
-        PSON.expects(:parse).with("foo").returns("type" => "PsonTest", "data" => "foo")
-        PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
-        expect(@pson.intern(PsonTest, text)).to eq("parsed_pson")
-      end
+    it "should intern multiple instances from a pson array" do
+      text = PSON.dump(
+        [
+          {
+            "string" => "BAR"
+          },
+          {
+            "string" => "BAZ"
+          }
+        ]
+      )
+      expect(pson.intern_multiple(FormatsTest, text)).to eq([FormatsTest.new('BAR'), FormatsTest.new('BAZ')])
+    end
 
-      it "should not render twice if 'PSON.parse' creates the appropriate instance" do
-        text = "foo"
-        instance = PsonTest.new("foo")
-        PSON.expects(:parse).with("foo").returns(instance)
-        PsonTest.expects(:from_data_hash).never
-        expect(@pson.intern(PsonTest, text)).to equal(instance)
-      end
+    it "should unwrap the data from legacy clients" do
+      text = PSON.dump(
+        {
+          "type" => "FormatsTest",
+          "data" => {
+            "string" => "parsed_json"
+          }
+        }
+      )
+      instance = pson.intern(FormatsTest, text)
+      expect(instance.string).to eq("parsed_json")
+    end
 
-      it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the actual into an instance if the pson has no class/data separation" do
-        text = "foo"
-        PSON.expects(:parse).with("foo").returns("foo")
-        PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
-        expect(@pson.intern(PsonTest, text)).to eq("parsed_pson")
-      end
+    it "fails intelligibly when given invalid data" do
+      expect do
+        pson.intern(Puppet::Node, '')
+      end.to raise_error(PSON::ParserError, /source did not contain any PSON/)
+    end
+  end
 
-      it "should intern multiples by parsing the text and using 'class.intern' on each resulting data structure" do
-        text = "foo"
-        PSON.expects(:parse).with("foo").returns ["bar", "baz"]
-        PsonTest.expects(:from_data_hash).with("bar").returns "BAR"
-        PsonTest.expects(:from_data_hash).with("baz").returns "BAZ"
-        expect(@pson.intern_multiple(PsonTest, text)).to eq(%w{BAR BAZ})
-      end
+  describe "json" do
+    let(:json) { Puppet::Network::FormatHandler.format(:json) }
 
-      it "fails intelligibly when given invalid data" do
-        expect do
-          @pson.intern(Puppet::Node, '')
-        end.to raise_error(PSON::ParserError, /source did not contain any PSON/)
-      end
+    it "should include a json format" do
+      expect(json).not_to be_nil
+    end
+
+    it "should have its mime type set to application/json" do
+      expect(json.mime).to eq("application/json")
+    end
+
+    it "should use 'utf-8' charset" do
+      expect(json.charset).to eq(Encoding::UTF_8)
+    end
+
+    it "should require the :render_method" do
+      expect(json.required_methods).to be_include(:render_method)
+    end
+
+    it "should require the :intern_method" do
+      expect(json.required_methods).to be_include(:intern_method)
+    end
+
+    it "should have a weight of 15" do
+      expect(json.weight).to eq(15)
+    end
+
+    it "should use a native parser implementation" do
+      expect(JSON.parser.name).to eq("JSON::Ext::Parser")
+    end
+
+    it "should use a native generator implementation" do
+      expect(JSON.generator.name).to eq("JSON::Ext::Generator")
+    end
+
+    it "should render an instance as JSON" do
+      instance = FormatsTest.new("foo")
+      expect(json.render(instance)).to eq({"string" => "foo"}.to_json)
+    end
+
+    it "should render multiple instances as a JSON array of hashes" do
+      instances = [FormatsTest.new("foo")]
+      expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
+    end
+
+    it "should intern an instance from a JSON hash" do
+      text = JSON.dump({"string" => "parsed_json"})
+      instance = json.intern(FormatsTest, text)
+      expect(instance.string).to eq("parsed_json")
+    end
+
+    it "should skip data_to_hash if data is already an instance of the specified class" do
+      # The rest terminus for the report indirected type relies on this behavior
+      data = JSON.dump([1, 2])
+      instance = json.intern(Array, data)
+      expect(instance).to eq([1, 2])
+    end
+
+    it "should intern multiple instances from a JSON array of hashes" do
+      text = JSON.dump(
+        [
+          {
+            "string" => "BAR"
+          },
+          {
+            "string" => "BAZ"
+          }
+        ]
+      )
+      expect(json.intern_multiple(FormatsTest, text)).to eq([FormatsTest.new('BAR'), FormatsTest.new('BAZ')])
+    end
+
+    it "should reject wrapped data from legacy clients as they've never supported JSON" do
+      text = JSON.dump(
+        {
+          "type" => "FormatsTest",
+          "data" => {
+            "string" => "parsed_json"
+          }
+        }
+      )
+      instance = json.intern(FormatsTest, text)
+      expect(instance.string).to be_nil
+    end
+
+    it "fails intelligibly when given invalid data" do
+      expect do
+        json.intern(Puppet::Node, '')
+      end.to raise_error(JSON::ParserError, /A JSON text must at least contain two octets|unexpected token at ''/)
     end
   end
 
   describe ":console format" do
-    subject { Puppet::Network::FormatHandler.format(:console) }
-    it { is_expected.to be_an_instance_of Puppet::Network::Format }
-    let :json do Puppet::Network::FormatHandler.format(:pson) end
+    let(:console) { Puppet::Network::FormatHandler.format(:console) }
+
+    it "should include a console format" do
+      expect(console).to be_an_instance_of Puppet::Network::Format
+    end
 
     [:intern, :intern_multiple].each do |method|
       it "should not implement #{method}" do
-        expect { subject.send(method, String, 'blah') }.to raise_error NotImplementedError
+        expect { console.send(method, String, 'blah') }.to raise_error NotImplementedError
       end
     end
 
-    ["hello", 1, 1.0].each do |input|
-      it "should just return a #{input.inspect}" do
-        expect(subject.render(input)).to eq(input)
+    context "when rendering ruby types" do
+      ["hello", 1, 1.0].each do |input|
+        it "should just return a #{input.inspect}" do
+          expect(console.render(input)).to eq(input)
+        end
       end
-    end
 
-    [true, false, nil, Object.new].each do |input|
-      it "renders #{input.class} using PSON" do
-        expect(subject.render(input)).to eq(input.to_pson)
+      { true  => "true",
+        false => "false",
+        nil   => "null",
+      }.each_pair do |input, output|
+        it "renders #{input.class} as '#{output}'" do
+          expect(console.render(input)).to eq(output)
+        end
       end
-    end
 
-    [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
-      it "should render #{input.inspect} as one item per line" do
-        expect(subject.render(input)).to eq(input.collect { |item| item.to_s + "\n" }.join(''))
+      it "renders an Object as its quoted inspect value" do
+        obj = Object.new
+        expect(console.render(obj)).to eq("\"#{obj.inspect}\"")
       end
     end
 
-    it "should render empty hashes as empty strings" do
-      expect(subject.render({})).to eq('')
+    context "when rendering arrays" do
+      {
+        []                => "",
+        [1, 2]            => "1\n2\n",
+        ["one"]           => "one\n",
+        [{1 => 1}]        => "{1=>1}\n",
+        [[1, 2], [3, 4]]  => "[1, 2]\n[3, 4]\n"
+      }.each_pair do |input, output|
+        it "should render #{input.inspect} as one item per line" do
+          expect(console.render(input)).to eq(output)
+        end
+      end
     end
 
-    it "should render a non-trivially-keyed Hash as pretty printed PSON" do
-      hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-      expect(subject.render(hash)).to eq(PSON.pretty_generate(hash).chomp)
-    end
+    context "when rendering hashes" do
+      {
+        {}                                   => "",
+        {1 => 2}                             => "1  2\n",
+        {"one" => "two"}                     => "one  \"two\"\n", # odd that two is quoted but one isn't
+        {[1,2] => 3, [2,3] => 5, [3,4] => 7} => "{\n  \"[1, 2]\": 3,\n  \"[2, 3]\": 5,\n  \"[3, 4]\": 7\n}",
+        {{1 => 2} => {3 => 4}}               => "{\n  \"{1=>2}\": {\n    \"3\": 4\n  }\n}"
+      }.each_pair do |input, output|
+        it "should render #{input.inspect}" do
+          expect(console.render(input)).to eq(output)
+        end
+      end
 
-    it "should render a {String,Numeric}-keyed Hash into a table" do
-      object = Object.new
-      hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
-        5 => 5, 6.0 => 6 }
+      it "should render a {String,Numeric}-keyed Hash into a table" do
+        json = Puppet::Network::FormatHandler.format(:json)
+        object = Object.new
+        hash = { "one" => 1, "two" => [], "three" => {}, "four" => object, 5 => 5,
+                 6.0 => 6 }
 
-      # Gotta love ASCII-betical sort order.  Hope your objects are better
-      # structured for display than my test one is. --daniel 2011-04-18
-      expect(subject.render(hash)).to eq <<EOT
+        # Gotta love ASCII-betical sort order.  Hope your objects are better
+        # structured for display than my test one is. --daniel 2011-04-18
+        expect(console.render(hash)).to eq <<EOT
 5      5
 6.0    6
 four   #{json.render(object).chomp}
@@ -315,22 +476,45 @@ one    1
 three  {}
 two    []
 EOT
+      end
     end
 
-    it "should render a hash nicely with a multi-line value" do
-      pending "Moving to PSON rather than PP makes this unsupportable."
-      hash = {
-        "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
-        "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
+    context "when rendering face-related objects" do
+      it "pretty prints facts" do
+        tm = Time.new("2016-01-27T19:30:00")
+        values = {
+          "architecture" =>  "x86_64",
+          "os" => {
+            "release" => {
+              "full" => "15.6.0"
+            }
+          },
+          "system_uptime" => {
+            "seconds" => 505532
+          }
+        }
+        facts = Puppet::Node::Facts.new("foo", values)
+        facts.timestamp = tm
+
+        # For some reason, render omits the last newline, seems like a bug
+        expect(console.render(facts)).to eq(<<EOT.chomp)
+{
+  "name": "foo",
+  "values": {
+    "architecture": "x86_64",
+    "os": {
+      "release": {
+        "full": "15.6.0"
       }
-      expect(subject.render(hash)).to eq <<EOT
-number  {"1"=>"1111111111111111111111111111111111111111",
-         "2"=>"2222222222222222222222222222222222222222",
-         "3"=>"3333333333333333333333333333333333333333"}
-text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-         "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-         "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
+    },
+    "system_uptime": {
+      "seconds": 505532
+    }
+  },
+  "timestamp": "#{tm.iso8601(9)}"
+}
 EOT
+      end
     end
   end
 end