puppet 4.10.12 → 5.0.0

data/spec/unit/pops/time/timestamp_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+  module Time
+    describe 'Timestamp' do
+      it 'Does not loose microsecond precision when converted to/from String' do
+        ts = Timestamp.new(1495789430910161286)
+        expect(Timestamp.parse(ts.to_s)).to eql(ts)
+      end
+    end
+  end
+end

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

@@ -60,7 +60,6 @@ describe 'The iterable support' do
       PBooleanType::DEFAULT,
       PCallableType::DEFAULT,
       PCatalogEntryType::DEFAULT,
-      PDataType::DEFAULT,
       PDefaultType::DEFAULT,
       PFloatType::DEFAULT,
       PHostClassType::DEFAULT,
@@ -72,6 +71,7 @@ describe 'The iterable support' do
       PResourceType::DEFAULT,
       PRuntimeType::DEFAULT,
       PScalarType::DEFAULT,
+      PScalarDataType::DEFAULT,
       PType::DEFAULT,
       PUndefType::DEFAULT
     ]

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

@@ -19,7 +19,7 @@ describe 'The Object Type' do
   end
 
   def type_object_t(name, body_string)
-    object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").current.body)
+    object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").body)
     loader.set_entry(Loader::TypedName.new(:type, name), object)
     object
   end
@@ -67,7 +67,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /expects a match for Enum\['constant', 'derived', 'given_or_derived'\], got 'derivd'/)
+        /expects a match for Enum\['constant', 'derived', 'given_or_derived', 'reference'\], got 'derivd'/)
     end
 
     it 'stores value in attribute' do
@@ -101,6 +101,17 @@ describe 'The Object Type' do
       expect(attr.value?).to be_falsey
     end
 
+    it 'attribute without defined value but optional type responds true to value?' do
+      tp = parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => Optional[Integer]
+        }
+      OBJECT
+      attr = tp['a']
+      expect(attr.value?).to be_truthy
+      expect(attr.value).to be_nil
+    end
+
     it 'raises an error when value is requested from an attribute that has no value' do
       tp = parse_object('MyObject', <<-OBJECT)
         attributes => {
@@ -700,7 +711,7 @@ describe 'The Object Type' do
         },
         equality => [b]
       OBJECT
-      obj2 = PObjectType.new(obj.i12n_hash)
+      obj2 = PObjectType.new(obj._pcore_init_hash)
       expect(obj).to eql(obj2)
     end
   end
@@ -712,7 +723,7 @@ describe 'The Object Type' do
       type Spec::MySecondObject = Object[{parent => Spec::MyObject, attributes => { b => String }}]
       notice(Spec::MySecondObject(42, 'Meaning of life'))
       CODE
-      expect(eval_and_collect_notices(code)).to eql(["Spec::MySecondObject({\n  'a' => 42,\n  'b' => 'Meaning of life'\n})"])
+      expect(eval_and_collect_notices(code)).to eql(["Spec::MySecondObject({'a' => 42, 'b' => 'Meaning of life'})"])
     end
   end
 
@@ -771,6 +782,34 @@ describe 'The Object Type' do
       expect(eval_and_collect_notices(code)).to eql(['true'])
     end
 
+    it 'declared Object type is assignable to default Object type' do
+      code = <<-CODE
+      type MyObject = Object[{ attributes => { a => Integer }}]
+      notice(MyObject < Object)
+      notice(MyObject <= Object)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true'])
+    end
+
+    it 'default Object type not is assignable to declared Object type' do
+      code = <<-CODE
+      type MyObject = Object[{ attributes => { a => Integer }}]
+      notice(Object < MyObject)
+      notice(Object <= MyObject)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['false', 'false'])
+    end
+
+    it 'default Object type is assignable to itself' do
+      code = <<-CODE
+      notice(Object < Object)
+      notice(Object <= Object)
+      notice(Object > Object)
+      notice(Object >= Object)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['false', 'true', 'false', 'true'])
+    end
+
     it 'an object type is an instance of an object type type' do
       code = <<-CODE
       type MyObject = Object[{ attributes => { a => Integer }}]
