puppet 0.24.6 → 0.24.7

data/spec/unit/provider/macauthorization.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# 
+# Unit testing for the macauthorization provider
+#
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet'
+require 'facter/util/plist'
+
+provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
+
+describe provider_class do
+    
+    before :each do
+        # Create a mock resource
+        @resource = stub 'resource'
+        
+        @authname = "foo.spam.eggs.puppettest"
+        @authplist = {}
+        
+        @rules = {@authname => @authplist}
+        
+        authdb = {}
+        authdb["rules"] = { "foorule" => "foo" }
+        authdb["rights"] = { "fooright" => "foo" }
+        
+        # Stub out Plist::parse_xml
+        Plist.stubs(:parse_xml).returns(authdb)
+
+        # A catch all; no parameters set
+        @resource.stubs(:[]).returns(nil)
+
+        # But set name, ensure
+        @resource.stubs(:[]).with(:name).returns @authname
+        @resource.stubs(:[]).with(:ensure).returns :present
+        @resource.stubs(:ref).returns "MacAuthorization[#{@authname}]"
+
+        @provider = provider_class.new(@resource)
+    end
+    
+    it "should have a create method" do
+        @provider.should respond_to(:create)
+    end
+    
+    it "should have a destroy method" do
+        @provider.should respond_to(:destroy)
+    end
+    
+    it "should have an exists? method" do
+        @provider.should respond_to(:exists?)
+    end
+    
+    it "should have a flush method" do
+        @provider.should respond_to(:flush)
+    end
+    
+    properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
+                        :group, :k_of_n, :mechanisms, :rule, :session_owner,
+                        :shared, :timeout, :tries, :auth_type ]
+                        
+    properties.each do |prop|
+        it "should have a #{prop.to_s} method" do
+            @provider.should respond_to(prop.to_s)
+        end
+        
+        it "should have a #{prop.to_s}= method" do
+            @provider.should respond_to(prop.to_s + "=")
+        end
+    end
+    
+    describe "when destroying a right" do
+        before :each do
+            @resource.stubs(:[]).with(:auth_type).returns(:right)
+        end
+        
+        it "should call the internal method destroy_right" do
+            @provider.expects(:destroy_right)
+            @provider.destroy
+        end
+        it "should call the external command 'security authorizationdb remove @authname" do
+            @provider.expects(:security).with("authorizationdb", :remove, @authname)
+            @provider.destroy
+        end
+    end
+    
+    describe "when destroying a rule" do
+        before :each do
+            @resource.stubs(:[]).with(:auth_type).returns(:rule)
+        end
+        
+        it "should call the internal method destroy_rule" do
+            @provider.expects(:destroy_rule)
+            @provider.destroy
+        end
+    end
+    
+    describe "when flushing a right" do
+        before :each do
+            @resource.stubs(:[]).with(:auth_type).returns(:right)
+        end
+        
+        it "should call the internal method flush_right" do
+            @provider.expects(:flush_right)
+            @provider.flush
+        end
+        
+        it "should call the internal method set_right" do
+            @provider.expects(:set_right)
+            @provider.flush
+        end
+        
+        it "should read and write to the auth database with the right arguments" do
+            @provider.expects(:execute).with() { |cmds, args| 
+                cmds.include?("read") and
+                cmds.include?(@authname) and
+                args[:combine] == false
+            }.once
+            
+            @provider.expects(:execute).with() { |cmds, args| 
+                cmds.include?("write") and
+                cmds.include?(@authname) and
+                args[:combine] == false and
+                args[:stdinfile] != nil
+            }.once
+            @provider.flush
+        end
+        
+    end
+    
+    describe "when flushing a rule" do
+        before :each do
+            @resource.stubs(:[]).with(:auth_type).returns(:rule)
+        end
+        
+        it "should call the internal method flush_rule" do
+            @provider.expects(:flush_rule)
+            @provider.flush
+        end
+        
+        it "should call the internal method set_rule" do
+            @provider.expects(:set_rule)
+            @provider.flush
+        end
+    end
+
+end

data/spec/unit/provider/mcx/mcxcontent.rb

