puppet 4.7.1-x86-mingw32 → 4.8.0-x86-mingw32

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

@@ -31,7 +31,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /attribute MyObject\[a\] had wrong type, expected a Type value, got Integer/)
+        /attribute MyObject\[a\] has wrong type, expects a Type value, got Integer/)
     end
 
     it 'raises an error if the type is missing' do
@@ -41,7 +41,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /expected a value for key 'type'/)
+        /expects a value for key 'type'/)
     end
 
     it 'raises an error when value is of incompatible type' do
@@ -51,7 +51,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /attribute MyObject\[a\] value had wrong type, expected an Integer value, got String/)
+        /attribute MyObject\[a\] value has wrong type, expects an Integer value, got String/)
     end
 
     it 'raises an error if the kind is invalid' do
@@ -61,7 +61,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /expected a match for Enum\['constant', 'derived', 'given_or_derived'\], got 'derivd'/)
+        /expects a match for Enum\['constant', 'derived', 'given_or_derived'\], got 'derivd'/)
     end
 
     it 'stores value in attribute' do
@@ -155,7 +155,7 @@ describe 'The Object Type' do
         }
       OBJECT
       expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError,
-        /function MyObject\[a\] had wrong type, expected a Type\[Callable\] value, got Type\[String\]/)
+        /function MyObject\[a\] has wrong type, expects a Type\[Callable\] value, got Type\[String\]/)
     end
 
     it 'raises an error when a function has the same name as an attribute' do
@@ -494,7 +494,7 @@ describe 'The Object Type' do
         a => Integer
       }
     OBJECT
-    expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError, /object initializer had wrong type, unrecognized key 'attribrutes'/)
+    expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError, /object initializer has wrong type, unrecognized key 'attribrutes'/)
   end
 
   it 'raises an error when attribute contains invalid keys' do
@@ -503,7 +503,7 @@ describe 'The Object Type' do
         a => { type => Integer, knid => constant }
       }
     OBJECT
-    expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError, /initializer for attribute MyObject\[a\] had wrong type, unrecognized key 'knid'/)
+    expect { parse_object('MyObject', obj) }.to raise_error(TypeAssertionError, /initializer for attribute MyObject\[a\] has wrong type, unrecognized key 'knid'/)
   end
 
   context 'when inheriting from a another Object type' do

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

@@ -96,7 +96,7 @@ describe 'Sensitive Type' do
       CODE
       expect {
         eval_and_collect_notices(code)
-      }.to raise_error(Puppet::Error, /expected a Sensitive\[String\[10, 20\]\] value, got Sensitive\[String\[7, 7\]\]/)
+      }.to raise_error(Puppet::Error, /expects a Sensitive\[String\[10, 20\]\] value, got Sensitive\[String\[7, 7\]\]/)
     end
 
     it 'does not match an inappropriate parameterized type' do

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

