puppet 0.24.6 → 0.24.7

data/spec/unit/util/loadedfile.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'tempfile'
+require 'puppet/util/loadedfile'
+
+describe Puppet::Util::LoadedFile do
+    before(:each) do
+        @f = Tempfile.new('loadedfile_test')
+        @f.puts "yayness"
+        @f.flush
+
+        @loaded = Puppet::Util::LoadedFile.new(@f.path)
+
+        fake_ctime = Time.now - (2 * Puppet[:filetimeout])
+        @stat = stub('stat', :ctime => fake_ctime)
+        @fake_now = Time.now + (2 * Puppet[:filetimeout])
+    end
+
+    it "should recognize when the file has not changed" do
+        # Use fake "now" so that we can be sure changed? actually checks, without sleeping
+        # for Puppet[:filetimeout] seconds.
+        Time.stubs(:now).returns(@fake_now)
+        @loaded.changed?.should == false
+    end
+
+    it "should recognize when the file has changed" do
+        # Fake File.stat so we don't have to depend on the filesystem granularity. Doing a flush()
+        # just didn't do the job.
+        File.stubs(:stat).returns(@stat)
+        # Use fake "now" so that we can be sure changed? actually checks, without sleeping
+        # for Puppet[:filetimeout] seconds.
+        Time.stubs(:now).returns(@fake_now)
+        @loaded.changed?.should be_an_instance_of(Time)
+    end
+
+    it "should not catch a change until the timeout has elapsed" do
+        # Fake File.stat so we don't have to depend on the filesystem granularity. Doing a flush()
+        # just didn't do the job.
+        File.stubs(:stat).returns(@stat)
+        @loaded.changed?.should be(false)
+        # Use fake "now" so that we can be sure changed? actually checks, without sleeping
+        # for Puppet[:filetimeout] seconds.
+        Time.stubs(:now).returns(@fake_now)
+        @loaded.changed?.should_not be(false)
+    end
+
+    it "should consider a file changed when that file is missing" do
+        @f.close!
+        # Use fake "now" so that we can be sure changed? actually checks, without sleeping
+        # for Puppet[:filetimeout] seconds.
+        Time.stubs(:now).returns(@fake_now)
+        @loaded.changed?.should_not be(false)
+    end
+
+    it "should disable checking if Puppet[:filetimeout] is negative" do
+        Puppet[:filetimeout] = -1
+        @loaded.changed?.should_not be(false)
+    end
+
+    after(:each) do
+        @f.close
+    end
+end

data/spec/unit/util/log.rb

@@ -0,0 +1,107 @@
+#!/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/log'
+
+describe Puppet::Util::Log do
+    describe "instances" do
+        before do
+            Puppet::Util::Log.stubs(:newmessage)
+        end
+
+        [:level, :message, :time, :remote].each do |attr|
+            it "should have a %s attribute" % attr do
+                log = Puppet::Util::Log.new :level => :notice, :message => "A test message"
+                log.should respond_to(attr)
+                log.should respond_to(attr.to_s + "=")
+            end
+        end
+
+        it "should fail if created without a level" do
+            lambda { Puppet::Util::Log.new(:message => "A test message") }.should raise_error(ArgumentError)
+        end
+
+        it "should fail if created without a message" do
+            lambda { Puppet::Util::Log.new(:level => :notice) }.should raise_error(ArgumentError)
+        end
+
+        it "should make available the level passed in at initialization" do
+            Puppet::Util::Log.new(:level => :notice, :message => "A test message").level.should == :notice
+        end
+
+        it "should make available the message passed in at initialization" do
+            Puppet::Util::Log.new(:level => :notice, :message => "A test message").message.should == "A test message"
+        end
+
+        # LAK:NOTE I don't know why this behavior is here, I'm just testing what's in the code,
+        # at least at first.
+        it "should always convert messages to strings" do
+            Puppet::Util::Log.new(:level => :notice, :message => :foo).message.should == "foo"
+        end
+
+        it "should convert the level to a symbol if it's passed in as a string" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).level.should == :notice
+        end
+
+        it "should fail if the level is not a symbol or string" do
+            lambda { Puppet::Util::Log.new(:level => 50, :message => :foo) }.should raise_error(ArgumentError)
+        end
+
+        it "should fail if the provided level is not valid" do
+            Puppet::Util::Log.expects(:validlevel?).with(:notice).returns false
+            lambda { Puppet::Util::Log.new(:level => :notice, :message => :foo) }.should raise_error(ArgumentError)
+        end
+
+        it "should set its time to the initialization time" do
+            time = mock 'time'
+            Time.expects(:now).returns time
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).time.should equal(time)
+        end
+
+        it "should make available any passed-in tags" do
+            log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{foo bar})
+            log.tags.should be_include("foo")
+            log.tags.should be_include("bar")
+        end
+
+        it "should use an passed-in source" do
+            Puppet::Util::Log.any_instance.expects(:source=).with "foo"
+            Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "foo")
+        end
+
+        it "should default to 'Puppet' as its source" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).source.should == "Puppet"
+        end
+
+        it "should register itself with Log" do
+            Puppet::Util::Log.expects(:newmessage)
+            Puppet::Util::Log.new(:level => "notice", :message => :foo)
+        end
+
+        it "should have a method for determining if a tag is present" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).should respond_to(:tagged?)
+        end
+
+        it "should match a tag if any of the tags are equivalent to the passed tag as a string" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{one two}).should be_tagged(:one)
+        end
+
+        it "should tag itself with its log level" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).should be_tagged(:notice)
+        end
+
+        it "should return its message when converted to a string" do
+            Puppet::Util::Log.new(:level => "notice", :message => :foo).to_s.should == "foo"
+        end
+
+        it "should include its time, source, level, and message when prepared for reporting" do
+            log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
+            report = log.to_report
+            report.should be_include("notice")
+            report.should be_include("foo")
+            report.should be_include(log.source)
+            report.should be_include(log.time.to_s)
+        end
+    end
+end

