puppet 0.25.5 → 2.6.0

data/spec/unit/util/monkey_patches_spec.rb

@@ -0,0 +1,7 @@
+#!/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/monkey_patches'
+
+

data/spec/unit/util/nagios_maker_spec.rb

@@ -0,0 +1,126 @@
+#!/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)
+
+    @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
+    @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
+    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.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.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
+    @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
+    @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
+    @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.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
+    @provider = stub 'provider', :nagios_type => nil
+
+    @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 }.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 }.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" }.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
+end

data/spec/unit/util/package_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/package'
+
+describe Puppet::Util::Package, " versioncmp" do
+
+  it "should be able to be used as a module function" do
+    Puppet::Util::Package.should respond_to(:versioncmp)
+  end
+
+  it "should be able to sort a long set of various unordered versions" do
+    ary = %w{ 1.1.6 2.3 1.1a 3.0 1.5 1 2.4 1.1-4 2.3.1 1.2 2.3.0 1.1-3 2.4b 2.4 2.40.2 2.3a.1 3.1 0002 1.1-5 1.1.a 1.06}
+
+    newary = ary.sort { |a, b| Puppet::Util::Package.versioncmp(a,b) }
+
+    newary.should == ["0002", "1", "1.06", "1.1-3", "1.1-4", "1.1-5", "1.1.6", "1.1.a", "1.1a", "1.2", "1.5", "2.3", "2.3.0", "2.3.1", "2.3a.1", "2.4", "2.4", "2.4b", "2.40.2", "3.0", "3.1"]
+  end
+
+end

data/spec/unit/util/posix_spec.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 #{name}" do
+      @posix.idfield(name).should == :gid
+    end
+
+    it "should return :getgrgid as the id method for #{name}" do
+      @posix.methodbyid(name).should == :getgrgid
+    end
+
+    it "should return :getgrnam as the name method for #{name}" do
+      @posix.methodbyname(name).should == :getgrnam
+    end
+  end
+
+  [:user, :pw, :passwd].each do |name|
+    it "should return :uid as the field for #{name}" do
+      @posix.idfield(name).should == :uid
+    end
+
+    it "should return :getpwuid as the id method for #{name}" do
+      @posix.methodbyid(name).should == :getpwuid
+    end
+
+    it "should return :getpwnam as the name method for #{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

data/spec/unit/util/queue/stomp_spec.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/util/queue'
+
+describe Puppet::Util::Queue do
+  confine "Missing Stomp" => Puppet.features.stomp?
+
+  it 'should load :stomp client appropriately' do
+    Puppet.settings.stubs(:value).returns 'faux_queue_source'
+    Puppet::Util::Queue.queue_type_to_class(:stomp).name.should == 'Puppet::Util::Queue::Stomp'
+  end
+end
+
+describe 'Puppet::Util::Queue::Stomp' do
+  confine "Missing Stomp" => Puppet.features.stomp?
+
+  before do
+    # So we make sure we never create a real client instance.
+    # Otherwise we'll try to connect, and that's bad.
+    Stomp::Client.stubs(:new).returns stub("client")
+  end
+
+  it 'should be registered with Puppet::Util::Queue as :stomp type' do
+    Puppet::Util::Queue.queue_type_to_class(:stomp).should == Puppet::Util::Queue::Stomp
+  end
+
+  describe "when initializing" do
+    it "should create a Stomp client instance" do
+      Stomp::Client.expects(:new).returns stub("stomp_client")
+      Puppet::Util::Queue::Stomp.new
+    end
+
+    it "should provide helpful failures when the queue source is not a valid source" do
+      # Stub rather than expect, so we can include the source in the error
+      Puppet.settings.stubs(:value).with(:queue_source).returns "-----"
+
+      lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+    end
+
+    it "should fail unless the queue source is a stomp URL" do
+      # Stub rather than expect, so we can include the source in the error
+      Puppet.settings.stubs(:value).with(:queue_source).returns "http://foo/bar"
+
+      lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+    end
+
+    it "should fail somewhat helpfully if the Stomp client cannot be created" do
+      Stomp::Client.expects(:new).raises RuntimeError
+      lambda { Puppet::Util::Queue::Stomp.new }.should raise_error(ArgumentError)
+    end
+
+    list = %w{user password host port}
+    {"user" => "myuser", "password" => "mypass", "host" => "foohost", "port" => 42}.each do |name, value|
+      it "should use the #{name} from the queue source as the queueing #{name}" do
+        Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser:mypass@foohost:42/"
+
+        Stomp::Client.expects(:new).with { |*args| args[list.index(name)] == value }
+        Puppet::Util::Queue::Stomp.new
+      end
+    end
+
+    it "should create a reliable client instance" do
+      Puppet.settings.expects(:value).with(:queue_source).returns "stomp://myuser@foohost:42/"
+
+      Stomp::Client.expects(:new).with { |*args| args[4] == true }
+      Puppet::Util::Queue::Stomp.new
+    end
+  end
+
+  describe "when sending a message" do
+    before do
+      @client = stub 'client'
+      Stomp::Client.stubs(:new).returns @client
+      @queue = Puppet::Util::Queue::Stomp.new
+    end
+
+    it "should send it to the queue client instance" do
+      @client.expects(:send).with { |queue, msg, options| msg == "Smite!" }
+      @queue.send_message('fooqueue', 'Smite!')
+    end
+
+    it "should send it to the transformed queue name" do
+      @client.expects(:send).with { |queue, msg, options| queue == "/queue/fooqueue" }
+      @queue.send_message('fooqueue', 'Smite!')
+    end
+
+    it "should send it as a persistent message" do
+      @client.expects(:send).with { |queue, msg, options| options[:persistent] == true }
+      @queue.send_message('fooqueue', 'Smite!')
+    end
+  end
+
+  describe "when subscribing to a queue" do
+    before do
+      @client = stub 'client', :acknowledge => true
+      Stomp::Client.stubs(:new).returns @client
+      @queue = Puppet::Util::Queue::Stomp.new
+    end
+
+    it "should subscribe via the queue client instance" do
+      @client.expects(:subscribe)
+      @queue.subscribe('fooqueue')
+    end
+
+    it "should subscribe to the transformed queue name" do
+      @client.expects(:subscribe).with { |queue, options| queue == "/queue/fooqueue" }
+      @queue.subscribe('fooqueue')
+    end
+
+    it "should specify that its messages should be acknowledged" do
+      @client.expects(:subscribe).with { |queue, options| options[:ack] == :client }
+      @queue.subscribe('fooqueue')
+    end
+
+    it "should yield the body of any received message" do
+      message = mock 'message'
+      message.expects(:body).returns "mybody"
+
+      @client.expects(:subscribe).yields(message)
+
+      body = nil
+      @queue.subscribe('fooqueue') { |b| body = b }
+      body.should == "mybody"
+    end
+
+    it "should acknowledge all successfully processed messages" do
+      message = stub 'message', :body => "mybode"
+
+      @client.stubs(:subscribe).yields(message)
+      @client.expects(:acknowledge).with(message)
+
+      @queue.subscribe('fooqueue') { |b| "eh" }
+    end
+  end
+
+  it 'should transform the simple queue name to "/queue/<queue_name>"' do
+    Puppet::Util::Queue::Stomp.new.stompify_target('blah').should == '/queue/blah'
+  end
+end