puppet 4.3.2 → 4.4.0

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

@@ -0,0 +1,241 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+module Types
+describe 'Puppet Type System' do
+  let(:tf) { TypeFactory }
+  context 'Integer type' do
+    let!(:a) { tf.range(10, 20) }
+    let!(:b) { tf.range(18, 28) }
+    let!(:c) { tf.range( 2, 12) }
+    let!(:d) { tf.range(12, 18) }
+    let!(:e) { tf.range( 8, 22) }
+    let!(:f) { tf.range( 8,  9) }
+    let!(:g) { tf.range(21, 22) }
+    let!(:h) { tf.range(30, 31) }
+    let!(:i) { tf.float_range(1.0, 30.0) }
+    let!(:j) { tf.float_range(1.0, 9.0) }
+
+    context 'when testing if ranges intersect' do
+      it 'detects an intersection when self is before its argument' do
+        expect(a.intersect?(b)).to be_truthy
+      end
+
+      it 'detects an intersection when self is after its argument' do
+        expect(a.intersect?(c)).to be_truthy
+      end
+
+      it 'detects an intersection when self covers its argument' do
+        expect(a.intersect?(d)).to be_truthy
+      end
+
+      it 'detects an intersection when self equals its argument' do
+        expect(a.intersect?(a)).to be_truthy
+      end
+
+      it 'detects an intersection when self is covered by its argument' do
+        expect(a.intersect?(e)).to be_truthy
+      end
+
+      it 'does not consider an adjacent range to be intersecting' do
+        [f, g].each {|x| expect(a.intersect?(x)).to be_falsey }
+      end
+
+      it 'does not consider an range that is apart to be intersecting' do
+        expect(a.intersect?(h)).to be_falsey
+      end
+
+      it 'does not consider an overlapping float range to be intersecting' do
+        expect(a.intersect?(i)).to be_falsey
+      end
+    end
+
+    context 'when testing if ranges are adjacent' do
+      it 'detects an adjacent type when self is after its argument' do
+        expect(a.adjacent?(f)).to be_truthy
+      end
+
+      it 'detects an adjacent type when self is before its argument' do
+        expect(a.adjacent?(g)).to be_truthy
+      end
+
+      it 'does not consider overlapping types to be adjacent' do
+        [a, b, c, d, e].each { |x| expect(a.adjacent?(x)).to be_falsey }
+      end
+
+      it 'does not consider an range that is apart to be adjacent' do
+        expect(a.adjacent?(h)).to be_falsey
+      end
+
+      it 'does not consider an adjacent float range to be adjancent' do
+        expect(a.adjacent?(j)).to be_falsey
+      end
+    end
+
+    context 'when merging ranges' do
+      it 'will merge intersecting ranges' do
+        expect(a.merge(b)).to eq(tf.range(10, 28))
+      end
+
+      it 'will merge adjacent ranges' do
+        expect(a.merge(g)).to eq(tf.range(10, 22))
+      end
+
+      it 'will not merge ranges that are apart' do
+        expect(a.merge(h)).to be_nil
+      end
+
+      it 'will not merge overlapping float ranges' do
+        expect(a.merge(i)).to be_nil
+      end
+
+      it 'will not merge adjacent float ranges' do
+        expect(a.merge(j)).to be_nil
+      end
+    end
+  end
+
+  context 'Float type' do
+    let!(:a) { tf.float_range(10.0, 20.0) }
+    let!(:b) { tf.float_range(18.0, 28.0) }
+    let!(:c) { tf.float_range( 2.0, 12.0) }
+    let!(:d) { tf.float_range(12.0, 18.0) }
+    let!(:e) { tf.float_range( 8.0, 22.0) }
+    let!(:f) { tf.float_range(30.0, 31.0) }
+    let!(:g) { tf.range(1, 30) }
+
+    context 'when testing if ranges intersect' do
+      it 'detects an intersection when self is before its argument' do
+        expect(a.intersect?(b)).to be_truthy
+      end
+
+      it 'detects an intersection when self is after its argument' do
+        expect(a.intersect?(c)).to be_truthy
+      end
+
+      it 'detects an intersection when self covers its argument' do
+        expect(a.intersect?(d)).to be_truthy
+      end
+
+      it 'detects an intersection when self equals its argument' do
+        expect(a.intersect?(a)).to be_truthy
+      end
+
+      it 'detects an intersection when self is covered by its argument' do
+        expect(a.intersect?(e)).to be_truthy
+      end
+
+      it 'does not consider an range that is apart to be intersecting' do
+        expect(a.intersect?(f)).to be_falsey
+      end
+
+      it 'does not consider an overlapping integer range to be intersecting' do
+        expect(a.intersect?(g)).to be_falsey
+      end
+    end
+
+    context 'when merging ranges' do
+      it 'will merge intersecting ranges' do
+        expect(a.merge(b)).to eq(tf.float_range(10.0, 28.0))
+      end
+
+      it 'will not merge ranges that are apart' do
+        expect(a.merge(f)).to be_nil
+      end
+
+      it 'will not merge overlapping integer ranges' do
+        expect(a.merge(g)).to be_nil
+      end
+    end
+  end
+
+  context 'Optional type' do
+    let!(:overlapping_ints) { tf.variant(tf.range(10, 20), tf.range(18, 28)) }
+    let!(:optoptopt) { tf.optional(tf.optional(tf.optional(overlapping_ints))) }
+    let!(:optnu) { tf.optional(tf.not_undef(overlapping_ints)) }
+
+    context 'when normalizing' do
+      it 'compacts optional in optional in optional to just optional' do
+        expect(optoptopt.normalize).to eq(tf.optional(tf.range(10, 28)))
+      end
+    end
+
+    it 'compacts NotUndef in Optional to just Optional' do
+      expect(optnu.normalize).to eq(tf.optional(tf.range(10, 28)))
+    end
+  end
+
+  context 'NotUndef type' do
+    let!(:nununu) { tf.not_undef(tf.not_undef(tf.not_undef(tf.any))) }
+    let!(:nuopt) { tf.not_undef(tf.optional(tf.any)) }
+
+    context 'when normalizing' do
+      it 'compacts NotUndef in NotUndef in NotUndef to just NotUndef' do
+        expect(nununu.normalize).to eq(tf.not_undef(tf.any))
+      end
+
+      it 'compacts Optional in NotUndef to just NotUndef' do
+        expect(nuopt.normalize).to eq(tf.not_undef(tf.any))
+      end
+    end
+  end
+
+  context 'Variant type' do
+    let!(:overlapping_ints) { tf.variant(tf.range(10, 20), tf.range(18, 28)) }
+    let!(:adjacent_ints) { tf.variant(tf.range(10, 20), tf.range(8, 9)) }
+    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!(: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))) }
+    let!(:groups) { tf.variant(mix_ints, overlapping_floats, enums, patterns, with_undef, all_optional) }
+
+    context 'when normalizing contained types that' do
+      it 'are overlapping ints, the result is a range' do
+        expect(overlapping_ints.normalize).to eq(tf.range(10, 28))
+      end
+
+      it 'are adjacent ints, the result is a range' do
+        expect(adjacent_ints.normalize).to eq(tf.range(8, 20))
+      end
+
+      it 'are mixed variants with adjacent and overlapping ints, the result is a range' do
+        expect(mix_ints.normalize).to eq(tf.range(8, 28))
+      end
+
+      it 'are overlapping floats, the result is a float range' do
+        expect(overlapping_floats.normalize).to eq(tf.float_range(10.0, 28.0))
+      end
+
+      it 'are enums, the result is an enum' do
+        expect(enums.normalize).to eq(tf.enum('a', 'b', 'c'))
+      end
+
+      it 'are patterns, the result is a pattern' do
+        expect(patterns.normalize).to eq(tf.pattern('a', 'b', 'c'))
+      end
+
+      it 'contains an Undef, the result is Optional' do
+        expect(with_undef.normalize).to eq(tf.optional(tf.range(1,10)))
+      end
+
+      it 'are all Optional, the result is an Optional with normalized type' do
+        expect(all_optional.normalize).to eq(tf.optional(tf.range(1,20)))
+      end
+
+      it 'can be normalized in groups, the result is a Variant containing the resulting normalizations' do
+        expect(groups.normalize).to eq(tf.variant(
+          tf.range(8, 28),
+          tf.float_range(10.0, 28.0),
+          tf.enum('a', 'b', 'c'),
+          tf.pattern('a', 'b', 'c'),
+          tf.optional(tf.range(1,20)))
+        )
+      end
+    end
+  end
+end
+end
+end

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

