puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/functions/getvar_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the getvar function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'returns undef value' do
+    it 'when result is undef due to missing variable' do
+      expect( evaluate(source: "getvar('x')")).to be_nil
+    end
+
+    it 'when result is undef due to resolved undef variable value' do
+      expect( evaluate(source: "$x = undef; getvar('x')")).to be_nil
+    end
+
+    it 'when result is undef due to navigation into undef' do
+      expect( evaluate(source: "$x = undef; getvar('x.0')")).to be_nil
+    end
+  end
+
+  context 'returns default value' do
+    it 'when result is undef due to missing variable' do
+      expect( evaluate(source: "getvar('x', 'ok')")).to eql('ok')
+    end
+
+    it 'when result is undef due to resolved undef variable value' do
+      expect( evaluate(source: "$x = undef; getvar('x', 'ok')")).to eql('ok')
+    end
+
+    it 'when result is undef due to navigation into undef' do
+      expect( evaluate(source: "$x = undef; getvar('x.0', 'ok')")).to eql('ok')
+    end
+  end
+
+  it 'returns value of $variable if dotted navigation is not present' do
+    expect(evaluate(source: "$x = 'testing'; getvar('x')")).to eql('testing')
+  end
+
+  it 'returns value of fully qualified $namespace::variable if dotted navigation is not present' do
+    expect(evaluate(
+             code:
+               "class testing::nested { $x = ['ok'] } include 'testing::nested'",
+             source:
+               "getvar('testing::nested::x.0')"
+           )).to eql('ok')
+  end
+
+  it 'navigates into $variable if given dot syntax after variable name' do
+    expect(
+      evaluate(
+        variables: {'x'=> ['nope', ['ok']]},
+        source: "getvar('x.1.0')"
+      )
+    ).to eql('ok')
+  end
+
+  it 'can navigate a key with . when it is quoted' do
+    expect(
+      evaluate(
+        variables: {'x' => {'a.b' => ['nope', ['ok']]}},
+        source: "getvar('x.\"a.b\".1.0')"
+      )
+    ).to eql('ok')
+  end
+
+  it 'an error is raised when navigating with string key into an array' do
+    expect {
+      evaluate(source: "$x =['nope', ['ok']]; getvar('x.1.blue')")
+    }.to raise_error(/The given data requires an Integer index/)
+  end
+
+  ['X', ':::x', 'x:::x', 'x-x', '_x::x', 'x::', '1'].each do |var_string|
+    it "an error pointing out that varible is invalid is raised for variable '#{var_string}'" do
+      expect {
+        evaluate(source: "getvar(\"#{var_string}.1.blue\")")
+      }.to raise_error(/The given string does not start with a valid variable name/)
+    end
+  end
+
+  it 'calls a given block with EXPECTED_INTEGER_INDEX if navigating into array with string' do
+    expect(evaluate(
+             source:
+               "$x = ['nope', ['ok']]; getvar('x.1.blue') |$error| {
+                 if $error.issue_code =~ /^EXPECTED_INTEGER_INDEX$/ {'ok'} else { 'nope'}
+                }"
+           )).to eql('ok')
+  end
+
+  it 'calls a given block with EXPECTED_COLLECTION if navigating into something not Undef or Collection' do
+    expect(evaluate(
+             source:
+               "$x = ['nope', /nah/]; getvar('x.1.blue') |$error| {
+                  if $error.issue_code =~ /^EXPECTED_COLLECTION$/ {'ok'} else { 'nope'}
+                }"
+           )).to eql('ok')
+  end
+
+  context 'it does not pick the default value when undef is returned by error handling block' do
+    it 'for "expected integer" case' do
+      expect(evaluate(
+               source: "$x = ['nope', ['ok']]; getvar('x.1.blue', 'nope') |$msg| { undef }"
+             )).to be_nil
+    end
+
+    it 'for "expected collection" case' do
+      expect(evaluate(
+               source: "$x = ['nope', /nah/]; getvar('x.1.blue') |$msg| { undef }"
+             )).to be_nil
+    end
+  end
+
+  it 'does not call a given block if navigation string has syntax error' do
+    expect {evaluate(
+      source: "$x = ['nope', /nah/]; getvar('x.1....') |$msg| { fail('so sad') }"
+    )}.to raise_error(/Syntax error/)
+  end
+
+end

data/spec/unit/functions/hiera_spec.rb

@@ -12,7 +12,7 @@ describe 'when calling' do
     ---
     :backends:
       - yaml
-      - custom
+      - hieraspec
     :yaml:
       :datadir: #{global_dir}/hieradata
     :hierarchy:
@@ -20,39 +20,6 @@ describe 'when calling' do
       - second
     YAML
 
