puppet 6.0.0 → 6.1.0

data/spec/unit/file_serving/fileset_spec.rb

@@ -147,12 +147,12 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      Dir.stubs(:entries).with(path).returns(top_names)
+      Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
         Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
-        Dir.stubs(:entries).with(subpath).returns(sub_names)
+        Dir.stubs(:entries).with(subpath, encoding: Encoding::UTF_8).returns(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
@@ -173,7 +173,7 @@ describe Puppet::FileServing::Fileset do
         extend Mocha::API
         path = File.join(base_path, name)
         Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
-        Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
+        Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(['.', '..'] + entries.map(&:name))
         entries.each do |entry|
           entry.mock(path)
         end
@@ -295,7 +295,7 @@ describe Puppet::FileServing::Fileset do
     link_path = File.join(path, "mylink")
     Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
-    Dir.stubs(:entries).with(path).returns(["mylink"])
+    Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -319,9 +319,9 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one uno})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two dos})
-      Dir.expects(:entries).with(make_absolute("/third/path")).returns(%w{three tres})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one uno})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two dos})
+      Dir.expects(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).returns(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -335,15 +335,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end

data/spec/unit/functions/logging_spec.rb

@@ -18,9 +18,16 @@ describe 'the log function' do
 
   def expect_log(code, log_level, message)
     logs = collect_logs(code)
-    expect(logs.size).to eql(1)
-    expect(logs[0].level).to eql(log_level)
-    expect(logs[0].message).to eql(message)
+
+    # There's a chance that additional messages could have been
+    # added during code compilation like debug messages from
+    # Facter. This happened on Appveyor when the Appveyor image
+    # failed to resolve the domain fact. Since these messages are
+    # not relevant to our test, and since they can (possibly) be
+    # injected at any location in our logs array, it is good enough
+    # to assert that our desired log _is_ included in the logs array
+    # instead of trying to figure out _where_ it is included.
+    expect(logs).to include(satisfy { |log| log.level == log_level && log.message == message })
   end
 
   before(:each) do

data/spec/unit/indirector/catalog/json_spec.rb

@@ -17,8 +17,9 @@ describe Puppet::Resource::Catalog::Json do
     let(:binary) { "\xC0\xFF".force_encoding(Encoding::BINARY) }
     let(:key)    { 'foo' }
     let(:file)   { subject.path(key) }
+    let(:env)    { Puppet::Node::Environment.create(:testing, []) }
     let(:catalog) do
-      catalog = Puppet::Resource::Catalog.new(key, Puppet::Node::Environment.create(:testing, []))
+      catalog = Puppet::Resource::Catalog.new(key, env)
       catalog.add_resource(Puppet::Resource.new(:file, '/tmp/a_file', :parameters => { :content => binary }))
       catalog
     end
@@ -27,6 +28,11 @@ describe Puppet::Resource::Catalog::Json do
       Puppet.run_mode.stubs(:master?).returns(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+    end
+
+    after :each do
+      Puppet.pop_context()
     end
 
     it 'saves a catalog containing binary content' do
@@ -43,7 +49,7 @@ describe Puppet::Resource::Catalog::Json do
       parsed_catalog = subject.find(request)
 
       content = parsed_catalog.resource(:file, '/tmp/a_file')[:content]
-      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+      expect(content.binary_buffer.bytes.to_a).to eq(binary.bytes.to_a)
     end
 
     it 'searches for catalogs contains binary content' do
@@ -55,7 +61,7 @@ describe Puppet::Resource::Catalog::Json do
 
       expect(parsed_catalogs.size).to eq(1)
       content = parsed_catalogs.first.resource(:file, '/tmp/a_file')[:content]
-      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+      expect(content.binary_buffer.bytes.to_a).to eq(binary.bytes.to_a)
     end
   end
 end

data/spec/unit/indirector/yaml_spec.rb

@@ -141,7 +141,7 @@ describe Puppet::Indirector::Yaml do
       dir_containing_instances([one, two])
 
       request = indirection.request(:search, "*", nil)
-      expect(terminus.search(request)).to eq([one, two])
+      expect(terminus.search(request)).to contain_exactly(one, two)
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do

data/spec/unit/network/http/connection_spec.rb

@@ -97,7 +97,7 @@ describe Puppet::Network::HTTP::Connection do
       :verify => ConstantErrorValidator.new(
         :fails_with => 'hostname was not match with server certificate',
         :peer_certs => [Puppet::TestCa.new.generate('not_my_server',
-                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server').content]))
+                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server')[:cert]]))
 
       expect do
         connection.get('request')
@@ -120,7 +120,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should check all peer certificates for upcoming expiration", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
       Puppet[:confdir] = tmpdir('conf')
       cert = Puppet::TestCa.new.generate('server',
-                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')
+                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')[:cert]
 
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -1385,6 +1385,24 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq('dGhlIHF1aWNrIHJlZCBmb3g=')
     end
 
+    it "parses pp syntax checked specification" do
+      src = <<-CODE
+      @(END:pp)
+        $x = 42
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('$x = 42')
+    end
+
+    it "parses epp syntax checked specification" do
+      src = <<-CODE
+      @(END:epp)
+        <% $x = 42 %><%= $x %>
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('<% $x = 42 %><%= $x %>')
+    end
+
     it "parses json syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
@@ -1403,6 +1421,24 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid Base64 string/)
     end
 
+    it "parses pp syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:pp)
+        $x ==== 42
+        |- END
+      CODE
+      expect{parser.evaluate_string(scope, src)}.to raise_error(/Invalid produced text having syntax: 'pp'/)
+    end
+
+    it "parses epp syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:epp)
+        <% $x ==== 42 %>
+        |- END
+      CODE
+      expect{parser.evaluate_string(scope, src)}.to raise_error(/Invalid produced text having syntax: 'epp'/)
+    end
+
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $pname = 'Fjodor'

data/spec/unit/pops/evaluator/runtime3_converter_spec.rb

@@ -30,22 +30,40 @@ describe 'when converting to 3.x' do
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
-  it 'converts the symbol :undef to the undef value' do
+  it 'converts top level symbol :undef to the given undef value' do
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'converts the nil to the undef value' do
+  it 'converts top level nil value to the given undef value' do
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'convert a symbol nested in an array' do
-    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => 'undef value'})
+  it 'converts nested :undef in a hash to nil' do
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => nil})
+  end
+
+  it 'converts nested :undef in an array to nil' do
+    expect(converter.convert(['boo', :undef], {}, 'undef value')).to eql(['boo', nil])
+  end
+
+  it 'converts deeply nested :undef in to nil' do
+    expect(converter.convert({'foo' => [[:undef]], 'bar' => { 'x' => :undef }}, {}, 'undef value')).to eql({'foo' => [[nil]], 'bar' => { 'x' => nil}})
   end
 
   it 'does not converts nil to given undef value when nested in an array' do
     expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => nil})
   end
 
