puppet 0.25.5 → 2.6.0

data/spec/unit/type/filebucket_spec.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:filebucket) do
+  describe "when validating attributes" do
+    %w{name server port path}.each do |attr|
+      it "should have a '#{attr}' parameter" do
+        Puppet::Type.type(:filebucket).attrtype(attr.intern).should == :param
+      end
+    end
+
+    it "should have its 'name' attribute set as its namevar" do
+      Puppet::Type.type(:filebucket).key_attributes.should == [:name]
+    end
+  end
+
+  it "should use the clientbucketdir as the path by default path" do
+    Puppet.settings[:clientbucketdir] = "/my/bucket"
+    Puppet::Type.type(:filebucket).new(:name => "main")[:path].should == Puppet[:clientbucketdir]
+  end
+
+  it "should use the masterport as the path by default port" do
+    Puppet.settings[:masterport] = 50
+    Puppet::Type.type(:filebucket).new(:name => "main")[:port].should == Puppet[:masterport]
+  end
+
+  it "should use the server as the path by default server" do
+    Puppet.settings[:server] = "myserver"
+    Puppet::Type.type(:filebucket).new(:name => "main")[:server].should == Puppet[:server]
+  end
+
+  it "be local by default" do
+    bucket = Puppet::Type.type(:filebucket).new :name => "main"
+
+    bucket.bucket.should be_local
+  end
+
+  it "not be local if path is false" do
+    bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+
+    bucket.bucket.should_not be_local
+  end
+
+  it "be local if both a path and a server are specified" do
+    bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "puppet", :path => "/my/path"
+
+    bucket.bucket.should be_local
+  end
+
+  describe "when creating the filebucket" do
+    before do
+      @bucket = stub 'bucket', :name= => nil
+    end
+
+    it "should use any provided path" do
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => "/foo/bar"
+      Puppet::FileBucket::Dipper.expects(:new).with(:Path => "/foo/bar").returns @bucket
+      bucket.bucket
+    end
+    it "should use any provided server and port" do
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
+      Puppet::FileBucket::Dipper.expects(:new).with(:Server => "myserv", :Port => "myport").returns @bucket
+      bucket.bucket
+    end
+
+    it "should use the default server if the path is unset and no server is provided" do
+      Puppet.settings[:server] = "myserv"
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+      Puppet::FileBucket::Dipper.expects(:new).with { |args| args[:Server] == "myserv" }.returns @bucket
+      bucket.bucket
+    end
+  end
+end

data/spec/unit/type/group_spec.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:group) do
+  before do
+    ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+    @class = Puppet::Type.type(:group)
+  end
+
+  it "should have a default provider" do
+    @class.defaultprovider.should_not be_nil
+  end
+
+  it "should have a default provider inheriting from Puppet::Provider" do
+    @class.defaultprovider.ancestors.should be_include(Puppet::Provider)
+  end
+
+  describe "when validating attributes" do
+    [:name, :allowdupe].each do |param|
+      it "should have a #{param} parameter" do
+        @class.attrtype(param).should == :param
+      end
+    end
+
+    [:ensure, :gid].each do |param|
+      it "should have a #{param} property" do
+        @class.attrtype(param).should == :property
+      end
+    end
+
+    it "should convert gids provided as strings into integers" do
+      @class.new(:name => "foo", :gid => "15")[:gid].should == 15
+    end
+
+    it "should accepts gids provided as integers" do
+      @class.new(:name => "foo", :gid => 15)[:gid].should == 15
+    end
+  end
+
+  # #1407 - we need to declare the allowdupe param as boolean.
+  it "should have a boolean method for determining if duplicates are allowed" do
+    @class.new(:name => "foo").methods.should be_include("allowdupe?")
+  end
+
+  it "should call 'create' to create the group" do
+    group = @class.new(:name => "foo", :ensure => :present)
+    group.provider.expects(:create)
+    group.parameter(:ensure).sync
+  end
+
+  it "should call 'delete' to remove the group" do
+    group = @class.new(:name => "foo", :ensure => :absent)
+    group.provider.expects(:delete)
+    group.parameter(:ensure).sync
+  end
+end

