puppet 0.25.5 → 2.6.0

data/spec/unit/util/loadedfile_spec.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/destinations_spec.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/util/log'
+
+describe Puppet::Util::Log.desttypes[:report] do
+  before do
+    @dest = Puppet::Util::Log.desttypes[:report]
+  end
+
+  it "should require a report at initialization" do
+    @dest.new("foo").report.should == "foo"
+  end
+
+  it "should send new messages to the report" do
+    report = mock 'report'
+    dest = @dest.new(report)
+
+    report.expects(:<<).with("my log")
+
+    dest.handle "my log"
+  end
+end

data/spec/unit/util/log_spec.rb

@@ -0,0 +1,215 @@
+#!/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
+  it "should write a given message to the specified destination" do
+    arraydest = []
+    Puppet::Util::Log.newdestination(arraydest)
+    Puppet::Util::Log.new(:level => :notice, :message => "foo")
+    message = arraydest.last.message
+    message.should == "foo"
+  end
+
+  describe Puppet::Util::Log::DestConsole do
+    before do
+      @console = Puppet::Util::Log::DestConsole.new
+    end
+
+    it "should colorize if Puppet[:color] is :ansi" do
+      Puppet[:color] = :ansi
+
+      @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
+    end
+
+    it "should colorize if Puppet[:color] is 'yes'" do
+      Puppet[:color] = "yes"
+
+      @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
+    end
+
+    it "should htmlize if Puppet[:color] is :html" do
+      Puppet[:color] = :html
+
+      @console.colorize(:alert, "abc").should == "<span style=\"color: FFA0A0\">abc</span>"
+    end
+
+    it "should do nothing if Puppet[:color] is false" do
+      Puppet[:color] = false
+
+      @console.colorize(:alert, "abc").should == "abc"
+    end
+
+    it "should do nothing if Puppet[:color] is invalid" do
+      Puppet[:color] = "invalid option"
+
+      @console.colorize(:alert, "abc").should == "abc"
+    end
+  end
+
+  describe "instances" do
+    before do
+      Puppet::Util::Log.stubs(:newmessage)
+    end
+
+    [:level, :message, :time, :remote].each do |attr|
+      it "should have a #{attr} attribute" 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 flush the log queue when the first destination is specified" do
+      Puppet::Util::Log.close_all
+      Puppet::Util::Log.expects(:flushqueue)
+      Puppet::Util::Log.newdestination([])
+    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
+
+    [:file, :line, :version].each do |attr|
+      it "should use #{attr} if provided" do
+        Puppet::Util::Log.any_instance.expects(attr.to_s + "=").with "foo"
+        Puppet::Util::Log.new(:level => "notice", :message => :foo, attr => "foo")
+      end
+    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
+
+    describe "when setting the source as a RAL object" do
+      it "should tag itself with any tags the source has" do
+        source = Puppet::Type.type(:file).new :path => "/foo/bar"
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+        source.tags.each do |tag|
+          log.tags.should be_include(tag)
+        end
+      end
+
+      it "should use the source_descriptors" do
+        source = stub "source"
+        source.stubs(:source_descriptors).returns(:tags => ["tag","tag2"], :path => "path", :version => 100)
+
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
+        log.expects(:tag).with("tag")
+        log.expects(:tag).with("tag2")
+        log.expects(:version=).with(100)
+
+        log.source = source
+
+        log.source.should == "path"
+      end
+
+      it "should copy over any version information" do
+        catalog = Puppet::Resource::Catalog.new
+        catalog.version = 25
+        source = Puppet::Type.type(:file).new :path => "/foo/bar"
+        catalog.add_resource source
+
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+        log.version.should == 25
+      end
+
+      it "should copy over any file and line information" do
+        source = Puppet::Type.type(:file).new :path => "/foo/bar"
+        source.file = "/my/file"
+        source.line = 50
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+        log.file.should == "/my/file"
+        log.line.should == 50
+      end
+    end
+
+    describe "when setting the source as a non-RAL object" do
+      it "should not try to copy over file, version, line, or tag information" do
+        source = Puppet::Module.new("foo")
+        source.expects(:file).never
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+      end
+    end
+  end
+end

data/spec/unit/util/logging_spec.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/logging'
+
+class LoggingTester
+  include Puppet::Util::Logging
+end
+
+describe Puppet::Util::Logging do
+  before do
+    @logger = LoggingTester.new
+  end
+
+  Puppet::Util::Log.eachlevel do |level|
+    it "should have a method for sending '#{level}' logs" do
+      @logger.should respond_to(level)
+    end
+  end
+
+  it "should have a method for sending a log with a specified log level" do
+    @logger.expects(:to_s).returns "I'm a string!"
+    Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" and args[:level] == "loglevel" and args[:message] == "mymessage" }
+
+    @logger.send_log "loglevel", "mymessage"
+  end
+
+  describe "when sending a log" do
+    it "should use the Log's 'create' entrance method" do
+      Puppet::Util::Log.expects(:create)
+
+      @logger.notice "foo"
+    end
+
+    it "should send itself converted to a string as the log source" do
+      @logger.expects(:to_s).returns "I'm a string!"
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
+
+      @logger.notice "foo"
+    end
+
+    it "should queue logs sent without a specified destination" do
+      Puppet::Util::Log.close_all
+      Puppet::Util::Log.expects(:queuemessage)
+
+      @logger.notice "foo"
+    end
+
+    it "should use the path of any provided resource type" do
+      resource = Puppet::Type.type(:mount).new :name => "foo"
+
+      resource.expects(:path).returns "/path/to/mount".to_sym
+
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/mount" }
+
+      resource.notice "foo"
+    end
+
+    it "should use the path of any provided resource parameter" do
+      resource = Puppet::Type.type(:mount).new :name => "foo"
+
+      param = resource.parameter(:name)
+
+      param.expects(:path).returns "/path/to/param".to_sym
+
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
+
+      param.notice "foo"
+    end
+
+    it "should send the provided argument as the log message" do
+      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
+
+      @logger.notice "foo"
+    end
+
+    it "should join any provided arguments into a single string for the message" do
+      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
+
+      @logger.notice ["foo", "bar", "baz"]
+    end
+
+    [:file, :line, :version, :tags].each do |attr|
+      it "should include #{attr} if available" do
+        @logger.singleton_class.send(:attr_accessor, attr)
+
+        @logger.send(attr.to_s + "=", "myval")
+
+        Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
+        @logger.notice "foo"
+      end
+    end
+  end
+end

data/spec/unit/util/metric_spec.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 == 0
+  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