+  it 'does not convert top level symbols' do
+    expect(converter.convert(:default, {}, 'undef value')).to eql(:default)
+    expect(converter.convert(:whatever, {}, 'undef value')).to eql(:whatever)
+  end
+
+  it 'does not convert nested symbols' do
+    expect(converter.convert([:default], {}, 'undef value')).to eql([:default])
+    expect(converter.convert([:whatever], {}, 'undef value')).to eql([:whatever])
+  end
+
   it 'does not convert a Regex instance to string' do
     v = /^[A-Z]$/
     expect(converter.convert(v, {}, nil)).to equal(v)

data/spec/unit/pops/loaders/loader_spec.rb

@@ -329,13 +329,6 @@ describe 'The Loader' do
               'bad_syntax.json' => <<-TXT.unindent,
                 text => This is not a task because JSON is unparsable
                 TXT
-              'bad_content.sh' => '',
-              'bad_content.json' => <<-JSON.unindent,
-                {
-                  "description": "This is not a task because parameters is misspelled",
-                  "paramters": { "string_param": { "type": "String[1]" } }
-                }
-                JSON
               'missing_adjacent.json' => <<-JSON.unindent,
                 {
                   "description": "This is not a task because there is no adjacent file with the same base name",
@@ -415,7 +408,7 @@ describe 'The Loader' do
                   contain_exactly(tn(:task, 'c::foo')))
               end
               expect(logs.select { |log| log.level == :warning }.map { |log| log.message }).to(
-                contain_exactly(/unexpected token/, /unrecognized key/, /No source besides task metadata was found/)
+                contain_exactly(/unexpected token/, /No source besides task metadata was found/)
               )
             end
 
@@ -427,11 +420,11 @@ describe 'The Loader' do
                   contain_exactly(tn(:task, 'c::foo')))
               end
               expect(logs.select { |log| log.level == :warning }.map { |log| log.message }).to be_empty
