Merge pull request #397 from cyberious/4.6.x

4.6.x

6 files changed, 168 insertions, 47 deletions

diff --git a/spec/functions/concat_spec.rb b/spec/functions/concat_spec.rb
index 49cb2ad..49fa6bb 100755
--- a/spec/functions/concat_spec.rb
+++ b/spec/functions/concat_spec.rb
@@ -4,14 +4,19 @@ require 'spec_helper'
 describe "the concat function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
-  it "should raise a ParseError if the client does not provide two arguments" do
+  it "should raise a ParseError if the client does not provide at least two arguments" do
     expect { scope.function_concat([]) }.to(raise_error(Puppet::ParseError))
+    expect { scope.function_concat([[1]]) }.to(raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if the first parameter is not an array" do
     expect { scope.function_concat([1, []])}.to(raise_error(Puppet::ParseError))
   end
 
+  it "should not raise a ParseError if the client provides more than two arguments" do
+    expect { scope.function_concat([[1],[2],[3]]) }.not_to raise_error
+  end
+
   it "should be able to concat an array" do
     result = scope.function_concat([['1','2','3'],['4','5','6']])
     expect(result).to(eq(['1','2','3','4','5','6']))
@@ -32,4 +37,14 @@ describe "the concat function" do
     result = scope.function_concat([array_original,['4','5','6']])
     array_original.should(eq(['1','2','3']))
   end
+
+  it "should be able to concat multiple arrays" do
+    result = scope.function_concat([['1','2','3'],['4','5','6'],['7','8','9']])
+    expect(result).to(eq(['1','2','3','4','5','6','7','8','9']))
+  end
+
+  it "should be able to concat mix of primitives and arrays to a final array" do
+    result = scope.function_concat([['1','2','3'],'4',['5','6','7']])
+    expect(result).to(eq(['1','2','3','4','5','6','7']))
+  end
 end
diff --git a/spec/functions/delete_spec.rb b/spec/functions/delete_spec.rb
index 39b3176..c8edd78 100755
--- a/spec/functions/delete_spec.rb
+++ b/spec/functions/delete_spec.rb
@@ -9,48 +9,53 @@ describe "the delete function" do
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    expect { scope.function_delete([]) }.to( raise_error(Puppet::ParseError))
+    expect { scope.function_delete([]) }.to(raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there are greater than 2 arguments" do
-    expect { scope.function_delete([[], 'foo', 'bar']) }.to( raise_error(Puppet::ParseError))
+    expect { scope.function_delete([[], 'foo', 'bar']) }.to(raise_error(Puppet::ParseError))
   end
 
   it "should raise a TypeError if a number is passed as the first argument" do
-    expect { scope.function_delete([1, 'bar']) }.to( raise_error(TypeError))
+    expect { scope.function_delete([1, 'bar']) }.to(raise_error(TypeError))
   end
 
   it "should delete all instances of an element from an array" do
-    result = scope.function_delete([['a','b','c','b'],'b'])
-    expect(result).to(eq(['a','c']))
+    result = scope.function_delete([['a', 'b', 'c', 'b'], 'b'])
+    expect(result).to(eq(['a', 'c']))
   end
 
   it "should delete all instances of a substring from a string" do
-    result = scope.function_delete(['foobarbabarz','bar'])
+    result = scope.function_delete(['foobarbabarz', 'bar'])
     expect(result).to(eq('foobaz'))
   end
 
   it "should delete a key from a hash" do
-    result = scope.function_delete([{ 'a' => 1, 'b' => 2, 'c' => 3 },'b'])
-    expect(result).to(eq({ 'a' => 1, 'c' => 3 }))
+    result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, 'b'])
+    expect(result).to(eq({'a' => 1, 'c' => 3}))
+  end
+
+  it 'should accept an array of items to delete' do
+    result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, ['b', 'c']])
+    expect(result).to(eq({'a' => 1}))
   end
 
   it "should not change origin array passed as argument" do
-    origin_array = ['a','b','c','d']
+    origin_array = ['a', 'b', 'c', 'd']
     result = scope.function_delete([origin_array, 'b'])
-    expect(origin_array).to(eq(['a','b','c','d']))
+    expect(origin_array).to(eq(['a', 'b', 'c', 'd']))
   end
 
   it "should not change the origin string passed as argument" do
     origin_string = 'foobarbabarz'
