puppet 5.0.0 → 6.0.0

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

@@ -20,6 +20,10 @@ describe 'Sensitive Type' do
       expect(t.type).to eql(PIntegerType::DEFAULT)
     end
 
+    it 'string representation of unparameterized instance is "Sensitive"' do
+      expect(PSensitiveType::DEFAULT.to_s).to eql('Sensitive')
+    end
+
     context 'when used in Puppet expressions' do
       it 'is equal to itself only' do
         code = <<-CODE

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

@@ -24,6 +24,20 @@ describe 'Timespan type' do
       expect(eval_and_collect_notices(code)).to eq(%w(true true false false))
     end
 
+    it 'does not consider an Integer to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timespan, 1234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timespan value, got Integer/)
+    end
+
+    it 'does not consider a Float to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timespan, 1.234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timespan value, got Float/)
+    end
+
     context "when parameterized" do
       it 'is equal other types with the same parameterization' do
         code = <<-CODE
@@ -33,9 +47,16 @@ describe 'Timespan type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'using just one parameter is the same as using that parameter twice' do
+      it 'using just one parameter is the same as using default for the second parameter' do
         code = <<-CODE
-            notice(Timespan['01:00:00'] == Timespan['01:00:00', '01:00:00'])
+            notice(Timespan['01:00:00'] == Timespan['01:00:00', default])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'if the second parameter is default, it is unlimited' do
+        code = <<-CODE
+            notice(Timespan('12345-23:59:59') =~ Timespan['01:00:00', default])
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true))
       end
@@ -93,7 +114,14 @@ 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 'can be created from a integer that represents seconds since epoch' do
+      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' do
         code = <<-CODE
             $o = Timespan(6800)
             notice(Integer($o) == 6800)
@@ -102,7 +130,7 @@ describe 'Timespan type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'can be created from a float that represents seconds with fraction since epoch' do
+      it 'can be created from a float that represents seconds with fraction' do
         code = <<-CODE
             $o = Timespan(6800.123456789)
             notice(Float($o) == 6800.123456789)

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

@@ -12,6 +12,11 @@ describe 'Timestamp type' do
     expect(t).to eql(TypeFactory.timestamp('2015-03-01', '2016-12-24'))
   end
 
+  it 'DateTime#_strptime creates hash with :leftover field' do
+    expect(DateTime._strptime('2015-05-04 and bogus', '%F')).to include(:leftover)
+    expect(DateTime._strptime('2015-05-04T10:34:11.003 UTC and bogus', '%FT%T.%N %Z')).to include(:leftover)
+  end
+
   context 'when used in Puppet expressions' do
     include PuppetSpec::Compiler
     it 'is equal to itself only' do
@@ -25,6 +30,20 @@ describe 'Timestamp type' do
       expect(eval_and_collect_notices(code)).to eq(%w(true true false false))
     end
 
+    it 'does not consider an Integer to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timestamp, 1234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timestamp value, got Integer/)
+    end
+
+    it 'does not consider a Float to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timestamp, 1.234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timestamp value, got Float/)
+    end
+
     context "when parameterized" do
       it 'is equal other types with the same parameterization' do
         code = <<-CODE
@@ -34,9 +53,16 @@ describe 'Timestamp type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'using just one parameter is the same as using that parameter twice' do
+      it 'using just one parameter is the same as using default for the second parameter' do
         code = <<-CODE
-            notice(Timestamp['2015-03-01'] == Timestamp['2015-03-01', '2015-03-01'])
+            notice(Timestamp['2015-03-01'] == Timestamp['2015-03-01', default])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'if the second parameter is default, it is unlimited' do
+        code = <<-CODE
+            notice(Timestamp('5553-12-31') =~ Timestamp['2015-03-01', default])
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true))
       end
@@ -51,7 +77,7 @@ describe 'Timestamp type' do
     end
 
     context 'a Timestamp instance' do
-      it 'can be created from a string' do
+      it 'can be created from a string with just a date' do
         code = <<-CODE
             $o = Timestamp('2015-03-01')
             notice($o)
