Convert tests to use plain rspec-puppet

Tests in the new style produces the following documentation output:

abs
  should not eq nil
  should run abs() and raise an Puppet::ParseError
  should run abs(-34) and return 34
  should run abs("-34") and return 34
  should run abs(34) and return 34
  should run abs("34") and return 34

1 files changed, 67 insertions, 201 deletions

diff --git a/spec/functions/validate_integer_spec.rb b/spec/functions/validate_integer_spec.rb
index e95da6a..4c0a9d7 100755
--- a/spec/functions/validate_integer_spec.rb
+++ b/spec/functions/validate_integer_spec.rb
@@ -1,224 +1,90 @@
-#! /usr/bin/env ruby -S rspec
-
 require 'spec_helper'
 
-describe Puppet::Parser::Functions.function(:validate_integer) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  describe 'when calling validate_integer from puppet without any argument or to many' do
-    it "should not compile when no argument is passed" do
-      Puppet[:code] = "validate_integer()"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
-    end
-    it "should not compile when more than three arguments are passed" do
-      Puppet[:code] = "validate_integer(1, 1, 1, 1)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
-    end
-  end
-
-  describe 'when calling validate_integer from puppet only with input' do
-    %w{ 1 -1 }.each do |the_number|
-      it "should compile when #{the_number} is an encapsulated integer" do
-        Puppet[:code] = "validate_integer('#{the_number}')"
-        scope.compiler.compile
-      end
-      it "should compile when #{the_number} is an bare integer" do
-        Puppet[:code] = "validate_integer(#{the_number})"
-        scope.compiler.compile
-      end
-    end
-
-    %w{ [1,2,3,4,5] ['1','2','3','4','5'] }.each do |the_number|
-      it "should compile when multiple Integer arguments are passed in an Array" do
-        Puppet[:code] = "validate_integer(#{the_number})"
-        scope.compiler.compile
-      end
-    end
-
-    %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_number|
-      it "should not compile when #{the_number} is in a string" do
-        Puppet[:code] = "validate_integer('#{the_number}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
-      end
-
-      it "should not compile when #{the_number} is a bare word" do
-        Puppet[:code] = "validate_integer(#{the_number})"
-        expect { scope.compiler.compile }.to raise_error
-      end
-    end
-
-    it "should not compile when an Integer is part of a larger String" do
-      Puppet[:code] = "validate_integer('1 test')"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
-    end
+describe 'validate_integer' do
+  describe 'signature validation' do
+    it { is_expected.not_to eq(nil) }
+    it { is_expected.to run.with_params().and_raise_error(Puppet::ParseError, /wrong number of arguments/i) }
+    it { is_expected.to run.with_params(1, 2, 3, 4).and_raise_error(Puppet::ParseError, /wrong number of arguments/i) }
 
-    it "should not compile when an Array with a non-Integer value is passed" do
-      Puppet[:code] = "validate_integer([1, '-7.0'])"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /at array position 1 to be an Integer/)
+    [ true, 'true', false, 'false', 'iAmAString', '1test', '1 test', 'test 1', 'test 1 test', 7.0, -7.0, {}, { 'key' => 'value' }, { 1=> 2 }, '', :undef , 'x'].each do |invalid|
+      it { is_expected.to run.with_params(invalid).and_raise_error(Puppet::ParseError, /to be an Integer/) }
+      it { is_expected.to run.with_params(invalid, 10).and_raise_error(Puppet::ParseError, /to be an Integer/) }
+      it { is_expected.to run.with_params(invalid, 10, -10).and_raise_error(Puppet::ParseError, /to be an Integer/) }
+      it { is_expected.to run.with_params([0, 1, 2, invalid, 3, 4], 10, -10).and_raise_error(Puppet::ParseError, /to be an Integer/) }
     end
 
-    it "should not compile when a Hash is passed" do
-      Puppet[:code] = "validate_integer({ 1 => 2 })"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer or Array/)
+    context 'when running on modern rubies', :unless => RUBY_VERSION == '1.8.7' do
+      it { is_expected.to run.with_params([0, 1, 2, {1=>2}, 3, 4], 10, -10).and_raise_error(Puppet::ParseError, /to be an Integer/) }
     end
 
-    it "should not compile when a Hash is passed as Array" do
-      Puppet[:code] = "validate_integer([{ 1 => 2 }])"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+    context 'when running on ruby, which munges hashes weirdly', :if => RUBY_VERSION == '1.8.7' do
+      it { is_expected.to run.with_params([0, 1, 2, {1=>2}, 3, 4], 10, -10).and_raise_error(Puppet::ParseError) }
+      it { is_expected.to run.with_params([0, 1, 2, {0=>2}, 3, 4], 10, -10).and_raise_error(Puppet::ParseError) }
     end
 
