puppet 5.4.0-universal-darwin → 5.5.0-universal-darwin

data/spec/unit/file_bucket/dipper_spec.rb

@@ -153,9 +153,6 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
 
-        onehour=60*60
-        twohours=onehour*2
-
         #First File
         file1 = make_tmp_file(plaintext)
         real_path = Pathname.new(file1).realpath
@@ -182,7 +179,6 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         checksum = digest(plaintext)
         expect(digest(plaintext)).to eq(checksum)
         expect(@dipper.backup(file3)).to eq(checksum)
-        date = Time.now
         expected_list3 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
 
         result = @dipper.list(nil, nil)

data/spec/unit/file_serving/content_spec.rb

@@ -25,7 +25,6 @@ describe Puppet::FileServing::Content do
   it "should not retrieve and store its contents when its attributes are collected" do
     content = Puppet::FileServing::Content.new(path)
 
-    result = "foo"
     File.expects(:read).with(path).never
     content.collect
 

data/spec/unit/file_serving/fileset_spec.rb

@@ -277,7 +277,6 @@ describe Puppet::FileServing::Fileset do
     it "works when paths have regexp significant characters" do
       @path = make_absolute("/my/path/rV1x2DafFr0R6tGG+1bbk++++TM")
       stat = stub('dir_stat', :directory? => true)
-      stub_file = stub(@path, :stat => stat, :lstat => stat)
       Puppet::FileSystem.expects(:lstat).with(@path).returns stub(@path, :stat => stat, :lstat => stat)
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)

data/spec/unit/file_serving/metadata_spec.rb

@@ -495,7 +495,6 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
         path = "/base/path/my/file"
         @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
         stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-        stub_file = stub(:readlink => "/some/other/path", :lstat => stat)
         Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
         Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
         @file.stubs("#{digest_algorithm}_file".intern).returns(checksum) # Remove these when :managed links are no longer checksumed.

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -56,8 +56,6 @@ describe Puppet::FileServing::TerminusSelector do
       end
 
       it "should choose :file_server when default_file_terminus is file_server and no server is specified on the request" do
-        modules = mock 'modules'
-
         @request.expects(:protocol).returns "puppet"
         @request.expects(:server).returns nil
         Puppet[:default_file_terminus] = 'file_server'

data/spec/unit/forge_spec.rb

@@ -270,8 +270,7 @@ describe Puppet::Forge do
     end
 
     it "ignores modules with unparseable dependencies" do
-      expect { result = forge.fetch('puppetlabs/bacula') }.to_not raise_error
-      expect { result.to be_empty }
+      expect(forge.fetch('puppetlabs/bacula')).to be_empty
     end
   end
 end

data/spec/unit/functions/assert_type_spec.rb

@@ -42,7 +42,7 @@ describe 'the assert_type function' do
   end
 
   it 'can be called with a callable that receives a specific type' do
-    expected, actual, actual2 = func.call({}, 'Optional[String]', 1) { |expected, actual| [expected, actual, actual] }
+    expected, actual, actual2 = func.call({}, 'Optional[String]', 1) { |expctd, actul| [expctd, actul, actul] }
     expect(expected.to_s).to eql('Optional[String]')
     expect(actual.to_s).to eql('Integer[1, 1]')
     expect(actual2.to_s).to eql('Integer[1, 1]')

data/spec/unit/functions/empty_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the empty function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  context 'for an array it' do
+    it 'returns true when empty' do
+      expect(compile_to_catalog("notify { String(empty([])): }")).to have_resource('Notify[true]')
+    end
+
+    it 'returns false when not empty' do
+      expect(compile_to_catalog("notify { String(empty([1])): }")).to have_resource('Notify[false]')
+    end
+  end
+
+  context 'for a hash it' do
+    it 'returns true when empty' do
+      expect(compile_to_catalog("notify { String(empty({})): }")).to have_resource('Notify[true]')
+    end
+
+    it 'returns false when not empty' do
+      expect(compile_to_catalog("notify { String(empty({1=>1})): }")).to have_resource('Notify[false]')
+    end
+  end
+
+  context 'for numeric values it' do
+    it 'always returns false for integer values (including 0)' do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String(empty(0)): }")).to have_resource('Notify[false]')
+      end
+      expect(warnings).to include(/Calling function empty\(\) with Numeric value is deprecated/)
+    end
+
+    it 'always returns false for float values (including 0.0)' do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String(empty(0.0)): }")).to have_resource('Notify[false]')
+      end
+      expect(warnings).to include(/Calling function empty\(\) with Numeric value is deprecated/)
+    end
+  end
+
+  context 'for a string it' do
+    it 'returns true when empty' do
+      expect(compile_to_catalog("notify { String(empty('')): }")).to have_resource('Notify[true]')
+    end
+
+    it 'returns false when not empty' do
+      expect(compile_to_catalog("notify { String(empty(' ')): }")).to have_resource('Notify[false]')
+    end
+  end
+
+  context 'for a binary it' do
+    it 'returns true when empty' do
+      expect(compile_to_catalog("notify { String(empty(Binary(''))): }")).to have_resource('Notify[true]')
+    end
+
+    it 'returns false when not empty' do
+      expect(compile_to_catalog("notify { String(empty(Binary('b25l'))): }")).to have_resource('Notify[false]')
+    end
+  end
+
+  context 'for undef it' do
+    it 'returns true and issues deprecation warning' do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String(empty(undef)): }")).to have_resource('Notify[true]')
+      end
+      expect(warnings).to include(/Calling function empty\(\) with Undef value is deprecated/)
+    end
+  end
+end

