From f8f147e794ad305bb8f2dbf5e3a612f0659834ba Mon Sep 17 00:00:00 2001
From: Hunter Haugen <hunter@puppetlabs.com>
Date: Tue, 8 Apr 2014 15:04:55 -0700
Subject: Add success/fail groups

---
 spec/acceptance/abs_spec.rb                 | 36 +++++++-------
 spec/acceptance/any2array_spec.rb           | 66 +++++++++++++------------
 spec/acceptance/base64_spec.rb              | 18 ++++---
 spec/acceptance/bool2num_spec.rb            | 40 +++++++--------
 spec/acceptance/capitalize_spec.rb          | 42 ++++++++--------
 spec/acceptance/chomp_spec.rb               | 26 +++++-----
 spec/acceptance/chop_spec.rb                | 66 +++++++++++++------------
 spec/acceptance/concat_spec.rb              | 20 ++++----
 spec/acceptance/count_spec.rb               | 36 +++++++-------
 spec/acceptance/deep_merge_spec.rb          | 22 +++++----
 spec/acceptance/defined_with_params_spec.rb | 24 ++++-----
 spec/acceptance/delete_at_spec.rb           | 20 ++++----
 spec/acceptance/delete_spec.rb              | 20 ++++----
 spec/acceptance/delete_undef_values_spec.rb | 20 ++++----
 spec/acceptance/num2bool_spec.rb            | 75 +++++++++++++++++++++++++++++
 15 files changed, 317 insertions(+), 214 deletions(-)
 create mode 100644 spec/acceptance/num2bool_spec.rb

(limited to 'spec')

diff --git a/spec/acceptance/abs_spec.rb b/spec/acceptance/abs_spec.rb
index 0921497..eeae89b 100644
--- a/spec/acceptance/abs_spec.rb
+++ b/spec/acceptance/abs_spec.rb
@@ -1,27 +1,29 @@
 require 'spec_helper_acceptance'
 
 describe 'abs function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should accept a string' do
-    pp = <<-EOS
-    $input  = '-34.56'
-    $output = abs($input)
-    notify { $output: }
-    EOS
+  describe 'success' do
+    it 'should accept a string' do
+      pp = <<-EOS
+      $input  = '-34.56'
+      $output = abs($input)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: 34.56/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: 34.56/)
+      end
     end
-  end
 
-  it 'should accept a float' do
-    pp = <<-EOS
-    $input  = -34.56
-    $output = abs($input)
-    notify { $output: }
-    EOS
+    it 'should accept a float' do
+      pp = <<-EOS
+      $input  = -34.56
+      $output = abs($input)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: 34.56/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: 34.56/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/any2array_spec.rb b/spec/acceptance/any2array_spec.rb
index 7d452ed..0127303 100644
--- a/spec/acceptance/any2array_spec.rb
+++ b/spec/acceptance/any2array_spec.rb
@@ -1,46 +1,48 @@
 require 'spec_helper_acceptance'
 
 describe 'any2array function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should create an empty array' do
-    pp = <<-EOS
-    $input = ''
-    $output = any2array($input)
-    validate_array($output)
-    notify { "Output: ${output}": }
-    EOS
+  describe 'success' do
+    it 'should create an empty array' do
+      pp = <<-EOS
+      $input = ''
+      $output = any2array($input)
+      validate_array($output)
+      notify { "Output: ${output}": }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: Output: /)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: Output: /)
+      end
     end
-  end
 
-  it 'should leave arrays modified' do
-    pp = <<-EOS
-    $input = ['test', 'array']
-    $output = any2array($input)
-    validate_array($output)
-    notify { "Output: ${output}": }
-    EOS
+    it 'should leave arrays modified' do
+      pp = <<-EOS
+      $input = ['test', 'array']
+      $output = any2array($input)
+      validate_array($output)
+      notify { "Output: ${output}": }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: Output: testarray/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: Output: testarray/)
+      end
     end
-  end
 
-  it 'should turn a hash into an array' do
-    pp = <<-EOS
-    $input = {'test' => 'array'}
-    $output = any2array($input)
+    it 'should turn a hash into an array' do
+      pp = <<-EOS
+      $input = {'test' => 'array'}
+      $output = any2array($input)
 
