puppet 0.24.6 → 0.24.7

data/spec/unit/type/file/ensure.rb

@@ -0,0 +1,21 @@
+#!/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") }
+
+property = Puppet::Type.type(:file).attrclass(:ensure)
+
+describe property do
+    before do
+        @resource = stub 'resource', :line => "foo", :file => "bar", :replace? => true
+        @resource.stubs(:[]).returns "foo"
+        @resource.stubs(:[]).with(:path).returns "/my/file"
+        @ensure = property.new :resource => @resource
+    end
+
+    describe "when testing whether in sync" do
+        it "should always be in sync if replace is 'false' unless the file is missing" do
+            @resource.expects(:replace?).returns false
+            @ensure.insync?(:link).should be_true
+        end
+    end
+end

data/spec/unit/type/file/group.rb

@@ -0,0 +1,118 @@
+#!/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") }
+
+property = Puppet::Type.type(:file).attrclass(:group)
+
+describe property do
+    before do
+        @resource = stub 'resource', :line => "foo", :file => "bar"
+        @resource.stubs(:[]).returns "foo"
+        @resource.stubs(:[]).with(:path).returns "/my/file"
+        @group = property.new :resource => @resource
+    end
+
+    it "should have a method for testing whether a group is valid" do
+        @group.must respond_to(:validgroup?)
+    end
+
+    it "should return the found gid if a group is valid" do
+        @group.expects(:gid).with("foo").returns 500
+        @group.validgroup?("foo").should == 500
+    end
+
+    it "should return false if a group is not valid" do
+        @group.expects(:gid).with("foo").returns nil
+        @group.validgroup?("foo").should be_false
+    end
+
+    describe "when retrieving the current value" do
+        it "should return :absent if the file cannot stat" do
+            @resource.expects(:stat).returns nil
+
+            @group.retrieve.should == :absent
+        end
+
+        it "should get the gid from the stat instance from the file" do
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            stat.expects(:gid).returns 500
+
+            @group.retrieve.should == 500
+        end
+
+        it "should warn and return :silly if the found value is higher than the maximum uid value" do
+            Puppet.settings.expects(:value).with(:maximum_uid).returns 500
+
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            stat.expects(:gid).returns 1000
+
+            @group.expects(:warning)
+            @group.retrieve.should == :silly
+        end
+    end
+
+    describe "when determining if the file is in sync" do
+        it "should directly compare the group values if the desired group is an integer" do
+            @group.should = [10]
+            @group.must be_insync(10)
+        end
+
+        it "should treat numeric strings as integers" do
+            @group.should = ["10"]
+            @group.must be_insync(10)
+        end
+
+        it "should convert the group name to an integer if the desired group is a string" do
+            @group.expects(:gid).with("foo").returns 10
+            @group.should = %w{foo}
+
+            @group.must be_insync(10)
+        end
+
+        it "should fail if it cannot convert a group name to an integer" do
+            @group.expects(:gid).with("foo").returns nil
+            @group.should = %w{foo}
+
+            lambda { @group.insync?(10) }.should raise_error(Puppet::Error)
+        end
+
+        it "should return false if the groups are not equal" do
+            @group.should = [10]
+            @group.should_not be_insync(20)
+        end
+    end
+
+    describe "when changing the group" do
+        before do
+            @group.should = %w{one}
+            @group.stubs(:gid).returns 500
+        end
+
+        it "should chown the file if :links is set to :follow" do
+            @resource.expects(:[]).with(:links).returns :follow
+            File.expects(:chown)
+
+            @group.sync
+        end
+
+        it "should lchown the file if :links is set to :manage" do
+            @resource.expects(:[]).with(:links).returns :manage
+            File.expects(:lchown)
+
+            @group.sync
+        end
+
+        it "should use the first valid group in its 'should' list" do
+            @group.should = %w{one two three}
+            @group.expects(:validgroup?).with("one").returns nil
+            @group.expects(:validgroup?).with("two").returns 500
+            @group.expects(:validgroup?).with("three").never
+
+            File.expects(:chown).with(nil, 500, "/my/file")
+
+            @group.sync
+        end
+    end
+end

data/spec/unit/type/file/owner.rb