@@ -1125,7 +1164,7 @@ describe 'The Object Type' do
     include_context 'types_setup'
 
     def find_parent(tc, parent_name)
-      p = tc._ptype
+      p = tc._pcore_type
       while p.is_a?(PObjectType) && p.name != parent_name
         p = p.parent
       end
@@ -1133,35 +1172,82 @@ describe 'The Object Type' do
       p
     end
 
-    it 'the class has a _ptype method' do
+    it 'the class has a _pcore_type method' do
       all_types.each do |tc|
-        expect(tc).to respond_to(:_ptype).with(0).arguments
+        expect(tc).to respond_to(:_pcore_type).with(0).arguments
       end
     end
 
-    it 'the _ptype method returns a PObjectType instance' do
+    it 'the _pcore_type method returns a PObjectType instance' do
       all_types.each do |tc|
-        expect(tc._ptype).to be_a(PObjectType)
+        expect(tc._pcore_type).to be_a(PObjectType)
       end
     end
 
-    it 'the instance returned by _ptype is a descendant from Pcore::AnyType' do
+    it 'the instance returned by _pcore_type is a descendant from Pcore::AnyType' do
       all_types.each { |tc| expect(find_parent(tc, 'Pcore::AnyType').name).to eq('Pcore::AnyType') }
     end
 
-    it 'PScalarType classes _ptype returns a descendant from Pcore::ScalarType' do
+    it 'PScalarType classes _pcore_type returns a descendant from Pcore::ScalarType' do
       scalar_types.each { |tc| expect(find_parent(tc, 'Pcore::ScalarType').name).to eq('Pcore::ScalarType') }
     end
 
-    it 'PNumericType classes _ptype returns a descendant from Pcore::NumberType' do
+    it 'PNumericType classes _pcore_type returns a descendant from Pcore::NumberType' do
       numeric_types.each { |tc| expect(find_parent(tc, 'Pcore::NumericType').name).to eq('Pcore::NumericType') }
     end
 
-    it 'PCollectionType classes _ptype returns a descendant from Pcore::CollectionType' do
+    it 'PCollectionType classes _pcore_type returns a descendant from Pcore::CollectionType' do
       coll_descendants = collection_types - [PTupleType, PStructType]
       coll_descendants.each { |tc| expect(find_parent(tc, 'Pcore::CollectionType').name).to eq('Pcore::CollectionType') }
     end
   end
+
+  context 'when dealing with annotations' do
+    let(:annotation) { <<-PUPPET }
+      type MyAdapter = Object[{
+        parent => Annotation,
+        attributes => {
+          id => Integer,
+          value => String[1]
+        }
+      }]
+    PUPPET
+
+    it 'the Annotation type can be used as parent' do
+      code = <<-PUPPET
+        #{annotation}
+        notice(MyAdapter < Annotation)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['true'])
+    end
+
+    it 'an annotation can be added to an Object type' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+          annotations => {
+            MyAdapter => { 'id' => 2, 'value' => 'annotation value' }
+          }
+        }]
+        notice(MyObject)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql([
+        "Object[{annotations => {MyAdapter => {'id' => 2, 'value' => 'annotation value'}}, name => 'MyObject'}]"])
+    end
+
+    it 'other types can not be used as annotations' do
+      code = <<-PUPPET
+        type NotAnAnnotation = Object[{}]
+        type MyObject = Object[{
+          annotations => {
+            NotAnAnnotation => {}
+          }
+        }]
+        notice(MyObject)
+      PUPPET
+      expect{eval_and_collect_notices(code)}.to raise_error(/entry 'annotations' expects a value of type Undef or Hash/)
+    end
+  end
 end
 end
 end

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

@@ -57,7 +57,7 @@ describe 'Timestamp type' do
             notice($o)
             notice(type($o))
         CODE
-        expect(eval_and_collect_notices(code)).to eq(['2015-03-01T00:00:00.000 UTC', "Timestamp['2015-03-01T00:00:00.000 UTC']"])
+        expect(eval_and_collect_notices(code)).to eq(['2015-03-01T00:00:00.000000000 UTC', "Timestamp['2015-03-01T00:00:00.000000000 UTC']"])
       end
 
       it 'can be created from a string and format' do