-    it "should not compile when an explicitly undef variable is passed" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        $foo = undef
-        validate_integer($foo)
-      ENDofPUPPETcode
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
-    end
+    it { is_expected.to run.with_params(1, '').and_raise_error(Puppet::ParseError, /to be unset or an Integer/) }
+    it { is_expected.to run.with_params(1, 2, '').and_raise_error(Puppet::ParseError, /to be unset or an Integer/) }
+    it { is_expected.to run.with_params(1, 2, 3).and_raise_error(Puppet::ParseError, /second argument to be larger than third argument/) }
+  end
 
-    it "should not compile when an undefined variable is passed" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        validate_integer($foobarbazishouldnotexist)
-      ENDofPUPPETcode
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
-    end
+  context 'with no range constraints' do
+    it { is_expected.to run.with_params(1) }
+    it { is_expected.to run.with_params(-1) }
+    it { is_expected.to run.with_params('1') }
+    it { is_expected.to run.with_params('-1') }
+    it { is_expected.to run.with_params([1, 2, 3, 4]) }
+    it { is_expected.to run.with_params([1, '2', '3', 4]) }
   end
 
-  describe 'when calling validate_integer from puppet with input and a maximum' do
-    max = 10
-    %w{ 1 -1 }.each do |the_number|
-      it "should compile when #{the_number} is lower than a maximum of #{max}" do
-        Puppet[:code] = "validate_integer(#{the_number},#{max})"
-        scope.compiler.compile
+  context "with a maximum limit of 10" do
+    describe 'rejects numbers greater than the limit' do
+      it { is_expected.to run.with_params(11, 10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+      it { is_expected.to run.with_params(100, 10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+      it { is_expected.to run.with_params(2**65, 10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+      it { is_expected.to run.with_params([1,2,10,100], 10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+    end
+
+    describe 'accepts numbers less or equal to the limit' do
+      it { is_expected.to run.with_params(10, 10) }
+      it { is_expected.to run.with_params(1, 10) }
+      it { is_expected.to run.with_params(-1, 10) }
+      it { is_expected.to run.with_params('1', 10) }
+      it { is_expected.to run.with_params('-1', 10) }
+      it { is_expected.to run.with_params([1, 2, 3, 4], 10) }
+      it { is_expected.to run.with_params([1, '2', '3', 4], 10) }
+    end
+
+    context "with a minimum limit of -10" do
+      describe 'rejects numbers greater than the upper limit' do
+        it { is_expected.to run.with_params(11, 10, -10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+        it { is_expected.to run.with_params(100, 10, -10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+        it { is_expected.to run.with_params(2**65, 10, -10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
+        it { is_expected.to run.with_params([1,2,10,100], 10, -10).and_raise_error(Puppet::ParseError, /to be smaller or equal/) }
       end
-    end
 
-    it "should compile when an Integer is equal the maximum" do
-      Puppet[:code] = "validate_integer(#{max},#{max})"
-      scope.compiler.compile
-    end
-
-    it "should not compile when #{max+1} is greater than a maximum of #{max}" do
-      Puppet[:code] = "validate_integer(#{max+1},#{max})"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
-    end
-
-    %w{ [-10,1,2,3,4,5,10] ['-10','1','2','3','4','5','10'] }.each do |the_number|
-      it "should compile when each element of #{the_number} is lower than a maximum of #{max}" do
-        Puppet[:code] = "validate_integer(#{the_number},#{max})"
-        scope.compiler.compile
+      describe 'rejects numbers smaller than the lower limit' do
+        it { is_expected.to run.with_params(-11, 10, -10).and_raise_error(Puppet::ParseError, /to be greater or equal/) }
+        it { is_expected.to run.with_params(-100, 10, -10).and_raise_error(Puppet::ParseError, /to be greater or equal/) }
+        it { is_expected.to run.with_params(-2**65, 10, -10).and_raise_error(Puppet::ParseError, /to be greater or equal/) }
+        it { is_expected.to run.with_params([-10, 1,2,10,-100], 10, -10).and_raise_error(Puppet::ParseError, /to be greater or equal/) }
       end
-    end
-
-    it "should not compile when an element of an Array [-10,1,2,3,4,5,#{max+1}] is greater than a maximum of #{max}" do
-      Puppet[:code] = "validate_integer([-10,1,2,3,4,5,#{max+1}],#{max})"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
-    end
 
-    %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_max|
-      it "should not compile when a non-Integer maximum #{the_max}, encapsulated in a String, is passed" do
-        Puppet[:code] = "validate_integer(1,'#{the_max}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+      describe 'accepts numbers between and including the limits' do
+        it { is_expected.to run.with_params(10, 10, -10) }
+        it { is_expected.to run.with_params(-10, 10, -10) }
+        it { is_expected.to run.with_params(1, 10, -10) }
+        it { is_expected.to run.with_params(-1, 10, -10) }
+        it { is_expected.to run.with_params('1', 10, -10) }
+        it { is_expected.to run.with_params('-1', 10, -10) }
+        it { is_expected.to run.with_params([1, 2, 3, 4], 10, -10) }
+        it { is_expected.to run.with_params([1, '2', '3', 4], 10, -10) }
       end
- 
-      it "should not compile when a non-Integer maximum #{the_max} bare word is passed" do
-        Puppet[:code] = "validate_integer(1,#{the_max})"
-        expect { scope.compiler.compile }.to raise_error
-      end
-    end
-
-    it "should not compile when an explicitly undefined variable is passed as maximum and no minimum is passed" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        $foo = undef
-        validate_integer(10, $foo)
-      ENDofPUPPETcode
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
-    end
-    it "should not compile when an explicitly undef is passed as maximum and no minimum is passed" do
-      Puppet[:code] = "validate_integer(10, undef)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
-    end
-    it "should not compile when an empty string is passed as maximum and no minimum is passed" do
-      Puppet[:code] = "validate_integer(10, '')"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
-    end
-    it "should not compile when an undefined variable for a maximum is passed" do
-      Puppet[:code] = "validate_integer(10, $foobarbazishouldnotexist)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
     end
   end
 
-  describe 'when calling validate_integer from puppet with input, a maximum and a minimum' do
-    it "should not compile when a minimum larger than maximum is passed" do
-      Puppet[:code] = "validate_integer(1,1,2)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /second argument to be larger than third argument/)
-    end
+  it { is_expected.to run.with_params(10, 10, 10) }
 
-    max = 10
-    min = -10
-    %w{ 1 -1 }.each do |the_number|
-      it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
-        Puppet[:code] = "validate_integer(#{the_number},#{max},#{min})"
-        scope.compiler.compile
-      end
-    end
-
-    it "should compile when an Integer is equal the minimum" do
-      Puppet[:code] = "validate_integer(#{min},#{max},#{min})"
-      scope.compiler.compile
-    end
-
-    it "should compile when an Integer is equal the minimum and maximum" do
-      Puppet[:code] = "validate_integer(#{max},#{max},#{max})"
-      scope.compiler.compile
-    end
-
-    it "should compile when an empty maximum is passed and the Integer is greater than the minimum" do
-      Puppet[:code] = "validate_integer(#{max},'',#{min})"
-      scope.compiler.compile
-    end
-    it "should compile when an explicitly undefined maximum is passed and the Integer is greater than the minimum" do
-      Puppet[:code] = "validate_integer(#{max},undef,#{min})"
-      scope.compiler.compile
-    end
-    it "should compile when an explicitly undefined variable is passed for maximum and the Integer is greater than the minimum" do
-      Puppet[:code] = <<-"ENDofPUPPETcode"
-        $foo = undef
-        validate_integer(#{max}, $foo, #{min})
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-    it "should not compile when no maximum value is given and the Integer is greater than the minimum" do
-      Puppet[:code] = "validate_integer(#{max},,#{min})"
-      expect { scope.compiler.compile }.to raise_error(Puppet::Error, /Syntax error at ','/)
-    end
-
-    it "should not compile when #{min-1} is lower than a minimum of #{min}" do
-      Puppet[:code] = "validate_integer(#{min-1},#{max},#{min})"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
-    end
-
-    %w{ [-10,1,2,3,4,5,10] ['-10','1','2','3','4','5','10'] }.each do |the_number|
-      it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
-        Puppet[:code] = "validate_integer(#{the_number},#{max},#{min})"
-        scope.compiler.compile
-      end
-    end
-
-    it "should not compile when an element of an Array [#{min-1},1,2,3,4,5,10] is lower than a minimum of #{min}" do
-      Puppet[:code] = "validate_integer([#{min-1},1,2,3,4,5,10],#{max},#{min})"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
-    end
-
-    %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_min|
-      it "should not compile when a non-Integer minimum #{the_min}, encapsulated in a String, is passed" do
-        Puppet[:code] = "validate_integer(1,#{max},'#{the_min}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
-      end
- 
-      it "should not compile when a non-Integer minimum #{the_min} bare word is passed" do
-        Puppet[:code] = "validate_integer(1,#{max},#{the_min})"
-        expect { scope.compiler.compile }.to raise_error
-      end
-    end
+  describe 'empty upper limit is interpreted as infinity' do
+    it { is_expected.to run.with_params(11, '', 10) }
   end
 end