@@ -0,0 +1,132 @@
+#!/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") }
+
+property = Puppet::Type.type(:file).attrclass(:owner)
+
+describe property do
+    before do
+        @resource = stub 'resource', :line => "foo", :file => "bar"
+        @resource.stubs(:[]).returns "foo"
+        @resource.stubs(:[]).with(:path).returns "/my/file"
+        @owner = property.new :resource => @resource
+    end
+
+    it "should have a method for testing whether an owner is valid" do
+        @owner.must respond_to(:validuser?)
+    end
+
+    it "should return the found uid if an owner is valid" do
+        @owner.expects(:uid).with("foo").returns 500
+        @owner.validuser?("foo").should == 500
+    end
+
+    it "should return false if an owner is not valid" do
+        @owner.expects(:uid).with("foo").returns nil
+        @owner.validuser?("foo").should be_false
+    end
+
+    describe "when retrieving the current value" do
+        it "should return :absent if the file cannot stat" do
+            @resource.expects(:stat).returns nil
+
+            @owner.retrieve.should == :absent
+        end
+
+        it "should get the uid from the stat instance from the file" do
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            stat.expects(:uid).returns 500
+
+            @owner.retrieve.should == 500
+        end
+
+        it "should warn and return :silly if the found value is higher than the maximum uid value" do
+            Puppet.settings.expects(:value).with(:maximum_uid).returns 500
+
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            stat.expects(:uid).returns 1000
+
+            @owner.expects(:warning)
+            @owner.retrieve.should == :silly
+        end
+    end
+
+    describe "when determining if the file is in sync" do
+        describe "and not running as root" do
+            it "should warn and return true" do
+                @owner.should = 10
+                Puppet::Util::SUIDManager.expects(:uid).returns 1
+                @owner.expects(:warning)
+                @owner.must be_insync("whatever")
+            end
+        end
+
+        before do
+            Puppet::Util::SUIDManager.stubs(:uid).returns 0
+        end
+
+        it "should directly compare the owner values if the desired owner is an integer" do
+            @owner.should = [10]
+            @owner.must be_insync(10)
+        end
+
+        it "should treat numeric strings as integers" do
+            @owner.should = ["10"]
+            @owner.must be_insync(10)
+        end
+
+        it "should convert the owner name to an integer if the desired owner is a string" do
+            @owner.expects(:uid).with("foo").returns 10
+            @owner.should = %w{foo}
+
+            @owner.must be_insync(10)
+        end
+
+        it "should fail if it cannot convert an owner name to an integer" do
+            @owner.expects(:uid).with("foo").returns nil
+            @owner.should = %w{foo}
+
+            lambda { @owner.insync?(10) }.should raise_error(Puppet::Error)
+        end
+
+        it "should return false if the owners are not equal" do
+            @owner.should = [10]
+            @owner.should_not be_insync(20)
+        end
+    end
+
+    describe "when changing the owner" do
+        before do
+            @owner.should = %w{one}
+            @owner.stubs(:path).returns "path"
+            @owner.stubs(:uid).returns 500
+        end
+
+        it "should chown the file if :links is set to :follow" do
+            @resource.expects(:[]).with(:links).returns :follow
+            File.expects(:chown)
+
+            @owner.sync
+        end
+
+        it "should lchown the file if :links is set to :manage" do
+            @resource.expects(:[]).with(:links).returns :manage
+            File.expects(:lchown)
+
+            @owner.sync
+        end
+
+        it "should use the first valid owner in its 'should' list" do
+            @owner.should = %w{one two three}
+            @owner.expects(:validuser?).with("one").returns nil
+            @owner.expects(:validuser?).with("two").returns 500
+            @owner.expects(:validuser?).with("three").never
+
+            File.expects(:chown).with(500, nil, "/my/file")
+
+            @owner.sync
+        end
+    end
+end

data/spec/unit/type/file/selinux.rb

