puppet-retrospec 0.12.1 → 0.12.2

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

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

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

@@ -1,39 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the ceiling function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("ceiling")).to eq("function_ceiling")
-  end
-
-  it "should raise a ParseError if there is less than 1 argument" do
-    expect { scope.function_ceiling([]) }.to( raise_error(Puppet::ParseError, /Wrong number of arguments/))
-  end
-
-  it "should should raise a ParseError if input isn't numeric (eg. String)" do
-    expect { scope.function_ceiling(["foo"]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
-  end
-
-  it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do
-    expect { scope.function_ceiling([true]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
-  end
-
-  it "should return an integer when a numeric type is passed" do
-    result = scope.function_ceiling([12.4])
-    expect(result.is_a?(Integer)).to(eq(true))
-  end
-
-  it "should return the input when an integer is passed" do
-    result = scope.function_ceiling([7])
-    expect(result).to(eq(7))
-  end
-
-  it "should return the smallest integer greater than or equal to the input" do
-    result = scope.function_ceiling([3.8])
-    expect(result).to(eq(4))
-  end
-end
-

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

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

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

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

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

@@ -1,50 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the concat function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should raise a ParseError if the client does not provide at least two arguments" do
-    expect { scope.function_concat([]) }.to(raise_error(Puppet::ParseError))
-    expect { scope.function_concat([[1]]) }.to(raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if the first parameter is not an array" do
-    expect { scope.function_concat([1, []])}.to(raise_error(Puppet::ParseError))
-  end
-
-  it "should not raise a ParseError if the client provides more than two arguments" do
-    expect { scope.function_concat([[1],[2],[3]]) }.not_to raise_error
-  end
-
-  it "should be able to concat an array" do
-    result = scope.function_concat([['1','2','3'],['4','5','6']])
-    expect(result).to(eq(['1','2','3','4','5','6']))
-  end
-
-  it "should be able to concat a primitive to an array" do
-    result = scope.function_concat([['1','2','3'],'4'])
-    expect(result).to(eq(['1','2','3','4']))
-  end
-
-  it "should not accidentally flatten nested arrays" do
-    result = scope.function_concat([['1','2','3'],[['4','5'],'6']])
-    expect(result).to(eq(['1','2','3',['4','5'],'6']))
-  end
-
-  it "should leave the original array intact" do
-    array_original = ['1','2','3']
-    result = scope.function_concat([array_original,['4','5','6']])
-    array_original.should(eq(['1','2','3']))
-  end
-
-  it "should be able to concat multiple arrays" do
-    result = scope.function_concat([['1','2','3'],['4','5','6'],['7','8','9']])
-    expect(result).to(eq(['1','2','3','4','5','6','7','8','9']))
-  end
-
-  it "should be able to concat mix of primitives and arrays to a final array" do
-    result = scope.function_concat([['1','2','3'],'4',['5','6','7']])
-    expect(result).to(eq(['1','2','3','4','5','6','7']))
-  end
-end

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

@@ -1,31 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the count function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("count")).to eq("function_count")
-  end
-
-  it "should raise a ArgumentError if there is more than 2 arguments" do
-    expect { scope.function_count(['foo', 'bar', 'baz']) }.to( raise_error(ArgumentError))
-  end
-
-  it "should be able to count arrays" do
-    expect(scope.function_count([["1","2","3"]])).to(eq(3))
-  end
-
-  it "should be able to count matching elements in arrays" do
-    expect(scope.function_count([["1", "2", "2"], "2"])).to(eq(2))
-  end
-
-  it "should not count nil or empty strings" do
-    expect(scope.function_count([["foo","bar",nil,""]])).to(eq(2))
-  end
-
-  it 'does not count an undefined hash key or an out of bound array index (which are both :undef)' do
-    expect(scope.function_count([["foo",:undef,:undef]])).to eq(1)
-  end
-end

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

@@ -1,105 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:deep_merge) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  describe 'when calling deep_merge from puppet' do
-    it "should not compile when no arguments are passed" do
-      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
-      Puppet[:code] = '$x = deep_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
-      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
-      Puppet[:code] = "$my_hash={'one' => 1}\n$x = deep_merge($my_hash)"
-      expect {
-        scope.compiler.compile
-      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
-    end
-  end
-
-  describe 'when calling deep_merge on the scope instance' do
-    it 'should require all parameters are hashes' do
-      expect { new_hash = scope.function_deep_merge([{}, '2'])}.to raise_error(Puppet::ParseError, /unexpected argument type String/)
-      expect { new_hash = scope.function_deep_merge([{}, 2])}.to raise_error(Puppet::ParseError, /unexpected argument type Fixnum/)
-    end
-
-    it 'should accept empty strings as puppet undef' do
-      expect { new_hash = scope.function_deep_merge([{}, ''])}.not_to raise_error
-    end
-
-    it 'should be able to deep_merge two hashes' do
-      new_hash = scope.function_deep_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
-      expect(new_hash['one']).to   eq('1')
-      expect(new_hash['two']).to   eq('2')
-      expect(new_hash['three']).to eq('2')
-    end
-
-    it 'should deep_merge multiple hashes' do
-      hash = scope.function_deep_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
-      expect(hash['one']).to eq('3')
-    end
-
-    it 'should accept empty hashes' do
-      expect(scope.function_deep_merge([{},{},{}])).to eq({})
-    end
-
-    it 'should deep_merge subhashes' do
-      hash = scope.function_deep_merge([{'one' => 1}, {'two' => 2, 'three' => { 'four' => 4 } }])
-      expect(hash['one']).to eq(1)
-      expect(hash['two']).to eq(2)
-      expect(hash['three']).to eq({ 'four' => 4 })
-    end
-
-    it 'should append to subhashes' do
-      hash = scope.function_deep_merge([{'one' => { 'two' => 2 } }, { 'one' => { 'three' => 3 } }])
-      expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
-    end
-
-    it 'should append to subhashes 2' do
-      hash = scope.function_deep_merge([{'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }, {'two' => 'dos', 'three' => { 'five' => 5 } }])
-      expect(hash['one']).to eq(1)
-      expect(hash['two']).to eq('dos')
-      expect(hash['three']).to eq({ 'four' => 4, 'five' => 5 })
-    end
-
-    it 'should append to subhashes 3' do
-      hash = scope.function_deep_merge([{ 'key1' => { 'a' => 1, 'b' => 2 }, 'key2' => { 'c' => 3 } }, { 'key1' => { 'b' => 99 } }])
-      expect(hash['key1']).to eq({ 'a' => 1, 'b' => 99 })
-      expect(hash['key2']).to eq({ 'c' => 3 })
-    end
-
-    it 'should not change the original hashes' do
-      hash1 = {'one' => { 'two' => 2 } }
-      hash2 = { 'one' => { 'three' => 3 } }
-      hash = scope.function_deep_merge([hash1, hash2])
-      expect(hash1).to eq({'one' => { 'two' => 2 } })
-      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
-      expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
-    end
-
-    it 'should not change the original hashes 2' do
-      hash1 = {'one' => { 'two' => [1,2] } }
-      hash2 = { 'one' => { 'three' => 3 } }
-      hash = scope.function_deep_merge([hash1, hash2])
-      expect(hash1).to eq({'one' => { 'two' => [1,2] } })
-      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
-      expect(hash['one']).to eq({ 'two' => [1,2], 'three' => 3 })
-    end
-
-    it 'should not change the original hashes 3' do
-      hash1 = {'one' => { 'two' => [1,2, {'two' => 2} ] } }
-      hash2 = { 'one' => { 'three' => 3 } }
-      hash = scope.function_deep_merge([hash1, hash2])
-      expect(hash1).to eq({'one' => { 'two' => [1,2, {'two' => 2}] } })
-      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
-      expect(hash['one']).to eq({ 'two' => [1,2, {'two' => 2} ], 'three' => 3 })
-      expect(hash['one']['two']).to eq([1,2, {'two' => 2}])
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-require 'rspec-puppet'
-describe 'defined_with_params' do
-  describe 'when a resource is not specified' do
-    it { is_expected.to run.with_params().and_raise_error(ArgumentError) }
-  end
-  describe 'when compared against a resource with no attributes' do
-    let :pre_condition do
-      'user { "dan": }'
-    end
-    it do
-      is_expected.to run.with_params('User[dan]', {}).and_return(true)
-      is_expected.to run.with_params('User[bob]', {}).and_return(false)
-      is_expected.to run.with_params('User[dan]', {'foo' => 'bar'}).and_return(false)
-    end
-  end
-
-  describe 'when compared against a resource with attributes' do
-    let :pre_condition do
-      'user { "dan": ensure => present, shell => "/bin/csh", managehome => false}'
-    end
-    it do
-      is_expected.to run.with_params('User[dan]', {}).and_return(true)
-      is_expected.to run.with_params('User[dan]', '').and_return(true)
-      is_expected.to run.with_params('User[dan]', {'ensure' => 'present'}
-                            ).and_return(true)
-      is_expected.to run.with_params('User[dan]',
-                             {'ensure' => 'present', 'managehome' => false}
-                            ).and_return(true)
-      is_expected.to run.with_params('User[dan]',
-                             {'ensure' => 'absent', 'managehome' => false}
-                            ).and_return(false)
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the delete_at function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("delete_at")).to eq("function_delete_at")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_delete_at([]) }.to( 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])
-    expect(result).to(eq(['a','c']))
-  end
-
-  it "should not change origin array passed as argument" do
-    origin_array = ['a','b','c','d']
-    result = scope.function_delete_at([origin_array, 1])
-    expect(origin_array).to(eq(['a','b','c','d']))
-  end
-end

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

@@ -1,61 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the delete function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("delete")).to eq("function_delete")
-  end
-
-  it "should raise a ParseError if there are fewer than 2 arguments" do
-    expect { scope.function_delete([]) }.to(raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are greater than 2 arguments" do
-    expect { scope.function_delete([[], 'foo', 'bar']) }.to(raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a TypeError if a number is passed as the first argument" do
-    expect { scope.function_delete([1, 'bar']) }.to(raise_error(TypeError))
-  end
-
-  it "should delete all instances of an element from an array" do
-    result = scope.function_delete([['a', 'b', 'c', 'b'], 'b'])
-    expect(result).to(eq(['a', 'c']))
-  end
-
-  it "should delete all instances of a substring from a string" do
-    result = scope.function_delete(['foobarbabarz', 'bar'])
-    expect(result).to(eq('foobaz'))
-  end
-
-  it "should delete a key from a hash" do
-    result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, 'b'])
-    expect(result).to(eq({'a' => 1, 'c' => 3}))
-  end
-
-  it 'should accept an array of items to delete' do
-    result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, ['b', 'c']])
-    expect(result).to(eq({'a' => 1}))
-  end
-
-  it "should not change origin array passed as argument" do
-    origin_array = ['a', 'b', 'c', 'd']
-    result = scope.function_delete([origin_array, 'b'])
-    expect(origin_array).to(eq(['a', 'b', 'c', 'd']))
-  end
-
-  it "should not change the origin string passed as argument" do
-    origin_string = 'foobarbabarz'
-    result = scope.function_delete([origin_string, 'bar'])
-    expect(origin_string).to(eq('foobarbabarz'))
-  end
-
-  it "should not change origin hash passed as argument" do
-    origin_hash = {'a' => 1, 'b' => 2, 'c' => 3}
-    result = scope.function_delete([origin_hash, 'b'])
-    expect(origin_hash).to(eq({'a' => 1, 'b' => 2, 'c' => 3}))
-  end
-
-end