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

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

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Binary Type' do
+  include PuppetSpec::Compiler
+
+  context 'as a type' do
+    it 'can be created with the type factory' do
+      t = TypeFactory.binary()
+      expect(t).to be_a(PBinaryType)
+      expect(t).to eql(PBinaryType::DEFAULT)
+    end
+  end
+
+  context 'a Binary instance' do
+    it 'can be created from a raw String using %r, raw string mode' do
+      str = [0xF1].pack("C*")
+      code = <<-CODE
+        $x = Binary($testing, '%r')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })).to eql(['8Q=='])
+    end
+
+    it 'can be created from a String using %s, string mode' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('binary', '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it 'format %s errors if encoding is bad in given string when using format %s and a broken UTF-8 string' do
+      str = [0xF1].pack("C*")
+      str.force_encoding('UTF-8')
+      code = <<-CODE
+        $x = Binary($testing, '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect {
+        eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })
+      }.to raise_error(/.*The given string in encoding 'UTF-8' is invalid\. Cannot create a Binary UTF-8 representation.*/)
+    end
+
+    it 'format %s errors if encoding is correct but string cannot be transcoded to UTF-8' do
+      str = [0xF1].pack("C*")
+      code = <<-CODE
+        $x = Binary($testing, '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect {
+        eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })
+      }.to raise_error(/.*"\\xF1" from ASCII-8BIT to UTF-8.*/)
+    end
+
+    it 'can be created from a strict Base64 encoded String using default format' do
+      code = <<-CODE
+        $x = Binary('YmluYXI=')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will error creation in strict mode if padding is missing when using default format' do
+      # the text 'binar' needs padding with '=' (missing here to trigger error
+      code = <<-CODE
+        $x = Binary('YmluYXI')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    it 'can be created from a Base64 encoded String using %B, strict mode' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('YmluYXI=', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will error creation in strict mode if padding is missing' do
+      # the text 'binar' needs padding with '=' (missing here to trigger error
+      code = <<-CODE
+        $x = Binary('YmluYXI', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    it 'will not error creation in base mode if padding is missing' do
+      # the text 'binar' needs padding with '=' (missing here to trigger possible error)
+      code = <<-CODE
+        $x = Binary('YmluYXI', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will not error creation in base mode if padding is not required' do
+      # the text 'binary' does not need padding with '='
+      code = <<-CODE
+        $x = Binary('YmluYXJ5', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it 'can be compared to another instance for equality' do
+      code = <<-CODE
+        $x = Binary('YmluYXJ5')
+        $y = Binary('YmluYXJ5')
+        notice($x == $y)
+        notice($x != $y)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
+    end
+
+    it 'can be created from an array of byte values' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary([251, 239, 255])
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an hash with value and format" do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary({value => '--__', format => '%u'})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an hash with value and default format" do
+      code = <<-CODE
+        $x = Binary({value => 'YmluYXI='})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'can be created from a hash with value being an array' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary({value => [251, 239, 255]})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an Base64 using URL safe encoding by specifying '%u' format'" do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('--__', '%u')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "when created with URL safe encoding chars in '%b' format, these are skipped" do
+      code = <<-CODE
+        $x = Binary('--__YmluYXJ5', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it "will error in strict format if string contains URL safe encoded chars" do
+      code = <<-CODE
+        $x = Binary('--__YmluYXJ5', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    [   '<',
+        '<=',
+        '>',
+        '>='
+    ].each do |op|
+      it "cannot be compared to another instance for magnitude using #{op}" do
+        code = <<-"CODE"
+          $x = Binary('YmluYXJ5')
+          $y = Binary('YmluYXJ5')
+          $x #{op} $y
+        CODE
+        expect { eval_and_collect_notices(code)}.to raise_error(/Comparison of: Binary #{op} Binary, is not possible/)
+      end
+    end
+
+    it 'can be matched against a Binary in case expression' do
+      code = <<-CODE
+        case Binary('YmluYXJ5') {
+          Binary('YWxpZW4='): {
+            notice('nope')
+          }
+          Binary('YmluYXJ5'): {
+            notice('yay')
+          }
+          default: {
+            notice('nope')
+          }
+        }
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['yay'])
+    end
+
+    it "can be matched against a Binary subsequence using 'in' expression" do
+      # finding 'one' in 'one two three'
+      code = <<-CODE
+        notice(Binary("b25l") in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(Binary("c25l") in Binary("b25lIHR3byB0aHJlZQ=="))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
+    end
+
+    it "can be matched against a byte value using 'in' expression" do
+      # finding 'e' (ascii 101) in 'one two three'
+      code = <<-CODE
+        notice(101 in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(101.0 in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(102 in Binary("b25lIHR3byB0aHJlZQ=="))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true', 'false'])
+    end
+
+    it "has a length method in ruby returning the length measured in bytes" do
+      # \u{1f452} is "woman's hat emoji - 4 bytes in UTF-8"
+      a_binary = PBinaryType::Binary.new("\u{1f452}")
+      expect(a_binary.length).to be(4)
+    end
+  end
+
+end
+end
+end

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