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

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

@@ -5,6 +5,7 @@ describe 'The string converter' do
   let(:converter) { Puppet::Pops::Types::StringConverter.singleton }
   let(:factory) { Puppet::Pops::Types::TypeFactory }
   let(:format) { Puppet::Pops::Types::StringConverter::Format }
+  let(:binary) { Puppet::Pops::Types::PBinaryType::Binary }
 
   describe 'helper Format' do
     it 'parses a single character like "%d" as a format' do
@@ -903,6 +904,94 @@ describe 'The string converter' do
     end
   end
 
+  context 'when converting binary' do
+    let(:sample) { binary.from_binary_string('binary') }
+
+    it 'the binary is converted to strict base64 string unquoted by default (same as %B)' do
+      expect(converter.convert(sample, :default)).to eq("YmluYXJ5")
+    end
+
+    it 'the binary is converted using %p by default when contained in an array' do
+      expect(converter.convert([sample], :default)).to eq("[Binary(\"YmluYXJ5\")]")
+    end
+
+    it '%B formats in base64 strict mode (same as default)' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%B'}
+      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5")
+    end
+
+    it '%b formats in base64 relaxed mode, and adds newline' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%b'}
+      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5\n")
+    end
+
+    it '%u formats in base64 urlsafe mode' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%u'}
+      expect(converter.convert(binary.from_base64("++//"), string_formats)).to eq("--__")
+    end
+
+    it '%p formats with type name' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%p'}
+      expect(converter.convert(sample, string_formats)).to eq("Binary(\"YmluYXJ5\")")
+    end
+
+    it '%#s formats as quoted string with escaped non printable bytes' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%#s'}
+      expect(converter.convert(binary.from_base64("apa="), string_formats)).to eq("\"j\\x96\"")
+    end
+
+    it '%s formats as unquoted string with valid UTF-8 chars' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
+      # womans hat emoji is E318, a three byte UTF-8 char EE 8C 98
+      expect(converter.convert(binary.from_binary_string("\xEE\x8C\x98"), string_formats)).to eq("\uE318")
+    end
+
+    it '%s errors if given non UTF-8 bytes' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
+      expect {
+        converter.convert(binary.from_base64("apa="), string_formats)
+      }.to raise_error(Encoding::UndefinedConversionError)
+    end
+
+    { "%s"    => 'binary',
+      "%#s"   => '"binary"',
+      "%8s"   => '  binary',
+      "%.2s"  => 'bi',
+      "%-8s"  => 'binary  ',
+      "%p"    => 'Binary("YmluYXJ5")',
+      "%10p"  => 'Binary("  YmluYXJ5")',
+      "%-10p" => 'Binary("YmluYXJ5  ")',
+      "%.2p"  => 'Binary("Ym")',
+      "%b"    => "YmluYXJ5\n",
+      "%11b"  => "  YmluYXJ5\n",
+      "%-11b" => "YmluYXJ5\n  ",
+      "%.2b"  => "Ym",
+      "%B"    => "YmluYXJ5",
+      "%11B"  => "   YmluYXJ5",
+      "%-11B" => "YmluYXJ5   ",
+      "%.2B"  => "Ym",
+      "%u"    => "YmluYXJ5",
+      "%11u"  => "   YmluYXJ5",
+      "%-11u" => "YmluYXJ5   ",
+      "%.2u"  => "Ym",
+      "%t"    => 'Binary',
+      "%#t"   => '"Binary"',
+      "%8t"   => '  Binary',
+      "%-8t"  => 'Binary  ',
+      "%.3t"  => 'Bin',
+      "%T"    => 'BINARY',
+      "%#T"   => '"BINARY"',
+      "%8T"   => '  BINARY',
+      "%-8T"  => 'BINARY  ',
+      "%.3T"  => 'BIN',
+    }.each do |fmt, result |
+      it "the format #{fmt} produces #{result}" do
+        string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => fmt}
+        expect(converter.convert(sample, string_formats)).to eq(result)
+      end
+    end
+  end
+
   context 'when converting iterator' do
     it 'the iterator is transformed to an array and formatted using array rules' do
       itor = Puppet::Pops::Types::Iterator.new(Puppet::Pops::Types::PIntegerType::DEFAULT, [1,2,3]).reverse_each

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

