puppet 5.0.0 → 6.0.0

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

@@ -19,7 +19,7 @@ describe 'The type formatter' do
     {
       'true' => true,
       'false' => false,
-      '?' => nil,
+      'undef' => nil,
       '23.4' => 23.4,
       '145' => 145,
       "'string'" => 'string',
@@ -83,7 +83,7 @@ FORMATTED
   context 'when representing the type as string' do
     include_context 'types_setup'
 
-    it "should yield 'Type' for PType" do
+    it "should yield 'Type' for PTypeType" do
       expect(s.string(f.type_type)).to eq('Type')
     end
 
@@ -99,6 +99,14 @@ FORMATTED
       expect(s.string(f.boolean)).to eq('Boolean')
     end
 
+    it "should yield 'Boolean[true]' for PBooleanType parameterized with true" do
+      expect(s.string(f.boolean(true))).to eq('Boolean[true]')
+    end
+
+    it "should yield 'Boolean[false]' for PBooleanType parameterized with false" do
+      expect(s.string(f.boolean(false))).to eq('Boolean[false]')
+    end
+
     it "should yield 'Data' for the Data type" do
       expect(s.string(f.data)).to eq('Data')
     end
@@ -112,7 +120,7 @@ FORMATTED
       expect(s.string(f.range(1,1))).to eq('Integer[1, 1]')
       expect(s.string(f.range(1,2))).to eq('Integer[1, 2]')
       expect(s.string(f.range(:default, 2))).to eq('Integer[default, 2]')
-      expect(s.string(f.range(2, :default))).to eq('Integer[2, default]')
+      expect(s.string(f.range(2, :default))).to eq('Integer[2]')
     end
 
     it "should yield 'Float' for PFloatType" do
@@ -142,8 +150,8 @@ FORMATTED
     it "should yield 'String' and from/to for PStringType" do
       expect(s.string(f.string(f.range(1,1)))).to eq('String[1, 1]')
       expect(s.string(f.string(f.range(1,2)))).to eq('String[1, 2]')
-      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[default, 2]')
-      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2, default]')
+      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[0, 2]')
+      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2]')
     end
 
     it "should yield 'Array[Integer]' for PArrayType[PIntegerType]" do
@@ -167,15 +175,15 @@ FORMATTED
     it "should yield 'Collection' and from/to for PCollectionType" do
       expect(s.string(f.collection(f.range(1,1)))).to eq('Collection[1, 1]')
       expect(s.string(f.collection(f.range(1,2)))).to eq('Collection[1, 2]')
-      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[default, 2]')
-      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2, default]')
+      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[0, 2]')
+      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2]')
     end
 
     it "should yield 'Array' and from/to for PArrayType" do
       expect(s.string(f.array_of(f.string, f.range(1,1)))).to eq('Array[String, 1, 1]')
       expect(s.string(f.array_of(f.string, f.range(1,2)))).to eq('Array[String, 1, 2]')
-      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, default, 2]')
-      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2, default]')
+      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, 0, 2]')
+      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2]')
     end
 
     it "should yield 'Iterable' for PIterableType" do
@@ -240,7 +248,7 @@ FORMATTED
       expect(s.string(f.tuple(types, f.range(1,1)))).to eq('Tuple[String, 1, 1]')
       expect(s.string(f.tuple(types, f.range(1,2)))).to eq('Tuple[String, 1, 2]')
       expect(s.string(f.tuple(types, f.range(:default, 2)))).to eq('Tuple[String, 0, 2]')
-      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2, default]')
+      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2]')
     end
 
     it "should yield 'Struct' and details for PStructType" do
@@ -257,19 +265,19 @@ FORMATTED
     it "should yield 'Hash' and from/to for PHashType" do
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,1)))).to eq('Hash[String, String, 1, 1]')
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,2)))).to eq('Hash[String, String, 1, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, default, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, 0, 2]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2]')
     end
 
     it "should yield 'Hash' for PHashType::DEFAULT" do
       expect(s.string(f.hash_of_any)).to eq('Hash')
     end
 
-    it "should yield 'Class' for a PHostClassType" do
+    it "should yield 'Class' for a PClassType" do
       expect(s.string(f.host_class)).to eq('Class')
     end
 
-    it "should yield 'Class[x]' for a PHostClassType[x]" do
+    it "should yield 'Class[x]' for a PClassType[x]" do
       expect(s.string(f.host_class('x'))).to eq('Class[x]')
     end
 
@@ -290,6 +298,16 @@ FORMATTED
       expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
     end
 
+    it "should yield 'Enum[s,...]' for a PEnumType[s,...,false]" do
+      t = f.enum('a', 'b', 'c', false)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
+    end
+
+    it "should yield 'Enum[s,...,true]' for a PEnumType[s,...,true]" do
+      t = f.enum('a', 'b', 'c', true)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c', true]")
+    end
+
     it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
       t = f.pattern('a')
       t2 = f.pattern('a', 'b', 'c')
@@ -331,7 +349,7 @@ FORMATTED
     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]')
