puppet 0.24.6 → 0.24.7

data/spec/unit/type/mcx.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+#--
+# Copyright (C) 2008 Jeffrey J McCune.
+
+# This program and entire repository is free software; you can
+# redistribute it and/or modify it under the terms of the GNU 
+# General Public License as published by the Free Software 
+# Foundation; either version 2 of the License, or any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+# Author: Jeff McCune <mccune.jeff@gmail.com>
+
+# Most of this code copied from /spec/type/service.rb
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/type/mcx'
+
+mcx_type = Puppet::Type.type(:mcx)
+
+describe mcx_type, "when validating attributes" do
+
+    properties = [:ensure, :content]
+    parameters = [:name, :ds_type, :ds_name]
+
+    parameters.each do |p|
+        it "should have a #{p} parameter" do
+            mcx_type.attrclass(p).ancestors.should be_include(Puppet::Parameter)
+        end
+        it "should have documentation for its #{p} parameter" do
+            mcx_type.attrclass(p).doc.should be_instance_of(String)
+        end
+    end
+
+    properties.each do |p|
+        it "should have a #{p} property" do
+            mcx_type.attrclass(p).ancestors.should be_include(Puppet::Property)
+        end
+        it "should have documentation for its #{p} property" do
+            mcx_type.attrclass(p).doc.should be_instance_of(String)
+        end
+    end
+
+end
+
+describe mcx_type, "default values" do
+
+    before :each do
+        provider_class = mcx_type.provider(mcx_type.providers[0])
+        mcx_type.stubs(:defaultprovider).returns provider_class
+    end
+
+    after :each do
+        mcx_type.clear
+    end
+
+    it "should be nil for :ds_type" do
+        mcx_type.create(:name => '/Foo/bar')[:ds_type].should be_nil
+    end
+
+    it "should be nil for :ds_name" do
+        mcx_type.create(:name => '/Foo/bar')[:ds_name].should be_nil
+    end
+
+    it "should be nil for :content" do
+        mcx_type.create(:name => '/Foo/bar')[:content].should be_nil
+    end
+
+end
+
+describe mcx_type, "when validating properties" do
+
+    before :each do
+        provider_class = mcx_type.provider(mcx_type.providers[0])
+        mcx_type.stubs(:defaultprovider).returns provider_class
+    end
+
+    after :each do
+        mcx_type.clear
+    end
+
+    it "should be able to create an instance" do
+        lambda {
+            mcx_type.create(:name => '/Foo/bar')
+        }.should_not raise_error
+    end
+
+    it "should support :present as a value to :ensure" do
+        lambda {
+            mcx_type.create(:name => "/Foo/bar", :ensure => :present)
+        }.should_not raise_error
+    end
+
+    it "should support :absent as a value to :ensure" do
+        lambda {
+            mcx_type.create(:name => "/Foo/bar", :ensure => :absent)
+        }.should_not raise_error
+    end
+
+end

