From 790818116e953118ba9eab5e5bef6d63f7bbc1fa Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Wed, 29 Jun 2011 21:21:55 +0100 Subject: Added tests for each function, fixing functions as we hit bugs. --- spec/unit/parser/functions/abs_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/bool2num_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/capitalize_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/chomp_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/chop_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/count_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/date_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/delete_at_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/delete_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/downcase_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/empty_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/fact_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/flatten_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/grep_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/hash_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_array_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_float_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_hash_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_integer_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_numeric_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/is_string_spec.rb | 21 +++++++++++++++ .../parser/functions/is_valid_domain_name_spec.rb | 21 +++++++++++++++ .../parser/functions/is_valid_ip_address_spec.rb | 21 +++++++++++++++ .../parser/functions/is_valid_mac_address_spec.rb | 21 +++++++++++++++ .../unit/parser/functions/is_valid_netmask_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/join_spec.rb | 21 +++++++++++++++ .../unit/parser/functions/join_with_prefix_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/keys_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/kwalify_spec.rb | 1 + spec/unit/parser/functions/load_json_spec.rb | 29 ++++++++++++++++++++ spec/unit/parser/functions/load_variables_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/load_yaml_spec.rb | 31 ++++++++++++++++++++++ spec/unit/parser/functions/lstrip_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/member_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/num2bool_spec.rb | 21 +++++++++++++++ .../functions/persistent_crontab_minutes_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/prefix_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/rand_spec.rb | 21 +++++++++++++++ .../functions/random_crontab_minutes_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/range_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/reverse_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/rstrip_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/shuffle_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/size_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/sort_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/squeeze_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/str2bool_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/strftime_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/strip_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/swapcase_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/time_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/type_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/unique_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/upcase_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/values_at_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/values_spec.rb | 21 +++++++++++++++ spec/unit/parser/functions/zip_spec.rb | 21 +++++++++++++++ 57 files changed, 1195 insertions(+) create mode 100755 spec/unit/parser/functions/abs_spec.rb create mode 100755 spec/unit/parser/functions/bool2num_spec.rb create mode 100755 spec/unit/parser/functions/capitalize_spec.rb create mode 100755 spec/unit/parser/functions/chomp_spec.rb create mode 100755 spec/unit/parser/functions/chop_spec.rb create mode 100755 spec/unit/parser/functions/count_spec.rb create mode 100755 spec/unit/parser/functions/date_spec.rb create mode 100755 spec/unit/parser/functions/delete_at_spec.rb create mode 100755 spec/unit/parser/functions/delete_spec.rb create mode 100755 spec/unit/parser/functions/downcase_spec.rb create mode 100755 spec/unit/parser/functions/empty_spec.rb create mode 100755 spec/unit/parser/functions/fact_spec.rb create mode 100755 spec/unit/parser/functions/flatten_spec.rb create mode 100755 spec/unit/parser/functions/grep_spec.rb create mode 100644 spec/unit/parser/functions/hash_spec.rb create mode 100644 spec/unit/parser/functions/is_array_spec.rb create mode 100644 spec/unit/parser/functions/is_float_spec.rb create mode 100644 spec/unit/parser/functions/is_hash_spec.rb create mode 100644 spec/unit/parser/functions/is_integer_spec.rb create mode 100644 spec/unit/parser/functions/is_numeric_spec.rb create mode 100644 spec/unit/parser/functions/is_string_spec.rb create mode 100644 spec/unit/parser/functions/is_valid_domain_name_spec.rb create mode 100644 spec/unit/parser/functions/is_valid_ip_address_spec.rb create mode 100644 spec/unit/parser/functions/is_valid_mac_address_spec.rb create mode 100644 spec/unit/parser/functions/is_valid_netmask_spec.rb create mode 100644 spec/unit/parser/functions/join_spec.rb create mode 100644 spec/unit/parser/functions/join_with_prefix_spec.rb create mode 100644 spec/unit/parser/functions/keys_spec.rb create mode 100644 spec/unit/parser/functions/load_json_spec.rb create mode 100644 spec/unit/parser/functions/load_variables_spec.rb create mode 100644 spec/unit/parser/functions/load_yaml_spec.rb create mode 100644 spec/unit/parser/functions/lstrip_spec.rb create mode 100644 spec/unit/parser/functions/member_spec.rb create mode 100644 spec/unit/parser/functions/num2bool_spec.rb create mode 100644 spec/unit/parser/functions/persistent_crontab_minutes_spec.rb create mode 100644 spec/unit/parser/functions/prefix_spec.rb create mode 100644 spec/unit/parser/functions/rand_spec.rb create mode 100644 spec/unit/parser/functions/random_crontab_minutes_spec.rb create mode 100644 spec/unit/parser/functions/range_spec.rb create mode 100644 spec/unit/parser/functions/reverse_spec.rb create mode 100644 spec/unit/parser/functions/rstrip_spec.rb create mode 100644 spec/unit/parser/functions/shuffle_spec.rb create mode 100644 spec/unit/parser/functions/size_spec.rb create mode 100644 spec/unit/parser/functions/sort_spec.rb create mode 100644 spec/unit/parser/functions/squeeze_spec.rb create mode 100644 spec/unit/parser/functions/str2bool_spec.rb create mode 100644 spec/unit/parser/functions/strftime_spec.rb create mode 100644 spec/unit/parser/functions/strip_spec.rb create mode 100644 spec/unit/parser/functions/swapcase_spec.rb create mode 100644 spec/unit/parser/functions/time_spec.rb create mode 100644 spec/unit/parser/functions/type_spec.rb create mode 100644 spec/unit/parser/functions/unique_spec.rb create mode 100644 spec/unit/parser/functions/upcase_spec.rb create mode 100644 spec/unit/parser/functions/values_at_spec.rb create mode 100644 spec/unit/parser/functions/values_spec.rb create mode 100644 spec/unit/parser/functions/zip_spec.rb (limited to 'spec/unit/parser/functions') diff --git a/spec/unit/parser/functions/abs_spec.rb b/spec/unit/parser/functions/abs_spec.rb new file mode 100755 index 0000000..cd2902a --- /dev/null +++ b/spec/unit/parser/functions/abs_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env 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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/bool2num_spec.rb b/spec/unit/parser/functions/bool2num_spec.rb new file mode 100755 index 0000000..a2585e9 --- /dev/null +++ b/spec/unit/parser/functions/bool2num_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/capitalize_spec.rb b/spec/unit/parser/functions/capitalize_spec.rb new file mode 100755 index 0000000..bb1fe2a --- /dev/null +++ b/spec/unit/parser/functions/capitalize_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/chomp_spec.rb b/spec/unit/parser/functions/chomp_spec.rb new file mode 100755 index 0000000..150a7c8 --- /dev/null +++ b/spec/unit/parser/functions/chomp_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/chop_spec.rb b/spec/unit/parser/functions/chop_spec.rb new file mode 100755 index 0000000..ae636cb --- /dev/null +++ b/spec/unit/parser/functions/chop_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/count_spec.rb b/spec/unit/parser/functions/count_spec.rb new file mode 100755 index 0000000..28617c9 --- /dev/null +++ b/spec/unit/parser/functions/count_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the count 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("count").should == "function_count" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_count([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/date_spec.rb b/spec/unit/parser/functions/date_spec.rb new file mode 100755 index 0000000..dcba4af --- /dev/null +++ b/spec/unit/parser/functions/date_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the date 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("date").should == "function_date" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_date([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/delete_at_spec.rb b/spec/unit/parser/functions/delete_at_spec.rb new file mode 100755 index 0000000..a0b5b06 --- /dev/null +++ b/spec/unit/parser/functions/delete_at_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/delete_spec.rb b/spec/unit/parser/functions/delete_spec.rb new file mode 100755 index 0000000..b0729ab --- /dev/null +++ b/spec/unit/parser/functions/delete_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/downcase_spec.rb b/spec/unit/parser/functions/downcase_spec.rb new file mode 100755 index 0000000..162291c --- /dev/null +++ b/spec/unit/parser/functions/downcase_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/empty_spec.rb b/spec/unit/parser/functions/empty_spec.rb new file mode 100755 index 0000000..beaf45c --- /dev/null +++ b/spec/unit/parser/functions/empty_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/fact_spec.rb b/spec/unit/parser/functions/fact_spec.rb new file mode 100755 index 0000000..c013ae0 --- /dev/null +++ b/spec/unit/parser/functions/fact_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the fact 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("fact").should == "function_fact" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_fact([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/flatten_spec.rb b/spec/unit/parser/functions/flatten_spec.rb new file mode 100755 index 0000000..7af23c1 --- /dev/null +++ b/spec/unit/parser/functions/flatten_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/grep_spec.rb b/spec/unit/parser/functions/grep_spec.rb new file mode 100755 index 0000000..1c949da --- /dev/null +++ b/spec/unit/parser/functions/grep_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/hash_spec.rb b/spec/unit/parser/functions/hash_spec.rb new file mode 100644 index 0000000..09b0d50 --- /dev/null +++ b/spec/unit/parser/functions/hash_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_array_spec.rb b/spec/unit/parser/functions/is_array_spec.rb new file mode 100644 index 0000000..b2843b0 --- /dev/null +++ b/spec/unit/parser/functions/is_array_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_float_spec.rb b/spec/unit/parser/functions/is_float_spec.rb new file mode 100644 index 0000000..e3dc8fc --- /dev/null +++ b/spec/unit/parser/functions/is_float_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_hash_spec.rb b/spec/unit/parser/functions/is_hash_spec.rb new file mode 100644 index 0000000..66dfdeb --- /dev/null +++ b/spec/unit/parser/functions/is_hash_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_integer_spec.rb b/spec/unit/parser/functions/is_integer_spec.rb new file mode 100644 index 0000000..131251c --- /dev/null +++ b/spec/unit/parser/functions/is_integer_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_numeric_spec.rb b/spec/unit/parser/functions/is_numeric_spec.rb new file mode 100644 index 0000000..3a49f5d --- /dev/null +++ b/spec/unit/parser/functions/is_numeric_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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 arguments" do + lambda { @scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/is_string_spec.rb b/spec/unit/parser/functions/is_string_spec.rb new file mode 100644 index 0000000..8c0061e --- /dev/null +++ b/spec/unit/parser/functions/is_string_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/is_valid_domain_name_spec.rb b/spec/unit/parser/functions/is_valid_domain_name_spec.rb new file mode 100644 index 0000000..5cea285 --- /dev/null +++ b/spec/unit/parser/functions/is_valid_domain_name_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_valid_domain_name 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("is_valid_domain_name").should == "function_is_valid_domain_name" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_valid_domain_name([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/is_valid_ip_address_spec.rb b/spec/unit/parser/functions/is_valid_ip_address_spec.rb new file mode 100644 index 0000000..fa803dd --- /dev/null +++ b/spec/unit/parser/functions/is_valid_ip_address_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_valid_ip_address 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("is_valid_ip_address").should == "function_is_valid_ip_address" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_valid_ip_address([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/is_valid_mac_address_spec.rb b/spec/unit/parser/functions/is_valid_mac_address_spec.rb new file mode 100644 index 0000000..f2a8389 --- /dev/null +++ b/spec/unit/parser/functions/is_valid_mac_address_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_valid_mac_address 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("is_valid_mac_address").should == "function_is_valid_mac_address" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_valid_mac_address([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/is_valid_netmask_spec.rb b/spec/unit/parser/functions/is_valid_netmask_spec.rb new file mode 100644 index 0000000..97cbb7c --- /dev/null +++ b/spec/unit/parser/functions/is_valid_netmask_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_valid_netmask 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("is_valid_netmask").should == "function_is_valid_netmask" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_valid_netmask([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/join_spec.rb b/spec/unit/parser/functions/join_spec.rb new file mode 100644 index 0000000..a7dc0e5 --- /dev/null +++ b/spec/unit/parser/functions/join_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/join_with_prefix_spec.rb b/spec/unit/parser/functions/join_with_prefix_spec.rb new file mode 100644 index 0000000..0182d8c --- /dev/null +++ b/spec/unit/parser/functions/join_with_prefix_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the join_with_prefix 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("join_with_prefix").should == "function_join_with_prefix" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_join_with_prefix([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/keys_spec.rb b/spec/unit/parser/functions/keys_spec.rb new file mode 100644 index 0000000..13dc260 --- /dev/null +++ b/spec/unit/parser/functions/keys_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the keys 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("keys").should == "function_keys" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_keys([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/kwalify_spec.rb b/spec/unit/parser/functions/kwalify_spec.rb index b2afa12..abdd529 100755 --- a/spec/unit/parser/functions/kwalify_spec.rb +++ b/spec/unit/parser/functions/kwalify_spec.rb @@ -56,6 +56,7 @@ describe "the kwalify function" do 'key1' => 'b', 'key2' => 'c', } + @scope.function_kwalify([schema, document]) end end diff --git a/spec/unit/parser/functions/load_json_spec.rb b/spec/unit/parser/functions/load_json_spec.rb new file mode 100644 index 0000000..73a4566 --- /dev/null +++ b/spec/unit/parser/functions/load_json_spec.rb @@ -0,0 +1,29 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the load_json 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("load_json").should == "function_load_json" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_load_json([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should convert JSON to a data structure" do + json = <<-EOS +["aaa","bbb","ccc"] +EOS + result = @scope.function_load_json([json]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end diff --git a/spec/unit/parser/functions/load_variables_spec.rb b/spec/unit/parser/functions/load_variables_spec.rb new file mode 100644 index 0000000..dc29e61 --- /dev/null +++ b/spec/unit/parser/functions/load_variables_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the load_variables 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("load_variables").should == "function_load_variables" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_load_variables([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/load_yaml_spec.rb b/spec/unit/parser/functions/load_yaml_spec.rb new file mode 100644 index 0000000..2498d12 --- /dev/null +++ b/spec/unit/parser/functions/load_yaml_spec.rb @@ -0,0 +1,31 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the load_yaml 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("load_yaml").should == "function_load_yaml" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_load_yaml([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should convert YAML to a data structure" do + yaml = <<-EOS +- aaa +- bbb +- ccc +EOS + result = @scope.function_load_yaml([yaml]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end diff --git a/spec/unit/parser/functions/lstrip_spec.rb b/spec/unit/parser/functions/lstrip_spec.rb new file mode 100644 index 0000000..9726675 --- /dev/null +++ b/spec/unit/parser/functions/lstrip_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/member_spec.rb b/spec/unit/parser/functions/member_spec.rb new file mode 100644 index 0000000..39b684f --- /dev/null +++ b/spec/unit/parser/functions/member_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/num2bool_spec.rb b/spec/unit/parser/functions/num2bool_spec.rb new file mode 100644 index 0000000..fbd25c8 --- /dev/null +++ b/spec/unit/parser/functions/num2bool_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb b/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb new file mode 100644 index 0000000..1d8cbe7 --- /dev/null +++ b/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the persistent_crontab_minutes 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("persistent_crontab_minutes").should == "function_persistent_crontab_minutes" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_persistent_crontab_minutes([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/prefix_spec.rb b/spec/unit/parser/functions/prefix_spec.rb new file mode 100644 index 0000000..9ede439 --- /dev/null +++ b/spec/unit/parser/functions/prefix_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/rand_spec.rb b/spec/unit/parser/functions/rand_spec.rb new file mode 100644 index 0000000..818d1c5 --- /dev/null +++ b/spec/unit/parser/functions/rand_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the rand 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("rand").should == "function_rand" + end + + it "should raise a ParseError if there is not 0 or 1 arguments" do + lambda { @scope.function_rand(['a','b']) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/random_crontab_minutes_spec.rb b/spec/unit/parser/functions/random_crontab_minutes_spec.rb new file mode 100644 index 0000000..b47b3ae --- /dev/null +++ b/spec/unit/parser/functions/random_crontab_minutes_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the random_crontab_minutes 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("random_crontab_minutes").should == "function_random_crontab_minutes" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_random_crontab_minutes([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/range_spec.rb b/spec/unit/parser/functions/range_spec.rb new file mode 100644 index 0000000..23310bc --- /dev/null +++ b/spec/unit/parser/functions/range_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the range 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("range").should == "function_range" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_range([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/reverse_spec.rb b/spec/unit/parser/functions/reverse_spec.rb new file mode 100644 index 0000000..27aa2cf --- /dev/null +++ b/spec/unit/parser/functions/reverse_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/rstrip_spec.rb b/spec/unit/parser/functions/rstrip_spec.rb new file mode 100644 index 0000000..a6e73ec --- /dev/null +++ b/spec/unit/parser/functions/rstrip_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/shuffle_spec.rb b/spec/unit/parser/functions/shuffle_spec.rb new file mode 100644 index 0000000..cf063c6 --- /dev/null +++ b/spec/unit/parser/functions/shuffle_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/size_spec.rb b/spec/unit/parser/functions/size_spec.rb new file mode 100644 index 0000000..0d1f0c4 --- /dev/null +++ b/spec/unit/parser/functions/size_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/sort_spec.rb b/spec/unit/parser/functions/sort_spec.rb new file mode 100644 index 0000000..ae62d5f --- /dev/null +++ b/spec/unit/parser/functions/sort_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + it "should exist" do + Puppet::Parser::Functions.function("sort").should == "function_sort" + end + + it "should raise a ParseError if there is not 0 arguments" do + lambda { @scope.function_sort(['']) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/squeeze_spec.rb b/spec/unit/parser/functions/squeeze_spec.rb new file mode 100644 index 0000000..da8965c --- /dev/null +++ b/spec/unit/parser/functions/squeeze_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/str2bool_spec.rb b/spec/unit/parser/functions/str2bool_spec.rb new file mode 100644 index 0000000..6a1ac95 --- /dev/null +++ b/spec/unit/parser/functions/str2bool_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/strftime_spec.rb b/spec/unit/parser/functions/strftime_spec.rb new file mode 100644 index 0000000..e377954 --- /dev/null +++ b/spec/unit/parser/functions/strftime_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/strip_spec.rb b/spec/unit/parser/functions/strip_spec.rb new file mode 100644 index 0000000..ca06845 --- /dev/null +++ b/spec/unit/parser/functions/strip_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/swapcase_spec.rb b/spec/unit/parser/functions/swapcase_spec.rb new file mode 100644 index 0000000..7c5ff30 --- /dev/null +++ b/spec/unit/parser/functions/swapcase_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/time_spec.rb b/spec/unit/parser/functions/time_spec.rb new file mode 100644 index 0000000..8bf5982 --- /dev/null +++ b/spec/unit/parser/functions/time_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb new file mode 100644 index 0000000..4109da1 --- /dev/null +++ b/spec/unit/parser/functions/type_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/unique_spec.rb b/spec/unit/parser/functions/unique_spec.rb new file mode 100644 index 0000000..fe7b3ca --- /dev/null +++ b/spec/unit/parser/functions/unique_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/upcase_spec.rb b/spec/unit/parser/functions/upcase_spec.rb new file mode 100644 index 0000000..39884eb --- /dev/null +++ b/spec/unit/parser/functions/upcase_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/values_at_spec.rb b/spec/unit/parser/functions/values_at_spec.rb new file mode 100644 index 0000000..af5dc25 --- /dev/null +++ b/spec/unit/parser/functions/values_at_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + +end diff --git a/spec/unit/parser/functions/values_spec.rb b/spec/unit/parser/functions/values_spec.rb new file mode 100644 index 0000000..2c313a0 --- /dev/null +++ b/spec/unit/parser/functions/values_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the values 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("values").should == "function_values" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_values([]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/parser/functions/zip_spec.rb b/spec/unit/parser/functions/zip_spec.rb new file mode 100644 index 0000000..3d0392a --- /dev/null +++ b/spec/unit/parser/functions/zip_spec.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env rspec +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 + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_zip([]) }.should( raise_error(Puppet::ParseError)) + end + +end -- cgit v1.2.3