puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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

@@ -41,8 +41,8 @@ describe 'The type factory' do
       expect(TypeFactory.scalar().class()).to eq(PScalarType)
     end
 
-    it 'data() returns PDataType' do
-      expect(TypeFactory.data().class()).to eq(PDataType)
+    it 'data() returns Data' do
+      expect(TypeFactory.data.name).to eq('Data')
     end
 
     it 'optional() returns POptionalType' do
@@ -163,24 +163,24 @@ describe 'The type factory' do
       expect(at.element_type.class).to eq(PIntegerType)
     end
 
-    it 'array_of_data returns PArrayType[PDataType]' do
+    it 'array_of_data returns Array[Data]' do
       at = TypeFactory.array_of_data
       expect(at.class()).to eq(PArrayType)
-      expect(at.element_type.class).to eq(PDataType)
+      expect(at.element_type.name).to eq('Data')
     end
 
-    it 'hash_of_data returns PHashType[PScalarType,PDataType]' do
+    it 'hash_of_data returns Hash[String,Data]' do
       ht = TypeFactory.hash_of_data
       expect(ht.class()).to eq(PHashType)
-      expect(ht.key_type.class).to eq(PScalarType)
-      expect(ht.value_type.class).to eq(PDataType)
+      expect(ht.key_type.class).to eq(PStringType)
+      expect(ht.value_type.name).to eq('Data')
     end
 
-    it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
+    it 'ruby(1) returns PRuntimeType[ruby, \'Integer\']' do
       ht = TypeFactory.ruby(1)
       expect(ht.class()).to eq(PRuntimeType)
       expect(ht.runtime).to eq(:ruby)
-      expect(ht.runtime_type_name).to eq('Fixnum')
+      expect(ht.runtime_type_name).to eq(1.class.name)
     end
 
     it 'a size constrained collection can be created from array' do

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

@@ -38,9 +38,13 @@ describe 'The type formatter' do
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]})).to eq(<<-FORMATTED)
 {
   'a' => 32,
-  'b' => [1, 2, {
-    'c' => 'd'
-  }]
+  'b' => [
+    1,
+    2,
+    {
+      'c' => 'd'
+    }
+  ]
 }
 FORMATTED
     end
@@ -49,9 +53,13 @@ FORMATTED
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 3)).to eq(<<-FORMATTED)
       {
         'a' => 32,
-        'b' => [1, 2, {
-          'c' => 'd'
-        }]
+        'b' => [
+          1,
+          2,
+          {
+            'c' => 'd'
+          }
+        ]
       }
 FORMATTED
     end
@@ -60,13 +68,17 @@ FORMATTED
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 2, 4)).to eq(<<-FORMATTED)
         {
             'a' => 32,
-            'b' => [1, 2, {
-                'c' => 'd'
-            }]
+            'b' => [
+                1,
+                2,
+                {
+                    'c' => 'd'
+                }
+            ]
         }
-    FORMATTED
+FORMATTED
+    end
   end
-end
 
   context 'when representing the type as string' do
     include_context 'types_setup'
@@ -87,7 +99,7 @@ end
       expect(s.string(f.boolean)).to eq('Boolean')
     end
 
-    it "should yield 'Data' for PDataType" do
+    it "should yield 'Data' for the Data type" do
       expect(s.string(f.data)).to eq('Data')
     end
 
@@ -138,8 +150,8 @@ end
       expect(s.string(f.array_of(f.integer))).to eq('Array[Integer]')
     end
 
-    it "should yield 'Array' for PArrayType::DATA" do
-      expect(s.string(f.array_of_data)).to eq('Array')
+    it "should yield 'Array' for PArrayType::DEFAULT" do
+      expect(s.string(f.array_of_any)).to eq('Array')
     end
 
     it "should yield 'Array[0, 0]' for an empty array" do
