puppet 5.0.0 → 6.0.0

data/spec/unit/parser/type_loader_spec.rb

@@ -161,7 +161,7 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should skip modules that don't have manifests" do
-      module1 = mk_module(modulebase1, "one")
+      mk_module(modulebase1, "one")
       module2 = mk_module(modulebase2, "two")
       mk_manifests(modulebase2, module2, %w{c d})
 

data/spec/unit/pops/adaptable_spec.rb

@@ -42,7 +42,6 @@ describe Puppet::Pops::Adaptable::Adapter do
 
   it "should return the correct adapter if there are several" do
     d = Duck.new
-    other = OtherAdapter.adapt(d)
     a = ValueAdapter.adapt(d)
     a.value = 10
     b = ValueAdapter.adapt(d)

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -539,6 +539,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(type_expr)).to eql(tf.callable([String], Integer))
     end
 
+    # Variant Type
+    it 'does not allow Variant declarations with non-type arguments' do
+      type_expr = fqr('Variant').access_at(fqr('Integer'), 'not a type')
+      expect { evaluate(type_expr) }.to raise_error(/Cannot use String where Any-Type is expected/)
+    end
   end
 
   matcher :be_the_type do |type|

data/spec/unit/pops/evaluator/arithmetic_ops_spec.rb

@@ -128,6 +128,16 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
+    context 'on binary values' do
+      include PuppetSpec::Compiler
+      require 'base64'
+      encoded = Base64.encode64('Hello world').chomp
+      it 'Binary + Binary' do
+        code = 'notice(assert_type(Binary, Binary([72,101,108,108,111,32]) + Binary([119,111,114,108,100])))'
+        expect(eval_and_collect_notices(code)).to eql([encoded])
+      end
+    end
+
     context 'on timespans' do
       include PuppetSpec::Compiler
 

data/spec/unit/pops/evaluator/conditionals_spec.rb

@@ -171,7 +171,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           ))).to eq('w00t')
       end
 
-      it "3 ? {1 => 'wat', default => 'w00t', 3 => 'wat'} == 'w00t'" do
+      it "3 ? {1 => 'wat', default => 'w00t', 2 => 'wat'} == 'w00t'" do
         expect(evaluate(literal(3).select(
           MAP(literal(1), literal('wat')),
           MAP(literal(:default), literal('w00t')),

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -202,6 +202,42 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "true  == true " => true,
       "false == false" => true,
       "true == false"  => false,
+
+      "Timestamp(1) < Timestamp(2)"  => true,
+      "Timespan(1) < Timespan(2)"    => true,
+      "Timestamp(1) > Timestamp(2)"  => false,
+      "Timespan(1) > Timespan(2)"    => false,
+      "Timestamp(1) == Timestamp(1)" => true,
+      "Timespan(1) == Timespan(1)"   => true,
+
+      "1 < Timestamp(2)"  => true,
+      "1 < Timespan(2)"   => true,
+      "1 > Timestamp(2)"  => false,
+      "1 > Timespan(2)"   => false,
+      "1 == Timestamp(1)" => true,
+      "1 == Timespan(1)"  => true,
+
+      "1.0 < Timestamp(2)"  => true,
+      "1.0 < Timespan(2)"   => true,
+      "1.0 > Timestamp(2)"  => false,
+      "1.0 > Timespan(2)"   => false,
+      "1.0 == Timestamp(1)" => true,
+      "1.0 == Timespan(1)"  => true,
+
+      "Timestamp(1) < 2"  => true,
+      "Timespan(1) < 2"   => true,
+      "Timestamp(1) > 2"  => false,
+      "Timespan(1) > 2"   => false,
+      "Timestamp(1) == 1" => true,
+      "Timespan(1) == 1"  => true,
+
+      "Timestamp(1) < 2.0"  => true,
+      "Timespan(1) < 2.0"   => true,
+      "Timestamp(1) > 2.0"  => false,
+      "Timespan(1) > 2.0"   => false,
+      "Timestamp(1) == 1.0" => true,
+      "Timespan(1) == 1.0"  => true,
+
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -1017,7 +1053,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
     it "provides location information on error in unparenthesized call logic" do
-    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /:1:1/)
+    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line: 1, column: 1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do
@@ -1103,14 +1139,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(nil)
+        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(nil)
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(nil)
+        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(nil)
       end
     end
   end
@@ -1146,7 +1182,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       source = '"value is ${{a=>1,b=>2}} yo"'
       # This test requires testing against two options because a hash to string
       # produces a result that is unordered
-      hashstr = {'a' => 1, 'b' => 2}.to_s
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
@@ -1204,7 +1239,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
-      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::ParseErrorWithIssue, /Illegal fully qualified name at line 1:7/)
+      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::ParseErrorWithIssue, /Illegal fully qualified name \(line: 1, column: 7\)/)
     end
 
     { '$a = $0'   => nil,
@@ -1394,7 +1429,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       source = "\nimport foo"
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
-      expect { parser.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.*line 2:1/)
+      expect { parser.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.* \(line: 2, column: 1\)/)
     end
   end
 
@@ -1404,15 +1439,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.evaluate_string(scope, source) }.to raise_error(
-        /Illegal Resource Type expression, expected result to be a type name, or untitled Resource.*line 1:2/)
+        /Illegal Resource Type expression, expected result to be a type name, or untitled Resource.* \(line: 1, column: 2\)/)
     end
 
     it 'for non r-value producing <| |>' do