data/spec/unit/type/mount.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:mount) do
+    it "should have a :refreshable feature that requires the :remount method" do
+        Puppet::Type.type(:mount).provider_feature(:refreshable).methods.should == [:remount]
+    end
+
+    it "should have no default value for :ensure" do
+        mount = Puppet::Type.type(:mount).create(:name => "yay")
+        mount.should(:ensure).should be_nil
+    end
+
+    after { Puppet::Type.type(:mount).clear }
+end
+
+describe Puppet::Type.type(:mount), "when validating attributes" do
+    [:name, :remounts].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type.type(:mount).attrtype(param).should == :param
+        end
+    end
+
+    [:ensure, :device, :blockdevice, :fstype, :options, :pass, :dump, :atboot, :target].each do |param|
+        it "should have a #{param} property" do
+            Puppet::Type.type(:mount).attrtype(param).should == :property
+        end
+    end
+end
+
+describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil
+        Puppet::Type.type(:mount).defaultprovider.expects(:new).returns(@provider)
+    end
+
+    it "should support :present as a value to :ensure" do
+        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :present)
+    end
+
+    it "should alias :unmounted to :present as a value to :ensure" do
+        mount = Puppet::Type.type(:mount).create(:name => "yay", :ensure => :unmounted)
+        mount.should(:ensure).should == :present
+    end
+
+    it "should support :absent as a value to :ensure" do
+        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :absent)
+    end
+
+    it "should support :mounted as a value to :ensure" do
+        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :mounted)
+    end
+
+    after { Puppet::Type.type(:mount).clear }
+end
+
+describe Puppet::Type.type(:mount)::Ensure do
+    before :each do
+        @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
+        Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
+        @mount = Puppet::Type.type(:mount).create(:name => "yay", :check => :ensure)
+
+        @ensure = @mount.property(:ensure)
+    end
+
+    after :each do
+        Puppet::Type.type(:mount).clear
+    end
+    
+    def mount_stub(params)
+        Puppet::Type.type(:mount).validproperties.each do |prop|
+            unless params[prop]
+                params[prop] = :absent
+                @mount[prop] = :absent
+            end
+        end
+
+        params.each do |param, value|
+            @provider.stubs(param).returns(value)
+        end
+    end
+
+    describe Puppet::Type.type(:mount)::Ensure, "when retrieving its current state" do
+
+        it "should return the provider's value if it is :absent" do
+            @provider.expects(:ensure).returns(:absent)
+            @ensure.retrieve.should == :absent
+        end
+
+        it "should return :mounted if the provider indicates it is mounted and the value is not :absent" do
+            @provider.expects(:ensure).returns(:present)
+            @provider.expects(:mounted?).returns(true)
+            @ensure.retrieve.should == :mounted
+        end
+
+        it "should return :present if the provider indicates it is not mounted and the value is not :absent" do
+            @provider.expects(:ensure).returns(:present)
+            @provider.expects(:mounted?).returns(false)
+            @ensure.retrieve.should == :present
+        end
+    end
+
+    describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
+
+        it "should destroy itself if it should be absent" do
+            @provider.stubs(:mounted?).returns(false)
+            @provider.expects(:destroy)
+            @ensure.should = :absent
+            @ensure.sync
+        end
+
+        it "should unmount itself before destroying if it is mounted and should be absent" do
+            @provider.expects(:mounted?).returns(true)
+            @provider.expects(:unmount)
+            @provider.expects(:destroy)
+            @ensure.should = :absent
+            @ensure.sync
+        end
+
+        it "should create itself if it is absent and should be present" do
+            @provider.stubs(:mounted?).returns(false)
+            @provider.expects(:create)
+            @ensure.should = :present
+            @ensure.sync
+        end
+
+        it "should unmount itself if it is mounted and should be present" do
+            @provider.stubs(:mounted?).returns(true)
+
+            # The interface here is just too much work to test right now.
+            @ensure.stubs(:syncothers)
+            @provider.expects(:unmount)
+            @ensure.should = :present
+            @ensure.sync
+        end
+
+        it "should create and mount itself if it does not exist and should be mounted" do
+            @provider.stubs(:ensure).returns(:absent)
+            @provider.stubs(:mounted?).returns(false)
+            @provider.expects(:create)
+            @ensure.stubs(:syncothers)
+            @provider.expects(:mount)
+            @ensure.should = :mounted
+            @ensure.sync
+        end
+
+        it "should mount itself if it is present and should be mounted" do
+            @provider.stubs(:ensure).returns(:present)
+            @provider.stubs(:mounted?).returns(false)
+            @ensure.stubs(:syncothers)
+            @provider.expects(:mount)
+            @ensure.should = :mounted
+            @ensure.sync
+        end
+
+        it "should create but not mount itself if it is absent and mounted and should be mounted" do
+            @provider.stubs(:ensure).returns(:absent)
+            @provider.stubs(:mounted?).returns(true)
+            @ensure.stubs(:syncothers)
+            @provider.expects(:create)
+            @ensure.should = :mounted
+            @ensure.sync
+        end
+    end
+
+    describe Puppet::Type.type(:mount), "when responding to events" do
+
+        it "should remount if it is currently mounted" do
+            @provider.expects(:mounted?).returns(true)
+            @provider.expects(:remount)
+
+            @mount.refresh
+        end
+
+        it "should not remount if it is not currently mounted" do
+            @provider.expects(:mounted?).returns(false)
+            @provider.expects(:remount).never
+
+            @mount.refresh
+        end
+
+        it "should not remount swap filesystems" do
+            @mount[:fstype] = "swap"
+            @provider.expects(:remount).never
+
+            @mount.refresh
+        end
+    end
+end
+
+describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
+        Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
+        @mount = Puppet::Type.type(:mount).create(:name => "yay", :ensure => :mounted)
+
+        {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
+            :ensure => :mounted}.each do
+            |param, value|
+            @mount.provider.stubs(param).returns value
+            @mount[param] = value
+        end
+
+        @mount.provider.stubs(:mounted?).returns true
+
+        @catalog = Puppet::Node::Catalog.new
+        @catalog.add_resource @mount
+    end
+
+    it "should use the provider to change the dump value" do
+        @mount.provider.expects(:dump).returns 0
+        @mount.provider.expects(:dump=).with(1)
+
+        @mount[:dump] = 1
+
+        @catalog.apply
+    end
+end