data/spec/unit/type/macauthorization_spec.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+macauth_type = Puppet::Type.type(:macauthorization)
+
+describe Puppet::Type.type(:macauthorization), "when checking macauthorization objects" do
+
+  before do
+    authplist = {}
+    authplist["rules"] = { "foorule" => "foo" }
+    authplist["rights"] = { "fooright" => "foo" }
+    provider_class = macauth_type.provider(macauth_type.providers[0])
+    Plist.stubs(:parse_xml).with("/etc/authorization").returns(authplist)
+    macauth_type.stubs(:defaultprovider).returns provider_class
+    @resource = macauth_type.new(:name => 'foo')
+  end
+
+  describe "when validating attributes" do
+
+    parameters = [:name,]
+    properties = [:auth_type, :allow_root, :authenticate_user, :auth_class,
+      :comment, :group, :k_of_n, :mechanisms, :rule,
+      :session_owner, :shared, :timeout, :tries]
+
+    parameters.each do |parameter|
+      it "should have a #{parameter} parameter" do
+        macauth_type.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+      end
+
+      it "should have documentation for its #{parameter} parameter" do
+        macauth_type.attrclass(parameter).doc.should be_instance_of(String)
+      end
+    end
+
+    properties.each do |property|
+      it "should have a #{property} property" do
+        macauth_type.attrclass(property).ancestors.should be_include(Puppet::Property)
+      end
+
+      it "should have documentation for its #{property} property" do
+        macauth_type.attrclass(property).doc.should be_instance_of(String)
+      end
+    end
+
+  end
+
+  describe "when validating properties" do
+
+    it "should have a default provider inheriting from Puppet::Provider" do
+      macauth_type.defaultprovider.ancestors.should be_include(Puppet::Provider)
+    end
+
+    it "should be able to create an instance" do
+      lambda {
+        macauth_type.new(:name => 'foo')
+      }.should_not raise_error
+    end
+
+    it "should support :present as a value to :ensure" do
+      lambda {
+        macauth_type.new(:name => "foo", :ensure => :present)
+      }.should_not raise_error
+    end
+
+    it "should support :absent as a value to :ensure" do
+      lambda {
+        macauth_type.new(:name => "foo", :ensure => :absent)
+      }.should_not raise_error
+    end
+
+  end
+
+  [:k_of_n, :timeout, :tries].each do |property|
+    describe "when managing the #{property} property" do
+      it "should convert number-looking strings into actual numbers" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        prop.should = "300"
+        prop.should.must == 300
+      end
+      it "should support integers as a value" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        prop.should = 300
+        prop.should.must == 300
+      end
+      it "should raise an error for non-integer values" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        lambda { prop.should = "foo" }.should raise_error(Puppet::Error)
+      end
+    end
+  end
+
+  [:allow_root, :authenticate_user, :session_owner, :shared].each do |property|
+    describe "when managing the #{property} property" do
+      it "should convert boolean-looking false strings into actual booleans" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        prop.should = "false"
+        prop.should.must == :false
+      end
+      it "should convert boolean-looking true strings into actual booleans" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        prop.should = "true"
+        prop.should.must == :true
+      end
+      it "should raise an error for non-boolean values" do
+        prop = macauth_type.attrclass(property).new(:resource => @resource)
+        lambda { prop.should = "foo" }.should raise_error(Puppet::Error)
+      end
+    end
+  end
+end

data/spec/unit/type/maillist_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+maillist = Puppet::Type.type(:maillist)
+
+describe maillist do
+  before do
+    @provider_class = Puppet::Type.type(:maillist).provider(:mailman)
+
+    @provider = stub 'provider', :class => @provider_class, :clear => nil
+    @provider.stubs(:respond_to).with(:aliases).returns(true)
+
+    @provider_class.stubs(:new).returns(@provider)
+
+    Puppet::Type.type(:maillist).stubs(:defaultprovider).returns(@provider_class)
+
+    @maillist = Puppet::Type.type(:maillist).new( :name => 'test' )
+
+    @catalog = Puppet::Resource::Catalog.new
+    @maillist.catalog = @catalog
+  end
+
+  it "should generate aliases unless they already exist" do
+    # Mail List aliases are careful not to stomp on managed Mail Alias aliases
+
+    # test1 is an unmanaged alias from /etc/aliases
+    Puppet::Type.type(:mailalias).provider(:aliases).stubs(:target_object).returns( StringIO.new("test1: root\n") )
+
+    # test2 is a managed alias from the manifest
+    dupe = Puppet::Type.type(:mailalias).new( :name => 'test2' )
+    @catalog.add_resource dupe
+
+    @provider.stubs(:aliases).returns({"test1" => 'this will get included', "test2" => 'this will dropped', "test3" => 'this will get included'})
+
+    generated = @maillist.generate
+    generated.map{ |x| x.name  }.sort.should == ['test1', 'test3']
+    generated.map{ |x| x.class }.should      == [Puppet::Type::Mailalias, Puppet::Type::Mailalias]
+
+  end
+
+end

