puppetmodule-stdlib 4.0.1

data/spec/unit/puppet/parser/functions/is_mac_address_spec.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_mac_address function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
+  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

data/spec/unit/puppet/parser/functions/is_numeric_spec.rb

@@ -0,0 +1,39 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_numeric function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric"
+  end
+
+  it "should raise a ParseError if there is less than 1 argument" do
+    lambda { scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
+  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 true if an integer is created from an arithmetical operation" do
+    result = scope.function_is_numeric([3*2])
+    result.should(eq(true))
+  end
+
+  it "should return true if a float is created from an arithmetical operation" do
+    result = scope.function_is_numeric([3.2*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

data/spec/unit/puppet/parser/functions/is_string_spec.rb

@@ -0,0 +1,34 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_string function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("is_string").should == "function_is_string"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
+  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

data/spec/unit/puppet/parser/functions/join_keys_to_values_spec.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the join_keys_to_values function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("join_keys_to_values").should == "function_join_keys_to_values"
+  end
+
+  it "should raise a ParseError if there are fewer than two arguments" do
+    lambda { scope.function_join_keys_to_values([{}]) }.should raise_error Puppet::ParseError
+  end
+
+  it "should raise a ParseError if there are greater than two arguments" do
+    lambda { scope.function_join_keys_to_values([{}, 'foo', 'bar']) }.should raise_error Puppet::ParseError
+  end
+
+  it "should raise a TypeError if the first argument is an array" do
+    lambda { scope.function_join_keys_to_values([[1,2], ',']) }.should raise_error TypeError
+  end
+
+  it "should raise a TypeError if the second argument is an array" do
+    lambda { scope.function_join_keys_to_values([{}, [1,2]]) }.should raise_error TypeError
+  end
+
+  it "should raise a TypeError if the second argument is a number" do
+    lambda { scope.function_join_keys_to_values([{}, 1]) }.should raise_error TypeError
+  end
+
+  it "should return an empty array given an empty hash" do
+    result = scope.function_join_keys_to_values([{}, ":"])
+    result.should == []
+  end
+
+  it "should join hash's keys to its values" do
+    result = scope.function_join_keys_to_values([{'a'=>1,2=>'foo',:b=>nil}, ":"])
+    result.should =~ ['a:1','2:foo','b:']
+  end
+end

data/spec/unit/puppet/parser/functions/join_spec.rb

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the join function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("join").should == "function_join"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_join([]) }.should( raise_error(Puppet::ParseError))
+  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

data/spec/unit/puppet/parser/functions/keys_spec.rb

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the keys function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  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}])
+    # =~ performs 'array with same elements' (set) matching
+    # For more info see RSpec::Matchers::MatchArray
+    result.should =~ ['a','b']
+  end
+end

data/spec/unit/puppet/parser/functions/lstrip_spec.rb

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the lstrip function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("lstrip").should == "function_lstrip"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should lstrip a string" do
+    result = scope.function_lstrip(["  asdf"])
+    result.should(eq('asdf'))
+  end
+end

data/spec/unit/puppet/parser/functions/max_spec.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the max function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("max").should == "function_max"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_max([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should be able to compare strings" do
+    scope.function_max(["albatross","dog","horse"]).should(eq("horse"))
+  end
+
+  it "should be able to compare numbers" do
+    scope.function_max([6,8,4]).should(eq(8))
+  end
+
+  it "should be able to compare a number with a stringified number" do
+    scope.function_max([1,"2"]).should(eq("2"))
+  end
+end

data/spec/unit/puppet/parser/functions/member_spec.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the member function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("member").should == "function_member"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_member([]) }.should( raise_error(Puppet::ParseError))
+  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

data/spec/unit/puppet/parser/functions/merge_spec.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:merge) do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  describe 'when calling merge from puppet' do
+    it "should not compile when no arguments are passed" do
+      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      Puppet[:code] = '$x = merge()'
+      expect {
+        scope.compiler.compile
+      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+    end
+
+    it "should not compile when 1 argument is passed" do
+      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      Puppet[:code] = "$my_hash={'one' => 1}\n$x = merge($my_hash)"
+      expect {
+        scope.compiler.compile
+      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+    end
+  end
+
+  describe 'when calling merge on the scope instance' do
+    it 'should require all parameters are hashes' do
+      expect { new_hash = scope.function_merge([{}, '2'])}.to raise_error(Puppet::ParseError, /unexpected argument type String/)
+    end
+
+    it 'should be able to merge two hashes' do
+      new_hash = scope.function_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
+      new_hash['one'].should   == '1'
+      new_hash['two'].should   == '2'
+      new_hash['three'].should == '2'
+    end
+
+    it 'should merge multiple hashes' do
+      hash = scope.function_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
+      hash['one'].should == '3'
+    end
+
+    it 'should accept empty hashes' do
+      scope.function_merge([{},{},{}]).should == {}
+    end
+  end
+end

data/spec/unit/puppet/parser/functions/min_spec.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the min function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("min").should == "function_min"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_min([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should be able to compare strings" do
+    scope.function_min(["albatross","dog","horse"]).should(eq("albatross"))
+  end
+
+  it "should be able to compare numbers" do
+    scope.function_min([6,8,4]).should(eq(4))
+  end
+
+  it "should be able to compare a number with a stringified number" do
+    scope.function_min([1,"2"]).should(eq(1))
+  end
+end

data/spec/unit/puppet/parser/functions/num2bool_spec.rb

@@ -0,0 +1,67 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the num2bool function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
+  end
+
+  it "should raise a ParseError if there are no arguments" do
+    lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should raise a ParseError if there are more than 1 arguments" do
+    lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should raise a ParseError if passed something non-numeric" do
+    lambda { scope.function_num2bool(["xyzzy"]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should return true if passed string 1" do
+    result = scope.function_num2bool(["1"])
+    result.should(be_true)
+  end
+
+  it "should return true if passed string 1.5" do
+    result = scope.function_num2bool(["1.5"])
+    result.should(be_true)
+  end
+
+  it "should return true if passed number 1" do
+    result = scope.function_num2bool([1])
+    result.should(be_true)
+  end
+
+  it "should return false if passed string 0" do
+    result = scope.function_num2bool(["0"])
+    result.should(be_false)
+  end
+
+  it "should return false if passed number 0" do
+    result = scope.function_num2bool([0])
+    result.should(be_false)
+  end
+
+  it "should return false if passed string -1" do
+    result = scope.function_num2bool(["-1"])
+    result.should(be_false)
+  end
+
+  it "should return false if passed string -1.5" do
+    result = scope.function_num2bool(["-1.5"])
+    result.should(be_false)
+  end
+
+  it "should return false if passed number -1" do
+    result = scope.function_num2bool([-1])
+    result.should(be_false)
+  end
+
+  it "should return false if passed float -1.5" do
+    result = scope.function_num2bool([-1.5])
+    result.should(be_false)
+  end
+end

data/spec/unit/puppet/parser/functions/parsejson_spec.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the parsejson function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("parsejson").should == "function_parsejson"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
+  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

data/spec/unit/puppet/parser/functions/parseyaml_spec.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the parseyaml function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
+  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