puppet-retrospec 0.12.1 → 0.12.2

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

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

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

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

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

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

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

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

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

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the pick_default function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("pick_default")).to eq("function_pick_default")
-  end
-
-  it 'should return the correct value' do
-    expect(scope.function_pick_default(['first', 'second'])).to eq('first')
-  end
-
-  it 'should return the correct value if the first value is empty' do
-    expect(scope.function_pick_default(['', 'second'])).to eq('second')
-  end
-
-  it 'should skip empty string values' do
-    expect(scope.function_pick_default(['', 'first'])).to eq('first')
-  end
-
-  it 'should skip :undef values' do
-    expect(scope.function_pick_default([:undef, 'first'])).to eq('first')
-  end
-
-  it 'should skip :undefined values' do
-    expect(scope.function_pick_default([:undefined, 'first'])).to eq('first')
-  end
-
-  it 'should return the empty string if it is the last possibility' do
-    expect(scope.function_pick_default([:undef, :undefined, ''])).to eq('')
-  end
-
-  it 'should return :undef if it is the last possibility' do
-    expect(scope.function_pick_default(['', :undefined, :undef])).to eq(:undef)
-  end
-
-  it 'should return :undefined if it is the last possibility' do
-    expect(scope.function_pick_default([:undef, '', :undefined])).to eq(:undefined)
-  end
-
-  it 'should return the empty string if it is the only possibility' do
-    expect(scope.function_pick_default([''])).to eq('')
-  end
-
-  it 'should return :undef if it is the only possibility' do
-    expect(scope.function_pick_default([:undef])).to eq(:undef)
-  end
-
-  it 'should return :undefined if it is the only possibility' do
-    expect(scope.function_pick_default([:undefined])).to eq(:undefined)
-  end
-
-  it 'should error if no values are passed' do
-    expect { scope.function_pick_default([]) }.to raise_error(Puppet::Error, /Must receive at least one argument./)
-  end
-end

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