@@ -65,7 +65,7 @@ describe 'Timestamp type' do
             $o = Timestamp('Sunday, 28 August, 2016', '%A, %d %B, %Y')
             notice($o)
         CODE
-        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T00:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T00:00:00.000000000 UTC'])
       end
 
       it 'can be created from a string, format, and a timezone' do
@@ -73,7 +73,7 @@ describe 'Timestamp type' do
             $o = Timestamp('Sunday, 28 August, 2016', '%A, %d %B, %Y', 'EST')
             notice($o)
         CODE
-        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T05:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T05:00:00.000000000 UTC'])
       end
 
       it 'can be not be created from a string, format with timezone designator, and a timezone' do
@@ -90,7 +90,7 @@ describe 'Timestamp type' do
             $o = Timestamp({ string => 'Sunday, 28 August, 2016', format => '%A, %d %B, %Y' })
             notice($o)
         CODE
-        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T00:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T00:00:00.000000000 UTC'])
       end
 
       it 'can be created from a hash with string, format, and a timezone' do
@@ -98,7 +98,7 @@ describe 'Timestamp type' do
             $o = Timestamp({ string => 'Sunday, 28 August, 2016', format => '%A, %d %B, %Y', timezone => 'EST' })
             notice($o)
         CODE
-        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T05:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eq(['2016-08-28T05:00:00.000000000 UTC'])
       end
 
       it 'can be created from a string and array of formats' do
@@ -113,7 +113,7 @@ describe 'Timestamp type' do
             notice(Timestamp('16-06-21 18:23:15 UTC', $fmts))
         CODE
         expect(eval_and_collect_notices(code)).to eq(
-          ['2016-08-28T12:15:00.000 UTC', '2016-07-24T01:20:00.000 UTC', '2016-06-21T18:23:15.000 UTC'])
+          ['2016-08-28T12:15:00.000000000 UTC', '2016-07-24T01:20:00.000000000 UTC', '2016-06-21T18:23:15.000000000 UTC'])
       end
 
       it 'can be created from a string, array of formats, and a timezone' do
@@ -128,7 +128,7 @@ describe 'Timestamp type' do
             notice(Timestamp('16-06-21 18:23:15', $fmts, 'CET'))
         CODE
         expect(eval_and_collect_notices(code)).to eq(
-          ['2016-08-28T11:15:00.000 UTC', '2016-07-24T00:20:00.000 UTC', '2016-06-21T17:23:15.000 UTC'])
+          ['2016-08-28T11:15:00.000000000 UTC', '2016-07-24T00:20:00.000000000 UTC', '2016-06-21T17:23:15.000000000 UTC'])
       end
 
       it 'can be created from a integer that represents seconds since epoch' do
@@ -154,7 +154,7 @@ describe 'Timestamp type' do
             $o = Timestamp('2015-05-01')
             notice(assert_type(Timestamp['2015-03-01', '2015-09-30'], $o))
          CODE
-        expect(eval_and_collect_notices(code)).to eq(['2015-05-01T00:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eq(['2015-05-01T00:00:00.000000000 UTC'])
       end
 
       it 'does not match an inappropriate parameterized type' do

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

@@ -14,7 +14,7 @@ module Puppet::Pops
       let(:loader) { loaders.find_loader(nil) }
 
       def type_set_t(name, body_string, name_authority)
-        i12n_literal_hash = pp_parser.parse_string("{#{body_string}}").current.body
+        i12n_literal_hash = pp_parser.parse_string("{#{body_string}}").body
         typeset = PTypeSetType.new(name, i12n_literal_hash, name_authority)
         loader.set_entry(Loader::TypedName.new(:type, name, name_authority), typeset)
         typeset
@@ -110,14 +110,6 @@ module Puppet::Pops
               /expects a value for key 'pcore_version'/)
           end
 
-          it 'version is missing' do
-            ts = <<-OBJECT
-            pcore_version => '1.0.0',
-            OBJECT
-            expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /expects a value for key 'version'/)
-          end
-
           it 'the version is an invalid semantic version' do
             ts = <<-OBJECT
             version => '1.x',

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