+      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0]')
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
@@ -341,7 +359,7 @@ FORMATTED
     it "should yield 'Callable[min,max]' callable with size > 0" do
       expect(s.string(f.callable(0, 0))).to eql('Callable[0, 0]')
       expect(s.string(f.callable(0, 1))).to eql('Callable[0, 1]')
-      expect(s.string(f.callable(0, :default))).to eql('Callable[0, default]')
+      expect(s.string(f.callable(0, :default))).to eql('Callable[0]')
     end
 
     it "should yield 'Callable[Callable]' for callable with block" do
@@ -397,12 +415,12 @@ FORMATTED
     end
 
     it 'should present a valid simple name' do
-      (all_types - [PType, PHostClassType]).each do |t|
+      (all_types - [PTypeType, PClassType]).each do |t|
         name = t::DEFAULT.simple_name
         expect(t.name).to match("^Puppet::Pops::Types::P#{name}Type$")
       end
-      expect(PType::DEFAULT.simple_name).to eql('Type')
-      expect(PHostClassType::DEFAULT.simple_name).to eql('Class')
+      expect(PTypeType::DEFAULT.simple_name).to eql('Type')
+      expect(PClassType::DEFAULT.simple_name).to eql('Class')
     end
   end
 end

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

@@ -168,6 +168,15 @@ describe 'the type mismatch describer' do
       /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
   end
 
+  it "will report the parameter of Type[<type alias>] using the alias name" do
+    code = <<-CODE
+      type Custom = String[1]
+      Custom.each |$x| { notice($x) }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /expects an Iterable value, got Type\[Custom\]/))
+  end
+
   context 'when reporting a mismatch between' do
     let(:parser) { TypeParser.singleton }
     let(:subject) { TypeMismatchDescriber.singleton }
@@ -223,6 +232,18 @@ describe 'the type mismatch describer' do
       expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
     end
   end
+
+  it "reports struct mismatch correctly when hash doesn't contain required keys" do
+    code = <<-PUPPET
+      type Test::Options = Struct[{
+        var => String
+      }]
+      class test(String $var, Test::Options $opts) {}
+      class { 'test': var => 'hello', opts => {} }
+    PUPPET
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
+  end
 end
 end
 end

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

@@ -30,8 +30,13 @@ describe TypeParser do
       /The expression <Array\[notAType\]> is not a valid type specification/)
   end
 
+  it "rejects an unknown type parameter in a variant" do
+    expect { parser.parse("Variant[Integer,'not a type']") }.to raise_error(Puppet::ParseError,
+      /The expression <Variant\[Integer,'not a type'\]> is not a valid type specification/)
+  end
+
   [
-    'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
+    'Any', 'Data', 'CatalogEntry', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
@@ -74,6 +79,18 @@ describe TypeParser do
     expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
+  it 'interprets an Boolean with a true parameter to represent boolean true' do
+    expect(parser.parse('Boolean[true]')).to be_the_type(types.boolean(true))
+  end
+
+  it 'interprets an Boolean with a false parameter to represent boolean false' do
+    expect(parser.parse('Boolean[false]')).to be_the_type(types.boolean(false))
+  end
+
+  it 'does not accept non-boolean parameters' do
+    expect{parser.parse('Boolean["false"]')}.to raise_error(/Boolean parameter must be true or false/)
+  end
+
   it 'interprets an Integer with one parameter to have unbounded upper range' do
     expect(parser.parse('Integer[0]')).to eq(parser.parse('Integer[0,default]'))
   end
@@ -155,7 +172,7 @@ describe TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
-    let(:loader) { Object.new }
+    let(:loader) { mock }
 
     before :each do
       Adapters::LoaderAdapter.expects(:loader_for_model_object).returns loader
@@ -371,6 +388,26 @@ describe TypeParser do
     expect(t.type_string).to eql('Nonesuch[{a=>undef,b=>true,c=>false,d=>default,e=>"string",f=>0,g=>1.0,h=>[1,2,3]}]')
   end
 
+  it 'parses a parameterized Enum using identifiers' do
+    t = parser.parse('Enum[a, b]')
+    expect(t).to be_a(PEnumType)
+    expect(t.to_s).to eql("Enum['a', 'b']")
+  end
+
+  it 'parses a parameterized Enum using strings' do
+    t = parser.parse("Enum['a', 'b']")
+    expect(t).to be_a(PEnumType)
+    expect(t.to_s).to eql("Enum['a', 'b']")
+  end
+
+  it 'rejects a parameterized Enum using type refs' do
+    expect { parser.parse('Enum[A, B]') }.to raise_error(/Enum parameters must be identifiers or strings/)
+  end
+
+  it 'rejects a parameterized Enum using integers' do
+    expect { parser.parse('Enum[1, 2]') }.to raise_error(/Enum parameters must be identifiers or strings/)
+  end
+
   matcher :be_the_type do |type|
     calc = TypeCalculator.new
 

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

@@ -153,6 +153,40 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'Boolean type' do
+    it 'parameterized type is assignable to base type' do
+      code = <<-CODE
+        notice(Boolean[true] < Boolean)
+        notice(Boolean[false] < Boolean)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are instances of the base type' do
+      code = <<-CODE
+        notice(true =~ Boolean)
+        notice(false =~ Boolean)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are instances of type parameterized with the same literal' do
+      code = <<-CODE
+        notice(true =~ Boolean[true])
+        notice(false =~ Boolean[false])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'boolean literals are not instances of type parameterized with a different literal' do
+      code = <<-CODE
+        notice(true =~ Boolean[false])
+        notice(false =~ Boolean[true])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
+    end
+  end
+
   context 'Enum type' do
     it 'sorts its entries' do
       code = <<-CODE
@@ -167,6 +201,22 @@ describe 'Puppet Type System' do
       CODE
       expect(eval_and_collect_notices(code)).to eq(['a', 'b', 'c'])
     end
+
+    it 'is case sensitive by default' do
+      code = <<-CODE
+        notice('A' =~ Enum[a,b])
+        notice('a' =~ Enum[a,b])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'true'])
+    end
+
+    it 'is case insensitive when last parameter argument is true' do
+      code = <<-CODE
+        notice('A' =~ Enum[a,b,true])
+        notice('a' =~ Enum[a,b,true])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
   end
 
   context 'Iterable type' do