@@ -1,34 +0,0 @@
-#!/usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the pick function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("pick")).to eq("function_pick")
-  end
-
-  it 'should return the correct value' do
-    expect(scope.function_pick(['first', 'second'])).to eq('first')
-  end
-
-  it 'should return the correct value if the first value is empty' do
-    expect(scope.function_pick(['', 'second'])).to eq('second')
-  end
-
-  it 'should remove empty string values' do
-    expect(scope.function_pick(['', 'first'])).to eq('first')
-  end
-
-  it 'should remove :undef values' do
-    expect(scope.function_pick([:undef, 'first'])).to eq('first')
-  end
-
-  it 'should remove :undefined values' do
-    expect(scope.function_pick([:undefined, 'first'])).to eq('first')
-  end
-
-  it 'should error if no values are passed' do
-    expect { scope.function_pick([]) }.to( raise_error(Puppet::ParseError, "pick(): must receive at least one non empty value"))
-  end
-end

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

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the prefix function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "raises a ParseError if there is less than 1 arguments" do
-    expect { scope.function_prefix([]) }.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_prefix([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_prefix([['first', 'second'], 42])
-    }.to raise_error(Puppet::ParseError, /expected second argument to be a String/)
-  end
-
-  it "returns a prefixed array" do
-    result = scope.function_prefix([['a','b','c'], 'p'])
-    expect(result).to(eq(['pa','pb','pc']))
-  end
-
-  it "returns a prefixed hash" do
-    result = scope.function_prefix([{'a' => 'b','b' => 'c','c' => 'd'}, 'p'])
-    expect(result).to(eq({'pa'=>'b','pb'=>'c','pc'=>'d'}))
-  end
-end

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

@@ -1,60 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:private) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  subject do
-    function_name = Puppet::Parser::Functions.function(:private)
-    scope.method(function_name)
-  end
-
-  it 'should issue a warning' do
-    scope.expects(:warning).with("private() DEPRECATED: This function will cease to function on Puppet 4; please use assert_private() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
-    subject.call []
-  end
-
-  context "when called from inside module" do
-    it "should not fail" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('foo')
-      expect {
-        subject.call []
-      }.not_to raise_error
-    end
-  end
-
-  context "with an explicit failure message" do
-    it "prints the failure message on error" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      expect {
-        subject.call ['failure message!']
-      }.to raise_error Puppet::ParseError, /failure message!/
-    end
-  end
-
-  context "when called from private class" do
-    it "should fail with a class error message" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      scope.source.expects(:name).returns('foo::baz')
-      scope.source.expects(:type).returns('hostclass')
-      expect {
-        subject.call []
-      }.to raise_error Puppet::ParseError, /Class foo::baz is private/
-    end
-  end
-
-  context "when called from private definition" do
-    it "should fail with a class error message" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      scope.source.expects(:name).returns('foo::baz')
-      scope.source.expects(:type).returns('definition')
-      expect {
-        subject.call []
-      }.to raise_error Puppet::ParseError, /Definition foo::baz is private/
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the pw_hash function" do
-
-  before :all do
-    @enhanced_salts_supported = RUBY_PLATFORM == 'java'
-  end
-
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("pw_hash")).to eq("function_pw_hash")
-  end
-
-  it "should raise an ArgumentError if there are less than 3 arguments" do
-    expect { scope.function_pw_hash([]) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
-    expect { scope.function_pw_hash(['password']) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
-    expect { scope.function_pw_hash(['password', 'sha-512']) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
-  end
-
-  it "should raise an ArgumentError if there are more than 3 arguments" do
-    expect { scope.function_pw_hash(['password', 'sha-512', 'salt', 5]) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
-  end
-
-  it "should raise an ArgumentError if the first argument is not a string" do
-    expect { scope.function_pw_hash([['password'], 'sha-512', 'salt']) }.to( raise_error(ArgumentError, /first argument must be a string/) )
-    # in Puppet 3, numbers are passed as strings, so we can't test that
-  end
-
-  it "should return nil if the first argument is empty" do
-    expect(scope.function_pw_hash(['', 'sha-512', 'salt'])).to eq(nil)
-  end
-
-  it "should return nil if the first argument is undef" do
-    expect(scope.function_pw_hash([nil, 'sha-512', 'salt'])).to eq(nil)
-  end
-
-  it "should raise an ArgumentError if the second argument is an invalid hash type" do
-    expect { scope.function_pw_hash(['', 'invalid', 'salt']) }.to( raise_error(ArgumentError, /not a valid hash type/) )
-  end
-
-  it "should raise an ArgumentError if the second argument is not a string" do
-    expect { scope.function_pw_hash(['', [], 'salt']) }.to( raise_error(ArgumentError, /second argument must be a string/) )
-  end
-
-  it "should raise an ArgumentError if the third argument is not a string" do
-    expect { scope.function_pw_hash(['password', 'sha-512', ['salt']]) }.to( raise_error(ArgumentError, /third argument must be a string/) )
-    # in Puppet 3, numbers are passed as strings, so we can't test that
-  end
-
-  it "should raise an ArgumentError if the third argument is empty" do
-    expect { scope.function_pw_hash(['password', 'sha-512', '']) }.to( raise_error(ArgumentError, /third argument must not be empty/) )
-  end
-
-  it "should raise an ArgumentError if the third argument has invalid characters" do
-    expect { scope.function_pw_hash(['password', 'sha-512', '%']) }.to( raise_error(ArgumentError, /characters in salt must be in the set/) )
-  end
-
-  it "should fail on platforms with weak implementations of String#crypt" do
-    String.any_instance.expects(:crypt).with('$1$1').returns('$1SoNol0Ye6Xk')
-    expect { scope.function_pw_hash(['password', 'sha-512', 'salt']) }.to( raise_error(Puppet::ParseError, /system does not support enhanced salts/) )
-  end
-
-  if @enhanced_salts_supported
-    describe "on systems with enhanced salts support" do
-      it "should return a hashed password" do
-        result = scope.function_pw_hash(['password', 'sha-512', 'salt'])
-        expect(result).to eql('$6$salt$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy.g.')
-      end
-
-      it "should use the specified salt" do
-        result = scope.function_pw_hash(['password', 'sha-512', 'salt'])
-        expect(result).to match('salt')
-      end
-
-      it "should use the specified hash type" do
-        resultmd5 = scope.function_pw_hash(['password', 'md5', 'salt'])
-        resultsha256 = scope.function_pw_hash(['password', 'sha-256', 'salt'])
-        resultsha512 = scope.function_pw_hash(['password', 'sha-512', 'salt'])
-
-        expect(resultmd5).to eql('$1$salt$qJH7.N4xYta3aEG/dfqo/0')
-        expect(resultsha256).to eql('$5$salt$Gcm6FsVtF/Qa77ZKD.iwsJlCVPY0XSMgLJL0Hnww/c1')
-        expect(resultsha512).to eql('$6$salt$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy.g.')
-      end
-
-      it "should generate a valid hash" do
-        password_hash = scope.function_pw_hash(['password', 'sha-512', 'salt'])
-
-        hash_parts = password_hash.match(%r{\A\$(.*)\$([a-zA-Z0-9./]+)\$([a-zA-Z0-9./]+)\z})
-
-        expect(hash_parts).not_to eql(nil)
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the range function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "exists" do
-    expect(Puppet::Parser::Functions.function("range")).to eq("function_range")
-  end
-
-  it "raises a ParseError if there is less than 1 arguments" do
-    expect { scope.function_range([]) }.to raise_error Puppet::ParseError, /Wrong number of arguments.*0 for 1/
-  end
-
-  describe 'with a letter range' do
-    it "returns a letter range" do
-      result = scope.function_range(["a","d"])
-      expect(result).to eq ['a','b','c','d']
-    end
-
-    it "returns a letter range given a step of 1" do
-      result = scope.function_range(["a","d","1"])
-      expect(result).to eq ['a','b','c','d']
-    end
-
-    it "returns a stepped letter range" do
-      result = scope.function_range(["a","d","2"])
-      expect(result).to eq ['a','c']
-    end
-
-    it "returns a stepped letter range given a negative step" do
-      result = scope.function_range(["a","d","-2"])
-      expect(result).to eq ['a','c']
-    end
-  end
-
-  describe 'with a number range' do
-    it "returns a number range" do
-      result = scope.function_range(["1","4"])
-      expect(result).to eq [1,2,3,4]
-    end
-
-    it "returns a number range given a step of 1" do
-      result = scope.function_range(["1","4","1"])
-      expect(result).to eq [1,2,3,4]
-    end
-
-    it "returns a stepped number range" do
-      result = scope.function_range(["1","4","2"])
-      expect(result).to eq [1,3]
-    end
-
-    it "returns a stepped number range given a negative step" do
-      result = scope.function_range(["1","4","-2"])
-      expect(result).to eq [1,3]
-    end
-  end
-
-  describe 'with a numeric-like string range' do
-    it "works with padded hostname like strings" do
-      expected = ("host01".."host10").to_a
-      expect(scope.function_range(["host01","host10"])).to eq expected
-    end
-
-    it "coerces zero padded digits to integers" do
-      expected = (0..10).to_a
-      expect(scope.function_range(["00", "10"])).to eq expected
-    end
-  end
-
-  describe 'with a numeric range' do
-    it "returns a range of numbers" do
-      expected = (1..10).to_a
-      expect(scope.function_range([1,10])).to eq expected
-    end
-    it "returns a range of numbers with step parameter" do
-      expected = (1..10).step(2).to_a
-      expect(scope.function_range([1,10,2])).to eq expected
-    end
-    it "works with mixed numeric like strings and numeric arguments" do
-      expected = (1..10).to_a
-      expect(scope.function_range(['1',10])).to eq expected
-      expect(scope.function_range([1,'10'])).to eq expected
-    end
-  end
-end