@@ -203,15 +215,16 @@ end
     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']")
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000000000 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']")
+      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000000000 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']")
+      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.000000000 UTC', '2016-12-01T00:00:00.000000000 UTC']"))
     end
 
     it "should yield 'Tuple[Integer]' for PTupleType[PIntegerType]" do
@@ -248,8 +261,8 @@ end
       expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
     end
 
-    it "should yield 'Hash' for PHashType::DATA" do
-      expect(s.string(f.hash_of_data)).to eq('Hash')
+    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

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

@@ -168,15 +168,6 @@ 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 }

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

@@ -54,12 +54,12 @@ describe TypeParser do
     expect(the_type_parsed_from(types.default)).to be_the_type(types.default)
   end
 
-  it "interprets an unparameterized Array as an Array of Data" do
-    expect(parser.parse("Array")).to be_the_type(types.array_of_data)
+  it "interprets an unparameterized Array as an Array of Any" do
+    expect(parser.parse("Array")).to be_the_type(types.array_of_any)
   end
 
-  it "interprets an unparameterized Hash as a Hash of Scalar to Data" do
-    expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
+  it "interprets an unparameterized Hash as a Hash of Any, Any" do
+    expect(parser.parse("Hash")).to be_the_type(types.hash_of_any)
   end
 
   it "interprets a parameterized Array[0, 0] as an empty hash with no key and value type" do
@@ -223,11 +223,11 @@ describe TypeParser do
 
   context 'without a scope' do
     it "interprets anything that is not a built in type to be a type reference" do
-      expect(parser.parse('File')).to eq(types.type_reference('File'))
+      expect(parser.parse('TestType')).to eq(types.type_reference('TestType'))
     end
 
     it "interprets anything that is not a built in type with parameterers to be type reference with parameters" do
-      expect(parser.parse("File['/tmp/foo']")).to eq(types.type_reference("File['/tmp/foo']"))
+      expect(parser.parse("TestType['/tmp/foo']")).to eq(types.type_reference("TestType['/tmp/foo']"))
     end
   end
 

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

@@ -352,13 +352,35 @@ describe 'Puppet Type System' do
     end
 
     it 'can be created with a runtime and, puppet name pattern, and runtime replacement' do
-      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, \"MyModule::\\\\1\"]]")
+      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, 'MyModule::\\1']]")
     end
 
     it 'will map a Puppet name to a runtime type' do
       t = tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1'])
       expect(t.from_puppet_name('MyPackage::MyType').to_s).to eq("Runtime[ruby, 'MyModule::MyType']")
     end
+
+    it 'with parameters is assignable to the default Runtime type' do
+      code = <<-CODE
+      notice(Runtime[ruby, 'Symbol'] < Runtime)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'with parameters is not assignable from the default Runtime type' do
+      code = <<-CODE
+      notice(Runtime < Runtime[ruby, 'Symbol'])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false'])
+    end
+
+    it 'default is assignable to itself' do
+      code = <<-CODE
+      notice(Runtime < Runtime)
+      notice(Runtime <= Runtime)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'true'])
+    end
   end
 
   context 'Type aliases' do
@@ -439,7 +461,7 @@ describe 'Puppet Type System' do
       type Foo = Variant[Foo,String,Integer]
       assert_type(Foo, /x/)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(/expects a value of type String or Integer, got Regexp/)
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Foo = Variant\[String, Integer\] value, got Regexp/)
     end
 
     it 'will handle a scalar correctly in combinations of nested aliased variants' do
@@ -605,6 +627,24 @@ describe 'Puppet Type System' do
       end
     end
   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
+      end
+    end
+
+    it 'is supported by Integer' do
+      int_type = tf.integer.class.create(0, 32)
+      expect(int_type).to eq(tf.range(0, 32))
+    end
+
+    it 'is supported by Regexp' do
+      rx_type = tf.regexp.class.create('[a-z]+')
+      expect(rx_type).to eq(tf.regexp(/[a-z]+/))
+    end
+  end
 end
 end
 end