@@ -151,7 +151,7 @@ describe "validating 4x" do
   end
 
   context 'for reserved words' do
-    ['private', 'type', 'attr'].each do |word|
+    ['private', 'attr'].each do |word|
       it "produces an error for the word '#{word}'" do
         source = "$a = #{word}"
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_WORD)
@@ -217,6 +217,27 @@ describe "validating 4x" do
     end
   end
 
+  context 'for keywords' do
+    it "should allow using the 'type' as the name of a function with no parameters" do
+      source = "type()"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+
+    it "should allow using the keyword 'type' as the name of a function with parameters" do
+      source = "type('a', 'b')"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+    it "should allow using the 'type' as the name of a function with no parameters and a block" do
+      source = "type() |$x| { $x }"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+
+    it "should allow using the keyword 'type' as the name of a function with parameters and a block" do
+      source = "type('a', 'b') |$x| { $x }"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+  end
+
   context 'for parameter names' do
     ['class', 'define'].each do |word|
       it "should require that #{word} parameter names are unique" do
@@ -229,6 +250,34 @@ describe "validating 4x" do
     end
   end
 
+  context 'for parameter defaults' do
+    ['class', 'define'].each do |word|
+      it "should not permit assignments in #{word} parameter default expressions" do
+        expect { parse("#{word} foo($a = $x = 10) {}") }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '='/)
+      end
+    end
+
+    ['class', 'define'].each do |word|
+      it "should not permit assignments in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = [$x = 10]) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should not permit assignments to subsequently declared parameters in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = ($b = 3), $b = 5) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should not permit assignments to previously declared parameters in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = 10, $b = ($a = 10)) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should permit assignments in #{word} parameter default inside nested lambda expressions" do
+        expect(validate(parse(
+          "#{word} foo($a = [1,2,3], $b = 0, $c = $a.map |$x| { $b = $x; $b * $a.reduce |$x, $y| {$x + $y}}) {}"))).not_to(
+          have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT))
+      end
+    end
+  end
+
   context 'for reserved parameter names' do
     ['name', 'title'].each do |word|
       it "produces an error when $#{word} is used as a parameter in a class" do
