puppet 0.24.6 → 0.24.7

data/spec/unit/provider/confiner.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/confiner'
+
+describe Puppet::Provider::Confiner do
+    before do
+        @object = Object.new
+        @object.extend(Puppet::Provider::Confiner)
+    end
+
+    it "should have a method for defining confines" do
+        @object.should respond_to(:confine)
+    end
+
+    it "should have a method for returning its confine collection" do
+        @object.should respond_to(:confine_collection)
+    end
+
+    it "should have a method for testing suitability" do
+        @object.should respond_to(:suitable?)
+    end
+
+    it "should delegate its confine method to its confine collection" do
+        coll = mock 'collection'
+        @object.stubs(:confine_collection).returns coll
+        coll.expects(:confine).with(:foo => :bar, :bee => :baz)
+        @object.confine(:foo => :bar, :bee => :baz)
+    end
+
+    it "should create a new confine collection if one does not exist" do
+        Puppet::Provider::ConfineCollection.expects(:new).with("mylabel").returns "mycoll"
+        @object.expects(:to_s).returns "mylabel"
+        @object.confine_collection.should == "mycoll"
+    end
+
+    it "should reuse the confine collection" do
+        @object.confine_collection.should equal(@object.confine_collection)
+    end
+
+    describe "when testing suitability" do
+        before do
+            @coll = mock 'collection'
+            @object.stubs(:confine_collection).returns @coll
+        end
+
+        it "should return true if the confine collection is valid" do
+            @coll.expects(:valid?).returns true
+            @object.should be_suitable
+        end
+
+        it "should return false if the confine collection is invalid" do
+            @coll.expects(:valid?).returns false
+            @object.should_not be_suitable
+        end
+
+        it "should return the summary of the confine collection if a long result is asked for" do
+            @coll.expects(:summary).returns "myresult"
+            @object.suitable?(false).should == "myresult"
+        end
+    end
+end

data/spec/unit/provider/group/groupadd.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:group).provider(:groupadd)
+
+describe provider_class do
+    before do
+        @resource = stub("resource", :name => "mygroup")
+        @provider = provider_class.new(@resource)
+    end
+
+    # #1360
+    it "should add -o when allowdupe is enabled and the group is being created" do
+        @resource.stubs(:should).returns "fakeval"
+        @resource.stubs(:[]).returns "fakeval"
+        @resource.expects(:allowdupe?).returns true
+        @provider.expects(:execute).with { |args| args.include?("-o") }
+
+        @provider.create
+    end
+
+    it "should add -o when allowdupe is enabled and the gid is being modified" do
+        @resource.stubs(:should).returns "fakeval"
+        @resource.stubs(:[]).returns "fakeval"
+        @resource.expects(:allowdupe?).returns true
+        @provider.expects(:execute).with { |args| args.include?("-o") }
+
+        @provider.gid = 150
+    end
+end

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

@@ -0,0 +1,105 @@
+#!/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(:group).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 :posixGroup objectclass" do
+        provider_class.manager.objectclasses.should == [:posixGroup]
+    end
+
+    it "should use 'ou=Groups' as its relative base" do
+        provider_class.manager.location.should == "ou=Groups"
+    end
+
+    it "should use :cn as its rdn" do
+        provider_class.manager.rdn.should == :cn
+    end
+
+    it "should map :name to 'cn'" do
+        provider_class.manager.ldap_name(:name).should == 'cn'
+    end
+
+    it "should map :gid to 'gidNumber'" do
+        provider_class.manager.ldap_name(:gid).should == 'gidNumber'
+    end
+
+    it "should map :members to 'memberUid', to be used by the user ldap provider" do
+        provider_class.manager.ldap_name(:members).should == 'memberUid'
+    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
+
+        describe "with no gid specified" do
+            it "should pick the first available GID after the largest existing GID" do
+                low = {:name=>["luke"], :gid=>["600"]}
+                high = {:name=>["testing"], :gid=>["640"]}
+                provider_class.manager.expects(:search).returns([low, high])
+
+                resource = stub 'resource', :should => %w{whatever}
+                resource.stubs(:should).with(:gid).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["gidNumber"] == ["641"] }
+
+                instance.create
+                instance.flush
+            end
+
+            it "should pick '501' as its GID if no groups are found" do
+                provider_class.manager.expects(:search).returns nil
+
+                resource = stub 'resource', :should => %w{whatever}
+                resource.stubs(:should).with(:gid).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["gidNumber"] == ["501"] }
+
+                instance.create
+                instance.flush
+            end
+        end
+    end
+
+    it "should have a method for converting group names to GIDs" do
+        provider_class.should respond_to(:name2id)
+    end
+
+    describe "when converting from a group name to GID" do
+        it "should use the ldap manager to look up the GID" do
+            provider_class.manager.expects(:search).with("cn=foo")
+            provider_class.name2id("foo")
+        end
+
+        it "should return nil if no group is found" do
+            provider_class.manager.expects(:search).with("cn=foo").returns nil
+            provider_class.name2id("foo").should be_nil
+            provider_class.manager.expects(:search).with("cn=bar").returns []
+            provider_class.name2id("bar").should be_nil
+        end
+
+        # We shouldn't ever actually have more than one gid, but it doesn't hurt
+        # to test for the possibility.
+        it "should return the first gid from the first returned group" do
+            provider_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
+            provider_class.name2id("foo").should == 10
+        end
+    end
+end

