puppet 5.1.0-x64-mingw32 → 5.2.0-x64-mingw32

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

@@ -191,7 +191,7 @@ describe 'The Init Type' do
       expect(eval_and_collect_notices(code)).to eql(['true'])
     end
 
-    it 'T1 is assignable to Init[T2] if T2 can be created from instance of T1 is valid' do
+    it 'T1 is assignable to Init[T2] if T2 can be created from instance of T1' do
       code = <<-CODE
       notice(Integer < Init[String])
       CODE

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

@@ -91,6 +91,19 @@ describe 'The Object Type' do
       expect(attr.value?).to be_truthy
     end
 
+    it 'attribute value can be defined using heredoc?' do
+      tp = parse_object('MyObject', <<-OBJECT.unindent)
+        attributes => {
+          a => { type => String, value => @(END) }
+            The value is some
+            multiline text
+            |-END
+        }
+      OBJECT
+      attr = tp['a']
+      expect(attr.value).to eql("The value is some\nmultiline text")
+    end
+
     it 'attribute without defined value responds false to value?' do
       tp = parse_object('MyObject', <<-OBJECT)
         attributes => {
@@ -122,44 +135,88 @@ describe 'The Object Type' do
     end
 
     context 'that are constants' do
-      it 'sets final => true' do
-        tp = parse_object('MyObject', <<-OBJECT)
-          attributes => {
-            a => {
-              type => Integer,
-              kind => constant,
-              value => 3
+      context 'and declared under key "constants"' do
+        it 'sets final => true' do
+          tp = parse_object('MyObject', <<-OBJECT)
+            constants => {
+              a => 3
             }
-          }
-        OBJECT
-        expect(tp['a'].final?).to be_truthy
-      end
-
-      it 'raises an error when no value is declared' do
-        obj = <<-OBJECT
-          attributes => {
-            a => {
-              type => Integer,
-              kind => constant
+          OBJECT
+          expect(tp['a'].final?).to be_truthy
+        end
+
+        it 'sets kind => constant' do
+          tp = parse_object('MyObject', <<-OBJECT)
+            constants => {
+              a => 3
             }
-          }
-        OBJECT
-        expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
-          "attribute MyObject[a] of kind 'constant' requires a value")
+          OBJECT
+          expect(tp['a'].constant?).to be_truthy
+        end
+
+        it 'infers generic type from value' do
+          tp = parse_object('MyObject', <<-OBJECT)
+            constants => {
+              a => 3
+            }
+          OBJECT
+          expect(tp['a'].type.to_s).to eql('Integer')
+        end
+
+        it 'cannot have the same name as an attribute' do
+          obj = <<-OBJECT
+            constants => {
+              a => 3
+            },
+            attributes => {
+              a => Integer
+            }
+          OBJECT
+          expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
+            'attribute MyObject[a] is defined as both a constant and an attribute')
+        end
       end
 
-      it 'raises an error when final => false' do
-        obj = <<-OBJECT
-          attributes => {
-            a => {
-              type => Integer,
-              kind => constant,
-              final => false
+      context 'and declared under key "attributes"' do
+        it 'sets final => true when declard in attributes' do
+          tp = parse_object('MyObject', <<-OBJECT)
+            attributes => {
+              a => {
+                type => Integer,
+                kind => constant,
+                value => 3
+              }
             }
-          }
-        OBJECT
-        expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
-          "attribute MyObject[a] of kind 'constant' cannot be combined with final => false")
+          OBJECT
+          expect(tp['a'].final?).to be_truthy
+        end
+
+        it 'raises an error when no value is declared' do
+          obj = <<-OBJECT
+            attributes => {
+              a => {
+                type => Integer,
+                kind => constant
+              }
+            }
+          OBJECT
+          expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
+            "attribute MyObject[a] of kind 'constant' requires a value")
+        end
+
+        it 'raises an error when final => false' do
+          obj = <<-OBJECT
+            attributes => {
+              a => {
+                type => Integer,
+                kind => constant,
+                final => false
+              }
+            }
+          OBJECT
+          expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
+            "attribute MyObject[a] of kind 'constant' cannot be combined with final => false")
+        end
       end
     end
   end
@@ -207,6 +264,24 @@ describe 'The Object Type' do
       expect(tp['a'].type).to eql(PIntegerType.new(0,10))
     end
 
