puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/spec/unit/{parser/functions → functions}/shared.rb

@@ -1,41 +1,44 @@
-shared_examples_for 'all functions transforming relative to absolute names' do |func_method|
-
-  it 'transforms relative names to absolute' do
-    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-    @scope.send(func_method, ["myclass"])
+shared_examples_for 'all functions transforming relative to absolute names' do |func_name|
+  before(:each) do
+    # mock that the class 'myclass' exists which are needed for the 'require' functions
+    # as it checks the existence of the required class
+    @klass = stub 'class', :name => "myclass"
+    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
+    @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
+    @scope.stubs(:resource).returns @resource
   end
 
   it 'accepts a Class[name] type' do
     @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
+    @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
   end
 
   it 'accepts a Resource[class, name] type' do
     @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
+    @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
   end
 
   it 'raises and error for unspecific Class' do
     expect {
-      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class()])
+      @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class()])
     }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
   end
 
   it 'raises and error for Resource that is not of class type' do
     expect {
-      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('file')])
+      @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('file')])
     }.to raise_error(ArgumentError, /Cannot use a Resource\[File\] where a Resource\['class', name\] is expected/)
   end
 
   it 'raises and error for Resource that is unspecific' do
     expect {
-      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource()])
+      @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource()])
     }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\[\] where a Resource\['class', name\] is expected/)
   end
 
   it 'raises and error for Resource[class] that is unspecific' do
     expect {
-      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class')])
+      @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class')])
     }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
   end
 