@@ -8,19 +8,19 @@ describe 'the type asserter' do
   context 'when deferring formatting of subject'
   it 'can use an array' do
     expect{ asserter.assert_instance_of(['The %s in the %s', 'gizmo', 'gadget'], PIntegerType::DEFAULT, 'lens') }.to(
-    raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'can use an array obtained from block' do
     expect do
       asserter.assert_instance_of('gizmo', PIntegerType::DEFAULT, 'lens') { |s| ['The %s in the %s', s, 'gadget'] }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'can use an subject obtained from zero argument block' do
     expect do
       asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 'lens') { 'The gizmo in the gadget' }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'does not produce a string unless the assertion fails' do

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

@@ -214,6 +214,12 @@ describe 'The type calculator' do
       end
     end
 
+    context 'binary' do
+      it 'translates to PBinaryType' do
+        expect(calculator.infer(PBinaryType::Binary.from_binary_string("binary")).class).to eq(PBinaryType)
+      end
+    end
+
     context 'version' do
       it 'translates to PVersionType' do
         expect(calculator.infer(Semantic::Version.new(1,0,0)).class).to eq(PSemVerType)
@@ -233,6 +239,34 @@ describe 'The type calculator' do
       end
     end
 
+    context 'timespan' do
+      it 'translates to PTimespanType' do
+        expect(calculator.infer(Time::Timespan.from_fields_hash('days' => 2))).to be_a(PTimespanType)
+      end
+
+      it 'translates to a limited PTimespanType by infer_set' do
+        ts = Time::Timespan.from_fields_hash('days' => 2)
+        t = calculator.infer_set(ts)
+        expect(t.class).to eq(PTimespanType)
+        expect(t.from).to be(ts)
+        expect(t.to).to be(ts)
+      end
+    end
+
+    context 'timestamp' do
+      it 'translates to PTimespanType' do
+        expect(calculator.infer(Time::Timestamp.now)).to be_a(PTimestampType)
+      end
+
+      it 'translates to a limited PTimespanType by infer_set' do
+        ts = Time::Timestamp.now
+        t = calculator.infer_set(ts)
+        expect(t.class).to eq(PTimestampType)
+        expect(t.from).to be(ts)
+        expect(t.to).to be(ts)
+      end
+    end
+
     context 'array' do
       it 'translates to PArrayType' do
         expect(calculator.infer([1,2]).class).to eq(PArrayType)
@@ -559,6 +593,24 @@ describe 'The type calculator' do
         expect(common_t.param_types.class).to be(PTupleType)
         expect(common_t.block_type).to eql(callable_t(scalar_t))
       end
+
+      it 'return_type is included in the check (incompatible return_type)' do
+        t1 = callable_t([String], String)
+        t2 = callable_t([String], Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(PCallableType)
+        expect(common_t.param_types).to be_nil
+        expect(common_t.return_type).to be_nil
+      end
+
+      it 'return_type is included in the check (compatible return_type)' do
+        t1 = callable_t([String], Numeric)
+        t2 = callable_t([String], Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(PCallableType)
+        expect(common_t.param_types).to be_a(PTupleType)
+        expect(common_t.return_type).to eql(PNumericType::DEFAULT)
+      end
     end
   end
 
@@ -864,6 +916,34 @@ describe 'The type calculator' do
       end
     end
 
+    context 'for Timespan such that' do
+      it 'Timespan is assignable to less constrained Timespan' do
+        t1 = PTimespanType.new('00:00:10', '00:00:20')
+        t2 = PTimespanType.new('00:00:11', '00:00:19')
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Timespan is not assignable to more constrained Timespan' do
+        t1 = PTimespanType.new('00:00:10', '00:00:20')
+        t2 = PTimespanType.new('00:00:11', '00:00:19')
+        expect(t1).not_to be_assignable_to(t2)
+      end
+    end
+
+    context 'for Timestamp such that' do
+      it 'Timestamp is assignable to less constrained Timestamp' do
+        t1 = PTimestampType.new('2016-01-01', '2016-12-31')
+        t2 = PTimestampType.new('2016-02-01', '2016-11-30')
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Timestamp is not assignable to more constrained Timestamp' do
+        t1 = PTimestampType.new('2016-01-01', '2016-12-31')
+        t2 = PTimestampType.new('2016-02-01', '2016-11-30')
+        expect(t1).not_to be_assignable_to(t2)
+      end
+    end
+
     context 'for Tuple, such that' do
       it 'Tuple is not assignable to any other non Array based Collection type' do
         t = PTupleType::DEFAULT
@@ -875,8 +955,8 @@ describe 'The type calculator' do
       end
 
       it 'A tuple with parameters is assignable to the default Tuple' do
-        t = Puppet::Pops::Types::PTupleType::DEFAULT
-        t2 = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PStringType::DEFAULT])
+        t = PTupleType::DEFAULT
+        t2 = PTupleType.new([PStringType::DEFAULT])
         expect(t2).to be_assignable_to(t)
       end
 
