puppet 0.24.6 → 0.24.7

data/spec/unit/provider/service/runit.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+# 
+# Unit testing for the Runit service Provider
+#
+# author Brice Figureau
+#
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:runit)
+
+describe provider_class do
+
+    before(:each) do
+        # Create a mock resource
+        @resource = stub 'resource'
+
+        @provider = provider_class.new
+        @servicedir = "/etc/service"
+        @provider.servicedir=@servicedir
+        @daemondir = "/etc/sv"
+        @provider.class.defpath=@daemondir
+
+        # A catch all; no parameters set
+        @resource.stubs(:[]).returns(nil)
+
+        # But set name, source and path (because we won't run
+        # the thing that will fetch the resource path from the provider)
+        @resource.stubs(:[]).with(:name).returns "myservice"
+        @resource.stubs(:[]).with(:ensure).returns :enabled
+        @resource.stubs(:[]).with(:path).returns @daemondir
+        @resource.stubs(:ref).returns "Service[myservice]"
+
+        @provider.stubs(:resource).returns @resource
+    end
+
+    it "should have a restartcmd method" do
+        @provider.should respond_to(:restartcmd)
+    end
+
+    it "should have a start method" do
+        @provider.should respond_to(:start)
+    end
+
+    it "should have a stop method" do
+        @provider.should respond_to(:stop)
+    end
+
+    it "should have an enabled? method" do
+        @provider.should respond_to(:enabled?)
+    end
+
+    it "should have an enable method" do
+        @provider.should respond_to(:enable)
+    end
+
+    it "should have a disable method" do
+        @provider.should respond_to(:disable)
+    end
+
+    describe "when starting" do
+        it "should call enable" do
+            @provider.expects(:enable)
+            @provider.start
+        end
+    end
+
+    describe "when stopping" do
+        it "should execute external command 'sv stop /etc/service/myservice'" do
+            @provider.expects(:ucommand).with(:stop).returns("")
+            @provider.stop
+        end
+    end
+
+    describe "when enabling" do
+        it "should create a symlink between daemon dir and service dir" do
+            FileTest.stubs(:symlink?).returns(false)
+            File.expects(:symlink).with(File.join(@daemondir,"myservice"), File.join(@servicedir,"myservice")).returns(0)
+            @provider.enable
+        end
+    end
+
+    describe "when disabling" do
+        it "should remove the '/etc/service/myservice' symlink" do
+            FileTest.stubs(:directory?).returns(false)
+            FileTest.stubs(:symlink?).returns(true)
+            File.expects(:unlink).with(File.join(@servicedir,"myservice")).returns(0)
+            @provider.disable
+        end
+    end
+
+    describe "when checking status" do
+        it "should call the external command 'sv status /etc/sv/myservice'" do
+            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice"))
+            @provider.status
+        end
+    end
+
+    describe "when checking status" do
+        it "and sv status fails, properly raise a Puppet::Error" do
+            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).raises(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
+            lambda { @provider.status }.should raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: fail: /etc/sv/myservice: file not found')
+        end
+        it "and sv status returns up, then return :running" do
+            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("run: /etc/sv/myservice: (pid 9029) 6s")
+            @provider.status.should == :running
+        end
+        it "and sv status returns not running, then return :stopped" do
+            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("fail: /etc/sv/myservice: runsv not running")
+            @provider.status.should == :stopped
+        end
+        it "and sv status returns a warning, then return :stopped" do
+            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
+            @provider.status.should == :stopped
+        end
+    end
+
+ end

data/spec/unit/provider/ssh_authorized_key/parsed.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppettest'
+require 'puppettest/support/utils'
+require 'puppettest/fileparsing'
+
+provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
+
+describe provider_class do
+    include PuppetTest
+    include PuppetTest::FileParsing
+
+    before :each do
+        @sshauthkey_class = Puppet.type(:ssh_authorized_key)
+        @provider = @sshauthkey_class.provider(:parsed)
+    end
+
+    after :each do
+        @provider.initvars
+    end
+
+    def mkkey(args)
+        fakeresource = fakeresource(:ssh_authorized_key, args[:name])
+
+        key = @provider.new(fakeresource)
+        args.each do |p,v|
+            key.send(p.to_s + "=", v)
+        end
+
+        return key
+    end
+
+    def genkey(key)
+        @provider.filetype = :ram
+        file = @provider.default_target
+
+        key.flush
+        text = @provider.target_object(file).read
+        return text
+    end
+
+    it "should be able to parse each example" do
+        fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
+            puts "Parsing %s" % file
+            fakedataparse(file)
+        }
+    end
+
+    it "should be able to generate a basic authorized_keys file" do
+        key = mkkey({
+            :name => "Just Testing",
+            :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
+            :type => "ssh-dss",
+            :ensure => :present,
+            :options => [:absent]
+        })
+
+        genkey(key).should == "ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just Testing\n"
+    end
+
+    it "should be able to generate a authorized_keys file with options" do
+        key = mkkey({
+            :name => "root@localhost",
+            :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
+            :type => "ssh-rsa",
+            :ensure => :present,
+            :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
+        })
+
+        genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
+    end
+
+    it "should prefetch ~user/.ssh/authorized_keys when user is given" do
+        key = Puppet::Type.type(:ssh_authorized_key).create(
+            :name => "Test",
+            :key => "AA",
+            :type => "rsa",
+            :ensure => :present,
+            :user => "root")
+        prov = @provider.new key
+
+        prov.prefetch
+        prov.target.should == File.expand_path("~root/.ssh/authorized_keys")
+    end
+
+    it "should create destination dir" do
+        # No idea how to test the flush method
+    end
+
+    it "should set correct default permissions" do
+        # No idea how to test the flush method
+    end
+
+    it "'s parse_options method should be able to parse options containing commas" do
+        options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
+        optionstr = options.join(", ")
+
+        @provider.parse_options(optionstr).should == options
+    end
+end

