puppet 0.25.5 → 2.6.0

data/spec/unit/util/cacher_spec.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/cacher'
+
+class ExpirerTest
+  include Puppet::Util::Cacher::Expirer
+end
+
+class CacheTest
+  @@init_count = 0
+
+  include Puppet::Util::Cacher
+  cached_attr(:instance_cache) { Time.now }
+end
+
+describe Puppet::Util::Cacher::Expirer do
+  before do
+    @expirer = ExpirerTest.new
+  end
+
+  it "should be able to test whether a timestamp is expired" do
+    @expirer.should respond_to(:dependent_data_expired?)
+  end
+
+  it "should be able to expire all values" do
+    @expirer.should respond_to(:expire)
+  end
+
+  it "should consider any value to be valid if it has never been expired" do
+    @expirer.should_not be_dependent_data_expired(Time.now)
+  end
+
+  it "should consider any value created after expiration to be expired" do
+    @expirer.expire
+    @expirer.should be_dependent_data_expired(Time.now - 1)
+  end
+end
+
+describe Puppet::Util::Cacher do
+  it "should be extended with the Expirer module" do
+    Puppet::Util::Cacher.singleton_class.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
+  end
+
+  it "should support defining cached attributes" do
+    CacheTest.methods.should be_include("cached_attr")
+  end
+
+  it "should default to the Cacher module as its expirer" do
+    CacheTest.new.expirer.should equal(Puppet::Util::Cacher)
+  end
+
+  describe "when using cached attributes" do
+    before do
+      @expirer = ExpirerTest.new
+      @object = CacheTest.new
+
+      @object.stubs(:expirer).returns @expirer
+    end
+
+    it "should create a getter for the cached attribute" do
+      @object.should respond_to(:instance_cache)
+    end
+
+    it "should return a value calculated from the provided block" do
+      time = Time.now
+      Time.stubs(:now).returns time
+      @object.instance_cache.should equal(time)
+    end
+
+    it "should return the cached value from the getter every time if the value is not expired" do
+      @object.instance_cache.should equal(@object.instance_cache)
+    end
+
+    it "should regenerate and return a new value using the provided block if the value has been expired" do
+      value = @object.instance_cache
+      @expirer.expire
+      @object.instance_cache.should_not equal(value)
+    end
+
+    it "should be able to trigger expiration on its expirer" do
+      @expirer.expects(:expire)
+      @object.expire
+    end
+
+    it "should do nothing when asked to expire when no expirer is available" do
+      cacher = CacheTest.new
+      class << cacher
+        def expirer
+          nil
+        end
+      end
+      lambda { cacher.expire }.should_not raise_error
+    end
+
+    it "should be able to cache false values" do
+      @object.expects(:init_instance_cache).returns false
+      @object.instance_cache.should be_false
+      @object.instance_cache.should be_false
+    end
+
+    it "should cache values again after expiration" do
+      @object.instance_cache
+      @expirer.expire
+      @object.instance_cache.should equal(@object.instance_cache)
+    end
+
+    it "should always consider a value expired if it has no expirer" do
+      @object.stubs(:expirer).returns nil
+      @object.instance_cache.should_not equal(@object.instance_cache)
+    end
+
+    it "should allow writing of the attribute" do
+      @object.should respond_to(:instance_cache=)
+    end
+
+    it "should correctly configure timestamps for expiration when the cached attribute is written to" do
+      @object.instance_cache = "foo"
+      @expirer.expire
+      @object.instance_cache.should_not == "foo"
+    end
+
+    it "should allow specification of a ttl for cached attributes" do
+      klass = Class.new do
+        include Puppet::Util::Cacher
+      end
+
+      klass.cached_attr(:myattr, :ttl => 5)  { Time.now }
+
+      klass.attr_ttl(:myattr).should == 5
+    end
+
+    it "should allow specification of a ttl as a string" do
+      klass = Class.new do
+        include Puppet::Util::Cacher
+      end
+
+      klass.cached_attr(:myattr, :ttl => "5")  { Time.now }
+
+      klass.attr_ttl(:myattr).should == 5
+    end
+
+    it "should fail helpfully if the ttl cannot be converted to an integer" do
+      klass = Class.new do
+        include Puppet::Util::Cacher
+      end
+
+      lambda { klass.cached_attr(:myattr, :ttl => "yep")  { Time.now } }.should raise_error(ArgumentError)
+    end
+
+    it "should not check for a ttl expiration if the class does not support that method" do
+      klass = Class.new do
+        extend Puppet::Util::Cacher
+      end
+
+      klass.singleton_class.cached_attr(:myattr) { "eh" }
+      klass.myattr
+    end
+
+    it "should automatically expire cached attributes whose ttl has expired, even if no expirer is present" do
+      klass = Class.new do
+        def self.to_s
+          "CacheTestClass"
+        end
+        include Puppet::Util::Cacher
+        attr_accessor :value
+      end
+
+      klass.cached_attr(:myattr, :ttl => 5)  { self.value += 1; self.value }
+
+      now = Time.now
+      later = Time.now + 15
+
+      instance = klass.new
+      instance.value = 0
+      instance.myattr.should == 1
+
+      Time.expects(:now).returns later
+
+      # This call should get the new Time value, which should expire the old value
+      instance.myattr.should == 2
+    end
+  end
+end