@@ -272,61 +321,69 @@ describe "validating 4x" do
     end
   end
 
-  context 'top level constructs in conditionals' do
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an if expression" do
-        source = "if true { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
-      end
+  context 'top level constructs' do
+    def issue(at_top)
+      at_top ? Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL : Puppet::Pops::Issues::NOT_TOP_LEVEL
     end
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an if-else expression" do
-        source = "if false {} else { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
+    # Top level. Defines the expressions that are tested inside of other things
+    {
+      'a class' => ['class x{}', false],
+      'a define' => ['define x{}', false],
+      'a node' => ['node x{}', false],
+      'a function' => ['function x() {}', true],
+      'a type alias' => ['type A = Data', true],
+      'a type alias for a complex type' => ['type C = Hash[String[1],Integer]', true],
+      'a type definition' => ['type A {}', true]
+    }.each_pair do |word, (decl, at_top)|
+      # Nesting level. Defines how each of the top level expressions are nested in
+      # another expression
+      {
+        'a define' => ["define y{ #{decl} }", at_top],
+        'a function' => ["function y() { #{decl} }", at_top],
+        'a type definition' => ["type A { #{decl} }", at_top],
+        'an if expression' => ["if true { #{decl} }", false],
+        'an if-else expression' => ["if false {} else { #{decl} }", false],
+        'an unless' => ["unless false { #{decl} }", false]
+      }.each_pair do |nester, (source, abs_top)|
+        # Tests each top level expression in each nested expression
+        it "produces an error when #{word} is nested in #{nester}" do
+          expect(validate(parse(source))).to have_issue(issue(abs_top))
+        end
       end
