From e071b05ab631f4b73fed7178c52d0416f7629cb8 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Wed, 29 Jun 2011 12:30:07 +0100 Subject: Added kwalify function. --- spec/unit/parser/functions/kwalify_spec.rb | 61 ++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100755 spec/unit/parser/functions/kwalify_spec.rb (limited to 'spec/unit') diff --git a/spec/unit/parser/functions/kwalify_spec.rb b/spec/unit/parser/functions/kwalify_spec.rb new file mode 100755 index 0000000..b2afa12 --- /dev/null +++ b/spec/unit/parser/functions/kwalify_spec.rb @@ -0,0 +1,61 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the kwalify 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("kwalify").should == "function_kwalify" + end + + it "should raise a ParseError if there is less than 2 arguments" do + lambda { @scope.function_kwalify([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should validate a simple array schema" do + schema = { + 'type' => 'seq', + 'sequence' => [ + { 'type' => 'str' } + ] + } + document = ['a','b','c'] + @scope.function_kwalify([schema, document]) + end + + it "should not validate a simple array schema when invalid" do + schema = { + 'type' => 'seq', + 'sequence' => [ + { 'type' => 'str' } + ] + } + document = ['a','b',{'a' => 'b'}] + lambda { @scope.function_kwalify([schema, document]) }.should(raise_error(Puppet::ParseError)) + end + + it "should validate a hash schema" do + schema = { + 'type' => 'map', + 'mapping' => { + 'key1' => { + 'type' => 'str', + }, + 'key2' => { + 'type' => 'str', + }, + } + } + document = { + 'key1' => 'b', + 'key2' => 'c', + } + end + +end -- cgit v1.2.3 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. --- .gitignore | 1 + lib/puppet/parser/functions/date.rb | 6 +++++ lib/puppet/parser/functions/delete.rb | 6 +++++ lib/puppet/parser/functions/grep.rb | 6 +++++ lib/puppet/parser/functions/is_float.rb | 6 +++++ lib/puppet/parser/functions/is_integer.rb | 6 +++++ lib/puppet/parser/functions/is_numeric.rb | 6 +++++ .../parser/functions/is_valid_domain_name.rb | 10 +++++-- lib/puppet/parser/functions/is_valid_ip_address.rb | 6 +++++ .../parser/functions/is_valid_mac_address.rb | 6 +++++ lib/puppet/parser/functions/is_valid_netmask.rb | 6 +++++ lib/puppet/parser/functions/load_json.rb | 12 +++++++++ lib/puppet/parser/functions/load_yaml.rb | 10 +++++++ lib/puppet/parser/functions/rand.rb | 6 +++++ lib/puppet/parser/functions/sort.rb | 6 +++++ lib/puppet/parser/functions/squeeze.rb | 6 +++++ lib/puppet/parser/functions/time.rb | 5 ++++ 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 +++++++++++++++ 74 files changed, 1303 insertions(+), 2 deletions(-) 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') diff --git a/.gitignore b/.gitignore index 01d0a08..7ad8fca 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ pkg/ +coverage/ diff --git a/lib/puppet/parser/functions/date.rb b/lib/puppet/parser/functions/date.rb index ea11265..4d0543e 100644 --- a/lib/puppet/parser/functions/date.rb +++ b/lib/puppet/parser/functions/date.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:date, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/delete.rb b/lib/puppet/parser/functions/delete.rb index b8376d1..88f3448 100644 --- a/lib/puppet/parser/functions/delete.rb +++ b/lib/puppet/parser/functions/delete.rb @@ -9,6 +9,12 @@ module Puppet::Parser::Functions newfunction(:delete, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 2) then + raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ + "given #{arguments.size} for 2") + end + end end diff --git a/lib/puppet/parser/functions/grep.rb b/lib/puppet/parser/functions/grep.rb index 1663fe7..8549218 100644 --- a/lib/puppet/parser/functions/grep.rb +++ b/lib/puppet/parser/functions/grep.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:grep, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 2) then + raise(Puppet::ParseError, "grep(): Wrong number of arguments "+ + "given #{arguments.size} for 2") + end + end end diff --git a/lib/puppet/parser/functions/is_float.rb b/lib/puppet/parser/functions/is_float.rb index 2a5a923..39d097f 100644 --- a/lib/puppet/parser/functions/is_float.rb +++ b/lib/puppet/parser/functions/is_float.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_float, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_float(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_integer.rb b/lib/puppet/parser/functions/is_integer.rb index 44337f0..9813cf1 100644 --- a/lib/puppet/parser/functions/is_integer.rb +++ b/lib/puppet/parser/functions/is_integer.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_integer, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_integer(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_numeric.rb b/lib/puppet/parser/functions/is_numeric.rb index 7a64091..96e8674 100644 --- a/lib/puppet/parser/functions/is_numeric.rb +++ b/lib/puppet/parser/functions/is_numeric.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_numeric, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_numeric(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_valid_domain_name.rb b/lib/puppet/parser/functions/is_valid_domain_name.rb index 05d64be..c0b319c 100644 --- a/lib/puppet/parser/functions/is_valid_domain_name.rb +++ b/lib/puppet/parser/functions/is_valid_domain_name.rb @@ -1,11 +1,17 @@ # -# is_valid_doman_name.rb +# is_valid_domain_name.rb # module Puppet::Parser::Functions - newfunction(:is_valid_doman_name, :type => :rvalue, :doc => <<-EOS + newfunction(:is_valid_domain_name, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_valid_domain_name(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_valid_ip_address.rb b/lib/puppet/parser/functions/is_valid_ip_address.rb index e6b68a8..e91dda8 100644 --- a/lib/puppet/parser/functions/is_valid_ip_address.rb +++ b/lib/puppet/parser/functions/is_valid_ip_address.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_valid_ip_address, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_valid_ip_address(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_valid_mac_address.rb b/lib/puppet/parser/functions/is_valid_mac_address.rb index 5e354c9..0b91d0d 100644 --- a/lib/puppet/parser/functions/is_valid_mac_address.rb +++ b/lib/puppet/parser/functions/is_valid_mac_address.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_valid_mac_address, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_valid_mac_address(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/is_valid_netmask.rb b/lib/puppet/parser/functions/is_valid_netmask.rb index 2aeb374..41e4843 100644 --- a/lib/puppet/parser/functions/is_valid_netmask.rb +++ b/lib/puppet/parser/functions/is_valid_netmask.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:is_valid_netmask, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + end end diff --git a/lib/puppet/parser/functions/load_json.rb b/lib/puppet/parser/functions/load_json.rb index 9ec8c78..7c3f187 100644 --- a/lib/puppet/parser/functions/load_json.rb +++ b/lib/puppet/parser/functions/load_json.rb @@ -6,6 +6,18 @@ module Puppet::Parser::Functions newfunction(:load_json, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "load_json(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + json = arguments[0] + + require 'json' + + JSON.load(json) + end end diff --git a/lib/puppet/parser/functions/load_yaml.rb b/lib/puppet/parser/functions/load_yaml.rb index 684a721..1bc2f36 100644 --- a/lib/puppet/parser/functions/load_yaml.rb +++ b/lib/puppet/parser/functions/load_yaml.rb @@ -6,6 +6,16 @@ module Puppet::Parser::Functions newfunction(:load_yaml, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "load_yaml(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + require 'yaml' + + YAML::load(arguments[0]) + end end diff --git a/lib/puppet/parser/functions/rand.rb b/lib/puppet/parser/functions/rand.rb index 2cb9acb..6d870dc 100644 --- a/lib/puppet/parser/functions/rand.rb +++ b/lib/puppet/parser/functions/rand.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:rand, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 0) and (arguments.size != 1) then + raise(Puppet::ParseError, "rand(): Wrong number of arguments "+ + "given #{arguments.size} for 0 or 1") + end + end end diff --git a/lib/puppet/parser/functions/sort.rb b/lib/puppet/parser/functions/sort.rb index 85e5ba0..974141c 100644 --- a/lib/puppet/parser/functions/sort.rb +++ b/lib/puppet/parser/functions/sort.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:sort, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 0) then + raise(Puppet::ParseError, "sort(): Wrong number of arguments "+ + "given #{arguments.size} for 0") + end + end end diff --git a/lib/puppet/parser/functions/squeeze.rb b/lib/puppet/parser/functions/squeeze.rb index a135bd3..02eb00c 100644 --- a/lib/puppet/parser/functions/squeeze.rb +++ b/lib/puppet/parser/functions/squeeze.rb @@ -6,6 +6,12 @@ module Puppet::Parser::Functions newfunction(:squeeze, :type => :rvalue, :doc => <<-EOS EOS ) do |arguments| + + if (arguments.size != 2) then + raise(Puppet::ParseError, "squeeze(): Wrong number of arguments "+ + "given #{arguments.size} for 2") + end + end end diff --git a/lib/puppet/parser/functions/time.rb b/lib/puppet/parser/functions/time.rb index f7c1041..e1f5b6f 100644 --- a/lib/puppet/parser/functions/time.rb +++ b/lib/puppet/parser/functions/time.rb @@ -10,6 +10,11 @@ module Puppet::Parser::Functions # The Time Zone argument is optional ... time_zone = arguments[0] if arguments[0] + if (arguments.size != 0) and (arguments.size != 1) then + raise(Puppet::ParseError, "time(): Wrong number of arguments "+ + "given #{arguments.size} for 0 or 1") + end + time = Time.new # There is probably a better way to handle Time Zone ... 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 From ff56d9917e52b1a0d14478af74411e81e3633e4f Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Wed, 29 Jun 2011 21:59:18 +0100 Subject: New abs test. --- spec/unit/parser/functions/abs_spec.rb | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'spec/unit') diff --git a/spec/unit/parser/functions/abs_spec.rb b/spec/unit/parser/functions/abs_spec.rb index cd2902a..6bf0b41 100755 --- a/spec/unit/parser/functions/abs_spec.rb +++ b/spec/unit/parser/functions/abs_spec.rb @@ -18,4 +18,9 @@ describe "the abs function" do 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.should(eq(34)) + end + end -- cgit v1.2.3 From 464fb1f41b9c7197fcaade6831b80d6390829ec7 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Wed, 29 Jun 2011 23:37:37 +0100 Subject: Add some more functional tests. --- lib/puppet/parser/functions/date.rb | 2 ++ lib/puppet/parser/functions/delete.rb | 6 +++++ lib/puppet/parser/functions/fact.rb | 36 --------------------------- lib/puppet/parser/functions/grep.rb | 5 ++++ spec/unit/parser/functions/delete_at_spec.rb | 5 ++++ spec/unit/parser/functions/delete_spec.rb | 5 ++++ spec/unit/parser/functions/downcase_spec.rb | 5 ++++ spec/unit/parser/functions/empty_spec.rb | 5 ++++ spec/unit/parser/functions/fact_spec.rb | 21 ---------------- spec/unit/parser/functions/flatten_spec.rb | 5 ++++ spec/unit/parser/functions/grep_spec.rb | 5 ++++ spec/unit/parser/functions/hash_spec.rb | 5 ++++ spec/unit/parser/functions/is_array_spec.rb | 10 ++++++++ spec/unit/parser/functions/is_float_spec.rb | 15 +++++++++++ spec/unit/parser/functions/is_hash_spec.rb | 15 +++++++++++ spec/unit/parser/functions/is_integer_spec.rb | 15 +++++++++++ 16 files changed, 103 insertions(+), 57 deletions(-) delete mode 100644 lib/puppet/parser/functions/fact.rb delete mode 100755 spec/unit/parser/functions/fact_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/date.rb b/lib/puppet/parser/functions/date.rb index 4d0543e..bc62e60 100644 --- a/lib/puppet/parser/functions/date.rb +++ b/lib/puppet/parser/functions/date.rb @@ -12,6 +12,8 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + # TODO: stubbed + end end diff --git a/lib/puppet/parser/functions/delete.rb b/lib/puppet/parser/functions/delete.rb index 88f3448..0d208b5 100644 --- a/lib/puppet/parser/functions/delete.rb +++ b/lib/puppet/parser/functions/delete.rb @@ -15,6 +15,12 @@ module Puppet::Parser::Functions "given #{arguments.size} for 2") end + a = arguments[0] + item = arguments[1] + + a.delete(item) + a + end end diff --git a/lib/puppet/parser/functions/fact.rb b/lib/puppet/parser/functions/fact.rb deleted file mode 100644 index 27b7bb2..0000000 --- a/lib/puppet/parser/functions/fact.rb +++ /dev/null @@ -1,36 +0,0 @@ -# -# fact.rb -# - -module Puppet::Parser::Functions - newfunction(:fact, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - raise(Puppet::ParseError, "fact(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 - - fact = arguments[0] - - unless fact.is_a?(String) - raise(Puppet::ParseError, 'fact(): Requires fact name to be a string') - end - - raise(Puppet::ParseError, 'fact(): You must provide ' + - 'fact name') if fact.empty? - - result = lookupvar(fact) # Get the value of interest from Facter ... - - # - # Now this is a funny one ... Puppet does not have a concept of - # returning neither undef nor nil back for use within the Puppet DSL - # and empty string is as closest to actual undef as you we can get - # at this point in time ... - # - result = result.empty? ? '' : result - - return result - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/grep.rb b/lib/puppet/parser/functions/grep.rb index 8549218..2caaa6f 100644 --- a/lib/puppet/parser/functions/grep.rb +++ b/lib/puppet/parser/functions/grep.rb @@ -12,6 +12,11 @@ module Puppet::Parser::Functions "given #{arguments.size} for 2") end + a = arguments[0] + pattern = Regexp.new(arguments[1]) + + a.grep(pattern) + end end diff --git a/spec/unit/parser/functions/delete_at_spec.rb b/spec/unit/parser/functions/delete_at_spec.rb index a0b5b06..27db0c8 100755 --- a/spec/unit/parser/functions/delete_at_spec.rb +++ b/spec/unit/parser/functions/delete_at_spec.rb @@ -18,4 +18,9 @@ describe "the delete_at function" do 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.should(eq(['a','c'])) + end + end diff --git a/spec/unit/parser/functions/delete_spec.rb b/spec/unit/parser/functions/delete_spec.rb index b0729ab..fab3230 100755 --- a/spec/unit/parser/functions/delete_spec.rb +++ b/spec/unit/parser/functions/delete_spec.rb @@ -18,4 +18,9 @@ describe "the delete function" do 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.should(eq(['a','c'])) + end + end diff --git a/spec/unit/parser/functions/downcase_spec.rb b/spec/unit/parser/functions/downcase_spec.rb index 162291c..0d53220 100755 --- a/spec/unit/parser/functions/downcase_spec.rb +++ b/spec/unit/parser/functions/downcase_spec.rb @@ -18,4 +18,9 @@ describe "the downcase function" do lambda { @scope.function_downcase([]) }.should( raise_error(Puppet::ParseError)) end + it "should downcase a string" do + result = @scope.function_downcase(["ASFD"]) + result.should(eq("asfd")) + end + end diff --git a/spec/unit/parser/functions/empty_spec.rb b/spec/unit/parser/functions/empty_spec.rb index beaf45c..6c0fe69 100755 --- a/spec/unit/parser/functions/empty_spec.rb +++ b/spec/unit/parser/functions/empty_spec.rb @@ -18,4 +18,9 @@ describe "the empty function" do 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.should(eq(true)) + end + end diff --git a/spec/unit/parser/functions/fact_spec.rb b/spec/unit/parser/functions/fact_spec.rb deleted file mode 100755 index c013ae0..0000000 --- a/spec/unit/parser/functions/fact_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 index 7af23c1..91cf4ef 100755 --- a/spec/unit/parser/functions/flatten_spec.rb +++ b/spec/unit/parser/functions/flatten_spec.rb @@ -18,4 +18,9 @@ describe "the flatten function" do 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.should(eq(["a","b","c","d","e","f","g"])) + end + end diff --git a/spec/unit/parser/functions/grep_spec.rb b/spec/unit/parser/functions/grep_spec.rb index 1c949da..b1f647c 100755 --- a/spec/unit/parser/functions/grep_spec.rb +++ b/spec/unit/parser/functions/grep_spec.rb @@ -18,4 +18,9 @@ describe "the grep function" do 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.should(eq(["aaabbb","bbbccc"])) + end + end diff --git a/spec/unit/parser/functions/hash_spec.rb b/spec/unit/parser/functions/hash_spec.rb index 09b0d50..6d3d48c 100644 --- a/spec/unit/parser/functions/hash_spec.rb +++ b/spec/unit/parser/functions/hash_spec.rb @@ -18,4 +18,9 @@ describe "the hash function" do 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.should(eq({'a'=>1,'b'=>2,'c'=>3})) + end + end diff --git a/spec/unit/parser/functions/is_array_spec.rb b/spec/unit/parser/functions/is_array_spec.rb index b2843b0..15b563c 100644 --- a/spec/unit/parser/functions/is_array_spec.rb +++ b/spec/unit/parser/functions/is_array_spec.rb @@ -18,4 +18,14 @@ describe "the is_array function" do 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.should(eq(true)) + end + + it "should return false if passed a hash" do + result = @scope.function_is_array([{'a'=>1}]) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/is_float_spec.rb b/spec/unit/parser/functions/is_float_spec.rb index e3dc8fc..3d58017 100644 --- a/spec/unit/parser/functions/is_float_spec.rb +++ b/spec/unit/parser/functions/is_float_spec.rb @@ -18,4 +18,19 @@ describe "the is_float function" do 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.should(eq(true)) + end + + it "should return false if a string" do + result = @scope.function_is_float(["asdf"]) + result.should(eq(false)) + end + + it "should return false if not an integer" do + result = @scope.function_is_float([3]) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/is_hash_spec.rb b/spec/unit/parser/functions/is_hash_spec.rb index 66dfdeb..94364f5 100644 --- a/spec/unit/parser/functions/is_hash_spec.rb +++ b/spec/unit/parser/functions/is_hash_spec.rb @@ -18,4 +18,19 @@ describe "the is_hash function" do 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.should(eq(true)) + end + + it "should return false if passed an array" do + 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.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/is_integer_spec.rb b/spec/unit/parser/functions/is_integer_spec.rb index 131251c..596bd33 100644 --- a/spec/unit/parser/functions/is_integer_spec.rb +++ b/spec/unit/parser/functions/is_integer_spec.rb @@ -18,4 +18,19 @@ describe "the is_integer function" do 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.should(eq(true)) + end + + it "should return false if a float" do + 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.should(eq(false)) + end + end -- cgit v1.2.3 From 1abf4b62fc8e97c7096c9da3d350e3e6268c5c72 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 30 Jun 2011 01:00:32 +0200 Subject: Few more tests. --- lib/puppet/parser/functions/date.rb | 2 +- spec/unit/parser/functions/bool2num_spec.rb | 10 ++++++++++ spec/unit/parser/functions/capitalize_spec.rb | 5 +++++ spec/unit/parser/functions/chomp_spec.rb | 5 +++++ spec/unit/parser/functions/chop_spec.rb | 5 +++++ spec/unit/parser/functions/count_spec.rb | 5 +++++ 6 files changed, 31 insertions(+), 1 deletion(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/date.rb b/lib/puppet/parser/functions/date.rb index bc62e60..0439bd1 100644 --- a/lib/puppet/parser/functions/date.rb +++ b/lib/puppet/parser/functions/date.rb @@ -8,7 +8,7 @@ module Puppet::Parser::Functions ) do |arguments| if (arguments.size != 1) then - raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ + raise(Puppet::ParseError, "date(): Wrong number of arguments "+ "given #{arguments.size} for 1") end diff --git a/spec/unit/parser/functions/bool2num_spec.rb b/spec/unit/parser/functions/bool2num_spec.rb index a2585e9..d5da18c 100755 --- a/spec/unit/parser/functions/bool2num_spec.rb +++ b/spec/unit/parser/functions/bool2num_spec.rb @@ -18,4 +18,14 @@ describe "the bool2num function" do lambda { @scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError)) end + it "should convert true to 1" do + result = @scope.function_bool2num([true]) + result.should(eq(1)) + end + + it "should convert false to 0" do + result = @scope.function_bool2num([false]) + result.should(eq(0)) + end + end diff --git a/spec/unit/parser/functions/capitalize_spec.rb b/spec/unit/parser/functions/capitalize_spec.rb index bb1fe2a..1c45821 100755 --- a/spec/unit/parser/functions/capitalize_spec.rb +++ b/spec/unit/parser/functions/capitalize_spec.rb @@ -18,4 +18,9 @@ describe "the capitalize function" do 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.should(eq("Abc")) + end + end diff --git a/spec/unit/parser/functions/chomp_spec.rb b/spec/unit/parser/functions/chomp_spec.rb index 150a7c8..0592115 100755 --- a/spec/unit/parser/functions/chomp_spec.rb +++ b/spec/unit/parser/functions/chomp_spec.rb @@ -18,4 +18,9 @@ describe "the chomp function" do 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.should(eq("abc")) + end + end diff --git a/spec/unit/parser/functions/chop_spec.rb b/spec/unit/parser/functions/chop_spec.rb index ae636cb..0c456a8 100755 --- a/spec/unit/parser/functions/chop_spec.rb +++ b/spec/unit/parser/functions/chop_spec.rb @@ -18,4 +18,9 @@ describe "the chop function" do 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.should(eq("asdf")) + end + end diff --git a/spec/unit/parser/functions/count_spec.rb b/spec/unit/parser/functions/count_spec.rb index 28617c9..62d005a 100755 --- a/spec/unit/parser/functions/count_spec.rb +++ b/spec/unit/parser/functions/count_spec.rb @@ -18,4 +18,9 @@ describe "the count function" do lambda { @scope.function_count([]) }.should( raise_error(Puppet::ParseError)) end + it "should return the size of an array" do + result = @scope.function_count([['a','c','b']]) + result.should(eq(3)) + end + end -- cgit v1.2.3 From fde64f37c98291f4a5b9ee1fcf634288e42b730a Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Sun, 24 Jul 2011 00:39:17 +0100 Subject: (#1) - fleshed out some more tests. --- lib/puppet/parser/functions/sort.rb | 6 ++++-- lib/puppet/parser/functions/squeeze.rb | 21 +++++++++++++++++++-- .../parser/functions/is_valid_domain_name_spec.rb | 10 ++++++++++ .../parser/functions/is_valid_ip_address_spec.rb | 10 ++++++++++ .../parser/functions/is_valid_mac_address_spec.rb | 10 ++++++++++ spec/unit/parser/functions/join_spec.rb | 5 +++++ spec/unit/parser/functions/join_with_prefix_spec.rb | 5 +++++ spec/unit/parser/functions/keys_spec.rb | 5 +++++ spec/unit/parser/functions/lstrip_spec.rb | 5 +++++ spec/unit/parser/functions/member_spec.rb | 10 ++++++++++ spec/unit/parser/functions/num2bool_spec.rb | 5 +++++ spec/unit/parser/functions/prefix_spec.rb | 5 +++++ spec/unit/parser/functions/range_spec.rb | 10 ++++++++++ spec/unit/parser/functions/reverse_spec.rb | 5 +++++ spec/unit/parser/functions/rstrip_spec.rb | 10 ++++++++++ spec/unit/parser/functions/size_spec.rb | 10 ++++++++++ spec/unit/parser/functions/sort_spec.rb | 9 +++++++-- spec/unit/parser/functions/squeeze_spec.rb | 10 ++++++++++ spec/unit/parser/functions/str2bool_spec.rb | 10 ++++++++++ spec/unit/parser/functions/strip_spec.rb | 5 +++++ spec/unit/parser/functions/swapcase_spec.rb | 5 +++++ spec/unit/parser/functions/type_spec.rb | 5 +++++ spec/unit/parser/functions/unique_spec.rb | 5 +++++ spec/unit/parser/functions/upcase_spec.rb | 5 +++++ spec/unit/parser/functions/values_at_spec.rb | 5 +++++ spec/unit/parser/functions/values_spec.rb | 5 +++++ spec/unit/parser/functions/zip_spec.rb | 5 +++++ 27 files changed, 195 insertions(+), 6 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/sort.rb b/lib/puppet/parser/functions/sort.rb index 974141c..54a4018 100644 --- a/lib/puppet/parser/functions/sort.rb +++ b/lib/puppet/parser/functions/sort.rb @@ -7,11 +7,13 @@ module Puppet::Parser::Functions EOS ) do |arguments| - if (arguments.size != 0) then + if (arguments.size != 1) then raise(Puppet::ParseError, "sort(): Wrong number of arguments "+ - "given #{arguments.size} for 0") + "given #{arguments.size} for 1") end + arguments[0].sort + end end diff --git a/lib/puppet/parser/functions/squeeze.rb b/lib/puppet/parser/functions/squeeze.rb index 02eb00c..9a1dd20 100644 --- a/lib/puppet/parser/functions/squeeze.rb +++ b/lib/puppet/parser/functions/squeeze.rb @@ -7,9 +7,26 @@ module Puppet::Parser::Functions EOS ) do |arguments| - if (arguments.size != 2) then + if ((arguments.size != 2) and (arguments.size != 1)) then raise(Puppet::ParseError, "squeeze(): Wrong number of arguments "+ - "given #{arguments.size} for 2") + "given #{arguments.size} for 2 or 1") + end + + item = arguments[0] + squeezeval = arguments[1] + + if item.is_a?(Array) then + if squeezeval then + item.collect { |i| i.squeeze(squeezeval) } + else + item.collect { |i| i.squeeze } + end + else + if squeezeval then + item.squeeze(squeezeval) + else + item.squeeze + end 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 index 5cea285..f03f6e8 100644 --- a/spec/unit/parser/functions/is_valid_domain_name_spec.rb +++ b/spec/unit/parser/functions/is_valid_domain_name_spec.rb @@ -18,4 +18,14 @@ describe "the is_valid_domain_name function" do lambda { @scope.function_is_valid_domain_name([]) }.should( raise_error(Puppet::ParseError)) end + it "should return true if a valid domain name" do + result = @scope.function_is_valid_domain_name("foo.bar.com") + result.should(eq(true)) + end + + it "should return false if not a valid domain name" do + result = @scope.function_is_valid_domain_name("not valid") + result.should(eq(false)) + 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 index fa803dd..ee53ee1 100644 --- a/spec/unit/parser/functions/is_valid_ip_address_spec.rb +++ b/spec/unit/parser/functions/is_valid_ip_address_spec.rb @@ -18,4 +18,14 @@ describe "the is_valid_ip_address function" do lambda { @scope.function_is_valid_ip_address([]) }.should( raise_error(Puppet::ParseError)) end + it "should return true if an IP address" do + result = @scope.function_is_valid_ip_address("1.2.3.4") + result.should(eq(true)) + end + + it "should return false if not valid" do + result = @scope.function_is_valid_ip_address("asdf") + result.should(eq(false)) + 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 index f2a8389..c4eb468 100644 --- a/spec/unit/parser/functions/is_valid_mac_address_spec.rb +++ b/spec/unit/parser/functions/is_valid_mac_address_spec.rb @@ -18,4 +18,14 @@ describe "the is_valid_mac_address function" do lambda { @scope.function_is_valid_mac_address([]) }.should( raise_error(Puppet::ParseError)) end + it "should return true if a valid mac address" do + result = @scope.function_is_valid_mac_address("00:a0:1f:12:7f:a0") + result.should(eq(true)) + end + + it "should return false if not valid" do + result = @scope.function_is_valid_mac_address("not valid") + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/join_spec.rb b/spec/unit/parser/functions/join_spec.rb index a7dc0e5..1b3dec8 100644 --- a/spec/unit/parser/functions/join_spec.rb +++ b/spec/unit/parser/functions/join_spec.rb @@ -18,4 +18,9 @@ describe "the join function" do 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.should(eq("a:b:c")) + end + end diff --git a/spec/unit/parser/functions/join_with_prefix_spec.rb b/spec/unit/parser/functions/join_with_prefix_spec.rb index 0182d8c..70e6965 100644 --- a/spec/unit/parser/functions/join_with_prefix_spec.rb +++ b/spec/unit/parser/functions/join_with_prefix_spec.rb @@ -18,4 +18,9 @@ describe "the join_with_prefix function" do lambda { @scope.function_join_with_prefix([]) }.should( raise_error(Puppet::ParseError)) end + it "should join an array into a string" do + result = @scope.function_join_with_prefix([["a","b","c"], ":", "p"]) + result.should(eq("pa:pb:pc")) + end + end diff --git a/spec/unit/parser/functions/keys_spec.rb b/spec/unit/parser/functions/keys_spec.rb index 13dc260..927be96 100644 --- a/spec/unit/parser/functions/keys_spec.rb +++ b/spec/unit/parser/functions/keys_spec.rb @@ -18,4 +18,9 @@ describe "the keys function" do lambda { @scope.function_keys([]) }.should( raise_error(Puppet::ParseError)) end + it "should return an array of keys when given a hash" do + result = @scope.function_keys([{'a'=>1, 'b' => 2}]) + result.should(eq(['a','b'])) + end + end diff --git a/spec/unit/parser/functions/lstrip_spec.rb b/spec/unit/parser/functions/lstrip_spec.rb index 9726675..ac331fa 100644 --- a/spec/unit/parser/functions/lstrip_spec.rb +++ b/spec/unit/parser/functions/lstrip_spec.rb @@ -18,4 +18,9 @@ describe "the lstrip function" do lambda { @scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError)) end + it "should lstrip a string" do + result = @scope.function_lstrip([" asdf"]) + result.should(eq('asdf')) + end + end diff --git a/spec/unit/parser/functions/member_spec.rb b/spec/unit/parser/functions/member_spec.rb index 39b684f..2cebc0d 100644 --- a/spec/unit/parser/functions/member_spec.rb +++ b/spec/unit/parser/functions/member_spec.rb @@ -18,4 +18,14 @@ describe "the member function" do 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.should(eq(true)) + end + + it "should return false if a member is not in an array" do + result = @scope.function_member([["a","b","c"], "d"]) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/num2bool_spec.rb b/spec/unit/parser/functions/num2bool_spec.rb index fbd25c8..2f6435d 100644 --- a/spec/unit/parser/functions/num2bool_spec.rb +++ b/spec/unit/parser/functions/num2bool_spec.rb @@ -18,4 +18,9 @@ describe "the num2bool function" do lambda { @scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError)) end + it "should return true if 1" do + result = @scope.function_num2bool(["1"]) + result.should(eq(true)) + end + end diff --git a/spec/unit/parser/functions/prefix_spec.rb b/spec/unit/parser/functions/prefix_spec.rb index 9ede439..a0cbcab 100644 --- a/spec/unit/parser/functions/prefix_spec.rb +++ b/spec/unit/parser/functions/prefix_spec.rb @@ -18,4 +18,9 @@ describe "the prefix function" do 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.should(eq(['pa','pb','pc'])) + end + end diff --git a/spec/unit/parser/functions/range_spec.rb b/spec/unit/parser/functions/range_spec.rb index 23310bc..8c2446a 100644 --- a/spec/unit/parser/functions/range_spec.rb +++ b/spec/unit/parser/functions/range_spec.rb @@ -18,4 +18,14 @@ describe "the range function" do lambda { @scope.function_range([]) }.should( raise_error(Puppet::ParseError)) end + it "should return a letter range" do + result = @scope.function_range(["a","d"]) + result.should(eq(['a','b','c','d'])) + end + + it "should return a number range" do + result = @scope.function_range(["1","4"]) + result.should(eq([1,2,3,4])) + end + end diff --git a/spec/unit/parser/functions/reverse_spec.rb b/spec/unit/parser/functions/reverse_spec.rb index 27aa2cf..4fa50e4 100644 --- a/spec/unit/parser/functions/reverse_spec.rb +++ b/spec/unit/parser/functions/reverse_spec.rb @@ -18,4 +18,9 @@ describe "the reverse function" do lambda { @scope.function_reverse([]) }.should( raise_error(Puppet::ParseError)) end + it "should reverse a string" do + result = @scope.function_reverse(["asdfghijkl"]) + result.should(eq('lkjihgfdsa')) + end + end diff --git a/spec/unit/parser/functions/rstrip_spec.rb b/spec/unit/parser/functions/rstrip_spec.rb index a6e73ec..af8cc12 100644 --- a/spec/unit/parser/functions/rstrip_spec.rb +++ b/spec/unit/parser/functions/rstrip_spec.rb @@ -18,4 +18,14 @@ describe "the rstrip function" do lambda { @scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError)) end + it "should rstrip a string" do + 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.should(eq(['a','b','c'])) + end + end diff --git a/spec/unit/parser/functions/size_spec.rb b/spec/unit/parser/functions/size_spec.rb index 0d1f0c4..ccaa335 100644 --- a/spec/unit/parser/functions/size_spec.rb +++ b/spec/unit/parser/functions/size_spec.rb @@ -18,4 +18,14 @@ describe "the size function" do 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.should(eq(4)) + end + + it "should return the size of an array" do + result = @scope.function_size([["a","b","c"]]) + result.should(eq(3)) + end + end diff --git a/spec/unit/parser/functions/sort_spec.rb b/spec/unit/parser/functions/sort_spec.rb index ae62d5f..da5db7a 100644 --- a/spec/unit/parser/functions/sort_spec.rb +++ b/spec/unit/parser/functions/sort_spec.rb @@ -14,8 +14,13 @@ describe "the sort function" 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)) + it "should raise a ParseError if there is not 1 arguments" do + lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError)) + end + + it "should sort an array" do + result = @scope.function_sort([["a","c","b"]]) + result.should(eq(['a','b','c'])) end end diff --git a/spec/unit/parser/functions/squeeze_spec.rb b/spec/unit/parser/functions/squeeze_spec.rb index da8965c..9355ad2 100644 --- a/spec/unit/parser/functions/squeeze_spec.rb +++ b/spec/unit/parser/functions/squeeze_spec.rb @@ -18,4 +18,14 @@ describe "the squeeze function" do lambda { @scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError)) end + it "should squeeze a string" do + 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.should(eq(['abc','df'])) + end + end diff --git a/spec/unit/parser/functions/str2bool_spec.rb b/spec/unit/parser/functions/str2bool_spec.rb index 6a1ac95..d7f0ac9 100644 --- a/spec/unit/parser/functions/str2bool_spec.rb +++ b/spec/unit/parser/functions/str2bool_spec.rb @@ -18,4 +18,14 @@ describe "the str2bool function" do lambda { @scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError)) end + it "should convert string 'true' to true" do + result = @scope.function_str2bool(["true"]) + result.should(eq(true)) + end + + it "should convert string 'undef' to false" do + result = @scope.function_str2bool(["undef"]) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/strip_spec.rb b/spec/unit/parser/functions/strip_spec.rb index ca06845..48a52dd 100644 --- a/spec/unit/parser/functions/strip_spec.rb +++ b/spec/unit/parser/functions/strip_spec.rb @@ -18,4 +18,9 @@ describe "the strip function" do lambda { @scope.function_strip([]) }.should( raise_error(Puppet::ParseError)) end + it "should strip a string" do + result = @scope.function_strip([" ab cd "]) + result.should(eq('ab cd')) + end + end diff --git a/spec/unit/parser/functions/swapcase_spec.rb b/spec/unit/parser/functions/swapcase_spec.rb index 7c5ff30..2686054 100644 --- a/spec/unit/parser/functions/swapcase_spec.rb +++ b/spec/unit/parser/functions/swapcase_spec.rb @@ -18,4 +18,9 @@ describe "the swapcase function" do lambda { @scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError)) end + it "should swapcase a string" do + result = @scope.function_swapcase(["aaBBccDD"]) + result.should(eq('AAbbCCdd')) + end + end diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb index 4109da1..fddb87d 100644 --- a/spec/unit/parser/functions/type_spec.rb +++ b/spec/unit/parser/functions/type_spec.rb @@ -18,4 +18,9 @@ describe "the type function" do lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError)) end + it "should return a type when given a string" do + result = @scope.function_type(["aaabbbbcccc"]) + result.should(eq('String')) + end + end diff --git a/spec/unit/parser/functions/unique_spec.rb b/spec/unit/parser/functions/unique_spec.rb index fe7b3ca..7b8b08d 100644 --- a/spec/unit/parser/functions/unique_spec.rb +++ b/spec/unit/parser/functions/unique_spec.rb @@ -18,4 +18,9 @@ describe "the unique function" do lambda { @scope.function_unique([]) }.should( raise_error(Puppet::ParseError)) end + it "should remove duplicate elements in a string" do + result = @scope.function_squeeze([["aabbc"]]) + result.should(eq(['abc'])) + end + end diff --git a/spec/unit/parser/functions/upcase_spec.rb b/spec/unit/parser/functions/upcase_spec.rb index 39884eb..10e4c8a 100644 --- a/spec/unit/parser/functions/upcase_spec.rb +++ b/spec/unit/parser/functions/upcase_spec.rb @@ -18,4 +18,9 @@ describe "the upcase function" do lambda { @scope.function_upcase([]) }.should( raise_error(Puppet::ParseError)) end + it "should upcase a string" do + result = @scope.function_upcase(["abc"]) + result.should(eq('ABC')) + end + end diff --git a/spec/unit/parser/functions/values_at_spec.rb b/spec/unit/parser/functions/values_at_spec.rb index af5dc25..ec8730b 100644 --- a/spec/unit/parser/functions/values_at_spec.rb +++ b/spec/unit/parser/functions/values_at_spec.rb @@ -18,4 +18,9 @@ describe "the values_at function" do lambda { @scope.function_values_at([]) }.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.should(eq(['b'])) + end + end diff --git a/spec/unit/parser/functions/values_spec.rb b/spec/unit/parser/functions/values_spec.rb index 2c313a0..92f1311 100644 --- a/spec/unit/parser/functions/values_spec.rb +++ b/spec/unit/parser/functions/values_spec.rb @@ -18,4 +18,9 @@ describe "the values function" do lambda { @scope.function_values([]) }.should( raise_error(Puppet::ParseError)) end + it "should return values from a hash" do + result = @scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}]) + result.should(eq(['1','2','3'])) + end + end diff --git a/spec/unit/parser/functions/zip_spec.rb b/spec/unit/parser/functions/zip_spec.rb index 3d0392a..074f4df 100644 --- a/spec/unit/parser/functions/zip_spec.rb +++ b/spec/unit/parser/functions/zip_spec.rb @@ -18,4 +18,9 @@ describe "the zip function" do 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.should(eq([["1", "4"], ["2", "5"], ["3", "6"]])) + end + end -- cgit v1.2.3 From a55930368afe2e8177608472653c4696eccec92f Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 15:38:19 +0100 Subject: (#2) - Added is_float and is_integer functionality. --- lib/puppet/parser/functions/is_float.rb | 8 ++++++++ lib/puppet/parser/functions/is_integer.rb | 8 ++++++++ spec/unit/parser/functions/is_float_spec.rb | 4 ++-- spec/unit/parser/functions/is_integer_spec.rb | 4 ++-- 4 files changed, 20 insertions(+), 4 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_float.rb b/lib/puppet/parser/functions/is_float.rb index 39d097f..8aed848 100644 --- a/lib/puppet/parser/functions/is_float.rb +++ b/lib/puppet/parser/functions/is_float.rb @@ -12,6 +12,14 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + value = arguments[0] + + if value != value.to_f.to_s then + return false + else + return true + end + end end diff --git a/lib/puppet/parser/functions/is_integer.rb b/lib/puppet/parser/functions/is_integer.rb index 9813cf1..9dd1cee 100644 --- a/lib/puppet/parser/functions/is_integer.rb +++ b/lib/puppet/parser/functions/is_integer.rb @@ -12,6 +12,14 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + value = arguments[0] + + if value != value.to_i.to_s then + return false + else + return true + end + end end diff --git a/spec/unit/parser/functions/is_float_spec.rb b/spec/unit/parser/functions/is_float_spec.rb index 3d58017..35c0dd6 100644 --- a/spec/unit/parser/functions/is_float_spec.rb +++ b/spec/unit/parser/functions/is_float_spec.rb @@ -19,7 +19,7 @@ describe "the is_float function" do 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 @@ -29,7 +29,7 @@ describe "the is_float function" do end it "should return false if not an integer" do - result = @scope.function_is_float([3]) + result = @scope.function_is_float(["3"]) result.should(eq(false)) end diff --git a/spec/unit/parser/functions/is_integer_spec.rb b/spec/unit/parser/functions/is_integer_spec.rb index 596bd33..faf6f2d 100644 --- a/spec/unit/parser/functions/is_integer_spec.rb +++ b/spec/unit/parser/functions/is_integer_spec.rb @@ -19,12 +19,12 @@ describe "the is_integer function" do 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 -- cgit v1.2.3 From 7efd6ec5819775226d669c15b58649d375f72959 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 15:44:26 +0100 Subject: (#1) - added new test for upcase. --- spec/unit/parser/functions/upcase_spec.rb | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'spec/unit') diff --git a/spec/unit/parser/functions/upcase_spec.rb b/spec/unit/parser/functions/upcase_spec.rb index 10e4c8a..5d18846 100644 --- a/spec/unit/parser/functions/upcase_spec.rb +++ b/spec/unit/parser/functions/upcase_spec.rb @@ -23,4 +23,9 @@ describe "the upcase function" do result.should(eq('ABC')) end + it "should do nothing if a string is already upcase" do + result = @scope.function_upcase(["ABC"]) + result.should(eq('ABC')) + end + end -- cgit v1.2.3 From 635ed82e5cae38b0ba82098c340cbeed70d483c3 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 18:10:16 +0100 Subject: (#2) - unstubbed is_valid_ip_address --- lib/puppet/parser/functions/is_valid_ip_address.rb | 13 +++++++++++++ .../parser/functions/is_valid_ip_address_spec.rb | 20 +++++++++++++++++--- 2 files changed, 30 insertions(+), 3 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_valid_ip_address.rb b/lib/puppet/parser/functions/is_valid_ip_address.rb index e91dda8..4f45890 100644 --- a/lib/puppet/parser/functions/is_valid_ip_address.rb +++ b/lib/puppet/parser/functions/is_valid_ip_address.rb @@ -7,11 +7,24 @@ module Puppet::Parser::Functions EOS ) do |arguments| + require 'ipaddr' + if (arguments.size != 1) then raise(Puppet::ParseError, "is_valid_ip_address(): Wrong number of arguments "+ "given #{arguments.size} for 1") end + begin + ip = IPAddr.new(arguments[0]) + rescue ArgumentError + return false + end + + if ip.ipv4? or ip.ipv6? then + return true + else + return false + end 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 index ee53ee1..2883aaa 100644 --- a/spec/unit/parser/functions/is_valid_ip_address_spec.rb +++ b/spec/unit/parser/functions/is_valid_ip_address_spec.rb @@ -18,14 +18,28 @@ describe "the is_valid_ip_address function" do lambda { @scope.function_is_valid_ip_address([]) }.should( raise_error(Puppet::ParseError)) end - it "should return true if an IP address" do - result = @scope.function_is_valid_ip_address("1.2.3.4") + it "should return true if an IPv4 address" do + result = @scope.function_is_valid_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_valid_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_valid_ip_address(["fe00::1"]) result.should(eq(true)) end it "should return false if not valid" do - result = @scope.function_is_valid_ip_address("asdf") + result = @scope.function_is_valid_ip_address(["asdf"]) result.should(eq(false)) end + it "should return false if IP octets out of range" do + result = @scope.function_is_valid_ip_address(["1.1.1.300"]) + result.should(eq(false)) + end end -- cgit v1.2.3 From 313df566bf5cfcbef73fc8182ccb07ddf2f13feb Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 21:03:33 +0100 Subject: (#2) unstub is_numeric function. --- lib/puppet/parser/functions/is_numeric.rb | 8 ++++++++ spec/unit/parser/functions/is_numeric_spec.rb | 17 ++++++++++++++++- 2 files changed, 24 insertions(+), 1 deletion(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_numeric.rb b/lib/puppet/parser/functions/is_numeric.rb index 96e8674..c2c0fb5 100644 --- a/lib/puppet/parser/functions/is_numeric.rb +++ b/lib/puppet/parser/functions/is_numeric.rb @@ -12,6 +12,14 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + value = arguments[0] + + if value == value.to_f.to_s or value == value.to_i.to_s then + return true + else + return false + end + end end diff --git a/spec/unit/parser/functions/is_numeric_spec.rb b/spec/unit/parser/functions/is_numeric_spec.rb index 3a49f5d..2191b7b 100644 --- a/spec/unit/parser/functions/is_numeric_spec.rb +++ b/spec/unit/parser/functions/is_numeric_spec.rb @@ -14,8 +14,23 @@ describe "the is_numeric function" 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 + it "should raise a ParseError if there is less than 1 argument" do 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.should(eq(true)) + end + + it "should return true if a float" do + 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.should(eq(false)) + end + end -- cgit v1.2.3 From 1a7bd1ae8321bfc3d2ae87f1d5184828abf56916 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 21:10:33 +0100 Subject: Remove is_valid_netmask instead of unstubbing. Doesn't seem like a sensible function on its own. --- lib/puppet/parser/functions/is_valid_netmask.rb | 18 ------------------ spec/unit/parser/functions/is_valid_netmask_spec.rb | 21 --------------------- 2 files changed, 39 deletions(-) delete mode 100644 lib/puppet/parser/functions/is_valid_netmask.rb delete mode 100644 spec/unit/parser/functions/is_valid_netmask_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_valid_netmask.rb b/lib/puppet/parser/functions/is_valid_netmask.rb deleted file mode 100644 index 41e4843..0000000 --- a/lib/puppet/parser/functions/is_valid_netmask.rb +++ /dev/null @@ -1,18 +0,0 @@ -# -# is_valid_netmask.rb -# - -module Puppet::Parser::Functions - newfunction(:is_valid_netmask, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/is_valid_netmask_spec.rb b/spec/unit/parser/functions/is_valid_netmask_spec.rb deleted file mode 100644 index 97cbb7c..0000000 --- a/spec/unit/parser/functions/is_valid_netmask_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 -- cgit v1.2.3 From a47853502d7681edd8173e05249ce43d44bede7c Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 21:15:43 +0100 Subject: Removed load_variables. load_yaml is sufficient to solve this problem on its own. --- lib/puppet/parser/functions/load_variables.rb | 77 ----------------------- spec/unit/parser/functions/load_variables_spec.rb | 21 ------- 2 files changed, 98 deletions(-) delete mode 100644 lib/puppet/parser/functions/load_variables.rb delete mode 100644 spec/unit/parser/functions/load_variables_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/load_variables.rb b/lib/puppet/parser/functions/load_variables.rb deleted file mode 100644 index a28c64b..0000000 --- a/lib/puppet/parser/functions/load_variables.rb +++ /dev/null @@ -1,77 +0,0 @@ -# -# load_variables.rb -# - -module Puppet::Parser::Functions - newfunction(:load_variables, :type => :statement, :doc => <<-EOS -This function will allow for loading variables from an external YAML -file and expose them for further use inside the Puppet manifest file ... - -For example: - -Given following content of the data.yaml file: - - --- - host1.example.com: - foo: bar - baz: quux - question: 42 - host2.example.com: - abc: def - this: that - darth: vader - -Then calling load_variables in Puppet manifest file as follows: - - load_variables("/etc/puppet/data.yaml", $fqdn) - -Will result in addition of variables $foo, $baz and $question -for matching host name as per the variable $fqdn ... - -Another example which uses per-host file: - -Given following content of the file data-host1.example.com.yaml: - - --- - foo: bar - -Then when we call load_variables like this: - - load_variables("/etc/puppet/data-${fqdn}.yaml") - -This will result in a variable $foo being added and ready for use. - EOS - ) do |arguments| - - raise(Puppet::ParseError, "load_variables(): Wrong number of " + - "arguments given (#{arguments.size} for 2)") if arguments.size < 2 - - data = {} - - file = arguments[0] - key = arguments[1] if arguments[1] - - if File.exists?(file) - - begin - data = YAML.load_file(file) - rescue => error - raise(Puppet::ParseError, "load_variables(): Unable to load data " + - "from the file `%s': %s" % file, error.to_s) - end - - raise(Puppet::ParseError, "load_variables(): Data in the file `%s' " + - "is not a hash" % file) unless data.is_a?(Hash) - - data = ((data[key] and data[key].is_a?(Hash)) ? data[key] : {}) if key - end - - data.each do |param, value| - value = strinterp(value) # Evaluate any interpolated variable names ... - - setvar(param, value) - end - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/load_variables_spec.rb b/spec/unit/parser/functions/load_variables_spec.rb deleted file mode 100644 index dc29e61..0000000 --- a/spec/unit/parser/functions/load_variables_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 -- cgit v1.2.3 From 4915eff575801e73ab15a77b500eb2e0d42b579c Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 21:23:53 +0100 Subject: Removed crontab functions instead of unstubbing them. --- .../parser/functions/persistent_crontab_minutes.rb | 63 ---------------------- .../parser/functions/random_crontab_minutes.rb | 31 ----------- .../functions/persistent_crontab_minutes_spec.rb | 21 -------- .../functions/random_crontab_minutes_spec.rb | 21 -------- 4 files changed, 136 deletions(-) delete mode 100644 lib/puppet/parser/functions/persistent_crontab_minutes.rb delete mode 100644 lib/puppet/parser/functions/random_crontab_minutes.rb delete mode 100644 spec/unit/parser/functions/persistent_crontab_minutes_spec.rb delete mode 100644 spec/unit/parser/functions/random_crontab_minutes_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/persistent_crontab_minutes.rb b/lib/puppet/parser/functions/persistent_crontab_minutes.rb deleted file mode 100644 index cd80094..0000000 --- a/lib/puppet/parser/functions/persistent_crontab_minutes.rb +++ /dev/null @@ -1,63 +0,0 @@ -# -# persistent_crontab_minutes.rb -# - -module Puppet::Parser::Functions - newfunction(:persistent_crontab_minutes, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - raise(Puppet::ParseError, "Wrong number of arguments " + - "given (#{arguments.size} for 2)") if arguments.size < 2 - - require 'md5' - - value = 0 - - job = arguments[0] - host = arguments[1] - - environment = Puppet[:environment] - - # We select first directory that exists. This might not be the best idea ... - modules = Puppet[:modulepath].split(':').select { |i| File.exists?(i) }.first - - raise(Puppet::ParseError, "Unable to determine the storage " + - "directory for Puppet modules") unless modules - - # Prepare the file where we store current value ... - file = "/puppet/state/crontab/#{host}-#{job}.minutes" - file = File.join(modules, file) - - # Get the directory portion from the file name ... - directory = File.dirname(file) - - FileUtils.mkdir_p(directory) unless File.directory?(directory) - - if FileTest.exists?(file) - File.open(file, 'r') { |f| value = f.read.to_i } - - raise(Puppet::ParseError, "The value for minutes in the file `%s' " + - "is out of the range from 0 to 59 inclusive") unless value < 60 - else - # - # Pick a random number based on the job and host name. This will yield - # the same value for exactly the same combination of the job and host name. - # - value = MD5.new(job_name + host).to_s.hex % 60 - - # Minutes are from 0 to 59 inclusive ... - value = value < 60 ? value : 59 - - File.open(file, 'w') { |f| f.write(value) } - end - - # Tell Puppet to keep an eye on this file ... - parser = Puppet::Parser::Parser.new(environment) - parser.watch_file(file) if File.exists?(file) - - return value - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/random_crontab_minutes.rb b/lib/puppet/parser/functions/random_crontab_minutes.rb deleted file mode 100644 index 8ab29e1..0000000 --- a/lib/puppet/parser/functions/random_crontab_minutes.rb +++ /dev/null @@ -1,31 +0,0 @@ -# -# random_crontab_minutes.rb -# - -module Puppet::Parser::Functions - newfunction(:random_crontab_minutes, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - raise(Puppet::ParseError, "Wrong number of arguments " + - "given (#{arguments.size} for 2)") if arguments.size < 2 - - require 'md5' - - job_name = arguments[0] - host = arguments[1] - - # - # Pick a random number based on the job and host name. This will yield - # the same value for exactly the same combination of the job and host name. - # - value = MD5.new(job_name + host).to_s.hex % 60 - - # Minutes are from 0 to 59 inclusive ... - value = value < 60 ? value : 59 - - return value - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb b/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb deleted file mode 100644 index 1d8cbe7..0000000 --- a/spec/unit/parser/functions/persistent_crontab_minutes_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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/random_crontab_minutes_spec.rb b/spec/unit/parser/functions/random_crontab_minutes_spec.rb deleted file mode 100644 index b47b3ae..0000000 --- a/spec/unit/parser/functions/random_crontab_minutes_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 -- cgit v1.2.3 From 7d6ae5d57ce45ff1293f02b90c816a7f938a3af6 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Thu, 28 Jul 2011 21:30:02 +0100 Subject: Count functionality overlaps with size - so removing it. --- lib/puppet/parser/functions/count.rb | 36 -------------------------------- spec/unit/parser/functions/count_spec.rb | 26 ----------------------- 2 files changed, 62 deletions(-) delete mode 100644 lib/puppet/parser/functions/count.rb delete mode 100755 spec/unit/parser/functions/count_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/count.rb b/lib/puppet/parser/functions/count.rb deleted file mode 100644 index c4e2283..0000000 --- a/lib/puppet/parser/functions/count.rb +++ /dev/null @@ -1,36 +0,0 @@ -# -# count.rb -# - -# TODO(Krzysztof Wilczynski): We need to add support for regular expression ... -# TODO(Krzysztof Wilczynski): Support for hash values would be nice too ... - -module Puppet::Parser::Functions - newfunction(:count, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - # Technically we support two arguments but only first is mandatory ... - raise(Puppet::ParseError, "count(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 - - value = arguments[0] - klass = value.class - - unless [Array, Hash, String].include?(klass) - raise(Puppet::ParseError, 'count(): Requires either ' + - 'array, hash or string to work with') - end - - item = arguments[1] if arguments[1] - - value = value.is_a?(Hash) ? value.keys : value - - # No item to look for and count? Then just return current size ... - result = item ? value.count(item) : value.size - - return result - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/count_spec.rb b/spec/unit/parser/functions/count_spec.rb deleted file mode 100755 index 62d005a..0000000 --- a/spec/unit/parser/functions/count_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should return the size of an array" do - result = @scope.function_count([['a','c','b']]) - result.should(eq(3)) - end - -end -- cgit v1.2.3 From ce48eb6e7a76f74e1f61c76ac3b185031c40772b Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 00:10:31 +0100 Subject: Allow sort for strings. --- lib/puppet/parser/functions/sort.rb | 8 +++++++- spec/unit/parser/functions/sort_spec.rb | 5 +++++ 2 files changed, 12 insertions(+), 1 deletion(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/sort.rb b/lib/puppet/parser/functions/sort.rb index 54a4018..49ca20a 100644 --- a/lib/puppet/parser/functions/sort.rb +++ b/lib/puppet/parser/functions/sort.rb @@ -12,7 +12,13 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end - arguments[0].sort + value = arguments[0] + + if value.is_a?(Array) then + value.sort + elsif value.is_a?(String) then + value.split("").sort.to_s + end end end diff --git a/spec/unit/parser/functions/sort_spec.rb b/spec/unit/parser/functions/sort_spec.rb index da5db7a..fbe3073 100644 --- a/spec/unit/parser/functions/sort_spec.rb +++ b/spec/unit/parser/functions/sort_spec.rb @@ -23,4 +23,9 @@ describe "the sort function" do result.should(eq(['a','b','c'])) end + it "should sort a string" do + result = @scope.function_sort(["acb"]) + result.should(eq('abc')) + end + end -- cgit v1.2.3 From 4080c0534e76cf68b935344c75b2382f0184a226 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 17:55:45 +0100 Subject: (#2) unstub is_valid_mac_address. --- lib/puppet/parser/functions/is_valid_mac_address.rb | 8 ++++++++ spec/unit/parser/functions/is_valid_mac_address_spec.rb | 9 +++++++-- 2 files changed, 15 insertions(+), 2 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_valid_mac_address.rb b/lib/puppet/parser/functions/is_valid_mac_address.rb index 0b91d0d..a00d874 100644 --- a/lib/puppet/parser/functions/is_valid_mac_address.rb +++ b/lib/puppet/parser/functions/is_valid_mac_address.rb @@ -12,6 +12,14 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + mac = arguments[0] + + if /^[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}$/.match(mac) then + return true + else + return false + end + 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 index c4eb468..62e6fee 100644 --- a/spec/unit/parser/functions/is_valid_mac_address_spec.rb +++ b/spec/unit/parser/functions/is_valid_mac_address_spec.rb @@ -19,12 +19,17 @@ describe "the is_valid_mac_address function" do end it "should return true if a valid mac address" do - result = @scope.function_is_valid_mac_address("00:a0:1f:12:7f:a0") + result = @scope.function_is_valid_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_valid_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_valid_mac_address("not valid") + result = @scope.function_is_valid_mac_address(["not valid"]) result.should(eq(false)) end -- cgit v1.2.3 From db7e06e301b689efcd421fd56fb1c23e3595e173 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 18:00:32 +0100 Subject: Removed join_with_prefix. --- lib/puppet/parser/functions/join_with_prefix.rb | 38 ---------------------- .../unit/parser/functions/join_with_prefix_spec.rb | 26 --------------- 2 files changed, 64 deletions(-) delete mode 100644 lib/puppet/parser/functions/join_with_prefix.rb delete mode 100644 spec/unit/parser/functions/join_with_prefix_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/join_with_prefix.rb b/lib/puppet/parser/functions/join_with_prefix.rb deleted file mode 100644 index 8bf96d9..0000000 --- a/lib/puppet/parser/functions/join_with_prefix.rb +++ /dev/null @@ -1,38 +0,0 @@ -# -# join_with_prefix.rb -# - -module Puppet::Parser::Functions - newfunction(:join_with_prefix, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - # Technically we support three arguments but only first is mandatory ... - raise(Puppet::ParseError, "join(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 - - array = arguments[0] - - unless array.is_a?(Array) - raise(Puppet::ParseError, 'join_with_prefix(): Requires ' + - 'array to work with') - end - - prefix = arguments[1] if arguments[1] - suffix = arguments[2] if arguments[2] - - if prefix and suffix - result = prefix + array.join(suffix + prefix) - elsif prefix and not suffix - result = array.collect { |i| prefix ? prefix + i : i } - elsif suffix and not prefix - result = array.join(suffix) - else - result = array.join - end - - return result - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/join_with_prefix_spec.rb b/spec/unit/parser/functions/join_with_prefix_spec.rb deleted file mode 100644 index 70e6965..0000000 --- a/spec/unit/parser/functions/join_with_prefix_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should join an array into a string" do - result = @scope.function_join_with_prefix([["a","b","c"], ":", "p"]) - result.should(eq("pa:pb:pc")) - end - -end -- cgit v1.2.3 From 56a402e6542105ec63c5071e685d5af93fd4d0f3 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 20:08:31 +0100 Subject: (#2) unstub is_valid_domain_name --- .../parser/functions/is_valid_domain_name.rb | 8 +++++ .../parser/functions/is_valid_domain_name_spec.rb | 35 ++++++++++++++++++---- 2 files changed, 38 insertions(+), 5 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_valid_domain_name.rb b/lib/puppet/parser/functions/is_valid_domain_name.rb index c0b319c..99d6f86 100644 --- a/lib/puppet/parser/functions/is_valid_domain_name.rb +++ b/lib/puppet/parser/functions/is_valid_domain_name.rb @@ -12,6 +12,14 @@ module Puppet::Parser::Functions "given #{arguments.size} for 1") end + domain = arguments[0] + + if domain =~ /^(([a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])\.?$/ then + return true + else + return false + end + 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 index f03f6e8..3339447 100644 --- a/spec/unit/parser/functions/is_valid_domain_name_spec.rb +++ b/spec/unit/parser/functions/is_valid_domain_name_spec.rb @@ -19,13 +19,38 @@ describe "the is_valid_domain_name function" do end it "should return true if a valid domain name" do - result = @scope.function_is_valid_domain_name("foo.bar.com") - result.should(eq(true)) + result = @scope.function_is_valid_domain_name(["foo.bar.com"]) + result.should(be_true) end - it "should return false if not a valid domain name" do - result = @scope.function_is_valid_domain_name("not valid") - result.should(eq(false)) + it "should allow domain parts to start with numbers" do + result = @scope.function_is_valid_domain_name(["3foo.2bar.com"]) + result.should(be_true) + end + + it "should allow domain to end with a dot" do + result = @scope.function_is_valid_domain_name(["3foo.2bar.com."]) + result.should(be_true) + end + + it "should allow a single part domain" do + result = @scope.function_is_valid_domain_name(["orange"]) + result.should(be_true) + end + + it "should return false if domain parts start with hyphens" do + result = @scope.function_is_valid_domain_name(["-3foo.2bar.com"]) + result.should(be_false) + end + + it "should return true if domain contains hyphens" do + result = @scope.function_is_valid_domain_name(["3foo-bar.2bar-fuzz.com"]) + result.should(be_true) + end + + it "should return false if domain name contains spaces" do + result = @scope.function_is_valid_domain_name(["not valid"]) + result.should(be_false) end end -- cgit v1.2.3 From 18e5302614bce168ac07e35dc23b058064e9e41c Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 20:11:47 +0100 Subject: (#2) fix is_string finally so it also makes sure numbers return false. --- lib/puppet/parser/functions/is_string.rb | 4 ++++ spec/unit/parser/functions/is_string_spec.rb | 20 ++++++++++++++++++++ 2 files changed, 24 insertions(+) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_string.rb b/lib/puppet/parser/functions/is_string.rb index 61037e3..8a02a10 100644 --- a/lib/puppet/parser/functions/is_string.rb +++ b/lib/puppet/parser/functions/is_string.rb @@ -14,6 +14,10 @@ module Puppet::Parser::Functions result = type.is_a?(String) + if result and (type == type.to_f.to_s or type == type.to_i.to_s) then + return false + end + return result end end diff --git a/spec/unit/parser/functions/is_string_spec.rb b/spec/unit/parser/functions/is_string_spec.rb index 8c0061e..4f3f5fd 100644 --- a/spec/unit/parser/functions/is_string_spec.rb +++ b/spec/unit/parser/functions/is_string_spec.rb @@ -18,4 +18,24 @@ describe "the is_string function" do 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.should(eq(true)) + end + + it "should return false if an integer" do + 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.should(eq(false)) + end + + it "should return false if an array" do + result = @scope.function_is_string([["a","b","c"]]) + result.should(eq(false)) + end + end -- cgit v1.2.3 From aa023c1e5d23b2a5a66dbe9a36d0e8765a8d8cff Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 20:56:40 +0100 Subject: Removed date stub since this functinality is available in strftime anyway. --- lib/puppet/parser/functions/date.rb | 20 -------------------- spec/unit/parser/functions/date_spec.rb | 21 --------------------- 2 files changed, 41 deletions(-) delete mode 100644 lib/puppet/parser/functions/date.rb delete mode 100755 spec/unit/parser/functions/date_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/date.rb b/lib/puppet/parser/functions/date.rb deleted file mode 100644 index 0439bd1..0000000 --- a/lib/puppet/parser/functions/date.rb +++ /dev/null @@ -1,20 +0,0 @@ -# -# date.rb -# - -module Puppet::Parser::Functions - newfunction(:date, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "date(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - # TODO: stubbed - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/date_spec.rb b/spec/unit/parser/functions/date_spec.rb deleted file mode 100755 index dcba4af..0000000 --- a/spec/unit/parser/functions/date_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 -- cgit v1.2.3 From 6827ad804f2eb44839f9a3e99f40f1bb2284f491 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 20:57:10 +0100 Subject: (#1) provide some more detailed tests for a number of functions. --- spec/unit/parser/functions/abs_spec.rb | 7 ++++++- spec/unit/parser/functions/downcase_spec.rb | 5 +++++ spec/unit/parser/functions/empty_spec.rb | 5 +++++ spec/unit/parser/functions/flatten_spec.rb | 5 +++++ spec/unit/parser/functions/is_array_spec.rb | 5 +++++ spec/unit/parser/functions/is_float_spec.rb | 2 +- spec/unit/parser/functions/num2bool_spec.rb | 7 ++++++- spec/unit/parser/functions/shuffle_spec.rb | 10 ++++++++++ spec/unit/parser/functions/strftime_spec.rb | 15 +++++++++++++++ spec/unit/parser/functions/time_spec.rb | 15 +++++++++++++++ spec/unit/parser/functions/type_spec.rb | 12 +++++++++++- 11 files changed, 84 insertions(+), 4 deletions(-) (limited to 'spec/unit') diff --git a/spec/unit/parser/functions/abs_spec.rb b/spec/unit/parser/functions/abs_spec.rb index 6bf0b41..65ba2e8 100755 --- a/spec/unit/parser/functions/abs_spec.rb +++ b/spec/unit/parser/functions/abs_spec.rb @@ -19,8 +19,13 @@ describe "the abs function" do 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.should(eq(5678)) + end + end diff --git a/spec/unit/parser/functions/downcase_spec.rb b/spec/unit/parser/functions/downcase_spec.rb index 0d53220..0bccd5f 100755 --- a/spec/unit/parser/functions/downcase_spec.rb +++ b/spec/unit/parser/functions/downcase_spec.rb @@ -23,4 +23,9 @@ describe "the downcase function" do result.should(eq("asfd")) end + it "should do nothing to a string that is already downcase" do + result = @scope.function_downcase(["asdf asdf"]) + result.should(eq("asdf asdf")) + end + end diff --git a/spec/unit/parser/functions/empty_spec.rb b/spec/unit/parser/functions/empty_spec.rb index 6c0fe69..cb0021f 100755 --- a/spec/unit/parser/functions/empty_spec.rb +++ b/spec/unit/parser/functions/empty_spec.rb @@ -23,4 +23,9 @@ describe "the empty function" do result.should(eq(true)) end + it "should return a false for a non-empty string" do + result = @scope.function_empty(['asdf']) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/flatten_spec.rb b/spec/unit/parser/functions/flatten_spec.rb index 91cf4ef..7bedeb2 100755 --- a/spec/unit/parser/functions/flatten_spec.rb +++ b/spec/unit/parser/functions/flatten_spec.rb @@ -23,4 +23,9 @@ describe "the flatten function" do 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.should(eq(["a","b","c","d"])) + end + end diff --git a/spec/unit/parser/functions/is_array_spec.rb b/spec/unit/parser/functions/is_array_spec.rb index 15b563c..537595c 100644 --- a/spec/unit/parser/functions/is_array_spec.rb +++ b/spec/unit/parser/functions/is_array_spec.rb @@ -28,4 +28,9 @@ describe "the is_array function" do result.should(eq(false)) end + it "should return false if passed a string" do + result = @scope.function_is_array(["asdf"]) + result.should(eq(false)) + end + end diff --git a/spec/unit/parser/functions/is_float_spec.rb b/spec/unit/parser/functions/is_float_spec.rb index 35c0dd6..55ba8cf 100644 --- a/spec/unit/parser/functions/is_float_spec.rb +++ b/spec/unit/parser/functions/is_float_spec.rb @@ -28,7 +28,7 @@ describe "the is_float function" do result.should(eq(false)) end - it "should return false if not an integer" do + it "should return false if an integer" do result = @scope.function_is_float(["3"]) result.should(eq(false)) end diff --git a/spec/unit/parser/functions/num2bool_spec.rb b/spec/unit/parser/functions/num2bool_spec.rb index 2f6435d..6585273 100644 --- a/spec/unit/parser/functions/num2bool_spec.rb +++ b/spec/unit/parser/functions/num2bool_spec.rb @@ -20,7 +20,12 @@ describe "the num2bool function" do it "should return true if 1" do result = @scope.function_num2bool(["1"]) - result.should(eq(true)) + result.should(be_true) + end + + it "should return false if 0" do + result = @scope.function_num2bool(["0"]) + result.should(be_false) end end diff --git a/spec/unit/parser/functions/shuffle_spec.rb b/spec/unit/parser/functions/shuffle_spec.rb index cf063c6..936c2fd 100644 --- a/spec/unit/parser/functions/shuffle_spec.rb +++ b/spec/unit/parser/functions/shuffle_spec.rb @@ -18,4 +18,14 @@ describe "the shuffle function" do 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.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.split("").sort.to_s.should(eq("adfs")) + end + end diff --git a/spec/unit/parser/functions/strftime_spec.rb b/spec/unit/parser/functions/strftime_spec.rb index e377954..f7a2cd9 100644 --- a/spec/unit/parser/functions/strftime_spec.rb +++ b/spec/unit/parser/functions/strftime_spec.rb @@ -18,4 +18,19 @@ describe "the strftime function" do 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.to_i.should(be > 1311953157) + end + + it "using %s should be lower then 1.5 trillion" do + 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.should =~ /^\d{4}-\d{2}-\d{2}$/ + end + end diff --git a/spec/unit/parser/functions/time_spec.rb b/spec/unit/parser/functions/time_spec.rb index 8bf5982..666e8e0 100644 --- a/spec/unit/parser/functions/time_spec.rb +++ b/spec/unit/parser/functions/time_spec.rb @@ -18,4 +18,19 @@ describe "the time function" do lambda { @scope.function_time(['','']) }.should( raise_error(Puppet::ParseError)) end + it "should return a number" do + result = @scope.function_time([]) + result.class.should(eq(Fixnum)) + end + + it "should be higher then when I wrote this test" do + result = @scope.function_time([]) + result.should(be > 1311953157) + end + + it "should be lower then 1.5 trillion" do + result = @scope.function_time([]) + result.should(be < 1500000000) + end + end diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb index fddb87d..36c3823 100644 --- a/spec/unit/parser/functions/type_spec.rb +++ b/spec/unit/parser/functions/type_spec.rb @@ -18,9 +18,19 @@ describe "the type function" do lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError)) end - it "should return a type when given a string" do + it "should return String when given a string" do 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.should(eq('Array')) + end + + it "should return Hash when given a hash" do + result = @scope.function_type([{"a"=>1,"b"=>2}]) + result.should(eq('Hash')) + end + end -- cgit v1.2.3 From 284843bd968acd3c361907aadc7921e1eda94822 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 21:17:19 +0100 Subject: Some improvements to values_at tests. --- spec/unit/parser/functions/values_at_spec.rb | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'spec/unit') diff --git a/spec/unit/parser/functions/values_at_spec.rb b/spec/unit/parser/functions/values_at_spec.rb index ec8730b..6c45316 100644 --- a/spec/unit/parser/functions/values_at_spec.rb +++ b/spec/unit/parser/functions/values_at_spec.rb @@ -18,9 +18,28 @@ describe "the values_at function" do 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)) + end + it "should return a value at from an array" do 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.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.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.should(eq(['a','c','e','f'])) + end + end -- cgit v1.2.3 From f9634b7f9b03be86e25dc740cdcda754a0d2bf7d Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 22:08:09 +0100 Subject: Remove rand. --- lib/puppet/parser/functions/rand.rb | 18 ------------------ spec/unit/parser/functions/rand_spec.rb | 21 --------------------- 2 files changed, 39 deletions(-) delete mode 100644 lib/puppet/parser/functions/rand.rb delete mode 100644 spec/unit/parser/functions/rand_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/rand.rb b/lib/puppet/parser/functions/rand.rb deleted file mode 100644 index 6d870dc..0000000 --- a/lib/puppet/parser/functions/rand.rb +++ /dev/null @@ -1,18 +0,0 @@ -# -# rand.rb -# - -module Puppet::Parser::Functions - newfunction(:rand, :type => :rvalue, :doc => <<-EOS - EOS - ) do |arguments| - - if (arguments.size != 0) and (arguments.size != 1) then - raise(Puppet::ParseError, "rand(): Wrong number of arguments "+ - "given #{arguments.size} for 0 or 1") - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/rand_spec.rb b/spec/unit/parser/functions/rand_spec.rb deleted file mode 100644 index 818d1c5..0000000 --- a/spec/unit/parser/functions/rand_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -#!/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 -- cgit v1.2.3 From 19313b43ea04066a88a0b78e83650ac52785e2e9 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 22:18:56 +0100 Subject: (#3) Apply missing documentation to more functions. --- lib/puppet/parser/functions/num2bool.rb | 2 + lib/puppet/parser/functions/prefix.rb | 7 +++ lib/puppet/parser/functions/range.rb | 12 +++++ lib/puppet/parser/functions/reverse.rb | 1 + lib/puppet/parser/functions/rstrip.rb | 1 + lib/puppet/parser/functions/shuffle.rb | 1 + lib/puppet/parser/functions/size.rb | 1 + lib/puppet/parser/functions/sort.rb | 1 + lib/puppet/parser/functions/squeeze.rb | 1 + lib/puppet/parser/functions/str2bool.rb | 3 ++ lib/puppet/parser/functions/strftime.rb | 63 ++++++++++++++++++++++++ lib/puppet/parser/functions/strip.rb | 8 +++ lib/puppet/parser/functions/swapcase.rb | 7 +++ lib/puppet/parser/functions/time.rb | 7 +++ lib/puppet/parser/functions/type.rb | 19 ++++++- lib/puppet/parser/functions/unique.rb | 17 +++++++ lib/puppet/parser/functions/upcase.rb | 9 ++++ lib/puppet/parser/functions/validate_resource.rb | 5 ++ lib/puppet/parser/functions/values.rb | 14 ++++++ lib/puppet/parser/functions/values_at.rb | 25 ++++++++-- lib/puppet/parser/functions/zip.rb | 9 ++++ spec/unit/parser/functions/type_spec.rb | 22 ++++++--- spec/unit/parser/functions/unique_spec.rb | 9 +++- spec/unit/parser/functions/values_spec.rb | 4 ++ 24 files changed, 235 insertions(+), 13 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb index 2baef62..874db22 100644 --- a/lib/puppet/parser/functions/num2bool.rb +++ b/lib/puppet/parser/functions/num2bool.rb @@ -6,6 +6,8 @@ module Puppet::Parser::Functions newfunction(:num2bool, :type => :rvalue, :doc => <<-EOS +This function converts a number into a true boolean. Zero becomes false. Numbers +higher then 0 become true. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/prefix.rb b/lib/puppet/parser/functions/prefix.rb index 0e0cee2..4593976 100644 --- a/lib/puppet/parser/functions/prefix.rb +++ b/lib/puppet/parser/functions/prefix.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:prefix, :type => :rvalue, :doc => <<-EOS +This function applies a prefix to all elements in an array. + +*Examles:* + + prefix(['a','b','c'], 'p') + +Will return: ['pa','pb','pc'] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/range.rb b/lib/puppet/parser/functions/range.rb index 6afb50c..6e85422 100644 --- a/lib/puppet/parser/functions/range.rb +++ b/lib/puppet/parser/functions/range.rb @@ -6,6 +6,18 @@ module Puppet::Parser::Functions newfunction(:range, :type => :rvalue, :doc => <<-EOS +When given range in the form of (start, stop) it will extrapolate a range as +an array. + +*Examples:* + + range("0", "9") + +Will return: [0,1,2,3,4,5,6,7,8,9] + + range("a", "c") + +Will return: ["a","b","c"] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/reverse.rb b/lib/puppet/parser/functions/reverse.rb index 79e9b93..fe04869 100644 --- a/lib/puppet/parser/functions/reverse.rb +++ b/lib/puppet/parser/functions/reverse.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:reverse, :type => :rvalue, :doc => <<-EOS +Reverses the order of a string or array. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/rstrip.rb b/lib/puppet/parser/functions/rstrip.rb index 56849d3..29b0998 100644 --- a/lib/puppet/parser/functions/rstrip.rb +++ b/lib/puppet/parser/functions/rstrip.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:rstrip, :type => :rvalue, :doc => <<-EOS +Strips leading spaces to the right of the string. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/shuffle.rb b/lib/puppet/parser/functions/shuffle.rb index 73e798c..18134ab 100644 --- a/lib/puppet/parser/functions/shuffle.rb +++ b/lib/puppet/parser/functions/shuffle.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:shuffle, :type => :rvalue, :doc => <<-EOS +Randomizes the order of a string or array elements. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/size.rb b/lib/puppet/parser/functions/size.rb index aa4f4ad..cc207e3 100644 --- a/lib/puppet/parser/functions/size.rb +++ b/lib/puppet/parser/functions/size.rb @@ -6,6 +6,7 @@ module Puppet::Parser::Functions newfunction(:size, :type => :rvalue, :doc => <<-EOS +Returns the number of elements in a string or array. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/sort.rb b/lib/puppet/parser/functions/sort.rb index 49ca20a..3785496 100644 --- a/lib/puppet/parser/functions/sort.rb +++ b/lib/puppet/parser/functions/sort.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:sort, :type => :rvalue, :doc => <<-EOS +Sorts strings and arrays lexically. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/squeeze.rb b/lib/puppet/parser/functions/squeeze.rb index 9a1dd20..65c174a 100644 --- a/lib/puppet/parser/functions/squeeze.rb +++ b/lib/puppet/parser/functions/squeeze.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:squeeze, :type => :rvalue, :doc => <<-EOS +Returns a new string where runs of the same character that occur in this set are replaced by a single character. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/str2bool.rb b/lib/puppet/parser/functions/str2bool.rb index f3a6d6c..c320da6 100644 --- a/lib/puppet/parser/functions/str2bool.rb +++ b/lib/puppet/parser/functions/str2bool.rb @@ -4,6 +4,9 @@ module Puppet::Parser::Functions newfunction(:str2bool, :type => :rvalue, :doc => <<-EOS +This converts a string to a boolean. This attempt to convert strings that +contain things like: y, 1, t, true to 'true' and strings that contain things +like: 0, f, n, false, no to 'false'. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/strftime.rb b/lib/puppet/parser/functions/strftime.rb index c919320..0b52ade 100644 --- a/lib/puppet/parser/functions/strftime.rb +++ b/lib/puppet/parser/functions/strftime.rb @@ -4,6 +4,69 @@ module Puppet::Parser::Functions newfunction(:strftime, :type => :rvalue, :doc => <<-EOS +This function returns formatted time. + +*Examples:* + +To return the time since epoch: + + strftime("%s") + +To return the date: + + strftime("%Y-%m-%d") + +*Format meaning:* + + %a - The abbreviated weekday name (``Sun'') + %A - The full weekday name (``Sunday'') + %b - The abbreviated month name (``Jan'') + %B - The full month name (``January'') + %c - The preferred local date and time representation + %C - Century (20 in 2009) + %d - Day of the month (01..31) + %D - Date (%m/%d/%y) + %e - Day of the month, blank-padded ( 1..31) + %F - Equivalent to %Y-%m-%d (the ISO 8601 date format) + %h - Equivalent to %b + %H - Hour of the day, 24-hour clock (00..23) + %I - Hour of the day, 12-hour clock (01..12) + %j - Day of the year (001..366) + %k - hour, 24-hour clock, blank-padded ( 0..23) + %l - hour, 12-hour clock, blank-padded ( 0..12) + %L - Millisecond of the second (000..999) + %m - Month of the year (01..12) + %M - Minute of the hour (00..59) + %n - Newline (\n) + %N - Fractional seconds digits, default is 9 digits (nanosecond) + %3N millisecond (3 digits) + %6N microsecond (6 digits) + %9N nanosecond (9 digits) + %p - Meridian indicator (``AM'' or ``PM'') + %P - Meridian indicator (``am'' or ``pm'') + %r - time, 12-hour (same as %I:%M:%S %p) + %R - time, 24-hour (%H:%M) + %s - Number of seconds since 1970-01-01 00:00:00 UTC. + %S - Second of the minute (00..60) + %t - Tab character (\t) + %T - time, 24-hour (%H:%M:%S) + %u - Day of the week as a decimal, Monday being 1. (1..7) + %U - Week number of the current year, + starting with the first Sunday as the first + day of the first week (00..53) + %v - VMS date (%e-%b-%Y) + %V - Week number of year according to ISO 8601 (01..53) + %W - Week number of the current year, + starting with the first Monday as the first + day of the first week (00..53) + %w - Day of the week (Sunday is 0, 0..6) + %x - Preferred representation for the date alone, no time + %X - Preferred representation for the time alone, no date + %y - Year without a century (00..99) + %Y - Year with century + %z - Time zone as hour offset from UTC (e.g. +0900) + %Z - Time zone name + %% - Literal ``%'' character EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/strip.rb b/lib/puppet/parser/functions/strip.rb index ebab20e..5f4630d 100644 --- a/lib/puppet/parser/functions/strip.rb +++ b/lib/puppet/parser/functions/strip.rb @@ -4,6 +4,14 @@ module Puppet::Parser::Functions newfunction(:strip, :type => :rvalue, :doc => <<-EOS +This function removes leading and trailing whitespace from a string or from +every string inside an array. + +*Examples:* + + strip(" aaa ") + +Would result in: "aaa" EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/swapcase.rb b/lib/puppet/parser/functions/swapcase.rb index a0002a9..b9e6632 100644 --- a/lib/puppet/parser/functions/swapcase.rb +++ b/lib/puppet/parser/functions/swapcase.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:swapcase, :type => :rvalue, :doc => <<-EOS +This function will swap the existing case of a string. + +*Examples:* + + swapcase("aBcD") + +Would result in: "AbCd" EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/time.rb b/lib/puppet/parser/functions/time.rb index e1f5b6f..0cddaf8 100644 --- a/lib/puppet/parser/functions/time.rb +++ b/lib/puppet/parser/functions/time.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:time, :type => :rvalue, :doc => <<-EOS +This function will return the current time since epoch as an integer. + +*Examples:* + + time() + +Will return something like: 1311972653 EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/type.rb b/lib/puppet/parser/functions/type.rb index 389a056..de6087e 100644 --- a/lib/puppet/parser/functions/type.rb +++ b/lib/puppet/parser/functions/type.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:type, :type => :rvalue, :doc => <<-EOS +Returns the type when passed a variable. Type can be one of: + +* string +* array +* hash +* float +* integer EOS ) do |arguments| @@ -22,11 +29,19 @@ module Puppet::Parser::Functions # We note that Integer is the parent to Bignum and Fixnum ... result = case klass - when /^(?:Big|Fix)num$/ then 'Integer' + when /^(?:Big|Fix)num$/ then 'integer' else klass end - return result + if result == "String" then + if value == value.to_i.to_s then + result = "Integer" + elsif value == value.to_f.to_s then + result = "Float" + end + end + + return result.downcase end end diff --git a/lib/puppet/parser/functions/unique.rb b/lib/puppet/parser/functions/unique.rb index a922c94..8844a74 100644 --- a/lib/puppet/parser/functions/unique.rb +++ b/lib/puppet/parser/functions/unique.rb @@ -4,6 +4,23 @@ module Puppet::Parser::Functions newfunction(:unique, :type => :rvalue, :doc => <<-EOS +This function will remove duplicates from strings and arrays. + +*Examples:* + + unique("aabbcc") + +Will return: + + abc + +You can also use this with arrays: + + unique(["a","a","b","b","c","c"]) + +This returns: + + ["a","b","c"] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/upcase.rb b/lib/puppet/parser/functions/upcase.rb index 8a9769d..fe6cadc 100644 --- a/lib/puppet/parser/functions/upcase.rb +++ b/lib/puppet/parser/functions/upcase.rb @@ -4,6 +4,15 @@ module Puppet::Parser::Functions newfunction(:upcase, :type => :rvalue, :doc => <<-EOS +Converts a string or an array of strings to uppercase. + +*Examples:* + + upcase("abcd") + +Will return: + + ASDF EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/validate_resource.rb b/lib/puppet/parser/functions/validate_resource.rb index bbb5a54..d71ef3f 100644 --- a/lib/puppet/parser/functions/validate_resource.rb +++ b/lib/puppet/parser/functions/validate_resource.rb @@ -4,6 +4,11 @@ module Puppet::Parser::Functions newfunction(:validate_resource, :type => :statement, :doc => <<-EOS +This function when placed at the beginning of a class, will go looking for a +valid kwalify schema by replacing the extension of the file with '.schema'. + +It will then validate the arguments passed to the function using that kwalify +schema. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/values.rb b/lib/puppet/parser/functions/values.rb index c1c4a77..1606756 100644 --- a/lib/puppet/parser/functions/values.rb +++ b/lib/puppet/parser/functions/values.rb @@ -4,6 +4,20 @@ module Puppet::Parser::Functions newfunction(:values, :type => :rvalue, :doc => <<-EOS +When given a hash this function will return the values of that hash. + +*Examples:* + + $hash = { + 'a' => 1, + 'b' => 2, + 'c' => 3, + } + values($hash) + +This example would return: + + [1,2,3] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/values_at.rb b/lib/puppet/parser/functions/values_at.rb index 331af6a..7f1de8e 100644 --- a/lib/puppet/parser/functions/values_at.rb +++ b/lib/puppet/parser/functions/values_at.rb @@ -2,11 +2,30 @@ # values_at.rb # -# TODO(Krzysztof Wilczynski): Support for hashes would be nice too ... -# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ... - module Puppet::Parser::Functions newfunction(:values_at, :type => :rvalue, :doc => <<-EOS +Finds value inside an array based on location. + +The first argument is the array you want to analyze, and the second element can +be a combination of: + +* A single numeric index +* A range in the form of 'start-stop' (eg. 4-9) +* An array combining the above + +*Examples*: + + values_at(['a','b','c'], 2) + +Would return ['c']. + + values_at(['a','b','c'], ["0-1"]) + +Would return ['a','b']. + + values_at(['a','b','c','d','e'], [0, "2-3"]) + +Would return ['a','c','d']. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/zip.rb b/lib/puppet/parser/functions/zip.rb index 024d64a..2b56e9c 100644 --- a/lib/puppet/parser/functions/zip.rb +++ b/lib/puppet/parser/functions/zip.rb @@ -4,6 +4,15 @@ module Puppet::Parser::Functions newfunction(:zip, :type => :rvalue, :doc => <<-EOS +Takes one element from first array and merges corresponding elements from second array. This generates a sequence of n-element arrays, where n is one more than the count of arguments. + +*Example:* + + zip(['1','2','3'],['4','5','6']) + +Would result in: + + ["1", "4"], ["2", "5"], ["3", "6"] EOS ) do |arguments| diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb index 36c3823..53071f3 100644 --- a/spec/unit/parser/functions/type_spec.rb +++ b/spec/unit/parser/functions/type_spec.rb @@ -18,19 +18,29 @@ describe "the type function" do lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError)) end - it "should return String when given a string" do + it "should return string when given a string" do result = @scope.function_type(["aaabbbbcccc"]) - result.should(eq('String')) + result.should(eq('string')) end - it "should return Array when given an array" do + it "should return array when given an array" do result = @scope.function_type([["aaabbbbcccc","asdf"]]) - result.should(eq('Array')) + result.should(eq('array')) end - it "should return Hash when given a hash" do + it "should return hash when given a hash" do result = @scope.function_type([{"a"=>1,"b"=>2}]) - result.should(eq('Hash')) + result.should(eq('hash')) + end + + it "should return integer when given an integer" do + 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.should(eq('float')) end end diff --git a/spec/unit/parser/functions/unique_spec.rb b/spec/unit/parser/functions/unique_spec.rb index 7b8b08d..627dc33 100644 --- a/spec/unit/parser/functions/unique_spec.rb +++ b/spec/unit/parser/functions/unique_spec.rb @@ -19,8 +19,13 @@ describe "the unique function" do end it "should remove duplicate elements in a string" do - result = @scope.function_squeeze([["aabbc"]]) - result.should(eq(['abc'])) + 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.should(eq(['a','b','c'])) end end diff --git a/spec/unit/parser/functions/values_spec.rb b/spec/unit/parser/functions/values_spec.rb index 92f1311..f6eb5b6 100644 --- a/spec/unit/parser/functions/values_spec.rb +++ b/spec/unit/parser/functions/values_spec.rb @@ -23,4 +23,8 @@ describe "the values function" do result.should(eq(['1','2','3'])) end + it "should return values from a hash" do + lambda { @scope.function_values([['a','b','c']]) }.should( raise_error(Puppet::ParseError)) + end + end -- cgit v1.2.3 From a1cae426f1d6b8f2c19184ec8aac3ebc47d97744 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 29 Jul 2011 23:09:30 +0100 Subject: (#3) Provide documentation for remaining functions. --- lib/puppet/parser/functions/delete.rb | 9 ++++++++- lib/puppet/parser/functions/delete_at.rb | 7 +++++++ lib/puppet/parser/functions/downcase.rb | 1 + lib/puppet/parser/functions/empty.rb | 1 + lib/puppet/parser/functions/flatten.rb | 8 ++++++++ lib/puppet/parser/functions/grep.rb | 10 ++++++++++ lib/puppet/parser/functions/hash.rb | 7 +++++++ lib/puppet/parser/functions/is_array.rb | 1 + lib/puppet/parser/functions/is_float.rb | 1 + lib/puppet/parser/functions/is_hash.rb | 1 + lib/puppet/parser/functions/is_integer.rb | 1 + lib/puppet/parser/functions/is_numeric.rb | 1 + lib/puppet/parser/functions/is_string.rb | 1 + lib/puppet/parser/functions/is_valid_domain_name.rb | 1 + lib/puppet/parser/functions/is_valid_ip_address.rb | 1 + lib/puppet/parser/functions/is_valid_mac_address.rb | 1 + lib/puppet/parser/functions/join.rb | 7 +++++++ lib/puppet/parser/functions/keys.rb | 1 + lib/puppet/parser/functions/load_json.rb | 2 ++ lib/puppet/parser/functions/load_yaml.rb | 2 ++ lib/puppet/parser/functions/lstrip.rb | 1 + lib/puppet/parser/functions/member.rb | 11 +++++++++++ lib/puppet/parser/functions/type.rb | 4 +++- spec/unit/parser/functions/type_spec.rb | 5 +++++ 24 files changed, 83 insertions(+), 2 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/delete.rb b/lib/puppet/parser/functions/delete.rb index 0d208b5..ab8f75b 100644 --- a/lib/puppet/parser/functions/delete.rb +++ b/lib/puppet/parser/functions/delete.rb @@ -7,11 +7,18 @@ module Puppet::Parser::Functions newfunction(:delete, :type => :rvalue, :doc => <<-EOS +Deletes a selected element from an array. + +*Examples:* + + delete(['a','b','c'], 'b') + +Would return: ['a','c'] EOS ) do |arguments| if (arguments.size != 2) then - raise(Puppet::ParseError, "is_valid_netmask(): Wrong number of arguments "+ + raise(Puppet::ParseError, "delete(): Wrong number of arguments "+ "given #{arguments.size} for 2") end diff --git a/lib/puppet/parser/functions/delete_at.rb b/lib/puppet/parser/functions/delete_at.rb index 10190ba..3eb4b53 100644 --- a/lib/puppet/parser/functions/delete_at.rb +++ b/lib/puppet/parser/functions/delete_at.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:delete_at, :type => :rvalue, :doc => <<-EOS +Deletes a determined indexed value from an array. + +*Examples:* + + delete_at(['a','b','c'], 1) + +Would return: ['a','c'] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/downcase.rb b/lib/puppet/parser/functions/downcase.rb index 71f8480..4066d21 100644 --- a/lib/puppet/parser/functions/downcase.rb +++ b/lib/puppet/parser/functions/downcase.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:downcase, :type => :rvalue, :doc => <<-EOS +Converts the case of a string or all strings in an array to lower case. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/empty.rb b/lib/puppet/parser/functions/empty.rb index e78ebf0..80ebb86 100644 --- a/lib/puppet/parser/functions/empty.rb +++ b/lib/puppet/parser/functions/empty.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:empty, :type => :rvalue, :doc => <<-EOS +Returns true if the variable is empty. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/flatten.rb b/lib/puppet/parser/functions/flatten.rb index 6036f72..781da78 100644 --- a/lib/puppet/parser/functions/flatten.rb +++ b/lib/puppet/parser/functions/flatten.rb @@ -4,6 +4,14 @@ module Puppet::Parser::Functions newfunction(:flatten, :type => :rvalue, :doc => <<-EOS +This function flattens any deeply nested arrays and returns a single flat array +as a result. + +*Examples:* + + flatten(['a', ['b', ['c']]]) + +Would return: ['a','b','c'] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/grep.rb b/lib/puppet/parser/functions/grep.rb index 2caaa6f..ceba9ec 100644 --- a/lib/puppet/parser/functions/grep.rb +++ b/lib/puppet/parser/functions/grep.rb @@ -4,6 +4,16 @@ module Puppet::Parser::Functions newfunction(:grep, :type => :rvalue, :doc => <<-EOS +This function searches through an array and returns any elements that match +the provided regular expression. + +*Examples:* + + grep(['aaa','bbb','ccc','aaaddd'], 'aaa') + +Would return: + + ['aaa','aaaddd'] EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/hash.rb b/lib/puppet/parser/functions/hash.rb index f0c01d4..453ba1e 100644 --- a/lib/puppet/parser/functions/hash.rb +++ b/lib/puppet/parser/functions/hash.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:hash, :type => :rvalue, :doc => <<-EOS +This function converts and array into a hash. + +*Examples:* + + hash(['a',1,'b',2,'c',3]) + +Would return: {'a'=>1,'b'=>2,'c'=>3} EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_array.rb b/lib/puppet/parser/functions/is_array.rb index 0b508fd..b39e184 100644 --- a/lib/puppet/parser/functions/is_array.rb +++ b/lib/puppet/parser/functions/is_array.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_array, :type => :rvalue, :doc => <<-EOS +Returns true if the variable passed to this function is an array. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_float.rb b/lib/puppet/parser/functions/is_float.rb index 8aed848..2fc05ba 100644 --- a/lib/puppet/parser/functions/is_float.rb +++ b/lib/puppet/parser/functions/is_float.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_float, :type => :rvalue, :doc => <<-EOS +Returns true if the variable passed to this function is a float. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_hash.rb b/lib/puppet/parser/functions/is_hash.rb index 000306e..ad907f0 100644 --- a/lib/puppet/parser/functions/is_hash.rb +++ b/lib/puppet/parser/functions/is_hash.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_hash, :type => :rvalue, :doc => <<-EOS +Returns true if the variable passed to this function is a hash. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_integer.rb b/lib/puppet/parser/functions/is_integer.rb index 9dd1cee..8ee34f6 100644 --- a/lib/puppet/parser/functions/is_integer.rb +++ b/lib/puppet/parser/functions/is_integer.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_integer, :type => :rvalue, :doc => <<-EOS +Returns true if the variable returned to this string is an integer. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_numeric.rb b/lib/puppet/parser/functions/is_numeric.rb index c2c0fb5..ce13ece 100644 --- a/lib/puppet/parser/functions/is_numeric.rb +++ b/lib/puppet/parser/functions/is_numeric.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_numeric, :type => :rvalue, :doc => <<-EOS +Returns true if the variable passed to this function is a number. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_string.rb b/lib/puppet/parser/functions/is_string.rb index 8a02a10..f5bef04 100644 --- a/lib/puppet/parser/functions/is_string.rb +++ b/lib/puppet/parser/functions/is_string.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_string, :type => :rvalue, :doc => <<-EOS +Returns true if the variable passed to this function is a string. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_valid_domain_name.rb b/lib/puppet/parser/functions/is_valid_domain_name.rb index 99d6f86..7dd9c0b 100644 --- a/lib/puppet/parser/functions/is_valid_domain_name.rb +++ b/lib/puppet/parser/functions/is_valid_domain_name.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_valid_domain_name, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid IP address. Support for IPv4 and IPv6 address types is included. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_valid_ip_address.rb b/lib/puppet/parser/functions/is_valid_ip_address.rb index 4f45890..604d938 100644 --- a/lib/puppet/parser/functions/is_valid_ip_address.rb +++ b/lib/puppet/parser/functions/is_valid_ip_address.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_valid_ip_address, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid IP address. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/is_valid_mac_address.rb b/lib/puppet/parser/functions/is_valid_mac_address.rb index a00d874..53199b6 100644 --- a/lib/puppet/parser/functions/is_valid_mac_address.rb +++ b/lib/puppet/parser/functions/is_valid_mac_address.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:is_valid_mac_address, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid mac address. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/join.rb b/lib/puppet/parser/functions/join.rb index 945556a..005a46e 100644 --- a/lib/puppet/parser/functions/join.rb +++ b/lib/puppet/parser/functions/join.rb @@ -4,6 +4,13 @@ module Puppet::Parser::Functions newfunction(:join, :type => :rvalue, :doc => <<-EOS +This function joins an array into a string using a seperator. + +*Examples:* + + join(['a','b','c'], ",") + +Would result in: "a,b,c" EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/keys.rb b/lib/puppet/parser/functions/keys.rb index 3a92a47..f0d13b6 100644 --- a/lib/puppet/parser/functions/keys.rb +++ b/lib/puppet/parser/functions/keys.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:keys, :type => :rvalue, :doc => <<-EOS +Returns the keys of a hash as an array. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/load_json.rb b/lib/puppet/parser/functions/load_json.rb index 7c3f187..333cf11 100644 --- a/lib/puppet/parser/functions/load_json.rb +++ b/lib/puppet/parser/functions/load_json.rb @@ -4,6 +4,8 @@ module Puppet::Parser::Functions newfunction(:load_json, :type => :rvalue, :doc => <<-EOS +This function accepts JSON as a string and converts into the correct Puppet +structure. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/load_yaml.rb b/lib/puppet/parser/functions/load_yaml.rb index 1bc2f36..2683277 100644 --- a/lib/puppet/parser/functions/load_yaml.rb +++ b/lib/puppet/parser/functions/load_yaml.rb @@ -4,6 +4,8 @@ module Puppet::Parser::Functions newfunction(:load_yaml, :type => :rvalue, :doc => <<-EOS +This function accepts YAML as a string and converts it into the correct +Puppet structure. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/lstrip.rb b/lib/puppet/parser/functions/lstrip.rb index a7b2656..3a64de3 100644 --- a/lib/puppet/parser/functions/lstrip.rb +++ b/lib/puppet/parser/functions/lstrip.rb @@ -4,6 +4,7 @@ module Puppet::Parser::Functions newfunction(:lstrip, :type => :rvalue, :doc => <<-EOS +Strips leading spaces to the left of a string. EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/member.rb b/lib/puppet/parser/functions/member.rb index bb43a37..43d76af 100644 --- a/lib/puppet/parser/functions/member.rb +++ b/lib/puppet/parser/functions/member.rb @@ -7,6 +7,17 @@ module Puppet::Parser::Functions newfunction(:member, :type => :rvalue, :doc => <<-EOS +This function determines if a variable is a member of an array. + +*Examples:* + + member(['a','b'], 'b') + +Would return: true + + member(['a','b'], 'c') + +Would return: false EOS ) do |arguments| diff --git a/lib/puppet/parser/functions/type.rb b/lib/puppet/parser/functions/type.rb index de6087e..8d85f11 100644 --- a/lib/puppet/parser/functions/type.rb +++ b/lib/puppet/parser/functions/type.rb @@ -11,6 +11,7 @@ Returns the type when passed a variable. Type can be one of: * hash * float * integer +* boolean EOS ) do |arguments| @@ -21,7 +22,7 @@ Returns the type when passed a variable. Type can be one of: klass = value.class - if not [Array, Bignum, Fixnum, Float, Hash, String].include?(klass) + if not [TrueClass, FalseClass, Array, Bignum, Fixnum, Float, Hash, String].include?(klass) raise(Puppet::ParseError, 'type(): Unknown type') end @@ -30,6 +31,7 @@ Returns the type when passed a variable. Type can be one of: # We note that Integer is the parent to Bignum and Fixnum ... result = case klass when /^(?:Big|Fix)num$/ then 'integer' + when /^(?:True|False)Class$/ then 'boolean' else klass end diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb index 53071f3..e3c28ed 100644 --- a/spec/unit/parser/functions/type_spec.rb +++ b/spec/unit/parser/functions/type_spec.rb @@ -43,4 +43,9 @@ describe "the type function" do result.should(eq('float')) end + it "should return boolean when given a boolean" do + result = @scope.function_type([true]) + result.should(eq('boolean')) + end + end -- cgit v1.2.3 From 35fefe186546427963d8c8a446fa98875d65ccad Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Sat, 30 Jul 2011 00:44:02 +0100 Subject: Fix some ruby 1.9.2 issues. --- lib/puppet/parser/functions/sort.rb | 2 +- lib/puppet/parser/functions/values_at.rb | 2 +- spec/unit/parser/functions/shuffle_spec.rb | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/sort.rb b/lib/puppet/parser/functions/sort.rb index 3785496..cefbe54 100644 --- a/lib/puppet/parser/functions/sort.rb +++ b/lib/puppet/parser/functions/sort.rb @@ -18,7 +18,7 @@ Sorts strings and arrays lexically. if value.is_a?(Array) then value.sort elsif value.is_a?(String) then - value.split("").sort.to_s + value.split("").sort.join("") end end diff --git a/lib/puppet/parser/functions/values_at.rb b/lib/puppet/parser/functions/values_at.rb index 7f1de8e..d3e69d9 100644 --- a/lib/puppet/parser/functions/values_at.rb +++ b/lib/puppet/parser/functions/values_at.rb @@ -38,7 +38,7 @@ Would return ['a','c','d']. raise(Puppet::ParseError, 'values_at(): Requires array to work with') end - indices = *arguments # Get them all ... Pokemon ... + indices = [arguments.shift].flatten() # Get them all ... Pokemon ... if not indices or indices.empty? raise(Puppet::ParseError, 'values_at(): You must provide ' + diff --git a/spec/unit/parser/functions/shuffle_spec.rb b/spec/unit/parser/functions/shuffle_spec.rb index 936c2fd..f04fda5 100644 --- a/spec/unit/parser/functions/shuffle_spec.rb +++ b/spec/unit/parser/functions/shuffle_spec.rb @@ -25,7 +25,7 @@ describe "the shuffle function" do it "should shuffle a string but the sorted contents should still be the same" do result = @scope.function_shuffle(["adfs"]) - result.split("").sort.to_s.should(eq("adfs")) + result.split("").sort.join("").should(eq("adfs")) end end -- cgit v1.2.3 From 681a1c7971d78c53dc9a0747ae4d983ff6b0d670 Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 5 Aug 2011 08:25:03 +0100 Subject: Prep for stdlib merge * Renamed load_yaml & load_json to parseyaml & parsejson * Renamed is_valid_* functions and remove the 'valid_' --- lib/puppet/parser/functions/is_domain_name.rb | 27 +++++++++++ lib/puppet/parser/functions/is_ip_address.rb | 32 +++++++++++++ lib/puppet/parser/functions/is_mac_address.rb | 27 +++++++++++ .../parser/functions/is_valid_domain_name.rb | 27 ----------- lib/puppet/parser/functions/is_valid_ip_address.rb | 32 ------------- .../parser/functions/is_valid_mac_address.rb | 27 ----------- lib/puppet/parser/functions/load_json.rb | 26 ---------- lib/puppet/parser/functions/load_yaml.rb | 24 ---------- lib/puppet/parser/functions/parsejson.rb | 26 ++++++++++ lib/puppet/parser/functions/parseyaml.rb | 24 ++++++++++ spec/unit/parser/functions/is_domain_name_spec.rb | 56 ++++++++++++++++++++++ spec/unit/parser/functions/is_ip_address_spec.rb | 45 +++++++++++++++++ spec/unit/parser/functions/is_mac_address_spec.rb | 36 ++++++++++++++ .../parser/functions/is_valid_domain_name_spec.rb | 56 ---------------------- .../parser/functions/is_valid_ip_address_spec.rb | 45 ----------------- .../parser/functions/is_valid_mac_address_spec.rb | 36 -------------- spec/unit/parser/functions/load_json_spec.rb | 29 ----------- spec/unit/parser/functions/load_yaml_spec.rb | 31 ------------ spec/unit/parser/functions/parsejson_spec.rb | 29 +++++++++++ spec/unit/parser/functions/parseyaml_spec.rb | 31 ++++++++++++ 20 files changed, 333 insertions(+), 333 deletions(-) create mode 100644 lib/puppet/parser/functions/is_domain_name.rb create mode 100644 lib/puppet/parser/functions/is_ip_address.rb create mode 100644 lib/puppet/parser/functions/is_mac_address.rb delete mode 100644 lib/puppet/parser/functions/is_valid_domain_name.rb delete mode 100644 lib/puppet/parser/functions/is_valid_ip_address.rb delete mode 100644 lib/puppet/parser/functions/is_valid_mac_address.rb delete mode 100644 lib/puppet/parser/functions/load_json.rb delete mode 100644 lib/puppet/parser/functions/load_yaml.rb create mode 100644 lib/puppet/parser/functions/parsejson.rb create mode 100644 lib/puppet/parser/functions/parseyaml.rb create mode 100644 spec/unit/parser/functions/is_domain_name_spec.rb create mode 100644 spec/unit/parser/functions/is_ip_address_spec.rb create mode 100644 spec/unit/parser/functions/is_mac_address_spec.rb delete mode 100644 spec/unit/parser/functions/is_valid_domain_name_spec.rb delete mode 100644 spec/unit/parser/functions/is_valid_ip_address_spec.rb delete mode 100644 spec/unit/parser/functions/is_valid_mac_address_spec.rb delete mode 100644 spec/unit/parser/functions/load_json_spec.rb delete mode 100644 spec/unit/parser/functions/load_yaml_spec.rb create mode 100644 spec/unit/parser/functions/parsejson_spec.rb create mode 100644 spec/unit/parser/functions/parseyaml_spec.rb (limited to 'spec/unit') diff --git a/lib/puppet/parser/functions/is_domain_name.rb b/lib/puppet/parser/functions/is_domain_name.rb new file mode 100644 index 0000000..4e92939 --- /dev/null +++ b/lib/puppet/parser/functions/is_domain_name.rb @@ -0,0 +1,27 @@ +# +# is_domain_name.rb +# + +module Puppet::Parser::Functions + newfunction(:is_domain_name, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid IP address. Support for IPv4 and IPv6 address types is included. + EOS + ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_domain_name(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + domain = arguments[0] + + if domain =~ /^(([a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])\.?$/ then + return true + else + return false + end + + end +end + +# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/is_ip_address.rb b/lib/puppet/parser/functions/is_ip_address.rb new file mode 100644 index 0000000..b4a9a15 --- /dev/null +++ b/lib/puppet/parser/functions/is_ip_address.rb @@ -0,0 +1,32 @@ +# +# is_ip_address.rb +# + +module Puppet::Parser::Functions + newfunction(:is_ip_address, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid IP address. + EOS + ) do |arguments| + + require 'ipaddr' + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_ip_address(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + begin + ip = IPAddr.new(arguments[0]) + rescue ArgumentError + return false + end + + if ip.ipv4? or ip.ipv6? then + return true + else + return false + end + end +end + +# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/is_mac_address.rb b/lib/puppet/parser/functions/is_mac_address.rb new file mode 100644 index 0000000..1b3088a --- /dev/null +++ b/lib/puppet/parser/functions/is_mac_address.rb @@ -0,0 +1,27 @@ +# +# is_mac_address.rb +# + +module Puppet::Parser::Functions + newfunction(:is_mac_address, :type => :rvalue, :doc => <<-EOS +Returns true if the string passed to this function is a valid mac address. + EOS + ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_mac_address(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + mac = arguments[0] + + if /^[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}$/.match(mac) then + return true + else + return false + end + + end +end + +# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/is_valid_domain_name.rb b/lib/puppet/parser/functions/is_valid_domain_name.rb deleted file mode 100644 index 7dd9c0b..0000000 --- a/lib/puppet/parser/functions/is_valid_domain_name.rb +++ /dev/null @@ -1,27 +0,0 @@ -# -# is_valid_domain_name.rb -# - -module Puppet::Parser::Functions - newfunction(:is_valid_domain_name, :type => :rvalue, :doc => <<-EOS -Returns true if the string passed to this function is a valid IP address. Support for IPv4 and IPv6 address types is included. - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "is_valid_domain_name(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - domain = arguments[0] - - if domain =~ /^(([a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])\.?$/ then - return true - else - return false - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/is_valid_ip_address.rb b/lib/puppet/parser/functions/is_valid_ip_address.rb deleted file mode 100644 index 604d938..0000000 --- a/lib/puppet/parser/functions/is_valid_ip_address.rb +++ /dev/null @@ -1,32 +0,0 @@ -# -# is_valid_ip_address.rb -# - -module Puppet::Parser::Functions - newfunction(:is_valid_ip_address, :type => :rvalue, :doc => <<-EOS -Returns true if the string passed to this function is a valid IP address. - EOS - ) do |arguments| - - require 'ipaddr' - - if (arguments.size != 1) then - raise(Puppet::ParseError, "is_valid_ip_address(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - begin - ip = IPAddr.new(arguments[0]) - rescue ArgumentError - return false - end - - if ip.ipv4? or ip.ipv6? then - return true - else - return false - end - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/is_valid_mac_address.rb b/lib/puppet/parser/functions/is_valid_mac_address.rb deleted file mode 100644 index 53199b6..0000000 --- a/lib/puppet/parser/functions/is_valid_mac_address.rb +++ /dev/null @@ -1,27 +0,0 @@ -# -# is_valid_mac_address.rb -# - -module Puppet::Parser::Functions - newfunction(:is_valid_mac_address, :type => :rvalue, :doc => <<-EOS -Returns true if the string passed to this function is a valid mac address. - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "is_valid_mac_address(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - mac = arguments[0] - - if /^[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}$/.match(mac) then - return true - else - return false - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/load_json.rb b/lib/puppet/parser/functions/load_json.rb deleted file mode 100644 index 333cf11..0000000 --- a/lib/puppet/parser/functions/load_json.rb +++ /dev/null @@ -1,26 +0,0 @@ -# -# load_json.rb -# - -module Puppet::Parser::Functions - newfunction(:load_json, :type => :rvalue, :doc => <<-EOS -This function accepts JSON as a string and converts into the correct Puppet -structure. - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "load_json(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - json = arguments[0] - - require 'json' - - JSON.load(json) - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/load_yaml.rb b/lib/puppet/parser/functions/load_yaml.rb deleted file mode 100644 index 2683277..0000000 --- a/lib/puppet/parser/functions/load_yaml.rb +++ /dev/null @@ -1,24 +0,0 @@ -# -# load_yaml.rb -# - -module Puppet::Parser::Functions - newfunction(:load_yaml, :type => :rvalue, :doc => <<-EOS -This function accepts YAML as a string and converts it into the correct -Puppet structure. - EOS - ) do |arguments| - - if (arguments.size != 1) then - raise(Puppet::ParseError, "load_yaml(): Wrong number of arguments "+ - "given #{arguments.size} for 1") - end - - require 'yaml' - - YAML::load(arguments[0]) - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/parsejson.rb b/lib/puppet/parser/functions/parsejson.rb new file mode 100644 index 0000000..cf3b12c --- /dev/null +++ b/lib/puppet/parser/functions/parsejson.rb @@ -0,0 +1,26 @@ +# +# parsejson.rb +# + +module Puppet::Parser::Functions + newfunction(:parsejson, :type => :rvalue, :doc => <<-EOS +This function accepts JSON as a string and converts into the correct Puppet +structure. + EOS + ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "parsejson(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + json = arguments[0] + + require 'json' + + JSON.load(json) + + end +end + +# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/parseyaml.rb b/lib/puppet/parser/functions/parseyaml.rb new file mode 100644 index 0000000..e8ac8a4 --- /dev/null +++ b/lib/puppet/parser/functions/parseyaml.rb @@ -0,0 +1,24 @@ +# +# parseyaml.rb +# + +module Puppet::Parser::Functions + newfunction(:parseyaml, :type => :rvalue, :doc => <<-EOS +This function accepts YAML as a string and converts it into the correct +Puppet structure. + EOS + ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "parseyaml(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + require 'yaml' + + YAML::load(arguments[0]) + + end +end + +# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/is_domain_name_spec.rb b/spec/unit/parser/functions/is_domain_name_spec.rb new file mode 100644 index 0000000..ec7c7f5 --- /dev/null +++ b/spec/unit/parser/functions/is_domain_name_spec.rb @@ -0,0 +1,56 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_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_domain_name").should == "function_is_domain_name" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should return true if a valid domain name" do + result = @scope.function_is_domain_name(["foo.bar.com"]) + result.should(be_true) + end + + it "should allow domain parts to start with numbers" do + result = @scope.function_is_domain_name(["3foo.2bar.com"]) + result.should(be_true) + end + + it "should allow domain to end with a dot" do + result = @scope.function_is_domain_name(["3foo.2bar.com."]) + result.should(be_true) + end + + it "should allow a single part domain" do + result = @scope.function_is_domain_name(["orange"]) + result.should(be_true) + end + + it "should return false if domain parts start with hyphens" do + result = @scope.function_is_domain_name(["-3foo.2bar.com"]) + result.should(be_false) + end + + it "should return true if domain contains hyphens" do + result = @scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"]) + result.should(be_true) + end + + it "should return false if domain name contains spaces" do + result = @scope.function_is_domain_name(["not valid"]) + result.should(be_false) + end + +end diff --git a/spec/unit/parser/functions/is_ip_address_spec.rb b/spec/unit/parser/functions/is_ip_address_spec.rb new file mode 100644 index 0000000..98ce828 --- /dev/null +++ b/spec/unit/parser/functions/is_ip_address_spec.rb @@ -0,0 +1,45 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should return true if an IPv4 address" do + 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.should(eq(true)) + end + + it "should return true if a compressed IPv6 address" do + 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.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.should(eq(false)) + end +end diff --git a/spec/unit/parser/functions/is_mac_address_spec.rb b/spec/unit/parser/functions/is_mac_address_spec.rb new file mode 100644 index 0000000..c9b9637 --- /dev/null +++ b/spec/unit/parser/functions/is_mac_address_spec.rb @@ -0,0 +1,36 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should return true if a valid mac address" do + 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.should(eq(false)) + end + + it "should return false if not valid" do + result = @scope.function_is_mac_address(["not valid"]) + result.should(eq(false)) + 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 deleted file mode 100644 index 3339447..0000000 --- a/spec/unit/parser/functions/is_valid_domain_name_spec.rb +++ /dev/null @@ -1,56 +0,0 @@ -#!/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 - - it "should return true if a valid domain name" do - result = @scope.function_is_valid_domain_name(["foo.bar.com"]) - result.should(be_true) - end - - it "should allow domain parts to start with numbers" do - result = @scope.function_is_valid_domain_name(["3foo.2bar.com"]) - result.should(be_true) - end - - it "should allow domain to end with a dot" do - result = @scope.function_is_valid_domain_name(["3foo.2bar.com."]) - result.should(be_true) - end - - it "should allow a single part domain" do - result = @scope.function_is_valid_domain_name(["orange"]) - result.should(be_true) - end - - it "should return false if domain parts start with hyphens" do - result = @scope.function_is_valid_domain_name(["-3foo.2bar.com"]) - result.should(be_false) - end - - it "should return true if domain contains hyphens" do - result = @scope.function_is_valid_domain_name(["3foo-bar.2bar-fuzz.com"]) - result.should(be_true) - end - - it "should return false if domain name contains spaces" do - result = @scope.function_is_valid_domain_name(["not valid"]) - result.should(be_false) - 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 deleted file mode 100644 index 2883aaa..0000000 --- a/spec/unit/parser/functions/is_valid_ip_address_spec.rb +++ /dev/null @@ -1,45 +0,0 @@ -#!/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 - - it "should return true if an IPv4 address" do - result = @scope.function_is_valid_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_valid_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_valid_ip_address(["fe00::1"]) - result.should(eq(true)) - end - - it "should return false if not valid" do - result = @scope.function_is_valid_ip_address(["asdf"]) - result.should(eq(false)) - end - - it "should return false if IP octets out of range" do - result = @scope.function_is_valid_ip_address(["1.1.1.300"]) - result.should(eq(false)) - 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 deleted file mode 100644 index 62e6fee..0000000 --- a/spec/unit/parser/functions/is_valid_mac_address_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return true if a valid mac address" do - result = @scope.function_is_valid_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_valid_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_valid_mac_address(["not valid"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/load_json_spec.rb b/spec/unit/parser/functions/load_json_spec.rb deleted file mode 100644 index 73a4566..0000000 --- a/spec/unit/parser/functions/load_json_spec.rb +++ /dev/null @@ -1,29 +0,0 @@ -#!/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_yaml_spec.rb b/spec/unit/parser/functions/load_yaml_spec.rb deleted file mode 100644 index 2498d12..0000000 --- a/spec/unit/parser/functions/load_yaml_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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/parsejson_spec.rb b/spec/unit/parser/functions/parsejson_spec.rb new file mode 100644 index 0000000..26eea36 --- /dev/null +++ b/spec/unit/parser/functions/parsejson_spec.rb @@ -0,0 +1,29 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should convert JSON to a data structure" do + json = <<-EOS +["aaa","bbb","ccc"] +EOS + result = @scope.function_parsejson([json]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end diff --git a/spec/unit/parser/functions/parseyaml_spec.rb b/spec/unit/parser/functions/parseyaml_spec.rb new file mode 100644 index 0000000..f9cb049 --- /dev/null +++ b/spec/unit/parser/functions/parseyaml_spec.rb @@ -0,0 +1,31 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should convert YAML to a data structure" do + yaml = <<-EOS +- aaa +- bbb +- ccc +EOS + result = @scope.function_parseyaml([yaml]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end -- cgit v1.2.3 From 1b73a66fc67af0e33fa41aacf50654d4a7a4903c Mon Sep 17 00:00:00 2001 From: Ken Barber Date: Fri, 5 Aug 2011 08:46:38 +0100 Subject: * Moved kwalify to puppetlabs-kwalify project * Re-arranged tests in line with puppetlabs-stdlib --- README.markdown | 27 +--------- examples/kwalify-1.pp | 9 ---- examples/kwalify-2.pp | 24 --------- examples/validate_resource-1.pp | 23 -------- examples/validate_resource-1.schema | 39 -------------- examples/validate_resource-2.pp | 17 ------ examples/validate_resource-2.schema | 26 --------- lib/puppet/parser/functions/kwalify.rb | 35 ------------ lib/puppet/parser/functions/validate_resource.rb | 41 -------------- spec/unit/parser/functions/abs_spec.rb | 31 ----------- spec/unit/parser/functions/bool2num_spec.rb | 31 ----------- spec/unit/parser/functions/capitalize_spec.rb | 26 --------- spec/unit/parser/functions/chomp_spec.rb | 26 --------- spec/unit/parser/functions/chop_spec.rb | 26 --------- spec/unit/parser/functions/delete_at_spec.rb | 26 --------- spec/unit/parser/functions/delete_spec.rb | 26 --------- spec/unit/parser/functions/downcase_spec.rb | 31 ----------- spec/unit/parser/functions/empty_spec.rb | 31 ----------- spec/unit/parser/functions/flatten_spec.rb | 31 ----------- spec/unit/parser/functions/grep_spec.rb | 26 --------- spec/unit/parser/functions/hash_spec.rb | 26 --------- spec/unit/parser/functions/is_array_spec.rb | 36 ------------- spec/unit/parser/functions/is_domain_name_spec.rb | 56 ------------------- spec/unit/parser/functions/is_float_spec.rb | 36 ------------- spec/unit/parser/functions/is_hash_spec.rb | 36 ------------- spec/unit/parser/functions/is_integer_spec.rb | 36 ------------- spec/unit/parser/functions/is_ip_address_spec.rb | 45 ---------------- spec/unit/parser/functions/is_mac_address_spec.rb | 36 ------------- spec/unit/parser/functions/is_numeric_spec.rb | 36 ------------- spec/unit/parser/functions/is_string_spec.rb | 41 -------------- spec/unit/parser/functions/join_spec.rb | 26 --------- spec/unit/parser/functions/keys_spec.rb | 26 --------- spec/unit/parser/functions/kwalify_spec.rb | 62 ---------------------- spec/unit/parser/functions/lstrip_spec.rb | 26 --------- spec/unit/parser/functions/member_spec.rb | 31 ----------- spec/unit/parser/functions/num2bool_spec.rb | 31 ----------- spec/unit/parser/functions/parsejson_spec.rb | 29 ---------- spec/unit/parser/functions/parseyaml_spec.rb | 31 ----------- spec/unit/parser/functions/prefix_spec.rb | 26 --------- spec/unit/parser/functions/range_spec.rb | 31 ----------- spec/unit/parser/functions/reverse_spec.rb | 26 --------- spec/unit/parser/functions/rstrip_spec.rb | 31 ----------- spec/unit/parser/functions/shuffle_spec.rb | 31 ----------- spec/unit/parser/functions/size_spec.rb | 31 ----------- spec/unit/parser/functions/sort_spec.rb | 31 ----------- spec/unit/parser/functions/squeeze_spec.rb | 31 ----------- spec/unit/parser/functions/str2bool_spec.rb | 31 ----------- spec/unit/parser/functions/strftime_spec.rb | 36 ------------- spec/unit/parser/functions/strip_spec.rb | 26 --------- spec/unit/parser/functions/swapcase_spec.rb | 26 --------- spec/unit/parser/functions/time_spec.rb | 36 ------------- spec/unit/parser/functions/type_spec.rb | 51 ------------------ spec/unit/parser/functions/unique_spec.rb | 31 ----------- spec/unit/parser/functions/upcase_spec.rb | 31 ----------- spec/unit/parser/functions/values_at_spec.rb | 45 ---------------- spec/unit/parser/functions/values_spec.rb | 30 ----------- spec/unit/parser/functions/zip_spec.rb | 26 --------- spec/unit/puppet/parser/functions/abs_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/bool2num_spec.rb | 31 +++++++++++ .../puppet/parser/functions/capitalize_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/chomp_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/chop_spec.rb | 26 +++++++++ .../unit/puppet/parser/functions/delete_at_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/delete_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/downcase_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/empty_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/flatten_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/grep_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/hash_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/is_array_spec.rb | 36 +++++++++++++ .../puppet/parser/functions/is_domain_name_spec.rb | 56 +++++++++++++++++++ spec/unit/puppet/parser/functions/is_float_spec.rb | 36 +++++++++++++ spec/unit/puppet/parser/functions/is_hash_spec.rb | 36 +++++++++++++ .../puppet/parser/functions/is_integer_spec.rb | 36 +++++++++++++ .../puppet/parser/functions/is_ip_address_spec.rb | 45 ++++++++++++++++ .../puppet/parser/functions/is_mac_address_spec.rb | 36 +++++++++++++ .../puppet/parser/functions/is_numeric_spec.rb | 36 +++++++++++++ .../unit/puppet/parser/functions/is_string_spec.rb | 41 ++++++++++++++ spec/unit/puppet/parser/functions/join_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/keys_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/lstrip_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/member_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/num2bool_spec.rb | 31 +++++++++++ .../unit/puppet/parser/functions/parsejson_spec.rb | 29 ++++++++++ .../unit/puppet/parser/functions/parseyaml_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/prefix_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/range_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/reverse_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/rstrip_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/shuffle_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/size_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/sort_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/squeeze_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/str2bool_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/strftime_spec.rb | 36 +++++++++++++ spec/unit/puppet/parser/functions/strip_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/swapcase_spec.rb | 26 +++++++++ spec/unit/puppet/parser/functions/time_spec.rb | 36 +++++++++++++ spec/unit/puppet/parser/functions/type_spec.rb | 51 ++++++++++++++++++ spec/unit/puppet/parser/functions/unique_spec.rb | 31 +++++++++++ spec/unit/puppet/parser/functions/upcase_spec.rb | 31 +++++++++++ .../unit/puppet/parser/functions/values_at_spec.rb | 45 ++++++++++++++++ spec/unit/puppet/parser/functions/values_spec.rb | 30 +++++++++++ spec/unit/puppet/parser/functions/zip_spec.rb | 26 +++++++++ 104 files changed, 1503 insertions(+), 1804 deletions(-) delete mode 100644 examples/kwalify-1.pp delete mode 100644 examples/kwalify-2.pp delete mode 100644 examples/validate_resource-1.pp delete mode 100644 examples/validate_resource-1.schema delete mode 100644 examples/validate_resource-2.pp delete mode 100644 examples/validate_resource-2.schema delete mode 100644 lib/puppet/parser/functions/kwalify.rb delete mode 100644 lib/puppet/parser/functions/validate_resource.rb delete mode 100755 spec/unit/parser/functions/abs_spec.rb delete mode 100755 spec/unit/parser/functions/bool2num_spec.rb delete mode 100755 spec/unit/parser/functions/capitalize_spec.rb delete mode 100755 spec/unit/parser/functions/chomp_spec.rb delete mode 100755 spec/unit/parser/functions/chop_spec.rb delete mode 100755 spec/unit/parser/functions/delete_at_spec.rb delete mode 100755 spec/unit/parser/functions/delete_spec.rb delete mode 100755 spec/unit/parser/functions/downcase_spec.rb delete mode 100755 spec/unit/parser/functions/empty_spec.rb delete mode 100755 spec/unit/parser/functions/flatten_spec.rb delete mode 100755 spec/unit/parser/functions/grep_spec.rb delete mode 100644 spec/unit/parser/functions/hash_spec.rb delete mode 100644 spec/unit/parser/functions/is_array_spec.rb delete mode 100644 spec/unit/parser/functions/is_domain_name_spec.rb delete mode 100644 spec/unit/parser/functions/is_float_spec.rb delete mode 100644 spec/unit/parser/functions/is_hash_spec.rb delete mode 100644 spec/unit/parser/functions/is_integer_spec.rb delete mode 100644 spec/unit/parser/functions/is_ip_address_spec.rb delete mode 100644 spec/unit/parser/functions/is_mac_address_spec.rb delete mode 100644 spec/unit/parser/functions/is_numeric_spec.rb delete mode 100644 spec/unit/parser/functions/is_string_spec.rb delete mode 100644 spec/unit/parser/functions/join_spec.rb delete mode 100644 spec/unit/parser/functions/keys_spec.rb delete mode 100755 spec/unit/parser/functions/kwalify_spec.rb delete mode 100644 spec/unit/parser/functions/lstrip_spec.rb delete mode 100644 spec/unit/parser/functions/member_spec.rb delete mode 100644 spec/unit/parser/functions/num2bool_spec.rb delete mode 100644 spec/unit/parser/functions/parsejson_spec.rb delete mode 100644 spec/unit/parser/functions/parseyaml_spec.rb delete mode 100644 spec/unit/parser/functions/prefix_spec.rb delete mode 100644 spec/unit/parser/functions/range_spec.rb delete mode 100644 spec/unit/parser/functions/reverse_spec.rb delete mode 100644 spec/unit/parser/functions/rstrip_spec.rb delete mode 100644 spec/unit/parser/functions/shuffle_spec.rb delete mode 100644 spec/unit/parser/functions/size_spec.rb delete mode 100644 spec/unit/parser/functions/sort_spec.rb delete mode 100644 spec/unit/parser/functions/squeeze_spec.rb delete mode 100644 spec/unit/parser/functions/str2bool_spec.rb delete mode 100644 spec/unit/parser/functions/strftime_spec.rb delete mode 100644 spec/unit/parser/functions/strip_spec.rb delete mode 100644 spec/unit/parser/functions/swapcase_spec.rb delete mode 100644 spec/unit/parser/functions/time_spec.rb delete mode 100644 spec/unit/parser/functions/type_spec.rb delete mode 100644 spec/unit/parser/functions/unique_spec.rb delete mode 100644 spec/unit/parser/functions/upcase_spec.rb delete mode 100644 spec/unit/parser/functions/values_at_spec.rb delete mode 100644 spec/unit/parser/functions/values_spec.rb delete mode 100644 spec/unit/parser/functions/zip_spec.rb create mode 100755 spec/unit/puppet/parser/functions/abs_spec.rb create mode 100755 spec/unit/puppet/parser/functions/bool2num_spec.rb create mode 100755 spec/unit/puppet/parser/functions/capitalize_spec.rb create mode 100755 spec/unit/puppet/parser/functions/chomp_spec.rb create mode 100755 spec/unit/puppet/parser/functions/chop_spec.rb create mode 100755 spec/unit/puppet/parser/functions/delete_at_spec.rb create mode 100755 spec/unit/puppet/parser/functions/delete_spec.rb create mode 100755 spec/unit/puppet/parser/functions/downcase_spec.rb create mode 100755 spec/unit/puppet/parser/functions/empty_spec.rb create mode 100755 spec/unit/puppet/parser/functions/flatten_spec.rb create mode 100755 spec/unit/puppet/parser/functions/grep_spec.rb create mode 100644 spec/unit/puppet/parser/functions/hash_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_array_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_domain_name_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_float_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_hash_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_integer_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_ip_address_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_mac_address_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_numeric_spec.rb create mode 100644 spec/unit/puppet/parser/functions/is_string_spec.rb create mode 100644 spec/unit/puppet/parser/functions/join_spec.rb create mode 100644 spec/unit/puppet/parser/functions/keys_spec.rb create mode 100644 spec/unit/puppet/parser/functions/lstrip_spec.rb create mode 100644 spec/unit/puppet/parser/functions/member_spec.rb create mode 100644 spec/unit/puppet/parser/functions/num2bool_spec.rb create mode 100644 spec/unit/puppet/parser/functions/parsejson_spec.rb create mode 100644 spec/unit/puppet/parser/functions/parseyaml_spec.rb create mode 100644 spec/unit/puppet/parser/functions/prefix_spec.rb create mode 100644 spec/unit/puppet/parser/functions/range_spec.rb create mode 100644 spec/unit/puppet/parser/functions/reverse_spec.rb create mode 100644 spec/unit/puppet/parser/functions/rstrip_spec.rb create mode 100644 spec/unit/puppet/parser/functions/shuffle_spec.rb create mode 100644 spec/unit/puppet/parser/functions/size_spec.rb create mode 100644 spec/unit/puppet/parser/functions/sort_spec.rb create mode 100644 spec/unit/puppet/parser/functions/squeeze_spec.rb create mode 100644 spec/unit/puppet/parser/functions/str2bool_spec.rb create mode 100644 spec/unit/puppet/parser/functions/strftime_spec.rb create mode 100644 spec/unit/puppet/parser/functions/strip_spec.rb create mode 100644 spec/unit/puppet/parser/functions/swapcase_spec.rb create mode 100644 spec/unit/puppet/parser/functions/time_spec.rb create mode 100644 spec/unit/puppet/parser/functions/type_spec.rb create mode 100644 spec/unit/puppet/parser/functions/unique_spec.rb create mode 100644 spec/unit/puppet/parser/functions/upcase_spec.rb create mode 100644 spec/unit/puppet/parser/functions/values_at_spec.rb create mode 100644 spec/unit/puppet/parser/functions/values_spec.rb create mode 100644 spec/unit/puppet/parser/functions/zip_spec.rb (limited to 'spec/unit') diff --git a/README.markdown b/README.markdown index 68e559e..a15338f 100644 --- a/README.markdown +++ b/README.markdown @@ -20,29 +20,4 @@ Depending on the version of Puppet, you may need to restart the puppetmasterd (o ## Functions -### kwalify - -This function allows you to validate Puppet data structures using Kwalify -schemas as documented here: - -http://www.kuwata-lab.com/kwalify/ruby/users-guide.01.html - -To validate, create a schema in Puppet: - - $schema = { - 'type' => 'seq', - 'sequence' => [ - { 'type' => 'str' } - ] - } - -And create some content that you want validated: - - $document = ['a', 'b', 'c'] - -And then use the function to validate: - - kwalify($schema, $document) - -The function will throw an error and list all validation errors if there is a -problem otherwise it succeeds silently. +TODO diff --git a/examples/kwalify-1.pp b/examples/kwalify-1.pp deleted file mode 100644 index 852e46c..0000000 --- a/examples/kwalify-1.pp +++ /dev/null @@ -1,9 +0,0 @@ -$schema = { - 'type' => 'seq', - 'sequence' => [ - { 'type' => 'str', 'enum' => ['asdf','fdsa'] } - ] -} -$document = ['a', 'b', 'c'] - -kwalify($schema, $document) diff --git a/examples/kwalify-2.pp b/examples/kwalify-2.pp deleted file mode 100644 index 3f4ec33..0000000 --- a/examples/kwalify-2.pp +++ /dev/null @@ -1,24 +0,0 @@ -$schema = { - 'type' => 'map', - 'mapping' => { - 'name' => { - 'type' => 'str', - 'required' => true, - }, - 'email' => { - 'type' => 'str', - 'pattern' => '/@/', - }, - 'age' => { - 'type' => 'str', - 'pattern' => '/^\d+$/', - }, - } -} -$document = { - 'name' => 'foo', - 'email' => 'foo@mail.com', - 'age' => 20, -} - -kwalify($schema, $document) diff --git a/examples/validate_resource-1.pp b/examples/validate_resource-1.pp deleted file mode 100644 index c701b8d..0000000 --- a/examples/validate_resource-1.pp +++ /dev/null @@ -1,23 +0,0 @@ -define fooresource( - $color, - $type, - $somenumber, - $map - ) { - - validate_resource() - - # ... do something ... - -} - -fooresource { "example1": - color => "blue", - type => "circle", - somenumber => 5, - map => { - a => 1, - b => 2, - c => 3, - } -} diff --git a/examples/validate_resource-1.schema b/examples/validate_resource-1.schema deleted file mode 100644 index c540db5..0000000 --- a/examples/validate_resource-1.schema +++ /dev/null @@ -1,39 +0,0 @@ -type: map -mapping: - "title": - type: str - required: yes - "name": - type: str - required: yes - "caller_module_name": - type: str - required: yes - "module_name": - type: str - required: yes - "color": - type: str - required: yes - "type": - type: str - required: yes - "somenumber": - type: str - required: yes - pattern: /^\d+$/ - "map": - type: map - mapping: - "a": - type: str - required: yes - pattern: /^\d+$/ - "b": - type: str - required: yes - pattern: /^\d+$/ - "c": - type: str - required: yes - pattern: /^\d+$/ diff --git a/examples/validate_resource-2.pp b/examples/validate_resource-2.pp deleted file mode 100644 index b53b109..0000000 --- a/examples/validate_resource-2.pp +++ /dev/null @@ -1,17 +0,0 @@ -class foo ( - $a, - $b, - $c - ) { - - validate_resource() - - # ... do something ... - -} - -class { "foo": - a => "1", - b => "foobaz", - c => ['a','b','c'] -} diff --git a/examples/validate_resource-2.schema b/examples/validate_resource-2.schema deleted file mode 100644 index b516945..0000000 --- a/examples/validate_resource-2.schema +++ /dev/null @@ -1,26 +0,0 @@ -type: map -mapping: - "title": - type: str - required: yes - "name": - type: str - required: yes - "caller_module_name": - type: str - required: yes - "module_name": - type: str - required: yes - "a": - type: str - required: yes - "b": - type: str - required: yes - pattern: /^foo/ - "c": - type: seq - required: yes - sequence: - - type: str diff --git a/lib/puppet/parser/functions/kwalify.rb b/lib/puppet/parser/functions/kwalify.rb deleted file mode 100644 index 49b9aeb..0000000 --- a/lib/puppet/parser/functions/kwalify.rb +++ /dev/null @@ -1,35 +0,0 @@ -# -# kwalify.rb -# - -module Puppet::Parser::Functions - newfunction(:kwalify, :type => :statement, :doc => <<-EOS -This function uses kwalify to validate Puppet data structures against Kwalify -schemas. - EOS - ) do |args| - - raise(Puppet::ParseError, "kwalify(): Wrong number of arguments " + - "given (#{args.size} for 2)") if args.size != 2 - - schema = args[0] - document = args[1] - - require 'kwalify' - - validator = Kwalify::Validator.new(schema) - - errors = validator.validate(document) - - if errors && !errors.empty? - error_out = [] - for e in errors - error_out << "[#{e.path}] #{e.message}" - end - raise(Puppet::ParseError, "Failed kwalify schema validation:\n" + error_out.join("\n")) - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/lib/puppet/parser/functions/validate_resource.rb b/lib/puppet/parser/functions/validate_resource.rb deleted file mode 100644 index d71ef3f..0000000 --- a/lib/puppet/parser/functions/validate_resource.rb +++ /dev/null @@ -1,41 +0,0 @@ -# -# validate_resource -# - -module Puppet::Parser::Functions - newfunction(:validate_resource, :type => :statement, :doc => <<-EOS -This function when placed at the beginning of a class, will go looking for a -valid kwalify schema by replacing the extension of the file with '.schema'. - -It will then validate the arguments passed to the function using that kwalify -schema. - EOS - ) do |arguments| - - require 'kwalify' - - if (arguments.size != 0) then - raise(Puppet::ParseError, "validate_resource(): Wrong number of arguments "+ - "given #{arguments.size} for 0") - end - - - classhash = to_hash(recursive=false) - sourcepath = source.file - schemapath = sourcepath.gsub(/\.(rb|pp)$/, ".schema") - schema = Kwalify::Yaml.load_file(schemapath) - validator = Kwalify::Validator.new(schema) - errors = validator.validate(classhash) - - if errors && !errors.empty? - error_output = "Resource validation failed:\n" - for e in errors - error_output += "[#{e.path}] #{e.message}\n" - end - raise(Puppet::ParseError, error_output) - end - - end -end - -# vim: set ts=2 sw=2 et : diff --git a/spec/unit/parser/functions/abs_spec.rb b/spec/unit/parser/functions/abs_spec.rb deleted file mode 100755 index 65ba2e8..0000000 --- a/spec/unit/parser/functions/abs_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should convert a negative number into a positive" do - 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.should(eq(5678)) - end - -end diff --git a/spec/unit/parser/functions/bool2num_spec.rb b/spec/unit/parser/functions/bool2num_spec.rb deleted file mode 100755 index d5da18c..0000000 --- a/spec/unit/parser/functions/bool2num_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should convert true to 1" do - result = @scope.function_bool2num([true]) - result.should(eq(1)) - end - - it "should convert false to 0" do - result = @scope.function_bool2num([false]) - result.should(eq(0)) - end - -end diff --git a/spec/unit/parser/functions/capitalize_spec.rb b/spec/unit/parser/functions/capitalize_spec.rb deleted file mode 100755 index 1c45821..0000000 --- a/spec/unit/parser/functions/capitalize_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should capitalize the beginning of a string" do - result = @scope.function_capitalize(["abc"]) - result.should(eq("Abc")) - end - -end diff --git a/spec/unit/parser/functions/chomp_spec.rb b/spec/unit/parser/functions/chomp_spec.rb deleted file mode 100755 index 0592115..0000000 --- a/spec/unit/parser/functions/chomp_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should chomp the end of a string" do - result = @scope.function_chomp(["abc\n"]) - result.should(eq("abc")) - end - -end diff --git a/spec/unit/parser/functions/chop_spec.rb b/spec/unit/parser/functions/chop_spec.rb deleted file mode 100755 index 0c456a8..0000000 --- a/spec/unit/parser/functions/chop_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should chop the end of a string" do - result = @scope.function_chop(["asdf\n"]) - result.should(eq("asdf")) - end - -end diff --git a/spec/unit/parser/functions/delete_at_spec.rb b/spec/unit/parser/functions/delete_at_spec.rb deleted file mode 100755 index 27db0c8..0000000 --- a/spec/unit/parser/functions/delete_at_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should delete an item at specified location from an array" do - result = @scope.function_delete_at([['a','b','c'],1]) - result.should(eq(['a','c'])) - end - -end diff --git a/spec/unit/parser/functions/delete_spec.rb b/spec/unit/parser/functions/delete_spec.rb deleted file mode 100755 index fab3230..0000000 --- a/spec/unit/parser/functions/delete_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should delete an item from an array" do - result = @scope.function_delete([['a','b','c'],'b']) - result.should(eq(['a','c'])) - end - -end diff --git a/spec/unit/parser/functions/downcase_spec.rb b/spec/unit/parser/functions/downcase_spec.rb deleted file mode 100755 index 0bccd5f..0000000 --- a/spec/unit/parser/functions/downcase_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should downcase a string" do - 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.should(eq("asdf asdf")) - end - -end diff --git a/spec/unit/parser/functions/empty_spec.rb b/spec/unit/parser/functions/empty_spec.rb deleted file mode 100755 index cb0021f..0000000 --- a/spec/unit/parser/functions/empty_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should return a true for an empty string" do - 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.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/flatten_spec.rb b/spec/unit/parser/functions/flatten_spec.rb deleted file mode 100755 index 7bedeb2..0000000 --- a/spec/unit/parser/functions/flatten_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should flatten a complex data structure" do - 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.should(eq(["a","b","c","d"])) - end - -end diff --git a/spec/unit/parser/functions/grep_spec.rb b/spec/unit/parser/functions/grep_spec.rb deleted file mode 100755 index b1f647c..0000000 --- a/spec/unit/parser/functions/grep_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should grep contents from an array" do - result = @scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"]) - result.should(eq(["aaabbb","bbbccc"])) - end - -end diff --git a/spec/unit/parser/functions/hash_spec.rb b/spec/unit/parser/functions/hash_spec.rb deleted file mode 100644 index 6d3d48c..0000000 --- a/spec/unit/parser/functions/hash_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should convert an array to a hash" do - result = @scope.function_hash([['a',1,'b',2,'c',3]]) - result.should(eq({'a'=>1,'b'=>2,'c'=>3})) - end - -end diff --git a/spec/unit/parser/functions/is_array_spec.rb b/spec/unit/parser/functions/is_array_spec.rb deleted file mode 100644 index 537595c..0000000 --- a/spec/unit/parser/functions/is_array_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return true if passed an array" do - 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.should(eq(false)) - end - - it "should return false if passed a string" do - result = @scope.function_is_array(["asdf"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_domain_name_spec.rb b/spec/unit/parser/functions/is_domain_name_spec.rb deleted file mode 100644 index ec7c7f5..0000000 --- a/spec/unit/parser/functions/is_domain_name_spec.rb +++ /dev/null @@ -1,56 +0,0 @@ -#!/usr/bin/env rspec -require 'spec_helper' - -describe "the is_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_domain_name").should == "function_is_domain_name" - end - - it "should raise a ParseError if there is less than 1 arguments" do - lambda { @scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError)) - end - - it "should return true if a valid domain name" do - result = @scope.function_is_domain_name(["foo.bar.com"]) - result.should(be_true) - end - - it "should allow domain parts to start with numbers" do - result = @scope.function_is_domain_name(["3foo.2bar.com"]) - result.should(be_true) - end - - it "should allow domain to end with a dot" do - result = @scope.function_is_domain_name(["3foo.2bar.com."]) - result.should(be_true) - end - - it "should allow a single part domain" do - result = @scope.function_is_domain_name(["orange"]) - result.should(be_true) - end - - it "should return false if domain parts start with hyphens" do - result = @scope.function_is_domain_name(["-3foo.2bar.com"]) - result.should(be_false) - end - - it "should return true if domain contains hyphens" do - result = @scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"]) - result.should(be_true) - end - - it "should return false if domain name contains spaces" do - result = @scope.function_is_domain_name(["not valid"]) - result.should(be_false) - end - -end diff --git a/spec/unit/parser/functions/is_float_spec.rb b/spec/unit/parser/functions/is_float_spec.rb deleted file mode 100644 index 55ba8cf..0000000 --- a/spec/unit/parser/functions/is_float_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return true if a float" do - 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.should(eq(false)) - end - - it "should return false if an integer" do - result = @scope.function_is_float(["3"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_hash_spec.rb b/spec/unit/parser/functions/is_hash_spec.rb deleted file mode 100644 index 94364f5..0000000 --- a/spec/unit/parser/functions/is_hash_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return true if passed a hash" do - 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.should(eq(false)) - end - - it "should return false if passed a string" do - result = @scope.function_is_hash(["asdf"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_integer_spec.rb b/spec/unit/parser/functions/is_integer_spec.rb deleted file mode 100644 index faf6f2d..0000000 --- a/spec/unit/parser/functions/is_integer_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return true if an integer" do - 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.should(eq(false)) - end - - it "should return false if a string" do - result = @scope.function_is_integer(["asdf"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_ip_address_spec.rb b/spec/unit/parser/functions/is_ip_address_spec.rb deleted file mode 100644 index 98ce828..0000000 --- a/spec/unit/parser/functions/is_ip_address_spec.rb +++ /dev/null @@ -1,45 +0,0 @@ -#!/usr/bin/env rspec -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 - - 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)) - end - - it "should return true if an IPv4 address" do - 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.should(eq(true)) - end - - it "should return true if a compressed IPv6 address" do - 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.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.should(eq(false)) - end -end diff --git a/spec/unit/parser/functions/is_mac_address_spec.rb b/spec/unit/parser/functions/is_mac_address_spec.rb deleted file mode 100644 index c9b9637..0000000 --- a/spec/unit/parser/functions/is_mac_address_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/usr/bin/env rspec -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 - - 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)) - end - - it "should return true if a valid mac address" do - 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.should(eq(false)) - end - - it "should return false if not valid" do - result = @scope.function_is_mac_address(["not valid"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_numeric_spec.rb b/spec/unit/parser/functions/is_numeric_spec.rb deleted file mode 100644 index 2191b7b..0000000 --- a/spec/unit/parser/functions/is_numeric_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 argument" do - 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.should(eq(true)) - end - - it "should return true if a float" do - 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.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/is_string_spec.rb b/spec/unit/parser/functions/is_string_spec.rb deleted file mode 100644 index 4f3f5fd..0000000 --- a/spec/unit/parser/functions/is_string_spec.rb +++ /dev/null @@ -1,41 +0,0 @@ -#!/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 - - it "should return true if a string" do - 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.should(eq(false)) - end - - it "should return false if a float" do - 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.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/join_spec.rb b/spec/unit/parser/functions/join_spec.rb deleted file mode 100644 index 1b3dec8..0000000 --- a/spec/unit/parser/functions/join_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should join an array into a string" do - result = @scope.function_join([["a","b","c"], ":"]) - result.should(eq("a:b:c")) - end - -end diff --git a/spec/unit/parser/functions/keys_spec.rb b/spec/unit/parser/functions/keys_spec.rb deleted file mode 100644 index 927be96..0000000 --- a/spec/unit/parser/functions/keys_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should return an array of keys when given a hash" do - result = @scope.function_keys([{'a'=>1, 'b' => 2}]) - result.should(eq(['a','b'])) - end - -end diff --git a/spec/unit/parser/functions/kwalify_spec.rb b/spec/unit/parser/functions/kwalify_spec.rb deleted file mode 100755 index abdd529..0000000 --- a/spec/unit/parser/functions/kwalify_spec.rb +++ /dev/null @@ -1,62 +0,0 @@ -#!/usr/bin/env rspec -require 'spec_helper' - -describe "the kwalify 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("kwalify").should == "function_kwalify" - end - - it "should raise a ParseError if there is less than 2 arguments" do - lambda { @scope.function_kwalify([]) }.should( raise_error(Puppet::ParseError)) - end - - it "should validate a simple array schema" do - schema = { - 'type' => 'seq', - 'sequence' => [ - { 'type' => 'str' } - ] - } - document = ['a','b','c'] - @scope.function_kwalify([schema, document]) - end - - it "should not validate a simple array schema when invalid" do - schema = { - 'type' => 'seq', - 'sequence' => [ - { 'type' => 'str' } - ] - } - document = ['a','b',{'a' => 'b'}] - lambda { @scope.function_kwalify([schema, document]) }.should(raise_error(Puppet::ParseError)) - end - - it "should validate a hash schema" do - schema = { - 'type' => 'map', - 'mapping' => { - 'key1' => { - 'type' => 'str', - }, - 'key2' => { - 'type' => 'str', - }, - } - } - document = { - 'key1' => 'b', - 'key2' => 'c', - } - @scope.function_kwalify([schema, document]) - end - -end diff --git a/spec/unit/parser/functions/lstrip_spec.rb b/spec/unit/parser/functions/lstrip_spec.rb deleted file mode 100644 index ac331fa..0000000 --- a/spec/unit/parser/functions/lstrip_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should lstrip a string" do - result = @scope.function_lstrip([" asdf"]) - result.should(eq('asdf')) - end - -end diff --git a/spec/unit/parser/functions/member_spec.rb b/spec/unit/parser/functions/member_spec.rb deleted file mode 100644 index 2cebc0d..0000000 --- a/spec/unit/parser/functions/member_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should return true if a member is in an array" do - result = @scope.function_member([["a","b","c"], "a"]) - result.should(eq(true)) - end - - it "should return false if a member is not in an array" do - result = @scope.function_member([["a","b","c"], "d"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/num2bool_spec.rb b/spec/unit/parser/functions/num2bool_spec.rb deleted file mode 100644 index 6585273..0000000 --- a/spec/unit/parser/functions/num2bool_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should return true if 1" do - result = @scope.function_num2bool(["1"]) - result.should(be_true) - end - - it "should return false if 0" do - result = @scope.function_num2bool(["0"]) - result.should(be_false) - end - -end diff --git a/spec/unit/parser/functions/parsejson_spec.rb b/spec/unit/parser/functions/parsejson_spec.rb deleted file mode 100644 index 26eea36..0000000 --- a/spec/unit/parser/functions/parsejson_spec.rb +++ /dev/null @@ -1,29 +0,0 @@ -#!/usr/bin/env rspec -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 - - 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)) - end - - it "should convert JSON to a data structure" do - json = <<-EOS -["aaa","bbb","ccc"] -EOS - result = @scope.function_parsejson([json]) - result.should(eq(['aaa','bbb','ccc'])) - end - -end diff --git a/spec/unit/parser/functions/parseyaml_spec.rb b/spec/unit/parser/functions/parseyaml_spec.rb deleted file mode 100644 index f9cb049..0000000 --- a/spec/unit/parser/functions/parseyaml_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/usr/bin/env rspec -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 - - 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)) - end - - it "should convert YAML to a data structure" do - yaml = <<-EOS -- aaa -- bbb -- ccc -EOS - result = @scope.function_parseyaml([yaml]) - result.should(eq(['aaa','bbb','ccc'])) - end - -end diff --git a/spec/unit/parser/functions/prefix_spec.rb b/spec/unit/parser/functions/prefix_spec.rb deleted file mode 100644 index a0cbcab..0000000 --- a/spec/unit/parser/functions/prefix_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should return a prefixed array" do - result = @scope.function_prefix([['a','b','c'], 'p']) - result.should(eq(['pa','pb','pc'])) - end - -end diff --git a/spec/unit/parser/functions/range_spec.rb b/spec/unit/parser/functions/range_spec.rb deleted file mode 100644 index 8c2446a..0000000 --- a/spec/unit/parser/functions/range_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should return a letter range" do - result = @scope.function_range(["a","d"]) - result.should(eq(['a','b','c','d'])) - end - - it "should return a number range" do - result = @scope.function_range(["1","4"]) - result.should(eq([1,2,3,4])) - end - -end diff --git a/spec/unit/parser/functions/reverse_spec.rb b/spec/unit/parser/functions/reverse_spec.rb deleted file mode 100644 index 4fa50e4..0000000 --- a/spec/unit/parser/functions/reverse_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should reverse a string" do - result = @scope.function_reverse(["asdfghijkl"]) - result.should(eq('lkjihgfdsa')) - end - -end diff --git a/spec/unit/parser/functions/rstrip_spec.rb b/spec/unit/parser/functions/rstrip_spec.rb deleted file mode 100644 index af8cc12..0000000 --- a/spec/unit/parser/functions/rstrip_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should rstrip a string" do - 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.should(eq(['a','b','c'])) - end - -end diff --git a/spec/unit/parser/functions/shuffle_spec.rb b/spec/unit/parser/functions/shuffle_spec.rb deleted file mode 100644 index f04fda5..0000000 --- a/spec/unit/parser/functions/shuffle_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should shuffle a string and the result should be the same size" do - 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.split("").sort.join("").should(eq("adfs")) - end - -end diff --git a/spec/unit/parser/functions/size_spec.rb b/spec/unit/parser/functions/size_spec.rb deleted file mode 100644 index ccaa335..0000000 --- a/spec/unit/parser/functions/size_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should return the size of a string" do - 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.should(eq(3)) - end - -end diff --git a/spec/unit/parser/functions/sort_spec.rb b/spec/unit/parser/functions/sort_spec.rb deleted file mode 100644 index fbe3073..0000000 --- a/spec/unit/parser/functions/sort_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 1 arguments" do - lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError)) - end - - it "should sort an array" do - 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.should(eq('abc')) - end - -end diff --git a/spec/unit/parser/functions/squeeze_spec.rb b/spec/unit/parser/functions/squeeze_spec.rb deleted file mode 100644 index 9355ad2..0000000 --- a/spec/unit/parser/functions/squeeze_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should squeeze a string" do - 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.should(eq(['abc','df'])) - end - -end diff --git a/spec/unit/parser/functions/str2bool_spec.rb b/spec/unit/parser/functions/str2bool_spec.rb deleted file mode 100644 index d7f0ac9..0000000 --- a/spec/unit/parser/functions/str2bool_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should convert string 'true' to true" do - result = @scope.function_str2bool(["true"]) - result.should(eq(true)) - end - - it "should convert string 'undef' to false" do - result = @scope.function_str2bool(["undef"]) - result.should(eq(false)) - end - -end diff --git a/spec/unit/parser/functions/strftime_spec.rb b/spec/unit/parser/functions/strftime_spec.rb deleted file mode 100644 index f7a2cd9..0000000 --- a/spec/unit/parser/functions/strftime_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "using %s should be higher then when I wrote this test" do - 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.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.should =~ /^\d{4}-\d{2}-\d{2}$/ - end - -end diff --git a/spec/unit/parser/functions/strip_spec.rb b/spec/unit/parser/functions/strip_spec.rb deleted file mode 100644 index 48a52dd..0000000 --- a/spec/unit/parser/functions/strip_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should strip a string" do - result = @scope.function_strip([" ab cd "]) - result.should(eq('ab cd')) - end - -end diff --git a/spec/unit/parser/functions/swapcase_spec.rb b/spec/unit/parser/functions/swapcase_spec.rb deleted file mode 100644 index 2686054..0000000 --- a/spec/unit/parser/functions/swapcase_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should swapcase a string" do - result = @scope.function_swapcase(["aaBBccDD"]) - result.should(eq('AAbbCCdd')) - end - -end diff --git a/spec/unit/parser/functions/time_spec.rb b/spec/unit/parser/functions/time_spec.rb deleted file mode 100644 index 666e8e0..0000000 --- a/spec/unit/parser/functions/time_spec.rb +++ /dev/null @@ -1,36 +0,0 @@ -#!/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 - - it "should return a number" do - result = @scope.function_time([]) - result.class.should(eq(Fixnum)) - end - - it "should be higher then when I wrote this test" do - result = @scope.function_time([]) - result.should(be > 1311953157) - end - - it "should be lower then 1.5 trillion" do - result = @scope.function_time([]) - result.should(be < 1500000000) - end - -end diff --git a/spec/unit/parser/functions/type_spec.rb b/spec/unit/parser/functions/type_spec.rb deleted file mode 100644 index e3c28ed..0000000 --- a/spec/unit/parser/functions/type_spec.rb +++ /dev/null @@ -1,51 +0,0 @@ -#!/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 - - it "should return string when given a string" do - 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.should(eq('array')) - end - - it "should return hash when given a hash" do - 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.should(eq('integer')) - end - - it "should return float when given a float" do - 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.should(eq('boolean')) - end - -end diff --git a/spec/unit/parser/functions/unique_spec.rb b/spec/unit/parser/functions/unique_spec.rb deleted file mode 100644 index 627dc33..0000000 --- a/spec/unit/parser/functions/unique_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should remove duplicate elements in a string" do - 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.should(eq(['a','b','c'])) - end - -end diff --git a/spec/unit/parser/functions/upcase_spec.rb b/spec/unit/parser/functions/upcase_spec.rb deleted file mode 100644 index 5d18846..0000000 --- a/spec/unit/parser/functions/upcase_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/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 - - it "should upcase a string" do - 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.should(eq('ABC')) - end - -end diff --git a/spec/unit/parser/functions/values_at_spec.rb b/spec/unit/parser/functions/values_at_spec.rb deleted file mode 100644 index 6c45316..0000000 --- a/spec/unit/parser/functions/values_at_spec.rb +++ /dev/null @@ -1,45 +0,0 @@ -#!/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 - - 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)) - end - - it "should return a value at from an array" do - 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.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.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.should(eq(['a','c','e','f'])) - end - -end diff --git a/spec/unit/parser/functions/values_spec.rb b/spec/unit/parser/functions/values_spec.rb deleted file mode 100644 index f6eb5b6..0000000 --- a/spec/unit/parser/functions/values_spec.rb +++ /dev/null @@ -1,30 +0,0 @@ -#!/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 - - it "should return values from a hash" do - result = @scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}]) - result.should(eq(['1','2','3'])) - end - - it "should return values from a hash" do - lambda { @scope.function_values([['a','b','c']]) }.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 deleted file mode 100644 index 074f4df..0000000 --- a/spec/unit/parser/functions/zip_spec.rb +++ /dev/null @@ -1,26 +0,0 @@ -#!/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 - - it "should be able to zip an array" do - result = @scope.function_zip([['1','2','3'],['4','5','6']]) - result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]])) - end - -end diff --git a/spec/unit/puppet/parser/functions/abs_spec.rb b/spec/unit/puppet/parser/functions/abs_spec.rb new file mode 100755 index 0000000..65ba2e8 --- /dev/null +++ b/spec/unit/puppet/parser/functions/abs_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should convert a negative number into a positive" do + 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.should(eq(5678)) + end + +end diff --git a/spec/unit/puppet/parser/functions/bool2num_spec.rb b/spec/unit/puppet/parser/functions/bool2num_spec.rb new file mode 100755 index 0000000..d5da18c --- /dev/null +++ b/spec/unit/puppet/parser/functions/bool2num_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should convert true to 1" do + result = @scope.function_bool2num([true]) + result.should(eq(1)) + end + + it "should convert false to 0" do + result = @scope.function_bool2num([false]) + result.should(eq(0)) + end + +end diff --git a/spec/unit/puppet/parser/functions/capitalize_spec.rb b/spec/unit/puppet/parser/functions/capitalize_spec.rb new file mode 100755 index 0000000..1c45821 --- /dev/null +++ b/spec/unit/puppet/parser/functions/capitalize_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should capitalize the beginning of a string" do + result = @scope.function_capitalize(["abc"]) + result.should(eq("Abc")) + end + +end diff --git a/spec/unit/puppet/parser/functions/chomp_spec.rb b/spec/unit/puppet/parser/functions/chomp_spec.rb new file mode 100755 index 0000000..0592115 --- /dev/null +++ b/spec/unit/puppet/parser/functions/chomp_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should chomp the end of a string" do + result = @scope.function_chomp(["abc\n"]) + result.should(eq("abc")) + end + +end diff --git a/spec/unit/puppet/parser/functions/chop_spec.rb b/spec/unit/puppet/parser/functions/chop_spec.rb new file mode 100755 index 0000000..0c456a8 --- /dev/null +++ b/spec/unit/puppet/parser/functions/chop_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should chop the end of a string" do + result = @scope.function_chop(["asdf\n"]) + result.should(eq("asdf")) + end + +end diff --git a/spec/unit/puppet/parser/functions/delete_at_spec.rb b/spec/unit/puppet/parser/functions/delete_at_spec.rb new file mode 100755 index 0000000..27db0c8 --- /dev/null +++ b/spec/unit/puppet/parser/functions/delete_at_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should delete an item at specified location from an array" do + result = @scope.function_delete_at([['a','b','c'],1]) + result.should(eq(['a','c'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/delete_spec.rb b/spec/unit/puppet/parser/functions/delete_spec.rb new file mode 100755 index 0000000..fab3230 --- /dev/null +++ b/spec/unit/puppet/parser/functions/delete_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should delete an item from an array" do + result = @scope.function_delete([['a','b','c'],'b']) + result.should(eq(['a','c'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/downcase_spec.rb b/spec/unit/puppet/parser/functions/downcase_spec.rb new file mode 100755 index 0000000..0bccd5f --- /dev/null +++ b/spec/unit/puppet/parser/functions/downcase_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should downcase a string" do + 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.should(eq("asdf asdf")) + end + +end diff --git a/spec/unit/puppet/parser/functions/empty_spec.rb b/spec/unit/puppet/parser/functions/empty_spec.rb new file mode 100755 index 0000000..cb0021f --- /dev/null +++ b/spec/unit/puppet/parser/functions/empty_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should return a true for an empty string" do + 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.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb new file mode 100755 index 0000000..7bedeb2 --- /dev/null +++ b/spec/unit/puppet/parser/functions/flatten_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should flatten a complex data structure" do + 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.should(eq(["a","b","c","d"])) + end + +end diff --git a/spec/unit/puppet/parser/functions/grep_spec.rb b/spec/unit/puppet/parser/functions/grep_spec.rb new file mode 100755 index 0000000..b1f647c --- /dev/null +++ b/spec/unit/puppet/parser/functions/grep_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should grep contents from an array" do + result = @scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"]) + result.should(eq(["aaabbb","bbbccc"])) + end + +end diff --git a/spec/unit/puppet/parser/functions/hash_spec.rb b/spec/unit/puppet/parser/functions/hash_spec.rb new file mode 100644 index 0000000..6d3d48c --- /dev/null +++ b/spec/unit/puppet/parser/functions/hash_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should convert an array to a hash" do + result = @scope.function_hash([['a',1,'b',2,'c',3]]) + result.should(eq({'a'=>1,'b'=>2,'c'=>3})) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_array_spec.rb b/spec/unit/puppet/parser/functions/is_array_spec.rb new file mode 100644 index 0000000..537595c --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_array_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "should return true if passed an array" do + 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.should(eq(false)) + end + + it "should return false if passed a string" do + result = @scope.function_is_array(["asdf"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_domain_name_spec.rb b/spec/unit/puppet/parser/functions/is_domain_name_spec.rb new file mode 100644 index 0000000..ec7c7f5 --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_domain_name_spec.rb @@ -0,0 +1,56 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_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_domain_name").should == "function_is_domain_name" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should return true if a valid domain name" do + result = @scope.function_is_domain_name(["foo.bar.com"]) + result.should(be_true) + end + + it "should allow domain parts to start with numbers" do + result = @scope.function_is_domain_name(["3foo.2bar.com"]) + result.should(be_true) + end + + it "should allow domain to end with a dot" do + result = @scope.function_is_domain_name(["3foo.2bar.com."]) + result.should(be_true) + end + + it "should allow a single part domain" do + result = @scope.function_is_domain_name(["orange"]) + result.should(be_true) + end + + it "should return false if domain parts start with hyphens" do + result = @scope.function_is_domain_name(["-3foo.2bar.com"]) + result.should(be_false) + end + + it "should return true if domain contains hyphens" do + result = @scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"]) + result.should(be_true) + end + + it "should return false if domain name contains spaces" do + result = @scope.function_is_domain_name(["not valid"]) + result.should(be_false) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_float_spec.rb b/spec/unit/puppet/parser/functions/is_float_spec.rb new file mode 100644 index 0000000..55ba8cf --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_float_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "should return true if a float" do + 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.should(eq(false)) + end + + it "should return false if an integer" do + result = @scope.function_is_float(["3"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_hash_spec.rb b/spec/unit/puppet/parser/functions/is_hash_spec.rb new file mode 100644 index 0000000..94364f5 --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_hash_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "should return true if passed a hash" do + 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.should(eq(false)) + end + + it "should return false if passed a string" do + result = @scope.function_is_hash(["asdf"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_integer_spec.rb b/spec/unit/puppet/parser/functions/is_integer_spec.rb new file mode 100644 index 0000000..faf6f2d --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_integer_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "should return true if an integer" do + 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.should(eq(false)) + end + + it "should return false if a string" do + result = @scope.function_is_integer(["asdf"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_ip_address_spec.rb b/spec/unit/puppet/parser/functions/is_ip_address_spec.rb new file mode 100644 index 0000000..98ce828 --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_ip_address_spec.rb @@ -0,0 +1,45 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should return true if an IPv4 address" do + 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.should(eq(true)) + end + + it "should return true if a compressed IPv6 address" do + 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.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.should(eq(false)) + end +end diff --git a/spec/unit/puppet/parser/functions/is_mac_address_spec.rb b/spec/unit/puppet/parser/functions/is_mac_address_spec.rb new file mode 100644 index 0000000..c9b9637 --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_mac_address_spec.rb @@ -0,0 +1,36 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should return true if a valid mac address" do + 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.should(eq(false)) + end + + it "should return false if not valid" do + result = @scope.function_is_mac_address(["not valid"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_numeric_spec.rb b/spec/unit/puppet/parser/functions/is_numeric_spec.rb new file mode 100644 index 0000000..2191b7b --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_numeric_spec.rb @@ -0,0 +1,36 @@ +#!/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 argument" do + 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.should(eq(true)) + end + + it "should return true if a float" do + 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.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/is_string_spec.rb b/spec/unit/puppet/parser/functions/is_string_spec.rb new file mode 100644 index 0000000..4f3f5fd --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_string_spec.rb @@ -0,0 +1,41 @@ +#!/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 + + it "should return true if a string" do + 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.should(eq(false)) + end + + it "should return false if a float" do + 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.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/join_spec.rb b/spec/unit/puppet/parser/functions/join_spec.rb new file mode 100644 index 0000000..1b3dec8 --- /dev/null +++ b/spec/unit/puppet/parser/functions/join_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should join an array into a string" do + result = @scope.function_join([["a","b","c"], ":"]) + result.should(eq("a:b:c")) + end + +end diff --git a/spec/unit/puppet/parser/functions/keys_spec.rb b/spec/unit/puppet/parser/functions/keys_spec.rb new file mode 100644 index 0000000..927be96 --- /dev/null +++ b/spec/unit/puppet/parser/functions/keys_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should return an array of keys when given a hash" do + result = @scope.function_keys([{'a'=>1, 'b' => 2}]) + result.should(eq(['a','b'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/lstrip_spec.rb b/spec/unit/puppet/parser/functions/lstrip_spec.rb new file mode 100644 index 0000000..ac331fa --- /dev/null +++ b/spec/unit/puppet/parser/functions/lstrip_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should lstrip a string" do + result = @scope.function_lstrip([" asdf"]) + result.should(eq('asdf')) + end + +end diff --git a/spec/unit/puppet/parser/functions/member_spec.rb b/spec/unit/puppet/parser/functions/member_spec.rb new file mode 100644 index 0000000..2cebc0d --- /dev/null +++ b/spec/unit/puppet/parser/functions/member_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should return true if a member is in an array" do + result = @scope.function_member([["a","b","c"], "a"]) + result.should(eq(true)) + end + + it "should return false if a member is not in an array" do + result = @scope.function_member([["a","b","c"], "d"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb new file mode 100644 index 0000000..6585273 --- /dev/null +++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should return true if 1" do + result = @scope.function_num2bool(["1"]) + result.should(be_true) + end + + it "should return false if 0" do + result = @scope.function_num2bool(["0"]) + result.should(be_false) + end + +end diff --git a/spec/unit/puppet/parser/functions/parsejson_spec.rb b/spec/unit/puppet/parser/functions/parsejson_spec.rb new file mode 100644 index 0000000..26eea36 --- /dev/null +++ b/spec/unit/puppet/parser/functions/parsejson_spec.rb @@ -0,0 +1,29 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should convert JSON to a data structure" do + json = <<-EOS +["aaa","bbb","ccc"] +EOS + result = @scope.function_parsejson([json]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/parseyaml_spec.rb b/spec/unit/puppet/parser/functions/parseyaml_spec.rb new file mode 100644 index 0000000..f9cb049 --- /dev/null +++ b/spec/unit/puppet/parser/functions/parseyaml_spec.rb @@ -0,0 +1,31 @@ +#!/usr/bin/env rspec +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 + + 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)) + end + + it "should convert YAML to a data structure" do + yaml = <<-EOS +- aaa +- bbb +- ccc +EOS + result = @scope.function_parseyaml([yaml]) + result.should(eq(['aaa','bbb','ccc'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/prefix_spec.rb b/spec/unit/puppet/parser/functions/prefix_spec.rb new file mode 100644 index 0000000..a0cbcab --- /dev/null +++ b/spec/unit/puppet/parser/functions/prefix_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should return a prefixed array" do + result = @scope.function_prefix([['a','b','c'], 'p']) + result.should(eq(['pa','pb','pc'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/range_spec.rb b/spec/unit/puppet/parser/functions/range_spec.rb new file mode 100644 index 0000000..8c2446a --- /dev/null +++ b/spec/unit/puppet/parser/functions/range_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should return a letter range" do + result = @scope.function_range(["a","d"]) + result.should(eq(['a','b','c','d'])) + end + + it "should return a number range" do + result = @scope.function_range(["1","4"]) + result.should(eq([1,2,3,4])) + end + +end diff --git a/spec/unit/puppet/parser/functions/reverse_spec.rb b/spec/unit/puppet/parser/functions/reverse_spec.rb new file mode 100644 index 0000000..4fa50e4 --- /dev/null +++ b/spec/unit/puppet/parser/functions/reverse_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should reverse a string" do + result = @scope.function_reverse(["asdfghijkl"]) + result.should(eq('lkjihgfdsa')) + end + +end diff --git a/spec/unit/puppet/parser/functions/rstrip_spec.rb b/spec/unit/puppet/parser/functions/rstrip_spec.rb new file mode 100644 index 0000000..af8cc12 --- /dev/null +++ b/spec/unit/puppet/parser/functions/rstrip_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should rstrip a string" do + 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.should(eq(['a','b','c'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/shuffle_spec.rb b/spec/unit/puppet/parser/functions/shuffle_spec.rb new file mode 100644 index 0000000..f04fda5 --- /dev/null +++ b/spec/unit/puppet/parser/functions/shuffle_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should shuffle a string and the result should be the same size" do + 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.split("").sort.join("").should(eq("adfs")) + end + +end diff --git a/spec/unit/puppet/parser/functions/size_spec.rb b/spec/unit/puppet/parser/functions/size_spec.rb new file mode 100644 index 0000000..ccaa335 --- /dev/null +++ b/spec/unit/puppet/parser/functions/size_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should return the size of a string" do + 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.should(eq(3)) + end + +end diff --git a/spec/unit/puppet/parser/functions/sort_spec.rb b/spec/unit/puppet/parser/functions/sort_spec.rb new file mode 100644 index 0000000..fbe3073 --- /dev/null +++ b/spec/unit/puppet/parser/functions/sort_spec.rb @@ -0,0 +1,31 @@ +#!/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 1 arguments" do + lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError)) + end + + it "should sort an array" do + 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.should(eq('abc')) + end + +end diff --git a/spec/unit/puppet/parser/functions/squeeze_spec.rb b/spec/unit/puppet/parser/functions/squeeze_spec.rb new file mode 100644 index 0000000..9355ad2 --- /dev/null +++ b/spec/unit/puppet/parser/functions/squeeze_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should squeeze a string" do + 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.should(eq(['abc','df'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/str2bool_spec.rb b/spec/unit/puppet/parser/functions/str2bool_spec.rb new file mode 100644 index 0000000..d7f0ac9 --- /dev/null +++ b/spec/unit/puppet/parser/functions/str2bool_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should convert string 'true' to true" do + result = @scope.function_str2bool(["true"]) + result.should(eq(true)) + end + + it "should convert string 'undef' to false" do + result = @scope.function_str2bool(["undef"]) + result.should(eq(false)) + end + +end diff --git a/spec/unit/puppet/parser/functions/strftime_spec.rb b/spec/unit/puppet/parser/functions/strftime_spec.rb new file mode 100644 index 0000000..f7a2cd9 --- /dev/null +++ b/spec/unit/puppet/parser/functions/strftime_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "using %s should be higher then when I wrote this test" do + 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.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.should =~ /^\d{4}-\d{2}-\d{2}$/ + end + +end diff --git a/spec/unit/puppet/parser/functions/strip_spec.rb b/spec/unit/puppet/parser/functions/strip_spec.rb new file mode 100644 index 0000000..48a52dd --- /dev/null +++ b/spec/unit/puppet/parser/functions/strip_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should strip a string" do + result = @scope.function_strip([" ab cd "]) + result.should(eq('ab cd')) + end + +end diff --git a/spec/unit/puppet/parser/functions/swapcase_spec.rb b/spec/unit/puppet/parser/functions/swapcase_spec.rb new file mode 100644 index 0000000..2686054 --- /dev/null +++ b/spec/unit/puppet/parser/functions/swapcase_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should swapcase a string" do + result = @scope.function_swapcase(["aaBBccDD"]) + result.should(eq('AAbbCCdd')) + end + +end diff --git a/spec/unit/puppet/parser/functions/time_spec.rb b/spec/unit/puppet/parser/functions/time_spec.rb new file mode 100644 index 0000000..666e8e0 --- /dev/null +++ b/spec/unit/puppet/parser/functions/time_spec.rb @@ -0,0 +1,36 @@ +#!/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 + + it "should return a number" do + result = @scope.function_time([]) + result.class.should(eq(Fixnum)) + end + + it "should be higher then when I wrote this test" do + result = @scope.function_time([]) + result.should(be > 1311953157) + end + + it "should be lower then 1.5 trillion" do + result = @scope.function_time([]) + result.should(be < 1500000000) + end + +end diff --git a/spec/unit/puppet/parser/functions/type_spec.rb b/spec/unit/puppet/parser/functions/type_spec.rb new file mode 100644 index 0000000..e3c28ed --- /dev/null +++ b/spec/unit/puppet/parser/functions/type_spec.rb @@ -0,0 +1,51 @@ +#!/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 + + it "should return string when given a string" do + 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.should(eq('array')) + end + + it "should return hash when given a hash" do + 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.should(eq('integer')) + end + + it "should return float when given a float" do + 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.should(eq('boolean')) + end + +end diff --git a/spec/unit/puppet/parser/functions/unique_spec.rb b/spec/unit/puppet/parser/functions/unique_spec.rb new file mode 100644 index 0000000..627dc33 --- /dev/null +++ b/spec/unit/puppet/parser/functions/unique_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should remove duplicate elements in a string" do + 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.should(eq(['a','b','c'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/upcase_spec.rb b/spec/unit/puppet/parser/functions/upcase_spec.rb new file mode 100644 index 0000000..5d18846 --- /dev/null +++ b/spec/unit/puppet/parser/functions/upcase_spec.rb @@ -0,0 +1,31 @@ +#!/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 + + it "should upcase a string" do + 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.should(eq('ABC')) + end + +end diff --git a/spec/unit/puppet/parser/functions/values_at_spec.rb b/spec/unit/puppet/parser/functions/values_at_spec.rb new file mode 100644 index 0000000..6c45316 --- /dev/null +++ b/spec/unit/puppet/parser/functions/values_at_spec.rb @@ -0,0 +1,45 @@ +#!/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 + + 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)) + end + + it "should return a value at from an array" do + 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.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.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.should(eq(['a','c','e','f'])) + end + +end diff --git a/spec/unit/puppet/parser/functions/values_spec.rb b/spec/unit/puppet/parser/functions/values_spec.rb new file mode 100644 index 0000000..f6eb5b6 --- /dev/null +++ b/spec/unit/puppet/parser/functions/values_spec.rb @@ -0,0 +1,30 @@ +#!/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 + + it "should return values from a hash" do + result = @scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}]) + result.should(eq(['1','2','3'])) + end + + it "should return values from a hash" do + lambda { @scope.function_values([['a','b','c']]) }.should( raise_error(Puppet::ParseError)) + end + +end diff --git a/spec/unit/puppet/parser/functions/zip_spec.rb b/spec/unit/puppet/parser/functions/zip_spec.rb new file mode 100644 index 0000000..074f4df --- /dev/null +++ b/spec/unit/puppet/parser/functions/zip_spec.rb @@ -0,0 +1,26 @@ +#!/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 + + it "should be able to zip an array" do + result = @scope.function_zip([['1','2','3'],['4','5','6']]) + result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]])) + end + +end -- cgit v1.2.3