data/spec/unit/type/nagios.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/external/nagios'
+
+describe "Nagios resource types" do
+    Nagios::Base.eachtype do |name, nagios_type|
+        puppet_type = Puppet::Type.type("nagios_" + name.to_s)
+
+        it "should have a valid type for #{name}" do
+            puppet_type.should_not be_nil
+        end
+
+        next unless puppet_type
+
+        describe puppet_type do
+            it "should be defined as a Puppet resource type" do
+                puppet_type.should_not be_nil
+            end
+
+            it "should have documentation" do
+                puppet_type.instance_variable_get("@doc").should_not == ""
+            end
+
+            it "should have %s as its namevar" % nagios_type.namevar do
+                puppet_type.namevar.should == nagios_type.namevar
+            end
+
+            it "should have documentation for its %s parameter" % nagios_type.namevar do
+                puppet_type.attrclass(nagios_type.namevar).instance_variable_get("@doc").should_not be_nil
+            end
+
+            it "should have an ensure property" do
+                puppet_type.should be_validproperty(:ensure)
+            end
+
+            it "should have a target property" do
+                puppet_type.should be_validproperty(:target)
+            end
+
+            it "should have documentation for its target property" do
+                puppet_type.attrclass(:target).instance_variable_get("@doc").should_not be_nil
+            end
+
+            nagios_type.parameters.reject { |param| param == nagios_type.namevar or param.to_s =~ /^[0-9]/ }.each do |param|
+                it "should have a %s property" % param do
+                    puppet_type.should be_validproperty(param)
+                end
+
+                it "should have documentation for its %s property" % param do
+                    puppet_type.attrclass(param).instance_variable_get("@doc").should_not be_nil
+                end
+            end
+
+            nagios_type.parameters.find_all { |param| param.to_s =~ /^[0-9]/ }.each do |param|
+                it "should have not have a %s property" % param do
+                    puppet_type.should_not be_validproperty(:param)
+                end
+            end
+        end
+    end
+end

data/spec/unit/type/noop_metaparam.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/type'
+
+describe Puppet::Type.type(:file).attrclass(:noop) do
+    before do
+        @file = Puppet::Type.newfile :path => "/what/ever"
+    end
+
+    after { Puppet::Type::File.clear }
+
+    it "should accept true as a value" do
+        lambda { @file[:noop] = true }.should_not raise_error
+    end
+
+    it "should accept false as a value" do
+        lambda { @file[:noop] = false }.should_not raise_error
+    end
+
+    describe "when set on a resource" do
+        it "should default to the :noop setting" do
+            Puppet.settings.expects(:value).with(:noop).returns "myval"
+            @file.noop.should == "myval"
+        end
+
+        it "should prefer true values from the attribute" do
+            @file[:noop] = true
+            @file.noop.should be_true
+        end
+
+        it "should prefer false values from the attribute" do
+            @file[:noop] = false
+            @file.noop.should be_false
+        end
+    end
+end