@@ -0,0 +1,175 @@
+#! /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>
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:mcx).provider(:mcxcontent)
+
+# describe creates a new ExampleGroup object.
+describe provider_class do
+
+    # :each executes before each test.
+    # :all executes once for the test group and before :each.
+    before :each do
+        # Create a mock resource
+        @resource = stub 'resource'
+
+        @provider = provider_class.new
+        @attached_to = "/Users/foobar"
+        @ds_path = "/Local/Default/Users/foobar"
+
+        # A catch all; no parameters set
+        @resource.stubs(:[]).returns(nil)
+
+        # But set name, ensure and enable
+        @resource.stubs(:[]).with(:name).returns @attached_to
+        @resource.stubs(:[]).with(:ensure).returns :present
+        @resource.stubs(:ref).returns "Mcx[#{@attached_to}]"
+
+        # stub out the provider methods that actually touch the filesystem
+        # or execute commands
+        @provider.class.stubs(:execute).returns('')
+        @provider.stubs(:execute).returns('')
+        @provider.stubs(:resource).returns @resource
+    end
+
+    it "should have a create method." do
+        @provider.should respond_to(:create)
+    end
+
+    it "should have a destroy method." do
+        @provider.should respond_to(:destroy)
+    end
+
+    it "should have an exists? method." do
+        @provider.should respond_to(:exists?)
+    end
+
+    it "should have an content method." do
+        @provider.should respond_to(:content)
+    end
+
+    it "should have an content= method." do
+        @provider.should respond_to(:content=)
+    end
+
+    describe "when managing the resource" do
+        it "should execute external command dscl from :create" do
+            @provider.class.expects(:dscl).returns('').once
+            @provider.create
+        end 
+        it "should execute external command dscl from :destroy" do
+            @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path).returns('').once
+            @provider.destroy
+        end 
+        it "should execute external command dscl from :exists?" do
+            @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('').once
+            @provider.exists?
+        end
+        it "should execute external command dscl from :content" do
+            @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('')
+            @provider.content
+        end
+        it "should execute external command dscl from :content=" do
+            @provider.class.expects(:dscl).returns('')
+            @provider.content=''
+        end
+    end
+
+    describe "when creating and parsing the name for ds_type" do
+        before :each do
+            @resource.stubs(:[]).with(:name).returns "/Foo/bar"
+        end
+        it "should not accept /Foo/bar" do
+            lambda { @provider.create }.should raise_error(MCXContentProviderException)
+        end
+        it "should accept /Foo/bar with ds_type => user" do
+            @resource.stubs(:[]).with(:ds_type).returns "user"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept /Foo/bar with ds_type => group" do
+            @resource.stubs(:[]).with(:ds_type).returns "group"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept /Foo/bar with ds_type => computer" do
+            @resource.stubs(:[]).with(:ds_type).returns "computer"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept :name => /Foo/bar with ds_type => computerlist" do
+            @resource.stubs(:[]).with(:ds_type).returns "computerlist"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+    end
+
+    describe "when creating and :name => foobar" do
+        before :each do
+            @resource.stubs(:[]).with(:name).returns "foobar"
+        end
+        it "should not accept unspecified :ds_type and :ds_name" do
+            lambda { @provider.create }.should raise_error(MCXContentProviderException)
+        end
+        it "should not accept unspecified :ds_type" do
+            @resource.stubs(:[]).with(:ds_type).returns "user"
+            lambda { @provider.create }.should raise_error(MCXContentProviderException)
+        end
+        it "should not accept unspecified :ds_name" do
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should raise_error(MCXContentProviderException)
+        end
+        it "should accept :ds_type => user, ds_name => foo" do
+            @resource.stubs(:[]).with(:ds_type).returns "user"
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept :ds_type => group, ds_name => foo" do
+            @resource.stubs(:[]).with(:ds_type).returns "group"
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept :ds_type => computer, ds_name => foo" do
+            @resource.stubs(:[]).with(:ds_type).returns "computer"
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should accept :ds_type => computerlist, ds_name => foo" do
+            @resource.stubs(:[]).with(:ds_type).returns "computerlist"
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+        end
+        it "should not accept :ds_type => bogustype, ds_name => foo" do
+            @resource.stubs(:[]).with(:ds_type).returns "bogustype"
+            @resource.stubs(:[]).with(:ds_name).returns "foo"
+            lambda { @provider.create }.should raise_error(MCXContentProviderException)
+        end
+    end
+
+    describe "when gathering existing instances" do
+        it "should define an instances class method." do
+            @provider.class.should respond_to(:instances)
+        end
+        it "should call external command dscl -list /Local/Default/<ds_type> on each known ds_type" do
+            @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Users").returns('')
+            @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Groups").returns('')
+            @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Computers").returns('')
+            @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/ComputerLists").returns('')
+            @provider.class.instances
+        end
+    end
+end