@@ -291,6 +341,8 @@ describe 'Puppet Type System' do
     let!(:mix_ints) { tf.variant(overlapping_ints, adjacent_ints) }
     let!(:overlapping_floats) { tf.variant(tf.float_range(10.0, 20.0), tf.float_range(18.0, 28.0)) }
     let!(:enums) { tf.variant(tf.enum('a', 'b'), tf.enum('b', 'c')) }
+    let!(:enums_s_is) { tf.variant(tf.enum('a', 'b'), tf.enum('b', 'c', true)) }
+    let!(:enums_is_is) { tf.variant(tf.enum('A', 'b', true), tf.enum('B', 'c', true)) }
     let!(:patterns) { tf.variant(tf.pattern('a', 'b'), tf.pattern('b', 'c')) }
     let!(:with_undef) { tf.variant(tf.undef, tf.range(1,10)) }
     let!(:all_optional) { tf.variant(tf.optional(tf.range(1,10)), tf.optional(tf.range(11,20))) }
@@ -317,6 +369,14 @@ describe 'Puppet Type System' do
         expect(enums.normalize).to eq(tf.enum('a', 'b', 'c'))
       end
 
+      it 'are case sensitive versus case insensitive enums, does not merge the enums' do
+        expect(enums_s_is.normalize).to eq(enums_s_is)
+      end
+
+      it 'are case insensitive enums, result is case insensitive and unique irrespective of case' do
+        expect(enums_is_is.normalize).to eq(tf.enum('a', 'b', 'c', true))
+      end
+
       it 'are patterns, the result is a pattern' do
         expect(patterns.normalize).to eq(tf.pattern('a', 'b', 'c'))
       end
@@ -570,19 +630,19 @@ describe 'Puppet Type System' do
   context 'instantiation via new_function is supported by' do
     let(:loader) { Loader::BaseLoader.new(nil, "types_unit_test_loader") }
     it 'Integer' do
-      func_class = tf.integer.new_function(loader)
+      func_class = tf.integer.new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
 
     it 'Optional[Integer]' do
-      func_class = tf.optional(tf.integer).new_function(loader)
+      func_class = tf.optional(tf.integer).new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
 
     it 'Regexp' do
-      func_class = tf.regexp.new_function(loader)
+      func_class = tf.regexp.new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
@@ -593,19 +653,22 @@ describe 'Puppet Type System' do
 
       it 'Any, Scalar, Collection' do
         [tf.any, tf.scalar, tf.collection ].each do |t|
-        expect { t.new_function(loader)
+        expect { t.new_function
         }.to raise_error(ArgumentError, /Creation of new instance of type '#{t.to_s}' is not supported/)
       end
     end
   end
 
   context 'instantiation via ruby create function' do
-    around(:each) do |example|
-      Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
-        example.run
+    before(:each) do
+      Puppet.push_context(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
       end
     end
 
+    after(:each) do
+      Puppet.pop_context()
+    end
+
     it 'is supported by Integer' do
       int = tf.integer.create('32')
       expect(int).to eq(32)
@@ -629,12 +692,15 @@ describe 'Puppet Type System' do
   end
 
   context 'creation of parameterized type via ruby create function on class' do
-    around(:each) do |example|
-      Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
-        example.run
+    before(:each) do
+      Puppet.push_context(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
       end
     end
 
+    after(:each) do
+      Puppet.pop_context()
+    end
+
     it 'is supported by Integer' do
       int_type = tf.integer.class.create(0, 32)
       expect(int_type).to eq(tf.range(0, 32))
@@ -645,6 +711,18 @@ describe 'Puppet Type System' do
       expect(rx_type).to eq(tf.regexp(/[a-z]+/))
     end
   end
+
+  context 'backward compatibility' do
+    it 'PTypeType can be accessed from PType' do
+      # should appoint the exact same instance
+      expect(PType).to equal(PTypeType)
+    end
+
+    it 'PClassType can be accessed from PHostClassType' do
+      # should appoint the exact same instance
+      expect(PHostClassType).to equal(PClassType)
+    end
+  end
 end
 end
 end