puppet 4.7.1-universal-darwin → 4.8.0-universal-darwin

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

@@ -0,0 +1,311 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Timestamp type' do
+
+  it 'is normalized in a Variant' do
+    t = TypeFactory.variant(TypeFactory.timestamp('2015-03-01', '2016-01-01'), TypeFactory.timestamp('2015-11-03', '2016-12-24')).normalize
+    expect(t).to be_a(PTimestampType)
+    expect(t).to eql(TypeFactory.timestamp('2015-03-01', '2016-12-24'))
+  end
+
+  context 'when used in Puppet expressions' do
+    include PuppetSpec::Compiler
+    it 'is equal to itself only' do
+      code = <<-CODE
+          $t = Timestamp
+          notice(Timestamp =~ Type[Timestamp])
+          notice(Timestamp == Timestamp)
+          notice(Timestamp < Timestamp)
+          notice(Timestamp > Timestamp)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(%w(true true false false))
+    end
+
+    context "when parameterized" do
+      it 'is equal other types with the same parameterization' do
+        code = <<-CODE
+            notice(Timestamp['2015-03-01', '2016-01-01'] == Timestamp['2015-03-01', '2016-01-01'])
+            notice(Timestamp['2015-03-01', '2016-01-01'] != Timestamp['2015-11-03', '2016-12-24'])
+        CODE
+        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
+        code = <<-CODE
+            notice(Timestamp['2015-03-01'] == Timestamp['2015-03-01', '2015-03-01'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'orders parameterized types based on range inclusion' do
+        code = <<-CODE
+            notice(Timestamp['2015-03-01', '2015-09-30'] < Timestamp['2015-02-01', '2015-10-30'])
+            notice(Timestamp['2015-03-01', '2015-09-30'] > Timestamp['2015-02-01', '2015-10-30'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false))
+      end
+    end
+
+    context 'a Timestamp instance' do
+      it 'can be created from a string' do
+        code = <<-CODE
+            $o = Timestamp('2015-03-01')
+            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']"])
+      end
+
+      it 'can be created from a string and format' do
+        code = <<-CODE
+            $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'])
+      end
+
+      it 'can be created from a string, format, and a timezone' do
+        code = <<-CODE
+            $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'])
+      end
+
+      it 'can be not be created from a string, format with timezone designator, and a timezone' do
+        code = <<-CODE
+            $o = Timestamp('Sunday, 28 August, 2016 UTC', '%A, %d %B, %Y %z', 'EST')
+            notice($o)
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(
+          /Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument/)
+      end
+
+      it 'can be created from a hash with string and format' do
+        code = <<-CODE
+            $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'])
+      end
+
+      it 'can be created from a hash with string, format, and a timezone' do
+        code = <<-CODE
+            $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'])
+      end
+
+      it 'can be created from a string and array of formats' do
+        code = <<-CODE
+            $fmts = [
+              '%A, %d %B, %Y at %r',
+              '%b %d, %Y, %l:%M %P',
+              '%y-%m-%d %H:%M:%S %z'
+            ]
+            notice(Timestamp('Sunday, 28 August, 2016 at 12:15:00 PM', $fmts))
+            notice(Timestamp('Jul 24, 2016, 1:20 am', $fmts))
+            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'])
+      end
+
+      it 'can be created from a string, array of formats, and a timezone' do
+        code = <<-CODE
+            $fmts = [
+              '%A, %d %B, %Y at %r',
+              '%b %d, %Y, %l:%M %P',
+              '%y-%m-%d %H:%M:%S'
+            ]
+            notice(Timestamp('Sunday, 28 August, 2016 at 12:15:00 PM', $fmts, 'CET'))
+            notice(Timestamp('Jul 24, 2016, 1:20 am', $fmts, 'CET'))
+            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'])
+      end
+
+      it 'can be created from a integer that represents seconds since epoch' do
+        code = <<-CODE
+            $o = Timestamp(1433116800)
+            notice(Integer($o) == 1433116800)
+            notice($o == Timestamp('2015-06-01T00:00:00 UTC'))
+        CODE
+        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
+        code = <<-CODE
+            $o = Timestamp(1433116800.123456)
+            notice(Float($o) == 1433116800.123456)
+            notice($o == Timestamp('2015-06-01T00:00:00.123456 UTC'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true))
+      end
+
+      it 'matches the appropriate parameterized type' do
+        code = <<-CODE
+            $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'])
+      end
+
+      it 'does not match an inappropriate parameterized type' do
+        code = <<-CODE
+            $o = Timestamp('2015-05-01')
+            notice(assert_type(Timestamp['2016-03-01', '2016-09-30'], $o) |$e, $a| { 'nope' })
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['nope'])
+      end
+
+      it 'can be compared to other instances' do
+        code = <<-CODE
+            $o1 = Timestamp('2015-05-01')
+            $o2 = Timestamp('2015-06-01')
+            $o3 = Timestamp('2015-06-01')
+            notice($o1 > $o3)
+            notice($o1 >= $o3)
+            notice($o1 < $o3)
+            notice($o1 <= $o3)
+            notice($o1 == $o3)
+            notice($o1 != $o3)
+            notice($o2 > $o3)
+            notice($o2 < $o3)
+            notice($o2 >= $o3)
+            notice($o2 <= $o3)
+            notice($o2 == $o3)
+            notice($o2 != $o3)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(false false true true false true false false true true true false))
+      end
+
+      it 'can be compared to integer that represents seconds since epoch' do
+        code = <<-CODE
+            $o1 = Timestamp('2015-05-01')
+            $o2 = Timestamp('2015-06-01')
+            $o3 = 1433116800
+            notice($o1 > $o3)
+            notice($o1 >= $o3)
+            notice($o1 < $o3)
+            notice($o1 <= $o3)
+            notice($o2 > $o3)
+            notice($o2 < $o3)
+            notice($o2 >= $o3)
+            notice($o2 <= $o3)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(false false true true false false true true))
+      end
+
+      it 'integer that represents seconds since epoch can be compared to it' do
+        code = <<-CODE
+            $o1 = 1430438400
+            $o2 = 1433116800
+            $o3 = Timestamp('2015-06-01')
+            notice($o1 > $o3)
+            notice($o1 >= $o3)
+            notice($o1 < $o3)
+            notice($o1 <= $o3)
+            notice($o2 > $o3)
+            notice($o2 < $o3)
+            notice($o2 >= $o3)
+            notice($o2 <= $o3)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(false false true true false false true true))
+      end
+
+      it 'is equal to integer that represents seconds since epoch' do
+        code = <<-CODE
+            $o1 = Timestamp('2015-06-01T00:00:00 UTC')
+            $o2 = 1433116800
+            notice($o1 == $o2)
+            notice($o1 != $o2)
+            notice(Integer($o1) == $o2)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false true))
+      end
+
+      it 'integer that represents seconds is equal to it' do
+        code = <<-CODE
+            $o1 = 1433116800
+            $o2 = Timestamp('2015-06-01T00:00:00 UTC')
+            notice($o1 == $o2)
+            notice($o1 != $o2)
+            notice($o1 == Integer($o2))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false true))
+      end
+
+      it 'can be compared to float that represents seconds with fraction since epoch' do
+        code = <<-CODE
+            $o1 = Timestamp('2015-05-01T00:00:00.123456789 UTC')
+            $o2 = Timestamp('2015-06-01T00:00:00.123456789 UTC')
+            $o3 = 1433116800.123456789
+            notice($o1 > $o3)
+            notice($o1 >= $o3)
+            notice($o1 < $o3)
+            notice($o1 <= $o3)
+            notice($o2 > $o3)
+            notice($o2 < $o3)
+            notice($o2 >= $o3)
+            notice($o2 <= $o3)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(false false true true false false true true))
+      end
+
+      it 'float that represents seconds with fraction since epoch can be compared to it' do
+        code = <<-CODE
+            $o1 = 1430438400.123456789
+            $o2 = 1433116800.123456789
+            $o3 = Timestamp('2015-06-01T00:00:00.123456789 UTC')
+            notice($o1 > $o3)
+            notice($o1 >= $o3)
+            notice($o1 < $o3)
+            notice($o1 <= $o3)
+            notice($o2 > $o3)
+            notice($o2 < $o3)
+            notice($o2 >= $o3)
+            notice($o2 <= $o3)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(false false true true false false true true))
+      end
+
+      it 'is equal to float that represents seconds with fraction since epoch' do
+        code = <<-CODE
+            $o1 = Timestamp('2015-06-01T00:00:00.123456789 UTC')
+            $o2 = 1433116800.123456789
+            notice($o1 == $o2)
+            notice($o1 != $o2)
+            notice(Float($o1) == $o2)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false true))
+      end
+
+      it 'float that represents seconds with fraction is equal to it' do
+        code = <<-CODE
+            $o1 = 1433116800.123456789
+            $o2 = Timestamp('2015-06-01T00:00:00.123456789 UTC')
+            notice($o1 == $o2)
+            notice($o1 != $o2)
+            notice($o1 == Float($o2))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false true))
+      end
+
+      it 'it cannot be compared to a Timespan' do
+        code = <<-CODE
+            notice(Timestamp() > Timespan(3))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Timestamps are only comparable to Timestamps, Integers, and Floats/)
+      end
+    end
+  end
+end
+end
+end

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

