puppet 0.24.7 → 0.24.8

data/spec/unit/type/group.rb

@@ -4,6 +4,9 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:group) do
     before do
+        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
+        end
         @class = Puppet::Type.type(:group)
     end
 

data/spec/unit/type/noop_metaparam.rb

@@ -6,6 +6,7 @@ require 'puppet/type'
 
 describe Puppet::Type.type(:file).attrclass(:noop) do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Type.newfile :path => "/what/ever"
     end
 

data/spec/unit/type/ssh_authorized_key.rb

@@ -89,14 +89,37 @@ describe ssh_authorized_key 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)
+    describe "when neither user nor target is specified" do
+        it "should raise an error" do
+            proc do
+                @class.create(
+                  :name   => "Test",
+                  :key    => "AAA",
+                  :type   => "ssh-rsa",
+                  :ensure => :present)
+            end.should raise_error(Puppet::Error)
+        end
+    end
+
+    describe "when both target and user are specified" do
+        it "should use target" do
+            resource = @class.create(
+                :name => "Test",
+                :user => "root",
+                :target => "/tmp/blah")
+            resource.should(:target).should == "/tmp/blah"
+        end
+    end
+
+
+    describe "when user is specified" do
+        it "should determine target" do
+            resource = @class.create(
+                :name   => "Test",
+                :user   => "root")
+            target = File.expand_path("~root/.ssh/authorized_keys")
+            resource.should(:target).should == target
+        end
     end
 
     after do

data/spec/unit/type/tidy.rb

@@ -5,6 +5,10 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 tidy = Puppet::Type.type(:tidy)
 
 describe tidy do
+    before do
+        Puppet.settings.stubs(:use)
+    end
+
     after { tidy.clear }
     
     it "should be in sync if the targeted file does not exist" do

data/spec/unit/type/user.rb

@@ -6,6 +6,9 @@ user = Puppet::Type.type(:user)
 
 describe user do
     before do
+        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
+            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
+        end
         @provider = stub 'provider'
         @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
     end
@@ -182,6 +185,12 @@ describe user do
                 @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
             end
 
+            it "should return true if no 'should' values are set" do
+                @gid = user.attrclass(:gid).new(:resource => @resource)
+
+                @gid.must be_insync(500)
+            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
@@ -225,6 +234,14 @@ describe user do
         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
+
+        it "should fail if a ':' is included in the password" do
+            lambda { @password.should = "some:thing" }.should raise_error(ArgumentError)
+        end
+
+        it "should allow the value to be set to :absent" do
+            lambda { @password.should = :absent }.should_not raise_error
+        end
     end
 
     describe "when manages_solaris_rbac is enabled" do

data/spec/unit/util/autoload.rb

@@ -0,0 +1,39 @@
+#!/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") }
+
+require 'puppet/util/autoload'
+
+describe Puppet::Util::Autoload do
+    before do
+        @autoload = Puppet::Util::Autoload.new("foo", "tmp")
+
+        @autoload.stubs(:eachdir).yields "/my/dir"
+    end
+
+    describe "when loading a file" do
+        [RuntimeError, LoadError, SyntaxError].each do |error|
+            it "should not die an if a #{error.to_s} exception is thrown" do
+                FileTest.stubs(:exists?).returns true
+
+                Kernel.expects(:load).raises error
+
+                lambda { @autoload.load("foo") }.should_not raise_error
+            end
+        end
+    end
+
+    describe "when loading all files" do
+        before do
+            Dir.stubs(:glob).returns "file.rb"
+        end
+
+        [RuntimeError, LoadError, SyntaxError].each do |error|
+            it "should not die an if a #{error.to_s} exception is thrown" do
+                Kernel.expects(:require).raises error
+
+                lambda { @autoload.loadall }.should_not raise_error
+            end
+        end
+    end
+end

data/spec/unit/util/filetype.rb

