dir = File.expand_path(File.dirname(__FILE__))
$LOAD_PATH.unshift File.join(dir, 'lib')
-p dir
-
# Don't want puppet getting the command line arguments for rake or autotest
ARGV.clear
gem 'rspec', '>=2.0.0'
require 'rspec/expectations'
+require 'puppetlabs_spec_helper/module_spec_helper'
-# So everyone else doesn't have to include this base constant.
-module PuppetSpec
- FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
-end
-
-# TODO: ultimately would like to move these requires into the puppet_spec_helper.rb file, but the namespaces
-# are not currently the same between the two, so tests would need to be modified. Not ready to undertake that
-# just yet.
-require 'puppet_spec/files'
-
-require 'puppet_spec_helper'
-
-
-RSpec.configure do |config|
-
- config.before :each do
- GC.disable
- end
-
- config.after :each do
- GC.enable
- end
-end
#! /usr/bin/env ruby -S rspec
+
require 'spec_helper'
describe "the abs function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("abs").should == "function_abs"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert a negative number into a positive" do
- result = @scope.function_abs(["-34"])
+ result = scope.function_abs(["-34"])
result.should(eq(34))
end
it "should do nothing with a positive number" do
- result = @scope.function_abs(["5678"])
+ result = scope.function_abs(["5678"])
result.should(eq(5678))
end
-
end
require 'spec_helper'
describe "the bool2num function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("bool2num").should == "function_bool2num"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert true to 1" do
- result = @scope.function_bool2num([true])
+ result = scope.function_bool2num([true])
result.should(eq(1))
end
it "should convert false to 0" do
- result = @scope.function_bool2num([false])
+ result = scope.function_bool2num([false])
result.should(eq(0))
end
-
end
require 'spec_helper'
describe "the capitalize function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("capitalize").should == "function_capitalize"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
end
it "should capitalize the beginning of a string" do
- result = @scope.function_capitalize(["abc"])
+ result = scope.function_capitalize(["abc"])
result.should(eq("Abc"))
end
-
end
require 'spec_helper'
describe "the chomp function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("chomp").should == "function_chomp"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
end
it "should chomp the end of a string" do
- result = @scope.function_chomp(["abc\n"])
+ result = scope.function_chomp(["abc\n"])
result.should(eq("abc"))
end
-
end
require 'spec_helper'
describe "the chop function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("chop").should == "function_chop"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
end
it "should chop the end of a string" do
- result = @scope.function_chop(["asdf\n"])
+ result = scope.function_chop(["asdf\n"])
result.should(eq("asdf"))
end
-
end
require 'spec_helper'
describe "the delete_at function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("delete_at").should == "function_delete_at"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
end
it "should delete an item at specified location from an array" do
- result = @scope.function_delete_at([['a','b','c'],1])
+ result = scope.function_delete_at([['a','b','c'],1])
result.should(eq(['a','c']))
end
-
end
require 'spec_helper'
describe "the delete function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("delete").should == "function_delete"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
end
it "should delete an item from an array" do
- result = @scope.function_delete([['a','b','c'],'b'])
+ result = scope.function_delete([['a','b','c'],'b'])
result.should(eq(['a','c']))
end
-
end
require 'spec_helper'
describe "the downcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("downcase").should == "function_downcase"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
end
it "should downcase a string" do
- result = @scope.function_downcase(["ASFD"])
+ result = scope.function_downcase(["ASFD"])
result.should(eq("asfd"))
end
it "should do nothing to a string that is already downcase" do
- result = @scope.function_downcase(["asdf asdf"])
+ result = scope.function_downcase(["asdf asdf"])
result.should(eq("asdf asdf"))
end
-
end
require 'spec_helper'
describe "the empty function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("empty").should == "function_empty"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
end
it "should return a true for an empty string" do
- result = @scope.function_empty([''])
+ result = scope.function_empty([''])
result.should(eq(true))
end
it "should return a false for a non-empty string" do
- result = @scope.function_empty(['asdf'])
+ result = scope.function_empty(['asdf'])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the flatten function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("flatten").should == "function_flatten"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
end
it "should flatten a complex data structure" do
- result = @scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
+ result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
result.should(eq(["a","b","c","d","e","f","g"]))
end
it "should do nothing to a structure that is already flat" do
- result = @scope.function_flatten([["a","b","c","d"]])
+ result = scope.function_flatten([["a","b","c","d"]])
result.should(eq(["a","b","c","d"]))
end
-
end
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
describe Puppet::Parser::Functions.function(:getvar) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling getvar from puppet' do
it "should not compile when no arguments are passed" do
Puppet[:code] = 'getvar()'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should not compile when too many arguments are passed" do
Puppet[:code] = 'getvar("foo::bar", "baz")'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should lookup variables in other namespaces" do
fail('getvar did not return what we expect')
}
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
-
end
-
end
-
require 'spec_helper'
describe "the grep function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("grep").should == "function_grep"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
end
it "should grep contents from an array" do
- result = @scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
+ result = scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
result.should(eq(["aaabbb","bbbccc"]))
end
-
end
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:has_key) do
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
- # Pulled from Dan's create_resources function
- # TODO - this should be moved to spec_helper since the
- # logic is likely to be applied to multiple rspec files.
- let(:compiler) {
- topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- topscope.parent = nil
- my_scope = Puppet::Parser::Scope.new
- my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- my_scope.parent = topscope
- compiler = my_scope.compiler
- }
- let(:scope) {
- scope = Puppet::Parser::Scope.new
- scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
- scope
- }
+describe Puppet::Parser::Functions.function(:has_key) do
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling has_key from puppet' do
it "should not compile when no arguments are passed" do
Puppet[:code] = 'has_key()'
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should not compile when 1 argument is passed" do
Puppet[:code] = "has_key('foo')"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should require the first value to be a Hash" do
Puppet[:code] = "has_key('foo', 'bar')"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
end
end
describe 'when calling the function has_key from a scope instance' do
scope.function_has_key([{'one' => 1}, 'two']).should be_false
end
end
-
end
require 'spec_helper'
describe "the hash function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("hash").should == "function_hash"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert an array to a hash" do
- result = @scope.function_hash([['a',1,'b',2,'c',3]])
+ result = scope.function_hash([['a',1,'b',2,'c',3]])
result.should(eq({'a'=>1,'b'=>2,'c'=>3}))
end
-
end
require 'spec_helper'
describe "the is_array function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_array").should == "function_is_array"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if passed an array" do
- result = @scope.function_is_array([[1,2,3]])
+ result = scope.function_is_array([[1,2,3]])
result.should(eq(true))
end
it "should return false if passed a hash" do
- result = @scope.function_is_array([{'a'=>1}])
+ result = scope.function_is_array([{'a'=>1}])
result.should(eq(false))
end
it "should return false if passed a string" do
- result = @scope.function_is_array(["asdf"])
+ result = scope.function_is_array(["asdf"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_domain_name function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- let(:scope) { Puppet::Parser::Scope.new }
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_domain_name").should == "function_is_domain_name"
require 'spec_helper'
describe "the is_float function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_float").should == "function_is_float"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if a float" do
- result = @scope.function_is_float(["0.12"])
+ result = scope.function_is_float(["0.12"])
result.should(eq(true))
end
it "should return false if a string" do
- result = @scope.function_is_float(["asdf"])
+ result = scope.function_is_float(["asdf"])
result.should(eq(false))
end
it "should return false if an integer" do
- result = @scope.function_is_float(["3"])
+ result = scope.function_is_float(["3"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_hash function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_hash").should == "function_is_hash"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if passed a hash" do
- result = @scope.function_is_hash([{"a"=>1,"b"=>2}])
+ result = scope.function_is_hash([{"a"=>1,"b"=>2}])
result.should(eq(true))
end
it "should return false if passed an array" do
- result = @scope.function_is_hash([["a","b"]])
+ result = scope.function_is_hash([["a","b"]])
result.should(eq(false))
end
it "should return false if passed a string" do
- result = @scope.function_is_hash(["asdf"])
+ result = scope.function_is_hash(["asdf"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_integer function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_integer").should == "function_is_integer"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if an integer" do
- result = @scope.function_is_integer(["3"])
+ result = scope.function_is_integer(["3"])
result.should(eq(true))
end
it "should return false if a float" do
- result = @scope.function_is_integer(["3.2"])
+ result = scope.function_is_integer(["3.2"])
result.should(eq(false))
end
it "should return false if a string" do
- result = @scope.function_is_integer(["asdf"])
+ result = scope.function_is_integer(["asdf"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_ip_address function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_ip_address").should == "function_is_ip_address"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if an IPv4 address" do
- result = @scope.function_is_ip_address(["1.2.3.4"])
+ result = scope.function_is_ip_address(["1.2.3.4"])
result.should(eq(true))
end
it "should return true if a full IPv6 address" do
- result = @scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
+ result = scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
result.should(eq(true))
end
it "should return true if a compressed IPv6 address" do
- result = @scope.function_is_ip_address(["fe00::1"])
+ result = scope.function_is_ip_address(["fe00::1"])
result.should(eq(true))
end
it "should return false if not valid" do
- result = @scope.function_is_ip_address(["asdf"])
+ result = scope.function_is_ip_address(["asdf"])
result.should(eq(false))
end
it "should return false if IP octets out of range" do
- result = @scope.function_is_ip_address(["1.1.1.300"])
+ result = scope.function_is_ip_address(["1.1.1.300"])
result.should(eq(false))
end
end
require 'spec_helper'
describe "the is_mac_address function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if a valid mac address" do
- result = @scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
+ result = scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
result.should(eq(true))
end
it "should return false if octets are out of range" do
- result = @scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
+ result = scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
result.should(eq(false))
end
it "should return false if not valid" do
- result = @scope.function_is_mac_address(["not valid"])
+ result = scope.function_is_mac_address(["not valid"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_numeric function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric"
end
it "should raise a ParseError if there is less than 1 argument" do
- lambda { @scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if an integer" do
- result = @scope.function_is_numeric(["3"])
+ result = scope.function_is_numeric(["3"])
result.should(eq(true))
end
it "should return true if a float" do
- result = @scope.function_is_numeric(["3.2"])
+ result = scope.function_is_numeric(["3.2"])
result.should(eq(true))
end
it "should return false if a string" do
- result = @scope.function_is_numeric(["asdf"])
+ result = scope.function_is_numeric(["asdf"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the is_string function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("is_string").should == "function_is_string"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if a string" do
- result = @scope.function_is_string(["asdf"])
+ result = scope.function_is_string(["asdf"])
result.should(eq(true))
end
it "should return false if an integer" do
- result = @scope.function_is_string(["3"])
+ result = scope.function_is_string(["3"])
result.should(eq(false))
end
it "should return false if a float" do
- result = @scope.function_is_string(["3.23"])
+ result = scope.function_is_string(["3.23"])
result.should(eq(false))
end
it "should return false if an array" do
- result = @scope.function_is_string([["a","b","c"]])
+ result = scope.function_is_string([["a","b","c"]])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the join function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("join").should == "function_join"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_join([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_join([]) }.should( raise_error(Puppet::ParseError))
end
it "should join an array into a string" do
- result = @scope.function_join([["a","b","c"], ":"])
+ result = scope.function_join([["a","b","c"], ":"])
result.should(eq("a:b:c"))
end
-
end
require 'spec_helper'
describe "the keys function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- let(:scope) { Puppet::Parser::Scope.new }
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("keys").should == "function_keys"
require 'spec_helper'
describe "the lstrip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("lstrip").should == "function_lstrip"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
end
it "should lstrip a string" do
- result = @scope.function_lstrip([" asdf"])
+ result = scope.function_lstrip([" asdf"])
result.should(eq('asdf'))
end
-
end
require 'spec_helper'
describe "the member function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("member").should == "function_member"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_member([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_member([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if a member is in an array" do
- result = @scope.function_member([["a","b","c"], "a"])
+ result = scope.function_member([["a","b","c"], "a"])
result.should(eq(true))
- end
+ end
it "should return false if a member is not in an array" do
- result = @scope.function_member([["a","b","c"], "d"])
+ result = scope.function_member([["a","b","c"], "d"])
result.should(eq(false))
- end
-
+ end
end
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:merge) do
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
- # Pulled from Dan's create_resources function
- # TODO - these let statements should be moved somewhere
- # where they can be resued
- let(:compiler) {
- topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- topscope.parent = nil
- my_scope = Puppet::Parser::Scope.new
- my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- my_scope.parent = topscope
- compiler = my_scope.compiler
- }
- let(:scope) {
- scope = Puppet::Parser::Scope.new
- scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
- scope
- }
+describe Puppet::Parser::Functions.function(:merge) do
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling merge from puppet' do
it "should not compile when no arguments are passed" do
Puppet[:code] = 'merge()'
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should not compile when 1 argument is passed" do
Puppet[:code] = "$my_hash={'one' => 1}\nmerge($my_hash)"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
end
describe 'when calling merge on the scope instance' do
it 'should accept empty hashes' do
scope.function_merge([{},{},{}]).should == {}
end
-
end
-
end
require 'spec_helper'
describe "the num2bool function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
end
it "should return true if 1" do
- result = @scope.function_num2bool(["1"])
+ result = scope.function_num2bool(["1"])
result.should(be_true)
end
it "should return false if 0" do
- result = @scope.function_num2bool(["0"])
+ result = scope.function_num2bool(["0"])
result.should(be_false)
end
-
end
require 'spec_helper'
describe "the parsejson function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("parsejson").should == "function_parsejson"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert JSON to a data structure" do
json = <<-EOS
["aaa","bbb","ccc"]
EOS
- result = @scope.function_parsejson([json])
+ result = scope.function_parsejson([json])
result.should(eq(['aaa','bbb','ccc']))
end
-
end
require 'spec_helper'
describe "the parseyaml function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert YAML to a data structure" do
- bbb
- ccc
EOS
- result = @scope.function_parseyaml([yaml])
+ result = scope.function_parseyaml([yaml])
result.should(eq(['aaa','bbb','ccc']))
end
-
end
require 'spec_helper'
describe "the prefix function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("prefix").should == "function_prefix"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_prefix([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_prefix([]) }.should( raise_error(Puppet::ParseError))
end
it "should return a prefixed array" do
- result = @scope.function_prefix([['a','b','c'], 'p'])
+ result = scope.function_prefix([['a','b','c'], 'p'])
result.should(eq(['pa','pb','pc']))
end
-
end
require 'spec_helper'
describe "the range function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- let :scope do
- Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("range").should == "function_range"
require 'spec_helper'
describe "the reverse function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("reverse").should == "function_reverse"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
end
it "should reverse a string" do
- result = @scope.function_reverse(["asdfghijkl"])
+ result = scope.function_reverse(["asdfghijkl"])
result.should(eq('lkjihgfdsa'))
end
-
end
require 'spec_helper'
describe "the rstrip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("rstrip").should == "function_rstrip"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
end
it "should rstrip a string" do
- result = @scope.function_rstrip(["asdf "])
+ result = scope.function_rstrip(["asdf "])
result.should(eq('asdf'))
end
it "should rstrip each element in an array" do
- result = @scope.function_rstrip([["a ","b ", "c "]])
+ result = scope.function_rstrip([["a ","b ", "c "]])
result.should(eq(['a','b','c']))
end
-
end
require 'spec_helper'
describe "the shuffle function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("shuffle").should == "function_shuffle"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
end
it "should shuffle a string and the result should be the same size" do
- result = @scope.function_shuffle(["asdf"])
+ result = scope.function_shuffle(["asdf"])
result.size.should(eq(4))
end
it "should shuffle a string but the sorted contents should still be the same" do
- result = @scope.function_shuffle(["adfs"])
+ result = scope.function_shuffle(["adfs"])
result.split("").sort.join("").should(eq("adfs"))
end
-
end
require 'spec_helper'
describe "the size function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("size").should == "function_size"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_size([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_size([]) }.should( raise_error(Puppet::ParseError))
end
it "should return the size of a string" do
- result = @scope.function_size(["asdf"])
+ result = scope.function_size(["asdf"])
result.should(eq(4))
end
it "should return the size of an array" do
- result = @scope.function_size([["a","b","c"]])
+ result = scope.function_size([["a","b","c"]])
result.should(eq(3))
end
-
end
require 'spec_helper'
describe "the sort function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("sort").should == "function_sort"
end
it "should raise a ParseError if there is not 1 arguments" do
- lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
end
it "should sort an array" do
- result = @scope.function_sort([["a","c","b"]])
+ result = scope.function_sort([["a","c","b"]])
result.should(eq(['a','b','c']))
end
it "should sort a string" do
- result = @scope.function_sort(["acb"])
+ result = scope.function_sort(["acb"])
result.should(eq('abc'))
end
-
end
require 'spec_helper'
describe "the squeeze function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("squeeze").should == "function_squeeze"
end
it "should raise a ParseError if there is less than 2 arguments" do
- lambda { @scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
end
it "should squeeze a string" do
- result = @scope.function_squeeze(["aaabbbbcccc"])
+ result = scope.function_squeeze(["aaabbbbcccc"])
result.should(eq('abc'))
end
it "should squeeze all elements in an array" do
- result = @scope.function_squeeze([["aaabbbbcccc","dddfff"]])
+ result = scope.function_squeeze([["aaabbbbcccc","dddfff"]])
result.should(eq(['abc','df']))
end
-
end
require 'spec_helper'
describe "the str2bool function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("str2bool").should == "function_str2bool"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
end
it "should convert string 'true' to true" do
- result = @scope.function_str2bool(["true"])
+ result = scope.function_str2bool(["true"])
result.should(eq(true))
end
it "should convert string 'undef' to false" do
- result = @scope.function_str2bool(["undef"])
+ result = scope.function_str2bool(["undef"])
result.should(eq(false))
end
-
end
require 'spec_helper'
describe "the strftime function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("strftime").should == "function_strftime"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
end
it "using %s should be higher then when I wrote this test" do
- result = @scope.function_strftime(["%s"])
+ result = scope.function_strftime(["%s"])
result.to_i.should(be > 1311953157)
end
it "using %s should be lower then 1.5 trillion" do
- result = @scope.function_strftime(["%s"])
+ result = scope.function_strftime(["%s"])
result.to_i.should(be < 1500000000)
end
it "should return a date when given %Y-%m-%d" do
- result = @scope.function_strftime(["%Y-%m-%d"])
+ result = scope.function_strftime(["%Y-%m-%d"])
result.should =~ /^\d{4}-\d{2}-\d{2}$/
end
-
end
require 'spec_helper'
describe "the strip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("strip").should == "function_strip"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
end
it "should strip a string" do
- result = @scope.function_strip([" ab cd "])
+ result = scope.function_strip([" ab cd "])
result.should(eq('ab cd'))
end
-
end
require 'spec_helper'
describe "the swapcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("swapcase").should == "function_swapcase"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
end
it "should swapcase a string" do
- result = @scope.function_swapcase(["aaBBccDD"])
+ result = scope.function_swapcase(["aaBBccDD"])
result.should(eq('AAbbCCdd'))
end
-
end
require 'spec_helper'
describe "the time function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("time").should == "function_time"
end
it "should raise a ParseError if there is more than 2 arguments" do
- lambda { @scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
end
it "should return a number" do
- result = @scope.function_time([])
+ result = scope.function_time([])
result.should be_an(Integer)
end
it "should be higher then when I wrote this test" do
- result = @scope.function_time([])
+ result = scope.function_time([])
result.should(be > 1311953157)
end
it "should be lower then 1.5 trillion" do
- result = @scope.function_time([])
+ result = scope.function_time([])
result.should(be < 1500000000)
end
-
end
require 'spec_helper'
describe "the type function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("type").should == "function_type"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_type([]) }.should( raise_error(Puppet::ParseError))
end
it "should return string when given a string" do
- result = @scope.function_type(["aaabbbbcccc"])
+ result = scope.function_type(["aaabbbbcccc"])
result.should(eq('string'))
end
it "should return array when given an array" do
- result = @scope.function_type([["aaabbbbcccc","asdf"]])
+ result = scope.function_type([["aaabbbbcccc","asdf"]])
result.should(eq('array'))
end
it "should return hash when given a hash" do
- result = @scope.function_type([{"a"=>1,"b"=>2}])
+ result = scope.function_type([{"a"=>1,"b"=>2}])
result.should(eq('hash'))
end
it "should return integer when given an integer" do
- result = @scope.function_type(["1"])
+ result = scope.function_type(["1"])
result.should(eq('integer'))
end
it "should return float when given a float" do
- result = @scope.function_type(["1.34"])
+ result = scope.function_type(["1.34"])
result.should(eq('float'))
end
it "should return boolean when given a boolean" do
- result = @scope.function_type([true])
+ result = scope.function_type([true])
result.should(eq('boolean'))
end
-
end
require 'spec_helper'
describe "the unique function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("unique").should == "function_unique"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
end
it "should remove duplicate elements in a string" do
- result = @scope.function_unique(["aabbc"])
+ result = scope.function_unique(["aabbc"])
result.should(eq('abc'))
end
it "should remove duplicate elements in an array" do
- result = @scope.function_unique([["a","a","b","b","c"]])
+ result = scope.function_unique([["a","a","b","b","c"]])
result.should(eq(['a','b','c']))
end
-
end
require 'spec_helper'
describe "the upcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("upcase").should == "function_upcase"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
end
it "should upcase a string" do
- result = @scope.function_upcase(["abc"])
+ result = scope.function_upcase(["abc"])
result.should(eq('ABC'))
end
it "should do nothing if a string is already upcase" do
- result = @scope.function_upcase(["ABC"])
+ result = scope.function_upcase(["ABC"])
result.should(eq('ABC'))
end
-
end
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
describe Puppet::Parser::Functions.function(:validate_array) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling validate_array from puppet' do
%w{ true false }.each do |the_string|
-
it "should not compile when #{the_string} is a string" do
Puppet[:code] = "validate_array('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
end
it "should not compile when #{the_string} is a bare word" do
Puppet[:code] = "validate_array(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
end
-
end
it "should compile when multiple array arguments are passed" do
$bar = [ 'one', 'two' ]
validate_array($foo, $bar)
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should not compile when an undef variable is passed" do
$foo = undef
validate_array($foo)
ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
end
-
end
-
end
-
-require 'puppet'
+#! /usr/bin/env/ruby -S rspec
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
describe Puppet::Parser::Functions.function(:validate_bool) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling validate_bool from puppet' do
%w{ true false }.each do |the_string|
it "should not compile when #{the_string} is a string" do
Puppet[:code] = "validate_bool('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
end
it "should compile when #{the_string} is a bare word" do
Puppet[:code] = "validate_bool(#{the_string})"
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
end
it "should not compile when an arbitrary string is passed" do
Puppet[:code] = 'validate_bool("jeff and dan are awesome")'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
end
it "should not compile when no arguments are passed" do
Puppet[:code] = 'validate_bool()'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
end
it "should compile when multiple boolean arguments are passed" do
$bar = false
validate_bool($foo, $bar, true, false)
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should compile when multiple boolean arguments are passed" do
$bar = false
validate_bool($foo, $bar, true, false, 'jeff')
ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
end
-
end
-
end
-
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
describe Puppet::Parser::Functions.function(:validate_hash) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling validate_hash from puppet' do
it "should not compile when #{the_string} is a string" do
Puppet[:code] = "validate_hash('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
end
it "should not compile when #{the_string} is a bare word" do
Puppet[:code] = "validate_hash(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
end
end
$bar = { 'one' => 'two' }
validate_hash($foo, $bar)
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should not compile when an undef variable is passed" do
$foo = undef
validate_hash($foo)
ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
end
end
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
describe Puppet::Parser::Functions.function(:validate_string) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
describe 'when calling validate_string from puppet' do
it "should compile when #{the_string} is a string" do
Puppet[:code] = "validate_string('#{the_string}')"
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should compile when #{the_string} is a bare word" do
Puppet[:code] = "validate_string(#{the_string})"
- get_scope
- @scope.compiler.compile
+ 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}')"
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should not compile when #{the_string} is a bare word" do
Puppet[:code] = "validate_string(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a string/)
+ expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a string/)
end
end
$bar = 'two'
validate_string($foo, $bar)
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
it "should compile when an explicitly undef variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
$foo = undef
validate_string($foo)
ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
+ 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
- get_scope
- @scope.compiler.compile
+ scope.compiler.compile
end
end
end
require 'spec_helper'
describe "the values_at function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("values_at").should == "function_values_at"
end
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
end
it "should raise a ParseError if you try to use a range where stop is greater then start" do
- lambda { @scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
end
it "should return a value at from an array" do
- result = @scope.function_values_at([['a','b','c'],"1"])
+ result = scope.function_values_at([['a','b','c'],"1"])
result.should(eq(['b']))
end
it "should return a value at from an array when passed a range" do
- result = @scope.function_values_at([['a','b','c'],"0-1"])
+ result = scope.function_values_at([['a','b','c'],"0-1"])
result.should(eq(['a','b']))
end
it "should return chosen values from an array when passed number of indexes" do
- result = @scope.function_values_at([['a','b','c'],["0","2"]])
+ result = scope.function_values_at([['a','b','c'],["0","2"]])
result.should(eq(['a','c']))
end
it "should return chosen values from an array when passed ranges and multiple indexes" do
- result = @scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
+ result = scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
result.should(eq(['a','c','e','f']))
end
-
end
require 'spec_helper'
describe "the values function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- let(:scope) { Puppet::Parser::Scope.new }
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should exist" do
Puppet::Parser::Functions.function("values").should == "function_values"
require 'spec_helper'
describe "the zip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("zip").should == "function_zip"
- end
+ let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
+ lambda { scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
end
it "should be able to zip an array" do
- result = @scope.function_zip([['1','2','3'],['4','5','6']])
+ result = scope.function_zip([['1','2','3'],['4','5','6']])
result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
end
-
end
projects / puppet-stdlib.git / commitdiff