-              expect(error_collector.size).to eql(3)
+              expect(error_collector.size).to eql(2)
               expect(error_collector.all? { |e| e.is_a?(Puppet::DataTypes::Error) })
               expect(error_collector.all? { |e| e.issue_code == Puppet::Pops::Issues::LOADER_FAILURE.issue_code })
               expect(error_collector.map { |e| e.details['original_error'] }).to(
-                contain_exactly(/unexpected token/, /unrecognized key/, /No source besides task metadata was found/)
+                contain_exactly(/unexpected token/, /No source besides task metadata was found/)
               )
             end
 
@@ -454,8 +447,7 @@ describe 'The Loader' do
           end
 
           context 'with no explicit dependencies' do
-
-            let(:modules) {
+            let(:modules) do
               {
                 'a' => {
                   'functions' => a_functions,
@@ -475,12 +467,12 @@ describe 'The Loader' do
                   'types' => c_types,
                 },
               }
+            end
 
-              it 'discover is only called once on dependent loader' do
-                ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
-                expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
-              end
-            }
+            it 'discover is only called once on dependent loader' do
+              ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
+              expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
+            end
           end
         end
       end

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -420,6 +420,54 @@ describe 'loaders' do
       function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
     end
+
+  end
+
+  context 'when causing a 3x load followed by a 4x load' do
+    let(:env) { environment_for(mix_4x_and_3x_functions) }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:scope) { compiler.topscope }
+    let(:loader) { compiler.loaders.private_loader_for_module('user') }
+
+    before(:each) do
+      Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
+    end
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    it "a 3x function with code outside body is reported as an error" do
+      expect { loader.load_typed(typed_name(:function, 'bad_func_load')) }.to raise_error(/Illegal legacy function definition/)
+    end
+  end
+
+  context 'when causing a 3x load followed by a 4x load' do
+    let(:env) { environment_for(mix_4x_and_3x_functions) }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:scope) { compiler.topscope }
+    let(:loader) { compiler.loaders.private_loader_for_module('user') }
+
+
+    before(:each) do
+      Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
+    end
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    it 'a 3x function is loaded once' do
+      # create a 3x function that when called will do a load of "callee_ws"
+      Puppet::Parser::Functions::newfunction(:callee, :type => :rvalue, :arity => 1) do |args|
+        function_callee_ws(['passed in scope'])
+      end
+      Puppet.expects(:warning).with(any_parameters).never
+      scope['passed_in_scope'] = 'value'
+      function = loader.load_typed(typed_name(:function, 'callee')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+
+      function = loader.load_typed(typed_name(:function, 'callee_ws')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+    end
   end
 
   context 'loading' do

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -104,8 +104,8 @@ describe 'FileBased module loader' do
 
       task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
       expect(task.name).to eq('testmodule::foo')
-      expect(task.implementations.length).to eq(1)
-      expect(task.implementations[0]['name']).to eq('foo.py')
+      expect(task.files.length).to eq(1)
+      expect(task.files[0]['name']).to eq('foo.py')
     end
 
     it 'can load tasks with multiple implementations' do
@@ -116,7 +116,7 @@ describe 'FileBased module loader' do
 
       task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
       expect(task.name).to eq('testmodule::foo')
-      expect(task.implementations.map {|impl| impl['name']}).to eq(['foo.py', 'foo.ps1'])
+      expect(task.files.map {|impl| impl['name']}).to eq(['foo.py', 'foo.ps1'])
     end
 
     it 'can load multiple tasks with multiple files' do
@@ -128,11 +128,11 @@ describe 'FileBased module loader' do
       foobar_task = module_loader.load_typed(typed_name(:task, 'testmodule::foobar')).value
 
       expect(foo_task.name).to eq('testmodule::foo')
-      expect(foo_task.implementations.length).to eq(1)
-      expect(foo_task.implementations[0]['name']).to eq('foo.py')
+      expect(foo_task.files.length).to eq(1)
+      expect(foo_task.files[0]['name']).to eq('foo.py')
       expect(foobar_task.name).to eq('testmodule::foobar')
-      expect(foobar_task.implementations.length).to eq(1)
-      expect(foobar_task.implementations[0]['name']).to eq('foobar.py')
+      expect(foobar_task.files.length).to eq(1)
+      expect(foobar_task.files[0]['name']).to eq('foobar.py')
     end
 
     it "won't load tasks with invalid names" do

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -140,6 +140,22 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it "parses interpolated [] expression by looking at the correct preceding char for space" do
+    # NOTE: Important not to use the left margin feature here
+    src = <<-CODE
+$xxxxxxx = @("END")
+${facts['os']['family']}
+XXXXXXX XXX
+END
+CODE
+    expect(dump(parse(src))).to eq([
+      "(= $xxxxxxx (@()",
+      "  (sublocated (cat (str (slice (slice $facts 'os') 'family')) '",
+      "XXXXXXX XXX",
+      "'))",
+      "))"].join("\n"))
+  end
+
   it 'parses multiple heredocs on the same line' do
     src = <<-CODE
     notice({ @(foo) => @(bar) })

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -153,6 +153,15 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'ACII_8BIT String as Binary' do
+      val = Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      strval = val.binary_buffer
+      write(strval)
+      val2 = read
+      expect(val2).to be_a(Types::PBinaryType::Binary)
+      expect(val2).to eql(val)
+    end
+
     it 'URI' do
       val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
       write(val)

data/spec/unit/pops/types/p_timespan_type_spec.rb

@@ -68,6 +68,28 @@ describe 'Timespan type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
+
+      it 'accepts integer values when specifying the range' do
+        code = <<-CODE
+            notice(Timespan(1) =~ Timespan[1, 2])
+            notice(Timespan(3) =~ Timespan[1])
+            notice(Timespan(0) =~ Timespan[default, 2])
+            notice(Timespan(0) =~ Timespan[1, 2])
+            notice(Timespan(3) =~ Timespan[1, 2])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
+      end
+
+      it 'accepts float values when specifying the range' do
+        code = <<-CODE
+            notice(Timespan(1.0) =~ Timespan[1.0, 2.0])
+            notice(Timespan(3.0) =~ Timespan[1.0])
+            notice(Timespan(0.0) =~ Timespan[default, 2.0])
+            notice(Timespan(0.0) =~ Timespan[1.0, 2.0])
+            notice(Timespan(3.0) =~ Timespan[1.0, 2.0])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
+      end
     end
 
     context 'a Timespan instance' do

data/spec/unit/pops/types/p_timestamp_type_spec.rb

@@ -74,6 +74,25 @@ describe 'Timestamp type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
+
+      it 'accepts integer values when specifying the range' do
+        code = <<-CODE
+            notice(Timestamp(1) =~ Timestamp[1, 2])
+            notice(Timestamp(3) =~ Timestamp[1])
+            notice(Timestamp(0) =~ Timestamp[default, 2])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
+      it 'accepts float values when specifying the range' do
+        code = <<-CODE
+            notice(Timestamp(1.0) =~ Timestamp[1.0, 2.0])
+            notice(Timestamp(3.0) =~ Timestamp[1.0])
+            notice(Timestamp(0.0) =~ Timestamp[default, 2.0])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
     end
 
     context 'a Timestamp instance' do

data/spec/unit/pops/types/string_converter_spec.rb

@@ -128,10 +128,14 @@ describe 'The string converter' do
          expect(converter.convert("hello\tworld.\r\nSun is brigth today.", string_formats)).to eq('"hello\\tworld.\\r\\nSun is brigth today."')
       end
 
-      it 'singe quoted result for string that is plain ascii without \\, $ or control characters' do
+      it 'single quoted result for string that is plain ascii without \\, $ or control characters' do
         expect(converter.convert('hello world', string_formats)).to eq("'hello world'")
       end
 
+      it 'double quoted result when using %#p if it would otherwise be single quoted' do
+        expect(converter.convert('hello world', '%#p')).to eq('"hello world"')
+      end
+
       it 'quoted 5-byte unicode chars' do
         expect(converter.convert("smile \u{1f603}.", string_formats)).to eq("'smile \u{1F603}.'")
       end
@@ -707,6 +711,15 @@ describe 'The string converter' do
      expect(formatted).to eq(result)
     end
 
+    it 'applies a short form format' do
+      result = [
+        "[1,",
+        "  [2, 3],",
+        "  4]"
+        ].join("\n")
+      expect(converter.convert([1, [2,3], 4], '%#a')).to eq(result)
+    end
+
     it 'treats hashes as nested arrays wrt indentation' do
       string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
@@ -855,6 +868,17 @@ describe 'The string converter' do
       expect(converter.convert({1 => "hello", 2 => {3=> "world"}}, string_formats)).to eq(result)
     end
 
+    it 'applies a short form format' do
+      result = [
+        "{",
+        "  1 => {",
+        "    2 => 3",
+        "  },",
+        "  4 => 5",
+        "}"].join("\n")
+      expect(converter.convert({1 => {2 => 3}, 4 => 5}, '%#h')).to eq(result)
+    end
+
     context "containing an array" do
       it 'the hash and array renders without breaks and indentation by default' do
         result = "{1 => [1, 2, 3]}"