-  let(:ruby_stuff_files) do
-    {
-      'hiera' => {
-        'backend' => {
-          'custom_backend.rb' => <<-RUBY.unindent
-            class Hiera::Backend::Custom_backend
-              def initialize(cache = nil)
-                Hiera.debug('Custom_backend starting')
-              end
-
-              def lookup(key, scope, order_override, resolution_type, context)
-                case key
-                when 'datasources'
-                  Hiera::Backend.datasources(scope, order_override) { |source| source }
-                when 'resolution_type'
-                  if resolution_type == :hash
-                    { key => resolution_type.to_s }
-                  elsif resolution_type == :array
-                    [ key, resolution_type.to_s ]
-                  else
-                    "resolution_type=\#{resolution_type}"
-                  end
-                else
-                  throw :no_such_key
-                end
-              end
-            end
-            RUBY
-        }
-      }
-    }
-  end
-
   let(:hieradata_files) do
     {
       'first.yaml' => <<-YAML.unindent,
@@ -143,7 +110,6 @@ describe 'when calling' do
   let(:global_files) do
     {
       'hiera.yaml' => hiera_yaml,
-      'ruby_stuff' => ruby_stuff_files,
       'hieradata' => hieradata_files,
       'environments' => environment_files
     }
@@ -158,23 +124,24 @@ describe 'when calling' do
   let(:compiler) { Puppet::Parser::Compiler.new(node) }
   let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera') }
 
+  before(:all) do
+    $LOAD_PATH.unshift(File.join(my_fixture_dir))
+  end
+
+  after(:all) do
+    Hiera::Backend.send(:remove_const, :Hieraspec_backend) if Hiera::Backend.const_defined?(:Hieraspec_backend)
+    $LOAD_PATH.shift
+  end
+
   before(:each) do
     Puppet.settings[:codedir] = global_dir
     Puppet.settings[:hiera_config] = File.join(global_dir, 'hiera.yaml')
   end
 
   around(:each) do |example|
-    # Faking the load path to enable 'require' to load from 'ruby_stuff'. It removes the need for a static fixture
-    # for the custom backend
     dir_contained_in(global_dir, global_files)
-    $LOAD_PATH.unshift(File.join(global_dir, 'ruby_stuff'))
-    begin
-      Puppet.override(:environments => environments, :current_environment => env) do
-        example.run
-      end
-    ensure
-      Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
-      $LOAD_PATH.shift
+    Puppet.override(:environments => environments, :current_environment => env) do
+      example.run
     end
   end
 
@@ -406,7 +373,7 @@ describe 'when calling' do
         ---
         :backends:
           - yaml
-          - custom
+          - hieraspec
         :yaml:
           :datadir: #{global_dir}/hieradata
         :hierarchy:
@@ -455,8 +422,7 @@ describe 'when calling' do
               - x3
               - x4
             YAML
-        },
-        'ruby_stuff' => ruby_stuff_files
+        }
       }
     end
 

data/spec/unit/functions/include_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -6,6 +7,7 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
+
 describe 'The "include" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
@@ -126,6 +128,7 @@ describe 'The "include" function' do
     expect(catalog).to_not contain_class("not_contained").in("container")
   end
 
+
   it 'produces an array with a single class references given a single argument' do
     catalog = compile_to_catalog(<<-MANIFEST)
       class a {
@@ -183,4 +186,5 @@ describe 'The "include" function' do
   it_should_behave_like 'all functions transforming relative to absolute names', :include
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
   it_should_behave_like 'an inclusion function, when --tasks is on,', :include
+
 end

data/spec/unit/functions/lookup_fixture_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/files'

data/spec/unit/functions/lookup_spec.rb

@@ -1,8 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'deep_merge/core'
+require 'hiera'
 
 describe "The lookup function" do
   include PuppetSpec::Compiler
@@ -36,8 +38,6 @@ describe "The lookup function" do
     }
   end
 
-  let(:ruby_dir_files) { {} }
-
   let(:logs) { [] }
   let(:scope_additions ) { {} }
   let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
@@ -56,11 +56,6 @@ describe "The lookup function" do
     code_dir
   end
 
-  let(:populated_ruby_dir) do
-    dir_contained_in(ruby_dir, ruby_dir_files)
-    ruby_dir
-  end
-
   let(:env_dir) do
     d = File.join(populated_code_dir, 'environments')
     Dir.mkdir(d)
@@ -120,10 +115,11 @@ describe "The lookup function" do
     nil
   end
 
-  def lookup(key, options = {}, explain = false)
+  def lookup(key, options = {}, explain = false, type = nil)
+    value_type = type ? ", #{type}" : ''
     nc_opts = options.empty? ? '' : ", #{Puppet::Pops::Types::TypeFormatter.string(options)}"
     keys = key.is_a?(Array) ? key : [key]
-    collect_notices(keys.map { |k| "notice(String(lookup('#{k}'#{nc_opts}), '%p'))" }.join("\n"), explain)
+    collect_notices(keys.map { |k| "notice(String(lookup('#{k}'#{value_type}#{nc_opts}), '%p'))" }.join("\n"), explain)
     if explain
       explanation
     else
@@ -810,9 +806,24 @@ describe "The lookup function" do
           YAML
         end
 
-        it 'fails lookup and reports a type mismatch' do
+        it 'fails lookup and reports parsing failed' do
           expect { lookup('a') }.to raise_error do |e|