-    validate_array($output)
-    # Check each element of the array is a plain string.
-    validate_string($output[0])
-    validate_string($output[1])
-    notify { "Output: ${output}": }
-    EOS
+      validate_array($output)
+      # Check each element of the array is a plain string.
+      validate_string($output[0])
+      validate_string($output[1])
+      notify { "Output: ${output}": }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: Output: testarray/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: Output: testarray/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/base64_spec.rb b/spec/acceptance/base64_spec.rb
index c29b3a7..30ba689 100644
--- a/spec/acceptance/base64_spec.rb
+++ b/spec/acceptance/base64_spec.rb
@@ -1,15 +1,17 @@
 require 'spec_helper_acceptance'
 
 describe 'base64 function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should encode then decode a string' do
-    pp = <<-EOS
-    $encodestring = base64('encode', 'thestring')
-    $decodestring = base64('decode', $encodestring)
-    notify { $decodestring: }
-    EOS
+  describe 'success' do
+    it 'should encode then decode a string' do
+      pp = <<-EOS
+      $encodestring = base64('encode', 'thestring')
+      $decodestring = base64('decode', $encodestring)
+      notify { $decodestring: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/thestring/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/thestring/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/bool2num_spec.rb b/spec/acceptance/bool2num_spec.rb
index 5bdb452..1cbd88d 100644
--- a/spec/acceptance/bool2num_spec.rb
+++ b/spec/acceptance/bool2num_spec.rb
@@ -1,30 +1,32 @@
 require 'spec_helper_acceptance'
 
 describe 'bool2num function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  ['false', 'f', '0', 'n', 'no'].each do |bool|
-    it 'should convert a given boolean, #{bool}, to 0' do
-      pp = <<-EOS
-      $input = #{bool}
-      $output = bool2num($input)
-      notify { $output: }
-      EOS
+  describe 'success' do
+    ['false', 'f', '0', 'n', 'no'].each do |bool|
+      it 'should convert a given boolean, #{bool}, to 0' do
+        pp = <<-EOS
+        $input = #{bool}
+        $output = bool2num($input)
+        notify { $output: }
+        EOS
 
-      apply_manifest(pp, :catch_failures => true) do |r|
-        expect(r.stdout).to match(/Notice: 0/)
+        apply_manifest(pp, :catch_failures => true) do |r|
+          expect(r.stdout).to match(/Notice: 0/)
+        end
       end
     end
-  end
 
-  ['true', 't', '1', 'y', 'yes'].each do |bool|
-    it 'should convert a given boolean, #{bool}, to 1' do
-      pp = <<-EOS
-      $input = #{bool}
-      $output = bool2num($input)
-      notify { $output: }
-      EOS
+    ['true', 't', '1', 'y', 'yes'].each do |bool|
+      it 'should convert a given boolean, #{bool}, to 1' do
+        pp = <<-EOS
+        $input = #{bool}
+        $output = bool2num($input)
+        notify { $output: }
+        EOS
 
-      apply_manifest(pp, :catch_failures => true) do |r|
-        expect(r.stdout).to match(/Notice: 1/)
+        apply_manifest(pp, :catch_failures => true) do |r|
+          expect(r.stdout).to match(/Notice: 1/)
+        end
       end
     end
   end
diff --git a/spec/acceptance/capitalize_spec.rb b/spec/acceptance/capitalize_spec.rb
index 41e16e9..c04b401 100644
--- a/spec/acceptance/capitalize_spec.rb
+++ b/spec/acceptance/capitalize_spec.rb
@@ -1,30 +1,32 @@
 require 'spec_helper_acceptance'
 
 describe 'capitalize function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should capitalize the first letter of a string' do
-    pp = <<-EOS
-    $input = 'this is a string'
-    $output = capitalize($input)
-    notify { $output: }
-    EOS
+  describe 'success' do
+    it 'should capitalize the first letter of a string' do
+      pp = <<-EOS
+      $input = 'this is a string'
+      $output = capitalize($input)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: This is a string/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: This is a string/)
+      end
     end
-  end
 
