puppet-retrospec 0.12.1 → 0.12.2

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

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "the reject function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("reject")).to eq("function_reject")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_reject([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should reject contents from an array" do
-    result = scope.function_reject([["1111", "aaabbb","bbbccc","dddeee"], "bbb"])
-    expect(result).to(eq(["1111", "dddeee"]))
-  end
-end

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

@@ -1,28 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the reverse function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("reverse")).to eq("function_reverse")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_reverse([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should reverse a string" do
-    result = scope.function_reverse(["asdfghijkl"])
-    expect(result).to(eq('lkjihgfdsa'))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new('asdfghjkl')
-    result = scope.function_reverse([value])
-    result.should(eq('lkjhgfdsa'))
-  end
-end

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

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the rstrip function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("rstrip")).to eq("function_rstrip")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_rstrip([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should rstrip a string" do
-    result = scope.function_rstrip(["asdf  "])
-    expect(result).to(eq('asdf'))
-  end
-
-  it "should rstrip each element in an array" do
-    result = scope.function_rstrip([["a ","b ", "c "]])
-    expect(result).to(eq(['a','b','c']))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new('asdf ')
-    result = scope.function_rstrip([value])
-    result.should(eq('asdf'))
-  end
-end

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

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the shuffle function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("shuffle")).to eq("function_shuffle")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_shuffle([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should shuffle a string and the result should be the same size" do
-    result = scope.function_shuffle(["asdf"])
-    expect(result.size).to(eq(4))
-  end
-
-  it "should shuffle a string but the sorted contents should still be the same" do
-    result = scope.function_shuffle(["adfs"])
-    expect(result.split("").sort.join("")).to(eq("adfs"))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new('asdf')
-    result = scope.function_shuffle([value])
-    result.size.should(eq(4))
-  end
-end

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

@@ -1,24 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the size function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("size")).to eq("function_size")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_size([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should return the size of a string" do
-    result = scope.function_size(["asdf"])
-    expect(result).to(eq(4))
-  end
-
-  it "should return the size of an array" do
-    result = scope.function_size([["a","b","c"]])
-    expect(result).to(eq(3))
-  end
-end

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

@@ -1,24 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the sort function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("sort")).to eq("function_sort")
-  end
-
-  it "should raise a ParseError if there is not 1 arguments" do
-    expect { scope.function_sort(['','']) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should sort an array" do
-    result = scope.function_sort([["a","c","b"]])
-    expect(result).to(eq(['a','b','c']))
-  end
-
-  it "should sort a string" do
-    result = scope.function_sort(["acb"])
-    expect(result).to(eq('abc'))
-  end
-end

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

@@ -1,24 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the squeeze function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("squeeze")).to eq("function_squeeze")
-  end
-
-  it "should raise a ParseError if there is less than 2 arguments" do
-    expect { scope.function_squeeze([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should squeeze a string" do
-    result = scope.function_squeeze(["aaabbbbcccc"])
-    expect(result).to(eq('abc'))
-  end
-
-  it "should squeeze all elements in an array" do
-    result = scope.function_squeeze([["aaabbbbcccc","dddfff"]])
-    expect(result).to(eq(['abc','df']))
-  end
-end

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

@@ -1,31 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the str2bool function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("str2bool")).to eq("function_str2bool")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_str2bool([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should convert string 'true' to true" do
-    result = scope.function_str2bool(["true"])
-    expect(result).to(eq(true))
-  end
-
-  it "should convert string 'undef' to false" do
-    result = scope.function_str2bool(["undef"])
-    expect(result).to(eq(false))
-  end
-
-  it "should return the boolean it was called with" do
-    result = scope.function_str2bool([true])
-    expect(result).to(eq(true))
-    result = scope.function_str2bool([false])
-    expect(result).to(eq(false))
-  end
-end

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

@@ -1,45 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the str2saltedsha512 function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("str2saltedsha512")).to eq("function_str2saltedsha512")
-  end
-
-  it "should raise a ParseError if there is less than 1 argument" do
-    expect { scope.function_str2saltedsha512([]) }.to( raise_error(Puppet::ParseError) )
-  end
-
-  it "should raise a ParseError if there is more than 1 argument" do
-    expect { scope.function_str2saltedsha512(['foo', 'bar', 'baz']) }.to( raise_error(Puppet::ParseError) )
-  end
-
-  it "should return a salted-sha512 password hash 136 characters in length" do
-    result = scope.function_str2saltedsha512(["password"])
-    expect(result.length).to(eq(136))
-  end
-
-  it "should raise an error if you pass a non-string password" do
-    expect { scope.function_str2saltedsha512([1234]) }.to( raise_error(Puppet::ParseError) )
-  end
-
-  it "should generate a valid password" do
-    # Allow the function to generate a password based on the string 'password'
-    password_hash = scope.function_str2saltedsha512(["password"])
-
-    # Separate the Salt and Password from the Password Hash
-    salt     = password_hash[0..7]
-    password = password_hash[8..-1]
-
-    # Convert the Salt and Password from Hex to Binary Data
-    str_salt     = Array(salt.lines).pack('H*')
-    str_password = Array(password.lines).pack('H*')
-
-    # Combine the Binary Salt with 'password' and compare the end result
-    saltedpass    = Digest::SHA512.digest(str_salt + 'password')
-    result        = (str_salt + saltedpass).unpack('H*')[0]
-    expect(result).to eq(password_hash)
-  end
-end

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

@@ -1,29 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the strftime function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("strftime")).to eq("function_strftime")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_strftime([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "using %s should be higher then when I wrote this test" do
-    result = scope.function_strftime(["%s"])
-    expect(result.to_i).to(be > 1311953157)
-  end
-
-  it "using %s should be lower then 1.5 trillion" do
-    result = scope.function_strftime(["%s"])
-    expect(result.to_i).to(be < 1500000000)
-  end
-
-  it "should return a date when given %Y-%m-%d" do
-    result = scope.function_strftime(["%Y-%m-%d"])
-    expect(result).to match(/^\d{4}-\d{2}-\d{2}$/)
-  end
-end

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

@@ -1,27 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the strip function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("strip")).to eq("function_strip")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_strip([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should strip a string" do
-    result = scope.function_strip([" ab cd "])
-    expect(result).to(eq('ab cd'))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new(' as df ')
-    result = scope.function_strip([value])
-    result.should(eq('as df'))
-  end
-end

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

@@ -1,27 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the suffix function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "raises a ParseError if there is less than 1 arguments" do
-    expect { scope.function_suffix([]) }.to raise_error(Puppet::ParseError, /number of arguments/)
-  end
-
-  it "raises an error if the first argument is not an array" do
-    expect {
-      scope.function_suffix([Object.new])
-    }.to raise_error(Puppet::ParseError, /expected first argument to be an Array/)
-  end
-
-  it "raises an error if the second argument is not a string" do
-    expect {
-      scope.function_suffix([['first', 'second'], 42])
-    }.to raise_error(Puppet::ParseError, /expected second argument to be a String/)
-  end
-
-  it "returns a suffixed array" do
-    result = scope.function_suffix([['a','b','c'], 'p'])
-    expect(result).to(eq(['ap','bp','cp']))
-  end
-end

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

@@ -1,28 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the swapcase function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("swapcase")).to eq("function_swapcase")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_swapcase([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should swapcase a string" do
-    result = scope.function_swapcase(["aaBBccDD"])
-    expect(result).to(eq('AAbbCCdd'))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new("aaBBccDD")
-    result = scope.function_swapcase([value])
-    result.should(eq("AAbbCCdd"))
-  end
-end

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

@@ -1,29 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the time function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("time")).to eq("function_time")
-  end
-
-  it "should raise a ParseError if there is more than 2 arguments" do
-    expect { scope.function_time(['','']) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should return a number" do
-    result = scope.function_time([])
-    expect(result).to be_an(Integer)
-  end
-
-  it "should be higher then when I wrote this test" do
-    result = scope.function_time([])
-    expect(result).to(be > 1311953157)
-  end
-
-  it "should be lower then 1.5 trillion" do
-    result = scope.function_time([])
-    expect(result).to(be < 1500000000)
-  end
-end

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

@@ -1,83 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the to_bytes function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("to_bytes")).to eq("function_to_bytes")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_to_bytes([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should convert kB to B" do
-    result = scope.function_to_bytes(["4 kB"])
-    expect(result).to(eq(4096))
-  end
-
-  it "should convert MB to B" do
-    result = scope.function_to_bytes(["4 MB"])
-    expect(result).to(eq(4194304))
-  end
-
-  it "should convert GB to B" do
-    result = scope.function_to_bytes(["4 GB"])
-    expect(result).to(eq(4294967296))
-  end
-
-  it "should convert TB to B" do
-    result = scope.function_to_bytes(["4 TB"])
-    expect(result).to(eq(4398046511104))
-  end
-
-  it "should convert PB to B" do
-    result = scope.function_to_bytes(["4 PB"])
-    expect(result).to(eq(4503599627370496))
-  end
-
-  it "should convert PB to B" do
-    result = scope.function_to_bytes(["4 EB"])
-    expect(result).to(eq(4611686018427387904))
-  end
-
-  it "should work without B in unit" do
-    result = scope.function_to_bytes(["4 k"])
-    expect(result).to(eq(4096))
-  end
-
-  it "should work without a space before unit" do
-    result = scope.function_to_bytes(["4k"])
-    expect(result).to(eq(4096))
-  end
-
-  it "should work without a unit" do
-    result = scope.function_to_bytes(["5678"])
-    expect(result).to(eq(5678))
-  end
-
-  it "should convert fractions" do
-    result = scope.function_to_bytes(["1.5 kB"])
-    expect(result).to(eq(1536))
-  end
-
-  it "should convert scientific notation" do
-    result = scope.function_to_bytes(["1.5e2 B"])
-    expect(result).to(eq(150))
-  end
-
-  it "should do nothing with a positive number" do
-    result = scope.function_to_bytes([5678])
-    expect(result).to(eq(5678))
-  end
-
-  it "should should raise a ParseError if input isn't a number" do
-    expect { scope.function_to_bytes(["foo"]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should should raise a ParseError if prefix is unknown" do
-    expect { scope.function_to_bytes(["5 uB"]) }.to( raise_error(Puppet::ParseError))
-  end
-end