puppet 5.0.0 → 6.0.0

data/spec/unit/functions/size_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the size 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(size([])): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(size([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(size({})): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(size({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(size('')): }")).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(size("\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(size(Binary(''))): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of bytes when not empty' do
+      expect(compile_to_catalog("notify { String(size(Binary('b25l'))): }")).to have_resource('Notify[3]')
+    end
+  end
+end

data/spec/unit/functions/sort_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the sort function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+    {
+      "'bac'"     => "'abc'",
+      "'BaC'"     => "'BCa'",
+    }.each_pair do |value, expected|
+      it "sorts characters in a string such that #{value}.sort results in #{expected}" do
+        expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+
+  {
+     "'bac'"     => "'abc'",
+     "'BaC'"     => "'aBC'",
+   }.each_pair do |value, expected|
+     it "accepts a lambda when sorting characters in a string such that #{value} results in #{expected}" do
+       expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
+     end
+   end
+
+  {
+    ['b', 'a', 'c']     => ['a', 'b', 'c'],
+    ['B', 'a', 'C']     => ['B', 'C', 'a'],
+  }.each_pair do |value, expected|
+    it "sorts strings in an array such that #{value}.sort results in #{expected}" do
+      expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ['b', 'a', 'c']     => ['a', 'b', 'c'],
+    ['B', 'a', 'C']     => ['a', 'B', 'C'],
+  }.each_pair do |value, expected|
+    it "accepts a lambda when sorting an array such that #{value} results in #{expected}" do
+      expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  it 'errors if given a mix of data types' do
+    expect { compile_to_catalog("sort([1, 'a'])")}.to raise_error(/comparison .* failed/)
+  end
+
+  it 'returns empty string for empty string input' do
+    expect(compile_to_catalog("notify { String(sort('') == ''): }")).to have_resource("Notify[true]")
+  end
+
+  it 'returns empty string for empty string input' do
+    expect(compile_to_catalog("notify { String(sort([]) == []): }")).to have_resource("Notify[true]")
+  end
+
+  it 'can sort mixed data types when using a lambda' do
+    # source sorts Numeric before string and uses compare() for same data type
+    src = <<-SRC
+    notify{ String(sort(['b', 3, 'a', 2]) |$a, $b| {
+        case [$a, $b] {
+          [String, Numeric] : { 1 }
+          [Numeric, String] : { -1 }
+          default:            { compare($a, $b) }
+        }
+      } == [2, 3,'a', 'b']):
+    }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+
+  end
+
+  it 'errors if lambda does not accept 2 arguments' do
+    expect { compile_to_catalog("sort([1, 'a']) || { }")}.to raise_error(/block expects 2 arguments/)
+    expect { compile_to_catalog("sort([1, 'a']) |$x| { }")}.to raise_error(/block expects 2 arguments/)
+    expect { compile_to_catalog("sort([1, 'a']) |$x,$y, $z| { }")}.to raise_error(/block expects 2 arguments/)
+  end
+end

data/spec/unit/functions/split_spec.rb

@@ -4,14 +4,13 @@ require 'puppet/loaders'
 
 describe 'the split function' do
 
-  before(:all) do
+  before(:each) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
   end
 
-  after(:all) do
-    Puppet::Pops::Loaders.clear
-    Puppet::pop_context()
+  after(:each) do
+    Puppet.pop_context()
   end
 
   def split(*args)

data/spec/unit/functions/step_spec.rb

@@ -52,7 +52,7 @@ describe 'the step method' do
       compile_to_catalog(<<-MANIFEST)
         [1].step(0) |$x| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1, default\] value, got Integer\[0, 0\]/)
+    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1\] value, got Integer\[0, 0\]/)
   end
 
   it 'raises an error when step is not an integer' do

data/spec/unit/functions/strftime_spec.rb

@@ -129,7 +129,7 @@ describe 'the strftime function' 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/)
+      expect(warnings[0]).to match(/The argument signature \(String format, \[String timezone\]\) is deprecated for #strftime/)
     end
 
     it 'produces the current time formatted with specific timezone when used with two arguments' do
@@ -145,7 +145,7 @@ describe 'the strftime function' 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/)
+      expect(warnings[0]).to match(/The argument signature \(String format, \[String timezone\]\) is deprecated for #strftime/)
     end
   end
 end

data/spec/unit/functions/strip_spec.rb

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