puppetmodule-stdlib 4.0.1

data/spec/functions/defined_with_params_spec.rb

@@ -0,0 +1,37 @@
+#! /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 { should 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
+      should run.with_params('User[dan]', {}).and_return(true)
+      should run.with_params('User[bob]', {}).and_return(false)
+      should 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
+      should run.with_params('User[dan]', {}).and_return(true)
+      should run.with_params('User[dan]', '').and_return(true)
+      should run.with_params('User[dan]', {'ensure' => 'present'}
+                            ).and_return(true)
+      should run.with_params('User[dan]',
+                             {'ensure' => 'present', 'managehome' => false}
+                            ).and_return(true)
+      should run.with_params('User[dan]',
+                             {'ensure' => 'absent', 'managehome' => false}
+                            ).and_return(false)
+    end
+  end
+end

data/spec/functions/ensure_packages_spec.rb

@@ -0,0 +1,42 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'rspec-puppet'
+
+describe 'ensure_packages' do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  describe 'argument handling' do
+    it 'fails with no arguments' do
+      should run.with_params().and_raise_error(Puppet::ParseError)
+    end
+    it 'requires an array' do
+      lambda { scope.function_ensure_packages([['foo']]) }.should_not raise_error
+    end
+    it 'fails when given a string' do
+      should run.with_params('foo').and_raise_error(Puppet::ParseError)
+    end
+  end
+
+  context 'given a catalog containing Package[puppet]{ensure => absent}' do
+    let :pre_condition do
+      'package { puppet: ensure => absent }'
+    end
+
+    # NOTE: should run.with_params has the side effect of making the compiler
+    # available to the test harness.
+    it 'has no effect on Package[puppet]' do
+      should run.with_params(['puppet'])
+      rsrc = compiler.catalog.resource('Package[puppet]')
+      rsrc.to_hash.should == {:ensure => "absent"}
+    end
+  end
+
+  context 'given a clean catalog' do
+    it 'declares package resources with ensure => present' do
+      should run.with_params(['facter'])
+      rsrc = compiler.catalog.resource('Package[facter]')
+      rsrc.to_hash.should == {:name => "facter", :ensure => "present"}
+    end
+  end
+end

data/spec/functions/ensure_resource_spec.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+require 'rspec-puppet'
+describe 'ensure_resource' do
+  describe 'when a type or title is not specified' do
+    it do
+      should run.with_params().and_raise_error(ArgumentError)
+      should run.with_params(['type']).and_raise_error(ArgumentError)
+    end
+  end
+  describe 'when compared against a resource with no attributes' do
+    let :pre_condition do
+      'user { "dan": }'
+    end
+    it do
+      should run.with_params('user', 'dan', {})
+      compiler.catalog.resource('User[dan]').to_s.should == 'User[dan]'
+    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
+      # these first three should not fail
+      should run.with_params('User', 'dan', {})
+      should run.with_params('User', 'dan', '')
+      should run.with_params('User', 'dan', {'ensure' => 'present'})
+      should run.with_params('User', 'dan',
+                             {'ensure' => 'present', 'managehome' => false}
+                            )
+      #  test that this fails
+      should run.with_params('User', 'dan',
+                             {'ensure' => 'absent', 'managehome' => false}
+                            ).and_raise_error(Puppet::Error)
+    end
+  end
+end

data/spec/functions/getparam_spec.rb

@@ -0,0 +1,34 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+require 'rspec-puppet'
+describe 'getparam' do
+  describe 'when a resource is not specified' do
+    it do
+      should run.with_params().and_raise_error(ArgumentError)
+      should run.with_params('User[dan]').and_raise_error(ArgumentError)
+      should run.with_params('User[dan]', {}).and_raise_error(ArgumentError)
+      should run.with_params('User[dan]', '').and_return('')
+    end
+  end
+  describe 'when compared against a resource with no params' do
+    let :pre_condition do
+      'user { "dan": }'
+    end
+    it do
+      should run.with_params('User[dan]', 'shell').and_return('')
+    end
+  end
+
+  describe 'when compared against a resource with params' do
+    let :pre_condition do
+      'user { "dan": ensure => present, shell => "/bin/sh", managehome => false}'
+    end
+    it do
+      should run.with_params('User[dan]', 'shell').and_return('/bin/sh')
+      should run.with_params('User[dan]', '').and_return('')
+      should run.with_params('User[dan]', 'ensure').and_return('present')
+      should run.with_params('User[dan]', 'managehome').and_return(false)
+    end
+  end
+end

