puppet-retrospec 0.12.1 → 0.12.2

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

@@ -1,41 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the delete_undef_values function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("delete_undef_values")).to eq("function_delete_undef_values")
-  end
-
-  it "should raise a ParseError if there is less than 1 argument" do
-    expect { scope.function_delete_undef_values([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if the argument is not Array nor Hash" do
-    expect { scope.function_delete_undef_values(['']) }.to( raise_error(Puppet::ParseError))
-    expect { scope.function_delete_undef_values([nil]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should delete all undef items from Array and only these" do
-    result = scope.function_delete_undef_values([['a',:undef,'c','undef']])
-    expect(result).to(eq(['a','c','undef']))
-  end
-
-  it "should delete all undef items from Hash and only these" do
-    result = scope.function_delete_undef_values([{'a'=>'A','b'=>:undef,'c'=>'C','d'=>'undef'}])
-    expect(result).to(eq({'a'=>'A','c'=>'C','d'=>'undef'}))
-  end
-
-  it "should not change origin array passed as argument" do
-    origin_array = ['a',:undef,'c','undef']
-    result = scope.function_delete_undef_values([origin_array])
-    expect(origin_array).to(eq(['a',:undef,'c','undef']))
-  end
-
-  it "should not change origin hash passed as argument" do
-    origin_hash = { 'a' => 1, 'b' => :undef, 'c' => 'undef' }
-    result = scope.function_delete_undef_values([origin_hash])
-    expect(origin_hash).to(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' }))
-  end
-end

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

@@ -1,36 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the delete_values function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("delete_values")).to eq("function_delete_values")
-  end
-
-  it "should raise a ParseError if there are fewer than 2 arguments" do
-    expect { scope.function_delete_values([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are greater than 2 arguments" do
-    expect { scope.function_delete_values([[], 'foo', 'bar']) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a TypeError if the argument is not a hash" do
-    expect { scope.function_delete_values([1,'bar']) }.to( raise_error(TypeError))
-    expect { scope.function_delete_values(['foo','bar']) }.to( raise_error(TypeError))
-    expect { scope.function_delete_values([[],'bar']) }.to( raise_error(TypeError))
-  end
-
-  it "should delete all instances of a value from a hash" do
-    result = scope.function_delete_values([{ 'a'=>'A', 'b'=>'B', 'B'=>'C', 'd'=>'B' },'B'])
-    expect(result).to(eq({ 'a'=>'A', 'B'=>'C' }))
-  end
-
-  it "should not change origin hash passed as argument" do
-    origin_hash = { 'a' => 1, 'b' => 2, 'c' => 3 }
-    result = scope.function_delete_values([origin_hash, 2])
-    expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
-  end
-
-end

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

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the difference function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("difference")).to eq("function_difference")
-  end
-
-  it "should raise a ParseError if there are fewer than 2 arguments" do
-    expect { scope.function_difference([]) }.to( raise_error(Puppet::ParseError) )
-  end
-
-  it "should return the difference between two arrays" do
-    result = scope.function_difference([["a","b","c"],["b","c","d"]])
-    expect(result).to(eq(["a"]))
-  end
-end

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

@@ -1,38 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the dirname function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("dirname")).to eq("function_dirname")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_dirname([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there is more than 1 argument" do
-    expect { scope.function_dirname(['a', 'b']) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should return dirname for an absolute path" do
-    result = scope.function_dirname(['/path/to/a/file.ext'])
-    expect(result).to(eq('/path/to/a'))
-  end
-
-  it "should return dirname for a relative path" do
-    result = scope.function_dirname(['path/to/a/file.ext'])
-    expect(result).to(eq('path/to/a'))
-  end
-
-  it "should complain about hash argument" do
-    expect { scope.function_dirname([{}]) }.to( raise_error(Puppet::ParseError))
-  end
-  it "should complain about list argument" do
-    expect { scope.function_dirname([[]]) }.to( raise_error(Puppet::ParseError))
-  end
-  it "should complain about numeric argument" do
-    expect { scope.function_dirname([2112]) }.to( raise_error(Puppet::ParseError))
-  end
-end

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

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

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

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

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

@@ -1,81 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'rspec-puppet'
-require 'puppet_spec/compiler'
-
-describe 'ensure_packages' do
-  include PuppetSpec::Compiler
-
-  before :each do
-    Puppet::Parser::Functions.autoloader.loadall
-    Puppet::Parser::Functions.function(:ensure_packages)
-    Puppet::Parser::Functions.function(:ensure_resource)
-    Puppet::Parser::Functions.function(:defined_with_params)
-    Puppet::Parser::Functions.function(:create_resources)
-  end
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do
-    if Puppet.version.to_f >= 3.0
-      Puppet::Parser::Scope.new(compiler)
-    else
-      newscope = Puppet::Parser::Scope.new
-      newscope.compiler = compiler
-      newscope.source   = Puppet::Resource::Type.new(:node, :localhost)
-      newscope
-    end
-  end
-
-  describe 'argument handling' do
-    it 'fails with no arguments' do
-      expect {
-        scope.function_ensure_packages([])
-      }.to raise_error(Puppet::ParseError, /0 for 1 or 2/)
-    end
-
-    it 'accepts an array of values' do
-      scope.function_ensure_packages([['foo']])
-    end
-
-    it 'accepts a single package name as a string' do
-      scope.function_ensure_packages(['foo'])
-    end
-  end
-
-  context 'given a catalog with puppet package => absent' do
-    let :catalog do
-      compile_to_catalog(<<-EOS
-        ensure_packages(['facter'])
-        package { puppet: ensure => absent }
-      EOS
-      )
-    end
-
-    it 'has no effect on Package[puppet]' do
-      expect(catalog.resource(:package, 'puppet')['ensure']).to eq('absent')
-    end
-  end
-
-  context 'given a clean catalog' do
-    let :catalog do
-      compile_to_catalog('ensure_packages(["facter"])')
-    end
-
-    it 'declares package resources with ensure => present' do
-      expect(catalog.resource(:package, 'facter')['ensure']).to eq('present')
-    end
-  end
-
-  context 'given a clean catalog and specified defaults' do
-    let :catalog do
-      compile_to_catalog('ensure_packages(["facter"], {"provider" => "gem"})')
-    end
-
-    it 'declares package resources with ensure => present' do
-      expect(catalog.resource(:package, 'facter')['ensure']).to eq('present')
-      expect(catalog.resource(:package, 'facter')['provider']).to eq('gem')
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'rspec-puppet'
-require 'puppet_spec/compiler'
-
-describe 'ensure_resource' do
-  include PuppetSpec::Compiler
-
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-    Puppet::Parser::Functions.function(:ensure_packages)
-  end
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  describe 'when a type or title is not specified' do
-    it { expect { scope.function_ensure_resource([]) }.to raise_error }
-    it { expect { scope.function_ensure_resource(['type']) }.to raise_error }
-  end
-
-  describe 'when compared against a resource with no attributes' do
-    let :catalog do
-      compile_to_catalog(<<-EOS
-        user { "dan": }
-        ensure_resource('user', 'dan', {})
-      EOS
-      )
-    end
-
-    it 'should contain the the ensured resources' do
-      expect(catalog.resource(:user, 'dan').to_s).to eq('User[dan]')
-    end
-  end
-
-  describe 'works when compared against a resource with non-conflicting attributes' do
-    [
-      "ensure_resource('User', 'dan', {})",
-      "ensure_resource('User', 'dan', '')",
-      "ensure_resource('User', 'dan', {'ensure' => 'present'})",
-      "ensure_resource('User', 'dan', {'ensure' => 'present', 'managehome' => false})"
-    ].each do |ensure_resource|
-      pp = <<-EOS
-        user { "dan": ensure => present, shell => "/bin/csh", managehome => false}
-        #{ensure_resource}
-      EOS
-
-      it { expect { compile_to_catalog(pp) }.to_not raise_error }
-    end
-  end
-
-  describe 'fails when compared against a resource with conflicting attributes' do
-    pp = <<-EOS
-      user { "dan": ensure => present, shell => "/bin/csh", managehome => false}
-      ensure_resource('User', 'dan', {'ensure' => 'absent', 'managehome' => false})
-    EOS
-
-    it { expect { compile_to_catalog(pp) }.to raise_error }
-  end
-
-  describe 'when an array of new resources are passed in' do
-    let :catalog do
-      compile_to_catalog("ensure_resource('User', ['dan', 'alex'], {})")
-    end
-
-    it 'should contain the ensured resources' do
-      expect(catalog.resource('User[dan]').to_s).to eq('User[dan]')
-      expect(catalog.resource('User[alex]').to_s).to eq('User[alex]')
-    end
-  end
-
-  describe 'when an array of existing resources is compared against existing resources' do
-    pp = <<-EOS
-      user { 'dan': ensure => present; 'alex': ensure => present }
-      ensure_resource('User', ['dan', 'alex'], {})
-    EOS
-
-    let :catalog do
-      compile_to_catalog(pp)
-    end
-
-    it 'should return the existing resources' do
-      expect(catalog.resource('User[dan]').to_s).to eq('User[dan]')
-      expect(catalog.resource('User[alex]').to_s).to eq('User[alex]')
-    end
-  end
-
-  describe 'works when compared against existing resources with attributes' do
-    [
-      "ensure_resource('User', ['dan', 'alex'], {})",
-      "ensure_resource('User', ['dan', 'alex'], '')",
-      "ensure_resource('User', ['dan', 'alex'], {'ensure' => 'present'})",
-    ].each do |ensure_resource|
-      pp = <<-EOS
-        user { 'dan': ensure => present; 'alex': ensure => present }
-        #{ensure_resource}
-      EOS
-
-      it { expect { compile_to_catalog(pp) }.to_not raise_error }
-    end
-  end
-
-  describe 'fails when compared against existing resources with conflicting attributes' do
-    pp = <<-EOS
-      user { 'dan': ensure => present; 'alex': ensure => present }
-      ensure_resource('User', ['dan', 'alex'], {'ensure' => 'absent'})
-    EOS
-
-    it { expect { compile_to_catalog(pp) }.to raise_error }
-  end
-
-end

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

@@ -1,27 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the flatten function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("flatten")).to eq("function_flatten")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_flatten([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there is more than 1 argument" do
-    expect { scope.function_flatten([[], []]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should flatten a complex data structure" do
-    result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
-    expect(result).to(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"]])
-    expect(result).to(eq(["a","b","c","d"]))
-  end
-end

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

@@ -1,39 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the floor function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("floor")).to eq("function_floor")
-  end
-
-  it "should raise a ParseError if there is less than 1 argument" do
-    expect { scope.function_floor([]) }.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_floor(["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_floor([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_floor([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_floor([7])
-    expect(result).to(eq(7))
-  end
-
-  it "should return the largest integer less than or equal to the input" do
-    result = scope.function_floor([3.8])
-    expect(result).to(eq(3))
-  end
-end
-