puppet-retrospec 0.12.1 → 0.12.2

data/spec/fixtures/modules/stdlib/spec/functions/validate_ipv6_address_spec.rb

@@ -1,67 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require "spec_helper"
-
-describe Puppet::Parser::Functions.function(:validate_ipv6_address) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  describe "when calling validate_ipv6_address from puppet" do
-    describe "when given IPv6 address strings" do
-      it "should compile with one argument" do
-        Puppet[:code] = "validate_ipv6_address('3ffe:0505:0002::')"
-        scope.compiler.compile
-      end
-
-      it "should compile with multiple arguments" do
-        Puppet[:code] = "validate_ipv6_address('3ffe:0505:0002::', '3ffe:0505:0001::')"
-        scope.compiler.compile
-      end
-    end
-
-    describe "when given an ipv4 address" do
-      it "should not compile" do
-        Puppet[:code] = "validate_ipv6_address('1.2.3.4')"
-        expect {
-          scope.compiler.compile
-        }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
-      end
-    end
-
-    describe "when given other strings" do
-      it "should not compile" do
-        Puppet[:code] = "validate_ipv6_address('hello', 'world')"
-        expect {
-          scope.compiler.compile
-        }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
-      end
-    end
-
-    # 1.8.7 is EOL'd and also absolutely insane about ipv6
-    unless RUBY_VERSION == '1.8.7'
-      describe "when given numbers" do
-        it "should not compile" do
-          Puppet[:code] = "validate_ipv6_address(1, 2)"
-          expect {
-            scope.compiler.compile
-          }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
-        end
-      end
-    end
-
-    describe "when given booleans" do
-      it "should not compile" do
-        Puppet[:code] = "validate_ipv6_address(true, false)"
-        expect {
-          scope.compiler.compile
-        }.to raise_error(Puppet::ParseError, /is not a string/)
-      end
-    end
-
-    it "should not compile when no arguments are passed" do
-      Puppet[:code] = "validate_ipv6_address()"
-      expect {
-        scope.compiler.compile
-      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/validate_numeric_spec.rb

@@ -1,217 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:validate_numeric) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  describe 'when calling validate_numeric from puppet without any argument or to many' do
-    it "should not compile when no argument is passed" do
-      Puppet[:code] = "validate_numeric()"
-      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_numeric(1, 1, 1, 1)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
-    end
-  end
-
-  describe 'when calling validate_numeric from puppet only with input' do
-    %w{ 1 -1 1.0 -1.0 }.each do |the_number|
-      it "should compile when #{the_number} is an encapsulated numeric" do
-        Puppet[:code] = "validate_numeric('#{the_number}')"
-        scope.compiler.compile
-      end
-      it "should compile when #{the_number} is a bare numeric" do
-        Puppet[:code] = "validate_numeric(#{the_number})"
-        scope.compiler.compile
-      end
-    end
-
-    %w{ [1,2,3,4,5] ['1','2','3','4','5'] [1.1,2.2,3.3,4.4,5.5] ['1.1','2.2','3.3','4.4','5.5'] }.each do |the_number|
-      it "should compile when multiple Numeric arguments are passed in an Array" do
-        Puppet[:code] = "validate_numeric(#{the_number})"
-        scope.compiler.compile
-      end
-    end
-
-    %w{ true false iAmAString 1test }.each do |the_number|
-      it "should not compile when #{the_number} is in a string" do
-        Puppet[:code] = "validate_numeric('#{the_number}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
-      end
-
-      it "should not compile when #{the_number} is a bare word" do
-        Puppet[:code] = "validate_numeric(#{the_number})"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
-      end
-    end
-
-    it "should not compile when a Numeric is part of a larger String" do
-      Puppet[:code] = "validate_numeric('1.0 test')"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
-    end
-
-    it "should not compile when an Array with a non-Numeric value is passed" do
-      Puppet[:code] = "validate_numeric([1, 'test'])"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /at array position 1 to be a Numeric/)
-    end
-
-    it "should not compile when a Hash is passed" do
-      Puppet[:code] = "validate_numeric({ 1 => 2 })"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric or Array/)
-    end
-
-    it "should not compile when an explicitly undef variable is passed" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        $foo = undef
-        validate_numeric($foo)
-      ENDofPUPPETcode
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
-    end
-
-    it "should not compile when an undefined variable is passed" do
-      Puppet[:code] = 'validate_numeric($foobarbazishouldnotexist)'
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
-    end
-  end
-
-  describe 'when calling validate_numeric from puppet with input and a maximum' do
-    max = 10
-    %w{ 1 -1 1.0 -1.0 }.each do |the_number|
-      it "should compile when #{the_number} is lower than a maximum of #{max}" do
-        Puppet[:code] = "validate_numeric(#{the_number},#{max})"
-        scope.compiler.compile
-      end
-    end
-
-    it "should compile when a Numeric is equal the maximum" do
-      Puppet[:code] = "validate_numeric(#{max},#{max})"
-      scope.compiler.compile
-    end
-
-    it "should not compile when #{max+1} is greater than a maximum of #{max}" do
-      Puppet[:code] = "validate_numeric(#{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_numeric(#{the_number},#{max})"
-        scope.compiler.compile
-      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_numeric([-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 }.each do |the_max|
-      it "should not compile when a non-Numeric maximum #{the_max}, encapsulated in a String, is passed" do
-        Puppet[:code] = "validate_numeric(1,'#{the_max}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-      end
- 
-      it "should not compile when a non-Numeric maximum #{the_max} bare word is passed" do
-        Puppet[:code] = "validate_numeric(1,#{the_max})"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-      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_numeric(10, $foo)
-      ENDofPUPPETcode
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-    end
-    it "should not compile when an explicitly undef is passed as maximum and no minimum is passed" do
-      Puppet[:code] = "validate_numeric(10, undef)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-    end
-    it "should not compile when an empty string is passed as maximum and no minimum is passed" do
-      Puppet[:code] = "validate_numeric(10, '')"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-    end
-    it "should not compile when an undefined variable for a maximum is passed" do
-      Puppet[:code] = "validate_numeric(10, $foobarbazishouldnotexist)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-    end
-  end
-
-  describe 'when calling validate_numeric 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_numeric(1,1,2)"
-      expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /second argument to be larger than third argument/)
-    end
-
-    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_numeric(#{the_number},#{max},#{min})"
-        scope.compiler.compile
-      end
-    end
-
-    it "should compile when a Numeric is equal the minimum" do
-      Puppet[:code] = "validate_numeric(#{min},#{max},#{min})"
-      scope.compiler.compile
-    end
-
-    it "should compile when a Numeric is equal the minimum and maximum" do
-      Puppet[:code] = "validate_numeric(#{max},#{max},#{max})"
-      scope.compiler.compile
-    end
-
-    it "should compile when an empty maximum is passed and the Numeric is greater than the minimum" do
-      Puppet[:code] = "validate_numeric(#{max}.1,'',#{min})"
-      scope.compiler.compile
-    end
-    it "should compile when an explicitly undefined maximum is passed and the Numeric is greater than the minimum" do
-      Puppet[:code] = "validate_numeric(#{max}.1,undef,#{min})"
-      scope.compiler.compile
-    end
-    it "should compile when an explicitly undefined variable is passed for maximum and the Numeric is greater than the minimum" do
-      Puppet[:code] = <<-"ENDofPUPPETcode"
-        $foo = undef
-        validate_numeric(#{max}.1, $foo, #{min})
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-    it "should not compile when no maximum value is given and the Numeric is greater than the minimum" do
-      Puppet[:code] = "validate_numeric(#{max}.1,,#{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_numeric(#{min-1.0},#{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.0','1','2','3','4','5','10.0'] }.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_numeric(#{the_number},#{max},#{min})"
-        scope.compiler.compile
-      end
-    end
-
-    it "should not compile when an element of an Array [#{min-1.1},1,2,3,4,5,10.0] is lower than a minimum of #{min}" do
-      Puppet[:code] = "validate_numeric([#{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 }.each do |the_min|
-      it "should not compile when a non-Numeric minimum #{the_min}, encapsulated in a String, is passed" do
-        Puppet[:code] = "validate_numeric(1,#{max},'#{the_min}')"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-      end
- 
-      it "should not compile when a non-Numeric minimum #{the_min} bare word is passed" do
-        Puppet[:code] = "validate_numeric(1,#{max},#{the_min})"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
-      end
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/validate_re_spec.rb

@@ -1,77 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:validate_re) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  # The subject of these examplres is the method itself.
-  subject do
-    # This makes sure the function is loaded within each test
-    function_name = Puppet::Parser::Functions.function(:validate_re)
-    scope.method(function_name)
-  end
-
-  context 'Using Puppet::Parser::Scope.new' do
-
-    describe 'Garbage inputs' do
-      inputs = [
-        [ nil ],
-        [ [ nil ] ],
-        [ { 'foo' => 'bar' } ],
-        [ { } ],
-        [ '' ],
-        [ "one", "one", "MSG to User", "4th arg" ],
-      ]
-
-      inputs.each do |input|
-        it "validate_re(#{input.inspect}) should fail" do
-          expect { subject.call [input] }.to raise_error Puppet::ParseError
-        end
-      end
-    end
-
-    describe 'Valid inputs' do
-      inputs = [
-        [ '/full/path/to/something', '^/full' ],
-        [ '/full/path/to/something', 'full' ],
-        [ '/full/path/to/something', ['full', 'absent'] ],
-        [ '/full/path/to/something', ['full', 'absent'], 'Message to the user' ],
-      ]
-
-      inputs.each do |input|
-        it "validate_re(#{input.inspect}) should not fail" do
-          expect { subject.call input }.not_to raise_error
-        end
-      end
-    end
-    describe "Valid inputs which should raise an exception without a message" do
-      # The intent here is to make sure valid inputs raise exceptions when they
-      # don't specify an error message to display.  This is the behvior in
-      # 2.2.x and prior.
-      inputs = [
-        [ "hello", [ "bye", "later", "adios" ] ],
-        [ "greetings", "salutations" ],
-      ]
-
-      inputs.each do |input|
-        it "validate_re(#{input.inspect}) should fail" do
-          expect { subject.call input }.to raise_error /validate_re.*?does not match/
-        end
-      end
-    end
-    describe "Nicer Error Messages" do
-      # The intent here is to make sure the function returns the 3rd argument
-      # in the exception thrown
-      inputs = [
-        [ "hello", [ "bye", "later", "adios" ], "MSG to User" ],
-        [ "greetings", "salutations", "Error, greetings does not match salutations" ],
-      ]
-
-      inputs.each do |input|
-        it "validate_re(#{input.inspect}) should fail" do
-          expect { subject.call input }.to raise_error /#{input[2]}/
-        end
-      end
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/validate_slength_spec.rb

@@ -1,67 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the validate_slength function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("validate_slength")).to eq("function_validate_slength")
-  end
-
-  describe "validating the input argument types" do
-    it "raises an error if there are less than two arguments" do
-      expect { scope.function_validate_slength([]) }.to raise_error Puppet::ParseError, /Wrong number of arguments/
-    end
-
-    it "raises an error if there are more than three arguments" do
-      expect { scope.function_validate_slength(['input', 1, 2, 3]) }.to raise_error Puppet::ParseError, /Wrong number of arguments/
-    end
-
-    it "raises an error if the first argument is not a string" do
-      expect { scope.function_validate_slength([Object.new, 2, 1]) }.to raise_error Puppet::ParseError, /Expected first argument.*got .*Object/
-    end
-
-    it "raises an error if the second argument cannot be cast to an Integer" do
-      expect { scope.function_validate_slength(['input', Object.new]) }.to raise_error Puppet::ParseError, /Expected second argument.*got .*Object/
-    end
-
-    it "raises an error if the third argument cannot be cast to an Integer" do
-      expect { scope.function_validate_slength(['input', 1, Object.new]) }.to raise_error Puppet::ParseError, /Expected third argument.*got .*Object/
-    end
-
-    it "raises an error if the second argument is smaller than the third argument" do
-      expect { scope.function_validate_slength(['input', 1, 2]) }.to raise_error Puppet::ParseError, /Expected second argument to be larger than third argument/
-    end
-  end
-
-  describe "validating the input string length" do
-    describe "when the input is a string" do
-      it "fails validation if the string is larger than the max length" do
-        expect { scope.function_validate_slength(['input', 1]) }.to raise_error Puppet::ParseError, /Expected length .* between 0 and 1, was 5/
-      end
-
-      it "fails validation if the string is less than the min length" do
-        expect { scope.function_validate_slength(['input', 10, 6]) }.to raise_error Puppet::ParseError, /Expected length .* between 6 and 10, was 5/
-      end
-
-      it "doesn't raise an error if the string is under the max length" do
-        scope.function_validate_slength(['input', 10])
-      end
-
-      it "doesn't raise an error if the string is equal to the max length" do
-        scope.function_validate_slength(['input', 5])
-      end
-
-      it "doesn't raise an error if the string is equal to the min length" do
-        scope.function_validate_slength(['input', 10, 5])
-      end
-    end
-
-    describe "when the input is an array" do
-      it "fails validation if one of the array elements is not a string" do
-        expect { scope.function_validate_slength([["a", "b", Object.new], 2]) }.to raise_error Puppet::ParseError, /Expected element at array position 2 .*String, got .*Object/
-      end
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/validate_string_spec.rb

@@ -1,60 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:validate_string) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  describe 'when calling validate_string from puppet' do
-
-    %w{ foo bar baz }.each do |the_string|
-
-      it "should compile when #{the_string} is a string" do
-        Puppet[:code] = "validate_string('#{the_string}')"
-        scope.compiler.compile
-      end
-
-      it "should compile when #{the_string} is a bare word" do
-        Puppet[:code] = "validate_string(#{the_string})"
-        scope.compiler.compile
-      end
-
-    end
-
-    %w{ true false }.each do |the_string|
-      it "should compile when #{the_string} is a string" do
-        Puppet[:code] = "validate_string('#{the_string}')"
-        scope.compiler.compile
-      end
-
-      it "should not compile when #{the_string} is a bare word" do
-        Puppet[:code] = "validate_string(#{the_string})"
-        expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a string/)
-      end
-    end
-
-    it "should compile when multiple string arguments are passed" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        $foo = ''
-        $bar = 'two'
-        validate_string($foo, $bar)
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-
-    it "should compile when an explicitly undef variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        $foo = undef
-        validate_string($foo)
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-
-    it "should compile when an undefined variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        validate_string($foobarbazishouldnotexist)
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-  end
-end