data/spec/unit/functions/strftime_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe 'the strftime function' do
+  include PuppetSpec::Compiler
+
+  def test_format(ctor_arg, format, expected)
+    expect(eval_and_collect_notices("notice(strftime(Timespan(#{ctor_arg}), '#{format}'))")).to eql(["#{expected}"])
+  end
+
+  context 'when applied to a Timespan' do
+    [
+      ['hours', 'H', 2],
+      ['minutes', 'M', 2],
+      ['seconds', 'S', 2],
+    ].each do |field, fmt, dflt_width|
+      ctor_arg = "{#{field}=>3}"
+      it "%#{fmt} width defaults to #{dflt_width}" do
+        test_format(ctor_arg, "%#{fmt}", sprintf("%0#{dflt_width}d", 3))
+      end
+
+      it "%_#{fmt} pads with space" do
+        test_format(ctor_arg, "%_#{fmt}", sprintf("% #{dflt_width}d", 3))
+      end
+
+      it "%-#{fmt} does not pad" do
+        test_format(ctor_arg, "%-#{fmt}", '3')
+      end
+
+      it "%10#{fmt} pads with zeroes to specified width" do
+        test_format(ctor_arg, "%10#{fmt}", sprintf("%010d", 3))
+      end
+
+      it "%_10#{fmt} pads with space to specified width" do
+        test_format(ctor_arg, "%_10#{fmt}", sprintf("% 10d", 3))
+      end
+
+      it "%-10#{fmt} does not pad even if width is specified" do
+        test_format(ctor_arg, "%-10#{fmt}", '3')
+      end
+    end
+
+    [
+      ['milliseconds', 'L', 3],
+      ['nanoseconds', 'N', 9],
+      ['milliseconds', '3N', 3],
+      ['microseconds', '6N', 6],
+      ['nanoseconds', '9N', 9],
+    ].each do |field, fmt, dflt_width|
+      ctor_arg = "{#{field}=>3000}"
+      it "%#{fmt} width defaults to #{dflt_width}" do
+        test_format(ctor_arg, "%#{fmt}", sprintf("%-#{dflt_width}d", 3000))
+      end
+
+      it "%_#{fmt} pads with space" do
+        test_format(ctor_arg, "%_#{fmt}", sprintf("%-#{dflt_width}d", 3000))
+      end
+
+      it "%-#{fmt} does not pad" do
+        test_format(ctor_arg, "%-#{fmt}", '3000')
+      end
+    end
+
+    it 'can use a format containing all format characters, flags, and widths' do
+      test_format("{string => '100-14:02:24.123456000', format => '%D-%H:%M:%S.%9N'}", '%_10D%%%03H:%-M:%S.%9N', '       100%014:2:24.123456000')
+    end
+
+    it 'can format and strip excess zeroes from fragment using no-padding flag' do
+      test_format("{string => '100-14:02:24.123456000', format => '%D-%H:%M:%S.%N'}", '%D-%H:%M:%S.%-N', '100-14:02:24.123456')
+    end
+
+    it 'can format and replace excess zeroes with spaces from fragment using space-padding flag and default widht' do
+      test_format("{string => '100-14:02:24.123456000', format => '%D-%H:%M:%S.%N'}", '%D-%H:%M:%S.%_N', '100-14:02:24.123456   ')
+    end
+
+    it 'can format and replace excess zeroes with spaces from fragment using space-padding flag and specified width' do
+      test_format("{string => '100-14:02:24.123400000', format => '%D-%H:%M:%S.%N'}", '%D-%H:%M:%S.%_6N', '100-14:02:24.1234  ')
+    end
+
+    it 'can format and retain excess zeroes in fragment using default width' do
+      test_format("{string => '100-14:02:24.123400000', format => '%D-%H:%M:%S.%N'}", '%D-%H:%M:%S.%N', '100-14:02:24.123400000')
+    end
+
+    it 'can format and retain excess zeroes in fragment using specified width' do
+      test_format("{string => '100-14:02:24.123400000', format => '%D-%H:%M:%S.%N'}", '%D-%H:%M:%S.%6N', '100-14:02:24.123400')
+    end
+  end
+
+  def test_timestamp_format(ctor_arg, format, expected)
+    expect(eval_and_collect_notices("notice(strftime(Timestamp('#{ctor_arg}'), '#{format}'))")).to eql(["#{expected}"])
+  end
+
+  def test_timestamp_format_tz(ctor_arg, format, tz, expected)
+    expect(eval_and_collect_notices("notice(strftime(Timestamp('#{ctor_arg}'), '#{format}', '#{tz}'))")).to eql(["#{expected}"])
+  end
+
+  def collect_log(code, node = Puppet::Node.new('foonode'))
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    node.environment.check_for_reparse
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compiler.compile
+    end
+    logs
+  end
+
+  context 'when applied to a Timestamp' do
+    it 'can format a timestamp with a format pattern' do
+      test_timestamp_format('2016-09-23T13:14:15.123 UTC', '%Y-%m-%d %H:%M:%S.%L %z', '2016-09-23 13:14:15.123 +0000')
+    end
+
+    it 'can format a timestamp using a specific timezone' do
+      test_timestamp_format_tz('2016-09-23T13:14:15.123 UTC', '%Y-%m-%d %H:%M:%S.%L %z', 'EST', '2016-09-23 08:14:15.123 -0500')
+    end
+  end
+
+  context 'when used with dispatcher covering legacy stdlib API (String format, String timeszone = undef)' do
+    it 'produces the current time when used with one argument' do
+      before_eval = Time.now
+      notices = eval_and_collect_notices("notice(strftime('%F %T'))")
+      expect(notices).not_to be_empty
+      expect(notices[0]).to match(/\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\z/)
+      parsed_time = DateTime.strptime(notices[0], '%F %T').to_time
+      expect(Time.now.to_i >= parsed_time.to_i && parsed_time.to_i >= before_eval.to_i).to be_truthy
+    end
+
+    it 'emits a deprecation warning when used with one argument' do
+      log = collect_log("notice(strftime('%F %T'))")
+      warnings = log.select { |log_entry| log_entry.level == :warning }.map { |log_entry| log_entry.message }
+      expect(warnings).not_to be_empty
+      expect(warnings[0]).to match(/The argument signature \(String format, \[String timezone\]\) is deprecated for #strfime/)
+    end
+
+    it 'produces the current time formatted with specific timezone when used with two arguments' do
+      before_eval = Time.now
+      notices = eval_and_collect_notices("notice(strftime('%F %T %:z', 'EST'))")
+      expect(notices).not_to be_empty
+      expect(notices[0]).to match(/\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} -05:00\z/)
+      parsed_time = DateTime.strptime(notices[0], '%F %T %z').to_time
+      expect(Time.now.to_i >= parsed_time.to_i && parsed_time.to_i >= before_eval.to_i).to be_truthy
+    end
+
+    it 'emits a deprecation warning when using legacy format with two arguments' do
+      log = collect_log("notice(strftime('%F %T', 'EST'))")
+      warnings = log.select { |log_entry| log_entry.level == :warning }.map { |log_entry| log_entry.message }
+      expect(warnings).not_to be_empty
+      expect(warnings[0]).to match(/The argument signature \(String format, \[String timezone\]\) is deprecated for #strfime/)
+    end
+  end
+end
+

data/spec/unit/functions4_spec.rb

@@ -482,6 +482,27 @@ describe 'the 4x function api' do
     context 'can use a loader when parsing types in function dispatch, and' do
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
 
+      it 'uses return_type to validate returned value' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'Integer', :x
+              return_type 'String'
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error,
+          /value returned from function 'test' has wrong type, expects a String value, got Integer/)
+      end
+
       it 'resolve a referenced Type alias' do
         the_loader = loader()
         the_loader.add_type('myalias', type_alias_t('MyAlias', 'Integer'))