-    end
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an unless expression" do
-        source = "unless false { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
-      end
-    end
+      # Test that the expression can exist anywhere in a top level block
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an function" do
-        source = "function y() { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
+      it "will allow #{word} as the only statement in a top level block" do
+        expect(validate(parse(decl))).not_to have_issue(issue(at_top))
       end
-    end
 
-    it 'produces an error when a function is nested in an function' do
-      source = 'function y() { function x() {} }'
-      expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
-    end
+      it "will allow #{word} as the last statement in a top level block" do
+        source = "$a = 10\n#{decl}"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
+      end
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when function is nested in a #{word}" do
-        source = "#{word} x { function y() {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+      it "will allow #{word} as the first statement in a top level block" do
+        source = "#{decl}\n$a = 10"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
       end
-    end
 
-    it 'does not produce an error when function is at top level script' do
-      source = 'function y() {}'
-      expect(validate(parse(source))).not_to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+      it "will allow #{word} in between other statements in a top level block" do
+        source = "$a = 10\n#{decl}\n$b = 20"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
+      end
     end
 
-    it 'does not produce an error when function is at top level file' do
-      source = 'function y() {}'
+    context 'that are type aliases' do
+      it 'raises errors when RHS is a name that is an invalid reference' do
+        source = 'type MyInt = integer'
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+      end
 
-      # We simulate a file by inserting a block between the program and the contained function
-      program = parse(source).current
-      function = program.body
-      program.body = Puppet::Pops::Model::BlockExpression.new
-      program.body.addStatements(function)
-      expect(validate(program)).not_to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+      it 'raises errors when RHS is an AccessExpression with a name that is an invalid reference on LHS' do
+        source = 'type IntegerArray = array[Integer]'
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+      end
     end
   end
 

data/spec/unit/provider/cron/parsed_spec.rb

@@ -139,6 +139,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       expect(described_class.parse_line('MAILTO=""')).to eq({:record_type => :environment, :line => 'MAILTO=""'})
       expect(described_class.parse_line('FOO=BAR')).to eq({:record_type => :environment, :line => 'FOO=BAR'})
       expect(described_class.parse_line('FOO_BAR=BAR')).to eq({:record_type => :environment, :line => 'FOO_BAR=BAR'})
+      expect(described_class.parse_line('SPACE = BAR')).to eq({:record_type => :environment, :line => 'SPACE = BAR'})
     end
 
     it "should extract a cron entry" do

data/spec/unit/provider/macauthorization_spec.rb

@@ -6,7 +6,9 @@
 require 'spec_helper'
 
 require 'puppet'
-require 'plist'
+
+module Puppet::Util::Plist
+end
 
 provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
 
@@ -26,7 +28,8 @@ describe provider_class do
     authdb["rights"] = { "fooright" => "foo" }
 
     # Stub out Plist::parse_xml
-    Plist.stubs(:parse_xml).returns(authdb)
+    Puppet::Util::Plist.stubs(:parse_plist).returns(authdb)
+    Puppet::Util::Plist.stubs(:write_plist_file)
 
     # A catch all; no parameters set
     @resource.stubs(:[]).returns(nil)