@@ -0,0 +1,82 @@
+#!/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") }
+
+
+[:seluser, :selrole, :seltype, :selrange].each do |param|
+    property = Puppet::Type.type(:file).attrclass(param)
+    describe property do
+        before do
+            @resource = mock 'resource'
+            @resource.stubs(:[]).with(:path).returns "/my/file"
+            @sel = property.new :resource => @resource
+        end
+
+        it "retrieve on #{param} should return :absent if the file isn't statable" do
+            @resource.expects(:stat).returns nil
+            @sel.retrieve.should == :absent
+        end
+
+        it "should retrieve nil for #{param} if there is no SELinux support" do
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            @sel.expects(:get_selinux_current_context).with("/my/file").returns nil
+            @sel.retrieve.should be_nil
+        end
+
+        it "should retrieve #{param} if a SELinux context is found with a range" do
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            @sel.expects(:get_selinux_current_context).with("/my/file").returns "user_u:role_r:type_t:s0"
+            expectedresult = case param
+                when :seluser then "user_u"
+                when :selrole then "role_r"
+                when :seltype then "type_t"
+                when :selrange then "s0"
+            end
+            @sel.retrieve.should == expectedresult
+        end
+
+        it "should retrieve #{param} if a SELinux context is found without a range" do
+            stat = stub 'stat', :ftype => "foo"
+            @resource.expects(:stat).returns stat
+            @sel.expects(:get_selinux_current_context).with("/my/file").returns "user_u:role_r:type_t"
+            expectedresult = case param
+                when :seluser then "user_u"
+                when :selrole then "role_r"
+                when :seltype then "type_t"
+                when :selrange then nil
+            end
+            @sel.retrieve.should == expectedresult
+        end
+
+        it "should handle no default gracefully" do
+            @sel.expects(:get_selinux_default_context).with("/my/file").returns nil
+            @sel.default.must be_nil
+        end
+
+        it "should be able to detect matchpathcon defaults" do
+            @sel.stubs(:debug)
+            @sel.expects(:get_selinux_default_context).with("/my/file").returns "user_u:role_r:type_t:s0"
+            expectedresult = case param
+                when :seluser then "user_u"
+                when :selrole then "role_r"
+                when :seltype then "type_t"
+                when :selrange then "s0"
+            end
+            @sel.default.must == expectedresult
+        end
+
+        it "should be able to set a new context" do
+            stat = stub 'stat', :ftype => "foo"
+            @sel.should = %w{newone}
+            @sel.expects(:set_selinux_context).with("/my/file", ["newone"], param)
+            @sel.sync
+        end
+
+        after do
+            Puppet::Type.type(:file).clear
+        end
+    end
+end
+

data/spec/unit/type/group.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:group) do
+    before do
+        @class = Puppet::Type.type(:group)
+    end
+
+    after do
+        @class.clear
+    end
+
+    it "should have a default provider" do
+        @class.defaultprovider.should_not be_nil
+    end
+
+    it "should have a default provider inheriting from Puppet::Provider" do
+        @class.defaultprovider.ancestors.should be_include(Puppet::Provider)
+    end
+
+    describe "when validating attributes" do
+        [:name, :allowdupe].each do |param|
+            it "should have a #{param} parameter" do
+                @class.attrtype(param).should == :param
+            end
+        end
+
+        [:ensure, :gid].each do |param|
+            it "should have a #{param} property" do
+                @class.attrtype(param).should == :property
+            end
+        end
+    end
+
+    # #1407 - we need to declare the allowdupe param as boolean.
+    it "should have a boolean method for determining if duplicates are allowed" do
+        @class.create(:name => "foo").methods.should be_include("allowdupe?")
+    end
+end

data/spec/unit/type/macauthorization.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+macauth_type = Puppet::Type.type(:macauthorization)
+
+describe Puppet.type(:macauthorization), "when checking macauthorization objects" do
+    
+    before do
+        authplist = {}
+        authplist["rules"] = { "foorule" => "foo" }
+        authplist["rights"] = { "fooright" => "foo" }
+        provider_class = macauth_type.provider(macauth_type.providers[0])
+        Plist.stubs(:parse_xml).with("/etc/authorization").returns(authplist)
+        macauth_type.stubs(:defaultprovider).returns provider_class
+    end
+    
+    after do
+        macauth_type.clear
+    end
+        
+    
+    describe "when validating attributes" do
+    
+        parameters = [:name,]
+        properties = [:auth_type, :allow_root, :authenticate_user, :auth_class, 
+                      :comment, :group, :k_of_n, :mechanisms, :rule, 
+                      :session_owner, :shared, :timeout, :tries]
+    
+        parameters.each do |parameter|
+            it "should have a %s parameter" % parameter do
+                macauth_type.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+            end
+    
+            it "should have documentation for its %s parameter" % parameter do
+                macauth_type.attrclass(parameter).doc.should be_instance_of(String)
+            end
+        end
+    
+        properties.each do |property|
+            it "should have a %s property" % property do
+                macauth_type.attrclass(property).ancestors.should be_include(Puppet::Property)
+            end
+    
+            it "should have documentation for its %s property" % property do
+                macauth_type.attrclass(property).doc.should be_instance_of(String)
+            end
+        end
+    
+    end
+    
+    describe "when validating properties" do
+        
+        it "should have a default provider inheriting from Puppet::Provider" do
+            macauth_type.defaultprovider.ancestors.should be_include(Puppet::Provider)
+        end
+    
+        it "should be able to create an instance" do
+            lambda {
+                macauth_type.create(:name => 'foo')
+            }.should_not raise_error
+        end
+            
+        it "should support :present as a value to :ensure" do
+            lambda {
+                macauth_type.create(:name => "foo", :ensure => :present)
+            }.should_not raise_error
+        end
+            
+        it "should support :absent as a value to :ensure" do
+            lambda {
+                macauth_type.create(:name => "foo", :ensure => :absent)
+            }.should_not raise_error
+        end
+    
+    end
+
+end