@@ -0,0 +1,110 @@
+#!/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") }
+
+require 'puppet/util/filetype'
+
+# XXX Import all of the tests into this file.
+describe Puppet::Util::FileType do
+    describe "when backing up a file" do
+        before do
+            @file = Puppet::Util::FileType.filetype(:flat).new("/my/file")
+        end
+
+        it "should do nothing if the file does not exist" do
+            File.expects(:exists?).with("/my/file").returns false
+            @file.expects(:bucket).never
+            @file.backup
+        end
+
+        it "should use its filebucket to backup the file if it exists" do
+            File.expects(:exists?).with("/my/file").returns true
+
+            bucket = mock 'bucket'
+            bucket.expects(:backup).with("/my/file")
+
+            @file.expects(:bucket).returns bucket
+            @file.backup
+        end
+
+        it "should use the filebucket named 'puppet' if it finds one" do
+            bucket = mock 'bucket'
+            bucket.expects(:bucket).returns "mybucket"
+
+            Puppet::Type.type(:filebucket).expects(:[]).with("puppet").returns bucket
+
+            @file.bucket.should == "mybucket"
+        end
+
+        it "should use the default filebucket if none named 'puppet' is found" do
+            bucket = mock 'bucket'
+            bucket.expects(:bucket).returns "mybucket"
+
+            Puppet::Type.type(:filebucket).expects(:[]).with("puppet").returns nil
+            Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
+
+            @file.bucket.should == "mybucket"
+        end
+    end
+
+    describe "the flat filetype" do
+        before do
+            @type = Puppet::Util::FileType.filetype(:flat)
+        end
+        it "should exist" do
+            @type.should_not be_nil
+        end
+
+        describe "when the file already exists" do
+            it "should return the file's contents when asked to read it" do
+                file = @type.new("/my/file")
+                File.expects(:exist?).with("/my/file").returns true
+                File.expects(:read).with("/my/file").returns "my text"
+
+                file.read.should == "my text"
+            end
+
+            it "should unlink the file when asked to remove it" do
+                file = @type.new("/my/file")
+                File.expects(:exist?).with("/my/file").returns true
+                File.expects(:unlink).with("/my/file")
+
+                file.remove
+            end
+        end
+
+        describe "when the file does not exist" do
+            it "should return an empty string when asked to read the file" do
+                file = @type.new("/my/file")
+                File.expects(:exist?).with("/my/file").returns false
+
+                file.read.should == ""
+            end
+        end
+
+        describe "when writing the file" do
+            before do
+                @file = @type.new("/my/file")
+                FileUtils.stubs(:cp)
+
+                @tempfile = stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file"
+                Tempfile.stubs(:new).returns @tempfile
+            end
+
+            it "should first create a temp file and copy its contents over to the file location" do
+                Tempfile.expects(:new).with("puppet").returns @tempfile
+                @tempfile.expects(:print).with("my text")
+                @tempfile.expects(:flush)
+                @tempfile.expects(:close)
+                FileUtils.expects(:cp).with(@tempfile.path, "/my/file")
+
+                @file.write "my text"
+            end
+
+            it "should set the selinux default context on the file" do
+                @file.expects(:set_selinux_default_context).with("/my/file")
+                @file.write "eh"
+            end
+        end
+    end
+end

data/spec/unit/util/nagios_maker.rb

@@ -13,6 +13,9 @@ describe Puppet::Util::NagiosMaker do
 
         @nagtype = stub 'nagios type', :parameters => [], :namevar => :name
         Nagios::Base.stubs(:type).with(:test).returns(@nagtype)
+
+        @provider = stub 'provider', :nagios_type => nil
+        @type = stub 'type', :newparam => nil, :newproperty => nil, :provide => @provider, :desc => nil, :ensurable => nil
     end
 
     it "should be able to create a new nagios type" do
@@ -26,73 +29,59 @@ describe Puppet::Util::NagiosMaker do
     end
 
     it "should create a new RAL type with the provided name prefixed with 'nagios_'" do