@@ -22,7 +22,32 @@ describe 'Puppet Ruby Generator' do
           attributes => {
             name => String,
             age  => { type => Integer, value => 30 },
-            what => { type => String, value => 'what is this', kind => constant }
+            what => { type => String, value => 'what is this', kind => constant },
+            uc_name => {
+              type => String,
+              kind => derived,
+              annotations => {
+                RubyMethod => { body => '@name.upcase' }
+              }
+            },
+            other_name => {
+              type => String,
+              kind => derived
+            }
+          },
+          functions => {
+            some_other => {
+              type => Callable[1,1]
+            },
+            name_and_age => {
+              type => Callable[1,1],
+              annotations => {
+                RubyMethod => {
+                  parameters => 'joiner',
+                  body => '"\#{@name}\#{joiner}\#{@age}"'
+                }
+              }
+            },
           }
         }]
         type MyModule::SecondGenerated = Object[{
@@ -32,7 +57,8 @@ describe 'Puppet Ruby Generator' do
             zipcode => String,
             email => String,
             another => { type => Optional[MyModule::FirstGenerated], value => undef },
-            number => Integer
+            number => Integer,
+            aref => { type => Optional[MyModule::FirstGenerated], value => undef, kind => reference }
           }
         }]
       CODE
@@ -103,6 +129,21 @@ describe 'Puppet Ruby Generator' do
           expect(inst.age).to eql(30)
           expect(inst.another).to be_nil
         end
+
+        it 'generates a code body for derived attribute from a RubyMethod body attribute' do
+          inst = first.create('Bob Builder', 52)
+          expect(inst.uc_name).to eq('BOB BUILDER')
+        end
+
+        it "generates a code body with 'not implemented' in the absense of a RubyMethod body attribute" do
+          inst = first.create('Bob Builder', 52)
+          expect { inst.other_name }.to raise_error(/no method is implemented for derived attribute MyModule::FirstGenerated\[other_name\]/)
+        end
+
+        it 'generates parameter list and a code body for derived function from a RubyMethod body attribute' do
+          inst = first.create('Bob Builder', 52)
+          expect(inst.name_and_age(' of age ')).to eq('Bob Builder of age 52')
+        end
       end
 
       context 'the #from_hash class method' do
@@ -137,6 +178,14 @@ describe 'Puppet Ruby Generator' do
         it 'that the TypeCalculator infers to the Object type' do
           expect(TypeCalculator.infer(first.from_hash('name' => 'Bob Builder'))).to eq(first_type)
         end
+
+        it "where attributes of kind 'reference' are not considered part of #_pcore_all_contents" do
+          inst = first.from_hash('name' => 'Bob Builder')
+          wrinst = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23, 40, inst, inst)
+          results = []
+          wrinst._pcore_all_contents([]) { |v| results << v }
+          expect(results).to eq([inst])
+        end
       end
     end
 
@@ -175,20 +224,14 @@ describe 'Puppet Ruby Generator' do
         PuppetSpec.send(:remove_const, :RubyGenerator)
       end
 
-      it 'the #_ptype class method returns a resolved Type' do
-        first_type = PuppetSpec::RubyGenerator::FirstGenerated._ptype
+      it 'the #_pcore_type class method returns a resolved Type' do
+        first_type = PuppetSpec::RubyGenerator::FirstGenerated._pcore_type
         expect(first_type).to be_a(PObjectType)
-        second_type = PuppetSpec::RubyGenerator::SecondGenerated._ptype
+        second_type = PuppetSpec::RubyGenerator::SecondGenerated._pcore_type
         expect(second_type).to be_a(PObjectType)
         expect(second_type.parent).to eql(first_type)
       end
 
-      it 'the #_plocation class method returns a file URI' do
-        loc = PuppetSpec::RubyGenerator::SecondGenerated._plocation
-        expect(loc).to be_a(URI)
-        expect(loc.to_s).to match(/^file:\/.*ruby_generator_spec.rb\?line=\d+$/)
-      end
-
       context 'the #create class method' do
         it 'has an arity that reflects optional arguments' do
           expect(PuppetSpec::RubyGenerator::FirstGenerated.method(:create).arity).to eql(-2)