-            expect(e.message).to match(/key 'a'.*data_hash function 'yaml_data'.*using location.*wrong type, expects Puppet::LookupValue, got Runtime/)
+            expect(e.message).to match(/Unable to parse .*: Tried to load unspecified class: Puppet::Graph::Key/)
+          end
+        end
+      end
+
+      context 'that contains a legal yaml hash with unexpected types' do
+        let(:common_yaml) do
+          <<-YAML.unindent
+          ---
+          a: 123
+          YAML
+        end
+
+        it 'fails lookup and reports a type mismatch' do
+          expect { lookup('a', {}, false, String) }.to raise_error do |e|
+            expect(e.message).to match(/Found value has wrong type, expects a String value, got Integer \(line: 1, column: \d+\)/)
           end
         end
       end
@@ -1481,7 +1492,7 @@ describe "The lookup function" do
         expect(lookup('x')).to eql('value x (from environment)')
       end
 
-      context 'obtained using /dev/null', :unless => Puppet.features.microsoft_windows? do
+      context 'obtained using /dev/null', :unless => Puppet::Util::Platform.windows? do
         let(:code_dir_files) { {} }
 
         it 'uses a Hiera version 3 defaults' do
@@ -1554,42 +1565,16 @@ describe "The lookup function" do
         }
       end
 
-      let(:ruby_dir_files) do
-        {
-          'hiera' => {
-            'backend' => {
-              'custom_backend.rb' => <<-RUBY.unindent,
-            class Hiera::Backend::Custom_backend
-              def lookup(key, scope, order_override, resolution_type, context)
-                case key
-                when 'hash_c'
-                  { 'hash_ca' => { 'cad' => 'value hash_c.hash_ca.cad (from global custom)' }}
-                when 'hash'
-                  { 'array' => [ 'x5,x6' ] }
-                when 'array'
-                  [ 'x5,x6' ]
-                when 'datasources'
-                  Hiera::Backend.datasources(scope, order_override) { |source| source }
-                when 'dotted.key'
-                  'custom backend received request for dotted.key value'
-                else
-                  throw :no_such_key
-                end
-              end
-            end
-            RUBY
-            'other_backend.rb' => <<-RUBY.unindent,
-            class Hiera::Backend::Other_backend
-              def lookup(key, scope, order_override, resolution_type, context)
-                value = Hiera::Config[:other][key.to_sym]
-                throw :no_such_key if value.nil?
-                value
-              end
-            end
-            RUBY
-            }
-          }
-        }
+      before(:all) do
+        $LOAD_PATH.unshift(my_fixture_dir)
+      end
+
+      after(:all) do
+        if Kernel.const_defined?(:Hiera) && Hiera.const_defined?(:Backend)
+          Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
+          Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
+        end
+        $LOAD_PATH.shift
       end
 
       before(:each) do
@@ -1599,19 +1584,8 @@ describe "The lookup function" do
       end
 
       around(:each) do |example|
-        # Faking the load path to enable 'require' to load from 'ruby_stuff'. It removes the need for a static fixture
-        # for the custom backend
-        $LOAD_PATH.unshift(populated_ruby_dir)
-        begin
-          Puppet.override(:environments => environments, :current_environment => env) do
-            example.run
-          end
-        ensure
-          if Kernel.const_defined?(:Hiera) && Hiera.const_defined?(:Backend)
-            Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
-            Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
-          end
-          $LOAD_PATH.shift
+        Puppet.override(:environments => environments, :current_environment => env) do
+          example.run
         end
       end
 
@@ -1834,6 +1808,7 @@ describe "The lookup function" do
                 a_ref: "A reference to %{hiera('a')}"
                 b_ref: "A reference to %{hiera('b')}"
                 c_ref: "%{alias('c')}"
+                :symbol: "A symbol"
                 YAML
             }
           end
@@ -2071,7 +2046,7 @@ describe "The lookup function" do
         end
 
         it 'provides a sensible error message when the hocon library is not loaded' do
-          allow(Puppet.features).to receive(:hocon?).and_return(false)
+          Puppet.features.stubs(:hocon?).returns(false)
 
           expect { lookup('a') }.to raise_error do |e|
             expect(e.message).to match(/Lookup using Hocon data_hash function is not supported without hocon library/)

data/spec/unit/functions/lstrip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the lstrip function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'removes leading whitepsace' do
+    expect(compile_to_catalog("notify { String(\"\t\n abc \".lstrip == 'abc '): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.lstrip == 42): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns lstripped version of each entry in an array' do
+    expect(compile_to_catalog("notify { String([' a ', ' b ', ' c '].lstrip == ['a ', 'b ', 'c ']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns lstripped version of each entry in an Iterator' do
+    expect(compile_to_catalog("notify { String([' a', ' b', ' c'].reverse_each.lstrip == ['c', 'b', 'a']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'errors when given a a nested Array' do
+    expect { compile_to_catalog("['a', 'b', ['c']].lstrip")}.to raise_error(/'lstrip' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
+  end
+
+end