data/spec/unit/provider/user/hpux.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:user).provider(:hpuxuseradd)
+
+describe provider_class do
+    # left from the useradd test... I have no clue what I'm doing.
+    before do
+        @resource = stub("resource", :name => "myuser", :managehome? => nil, :should => "fakeval", :[] => "fakeval")
+        @provider = provider_class.new(@resource)
+    end
+
+    it "should add -F when modifying a user" do
+        @resource.expects(:allowdupe?).returns true
+        @provider.expects(:execute).with { |args| args.include?("-F") }
+        @provider.uid = 1000
+    end
+
+    it "should add -F when deleting a user" do
+        @provider.stubs(:exists?).returns(true)
+        @provider.expects(:execute).with { |args| args.include?("-F") }
+        @provider.delete
+    end
+end

data/spec/unit/provider/user/ldap.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-10.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:user).provider(:ldap)
+
+describe provider_class do
+    it "should have the Ldap provider class as its baseclass" do
+        provider_class.superclass.should equal(Puppet::Provider::Ldap)
+    end
+
+    it "should manage :posixAccount and :person objectclasses" do
+        provider_class.manager.objectclasses.should == [:posixAccount, :person]
+    end
+
+    it "should use 'ou=People' as its relative base" do
+        provider_class.manager.location.should == "ou=People"
+    end
+
+    it "should use :uid as its rdn" do
+        provider_class.manager.rdn.should == :uid
+    end
+
+    it "should be able to manage passwords" do
+        provider_class.should be_manages_passwords
+    end
+    
+    it "should use the ldap group provider to convert group names to numbers" do
+        provider = provider_class.new(:name => "foo")
+        Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 10
+
+        provider.gid = 'bar'
+        provider.gid.should == 10
+    end
+
+    {:name => "uid",
+        :password => "userPassword",
+        :comment => "cn",
+        :uid => "uidNumber",
+        :gid => "gidNumber",
+        :home => "homeDirectory",
+        :shell => "loginShell"
+    }.each do |puppet, ldap|
+        it "should map :#{puppet.to_s} to '#{ldap}'" do
+            provider_class.manager.ldap_name(puppet).should == ldap
+        end
+    end
+
+    describe "when being created" do
+        before do
+            # So we don't try to actually talk to ldap
+            @connection = mock 'connection'
+            provider_class.manager.stubs(:connect).yields @connection
+        end
+
+        it "should generate the sn as the last field of the cn" do
+            resource = stub 'resource', :should => %w{whatever}
+            resource.stubs(:should).with(:comment).returns ["Luke Kanies"]
+            resource.stubs(:should).with(:ensure).returns :present
+            instance = provider_class.new(:name => "luke", :ensure => :absent)
+            instance.stubs(:resource).returns resource
+
+            @connection.expects(:add).with { |dn, attrs| attrs["sn"] == ["Kanies"] }
+
+            instance.create
+            instance.flush
+        end
+
+        describe "with no uid specified" do
+            it "should pick the first available UID after the largest existing UID" do
+                low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
+                high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
+                provider_class.manager.expects(:search).returns([low, high])
+
+                resource = stub 'resource', :should => %w{whatever}
+                resource.stubs(:should).with(:uid).returns nil
+                resource.stubs(:should).with(:ensure).returns :present
+                instance = provider_class.new(:name => "luke", :ensure => :absent)
+                instance.stubs(:resource).returns resource
+
+                @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["641"] }
+
+                instance.create
+                instance.flush
+            end
+
+            it "should pick 501 of no users exist" do
+                provider_class.manager.expects(:search).returns nil
+
+                resource = stub 'resource', :should => %w{whatever}
+                resource.stubs(:should).with(:uid).returns nil
+                resource.stubs(:should).with(:ensure).returns :present
+                instance = provider_class.new(:name => "luke", :ensure => :absent)
+                instance.stubs(:resource).returns resource
+
+                @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["501"] }
+
+                instance.create
+                instance.flush
+            end
+        end
+    end
+
+    describe "when flushing" do
+        before do
+            provider_class.stubs(:suitable?).returns true
+
+            @instance = provider_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
+        end
+
+        it "should remove the :groups value before updating" do
+            @instance.class.manager.expects(:update).with { |name, ldap, puppet| puppet[:groups].nil? }
+
+            @instance.flush
+        end
+
+        it "should empty the property hash" do
+            @instance.class.manager.stubs(:update)
+
+            @instance.flush
+
+            @instance.uid.should == :absent
+        end
+
+        it "should empty the ldap property hash" do
+            @instance.class.manager.stubs(:update)
+
+            @instance.flush
+
+            @instance.ldap_properties[:uid].should be_nil
+        end
+    end
+
+    describe "when checking group membership" do
+        before do
+            @groups = Puppet::Type.type(:group).provider(:ldap)
+            @group_manager = @groups.manager
+            provider_class.stubs(:suitable?).returns true
+
+            @instance = provider_class.new(:name => "myname")
+        end
+
+        it "should show its group membership as the list of all groups returned by an ldap query of group memberships" do
+            one = {:name => "one"}
+            two = {:name => "two"}
+            @group_manager.expects(:search).with("memberUid=myname").returns([one, two])
+
+            @instance.groups.should == "one,two"
+        end
+
+        it "should show its group membership as :absent if no matching groups are found in ldap" do
+            @group_manager.expects(:search).with("memberUid=myname").returns(nil)
+
+            @instance.groups.should == :absent
+        end
+
+        it "should cache the group value" do
+            @group_manager.expects(:search).with("memberUid=myname").once.returns nil
+
+            @instance.groups
+            @instance.groups.should == :absent
+        end
+    end
+
+    describe "when modifying group membership" do
+        before do
+            @groups = Puppet::Type.type(:group).provider(:ldap)
+            @group_manager = @groups.manager
+            provider_class.stubs(:suitable?).returns true
+
+            @one = {:name => "one", :gid => "500"}
+            @group_manager.stubs(:find).with("one").returns(@one)
+
+            @two = {:name => "one", :gid => "600"}
+            @group_manager.stubs(:find).with("two").returns(@two)
+
+            @instance = provider_class.new(:name => "myname")
+
+            @instance.stubs(:groups).returns :absent
+        end
+
+        it "should fail if the group does not exist" do
+            @group_manager.expects(:find).with("mygroup").returns nil
+
+            lambda { @instance.groups = "mygroup" }.should raise_error(Puppet::Error)
+        end
+
+        it "should only pass the attributes it cares about to the group manager" do
+            @group_manager.expects(:update).with { |name, attrs| attrs[:gid].nil? }
+
+            @instance.groups = "one"
+        end
+
+        it "should always include :ensure => :present in the current values" do
+            @group_manager.expects(:update).with { |name, is, should| is[:ensure] == :present }
+
+            @instance.groups = "one"
+        end
+
+        it "should always include :ensure => :present in the desired values" do
+            @group_manager.expects(:update).with { |name, is, should| should[:ensure] == :present }
+
+            @instance.groups = "one"
+        end
+
+        it "should always pass the group's original member list" do
+            @one[:members] = %w{yay ness}
+            @group_manager.expects(:update).with { |name, is, should| is[:members] == %w{yay ness} }
+
+            @instance.groups = "one"
+        end
+
+        it "should find the group again when resetting its member list, so it has the full member list" do
+            @group_manager.expects(:find).with("one").returns(@one)
+
+            @group_manager.stubs(:update)
+
+            @instance.groups = "one"
+        end
+
+        describe "for groups that have no members" do
+            it "should create a new members attribute with its value being the user's name" do
+                @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{myname} }
+
+                @instance.groups = "one"
+            end
+        end
+
+        describe "for groups it is being removed from" do
+            it "should replace the group's member list with one missing the user's name" do
+                @one[:members] = %w{myname a}
+                @two[:members] = %w{myname b}
+
+                @group_manager.expects(:update).with { |name, is, should| name == "two" and should[:members] == %w{b} }
+
+                @instance.stubs(:groups).returns "one,two"
+                @instance.groups = "one"
+            end
+
+            it "should mark the member list as empty if there are no remaining members" do
+                @one[:members] = %w{myname}
+                @two[:members] = %w{myname b}
+
+                @group_manager.expects(:update).with { |name, is, should| name == "one" and should[:members] == :absent }
+
+                @instance.stubs(:groups).returns "one,two"
+                @instance.groups = "two"
+            end
+        end
+
+        describe "for groups that already have members" do
+            it "should replace each group's member list with a new list including the user's name" do
+                @one[:members] = %w{a b}
+                @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+                @two[:members] = %w{b c}
+                @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{b c myname} }
+
+                @instance.groups = "one,two"
+            end
+        end
+
+        describe "for groups of which it is a member" do
+            it "should do nothing" do
+                @one[:members] = %w{a b}
+                @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+
+                @two[:members] = %w{c myname}
+                @group_manager.expects(:update).with { |name, *other| name == "two" }.never
+
+                @instance.stubs(:groups).returns "two"
+
+                @instance.groups = "one,two"
+            end
+        end
+    end
+end