data/spec/unit/functions/epp_spec.rb

@@ -164,6 +164,6 @@ describe "the epp function" do
   end
 
   def epp_function()
-    epp_func = scope.compiler.loaders.public_environment_loader.load(:function, 'epp')
+    scope.compiler.loaders.public_environment_loader.load(:function, 'epp')
   end
 end

data/spec/unit/functions/flatten_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the flatten function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:array_fmt) { { 'format' => "%(a", 'separator'=>""} }
+
+  it 'returns flattened array of all its given arguments' do
+    expect(compile_to_catalog("notify { String([1,[2,[3]]].flatten, Array => #{array_fmt}): }")).to have_resource('Notify[(123)]')
+  end
+
+  it 'accepts a single non array value which results in it being wrapped in an array' do
+    expect(compile_to_catalog("notify { String(flatten(1), Array => #{array_fmt}): }")).to have_resource('Notify[(1)]')
+  end
+
+  it 'accepts a single array value - (which is a noop)' do
+    expect(compile_to_catalog("notify { String(flatten([1]), Array => #{array_fmt}): }")).to have_resource('Notify[(1)]')
+  end
+
+  it 'it does not flatten a hash - it is a value that gets wrapped' do
+    expect(compile_to_catalog("notify { String(flatten({a=>1}), Array => #{array_fmt}): }")).to have_resource("Notify[({'a' => 1})]")
+  end
+
+  it 'accepts mix of array and non array arguments and concatenates and flattens them' do
+    expect(compile_to_catalog("notify { String(flatten([1],2,[[3,4]]), Array => #{array_fmt}): }")).to have_resource('Notify[(1234)]')
+  end
+end

data/spec/unit/functions/include_spec.rb

@@ -92,7 +92,7 @@ describe 'The "include" function' do
 
   it "raises an error if class does not exist" do
     expect {
-      catalog = compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST)
         include the_god_in_your_religion
       MANIFEST
     }.to raise_error(Puppet::Error)