data/spec/monkey_patches/alias_should_to_must.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+
+class Object
+  # This is necessary because the RAL has a 'should'
+  # method.
+  alias :must :should
+  alias :must_not :should_not
+end

data/spec/monkey_patches/publicize_methods.rb

@@ -0,0 +1,10 @@
+# Some monkey-patching to allow us to test private methods.
+class Class
+    def publicize_methods(*methods)
+        saved_private_instance_methods = methods.empty? ? self.private_instance_methods : methods
+
+        self.class_eval { public(*saved_private_instance_methods) }
+        yield
+        self.class_eval { private(*saved_private_instance_methods) }
+    end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--format
+s
+--colour
+--loadby
+mtime
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+# Don't want puppet getting the command line arguments for rake or autotest
+ARGV.clear
+
+require 'puppet'
+require 'facter'
+require 'mocha'
+gem 'rspec', '>=2.0.0'
+require 'rspec/expectations'
+
+require 'puppetlabs_spec_helper/module_spec_helper'
+
+RSpec.configure do |config|
+  # FIXME REVISIT - We may want to delegate to Facter like we do in
+  # Puppet::PuppetSpecInitializer.initialize_via_testhelper(config) because
+  # this behavior is a duplication of the spec_helper in Facter.
+  config.before :each do
+    # Ensure that we don't accidentally cache facts and environment between
+    # test cases.  This requires each example group to explicitly load the
+    # facts being exercised with something like
+    # Facter.collection.loader.load(:ipaddress)
+    Facter::Util::Loader.any_instance.stubs(:load_all)
+    Facter.clear
+    Facter.clear_messages
+  end
+end

data/spec/unit/facter/pe_version_spec.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe "PE Version specs" do
+  before :each do
+    # Explicitly load the pe_version.rb file which contains generated facts
+    # that cannot be automatically loaded.  Puppet 2.x implements
+    # Facter.collection.load while Facter 1.x markes Facter.collection.load as
+    # a private method.
+    if Facter.collection.respond_to? :load
+      Facter.collection.load(:pe_version)
+    else
+      Facter.collection.loader.load(:pe_version)
+    end
+  end
+
+  context "If PE is installed" do
+    %w{ 2.6.1 2.10.300 }.each do |version|
+      puppetversion = "2.7.19 (Puppet Enterprise #{version})"
+      context "puppetversion => #{puppetversion}" do
+        before :each do
+          Facter.fact(:puppetversion).stubs(:value).returns(puppetversion)
+        end
+
+        (major,minor,patch) = version.split(".")
+
+        it "Should return true" do
+          Facter.fact(:is_pe).value.should == true
+        end
+
+        it "Should have a version of #{version}" do
+          Facter.fact(:pe_version).value.should == version
+        end
+
+        it "Should have a major version of #{major}" do
+          Facter.fact(:pe_major_version).value.should == major
+        end
+
+        it "Should have a minor version of #{minor}" do
+          Facter.fact(:pe_minor_version).value.should == minor
+        end
+
+        it "Should have a patch version of #{patch}" do
+          Facter.fact(:pe_patch_version).value.should == patch
+        end
+      end
+    end
+  end
+
+  context "When PE is not installed" do
+    before :each do
+      Facter.fact(:puppetversion).stubs(:value).returns("2.7.19")
+    end
+
+    it "is_pe is false" do
+      Facter.fact(:is_pe).value.should == false
+    end
+
+    it "pe_version is nil" do
+      Facter.fact(:pe_version).value.should be_nil
+    end
+
+    it "pe_major_version is nil" do
+      Facter.fact(:pe_major_version).value.should be_nil
+    end
+
+    it "pe_minor_version is nil" do
+      Facter.fact(:pe_minor_version).value.should be_nil
+    end
+
+    it "Should have a patch version" do
+      Facter.fact(:pe_patch_version).value.should be_nil
+    end
+  end
+end