-    result = scope.function_delete([origin_string,'bar'])
+    result = scope.function_delete([origin_string, 'bar'])
     expect(origin_string).to(eq('foobarbabarz'))
   end
 
   it "should not change origin hash passed as argument" do
-    origin_hash = { 'a' => 1, 'b' => 2, 'c' => 3 }
+    origin_hash = {'a' => 1, 'b' => 2, 'c' => 3}
     result = scope.function_delete([origin_hash, 'b'])
-    expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
+    expect(origin_hash).to(eq({'a' => 1, 'b' => 2, 'c' => 3}))
   end
 
 end
diff --git a/spec/functions/type3x_spec.rb b/spec/functions/type3x_spec.rb
new file mode 100644
index 0000000..d21236a
--- /dev/null
+++ b/spec/functions/type3x_spec.rb
@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the type3x function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+  it "should exist" do
+    expect(Puppet::Parser::Functions.function("type3x")).to eq("function_type3x")
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    expect { scope.function_type3x([]) }.to( raise_error(Puppet::ParseError))
+  end
+
+  it "should return string when given a string" do
+    result = scope.function_type3x(["aaabbbbcccc"])
+    expect(result).to(eq('string'))
+  end
+
+  it "should return array when given an array" do
+    result = scope.function_type3x([["aaabbbbcccc","asdf"]])
+    expect(result).to(eq('array'))
+  end
+
+  it "should return hash when given a hash" do
+    result = scope.function_type3x([{"a"=>1,"b"=>2}])
+    expect(result).to(eq('hash'))
+  end
+
+  it "should return integer when given an integer" do
+    result = scope.function_type3x(["1"])
+    expect(result).to(eq('integer'))
+  end
+
+  it "should return float when given a float" do
+    result = scope.function_type3x(["1.34"])
+    expect(result).to(eq('float'))
+  end
+
+  it "should return boolean when given a boolean" do
+    result = scope.function_type3x([true])
+    expect(result).to(eq('boolean'))
+  end
+end
diff --git a/spec/functions/type_spec.rb b/spec/functions/type_spec.rb
index 9dfe9d7..b683fcf 100755
--- a/spec/functions/type_spec.rb
+++ b/spec/functions/type_spec.rb
@@ -7,8 +7,9 @@ describe "the type function" do
     expect(Puppet::Parser::Functions.function("type")).to eq("function_type")
   end
 
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_type([]) }.to( raise_error(Puppet::ParseError))
+  it "should give a deprecation warning when called" do
+    scope.expects(:warning).with("type() DEPRECATED: This function will cease to function on Puppet 4; please use type3x() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
+    scope.function_type(["aoeu"])
   end
 
   it "should return string when given a string" do
diff --git a/spec/functions/validate_absolute_path_spec.rb b/spec/functions/validate_absolute_path_spec.rb
index 342ae84..36c836b 100755
--- a/spec/functions/validate_absolute_path_spec.rb
+++ b/spec/functions/validate_absolute_path_spec.rb
@@ -39,6 +39,11 @@ describe Puppet::Parser::Functions.function(:validate_absolute_path) do
           expect { subject.call [path] }.not_to raise_error
         end
       end
+      valid_paths do
+        it "validate_absolute_path(#{valid_paths.inspect}) should not fail" do
+          expect { subject.call [valid_paths] }.not_to raise_error
+        end
+      end
     end
 
     context "Puppet without mocking" do
@@ -47,6 +52,11 @@ describe Puppet::Parser::Functions.function(:validate_absolute_path) do
           expect { subject.call [path] }.not_to raise_error
         end
       end
+      valid_paths do
+        it "validate_absolute_path(#{valid_paths.inspect}) should not fail" do
+          expect { subject.call [valid_paths] }.not_to raise_error
+        end
+      end
     end
   end
 
@@ -55,6 +65,7 @@ describe Puppet::Parser::Functions.function(:validate_absolute_path) do
       [
         nil,
         [ nil ],
+        [ nil, nil ],
         { 'foo' => 'bar' },
         { },
         '',
@@ -66,19 +77,28 @@ describe Puppet::Parser::Functions.function(:validate_absolute_path) do
     end
 
     context 'Relative paths' do
-      %w{
-        relative1
-        .
-        ..
-        ./foo
-        ../foo
-        etc/puppetlabs/puppet
-        opt/puppet/bin
-      }.each do |path|
+      def self.rel_paths 
+        %w{
+          relative1
+          .
+          ..
+          ./foo
+          ../foo
+          etc/puppetlabs/puppet
+          opt/puppet/bin
+        }
+      end
+      rel_paths.each do |path|
         it "validate_absolute_path(#{path.inspect}) should fail" do
           expect { subject.call [path] }.to raise_error Puppet::ParseError
         end
       end
+      rel_paths do
+        it "validate_absolute_path(#{rel_paths.inspect}) should fail" do
+          expect { subject.call [rel_paths] }.to raise_error Puppet::ParseError
+        end
+      end
     end
   end
 end
+
diff --git a/spec/functions/validate_cmd_spec.rb b/spec/functions/validate_cmd_spec.rb
index a6e68df..7cb9782 100755
--- a/spec/functions/validate_cmd_spec.rb
+++ b/spec/functions/validate_cmd_spec.rb
@@ -12,37 +12,74 @@ describe Puppet::Parser::Functions.function(:validate_cmd) do
     scope.method(function_name)
   end
 
-  describe "with an explicit failure message" do
-    it "prints the failure message on error" do
-      expect {
-        subject.call ['', '/bin/false', 'failure message!']
-      }.to raise_error Puppet::ParseError, /failure message!/
+  context 'with no % placeholder' do
+    describe "with an explicit failure message" do
+      it "prints the failure message on error" do
+        expect {
+          subject.call ['', '/bin/false', 'failure message!']
+        }.to raise_error Puppet::ParseError, /failure message!/
+      end
     end
-  end
 
-  describe "on validation failure" do
-    it "includes the command error output" do
-      expect {
-        subject.call ['', "#{TOUCHEXE} /cant/touch/this"]
-      }.to raise_error Puppet::ParseError, /(cannot touch|o such file or)/
+    describe "on validation failure" do
+      it "includes the command error output" do
+        expect {
+          subject.call ['', "#{TOUCHEXE} /cant/touch/this"]
+        }.to raise_error Puppet::ParseError, /(cannot touch|o such file or)/
+      end
+
+      it "includes the command return value" do
+        expect {
+          subject.call ['', '/cant/run/this']
+        }.to raise_error Puppet::ParseError, /returned 1\b/
+      end
     end
 
-    it "includes the command return value" do
-      expect {
-        subject.call ['', '/cant/run/this']
-      }.to raise_error Puppet::ParseError, /returned 1\b/
+    describe "when performing actual validation" do
+      it "can positively validate file content" do
+        expect { subject.call ["non-empty", "#{TESTEXE} -s"] }.to_not raise_error
+      end
+
+      it "can negatively validate file content" do
+        expect {
+          subject.call ["", "#{TESTEXE} -s"]
+        }.to raise_error Puppet::ParseError, /failed to validate.*test -s/
+      end
     end
   end
 
-  describe "when performing actual validation" do
-    it "can positively validate file content" do
-      expect { subject.call ["non-empty", "#{TESTEXE} -s"] }.to_not raise_error
+  context 'with % placeholder' do
+    describe "with an explicit failure message" do
+      it "prints the failure message on error" do
+        expect {
+          subject.call ['', '/bin/false % -f', 'failure message!']
+        }.to raise_error Puppet::ParseError, /failure message!/
+      end
     end
+    describe "on validation failure" do
+      it "includes the command error output" do
+        expect {
+          subject.call ['', "#{TOUCHEXE} /cant/touch/this"]
+        }.to raise_error Puppet::ParseError, /(cannot touch|o such file or)/
+      end
+
+      it "includes the command return value" do
+        expect {
+          subject.call ['', '/cant/run/this % -z']
+        }.to raise_error Puppet::ParseError, /Execution of '\/cant\/run\/this .+ -z' returned 1/
+      end
+    end
+
+    describe "when performing actual validation" do
+      it "can positively validate file content" do
+        expect { subject.call ["non-empty", "#{TESTEXE} -s %"] }.to_not raise_error
+      end
 
-    it "can negatively validate file content" do
-      expect {
-        subject.call ["", "#{TESTEXE} -s"]
-      }.to raise_error Puppet::ParseError, /failed to validate.*test -s/
+      it "can negatively validate file content" do
+        expect {
+          subject.call ["", "#{TESTEXE} -s %"]
+        }.to raise_error Puppet::ParseError, /failed to validate.*test -s/
+      end
     end
   end
 end