@@ -60,6 +86,34 @@ describe 'Timestamp type' do
         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 time separated by "T"' do
+        code = <<-CODE
+            notice(Timestamp('2015-03-01T11:12:13'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['2015-03-01T11:12:13.000000000 UTC'])
+      end
+
+      it 'can be created from a string and time separated by space' do
+        code = <<-CODE
+            notice(Timestamp('2015-03-01 11:12:13'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['2015-03-01T11:12:13.000000000 UTC'])
+      end
+
+      it 'should error when none of the default formats can parse the string' do
+        code = <<-CODE
+            notice(Timestamp('2015#03#01 11:12:13'))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(/Unable to parse/)
+      end
+
+      it 'should error when only part of the string is parsed' do
+        code = <<-CODE
+            notice(Timestamp('2015-03-01T11:12:13 bogus after'))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(/Unable to parse/)
+      end
+
       it 'can be created from a string and format' do
         code = <<-CODE
             $o = Timestamp('Sunday, 28 August, 2016', '%A, %d %B, %Y')
@@ -116,6 +170,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/p_type_set_type_spec.rb

@@ -14,8 +14,8 @@ 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}}").body
-        typeset = PTypeSetType.new(name, i12n_literal_hash, name_authority)
+        init_literal_hash = pp_parser.parse_string("{#{body_string}}").body
+        typeset = PTypeSetType.new(name, init_literal_hash, name_authority)
         loader.set_entry(Loader::TypedName.new(:type, name, name_authority), typeset)
         typeset
       end
@@ -314,7 +314,7 @@ module Puppet::Pops
           OBJECT
         end
 
-        it 'can declare a type and Object type' do
+        it 'can declare an Object type using Object[{}]' do
           expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
             version => '1.0.0',
             pcore_version => '1.0.0',
@@ -410,6 +410,110 @@ module Puppet::Pops
               }
           OBJECT
         end