data/spec/unit/type/package.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:package) do
+    it "should have an :installable feature that requires the :install method" do
+        Puppet::Type.type(:package).provider_feature(:installable).methods.should == [:install]
+    end
+
+    it "should have an :uninstallable feature that requires the :uninstall method" do
+        Puppet::Type.type(:package).provider_feature(:uninstallable).methods.should == [:uninstall]
+    end
+
+    it "should have an :upgradeable feature that requires :update and :latest methods" do
+        Puppet::Type.type(:package).provider_feature(:upgradeable).methods.should == [:update, :latest]
+    end
+
+    it "should have a :purgeable feature that requires the :purge latest method" do
+        Puppet::Type.type(:package).provider_feature(:purgeable).methods.should == [:purge]
+    end
+
+    it "should have a :versionable feature" do
+        Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
+    end
+
+    it "should default to being installed" do
+        pkg = Puppet::Type.type(:package).create(:name => "yay")
+        pkg.should(:ensure).should == :present
+    end
+
+    after { Puppet::Type.type(:package).clear }
+end
+
+describe Puppet::Type.type(:package), "when validating attributes" do
+    [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type.type(:package).attrtype(param).should == :param
+        end
+    end
+
+    it "should have an ensure property" do
+        Puppet::Type.type(:package).attrtype(:ensure).should == :property
+    end
+end
+
+describe Puppet::Type.type(:package), "when validating attribute values" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil
+        Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
+    end
+
+    it "should support :present as a value to :ensure" do
+        Puppet::Type.type(:package).create(:name => "yay", :ensure => :present)
+    end
+
+    it "should alias :installed to :present as a value to :ensure" do
+        pkg = Puppet::Type.type(:package).create(:name => "yay", :ensure => :installed)
+        pkg.should(:ensure).should == :present
+    end
+
+    it "should support :absent as a value to :ensure" do
+        Puppet::Type.type(:package).create(:name => "yay", :ensure => :absent)
+    end
+
+    it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
+        @provider.expects(:satisfies?).with(:purgeable).returns(true)
+        Puppet::Type.type(:package).create(:name => "yay", :ensure => :purged)
+    end
+
+    it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
+        @provider.expects(:satisfies?).with(:purgeable).returns(false)
+        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
+    end
+
+    it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
+        @provider.expects(:satisfies?).with(:upgradeable).returns(true)
+        Puppet::Type.type(:package).create(:name => "yay", :ensure => :latest)
+    end
+
+    it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
+        @provider.expects(:satisfies?).with(:upgradeable).returns(false)
+        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
+    end
+
+    it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
+        @provider.expects(:satisfies?).with(:versionable).returns(true)
+        Puppet::Type.type(:package).create(:name => "yay", :ensure => "1.0")
+    end
+
+    it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
+        @provider.expects(:satisfies?).with(:versionable).returns(false)
+        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
+    end
+
+    it "should accept any string as an argument to :source" do
+        proc { Puppet::Type.type(:package).create(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
+    end
+
+    after { Puppet::Type.type(:package).clear }
+end
+
+module PackageEvaluationTesting
+    def setprops(properties)
+        @provider.stubs(:properties).returns(properties)
+    end
+end
+
+describe Puppet::Type.type(:package) do
+    before :each do
+        @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
+        Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
+        Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
+        @package = Puppet::Type.type(:package).create(:name => "yay")
+
+        @catalog = Puppet::Node::Catalog.new
+        @catalog.add_resource(@package)
+    end
+    
+    after :each do
+        @catalog.clear(true)
+        Puppet::Type.type(:package).clear
+    end
+
+
+    describe Puppet::Type.type(:package), "when it should be purged" do
+        include PackageEvaluationTesting
+
+        before { @package[:ensure] = :purged }
+
+        it "should do nothing if it is :purged" do
+            @provider.expects(:properties).returns(:ensure => :purged)
+            @catalog.apply
+        end
+
+        [:absent, :installed, :present, :latest].each do |state|
+            it "should purge if it is #{state.to_s}" do
+                @provider.stubs(:properties).returns(:ensure => state)
+                @provider.expects(:purge)
+                @catalog.apply
+            end
+        end
+    end
+
+    describe Puppet::Type.type(:package), "when it should be absent" do
+        include PackageEvaluationTesting
+
+        before { @package[:ensure] = :absent }
+
+        [:purged, :absent].each do |state|
+            it "should do nothing if it is #{state.to_s}" do
+                @provider.expects(:properties).returns(:ensure => state)
+                @catalog.apply
+            end
+        end
+
+        [:installed, :present, :latest].each do |state|
+            it "should uninstall if it is #{state.to_s}" do
+                @provider.stubs(:properties).returns(:ensure => state)
+                @provider.expects(:uninstall)
+                @catalog.apply
+            end
+        end
+    end
+
+    describe Puppet::Type.type(:package), "when it should be present" do
+        include PackageEvaluationTesting
+
+        before { @package[:ensure] = :present }
+
+        [:present, :latest, "1.0"].each do |state|
+            it "should do nothing if it is #{state.to_s}" do
+                @provider.expects(:properties).returns(:ensure => state)
+                @catalog.apply
+            end
+        end
+
+        [:purged, :absent].each do |state|
+            it "should install if it is #{state.to_s}" do
+                @provider.stubs(:properties).returns(:ensure => state)
+                @provider.expects(:install)
+                @catalog.apply
+            end
+        end
+    end
+
+    describe Puppet::Type.type(:package), "when it should be latest" do
+        include PackageEvaluationTesting
+
+        before { @package[:ensure] = :latest }
+
+        [:purged, :absent].each do |state|
+            it "should upgrade if it is #{state.to_s}" do
+                @provider.stubs(:properties).returns(:ensure => state)
+                @provider.expects(:update)
+                @catalog.apply
+            end
+        end
+
+        it "should upgrade if the current version is not equal to the latest version" do
+            @provider.stubs(:properties).returns(:ensure => "1.0")
+            @provider.stubs(:latest).returns("2.0")
+            @provider.expects(:update)
+            @catalog.apply
+        end
+
+        it "should do nothing if it is equal to the latest version" do
+            @provider.stubs(:properties).returns(:ensure => "1.0")
+            @provider.stubs(:latest).returns("1.0")
+            @provider.expects(:update).never
+            @catalog.apply
+        end
+
+        it "should do nothing if the provider returns :present as the latest version" do
+            @provider.stubs(:properties).returns(:ensure => :present)
+            @provider.stubs(:latest).returns("1.0")
+            @provider.expects(:update).never
+            @catalog.apply
+        end
+    end
+
+    describe Puppet::Type.type(:package), "when it should be a specific version" do
+        include PackageEvaluationTesting
+
+        before { @package[:ensure] = "1.0" }
+
+        [:purged, :absent].each do |state|
+            it "should install if it is #{state.to_s}" do
+                @provider.stubs(:properties).returns(:ensure => state)
+                @provider.expects(:install)
+                @catalog.apply
+            end
+        end
+
+        it "should do nothing if the current version is equal to the desired version" do
+            @provider.stubs(:properties).returns(:ensure => "1.0")
+            @provider.expects(:install).never
+            @catalog.apply
+        end
+
+        it "should install if the current version is not equal to the specified version" do
+            @provider.stubs(:properties).returns(:ensure => "2.0")
+            @provider.expects(:install)
+            @catalog.apply
+        end
+    end
+end