data/spec/unit/type/mcx_spec.rb

@@ -0,0 +1,100 @@
+#!/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
+
+  it "should be nil for :ds_type" do
+    mcx_type.new(:name => '/Foo/bar')[:ds_type].should be_nil
+  end
+
+  it "should be nil for :ds_name" do
+    mcx_type.new(:name => '/Foo/bar')[:ds_name].should be_nil
+  end
+
+  it "should be nil for :content" do
+    mcx_type.new(: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
+
+  it "should be able to create an instance" do
+    lambda {
+      mcx_type.new(:name => '/Foo/bar')
+    }.should_not raise_error
+  end
+
+  it "should support :present as a value to :ensure" do
+    lambda {
+      mcx_type.new(:name => "/Foo/bar", :ensure => :present)
+    }.should_not raise_error
+  end
+
+  it "should support :absent as a value to :ensure" do
+    lambda {
+      mcx_type.new(:name => "/Foo/bar", :ensure => :absent)
+    }.should_not raise_error
+  end
+
+end

data/spec/unit/type/mount_spec.rb

@@ -0,0 +1,261 @@
+#!/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).new(:name => "yay")
+    mount.should(:ensure).should be_nil
+  end
+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 alias :present to :defined as a value to :ensure" do
+    mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
+    mount.should(:ensure).should == :defined
+  end
+
+  it "should support :unmounted as a value to :ensure" do
+    mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
+    mount.should(:ensure).should == :unmounted
+  end
+
+  it "should support :absent as a value to :ensure" do
+    Puppet::Type.type(:mount).new(:name => "yay", :ensure => :absent)
+  end
+
+  it "should support :mounted as a value to :ensure" do
+    Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
+  end
+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).new(:name => "yay", :check => :ensure)
+
+    @ensure = @mount.property(:ensure)
+  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 :unmounted 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 == :unmounted
+    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 defined" do
+      @provider.stubs(:ensure).returns(:absent)
+      @provider.stubs(:mounted?).returns(true)
+
+      @provider.stubs(:mounted?).returns(false)
+      @provider.expects(:create)
+      @ensure.should = :defined
+      @ensure.sync
+    end
+
+    it "should not unmount itself if it is mounted and should be defined" do
+      @provider.stubs(:ensure).returns(:mounted)
+      @provider.stubs(:mounted?).returns(true)
+
+      @provider.stubs(:create)
+      @provider.expects(:mount).never
+      @provider.expects(:unmount).never
+      @ensure.should = :defined
+      @ensure.sync
+    end
+
+    it "should not mount itself if it is unmounted and should be defined" do
+      @provider.stubs(:ensure).returns(:unmounted)
+      @provider.stubs(:mounted?).returns(false)
+
+      @ensure.stubs(:syncothers)
+      @provider.stubs(:create)
+      @provider.expects(:mount).never
+      @provider.expects(:unmount).never
+      @ensure.should = :present
+      @ensure.sync
+    end
+
+    it "should unmount itself if it is mounted and should be unmounted" do
+      @provider.stubs(:ensure).returns(:present)
+      @provider.stubs(:mounted?).returns(true)
+
+      @ensure.stubs(:syncothers)
+      @provider.expects(:unmount)
+      @ensure.should = :unmounted
+      @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
+
+    it "should be insync if it is mounted and should be defined" do
+      @ensure.should = :defined
+      @ensure.insync?(:mounted).should == true
+    end
+
+    it "should be insync if it is unmounted and should be defined" do
+      @ensure.should = :defined
+      @ensure.insync?(:unmounted).should == true
+    end
+
+    it "should be insync if it is mounted and should be present" do
+      @ensure.should = :present
+      @ensure.insync?(:mounted).should == true
+    end
+
+    it "should be insync if it is unmounted and should be present" do
+      @ensure.should = :present
+      @ensure.insync?(:unmounted).should == true
+    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).new(: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
+
+    # stub this to not try to create state.yaml
+    Puppet::Util::Storage.stubs(:store)
+
+    @catalog = Puppet::Resource::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