@@ -967,11 +1047,39 @@ describe 'The type calculator' do
       end
 
       it 'a callable with parameter is assignable to the default callable' do
-        expect(callable_t(string_t)).to be_assignable_to(Puppet::Pops::Types::PCallableType::DEFAULT)
+        expect(callable_t(string_t)).to be_assignable_to(PCallableType::DEFAULT)
       end
 
       it 'the default callable is not assignable to a callable with parameter' do
-        expect(Puppet::Pops::Types::PCallableType::DEFAULT).not_to be_assignable_to(callable_t(string_t))
+        expect(PCallableType::DEFAULT).not_to be_assignable_to(callable_t(string_t))
+      end
+
+      it 'a callable with a return type is assignable to the default callable' do
+        expect(callable_t([], string_t)).to be_assignable_to(PCallableType::DEFAULT)
+      end
+
+      it 'the default callable is not assignable to a callable with a return type' do
+        expect(PCallableType::DEFAULT).not_to be_assignable_to(callable_t([],string_t))
+      end
+
+      it 'a callable with a return type Any is assignable to the default callable' do
+        expect(callable_t([], object_t)).to be_assignable_to(PCallableType::DEFAULT)
+      end
+
+      it 'a callable with a return type Any is equal to a callable with the same parameters and no return type' do
+        expect(callable_t([string_t], object_t)).to eql(callable_t(string_t))
+      end
+
+      it 'a callable with a return type different than Any is not equal to a callable with the same parameters and no return type' do
+        expect(callable_t([string_t], string_t)).not_to eql(callable_t(string_t))
+      end
+
+      it 'a callable with a return type is assignable from another callable with an assignable return type' do
+        expect(callable_t([], string_t)).to be_assignable_to(callable_t([], PScalarType::DEFAULT))
+      end
+
+      it 'a callable with a return type is not assignable from another callable unless the return type is assignable' do
+        expect(callable_t([], string_t)).not_to be_assignable_to(callable_t([], integer_t))
       end
     end
 
@@ -1720,7 +1828,7 @@ describe 'The type calculator' do
       it 'a Closure should be considered a Callable' do
         factory = Model::Factory
         params = [factory.PARAM('a')]
-        the_block = factory.LAMBDA(params,factory.literal(42))
+        the_block = factory.LAMBDA(params,factory.literal(42), nil)
         the_closure = Evaluator::Closure::Dynamic.new(:fake_evaluator, the_block, :fake_scope)
         expect(calculator.instance?(all_callables_t, the_closure)).to be_truthy
         expect(calculator.instance?(callable_t(object_t), the_closure)).to be_truthy

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

@@ -178,6 +178,38 @@ end
       expect(s.string(f.iterator(f.integer))).to eq('Iterator[Integer]')
     end
 
+    it "should yield 'Timespan' for PTimespanType" do
+      expect(s.string(f.timespan())).to eq('Timespan')
+    end
+
+    it "should yield 'Timespan[{hours => 1}] for PTimespanType[Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}))).to eq("Timespan['0-01:00:00.0']")
+    end
+
+    it "should yield 'Timespan[default, {hours => 2}] for PTimespanType[nil, Timespan]" do
+      expect(s.string(f.timespan(nil, {'hours' => 2}))).to eq("Timespan[default, '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timespan[{hours => 1}, {hours => 2}] for PTimespanType[Timespan, Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}, {'hours' => 2}))).to eq("Timespan['0-01:00:00.0', '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timestamp' for PTimestampType" do
+      expect(s.string(f.timestamp())).to eq('Timestamp')
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC'] for PTimestampType[Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp[default, '2016-09-05T13:00:00.000 UTC'] for PTimestampType[nil, Timestamp]" do
+      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'] for PTimestampType[Timestamp, Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC']")
+    end
+
     it "should yield 'Tuple[Integer]' for PTupleType[PIntegerType]" do
       expect(s.string(f.tuple([f.integer]))).to eq('Tuple[Integer]')
     end
@@ -269,10 +301,18 @@ end
       expect(s.string(f.callable)).to eql('Callable[0, 0]')
     end
 
+    it "should yield 'Callable[[0,0],rt]' for callable without params but with return type" do
+      expect(s.string(f.callable([], Float))).to eql('Callable[[0, 0], Float]')
+    end
+
     it "should yield 'Callable[t,t]' for callable with typed parameters" do
       expect(s.string(f.callable(String, Integer))).to eql('Callable[String, Integer]')
     end
 
+    it "should yield 'Callable[[t,t],rt]' for callable with typed parameters and return type" do
+      expect(s.string(f.callable([String, Integer], Float))).to eql('Callable[[String, Integer], Float]')
+    end
+
     it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
       expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0, default]')
     end

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