data/spec/unit/util/metric.rb

@@ -0,0 +1,95 @@
+#!/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/metric'
+
+describe Puppet::Util::Metric do
+    before do
+        @metric = Puppet::Util::Metric.new("foo")
+    end
+
+    it "should be aliased to Puppet::Metric" do
+        Puppet::Util::Metric.should equal(Puppet::Metric)
+    end
+
+    [:type, :name, :value, :label, :basedir].each do |name|
+        it "should have a #{name} attribute" do
+            @metric.should respond_to(name)
+            @metric.should respond_to(name.to_s + "=")
+        end
+    end
+
+    it "should default to the :rrdir as the basedir "do
+        Puppet.settings.expects(:value).with(:rrddir).returns "myrrd"
+        @metric.basedir.should == "myrrd"
+    end
+
+    it "should use any provided basedir" do
+        @metric.basedir = "foo"
+        @metric.basedir.should == "foo"
+    end
+
+    it "should require a name at initialization" do
+        lambda { Puppet::Util::Metric.new }.should raise_error(ArgumentError)
+    end
+
+    it "should always convert its name to a string" do
+        Puppet::Util::Metric.new(:foo).name.should == "foo"
+    end
+
+    it "should support a label" do
+        Puppet::Util::Metric.new("foo", "mylabel").label.should == "mylabel"
+    end
+
+    it "should autogenerate a label if none is provided" do
+        Puppet::Util::Metric.new("foo_bar").label.should == "Foo bar"
+    end
+
+    it "should have a method for adding values" do
+        @metric.should respond_to(:newvalue)
+    end
+
+    it "should have a method for returning values" do
+        @metric.should respond_to(:values)
+    end
+
+    it "should require a name and value for its values" do
+        lambda { @metric.newvalue }.should raise_error(ArgumentError)
+    end
+
+    it "should support a label for values" do
+        @metric.newvalue(:foo, 10, "label")
+        @metric.values[0][1].should == "label"
+    end
+
+    it "should autogenerate value labels if none is provided" do
+        @metric.newvalue("foo_bar", 10)
+        @metric.values[0][1].should == "Foo bar"
+    end
+
+    it "should return its values sorted by label" do
+        @metric.newvalue(:foo, 10, "b")
+        @metric.newvalue(:bar, 10, "a")
+
+        @metric.values.should == [[:bar, "a", 10], [:foo, "b", 10]]
+    end
+
+    it "should use an array indexer method to retrieve individual values" do
+        @metric.newvalue(:foo, 10)
+        @metric[:foo].should == 10
+    end
+
+    it "should return nil if the named value cannot be found" do
+        @metric[:foo].should be_nil
+    end
+
+    # LAK: I'm not taking the time to develop these tests right now.
+    # I expect they should actually be extracted into a separate class
+    # anyway.
+    it "should be able to graph metrics using RRDTool"
+
+    it "should be able to create a new RRDTool database"
+
+    it "should be able to store metrics into an RRDTool database"
+end