@@ -107,7 +107,7 @@ module Puppet::Pops
             version => '1.0.0',
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /expected a value for key 'pcore_version'/)
+              /expects a value for key 'pcore_version'/)
           end
 
           it 'version is missing' do
@@ -115,7 +115,7 @@ module Puppet::Pops
             pcore_version => '1.0.0',
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /expected a value for key 'version'/)
+              /expects a value for key 'version'/)
           end
 
           it 'the version is an invalid semantic version' do
@@ -150,7 +150,7 @@ module Puppet::Pops
             name_authority => 'not a valid URI'
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /entry 'name_authority' expected a match for Pattern\[.*\], got 'not a valid URI'/m)
+              /entry 'name_authority' expects a match for Pattern\[.*\], got 'not a valid URI'/m)
           end
 
           context 'the types map' do
@@ -161,7 +161,7 @@ module Puppet::Pops
                 types => {}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'types' expected size to be at least 1, got 0/)
+                /entry 'types' expects size to be at least 1, got 0/)
             end
 
             it 'is not a map' do
@@ -171,7 +171,7 @@ module Puppet::Pops
                 types => []
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(Puppet::Error,
-                /entry 'types' expected a Hash value, got Array/)
+                /entry 'types' expects a Hash value, got Array/)
             end
 
             it 'contains values that are not types' do