-  it 'should capitalize the first letter of an array of strings' do
-    pp = <<-EOS
-    $input = ['this', 'is', 'a', 'string']
-    $output = capitalize($input)
-    notify { $output: }
-    EOS
+    it 'should capitalize the first letter of an array of strings' do
+      pp = <<-EOS
+      $input = ['this', 'is', 'a', 'string']
+      $output = capitalize($input)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: This/)
-      expect(r.stdout).to match(/Notice: Is/)
-      expect(r.stdout).to match(/Notice: A/)
-      expect(r.stdout).to match(/Notice: String/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: This/)
+        expect(r.stdout).to match(/Notice: Is/)
+        expect(r.stdout).to match(/Notice: A/)
+        expect(r.stdout).to match(/Notice: String/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/chomp_spec.rb b/spec/acceptance/chomp_spec.rb
index 052226f..c4af9d9 100644
--- a/spec/acceptance/chomp_spec.rb
+++ b/spec/acceptance/chomp_spec.rb
@@ -1,18 +1,20 @@
 require 'spec_helper_acceptance'
 
 describe 'chomp function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should eat the newline' do
-    pp = <<-EOS
-    $input = "test\n"
-    if size($input) != 5 {
-      fail("Size of ${input} is not 5.")
-    }
-    $output = chomp($input)
-    if size($output) != 4 {
-      fail("Size of ${input} is not 4.")
-    }
-    EOS
+  describe 'success' do
+    it 'should eat the newline' do
+      pp = <<-EOS
+      $input = "test\n"
+      if size($input) != 5 {
+        fail("Size of ${input} is not 5.")
+      }
+      $output = chomp($input)
+      if size($output) != 4 {
+        fail("Size of ${input} is not 4.")
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_failures => true)
+    end
   end
 end
diff --git a/spec/acceptance/chop_spec.rb b/spec/acceptance/chop_spec.rb
index f1183a1..8774390 100644
--- a/spec/acceptance/chop_spec.rb
+++ b/spec/acceptance/chop_spec.rb
@@ -1,42 +1,44 @@
 require 'spec_helper_acceptance'
 
 describe 'chop function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should eat the last character' do
-    pp = <<-EOS
-    $input = "test"
-    if size($input) != 4 {
-      fail("Size of ${input} is not 4.")
-    }
-    $output = chop($input)
-    if size($output) != 3 {
-      fail("Size of ${input} is not 3.")
-    }
-    EOS
+  describe 'success' do
+    it 'should eat the last character' do
+      pp = <<-EOS
+      $input = "test"
+      if size($input) != 4 {
+        fail("Size of ${input} is not 4.")
+      }
+      $output = chop($input)
+      if size($output) != 3 {
+        fail("Size of ${input} is not 3.")
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
-  end
+      apply_manifest(pp, :catch_failures => true)
+    end
 
-  it 'should eat the last two characters of \r\n' do
-    pp = <<-EOS
-    $input = "test\r\n"
-    if size($input) != 6 {
-      fail("Size of ${input} is not 6.")
-    }
-    $output = chop($input)
-    if size($output) != 4 {
-      fail("Size of ${input} is not 4.")
-    }
-    EOS
+    it 'should eat the last two characters of \r\n' do
+      pp = <<-EOS
+      $input = "test\r\n"
+      if size($input) != 6 {
+        fail("Size of ${input} is not 6.")
+      }
+      $output = chop($input)
+      if size($output) != 4 {
+        fail("Size of ${input} is not 4.")
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
-  end
+      apply_manifest(pp, :catch_failures => true)
+    end
 
-  it 'should not fail on empty strings' do
-    pp = <<-EOS
-    $input = ""
-    $output = chop($input)
-    EOS
+    it 'should not fail on empty strings' do
+      pp = <<-EOS
+      $input = ""
+      $output = chop($input)
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_failures => true)
+    end
   end
 end
diff --git a/spec/acceptance/concat_spec.rb b/spec/acceptance/concat_spec.rb
index 1fe7729..24b5955 100644
--- a/spec/acceptance/concat_spec.rb
+++ b/spec/acceptance/concat_spec.rb
@@ -1,15 +1,17 @@
 require 'spec_helper_acceptance'
 
 describe 'concat function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should concat one array to another' do
-    pp = <<-EOS
-    $output = concat(['1','2','3'],['4','5','6'])
-    validate_array($output)
-    if size($output) != 6 {
-      fail("${output} should have 6 elements.")
-    }
-    EOS
+  describe 'success' do
+    it 'should concat one array to another' do
+      pp = <<-EOS
+      $output = concat(['1','2','3'],['4','5','6'])
+      validate_array($output)
+      if size($output) != 6 {
+        fail("${output} should have 6 elements.")
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_failures => true)
+    end
   end
 end
diff --git a/spec/acceptance/count_spec.rb b/spec/acceptance/count_spec.rb
index cc46be0..0a0f5d7 100644
--- a/spec/acceptance/count_spec.rb
+++ b/spec/acceptance/count_spec.rb
@@ -1,27 +1,29 @@
 require 'spec_helper_acceptance'
 
 describe 'count function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should count elements in an array' do
-    pp = <<-EOS
-    $input = [1,2,3,4]
-    $output = count($input)
-    notify { $output: }
-    EOS
+  describe 'success' do
+    it 'should count elements in an array' do
+      pp = <<-EOS
+      $input = [1,2,3,4]
+      $output = count($input)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: 4/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: 4/)
+      end
     end
-  end
 
-  it 'should count elements in an array that match a second argument' do
-    pp = <<-EOS
-    $input = [1,1,1,2]
-    $output = count($input, 1)
-    notify { $output: }
-    EOS
+    it 'should count elements in an array that match a second argument' do
+      pp = <<-EOS
+      $input = [1,1,1,2]
+      $output = count($input, 1)
+      notify { $output: }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: 3/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: 3/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/deep_merge_spec.rb b/spec/acceptance/deep_merge_spec.rb
index c7f35be..676d23d 100644
--- a/spec/acceptance/deep_merge_spec.rb
+++ b/spec/acceptance/deep_merge_spec.rb
@@ -1,17 +1,19 @@
 require 'spec_helper_acceptance'
 
 describe 'deep_merge function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should deep merge two hashes' do
-    pp = <<-EOS
-    $hash1 = {'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }
-    $hash2 = {'two' => 'dos', 'three' => { 'five' => 5 } }
-    $merged_hash = deep_merge($hash1, $hash2)
+  describe 'success' do
+    it 'should deep merge two hashes' do
+      pp = <<-EOS
+      $hash1 = {'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }
+      $hash2 = {'two' => 'dos', 'three' => { 'five' => 5 } }
+      $merged_hash = deep_merge($hash1, $hash2)
 
-    if $merged_hash != { 'one' => 1, 'two' => 'dos', 'three' => { 'four' => 4, 'five' => 5 } } {
-      fail("Hash was incorrectly merged.")
-    }
-    EOS
+      if $merged_hash != { 'one' => 1, 'two' => 'dos', 'three' => { 'four' => 4, 'five' => 5 } } {
+        fail("Hash was incorrectly merged.")
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_failures => true)
+    end
   end
 end
diff --git a/spec/acceptance/defined_with_params_spec.rb b/spec/acceptance/defined_with_params_spec.rb
index eb549e5..7477453 100644
--- a/spec/acceptance/defined_with_params_spec.rb
+++ b/spec/acceptance/defined_with_params_spec.rb
@@ -1,19 +1,21 @@
 require 'spec_helper_acceptance'
 
 describe 'defined_with_params function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should successfully notify' do
-    pp = <<-EOS
-    user { 'dan':
-      ensure => present,
-    }
+  describe 'success' do
+    it 'should successfully notify' do
+      pp = <<-EOS
+      user { 'dan':
+        ensure => present,
+      }
 
-    if defined_with_params(User[dan], {'ensure' => 'present' }) {
-      notify { 'User defined with ensure=>present': }
-    }
-    EOS
+      if defined_with_params(User[dan], {'ensure' => 'present' }) {
+        notify { 'User defined with ensure=>present': }
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: User defined with ensure=>present/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: User defined with ensure=>present/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/delete_at_spec.rb b/spec/acceptance/delete_at_spec.rb
index 42d7a77..f2c5cfe 100644
--- a/spec/acceptance/delete_at_spec.rb
+++ b/spec/acceptance/delete_at_spec.rb
@@ -1,16 +1,18 @@
 require 'spec_helper_acceptance'
 
 describe 'delete_at function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should delete elements of the array' do
-    pp = <<-EOS
-    $output = delete_at(['a','b','c','b'], 1)
-    if $output == ['a','c','b'] {
-      notify { 'output correct': }
-    }
-    EOS
+  describe 'success' do
+    it 'should delete elements of the array' do
+      pp = <<-EOS
+      $output = delete_at(['a','b','c','b'], 1)
+      if $output == ['a','c','b'] {
+        notify { 'output correct': }
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: output correct/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: output correct/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/delete_spec.rb b/spec/acceptance/delete_spec.rb
index 63804bc..e54d816 100644
--- a/spec/acceptance/delete_spec.rb
+++ b/spec/acceptance/delete_spec.rb
@@ -1,16 +1,18 @@
 require 'spec_helper_acceptance'
 
 describe 'delete function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should delete elements of the array' do
-    pp = <<-EOS
-    $output = delete(['a','b','c','b'], 'b')
-    if $output == ['a','c'] {
-      notify { 'output correct': }
-    }
-    EOS
+  describe 'success' do
+    it 'should delete elements of the array' do
+      pp = <<-EOS
+      $output = delete(['a','b','c','b'], 'b')
+      if $output == ['a','c'] {
+        notify { 'output correct': }
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: output correct/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: output correct/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/delete_undef_values_spec.rb b/spec/acceptance/delete_undef_values_spec.rb
index 1ecdf4c..c2ac931 100644
--- a/spec/acceptance/delete_undef_values_spec.rb
+++ b/spec/acceptance/delete_undef_values_spec.rb
@@ -1,16 +1,18 @@
 require 'spec_helper_acceptance'
 
 describe 'delete_undef_values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  it 'should delete elements of the array' do
-    pp = <<-EOS
-    $output = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})
-    if $output == { a => 'A', b => '', d => false } {
-      notify { 'output correct': }
-    }
-    EOS
+  describe 'success' do
+    it 'should delete elements of the array' do
+      pp = <<-EOS
+      $output = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})
+      if $output == { a => 'A', b => '', d => false } {
+        notify { 'output correct': }
+      }
+      EOS
 
-    apply_manifest(pp, :catch_failures => true) do |r|
-      expect(r.stdout).to match(/Notice: output correct/)
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/Notice: output correct/)
+      end
     end
   end
 end
diff --git a/spec/acceptance/num2bool_spec.rb b/spec/acceptance/num2bool_spec.rb
new file mode 100644
index 0000000..cdfbc70
--- /dev/null
+++ b/spec/acceptance/num2bool_spec.rb
@@ -0,0 +1,75 @@
+require 'spec_helper_acceptance'
+
+describe 'num2bool function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+  describe 'success' do
+    it 'bools positive numbers and numeric strings as true' do
+      pp = <<-EOS
+      $a = 1
+      $b = "1"
+      $c = "50"
+      $ao = num2bool($a)
+      $bo = num2bool($b)
+      $co = num2bool($c)
+      notice(inline_template('a is <%= @ao.inspect %>'))
+      notice(inline_template('b is <%= @bo.inspect %>'))
+      notice(inline_template('c is <%= @co.inspect %>'))
+      EOS
+
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/a is true/)
+        expect(r.stdout).to match(/b is true/)
+        expect(r.stdout).to match(/c is true/)
+      end
+    end
+    it 'bools negative numbers as false' do
+      pp = <<-EOS
+      $a = 0
+      $b = -0.1
+      $c = ["-50","1"]
+      $ao = num2bool($a)
+      $bo = num2bool($b)
+      $co = num2bool($c)
+      notice(inline_template('a is <%= @ao.inspect %>'))
+      notice(inline_template('b is <%= @bo.inspect %>'))
+      notice(inline_template('c is <%= @co.inspect %>'))
+      EOS
+
+      apply_manifest(pp, :catch_failures => true) do |r|
+        expect(r.stdout).to match(/a is false/)
+        expect(r.stdout).to match(/b is false/)
+        expect(r.stdout).to match(/c is false/)
+      end
+    end
+  end
+  describe 'failure' do
+    it 'fails on words' do
+      pp = <<-EOS
+      $a = "a"
+      $ao = num2bool($a)
+      notice(inline_template('a is <%= @ao.inspect %>'))
+      EOS
+      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/not look like a number/)
+    end
+
+    it 'fails on numberwords' do
+      pp = <<-EOS
+      $b = "1b"
+      $bo = num2bool($b)
+      notice(inline_template('b is <%= @bo.inspect %>'))
+      EOS
+      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/not look like a number/)
+
+    end
+
+    it 'fails on non-numeric/strings' do
+      pending "The function will call .to_s.to_i on anything not a Numeric or
+      String, and results in 0. Is this intended?"
+      pp = <<-EOS
+      $c = {"c" => "-50"}
+      $co = num2bool($c)
+      notice(inline_template('c is <%= @co.inspect %>'))
+      EOS
+      expect(apply_manifest(ppc :expect_failures => true).stderr).to match(/Unable to parse/)
+    end
+  end
+end
-- 
cgit v1.2.3