data/spec/unit/util/nagios_maker.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-11-18.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/nagios_maker'
+
+describe Puppet::Util::NagiosMaker do
+    before do
+        @module = Puppet::Util::NagiosMaker
+
+        @nagtype = stub 'nagios type', :parameters => [], :namevar => :name
+        Nagios::Base.stubs(:type).with(:test).returns(@nagtype)
+    end
+
+    it "should be able to create a new nagios type" do
+        @module.should respond_to(:create_nagios_type)
+    end
+
+    it "should fail if it cannot find the named Naginator type" do
+        Nagios::Base.stubs(:type).returns(nil)
+
+        lambda { @module.create_nagios_type(:no_such_type) }.should raise_error(Puppet::DevError)
+    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)
+        @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)
+
+        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)
+
+        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)
+
+        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)
+
+        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)
+
+        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)
+
+        Puppet::Type.expects(:newtype).with(:nagios_test).returns(type)
+        @module.create_nagios_type(:test)
+    end
+end
+
+describe Puppet::Util::NagiosMaker, " when creating the naginator provider" do
+    before do
+        @module = Puppet::Util::NagiosMaker
+
+        @nagtype = stub 'nagios type', :parameters => [], :namevar => :name
+        Nagios::Base.stubs(:type).with(:test).returns(@nagtype)
+
+        @type = stub 'type', :newparam => nil, :ensurable => nil, :newproperty => nil, :desc => nil
+        Puppet::Type.stubs(:newtype).with(:nagios_test).returns(@type)
+    end
+
+    it "should add a naginator provider" do
+        @type.expects(:provide).with { |name, options| name == :naginator }
+
+        @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 }
+
+        @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" }
+
+        @module.create_nagios_type(:test)
+    end
+end

data/spec/unit/util/posix.rb