-      expect { parser.parse_string("$a = File <| |>", nil) }.to raise_error(/A Virtual Query does not produce a value at line 1:6/)
+      expect { parser.parse_string("$a = File <| |>", nil) }.to raise_error(/A Virtual Query does not produce a value \(line: 1, column: 6\)/)
     end
 
     it 'for non r-value producing <<| |>>' do
-      expect { parser.parse_string("$a = File <<| |>>", nil) }.to raise_error(/An Exported Query does not produce a value at line 1:6/)
+      expect { parser.parse_string("$a = File <<| |>>", nil) }.to raise_error(/An Exported Query does not produce a value \(line: 1, column: 6\)/)
     end
 
     it 'for non r-value producing define' do
@@ -1433,7 +1468,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       yyy
       SOURCE
       # first char after opening " reported as being in error.
-      expect { parser.parse_string(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' at line 1:7/)
+      expect { parser.parse_string(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' \(line: 1, column: 7\)/)
     end
 
     it 'for multiple errors with a summary exception' do
@@ -1445,7 +1480,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     it 'for a bad hostname' do
       expect {
         parser.parse_string("node 'macbook+owned+by+name' { }", nil)
-      }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.*at line 1:6/)
+      }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.* \(line: 1, column: 6\)/)
     end
 
     it 'for a hostname with interpolation' do
@@ -1455,7 +1490,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       SOURCE
       expect {
         parser.parse_string(source, nil)
-      }.to raise_error(/An interpolated expression is not allowed in a hostname of a node at line 2:23/)
+      }.to raise_error(/An interpolated expression is not allowed in a hostname of a node \(line: 2, column: 23\)/)
     end
 
   end
@@ -1493,9 +1528,36 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
   end
 
-  matcher :have_relationship do |expected|
-    calc = Puppet::Pops::Types::TypeCalculator.new
+  context 'with --tasks' do
+    before(:each) do
+      Puppet[:tasks] = true
+    end
+
+    context 'when evaluating apply' do
+      let(:applicator) { mock('apply_executor') }
+
+      it 'invokes an apply_executor' do
+        applicator.expects(:apply).with(['arg1', 'arg2'], nil, scope).returns(:result)
+        src = "apply('arg1', 'arg2') { }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
 
+      it 'passes the declared ast' do
+        applicator.expects(:apply).with(
+          [['arg1']],
+          instance_of(Puppet::Pops::Model::ResourceExpression),
+          scope).returns(:result)
+        src = "apply(['arg1']) { notify { 'hello': } }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
+    end
+  end
+
+  matcher :have_relationship do |expected|
     match do |compiler|
       op_name = {'->' => :relationship, '~>' => :subscription}
       compiler.relationships.any? do | relation |

data/spec/unit/pops/evaluator/runtime3_converter_spec.rb