data/spec/unit/pops/validator/validator_spec.rb

@@ -11,8 +11,8 @@ describe "validating 4x" do
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
   let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
 
-  def validate(model)
-    validator.validate(model)
+  def validate(factory)
+    validator.validate(factory.model)
     acceptor
   end
 
@@ -56,20 +56,6 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
-
-    it 'produces a warning for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
-    it 'produces a warning for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
   end
 
   context 'with --strict set to warning' do
@@ -81,20 +67,6 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a warning for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
-    it 'produces a warning for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
     it 'produces a warning for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
       expect(acceptor.warning_count).to eql(1)
@@ -108,7 +80,6 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
-
   end
 
   context 'with --strict set to error' do
@@ -120,20 +91,6 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces an error for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
-      expect(acceptor.warning_count).to eql(0)
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
-    it 'produces an error for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
-      expect(acceptor.warning_count).to eql(0)
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
     it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
       expect(acceptor.warning_count).to eql(0)
@@ -141,6 +98,13 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
+    it 'does not produce an error for regular class resource' do
+      acceptor = validate(parse('class { test: }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).not_to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
+
     it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
       expect(acceptor.warning_count).to eql(0)
@@ -157,19 +121,21 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+  end
 
-    it 'does not produce an error for duplicate default in a case expression' do
+  context 'irrespective of --strict' do
+    it 'produces an error for duplicate default in a case expression' do
       acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
       expect(acceptor.warning_count).to eql(0)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
-    it 'does not produce an error for duplicate default in a selector expression' do
+    it 'produces an error for duplicate default in a selector expression' do
       acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
       expect(acceptor.warning_count).to eql(0)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
     it 'produces a warning for virtual class resource' do
@@ -312,30 +278,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for future reserved words' do
-    ['application', 'produces', 'consumes'].each do |word|
-      it "produces an issue for the word '#{word}'" do
-        source = "$a = #{word}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces a warning issue when used as a class name' do
-        source = "class #{word} {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces no warning or error when used as a parameter name' do
-        source = "define foo($#{word}) { notice $#{word} }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-
-      it 'produces no warning or error when used as an attribute name' do
-        source = "foo { bar: #{word} => ok }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-    end
-  end
-
   context 'for reserved type names' do
     [# type/Type, is a reserved name but results in syntax error because it is a keyword in lower case form
     'any',
@@ -606,9 +548,6 @@ describe "validating 4x" do
   end
 
   context "capability annotations" do
-    before(:each) { Puppet[:app_management] = true }
-    after(:each) { Puppet[:app_management] = false }
-
     ['produces', 'consumes'].each do |word|
       it "rejects illegal resource types in #{word} clauses" do
         expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
@@ -625,17 +564,17 @@ describe "validating 4x" do
     end
   end
 
-  context 'uses a var pattern that is performant' do
-    it 'such that illegal VAR_NAME is not too slow' do
-      t = Time.now.nsec
-      result = '$hg_oais::archivematica::requirements::automation_tools::USER' =~ Puppet::Pops::Patterns::VAR_NAME
-      t2 = Time.now.nsec
-      expect(result).to be(nil)
-      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond 
+  context 'literal values' do
+    it 'rejects a literal integer outside of max signed 64 bit range' do
+      expect(validate(parse("0x8000000000000000"))).to have_issue(Puppet::Pops::Issues::NUMERIC_OVERFLOW)
+    end
+
+    it 'rejects a literal integer outside of min signed 64 bit range' do
+      expect(validate(parse("-0x8000000000000001"))).to have_issue(Puppet::Pops::Issues::NUMERIC_OVERFLOW)
     end
   end
 
   def parse(source)
-    Puppet::Pops::Parser::Parser.new().parse_string(source)
+    Puppet::Pops::Parser::Parser.new.parse_string(source)
   end
 end