-        type = stub 'type', :newparam => nil, :newproperty => nil, :ensurable => nil, :provide => nil, :desc => nil
-
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should mark the created type as ensurable" do
-        type = stub 'type', :newparam => nil, :newproperty => nil, :provide => nil, :desc => nil
+        @type.expects(:ensurable)
 
-        type.expects(:ensurable)
-
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should create a namevar parameter for the nagios type's name parameter" do
-        type = stub 'type', :newproperty => nil, :ensurable => nil, :provide => nil, :desc => nil
-
-        type.expects(:newparam).with(:name, :namevar => true)
+        @type.expects(:newparam).with(:name, :namevar => true)
 
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should create a property for all non-namevar parameters" do
-        type = stub 'type', :newparam => nil, :ensurable => nil, :provide => nil, :desc => nil
-
         @nagtype.stubs(:parameters).returns([:one, :two])
 
-        type.expects(:newproperty).with(:one)
-        type.expects(:newproperty).with(:two)
-        type.expects(:newproperty).with(:target)
+        @type.expects(:newproperty).with(:one)
+        @type.expects(:newproperty).with(:two)
+        @type.expects(:newproperty).with(:target)
 
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should skip parameters that start with integers" do
-        type = stub 'type', :newparam => nil, :ensurable => nil, :provide => nil, :desc => nil
-
         @nagtype.stubs(:parameters).returns(["2dcoords".to_sym, :other])
 
-        type.expects(:newproperty).with(:other)
-        type.expects(:newproperty).with(:target)
+        @type.expects(:newproperty).with(:other)
+        @type.expects(:newproperty).with(:target)
 
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should deduplicate the parameter list" do
-        type = stub 'type', :newparam => nil, :ensurable => nil, :provide => nil, :desc => nil
-
         @nagtype.stubs(:parameters).returns([:one, :one])
 
-        type.expects(:newproperty).with(:one)
-        type.expects(:newproperty).with(:target)
+        @type.expects(:newproperty).with(:one)
+        @type.expects(:newproperty).with(:target)
 
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 
     it "should create a target property" do
-        type = stub 'type', :newparam => nil, :ensurable => nil, :provide => nil, :desc => nil
+        @type.expects(:newproperty).with(:target)
 
-        type.expects(:newproperty).with(:target)
-
-        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(@type)
         @module.create_nagios_type(:test)
     end
 end
@@ -100,6 +89,7 @@ end
 describe Puppet::Util::NagiosMaker, " when creating the naginator provider" do
     before do
         @module = Puppet::Util::NagiosMaker
+        @provider = stub 'provider', :nagios_type => nil
 
         @nagtype = stub 'nagios type', :parameters => [], :namevar => :name
         Nagios::Base.stubs(:type).with(:test).returns(@nagtype)
@@ -109,19 +99,27 @@ describe Puppet::Util::NagiosMaker, " when creating the naginator provider" do
     end
 
     it "should add a naginator provider" do
-        @type.expects(:provide).with { |name, options| name == :naginator }
+        @type.expects(:provide).with { |name, options| name == :naginator }.returns @provider
 
         @module.create_nagios_type(:test)
     end
 
     it "should set Puppet::Provider::Naginator as the parent class of the provider" do
-        @type.expects(:provide).with { |name, options| options[:parent] == Puppet::Provider::Naginator }
+        @type.expects(:provide).with { |name, options| options[:parent] == Puppet::Provider::Naginator }.returns @provider
 
         @module.create_nagios_type(:test)
     end
 
     it "should use /etc/nagios/$name.cfg as the default target" do
-        @type.expects(:provide).with { |name, options| options[:default_target] == "/etc/nagios/nagios_test.cfg" }
+        @type.expects(:provide).with { |name, options| options[:default_target] == "/etc/nagios/nagios_test.cfg" }.returns @provider
+
+        @module.create_nagios_type(:test)
+    end
+
+    it "should trigger the lookup of the Nagios class" do
+        @type.expects(:provide).returns @provider
+
+        @provider.expects(:nagios_type)
 
         @module.create_nagios_type(:test)
     end