@@ -31,23 +31,19 @@ describe 'when converting to 3.x' do
   end
 
   it 'converts the symbol :undef to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
   it 'converts the nil to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'does not convert a symbol nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
+  it 'convert a symbol nested in an array' do
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => 'undef value'})
   end
 
-  it 'converts nil to :undef when nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
+  it 'does not converts nil to given undef value when nested in an array' do
+    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => nil})
   end
 
   it 'does not convert a Regex instance to string' do

data/spec/unit/pops/factory_rspec_helper.rb

@@ -59,7 +59,7 @@ module FactoryRspecHelper
   end
 
   def unindent x
-    (x.gsub /^#{x[/\A\s*/]}/, '').chomp
+    x.gsub(/^#{x[/\A\s*/]}/, '').chomp
   end
   factory ||= Puppet::Pops::Model::Factory
 end

data/spec/unit/pops/factory_spec.rb

@@ -45,7 +45,11 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Multiple expressions should produce a block expression" do
-      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)]).model
+      braces = mock 'braces'
+      braces.stubs(:offset).returns(0)
+      braces.stubs(:length).returns(0)
+
+      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)], braces, braces).model
       expect(model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
       expect(model.statements.size).to eq(2)
     end
@@ -187,7 +191,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle 'just a string'" do
       model = string('blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
     end
@@ -195,7 +199,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression in the middle" do
       model = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 3
+      expect(model.segments.size).to eq(3)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -207,7 +211,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression at the end" do
       model = string('blah blah', TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -217,7 +221,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle only one expression" do
       model = string(TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
@@ -225,7 +229,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle several expressions" do
       model = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)

data/spec/unit/pops/issues_spec.rb

@@ -34,24 +34,25 @@ describe "Puppet::Pops::IssueReporter" do
     stub("positioned_#{number}", :line => number, :pos => number)
   end
 
-  def diagnostic(severity,  number)
+  def diagnostic(severity,  number, args)
     Puppet::Pops::Validation::Diagnostic.new(
       severity,
       Puppet::Pops::Issues::Issue.new(number) { "#{severity}#{number}" },
       "#{severity}file",
-      fake_positioned(number))
+      fake_positioned(number),
+      args)
   end
 
-  def warning(number)
-    diagnostic(:warning, number)
+  def warning(number, args = {})
+    diagnostic(:warning, number, args)
   end
 
-  def deprecation(number)
-    diagnostic(:deprecation, number)
+  def deprecation(number, args = {})
+    diagnostic(:deprecation, number, args)
   end
 
-  def error(number)
-    diagnostic(:error, number)
+  def error(number, args = {})
+    diagnostic(:error, number, args)
   end
 
   context "given warnings" do
@@ -98,6 +99,13 @@ describe "Puppet::Pops::IssueReporter" do
       Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
+
+    it "includes diagnostic arguments in logged entry" do
+      acceptor.accept( warning(2, :n => 'a') )
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning2/), :arguments => {:n => 'a'}))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
   end
 
   context "given errors" do
@@ -175,6 +183,13 @@ describe "Puppet::Pops::IssueReporter" do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
     end
+
+    it "includes diagnostic arguments in raised error" do
+      acceptor.accept( error(1, :n => 'a') )
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseErrorWithIssue, /error1/) { |ex| expect(ex.arguments).to eq(:n => 'a')}
+    end
   end
 
   context "given both" do

data/spec/unit/pops/loaders/dependency_loader_spec.rb

@@ -84,7 +84,7 @@ Puppet::Functions.create_function('testmodule::foo') {
 
       context 'when loading files from disk' do
         it 'should always read files as UTF-8' do
-          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+          if Puppet::Util::Platform.windows? && Encoding.default_external == Encoding::UTF_8
             raise 'This test must be run in a codepage other than 65001 to validate behavior'
           end
 
@@ -102,7 +102,7 @@ Puppet::Functions.create_function('testmodule::foo') {
         it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
           bom = "\uFEFF"
 
-          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+          if Puppet::Util::Platform.windows? && Encoding.default_external == Encoding::UTF_8
             raise 'This test must be run in a codepage other than 65001 to validate behavior'
           end