@@ -513,20 +556,14 @@ describe 'Puppet Ruby Generator' do
         PuppetSpec.send(:remove_const, :RubyGenerator)
       end
 
-      it 'the #_ptype class method returns a resolved Type' do
-        first_type = PuppetSpec::RubyGenerator::My::FirstGenerated._ptype
+      it 'the #_pcore_type class method returns a resolved Type' do
+        first_type = PuppetSpec::RubyGenerator::My::FirstGenerated._pcore_type
         expect(first_type).to be_a(PObjectType)
-        second_type = PuppetSpec::RubyGenerator::My::SecondGenerated._ptype
+        second_type = PuppetSpec::RubyGenerator::My::SecondGenerated._pcore_type
         expect(second_type).to be_a(PObjectType)
         expect(second_type.parent).to eql(first_type)
       end
 
-      it 'the #_plocation class method returns a file URI' do
-        loc = PuppetSpec::RubyGenerator::My::SecondGenerated._plocation
-        expect(loc).to be_a(URI)
-        expect(loc.to_s).to match(/^file:\/.*ruby_generator_spec.rb\?line=\d+$/)
-      end
-
       context 'the #create class method' do
         it 'has an arity that reflects optional arguments' do
           expect(PuppetSpec::RubyGenerator::My::FirstGenerated.method(:create).arity).to eql(-2)

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

@@ -127,24 +127,38 @@ describe 'The string converter' do
       end
 
       it 'quoted 5-byte unicode chars' do
-        expect(converter.convert("smile \u{1f603}.", string_formats)).to eq('"smile \\u{1F603}."')
+        expect(converter.convert("smile \u{1f603}.", string_formats)).to eq("'smile \u{1F603}.'")
       end
 
       it 'quoted 2-byte unicode chars' do
         expect(converter.convert("esc \u{1b}.", string_formats)).to eq('"esc \\u{1B}."')
       end
 
-      it 'escape for $' do
-        expect(converter.convert('escape the $ sign', string_formats)).to eq('"escape the \$ sign"')
+      it 'escape for $ in double quoted string' do
+        # Use \n in string to force double quotes
+        expect(converter.convert("escape the $ sign\n", string_formats)).to eq('"escape the \$ sign\n"')
       end
 
-      it 'escape for double qoute but not for single quote' do
-        expect(converter.convert('the \' single and " double quote', string_formats)).to eq('"the \' single and \\" double quote"')
+      it 'no escape for $ in single quoted string' do
+        expect(converter.convert('don\'t escape the $ sign', string_formats)).to eq("'don\\'t escape the $ sign'")
+      end
+
+      it 'escape for double quote but not for single quote in double quoted string' do
+        # Use \n in string to force double quotes
+        expect(converter.convert("the ' single and \" double quote\n", string_formats)).to eq('"the \' single and \\" double quote\n"')
+      end
+
+      it 'escape for single quote but not for double quote in single quoted string' do
+        expect(converter.convert('the \' single and " double quote', string_formats)).to eq("'the \\' single and \" double quote'")
       end
 
       it 'no escape for #' do
         expect(converter.convert('do not escape #{x}', string_formats)).to eq('\'do not escape #{x}\'')
       end
+
+      it 'escape for last \\' do
+        expect(converter.convert('escape the last \\', string_formats)).to eq("'escape the last \\'")
+      end
     end
 
     {
@@ -828,7 +842,7 @@ describe 'The string converter' do
         string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>"," } }
         result = [
         "{1 => [ 1,",
-        "    2,", 
+        "    2,",
         "    3]}"
         ].join("\n")
         formatted = converter.convert({ 1 => [1, 2, 3] }, string_formats)
@@ -843,7 +857,7 @@ describe 'The string converter' do
         result = [
         "{",
         "  1 => [ 1,",
-        "    2,", 
+        "    2,",
         "    3]",
         "}"
         ].join("\n")
@@ -866,6 +880,54 @@ describe 'The string converter' do
       end
     end
 