data/spec/unit/provider/ldap.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-21.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/ldap'
+
+describe Puppet::Provider::Ldap do
+    before do
+        @class = Class.new(Puppet::Provider::Ldap)
+    end
+
+    it "should be able to define its manager" do
+        manager = mock 'manager'
+        Puppet::Util::Ldap::Manager.expects(:new).returns manager
+        @class.stubs :mk_resource_methods
+        manager.expects(:manages).with(:one)
+        @class.manages(:one).should equal(manager)
+        @class.manager.should equal(manager)
+    end
+
+    it "should be able to prefetch instances from ldap" do
+        @class.should respond_to(:prefetch)
+    end
+
+    it "should create its resource getter/setter methods when the manager is defined" do
+        manager = mock 'manager'
+        Puppet::Util::Ldap::Manager.expects(:new).returns manager
+        @class.expects :mk_resource_methods
+        manager.stubs(:manages)
+        @class.manages(:one).should equal(manager)
+    end
+
+    it "should have an instances method" do
+        @class.should respond_to(:instances)
+    end
+
+    describe "when providing a list of instances" do
+        it "should convert all results returned from the manager's :search method into provider instances" do
+            manager = mock 'manager'
+            @class.stubs(:manager).returns manager
+
+            manager.expects(:search).returns %w{one two three}
+
+            @class.expects(:new).with("one").returns(1)
+            @class.expects(:new).with("two").returns(2)
+            @class.expects(:new).with("three").returns(3)
+
+            @class.instances.should == [1,2,3]
+        end
+    end
+
+    it "should have a prefetch method" do
+        @class.should respond_to(:prefetch)
+    end
+
+    describe "when prefetching" do
+        before do
+            @manager = mock 'manager'
+            @class.stubs(:manager).returns @manager
+
+            @resource = mock 'resource'
+
+            @resources = {"one" => @resource}
+        end
+
+        it "should find an entry for each passed resource" do
+            @manager.expects(:find).with("one").returns nil
+
+            @class.stubs(:new)
+            @resource.stubs(:provider=)
+            @class.prefetch(@resources)
+        end
+
+        describe "resources that do not exist" do
+            it "should create a provider with :ensure => :absent" do
+                result = mock 'result'
+                @manager.expects(:find).with("one").returns nil
+
+                @class.expects(:new).with(:ensure => :absent).returns "myprovider"
+
+                @resource.expects(:provider=).with("myprovider")
+
+                @class.prefetch(@resources)
+            end
+        end
+
+        describe "resources that exist" do
+            it "should create a provider with the results of the find" do
+                @manager.expects(:find).with("one").returns("one" => "two")
+
+                @class.expects(:new).with("one" => "two", :ensure => :present).returns "myprovider"
+
+                @resource.expects(:provider=).with("myprovider")
+
+                @class.prefetch(@resources)
+            end
+
+            it "should set :ensure to :present in the returned values" do
+                @manager.expects(:find).with("one").returns("one" => "two")
+
+                @class.expects(:new).with("one" => "two", :ensure => :present).returns "myprovider"
+
+                @resource.expects(:provider=).with("myprovider")
+
+                @class.prefetch(@resources)
+            end
+        end
+    end
+
+    describe "when being initialized" do
+        it "should fail if no manager has been defined" do
+            lambda { @class.new }.should raise_error(Puppet::DevError)
+        end
+
+        it "should fail if the manager is invalid" do
+            manager = stub "manager", :valid? => false
+            @class.stubs(:manager).returns manager
+            lambda { @class.new }.should raise_error(Puppet::DevError)
+        end
+
+        describe "with a hash" do
+            before do
+                @manager = stub "manager", :valid? => true
+                @class.stubs(:manager).returns @manager
+
+                @resource_class = mock 'resource_class'
+                @class.stubs(:resource_type).returns @resource_class
+
+                @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
+                @resource_class.stubs(:attrclass).with(:one).returns(@property_class)
+                @resource_class.stubs(:validattr?).returns true
+            end
+
+            it "should store a copy of the hash as its ldap_properties" do
+                instance = @class.new(:one => :two)
+                instance.ldap_properties.should == {:one => :two}
+            end
+
+            it "should only store the first value of each value array for those attributes that do not match all values" do
+                @property_class.expects(:array_matching).returns :first
+                instance = @class.new(:one => %w{two three})
+                instance.properties.should == {:one => "two"}
+            end
+
+            it "should store the whole value array for those attributes that match all values" do
+                @property_class.expects(:array_matching).returns :all
+                instance = @class.new(:one => %w{two three})
+                instance.properties.should == {:one => %w{two three}}
+            end
+
+            it "should only use the first value for attributes that are not properties" do
+                # Yay.  hackish, but easier than mocking everything.
+                @resource_class.expects(:attrclass).with(:a).returns Puppet::Type.type(:user).attrclass(:name)
+                @property_class.stubs(:array_matching).returns :all
+
+                instance = @class.new(:one => %w{two three}, :a => %w{b c})
+                instance.properties.should == {:one => %w{two three}, :a => "b"}
+            end
+
+            it "should discard any properties not valid in the resource class" do
+                @resource_class.expects(:validattr?).with(:a).returns false
+                @property_class.stubs(:array_matching).returns :all
+
+                instance = @class.new(:one => %w{two three}, :a => %w{b})
+                instance.properties.should == {:one => %w{two three}}
+            end
+        end
+    end
+
+    describe "when an instance" do
+        before do
+            @manager = stub "manager", :valid? => true
+            @class.stubs(:manager).returns @manager
+            @instance = @class.new
+
+            @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
+            @resource_class = stub 'resource_class', :attrclass => @property_class, :validattr? => true, :validproperties => [:one, :two]
+            @class.stubs(:resource_type).returns @resource_class
+        end
+
+        it "should have a method for creating the ldap entry" do
+            @instance.should respond_to(:create)
+        end
+
+        it "should have a method for removing the ldap entry" do
+            @instance.should respond_to(:delete)
+        end
+
+        it "should have a method for returning the class's manager" do
+            @instance.manager.should equal(@manager)
+        end
+
+        it "should indicate when the ldap entry already exists" do
+            @instance = @class.new(:ensure => :present)
+            @instance.exists?.should be_true
+        end
+
+        it "should indicate when the ldap entry does not exist" do
+            @instance = @class.new(:ensure => :absent)
+            @instance.exists?.should be_false
+        end
+
+        describe "is being flushed" do
+            it "should call the manager's :update method with its name, current attributes, and desired attributes" do
+                @instance.stubs(:name).returns "myname"
+                @instance.stubs(:ldap_properties).returns(:one => :two)
+                @instance.stubs(:properties).returns(:three => :four)
+                @manager.expects(:update).with(@instance.name, {:one => :two}, {:three => :four})
+                @instance.flush
+            end
+        end
+
+        describe "is being created" do
+            before do
+                @rclass = mock 'resource_class'
+                @rclass.stubs(:validproperties).returns([:one, :two])
+                @resource = mock 'resource'
+                @resource.stubs(:class).returns @rclass
+                @resource.stubs(:should).returns nil
+                @instance.stubs(:resource).returns @resource
+            end
+
+            it "should set its :ensure value to :present" do
+                @instance.create
+                @instance.properties[:ensure].should == :present
+            end
+
+            it "should set all of the other attributes from the resource" do
+                @resource.expects(:should).with(:one).returns "oneval"
+                @resource.expects(:should).with(:two).returns "twoval"
+
+                @instance.create
+                @instance.properties[:one].should == "oneval"
+                @instance.properties[:two].should == "twoval"
+            end
+        end
+
+        describe "is being deleted" do
+            it "should set its :ensure value to :absent" do
+                @instance.delete
+                @instance.properties[:ensure].should == :absent
+            end
+        end
+    end
+end