@@ -490,6 +511,7 @@ describe 'the 4x function api' do
           Puppet::Functions.create_function('testing::test') do
             dispatch :test do
               param 'MyAlias', :x
+              return_type 'MyAlias'
             end
             def test(x)
               x

data/spec/unit/indirector/face_spec.rb

@@ -40,16 +40,24 @@ describe Puppet::Indirector::Face do
   end
 
   [:find, :search, :save, :destroy].each do |method|
+    def params(method, options)
+      if method == :save
+        [nil, options]
+      else
+        [options]
+      end
+    end
+
     it "should define a '#{method}' action" do
       expect(Puppet::Indirector::Face).to be_action(method)
     end
 
     it "should call the indirection method with options when the '#{method}' action is invoked" do
-      subject.indirection.expects(method).with(:test, {})
+      subject.indirection.expects(method).with(:test, *params(method, {}))
       subject.send(method, :test)
     end
     it "should forward passed options" do
-      subject.indirection.expects(method).with(:test, {'one'=>'1'})
+      subject.indirection.expects(method).with(:test, *params(method, {'one'=>'1'}))
       subject.send(method, :test, :extra => {'one'=>'1'})
     end
   end

data/spec/unit/network/http/error_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Network::HTTP::Error do
   end
 
   describe Puppet::Network::HTTP::Error::HTTPServerError do
-    it "should serialize to JSON that matches the error schema and has a deprecated stacktrace property" do
+    it "should serialize to JSON that matches the error schema" do
       begin
         raise Exception, "a wild Exception appeared!"
       rescue Exception => e
@@ -24,7 +24,6 @@ describe Puppet::Network::HTTP::Error do
       error = Puppet::Network::HTTP::Error::HTTPServerError.new(culpable)
 
       expect(error.to_json).to validate_against('api/schemas/error.json')
-      expect(error.to_json).to match(/The 'stacktrace' property is deprecated/)
     end
   end
 

data/spec/unit/network/http/handler_spec.rb

@@ -76,8 +76,7 @@ describe Puppet::Network::HTTP::Handler do
 
     it "returns a structured error response when the server encounters an internal error" do
       error = StandardError.new("the sky is falling!")
-      original_stacktrace = ['a.rb', 'b.rb']
-      error.set_backtrace(original_stacktrace)
+      error.set_backtrace(['a.rb', 'b.rb'])
 
       handler = PuppetSpec::Handler.new(
         Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
@@ -95,9 +94,11 @@ describe Puppet::Network::HTTP::Handler do
       expect(res[:content_type_header]).to eq("application/json")
       expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
       expect(res_body["message"]).to eq("Server Error: the sky is falling!")
-      expect(res_body["stacktrace"].is_a?(Array) && !res_body["stacktrace"].empty?).to be_truthy
-      expect(res_body["stacktrace"][0]).to match(/The 'stacktrace' property is deprecated/)
-      expect(res_body["stacktrace"] & original_stacktrace).to be_empty
+
+      # Stactraces may contain sensitive information, returning them to API
+      # consumers is not a best practice. See
+      # https://tickets.puppetlabs.com/browse/PUP-6659
+      expect(res_body["stacktrace"]).to be_nil
       expect(res[:status]).to eq(500)
     end
 

data/spec/unit/parser/functions/hiera_array_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_array' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_hash_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_hash' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_include_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_include' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/lookup_spec.rb

@@ -9,6 +9,6 @@ describe "lookup function" do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/regsubst_spec.rb

@@ -19,6 +19,6 @@ describe "the regsubst function" do
         'b[an]*a',
         'coconut'
       ])