data/spec/unit/util/checksums_spec.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/checksums'
+
+describe Puppet::Util::Checksums do
+  before do
+    @summer = Object.new
+    @summer.extend(Puppet::Util::Checksums)
+  end
+
+  content_sums = [:md5, :md5lite, :sha1, :sha1lite]
+  file_only = [:ctime, :mtime, :none]
+
+  content_sums.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from strings" do
+      @summer.should be_respond_to(sumtype)
+    end
+  end
+
+  [content_sums, file_only].flatten.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from files" do
+      @summer.should be_respond_to(sumtype.to_s + "_file")
+    end
+  end
+
+  [content_sums, file_only].flatten.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from stream" do
+      @summer.should be_respond_to(sumtype.to_s + "_stream")
+    end
+  end
+
+  it "should have a method for determining whether a given string is a checksum" do
+    @summer.should respond_to(:checksum?)
+  end
+
+  %w{{md5}asdfasdf {sha1}asdfasdf {ctime}asdasdf {mtime}asdfasdf}.each do |sum|
+    it "should consider #{sum} to be a checksum" do
+      @summer.should be_checksum(sum)
+    end
+  end
+
+  %w{{nosuchsum}asdfasdf {a}asdfasdf {ctime}}.each do |sum|
+    it "should not consider #{sum} to be a checksum" do
+      @summer.should_not be_checksum(sum)
+    end
+  end
+
+  it "should have a method for stripping a sum type from an existing checksum" do
+    @summer.sumtype("{md5}asdfasdfa").should == "md5"
+  end
+
+  it "should have a method for stripping the data from a checksum" do
+    @summer.sumdata("{md5}asdfasdfa").should == "asdfasdfa"
+  end
+
+  it "should return a nil sumtype if the checksum does not mention a checksum type" do
+    @summer.sumtype("asdfasdfa").should be_nil
+  end
+
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1}.each do |sum, klass|
+    describe("when using #{sum}") do
+      it "should use #{klass} to calculate string checksums" do
+        klass.expects(:hexdigest).with("mycontent").returns "whatever"
+        @summer.send(sum, "mycontent").should == "whatever"
+      end
+
+      it "should use incremental #{klass} sums to calculate file checksums" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+
+        file = "/path/to/my/file"
+
+        fh = mock 'filehandle'
+        fh.expects(:read).with(4096).times(3).returns("firstline").then.returns("secondline").then.returns(nil)
+        #fh.expects(:read).with(512).returns("secondline")
+        #fh.expects(:read).with(512).returns(nil)
+
+        File.expects(:open).with(file, "r").yields(fh)
+
+        digest.expects(:<<).with "firstline"
+        digest.expects(:<<).with "secondline"
+        digest.expects(:hexdigest).returns :mydigest
+
+        @summer.send(sum.to_s + "_file", file).should == :mydigest
+      end
+
+      it "should yield #{klass} to the given block to calculate stream checksums" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+        digest.expects(:hexdigest).returns :mydigest
+
+        @summer.send(sum.to_s + "_stream") do |sum|
+          sum.should == digest
+        end.should == :mydigest
+      end
+    end
+  end
+
+  {:md5lite => Digest::MD5, :sha1lite => Digest::SHA1}.each do |sum, klass|
+    describe("when using #{sum}") do
+      it "should use #{klass} to calculate string checksums from the first 512 characters of the string" do
+        content = "this is a test" * 100
+        klass.expects(:hexdigest).with(content[0..511]).returns "whatever"
+        @summer.send(sum, content).should == "whatever"
+      end
+
+      it "should use #{klass} to calculate a sum from the first 512 characters in the file" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+
+        file = "/path/to/my/file"
+
+        fh = mock 'filehandle'
+        fh.expects(:read).with(512).returns('my content')
+
+        File.expects(:open).with(file, "r").yields(fh)
+
+        digest.expects(:<<).with "my content"
+        digest.expects(:hexdigest).returns :mydigest
+
+        @summer.send(sum.to_s + "_file", file).should == :mydigest
+      end
+    end
+  end
+
+  [:ctime, :mtime].each do |sum|
+    describe("when using #{sum}") do
+      it "should use the '#{sum}' on the file to determine the ctime" do
+        file = "/my/file"
+        stat = mock 'stat', sum => "mysum"
+
+        File.expects(:stat).with(file).returns(stat)
+
+        @summer.send(sum.to_s + "_file", file).should == "mysum"
+      end
+
+      it "should return nil for streams" do
+        @summer.send(sum.to_s + "_stream").should be_nil
+      end
+    end
+  end
+
+  describe "when using the none checksum" do
+    it "should return an empty string" do
+      @summer.none_file("/my/file").should == ""
+    end
+  end
+end