@@ -0,0 +1,256 @@
+#!/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/posix'
+
+class PosixTest
+    include Puppet::Util::POSIX
+end
+
+describe Puppet::Util::POSIX do
+    before do
+        @posix = PosixTest.new
+    end
+
+    [:group, :gr].each do |name|
+        it "should return :gid as the field for %s" % name do
+            @posix.idfield(name).should == :gid
+        end
+
+        it "should return :getgrgid as the id method for %s" % name do
+            @posix.methodbyid(name).should == :getgrgid
+        end
+
+        it "should return :getgrnam as the name method for %s" % name do
+            @posix.methodbyname(name).should == :getgrnam
+        end
+    end
+
+    [:user, :pw, :passwd].each do |name|
+        it "should return :uid as the field for %s" % name do
+            @posix.idfield(name).should == :uid
+        end
+
+        it "should return :getpwuid as the id method for %s" % name do
+            @posix.methodbyid(name).should == :getpwuid
+        end
+
+        it "should return :getpwnam as the name method for %s" % name do
+            @posix.methodbyname(name).should == :getpwnam
+        end
+    end
+
+    describe "when retrieving a posix field" do
+        before do
+            @thing = stub 'thing', :field => "asdf"
+        end
+
+        it "should fail if no id was passed" do
+            lambda { @posix.get_posix_field("asdf", "bar", nil) }.should raise_error(Puppet::DevError)
+        end
+
+        describe "and the id is an integer" do
+            it "should log an error and return nil if the specified id is greater than the maximum allowed ID" do
+                Puppet.settings.expects(:value).with(:maximum_uid).returns 100
+                Puppet.expects(:err)
+
+                @posix.get_posix_field("asdf", "bar", 200).should be_nil
+            end
+
+            it "should use the method return by :methodbyid and return the specified field" do
+                Etc.expects(:getgrgid).returns @thing
+
+                @thing.expects(:field).returns "myval"
+
+                @posix.get_posix_field(:gr, :field, 200).should == "myval"
+            end
+
+            it "should return nil if the method throws an exception" do
+                Etc.expects(:getgrgid).raises ArgumentError
+
+                @thing.expects(:field).never
+
+                @posix.get_posix_field(:gr, :field, 200).should be_nil
+            end
+        end
+
+        describe "and the id is not an integer" do
+            it "should use the method return by :methodbyid and return the specified field" do
+                Etc.expects(:getgrnam).returns @thing
+
+                @thing.expects(:field).returns "myval"
+
+                @posix.get_posix_field(:gr, :field, "asdf").should == "myval"
+            end
+
+            it "should return nil if the method throws an exception" do
+                Etc.expects(:getgrnam).raises ArgumentError
+
+                @thing.expects(:field).never
+
+                @posix.get_posix_field(:gr, :field, "asdf").should be_nil
+            end
+        end
+    end
+
+    describe "when returning the gid" do
+        before do
+            @posix.stubs(:get_posix_field)
+        end
+
+        describe "and the group is an integer" do
+            it "should convert integers specified as a string into an integer" do
+                @posix.expects(:get_posix_field).with(:group, :name, 100)
+
+                @posix.gid("100")
+            end
+
+            it "should look up the name for the group" do
+                @posix.expects(:get_posix_field).with(:group, :name, 100)
+
+                @posix.gid(100)
+            end
+
+            it "should return nil if the group cannot be found" do
+                @posix.expects(:get_posix_field).once.returns nil
+                @posix.expects(:search_posix_field).never
+
+                @posix.gid(100).should be_nil
+            end
+
+            it "should use the found name to look up the id" do
+                @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+                @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+
+                @posix.gid(100).should == 100
+            end
+
+            # LAK: This is because some platforms have a broken Etc module that always return
+            # the same group.
+            it "should use :search_posix_field if the discovered id does not match the passed-in id" do
+                @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+                @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 50
+
+                @posix.expects(:search_posix_field).with(:group, :gid, 100).returns "asdf"
+
+                @posix.gid(100).should == "asdf"
+            end
+        end
+
+        describe "and the group is a string" do
+            it "should look up the gid for the group" do
+                @posix.expects(:get_posix_field).with(:group, :gid, "asdf")
+
+                @posix.gid("asdf")
+            end
+
+            it "should return nil if the group cannot be found" do
+                @posix.expects(:get_posix_field).once.returns nil
+                @posix.expects(:search_posix_field).never
+
+                @posix.gid("asdf").should be_nil
+            end
+
+            it "should use the found gid to look up the nam" do
+                @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+                @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+
+                @posix.gid("asdf").should == 100
+            end
+
+            it "should use :search_posix_field if the discovered name does not match the passed-in name" do
+                @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+                @posix.expects(:get_posix_field).with(:group, :name, 100).returns "boo"
+
+                @posix.expects(:search_posix_field).with(:group, :gid, "asdf").returns "asdf"
+
+                @posix.gid("asdf").should == "asdf"
+            end
+        end
+    end
+
+    describe "when returning the uid" do
+        before do
+            @posix.stubs(:get_posix_field)
+        end
+
+        describe "and the group is an integer" do
+            it "should convert integers specified as a string into an integer" do
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100)
+
+                @posix.uid("100")
+            end
+
+            it "should look up the name for the group" do
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100)
+
+                @posix.uid(100)
+            end
+
+            it "should return nil if the group cannot be found" do
+                @posix.expects(:get_posix_field).once.returns nil
+                @posix.expects(:search_posix_field).never
+
+                @posix.uid(100).should be_nil
+            end
+
+            it "should use the found name to look up the id" do
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+                @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+
+                @posix.uid(100).should == 100
+            end
+
+            # LAK: This is because some platforms have a broken Etc module that always return
+            # the same group.
+            it "should use :search_posix_field if the discovered id does not match the passed-in id" do
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+                @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 50
+
+                @posix.expects(:search_posix_field).with(:passwd, :uid, 100).returns "asdf"
+
+                @posix.uid(100).should == "asdf"
+            end
+        end
+
+        describe "and the group is a string" do
+            it "should look up the uid for the group" do
+                @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf")
+
+                @posix.uid("asdf")
+            end
+
+            it "should return nil if the group cannot be found" do
+                @posix.expects(:get_posix_field).once.returns nil
+                @posix.expects(:search_posix_field).never
+
+                @posix.uid("asdf").should be_nil
+            end
+
+            it "should use the found uid to look up the nam" do
+                @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+
+                @posix.uid("asdf").should == 100
+            end
+
+            it "should use :search_posix_field if the discovered name does not match the passed-in name" do
+                @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+                @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "boo"
+
+                @posix.expects(:search_posix_field).with(:passwd, :uid, "asdf").returns "asdf"
+
+                @posix.uid("asdf").should == "asdf"
+            end
+        end
+    end
+
+    it "should be able to iteratively search for posix values" do
+        @posix.should respond_to(:search_posix_field)
+    end
+
+    describe "when searching for posix values iteratively" do
+        it "should iterate across all of the structs returned by Etc and return the appropriate field from the first matching value"
+    end
+end