puppet 0.24.6 → 0.24.7

data/spec/unit/type/ssh_authorized_key.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+ssh_authorized_key = Puppet::Type.type(:ssh_authorized_key)
+
+describe ssh_authorized_key do
+    before do
+        @class = Puppet::Type.type(:ssh_authorized_key)
+
+        @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
+        @class.stubs(:defaultprovider).returns(@provider_class)
+        @class.stubs(:provider).returns(@provider_class)
+
+        @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
+        @provider_class.stubs(:new).returns(@provider)
+        @catalog = Puppet::Node::Catalog.new
+    end
+
+    it "should have a name parameter" do
+        @class.attrtype(:name).should == :param
+    end
+
+    it "should have :name be its namevar" do
+        @class.namevar.should == :name
+    end
+
+    it "should have a :provider parameter" do
+        @class.attrtype(:provider).should == :param
+    end
+
+    it "should have an ensure property" do
+        @class.attrtype(:ensure).should == :property
+    end
+
+    it "should support :present as a value for :ensure" do
+        proc { @class.create(:name => "whev", :ensure => :present, :user => "nobody") }.should_not raise_error
+    end
+
+    it "should support :absent as a value for :ensure" do
+        proc { @class.create(:name => "whev", :ensure => :absent, :user => "nobody") }.should_not raise_error
+    end
+
+    it "should have an type property" do
+        @class.attrtype(:type).should == :property
+    end
+    it "should support ssh-dss as an type value" do
+        proc { @class.create(:name => "whev", :type => "ssh-dss", :user => "nobody") }.should_not raise_error
+    end
+    it "should support ssh-rsa as an type value" do
+        proc { @class.create(:name => "whev", :type => "ssh-rsa", :user => "nobody") }.should_not raise_error
+    end
+    it "should support :dsa as an type value" do
+        proc { @class.create(:name => "whev", :type => :dsa, :user => "nobody") }.should_not raise_error
+    end
+    it "should support :rsa as an type value" do
+        proc { @class.create(:name => "whev", :type => :rsa, :user => "nobody") }.should_not raise_error
+    end
+
+    it "should not support values other than ssh-dss, ssh-rsa, dsa, rsa in the ssh_authorized_key_type" do
+        proc { @class.create(:name => "whev", :type => :something) }.should raise_error(Puppet::Error)
+    end
+
+    it "should have an key property" do
+        @class.attrtype(:key).should == :property
+    end
+
+    it "should have an user property" do
+        @class.attrtype(:user).should == :property
+    end
+
+    it "should have an options property" do
+        @class.attrtype(:options).should == :property
+    end
+
+    it "'s options property should return well formed string of arrays from is_to_s" do
+        resource = @class.create(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
+
+        resource.property(:options).is_to_s(["a","b","c"]).should == "a,b,c"
+    end
+
+    it "'s options property should return well formed string of arrays from is_to_s" do
+        resource = @class.create(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
+
+        resource.property(:options).should_to_s(["a","b","c"]).should == "a,b,c"
+    end
+
+    it "should have a target property" do
+        @class.attrtype(:target).should == :property
+    end
+
+    it "should raise an error when neither user nor target is given" do
+        proc do
+            @class.create(
+              :name   => "Test",
+              :key    => "AAA",
+              :type   => "ssh-rsa",
+              :ensure => :present)
+        end.should raise_error(Puppet::Error)
+    end
+
+    after do
+      @class.clear
+      @catalog.clear
+    end
+end

data/spec/unit/type/tidy.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+tidy = Puppet::Type.type(:tidy)
+
+describe tidy do
+    after { tidy.clear }
+    
+    it "should be in sync if the targeted file does not exist" do
+        File.expects(:lstat).with("/tmp/foonesslaters").raises Errno::ENOENT
+        @tidy = tidy.create :path => "/tmp/foonesslaters", :age => "100d"
+
+        @tidy.property(:ensure).must be_insync({})
+    end
+
+    [:ensure, :age, :size].each do |property|
+        it "should have a %s property" % property do
+            tidy.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+
+        it "should have documentation for its %s property" % property do
+            tidy.attrclass(property).doc.should be_instance_of(String)
+        end
+    end
+
+    [:path, :matches, :type, :recurse, :rmdirs].each do |param|
+        it "should have a %s parameter" % param do
+            tidy.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+        end
+
+        it "should have documentation for its %s param" % param do
+            tidy.attrclass(param).doc.should be_instance_of(String)
+        end
+    end
+
+    describe "when validating parameter values" do
+        describe "for 'recurse'" do
+            before do
+                @tidy = tidy.create :path => "/tmp", :age => "100d"
+            end
+
+            it "should allow 'true'" do
+                lambda { @tidy[:recurse] = true }.should_not raise_error
+            end
+
+            it "should allow 'false'" do
+                lambda { @tidy[:recurse] = false }.should_not raise_error
+            end
+
+            it "should allow integers" do
+                lambda { @tidy[:recurse] = 10 }.should_not raise_error
+            end
+
+            it "should allow string representations of integers" do
+                lambda { @tidy[:recurse] = "10" }.should_not raise_error
+            end
+
+            it "should allow 'inf'" do
+                lambda { @tidy[:recurse] = "inf" }.should_not raise_error
+            end
+
+            it "should not allow arbitrary values" do
+                lambda { @tidy[:recurse] = "whatever" }.should raise_error
+            end
+        end
+    end
+end

data/spec/unit/type/user.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+user = Puppet::Type.type(:user)
+
+describe user do
+    before do
+        @provider = stub 'provider'
+        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
+    end
+
+    after { user.clear }
+
+    it "should have a default provider inheriting from Puppet::Provider" do
+        user.defaultprovider.ancestors.should be_include(Puppet::Provider)
+    end
+
+    it "should be able to create a instance" do
+        user.create(:name => "foo").should_not be_nil
+    end
+
+    it "should have an allows_duplicates feature" do
+        user.provider_feature(:allows_duplicates).should_not be_nil
+    end
+
+    it "should have an manages_homedir feature" do
+        user.provider_feature(:manages_homedir).should_not be_nil
+    end
+
+    it "should have an manages_passwords feature" do
+        user.provider_feature(:manages_passwords).should_not be_nil
+    end
+
+    it "should have a manages_solaris_rbac feature" do
+        user.provider_feature(:manages_solaris_rbac).should_not be_nil
+    end
+
+    describe "instances" do
+        it "should have a valid provider" do
+            user.create(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+        end
+    end
+
+    properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :groups, :roles, :auths, :profiles, :project, :keys]
+
+    properties.each do |property|
+        it "should have a %s property" % property do
+            user.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+
+        it "should have documentation for its %s property" % property do
+            user.attrclass(property).doc.should be_instance_of(String)
+        end
+    end
+
+    list_properties = [:groups, :roles, :auths]
+
+    list_properties.each do |property|
+        it "should have a list '%s'" % property do
+            user.attrclass(property).ancestors.should be_include(Puppet::Property::List)
+        end
+    end
+
+    it "should have an ordered list 'profiles'" do
+        user.attrclass(:profiles).ancestors.should be_include(Puppet::Property::OrderedList)
+    end
+
+    it "should have key values 'keys'" do
+        user.attrclass(:keys).ancestors.should be_include(Puppet::Property::KeyValue)
+    end
+
+    describe "when retrieving all current values" do
+        before do
+            @user = user.create(:name => "foo", :uid => 10, :gid => 10)
+            @properties = {}
+        end
+
+        it "should return a hash containing values for all set properties" do
+            values = @user.retrieve
+            [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
+        end
+
+        it "should set all values to :absent if the user is absent" do
+            @user.property(:ensure).expects(:retrieve).returns :absent
+            @user.property(:uid).expects(:retrieve).never
+            @user.retrieve[@user.property(:uid)].should == :absent
+        end
+
+        it "should include the result of retrieving each property's current value if the user is present" do
+            @user.property(:ensure).expects(:retrieve).returns :present
+            @user.property(:uid).expects(:retrieve).returns 15
+            @user.retrieve[@user.property(:uid)].should == 15
+        end
+    end
+
+    describe "when managing the ensure property" do
+        before do
+            @ensure = user.attrclass(:ensure).new(:resource => @resource)
+        end
+
+        it "should support a :present value" do
+            lambda { @ensure.should = :present }.should_not raise_error
+        end
+
+        it "should support an :absent value" do
+            lambda { @ensure.should = :absent }.should_not raise_error
+        end
+
+        it "should call :create on the provider when asked to sync to the :present state" do
+            @provider.expects(:create)
+            @ensure.should = :present
+            @ensure.sync
+        end
+
+        it "should call :delete on the provider when asked to sync to the :absent state" do
+            @provider.expects(:delete)
+            @ensure.should = :absent
+            @ensure.sync
+        end
+
+        describe "and determining the current state" do
+            it "should return :present when the provider indicates the user exists" do
+                @provider.expects(:exists?).returns true
+                @ensure.retrieve.should == :present
+            end
+
+            it "should return :absent when the provider indicates the user does not exist" do
+                @provider.expects(:exists?).returns false
+                @ensure.retrieve.should == :absent
+            end
+        end
+    end
+
+    describe "when managing the uid property" do
+        it "should convert number-looking strings into actual numbers" do
+            uid = user.attrclass(:uid).new(:resource => @resource)
+            uid.should = "50"
+            uid.should.must == 50
+        end
+
+        it "should support UIDs as numbers" do
+            uid = user.attrclass(:uid).new(:resource => @resource)
+            uid.should = 50
+            uid.should.must == 50
+        end
+
+        it "should :absent as a value" do
+            uid = user.attrclass(:uid).new(:resource => @resource)
+            uid.should = :absent
+            uid.should.must == :absent
+        end
+    end
+
+    describe "when managing the gid" do
+        it "should :absent as a value" do
+            gid = user.attrclass(:gid).new(:resource => @resource)
+            gid.should = :absent
+            gid.should.must == :absent
+        end
+
+        it "should convert number-looking strings into actual numbers" do
+            gid = user.attrclass(:gid).new(:resource => @resource)
+            gid.should = "50"
+            gid.should.must == 50
+        end
+
+        it "should support GIDs specified as integers" do
+            gid = user.attrclass(:gid).new(:resource => @resource)
+            gid.should = 50
+            gid.should.must == 50
+        end
+
+        it "should support groups specified by name" do
+            gid = user.attrclass(:gid).new(:resource => @resource)
+            gid.should = "foo"
+            gid.should.must == "foo"
+        end
+
+        describe "when testing whether in sync" do
+            before do
+                @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
+            end
+
+            it "should return true if any of the specified groups are equal to the current integer" do
+                Puppet::Util.expects(:gid).with("foo").returns 300
+                Puppet::Util.expects(:gid).with("bar").returns 500
+
+                @gid.must be_insync(500)
+            end
+
+            it "should return false if none of the specified groups are equal to the current integer" do
+                Puppet::Util.expects(:gid).with("foo").returns 300
+                Puppet::Util.expects(:gid).with("bar").returns 500
+
+                @gid.should_not be_insync(700)
+            end
+        end
+
+        describe "when syncing" do
+            before do
+                @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
+            end
+
+            it "should use the first found, specified group as the desired value and send it to the provider" do
+                Puppet::Util.expects(:gid).with("foo").returns nil
+                Puppet::Util.expects(:gid).with("bar").returns 500
+
+                @provider.expects(:gid=).with 500
+
+                @gid.sync
+            end
+        end
+    end
+
+    describe "when managing passwords" do
+        before do
+            @password = user.attrclass(:password).new(:resource => @resource, :should => "mypass")
+        end
+
+        it "should not include the password in the change log when adding the password" do
+            @password.change_to_s(:absent, "mypass").should_not be_include("mypass")
+        end
+
+        it "should not include the password in the change log when changing the password" do
+            @password.change_to_s("other", "mypass").should_not be_include("mypass")
+        end
+    end
+
+    describe "when manages_solaris_rbac is enabled" do
+        before do
+            @provider.stubs(:satisfies?).returns(false)
+            @provider.expects(:satisfies?).with(:manages_solaris_rbac).returns(true)
+        end
+
+        it "should support a :role value for ensure" do
+            @ensure = user.attrclass(:ensure).new(:resource => @resource)
+            lambda { @ensure.should = :role }.should_not raise_error
+        end
+    end
+
+    describe "when user has roles" do
+        it "should autorequire roles" do
+            #this is a little funky because the autorequire depends on a property with a feature
+            testuser = Puppet.type(:user).create(:name => "testuser")
+            testuser.provider.class.expects(:feature?).with(:manages_solaris_rbac).returns(true)
+            testuser[:roles] = "testrole"
+
+            testrole = Puppet.type(:user).create(:name => "testrole")
+
+            config = Puppet::Node::Catalog.new :testing do |conf|
+                [testuser, testrole].each { |resource| conf.add_resource resource }
+            end
+
+            rel = testuser.autorequire[0]
+            rel.source.ref.should == testrole.ref
+            rel.target.ref.should == testuser.ref
+        end
+    end
+end

data/spec/unit/type/zfs.rb

@@ -0,0 +1,45 @@
+#!/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") }
+
+zfs = Puppet::Type.type(:zfs)
+
+describe zfs do
+    properties = [:ensure, :mountpoint, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir]
+
+    properties.each do |property|
+        it "should have a %s property" % property do
+            zfs.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+    end
+
+    parameters = [:name]
+
+    parameters.each do |parameter|
+        it "should have a %s parameter" % parameter do
+            zfs.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+        end
+    end
+
+    it "should autorequire the containing zfss and the zpool" do
+        provider = mock "provider"
+        provider.stubs(:name).returns(:solaris)
+        zfs.stubs(:defaultprovider).returns(provider)
+        Puppet.type(:zpool).stubs(:defaultprovider).returns(provider)
+
+
+        foo_pool = Puppet.type(:zpool).create(:name => "foo")
+
+        foo_bar_zfs = Puppet.type(:zfs).create(:name => "foo/bar")
+        foo_bar_baz_zfs = Puppet.type(:zfs).create(:name => "foo/bar/baz")
+        foo_bar_baz_buz_zfs = Puppet.type(:zfs).create(:name => "foo/bar/baz/buz")
+
+        config = Puppet::Node::Catalog.new :testing do |conf|
+            [foo_pool, foo_bar_zfs, foo_bar_baz_zfs, foo_bar_baz_buz_zfs].each { |resource| conf.add_resource resource }
+        end
+
+        req = foo_bar_baz_buz_zfs.autorequire.collect { |edge| edge.source.ref }
+
+        [foo_pool.ref, foo_bar_zfs.ref, foo_bar_baz_zfs.ref].each { |ref| req.include?(ref).should == true }
+    end
+end