+    context 'that is subclassed' do
+      let(:array) { ['a', 2] }
+      let(:derived_array) do
+        Class.new(Array) do
+          def to_a
+            self # Dead wrong! Should return a plain Array copy
+          end
+        end.new(array)
+      end
+      let(:derived_with_to_a) do
+        Class.new(Array) do
+          def to_a
+            super
+          end
+        end.new(array)
+      end
+
+      let(:hash) { {'first' => 1, 'second' => 2} }
+      let(:derived_hash) do
+        Class.new(Hash)[hash]
+      end
+      let(:derived_with_to_hash) do
+        Class.new(Hash) do
+          def to_hash
+            {}.merge(self)
+          end
+        end[hash]
+      end
+
+      it 'formats a derived array as a Runtime' do
+        expect(converter.convert(array)).to eq('[\'a\', 2]')
+        expect(converter.convert(derived_array)).to eq('["a", 2]')
+      end
+
+      it 'formats a derived array with #to_a retuning plain Array as an Array' do
+        expect(converter.convert(derived_with_to_a)).to eq('[\'a\', 2]')
+      end
+
+      it 'formats a derived hash as a Runtime' do
+        expect(converter.convert(hash)).to eq('{\'first\' => 1, \'second\' => 2}')
+        expect(converter.convert(derived_hash)).to eq('{"first"=>1, "second"=>2}')
+      end
+
+      it 'formats a derived hash with #to_hash retuning plain Hash as a Hash' do
+        expect(converter.convert(derived_with_to_hash, '%p')).to eq('{\'first\' => 1, \'second\' => 2}')
+      end
+    end
+
     it 'errors when format is not recognized' do
       expect do
       string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => "%k"}
@@ -883,10 +945,14 @@ describe 'The string converter' do
       it "the '%q' string representation for #{value} is #inspect" do
         expect(converter.convert(value, '%q')).to eq(value.inspect)
       end
+
+      it "the '%p' string representation for #{value} is quoted #to_s" do
+        expect(converter.convert(value, '%p')).to eq("'#{value}'")
+      end
     end
 
     it 'an unknown format raises an error' do
-      expect { converter.convert(:sym, '%b') }.to raise_error("Illegal format 'b' specified for value of Runtime type - expected one of the characters 'sq'")
+      expect { converter.convert(:sym, '%b') }.to raise_error("Illegal format 'b' specified for value of Runtime type - expected one of the characters 'spq'")
     end
   end
 
@@ -927,28 +993,6 @@ describe 'The string converter' do
         string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
         expect(converter.convert(/foo\/bar/, string_formats)).to eq('/foo\/bar/')
       end
-
-      context 'and slashes' do
-        it 'the format %s produces \'(?m-ix:foo/bar)\' for expression /foo\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%s'}
-          expect(converter.convert(/foo\/bar/m, string_formats)).to eq('(?m-ix:foo/bar)')
-        end
-
-        it 'the format %s produces \'(?m-ix:foo\/bar)\' for expression /foo\\\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%s'}
-          expect(converter.convert(/foo\\\/bar/m, string_formats)).to eq('(?m-ix:foo\\\\/bar)')
-        end
-
-        it 'the format %p produces \'(?m-ix:foo\/bar)\' for expression /foo\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-          expect(converter.convert(/foo\/bar/m, string_formats)).to eq('/(?m-ix:foo\/bar)/')
-        end
-
-        it 'the format %p produces \'(?m-ix:foo\/bar)\' for expression /(?m-ix:foo\/bar)/' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-          expect(converter.convert(/(?m-ix:foo\/bar)/, string_formats)).to eq('/(?m-ix:foo\/bar)/')
-        end
-      end
     end
 
     it 'errors when format is not recognized' do
@@ -1081,4 +1125,8 @@ describe 'The string converter' do
   it "allows format to be directly given (instead of as a type=> format hash)" do
     expect(converter.convert('hello', '%5.1s')).to eq('    h')
   end
+
+  it 'an explicit format for a type will override more specific defaults' do
+    expect(converter.convert({ 'x' => 'X' }, { Puppet::Pops::Types::PCollectionType::DEFAULT => '%#p' })).to eq("{\n  'x' => 'X'\n}")
+  end
 end