+    it 'can redefine inherited constant to assignable type' do
+      parent = <<-OBJECT
+        constants => {
+          a => 23
+        }
+      OBJECT
+      obj = <<-OBJECT
+        parent => MyObject,
+        constants => {
+          a => 46
+        }
+      OBJECT
+      tp = parse_object('MyObject', parent)
+      td = parse_object('MyDerivedObject', obj)
+      expect(tp['a'].value).to eql(23)
+      expect(td['a'].value).to eql(46)
+    end
+
     it 'raises an error when an attribute overrides a function' do
       parent = <<-OBJECT
         attributes => {
@@ -845,6 +920,115 @@ describe 'The Object Type' do
         /attribute MySecondObject\[a\] attempts to override final attribute MyObject\[a\]/)
     end
 
+    context 'type alias using bracket-less (implicit Object) form' do
+      let(:logs) { [] }
+      let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+      let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+      let(:node) { Puppet::Node.new('example.com') }
+      let(:compiler) { Puppet::Parser::Compiler.new(node) }
+
+      def compile(code)
+        Puppet[:code] = code
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) { compiler.compile }
+      end
+
+      it 'Object is implicit' do
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => Integer}}
+          notice(MyObject =~ Type)
+          notice(MyObject(3))
+        CODE
+        expect(warnings).to be_empty
+        expect(notices).to eql(['true', "MyObject({'a' => 3})"])
+      end
+
+      it 'Object can be specified' do
+        compile(<<-CODE)
+          type MyObject = Object { name => 'MyFirstObject', attributes => { a =>Integer }}
+          notice(MyObject =~ Type)
+          notice(MyObject(3))
+        CODE
+        expect(warnings).to be_empty
+        expect(notices).to eql(['true', "MyObject({'a' => 3})"])
+      end
+
+      it 'parent can be specified before the hash' do
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = MyObject { attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+          notice(MySecondObject < MyObject)
+          notice(MyObject('hi'))
+          notice(MySecondObject('hello', 'world'))
+        CODE
+        expect(warnings).to be_empty
+        expect(notices).to eql(
+          ['true', 'true', "MyObject({'a' => 'hi'})", "MySecondObject({'a' => 'hello', 'b' => 'world'})"])
+      end
+
+      it 'parent can be specified in the hash' do
+        Puppet[:strict] = 'warning'
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = { parent => MyOtherType, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+        expect(warnings).to be_empty
+        expect(notices).to eql(['true'])
+      end
+
+      it 'Object before the hash and parent inside the hash can be combined' do
+        Puppet[:strict] = 'warning'
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = Object { parent => MyOtherType, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+        expect(warnings).to be_empty
+        expect(notices).to eql(['true'])
+      end
+
+      it 'if strict == warning, a warning is issued when the same is parent specified both before and inside the hash' do
+        Puppet[:strict] = 'warning'
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = MyObject { parent => MyObject, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+        expect(notices).to eql(['true'])
+        expect(warnings).to eql(["The key 'parent' is declared more than once"])
+      end
+
+      it 'if strict == warning, a warning is issued when different parents are specified before and inside the hash. The former overrides the latter' do
+        Puppet[:strict] = 'warning'
+        compile(<<-CODE)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = MyObject { parent => MyObject, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+        expect(notices).to eql(['true'])
+        expect(warnings).to eql(["The key 'parent' is declared more than once"])
+      end
+
+      it 'if strict == error, an error is raised when the same parent is specified both before and inside the hash' do
+        Puppet[:strict] = 'error'
+        expect { compile(<<-CODE) }.to raise_error(/The key 'parent' is declared more than once/)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = MyObject { parent => MyObject, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+      end
+
+      it 'if strict == error, an error is raised when different parents are specified before and inside the hash' do
+        Puppet[:strict] = 'error'
+        expect { compile(<<-CODE) }.to raise_error(/The key 'parent' is declared more than once/)
+          type MyObject = { name => 'MyFirstObject', attributes => { a => String }}
+          type MySecondObject = MyObject { parent => MyOtherType, attributes => { b => String }}
+          notice(MySecondObject =~ Type)
+        CODE
+      end
+    end
+
     it 'can inherit from an aliased type' do
       code = <<-CODE
       type MyObject = Object[{ name => 'MyFirstObject', attributes => { a => Integer }}]

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

@@ -107,6 +107,13 @@ describe 'Timespan type' do
           %w(1-11:23:13.0 0-11:23:13.0 1-11:23:00.0 1-11:00:00.0 0-11:23:00.0 0-00:23:13.0 1-00:00:00.0 0-11:00:00.0 0-00:23:00.0 0-00:00:13.0))
       end
 
+      it 'it cannot be created using an empty formats array' do
+        code = <<-CODE
+            notice(Timespan('1d11h23m13s', []))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /parameter 'format' variant 1 expects size to be at least 1, got 0/)
+      end
+
       it 'can be created from a integer that represents seconds since epoch' do
         code = <<-CODE
             $o = Timespan(6800)

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

@@ -163,6 +163,13 @@ describe 'Timestamp type' do
           ['2016-08-28T12:15:00.000000000 UTC', '2016-07-24T01:20:00.000000000 UTC', '2016-06-21T18:23:15.000000000 UTC'])
       end
 
+      it 'it cannot be created using an empty formats array' do
+        code = <<-CODE
+            notice(Timestamp('2015-03-01T11:12:13', []))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /parameter 'format' variant 1 expects size to be at least 1, got 0/)
+      end
+
       it 'can be created from a string, array of formats, and a timezone' do
         code = <<-CODE
             $fmts = [

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

@@ -87,6 +87,12 @@ describe 'The string converter' do
       end.to raise_error(/Only one of the delimiters/)
     end
 
+    it "Is an error to have trailing characters after the format" do
+      expect do
+        fmt = format.new("%dv")
+      end.to raise_error(/The format '%dv' is not a valid format/)
+    end
+
     it "Is an error to specify the same flag more than once" do
       expect do
         fmt = format.new("%[[d")
@@ -644,15 +650,19 @@ describe 'The string converter' do
       "% a"  => "1, 'hello'",
 
       {'format' => '%(a',
-        'separator' => ''
+        'separator' => ' '
       } => "(1 'hello')",
 
-      {'format' => '%|a',
+      {'format' => '%(a',
         'separator' => ''
+      } => "(1'hello')",
+
+      {'format' => '%|a',
+        'separator' => ' '
       } => "|1 'hello'|",
 
       {'format' => '%(a',
-        'separator' => '',
+        'separator' => ' ',
         'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
       } => "(0x1 'hello')",
     }.each do |fmt, result |
@@ -674,7 +684,7 @@ describe 'The string converter' do
     end
 
     it 'indents elements in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[1, 2, 9, 9,",
@@ -689,7 +699,7 @@ describe 'The string converter' do
     end
 
     it 'treats hashes as nested arrays wrt indentation' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[1, 2, 9, 9,",
@@ -704,7 +714,7 @@ describe 'The string converter' do
     end
 
     it 'indents and breaks when a sequence > given width, in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[ 1,",
@@ -722,7 +732,7 @@ describe 'The string converter' do
     end
 
     it 'indents and breaks when a sequence (placed last) > given width, in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[ 1,",
@@ -740,7 +750,7 @@ describe 'The string converter' do
     end
 
     it 'indents and breaks nested sequences when one is placed first' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[",
@@ -801,7 +811,12 @@ describe 'The string converter' do
        } => "(1 'hello', 2 'world')",
 
        {'format' => '%(h',
-         'separator' => ' >>',
+         'separator' => '',
+         'separator2' => ''
+       } => "(1'hello'2'world')",
+
+       {'format' => '%(h',
+         'separator' => ' >> ',
          'separator2' => ' <=> ',
          'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
        } => "(0x1 <=> 'hello' >> 0x2 <=> 'world')",
@@ -851,7 +866,7 @@ describe 'The string converter' do
 
       it 'both hash and array renders with breaks and indentation if so specified for both' do
         string_formats = {
-          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>"," },
+          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>", " },
           Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
         }
         result = [
@@ -867,7 +882,7 @@ describe 'The string converter' do
 
       it 'hash, but not array is rendered with breaks and indentation if so specified only for the hash' do
         string_formats = {
-          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%a', 'separator' =>"," },
+          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%a', 'separator' =>", " },
           Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
         }
         result = [
@@ -993,6 +1008,28 @@ 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