+
+        context 'allows bracket-less 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 'on the TypeSet declaration itself' do
+            compile(<<-PUPPET)
+              type TS = TypeSet { pcore_version => '1.0.0' }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true'])
+          end
+
+          it 'without prefix on declared types (implies Object)' do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => Integer} }
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MyObject =~ Type)
+              notice(TS::MyObject(3))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true', 'true', "TS::MyObject({'a' => 3})"])
+          end
+
+          it "prefixed with QREF 'Object' on declared types" do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => Object { attributes => { a => Integer} }
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MyObject =~ Type)
+              notice(TS::MyObject(3))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true', 'true', "TS::MyObject({'a' => 3})"])
+          end
+
+          it 'prefixed with QREF to declare parent on declared types' do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MySecondObject =~ Type)
+              notice(TS::MySecondObject < TS::MyObject)
+              notice(TS::MyObject('hi'))
+              notice(TS::MySecondObject('hello', 'world'))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(
+              ['true', 'true', 'true', "TS::MyObject({'a' => 'hi'})", "TS::MySecondObject({'a' => 'hello', 'b' => 'world'})"])
+          end
+
+          it 'and warns when parent is specified both before and inside the hash if strict == warning' do
+            Puppet[:strict] = 'warning'
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { parent => MyObject, attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+            expect(warnings).to eql(["The key 'parent' is declared more than once"])
+            expect(notices).to eql(['true'])
+          end
+
+          it 'and errors when parent is specified both before and inside the hash if strict == error' do
+            Puppet[:strict] = 'error'
+            expect{ compile(<<-PUPPET) }.to raise_error(/The key 'parent' is declared more than once/)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { parent => MyObject, attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+          end
+        end
       end
 
       it '#name_for method reports the name of deeply nested type correctly' do
@@ -418,7 +522,7 @@ module Puppet::Pops
             pcore_version => '1.0.0',
             types => { Car => Object[{}] }
         OBJECT
-        tt = parse_type_set('Transports', <<-OBJECT)
+        parse_type_set('Transports', <<-OBJECT)
             version => '1.0.0',
             pcore_version => '1.0.0',
             references => {

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

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'URI type' do
+  context 'when used in Puppet expressions' do
+    include PuppetSpec::Compiler
+    it 'is equal to itself only' do
+      expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+          $t = URI
+          notice(URI =~ Type[URI])
+          notice(URI == URI)
+          notice(URI < URI)
+          notice(URI > URI)
+      CODE
+    end
+
+    context "when parameterized" do
+      it 'is equal other types with the same parameterization' do
+        code = <<-CODE
+            notice(URI == URI[{}])
+            notice(URI['http://example.com'] == URI[scheme => http, host => 'example.com'])
+            notice(URI['urn:a:b:c'] == URI[scheme => urn, opaque => 'a:b:c'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
+      it 'is assignable from more qualified types' do
+        expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true true))
+          notice(URI > URI['http://example.com'])
+          notice(URI['http://example.com'] > URI['http://example.com/path'])
+          notice(URI[scheme => Enum[http, https]] > URI['http://example.com'])
+        CODE
+      end
+
+      it 'is not assignable unless scheme is assignable' do
+        expect(eval_and_collect_notices(<<-CODE)).to eq(%w(false))
+          notice(URI[scheme => Enum[http, https]] > URI[scheme => 'ftp'])
+        CODE
+      end
+
+      it 'presents parsable string form' do
+        code = <<-CODE
+          notice(URI['https://user:password@www.example.com:3000/some/path?x=y#frag'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI[{'scheme' => 'https', 'userinfo' => 'user:password', 'host' => 'www.example.com', 'port' => '3000', 'path' => '/some/path', 'query' => 'x=y', 'fragment' => 'frag'}]",
+        ])
+      end
+    end
+
+    context 'a URI instance' do
+      it 'can be created from a string' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('https://example.com/a/b')",
+          "URI[{'scheme' => 'https', 'host' => 'example.com', 'path' => '/a/b'}]"
+        ])
+      end
+
+      it 'which is opaque, can be created from a string' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('urn:a:b:c')",
+          "URI[{'scheme' => 'urn', 'opaque' => 'a:b:c'}]"
+        ])
+      end
+
+      it 'can be created from a hash' do
+        code = <<-CODE
+            $o = URI(scheme => 'https', host => 'example.com', path => '/a/b')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('https://example.com/a/b')",
+          "URI[{'scheme' => 'https', 'host' => 'example.com', 'path' => '/a/b'}]"
+        ])
+      end
+
+      it 'which is opaque, can be created from a hash' do
+        code = <<-CODE
+            $o = URI(scheme => 'urn', opaque => 'a:b:c')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('urn:a:b:c')",
+          "URI[{'scheme' => 'urn', 'opaque' => 'a:b:c'}]"
+        ])
+      end
+
+      it 'is an instance of its type' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'is an instance of matching parameterized URI' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[scheme => https, host => 'example.com'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'is an instance of matching default URI' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'path is not matched by opaque' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice($o =~ URI[path => 'a:b:c'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'opaque is not matched by path' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[opaque => '/a/b'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'is not an instance unless parameters matches' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[scheme => http])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'individual parts of URI can be accessed using accessor methods' do
+        code = <<-CODE
+            $o = URI('https://bob:pw@example.com:8080/a/b?a=b#frag')
+            notice($o.scheme)
+            notice($o.userinfo)
+            notice($o.host)
+            notice($o.port)
+            notice($o.path)
+            notice($o.query)
+            notice($o.fragment)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['https', 'bob:pw', 'example.com', '8080', '/a/b', 'a=b', 'frag'])
+      end
+
+      it 'individual parts of opaque URI can be accessed using accessor methods' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice($o.scheme)
+            notice($o.opaque)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['urn', 'a:b:c'])
+      end
+
+      it 'An URI can be merged with a String using the + operator' do
+        code = <<-CODE
+          notice(String(URI('https://example.com') + '/a/b', '%p'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(["URI('https://example.com/a/b')"])
+      end
+
+      it 'An URI can be merged with another URI using the + operator' do
+        code = <<-CODE
+          notice(String(URI('https://example.com') + URI('/a/b'), '%p'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(["URI('https://example.com/a/b')"])
+      end
+    end
+  end
+end
+end
+end