@@ -105,7 +105,7 @@ describe 'The "include" function' do
     }.each_pair do |value, name_kind|
       it "raises an error if class is #{name_kind}" do
         expect {
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             include #{value}
           MANIFEST
         }.to raise_error(/Cannot use #{name_kind}/)

data/spec/unit/functions/inline_epp_spec.rb

@@ -83,7 +83,7 @@ describe "the inline_epp function" do
   end
 
   def epp_function()
-    epp_func = scope.compiler.loaders.public_environment_loader.load(:function, 'inline_epp')
+    scope.compiler.loaders.public_environment_loader.load(:function, 'inline_epp')
   end
 
 end

data/spec/unit/functions/join_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the join function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'joins an array with empty string delimiter if delimiter is not given' do
+    expect(compile_to_catalog("notify { join([1,2,3]): }")).to have_resource('Notify[123]')
+  end
+
+  it 'joins an array with given string delimiter' do
+    expect(compile_to_catalog("notify { join([1,2,3],'x'): }")).to have_resource('Notify[1x2x3]')
+  end
+
+  it 'results in empty string if array is empty' do
+    expect(compile_to_catalog('notify { "x${join([])}y": }')).to have_resource('Notify[xy]')
+  end
+
+  it 'flattens nested arrays' do
+    expect(compile_to_catalog("notify { join([1,2,[3,4]]): }")).to have_resource('Notify[1234]')
+  end
+
+  it 'does not flatten arrays nested in hashes' do
+    expect(compile_to_catalog("notify { join([1,2,{a => [3,4]}]): }")).to have_resource('Notify[12{"a"=>[3, 4]}]')
+  end
+
+  it 'formats nil/undef as empty string' do
+    expect(compile_to_catalog('notify { join([undef, undef], "x"): }')).to have_resource('Notify[x]')
+  end
+end

data/spec/unit/functions/keys_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the keys function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'returns the keys in the hash in the order they appear in a hash iteration' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[apples & oranges]')
+        $k = {'apples' => 1, 'oranges' => 2}.keys
+        notify { "${k[0]} & ${k[1]}": }
+      SRC
+  end
+
+  it 'returns an empty array for an empty hash' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[0]')
+        $v = {}.keys.reduce(0) |$m, $v| { $m+1 }
+        notify { "${v}": }
+      SRC
+  end
+
+  it 'includes an undef key if one is present in the hash' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[Undef]')
+        $types = {undef => 1}.keys.map |$v| { $v.type }
+        notify { "${types[0]}": }
+      SRC
+  end
+
+end

data/spec/unit/functions/length_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the length function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'for an array it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(length([])): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(length([1, 2, 3])): }")).to have_resource('Notify[3]')
+    end
+  end
+
+  context 'for a hash it' do
+    it 'returns 0 empty' do
+      expect(compile_to_catalog("notify { String(length({})): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(length({1=>1,2=>2})): }")).to have_resource('Notify[2]')
+    end
+  end
+
+  context 'for a string it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(length('')): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of characters when not empty' do
+      # note the multibyte characters - åäö each taking two bytes in UTF-8
+      expect(compile_to_catalog('notify { String(length("\u00e5\u00e4\u00f6")): }')).to have_resource('Notify[3]')
+    end
+  end
+
+  context 'for a binary it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(length(Binary(''))): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of bytes when not empty' do
+      expect(compile_to_catalog("notify { String(length(Binary('b25l'))): }")).to have_resource('Notify[3]')
+    end
+  end
+end

data/spec/unit/functions/lookup_fixture_spec.rb

@@ -47,7 +47,7 @@ describe 'The lookup function' do
   def compile_and_get_notifications(code)
     Puppet[:code] = code
     node.environment.check_for_reparse
-    catalog = block_given? ? compiler.compile { |catalog| yield(compiler.topscope); catalog } : compiler.compile
+    catalog = block_given? ? compiler.compile { |cat| yield(compiler.topscope); cat } : compiler.compile
     catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
   end
 

data/spec/unit/functions/lookup_spec.rb

@@ -2806,9 +2806,29 @@ describe "The lookup function" do
           mod_a::f:
             a:
               a: value mod_a::f.a.a (from module)
+          mod_a::to_array1: 'hello'
+          mod_a::to_array2: 'hello'
+          mod_a::to_int: 'bananas'
+          mod_a::to_bad_type: 'pyjamas'
+          mod_a::undef_value: null
           lookup_options:
             mod_a::e:
               merge: deep
+            mod_a::to_array1:
+              merge: deep
+              convert_to: "Array"
+            mod_a::to_array2:
+              convert_to:
+                - "Array"
+                - true
+            mod_a::to_int:
+              convert_to: "Integer"
+            mod_a::to_bad_type:
+              convert_to: "ComicSans"
+            mod_a::undef_value:
+              convert_to:
+                - "Array"
+                - true
           YAML
 
 
@@ -2896,6 +2916,38 @@ describe "The lookup function" do
           expect(lookup('mod_a::d')).to eql('a' => 'value mod_a::d.a (from module)')
         end
 
+        context "and conversion via convert_to" do
+          it 'converts with a single data type value' do
+            expect(lookup('mod_a::to_array1')).to eql(['h', 'e', 'l', 'l', 'o'])
+          end
+
+          it 'converts with an array of arguments to the convert_to call' do
+            expect(lookup('mod_a::to_array2')).to eql(['hello'])
+          end
+
+          it 'converts an undef/nil value that has convert_to option' do
+            expect(lookup('mod_a::undef_value')).to eql([nil])
+          end
+
+          it 'errors if a convert_to lookup_option cannot be performed because value does not match type' do
+            expect{lookup('mod_a::to_int')}.to raise_error(/The convert_to lookup_option for key 'mod_a::to_int' raised error.*The string 'bananas' cannot be converted to Integer/)
+          end
+
+          it 'errors if a convert_to lookup_option cannot be performed because type does not exist' do
+            expect{lookup('mod_a::to_bad_type')}.to raise_error(/The convert_to lookup_option for key 'mod_a::to_bad_type' raised error.*Creation of new instance of type 'TypeReference\['ComicSans'\]' is not supported/)
+          end
+
+          it 'adds explanation that conversion took place with a type' do
+            explanation = explain('mod_a::to_array1')
+            expect(explanation).to include('Applying convert_to lookup_option with arguments [Array]')
+          end
+
+          it 'adds explanation that conversion took place with a type and arguments' do
+            explanation = explain('mod_a::to_array2')
+            expect(explanation).to include('Applying convert_to lookup_option with arguments [Array, true]')
+          end
+        end
+
         it 'the default hierarchy lookup is included in the explain output' do
           explanation = explain('mod_a::c')
           expect(explanation).to match(/Searching default_hierarchy of module "mod_a".+Original path: "defaults.yaml"/m)

data/spec/unit/functions/shared.rb

@@ -88,7 +88,7 @@ shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
   it "is not available when --tasks is on" do
     Puppet[:tasks] = true
     expect do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST)
         #{function}(bar)
       MANIFEST
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)

data/spec/unit/functions/values_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the values function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'returns the values in the hash in the order they appear in a hash iteration' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[1 & 2]')
+        $k = {'apples' => 1, 'oranges' => 2}.values
+        notify { "${k[0]} & ${k[1]}": }
+      SRC
+  end
+
+  it 'returns an empty array for an empty hash' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[0]')
+        $v = {}.values.reduce(0) |$m, $v| { $m+1 }
+        notify { "${v}": }
+      SRC
+  end
+
+  it 'includes an undef value if one is present in the hash' do
+    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[Undef]')
+        $types = {a => undef}.values.map |$v| { $v.type }
+        notify { "${types[0]}": }
+    SRC
+  end
+end