@@ -0,0 +1,273 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Timespan type' do
+  it 'is normalized in a Variant' do
+    t = TypeFactory.variant(TypeFactory.timespan('10:00:00', '15:00:00'), TypeFactory.timespan('14:00:00', '17:00:00')).normalize
+    expect(t).to be_a(PTimespanType)
+    expect(t).to eql(TypeFactory.timespan('10:00:00', '17:00:00'))
+  end
+
+  context 'when used in Puppet expressions' do
+    include PuppetSpec::Compiler
+    it 'is equal to itself only' do
+      code = <<-CODE
+          $t = Timespan
+          notice(Timespan =~ Type[Timespan])
+          notice(Timespan == Timespan)
+          notice(Timespan < Timespan)
+          notice(Timespan > Timespan)
+      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(Timespan['01:00:00', '13:00:00'] == Timespan['01:00:00', '13:00:00'])
+            notice(Timespan['01:00:00', '13:00:00'] != Timespan['01:12:20', '13:00:00'])
+        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(Timespan['01:00:00'] == Timespan['01:00:00', '01:00:00'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'orders parameterized types based on range inclusion' do
+        code = <<-CODE
+            notice(Timespan['01:00:00', '13:00:00'] < Timespan['00:00:00', '14:00:00'])
+            notice(Timespan['01:00:00', '13:00:00'] > Timespan['00:00:00', '14:00:00'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true false))
+      end
+    end
+
+    context 'a Timespan instance' do
+      it 'can be created from a string' do
+        code = <<-CODE
+            $o = Timespan('3-11:00')
+            notice($o)
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(3-11:00:00.0 Timespan['3-11:00:00.0']))
+      end
+
+      it 'can be created from a string and format' do
+        code = <<-CODE
+            $o = Timespan('1d11h23m', '%Dd%Hh%Mm')
+            notice($o)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(1-11:23:00.0))
+      end
+
+      it 'can be created from a hash with string and format' do
+        code = <<-CODE
+            $o = Timespan({string => '1d11h23m', format => '%Dd%Hh%Mm'})
+            notice($o)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(1-11:23:00.0))
+      end
+
+      it 'can be created from a string and array of formats' do
+        code = <<-CODE
+            $fmts = ['%Dd%Hh%Mm%Ss', '%Hh%Mm%Ss', '%Dd%Hh%Mm', '%Dd%Hh', '%Hh%Mm', '%Mm%Ss', '%Dd', '%Hh', '%Mm', '%Ss' ]
+            notice(Timespan('1d11h23m13s', $fmts))
+            notice(Timespan('11h23m13s', $fmts))
+            notice(Timespan('1d11h23m', $fmts))
+            notice(Timespan('1d11h', $fmts))
+            notice(Timespan('11h23m', $fmts))
+            notice(Timespan('23m13s', $fmts))
+            notice(Timespan('1d', $fmts))
+            notice(Timespan('11h', $fmts))
+            notice(Timespan('23m', $fmts))
+            notice(Timespan('13s', $fmts))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(
+          %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
+        code = <<-CODE
+            $o = Timespan(6800)
+            notice(Integer($o) == 6800)
+            notice($o == Timespan('01:53:20'))
+        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 = Timespan(6800.123456789)
+            notice(Float($o) == 6800.123456789)
+            notice($o == Timespan('01:53:20.123456789', '%H:%M:%S.%N'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true))
+      end
+
+      it 'matches the appropriate parameterized type' do
+        code = <<-CODE
+            $o = Timespan('3-11:12:13')
+            notice(assert_type(Timespan['3-00:00:00', '4-00:00:00'], $o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['3-11:12:13.0'])
+      end
+
+      it 'does not match an inappropriate parameterized type' do
+        code = <<-CODE
+            $o = Timespan('1-03:04:05')
+            notice(assert_type(Timespan['2-00:00:00', '3-00:00:00'], $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 = Timespan('00:00:01')
+            $o2 = Timespan('00:00:02')
+            $o3 = Timespan('00:00:02')
+            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' do
+        code = <<-CODE
+            $o1 = Timespan('00:00:01')
+            $o2 = Timespan('00:00:02')
+            $o3 = 2
+            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 can be compared to it' do
+        code = <<-CODE
+            $o1 = 1
+            $o2 = 2
+            $o3 = Timespan('00:00:02')
+            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' do
+        code = <<-CODE
+            $o1 = Timespan('02', '%S')
+            $o2 = 2
+            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 = 2
+            $o2 = Timespan('02', '%S')
+            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' do
+        code = <<-CODE
+            $o1 = Timespan('01.123456789', '%S.%N')
+            $o2 = Timespan('02.123456789', '%S.%N')
+            $o3 = 2.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 can be compared to it' do
+        code = <<-CODE
+            $o1 = 1.123456789
+            $o2 = 2.123456789
+            $o3 = Timespan('02.123456789', '%S.%N')
+            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' do
+        code = <<-CODE
+            $o1 = Timespan('02.123456789', '%S.%N')
+            $o2 = 2.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 = 2.123456789
+            $o2 = Timespan('02.123456789', '%S.%N')
+            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 Timestamp' do
+        code = <<-CODE
+            notice(Timespan(3) < Timestamp())
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Timespans are only comparable to Timespans, Integers, and Floats/)
+      end
+    end
+  end
+end
+end
+end

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