data/spec/unit/util/command_line_spec.rb

@@ -0,0 +1,108 @@
+#!/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/command_line'
+
+describe Puppet::Util::CommandLine do
+  before do
+    @tty  = stub("tty",  :tty? => true )
+    @pipe = stub("pipe", :tty? => false)
+  end
+
+  it "should pull off the first argument if it looks like a subcommand" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp }, @tty )
+
+    command_line.subcommand_name.should == "client"
+    command_line.args.should            == %w{ --help whatever.pp }
+  end
+
+  it "should use 'apply' if the first argument looks like a .pp file" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp }, @tty )
+
+    command_line.subcommand_name.should == "apply"
+    command_line.args.should            == %w{ whatever.pp }
+  end
+
+  it "should use 'apply' if the first argument looks like a .rb file" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.rb }, @tty )
+
+    command_line.subcommand_name.should == "apply"
+    command_line.args.should            == %w{ whatever.rb }
+  end
+
+  it "should use 'apply' if the first argument looks like a flag" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug }, @tty )
+
+    command_line.subcommand_name.should == "apply"
+    command_line.args.should            == %w{ --debug }
+  end
+
+  it "should use 'apply' if the first argument is -" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ - }, @tty )
+
+    command_line.subcommand_name.should == "apply"
+    command_line.args.should            == %w{ - }
+  end
+
+  it "should return nil if the first argument is --help" do
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help }, @tty )
+
+    command_line.subcommand_name.should == nil
+  end
+
+
+  it "should return nil if there are no arguments on a tty" do
+    command_line = Puppet::Util::CommandLine.new("puppet", [], @tty )
+
+    command_line.subcommand_name.should == nil
+    command_line.args.should            == []
+  end
+
+  it "should use 'apply' if there are no arguments on a pipe" do
+    command_line = Puppet::Util::CommandLine.new("puppet", [], @pipe )
+
+    command_line.subcommand_name.should == "apply"
+    command_line.args.should            == []
+  end
+
+  it "should return the executable name if it is not puppet" do
+    command_line = Puppet::Util::CommandLine.new("puppetmasterd", [], @tty )
+
+    command_line.subcommand_name.should == "puppetmasterd"
+  end
+
+  it "should translate subcommand names into their legacy equivalent" do
+    command_line = Puppet::Util::CommandLine.new("puppet", ["master"], @tty)
+    command_line.legacy_executable_name.should == "puppetmasterd"
+  end
+
+  it "should leave legacy command names alone" do
+    command_line = Puppet::Util::CommandLine.new("puppetmasterd", [], @tty)
+    command_line.legacy_executable_name.should == "puppetmasterd"
+  end
+
+  describe "when the subcommand is not implemented" do
+    it "should find and invoke an executable with a hyphenated name" do
+      commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
+      Puppet::Util.expects(:binary).with('puppet-whatever').returns('/dev/null/puppet-whatever')
+      commandline.expects(:system).with('/dev/null/puppet-whatever', 'argument')
+
+      commandline.execute
+    end
+
+    describe "and an external implementation cannot be found" do
+      it "should abort and show the usage message" do
+        commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
+        Puppet::Util.expects(:binary).with('puppet-whatever').returns(nil)
+        commandline.expects(:system).never
+
+        commandline.expects(:usage_message).returns("the usage message")
+        commandline.expects(:abort).with{|x| x =~ /the usage message/}.raises("stubbed abort")
+
+        lambda{ commandline.execute }.should raise_error('stubbed abort')
+      end
+    end
+  end
+end