@@ -195,7 +195,7 @@ module Puppet::Pops
                 }
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /key of entry 'car' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'car'/)
+                /key of entry 'car' expects a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'car'/)
             end
           end
 
@@ -207,7 +207,7 @@ module Puppet::Pops
                 references => {}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' expected size to be at least 1, got 0/)
+                /entry 'references' expects size to be at least 1, got 0/)
             end
 
             it 'is not a hash' do
@@ -217,7 +217,7 @@ module Puppet::Pops
                 references => []
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' expected a Hash value, got Array/)
+                /entry 'references' expects a Hash value, got Array/)
             end
 
             it 'contains something other than reference initialization maps' do
@@ -227,7 +227,7 @@ module Puppet::Pops
                 references => {Ref => 2}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' entry 'Ref' expected a Struct value, got Integer/)
+                /entry 'references' entry 'Ref' expects a Struct value, got Integer/)
             end
 
             it 'contains several initialization that refers to the same TypeSet' do
@@ -266,7 +266,7 @@ module Puppet::Pops
                   references => { Ref => { name => 'X' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' expected a value for key 'version_range'/)
+                  /entry 'references' entry 'Ref' expects a value for key 'version_range'/)
               end
 
               it 'has no name' do
@@ -276,7 +276,7 @@ module Puppet::Pops
                   references => { Ref => { version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' expected a value for key 'name'/)
+                  /entry 'references' entry 'Ref' expects a value for key 'name'/)
               end
 
               it 'has a name that is not a QRef' do
@@ -286,7 +286,7 @@ module Puppet::Pops
                   references => { Ref => { name => 'cars', version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' entry 'name' expected a match for Pattern\[\/\\A\[A-Z\]\[\\w\]\*\(\?:::\[A-Z\]\[\\w\]\*\)\*\\z\/\], got 'cars'/)
+                  /entry 'references' entry 'Ref' entry 'name' expects a match for Pattern\[\/\\A\[A-Z\]\[\\w\]\*\(\?:::\[A-Z\]\[\\w\]\*\)\*\\z\/\], got 'cars'/)
               end
 
               it 'has a version_range that is not a valid SemVer range' do
@@ -306,7 +306,7 @@ module Puppet::Pops
                   references => { 'cars' => { name => 'X', version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' key of entry 'cars' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'cars'/)
+                  /entry 'references' key of entry 'cars' expects a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'cars'/)
               end
             end
           end

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

@@ -81,14 +81,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { first.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -128,7 +128,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { first.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -205,14 +205,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -252,7 +252,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -389,14 +389,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { first.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -436,7 +436,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { first.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -519,14 +519,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -566,7 +566,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end