data/spec/unit/provider/mount.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/mount'
+
+describe Puppet::Provider::Mount do
+    before :each do
+        @mounter = Object.new
+        @mounter.extend(Puppet::Provider::Mount)
+
+        @name = "/"
+
+        @resource = stub 'resource'
+        @resource.stubs(:[]).with(:name).returns(@name)
+
+        @mounter.stubs(:resource).returns(@resource)
+    end
+
+    describe Puppet::Provider::Mount, " when mounting" do
+
+        it "should use the 'mountcmd' method to mount" do
+            @mounter.stubs(:options).returns(nil)
+            @mounter.expects(:mountcmd)
+
+            @mounter.mount
+        end
+
+        it "should flush before mounting if a flush method exists" do
+            @mounter.meta_def(:flush) { }
+            @mounter.expects(:flush)
+            @mounter.stubs(:mountcmd)
+            @mounter.stubs(:options).returns(nil)
+
+            @mounter.mount
+        end
+
+        it "should add the options following '-o' if they exist and are not set to :absent" do
+            @mounter.stubs(:options).returns("ro")
+            @mounter.expects(:mountcmd).with { |*ary| ary[0] == "-o" and ary[1] == "ro" }
+
+            @mounter.mount
+        end
+
+        it "should specify the filesystem name to the mount command" do
+            @mounter.stubs(:options).returns(nil)
+            @mounter.expects(:mountcmd).with { |*ary| ary[-1] == @name }
+
+            @mounter.mount
+        end
+    end
+
+    describe Puppet::Provider::Mount, " when remounting" do
+
+        it "should use '-o remount' if the resource specifies it supports remounting" do
+            @mounter.stubs(:info)
+            @resource.stubs(:[]).with(:remounts).returns(:true)
+            @mounter.expects(:mountcmd).with("-o", "remount", @name)
+            @mounter.remount
+        end
+
+        it "should unmount and mount if the resource does not specify it supports remounting" do
+            @mounter.stubs(:info)
+            @resource.stubs(:[]).with(:remounts).returns(false)
+            @mounter.expects(:unmount)
+            @mounter.expects(:mount)
+            @mounter.remount
+        end
+
+        it "should log that it is remounting" do
+            @resource.stubs(:[]).with(:remounts).returns(:true)
+            @mounter.stubs(:mountcmd)
+            @mounter.expects(:info).with("Remounting")
+            @mounter.remount
+        end
+    end
+
+    describe Puppet::Provider::Mount, " when unmounting" do
+
+        it "should call the :umount command with the resource name" do
+            @mounter.expects(:umount).with(@name)
+            @mounter.unmount
+        end
+    end
+
+    describe Puppet::Provider::Mount, " when determining if it is mounted" do
+
+        it "should parse the results of running the mount command with no arguments" do
+            Facter.stubs(:value).returns("whatever")
+            @mounter.expects(:mountcmd).returns("")
+
+            @mounter.mounted?
+        end
+
+        it "should match ' on /private/var/automount<name>' if the operating system is Darwin" do
+            Facter.stubs(:value).with("operatingsystem").returns("Darwin")
+            @mounter.expects(:mountcmd).returns("/dev/whatever on /private/var/automount/\ndevfs on /dev")
+
+            @mounter.should be_mounted
+        end
+
+        it "should match ' on <name>' if the operating system is Darwin" do
+            Facter.stubs(:value).with("operatingsystem").returns("Darwin")
+            @mounter.expects(:mountcmd).returns("/dev/disk03 on / (local, journaled)\ndevfs on /dev")
+
+            @mounter.should be_mounted
+        end
+
+        it "should match '^<name> on' if the operating system is Solaris" do
+            Facter.stubs(:value).with("operatingsystem").returns("Solaris")
+            @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
+
+            @mounter.should be_mounted
+        end
+
+        it "should match ' on <name>' if the operating system is not Darwin or Solaris" do
+            Facter.stubs(:value).with("operatingsystem").returns("Debian")
+            @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on / and stuff\n/dev/other/disk on /var and stuff")
+
+            @mounter.should be_mounted
+        end
+
+        it "should not be considered mounted if it did not match the mount output" do
+            Facter.stubs(:value).with("operatingsystem").returns("Debian")
+            @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on /something/else and stuff\n/dev/other/disk on /var and stuff")
+
+            @mounter.should_not be_mounted
+        end
+    end
+end