-    end.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    end.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/split_spec.rb

@@ -13,6 +13,6 @@ describe "the split function" do
   end
 
   it 'should raise a ParseError' do
-    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/pops/types/type_factory'
-
+require 'base64'
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
@@ -20,6 +20,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     Puppet::Pops::Types::TypeFactory.float_range(from, to)
   end
 
+  def binary(s)
+    # Note that the factory is not aware of Binary and cannot operate on a
+    # literal binary. Instead, it must create a call to Binary.new() with the base64 encoded
+    # string as an argument
+    CALL_NAMED(QREF("Binary"), true, [Base64.strict_encode64(s)])
+  end
+
   context 'The evaluator when operating on a String' do
     it 'can get a single character using a single key index to []' do
       expect(evaluate(literal('abc')[1])).to eql('b')
@@ -45,6 +52,31 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     end
   end
 
+  context 'The evaluator when operating on a Binary' do
+    it 'can get a single character using a single key index to []' do
+      expect(evaluate(binary('abc')[1]).binary_buffer).to eql('b')
+    end
+
+    it 'can get the last character using the key -1 in []' do
+      expect(evaluate(binary('abc')[-1]).binary_buffer).to eql('c')
+    end
+
+    it 'can get a substring by giving two keys' do
+      expect(evaluate(binary('abcd')[1,2]).binary_buffer).to eql('bc')
+      # flattens keys
+      expect(evaluate(binary('abcd')[[1,2]]).binary_buffer).to eql('bc')
+    end
+
+    it 'produces empty string for a substring out of range' do
+      expect(evaluate(binary('abc')[100]).binary_buffer).to eql('')
+    end
+
+    it 'raises an error if arity is wrong for []' do
+      expect{evaluate(binary('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
+      expect{evaluate(binary('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
+    end
+  end
+
   context 'The evaluator when operating on an Array' do
     it 'is tested with the correct assumptions' do
       expect(literal([1,2,3])[1].current.is_a?(Puppet::Pops::Model::AccessExpression)).to eql(true)
@@ -235,6 +267,40 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect { evaluate(expr)}.to raise_error(/Array-Type\[\] arguments must be types/)
     end
 
+    # Timespan Type
+    #
+    it 'produdes a Timespan type with a lower bound' do
+      expr = fqr('Timespan')[{fqn('hours') => literal(3)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}))
+    end
+
+    it 'produdes a Timespan type with an upper bound' do
+      expr = fqr('Timespan')[literal(:default), {fqn('hours') => literal(9)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan(nil, {'hours' => 9}))
+    end
+
+    it 'produdes a Timespan type with both lower and upper bounds' do
+      expr = fqr('Timespan')[{fqn('hours') => literal(3)}, {fqn('hours') => literal(9)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}, {'hours' => 9}))
+    end
+
+    # Timestamp Type
+    #
+    it 'produdes a Timestamp type with a lower bound' do
+      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET'))
+    end
+
+    it 'produdes a Timestamp type with an upper bound' do
+      expr = fqr('Timestamp')[literal(:default), literal('2016-08-23T17:50:00 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp(nil, '2016-08-23T17:50:00 CET'))
+    end
+
+    it 'produdes a Timestamp type with both lower and upper bounds' do
+      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET'), literal('2016-08-23T17:50:00 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET'))
+    end
+
     # Tuple Type
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
@@ -459,6 +525,20 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
     end
 
+    # Callable Type
+    #
+    it 'produces Callable instance without return type' do
+      type_expr = fqr('Callable')[fqr('String')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.callable(String))
+    end
+
+    it 'produces Callable instance with parameters and return type' do
+      type_expr = fqr('Callable')[[fqr('String')], fqr('Integer')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.callable([String], Integer))
+    end
+
   end
 
   matcher :be_the_type do |type|