data/spec/unit/facter/root_home_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'facter/root_home'
+
+describe Facter::Util::RootHome do
+  context "solaris" do
+    let(:root_ent) { "root:x:0:0:Super-User:/:/sbin/sh" }
+    let(:expected_root_home) { "/" }
+
+    it "should return /" do
+      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
+      Facter::Util::RootHome.get_root_home.should == expected_root_home
+    end
+  end
+  context "linux" do
+    let(:root_ent) { "root:x:0:0:root:/root:/bin/bash" }
+    let(:expected_root_home) { "/root" }
+
+    it "should return /root" do
+      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
+      Facter::Util::RootHome.get_root_home.should == expected_root_home
+    end
+  end
+  context "macosx" do
+    let(:root_ent) { "root:*:0:0:System Administrator:/var/root:/bin/sh" }
+    let(:expected_root_home) { "/var/root" }
+
+    it "should return /var/root" do
+      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
+      Facter::Util::RootHome.get_root_home.should == expected_root_home
+    end
+  end
+  context "windows" do
+    before :each do
+      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil)
+    end
+    it "should be nil on windows" do
+      Facter::Util::RootHome.get_root_home.should be_nil
+    end
+  end
+end

data/spec/unit/facter/util/puppet_settings_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'facter/util/puppet_settings'
+
+describe Facter::Util::PuppetSettings do
+
+  describe "#with_puppet" do
+    context "Without Puppet loaded" do
+      before(:each) do
+        Module.expects(:const_get).with("Puppet").raises(NameError)
+      end
+
+      it 'should be nil' do
+        subject.with_puppet { Puppet[:vardir] }.should be_nil
+      end
+      it 'should not yield to the block' do
+        Puppet.expects(:[]).never
+        subject.with_puppet { Puppet[:vardir] }.should be_nil
+      end
+    end
+    context "With Puppet loaded" do
+      module Puppet; end
+      let(:vardir) { "/var/lib/puppet" }
+
+      before :each do
+        Puppet.expects(:[]).with(:vardir).returns vardir
+      end
+      it 'should yield to the block' do
+        subject.with_puppet { Puppet[:vardir] }
+      end
+      it 'should return the nodes vardir' do
+        subject.with_puppet { Puppet[:vardir] }.should eq vardir
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the abs function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("abs").should == "function_abs"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should convert a negative number into a positive" do
+    result = scope.function_abs(["-34"])
+    result.should(eq(34))
+  end
+
+  it "should do nothing with a positive number" do
+    result = scope.function_abs(["5678"])
+    result.should(eq(5678))
+  end
+end

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

@@ -0,0 +1,55 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the any2array function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("any2array").should == "function_any2array"
+  end
+
+  it "should return an empty array if there is less than 1 argument" do
+    result = scope.function_any2array([])
+    result.should(eq([]))
+  end
+
+  it "should convert boolean true to [ true ] " do
+    result = scope.function_any2array([true])
+    result.should(eq([true]))
+  end
+
+  it "should convert one object to [object]" do
+    result = scope.function_any2array(['one'])
+    result.should(eq(['one']))
+  end
+
+  it "should convert multiple objects to [objects]" do
+    result = scope.function_any2array(['one', 'two'])
+    result.should(eq(['one', 'two']))
+  end
+
+  it "should return empty array it was called with" do
+    result = scope.function_any2array([[]])
+    result.should(eq([]))
+  end
+
+  it "should return one-member array it was called with" do
+    result = scope.function_any2array([['string']])
+    result.should(eq(['string']))
+  end
+
+  it "should return multi-member array it was called with" do
+    result = scope.function_any2array([['one', 'two']])
+    result.should(eq(['one', 'two']))
+  end
+
+  it "should return members of a hash it was called with" do
+    result = scope.function_any2array([{ 'key' => 'value' }])
+    result.should(eq(['key', 'value']))
+  end
+
+  it "should return an empty array if it was called with an empty hash" do
+    result = scope.function_any2array([{ }])
+    result.should(eq([]))
+  end
+end