puppet 0.25.5 → 2.6.0

data/spec/unit/provider/macauthorization_spec.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_spec.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/parsed_spec.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-12.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppettest/support/utils'
+require 'puppettest/fileparsing'
+
+module ParsedMountTesting
+  include PuppetTest::Support::Utils
+  include PuppetTest::FileParsing
+
+  def fake_fstab
+    os = Facter['operatingsystem']
+    if os == "Solaris"
+      name = "solaris.fstab"
+    elsif os == "FreeBSD"
+      name = "freebsd.fstab"
+    else
+      # Catchall for other fstabs
+      name = "linux.fstab"
+    end
+    oldpath = @provider_class.default_target
+    fakefile(File::join("data/types/mount", name))
+  end
+
+  def mkmountargs
+    mount = nil
+
+    if defined?(@pcount)
+      @pcount += 1
+    else
+      @pcount = 1
+    end
+    args = {
+      :name => "/fspuppet#{@pcount}",
+      :device => "/dev/dsk#{@pcount}",
+    }
+
+    @provider_class.fields(:parsed).each do |field|
+      args[field] = "fake#{field}#{@pcount}" unless args.include? field
+    end
+
+    args
+  end
+
+  def mkmount
+    hash = mkmountargs
+    #hash[:provider] = @provider_class.name
+
+    fakeresource = stub :type => :mount, :name => hash[:name]
+    fakeresource.stubs(:[]).with(:name).returns(hash[:name])
+    fakeresource.stubs(:should).with(:target).returns(nil)
+
+    mount = @provider_class.new(fakeresource)
+    hash[:record_type] = :parsed
+    hash[:ensure] = :present
+    mount.property_hash = hash
+
+    mount
+  end
+
+  # Here we just create a fake host type that answers to all of the methods
+  # but does not modify our actual system.
+  def mkfaketype
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+  end
+end
+
+provider_class = Puppet::Type.type(:mount).provider(:parsed)
+
+describe provider_class do
+  before :each do
+    @mount_class = Puppet::Type.type(:mount)
+    @provider_class = @mount_class.provider(:parsed)
+  end
+
+
+  describe provider_class do
+    include ParsedMountTesting
+
+    it "should be able to parse all of the example mount tabs" do
+      tab = fake_fstab
+      @provider = @provider_class
+
+      # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
+      # I suppose this is more of an integration test?  I dunno.
+      fakedataparse(tab) do
+        # Now just make we've got some mounts we know will be there
+        hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
+        (hashes.length > 0).should be_true
+        root = hashes.find { |i| i[:name] == "/" }
+
+        proc { @provider_class.to_file(hashes) }.should_not raise_error
+      end
+    end
+
+    # LAK:FIXME I can't mock Facter because this test happens at parse-time.
+    it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
+      should = case Facter.value(:operatingsystem)
+        when "Solaris"; "/etc/vfstab"
+        else
+          "/etc/fstab"
+        end
+      Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
+    end
+
+    it "should not crash on incomplete lines in fstab" do
+      parse = @provider_class.parse <<-FSTAB
+/dev/incomplete
+/dev/device       name
+      FSTAB
+
+      lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
+    end
+  end
+
+  describe provider_class, " when mounting an absent filesystem" do
+    include ParsedMountTesting
+
+    # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
+    it "should flush the fstab to disk" do
+      mount = mkmount
+
+      # Mark the mount as absent
+      mount.property_hash[:ensure] = :absent
+
+      mount.stubs(:mountcmd) # just so we don't actually try to mount anything
+
+      mount.expects(:flush)
+      mount.mount
+    end
+  end
+
+  describe provider_class, " when modifying the filesystem tab" do
+    include ParsedMountTesting
+    before do
+      Puppet.settings.stubs(:use)
+      # Never write to disk, only to RAM.
+      #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+      @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
+      @provider_class.clear
+
+      @mount = mkmount
+      @target = @provider_class.default_target
+    end
+
+    it "should write the mount to disk when :flush is called" do
+      old_text = @provider_class.target_object(@provider_class.default_target).read
+
+      @mount.flush
+
+      text = @provider_class.target_object(@provider_class.default_target).read
+      text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
+    end
+  end
+
+  describe provider_class, " when parsing information about the root filesystem" do
+    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
+    include ParsedMountTesting
+
+    before do
+      @mount = @mount_class.new :name => "/"
+      @provider = @mount.provider
+    end
+
+    it "should have a filesystem tab" do
+      FileTest.should be_exist(@provider_class.default_target)
+    end
+
+    it "should find the root filesystem" do
+      @provider_class.prefetch("/" => @mount)
+      @mount.provider.property_hash[:ensure].should == :present
+    end
+
+    it "should determine that the root fs is mounted" do
+      @provider_class.prefetch("/" => @mount)
+      @mount.provider.should be_mounted
+    end
+  end
+
+  describe provider_class, " when mounting and unmounting" do
+    include ParsedMountTesting
+
+    it "should call the 'mount' command to mount the filesystem"
+
+    it "should call the 'unmount' command to unmount the filesystem"
+
+    it "should specify the filesystem when remounting a filesystem"
+  end
+end