data/spec/unit/util/constant_inflector_spec.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-02-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/constant_inflector'
+
+describe Puppet::Util::ConstantInflector, "when converting file names to constants" do
+  before do
+    @inflector = Object.new
+    @inflector.extend(Puppet::Util::ConstantInflector)
+  end
+
+  it "should capitalize terms" do
+    @inflector.file2constant("file").should == "File"
+  end
+
+  it "should switch all '/' characters to double colons" do
+    @inflector.file2constant("file/other").should == "File::Other"
+  end
+
+  it "should remove underscores and capitalize the proceeding letter" do
+    @inflector.file2constant("file_other").should == "FileOther"
+  end
+
+  it "should correctly replace as many underscores as exist in the file name" do
+    @inflector.file2constant("two_under_scores/with_some_more_underscores").should == "TwoUnderScores::WithSomeMoreUnderscores"
+  end
+
+  it "should collapse multiple underscores" do
+    @inflector.file2constant("many___scores").should == "ManyScores"
+  end
+
+  it "should correctly handle file names deeper than two directories" do
+    @inflector.file2constant("one_two/three_four/five_six").should == "OneTwo::ThreeFour::FiveSix"
+  end
+end
+
+describe Puppet::Util::ConstantInflector, "when converting constnats to file names" do
+  before do
+    @inflector = Object.new
+    @inflector.extend(Puppet::Util::ConstantInflector)
+  end
+
+  it "should convert them to a string if necessary" do
+    @inflector.constant2file(Puppet::Util::ConstantInflector).should be_instance_of(String)
+  end
+
+  it "should accept string inputs" do
+    @inflector.constant2file("Puppet::Util::ConstantInflector").should be_instance_of(String)
+  end
+
+  it "should downcase all terms" do
+    @inflector.constant2file("Puppet").should == "puppet"
+  end
+
+  it "should convert '::' to '/'" do
+    @inflector.constant2file("Puppet::Util::Constant").should == "puppet/util/constant"
+  end
+
+  it "should convert mid-word capitalization to an underscore" do
+    @inflector.constant2file("OneTwo::ThreeFour").should == "one_two/three_four"
+  end
+
+  it "should correctly handle constants with more than two parts" do
+    @inflector.constant2file("OneTwoThree::FourFiveSixSeven").should == "one_two_three/four_five_six_seven"
+  end
+end