@@ -112,84 +112,95 @@ describe 'the type mismatch describer' do
        /parameter 'evars' expects a match for EVariants = Enum\['a', 'b', 'c', 'd'\], got 'n'/))
   end
 
+  it "will not generalize a string that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums('c')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums(Sensitive('c'))
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
+  it "will not generalize a string that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => 'c' }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => Sensitive('c') }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
   context 'when reporting a mismatch between' do
-    let(:parser) { TypeParser.new }
+    let(:parser) { TypeParser.singleton }
     let(:subject) { TypeMismatchDescriber.singleton }
 
     context 'hash and struct' do
       it 'reports a size mismatch when hash has unlimited size' do
         expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
         actual = parser.parse('Hash[String,Integer]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq('expected size to be 2, got unlimited')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got unlimited')
       end
 
       it 'reports a size mismatch when hash has specified but incorrect size' do
         expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
         actual = parser.parse('Hash[String,Integer,1,1]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq('expected size to be 2, got 1')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got 1')
       end
 
       it 'reports a full type mismatch when size is correct but hash value type is incorrect' do
         expected = parser.parse('Struct[{a=>Integer,b=>String}]')
         actual = parser.parse('Hash[String,Integer,2,2]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq("expected a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
+        expect(subject.describe_mismatch('', expected, actual)).to eq("expects a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
       end
     end
-  end
 
-  context 'when using present tense' do
-    let(:parser) { TypeParser.singleton }
-    let(:subject) { TypeMismatchDescriber.singleton }
     it 'reports a missing parameter as "has no parameter"' do
       t = parser.parse('Struct[{a=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false, :present) }.to raise_error(Puppet::Error, "v: has no parameter named 'b'")
+      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false) }.to raise_error(Puppet::Error, "v: has no parameter named 'b'")
     end
 
     it 'reports a missing value as "expects a value"' do
       t = parser.parse('Struct[{a=>String,b=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false, :present) }.to raise_error(Puppet::Error, "v: expects a value for parameter 'b'")
+      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false) }.to raise_error(Puppet::Error, "v: expects a value for parameter 'b'")
     end
 
     it 'reports a missing block as "expects a block"' do
       callable = parser.parse('Callable[String,String,Callable]')
       args_tuple = parser.parse('Tuple[String,String]')
       dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :present)).to eq("'function' expects a block")
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' expects a block")
     end
 
     it 'reports an unexpected block as "does not expect a block"' do
       callable = parser.parse('Callable[String,String]')
       args_tuple = parser.parse('Tuple[String,String,Callable]')
       dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :present)).to eq("'function' does not expect a block")
-    end
-  end
-
-  context 'when using past tense' do
-    let(:parser) { TypeParser.singleton }
-    let(:subject) { TypeMismatchDescriber.singleton }
-    it 'reports a missing parameter as "did not have a parameter"' do
-      t = parser.parse('Struct[{a=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false, :past) }.to raise_error(Puppet::Error, "v: did not have a parameter named 'b'")
-    end
-
-    it 'reports a missing value as "expected a value"' do
-      t = parser.parse('Struct[{a=>String,b=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false, :past) }.to raise_error(Puppet::Error, "v: expected a value for parameter 'b'")
-    end
-
-    it 'reports a missing block as "expected a block"' do
-      callable = parser.parse('Callable[String,String,Callable]')
-      args_tuple = parser.parse('Tuple[String,String]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :past)).to eq("'function' expected a block")
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' does not expect a block")
     end
 
-    it 'reports an unexpected block as "did not expect a block"' do
-      callable = parser.parse('Callable[String,String]')
-      args_tuple = parser.parse('Tuple[String,String,Callable]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :past)).to eq("'function' did not expect a block")
+    it 'reports a block return type mismatch' do
+      callable = parser.parse('Callable[[0,0,Callable[ [0,0],String]],Undef]')
+      args_tuple = parser.parse('Tuple[Callable[[0,0],Integer]]')
+      dispatch = Functions::Dispatch.new(callable, 'foo', [], 'block', nil, nil, false)
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
     end
   end
 end