puppet 0.24.6 → 0.24.7

data/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb

@@ -0,0 +1,46 @@
+dir = File.expand_path(File.dirname(__FILE__))
+[ "#{dir}/../../lib", "#{dir}/../../test/lib"].each do |dir|
+        fulldir = File.expand_path(dir)
+        $LOAD_PATH.unshift(fulldir) unless $LOAD_PATH.include?(fulldir)
+end
+
+require 'spec'
+require 'puppettest'
+require 'puppettest/runnable_test'
+
+module Spec
+    module Runner
+        class ExampleGroupRunner
+            def run
+                prepare
+                success = true
+                example_groups.each do |example_group|
+                    unless example_group.runnable?
+                        warn "Skipping unsuitable example group %s: %s" % [example_group.description, example_group.messages.join(", ")]
+                        next
+                    end
+                    success = success & example_group.run
+                end
+                return success
+            ensure
+                finish
+            end
+        end
+    end
+end
+
+module Spec
+    module Example
+        class ExampleGroup
+            extend PuppetTest::RunnableTest
+        end
+    end
+end
+
+module Test
+    module Unit
+        class TestCase
+            extend PuppetTest::RunnableTest
+        end
+    end
+end

data/spec/monkey_patches/alias_should_to_must.rb

@@ -0,0 +1,5 @@
+class Object
+    # This is necessary because the RAL has a 'should'
+    # method.
+    alias :must :should
+end

data/spec/shared_behaviours/file_server_terminus.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+describe "Puppet::Indirector::FileServerTerminus", :shared => true do
+    # This only works if the shared behaviour is included before
+    # the 'before' block in the including context.
+    before do
+        Puppet::FileServing::Configuration.clear_cache
+        FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
+        FileTest.stubs(:exists?).with("/my/mount/path").returns(true)
+        FileTest.stubs(:directory?).with("/my/mount/path").returns(true)
+        FileTest.stubs(:readable?).with("/my/mount/path").returns(true)
+
+        # Use a real mount, so the integration is a bit deeper.
+        @mount1 = Puppet::FileServing::Configuration::Mount.new("one")
+        @mount1.path = "/my/mount/path"
+
+        @parser = stub 'parser', :changed? => false
+        @parser.stubs(:parse).returns("one" => @mount1)
+
+        Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+
+        # Stub out the modules terminus
+        @modules = mock 'modules terminus'
+
+        @request = Puppet::Indirector::Request.new(:indirection, :method, "puppetmounts://myhost/one/my/file")
+    end
+
+    it "should use the file server configuration to find files" do
+        @modules.stubs(:find).returns(nil)
+        @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
+
+        path = "/my/mount/path/my/file"
+        FileTest.stubs(:exists?).with(path).returns(true)
+        FileTest.stubs(:exists?).with("/my/mount/path").returns(true)
+        @mount1.expects(:file).with("my/file", :node => nil).returns(path)
+
+        @terminus.find(@request).should be_instance_of(@test_class)
+    end
+end

data/spec/shared_behaviours/file_serving.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+describe "Puppet::FileServing::Files", :shared => true do
+    it "should use the rest terminus when the 'puppet' URI scheme is used and a host name is present" do
+        uri = "puppet://myhost/fakemod/my/file"
+        @indirection.terminus(:rest).expects(:find)
+        @test_class.find(uri)
+    end
+
+    it "should use the rest terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is not 'puppet'" do
+        uri = "puppet:///fakemod/my/file"
+        Puppet.settings.stubs(:value).with(:name).returns("puppetd")
+        Puppet.settings.stubs(:value).with(:modulepath).returns("")
+        @indirection.terminus(:rest).expects(:find)
+        @test_class.find(uri)
+    end
+
+    it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'puppet'" do
+        uri = "puppet:///fakemod/my/file"
+        Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing"))
+        Puppet.settings.stubs(:value).with(:name).returns("puppet")
+        Puppet.settings.stubs(:value).with(:modulepath, "testing").returns("")
+        Puppet.settings.stubs(:value).with(:modulepath).returns("")
+        Puppet.settings.stubs(:value).with(:libdir).returns("")
+        Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
+        Puppet.settings.stubs(:value).with(:environment).returns("")
+        @indirection.terminus(:file_server).expects(:find)
+        @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
+        @test_class.find(uri)
+    end
+
+    it "should use the file_server terminus when the 'puppetmounts' URI scheme is used" do
+        uri = "puppetmounts:///fakemod/my/file"
+        @indirection.terminus(:file_server).expects(:find)
+        @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
+        @test_class.find(uri)
+    end
+
+    it "should use the file terminus when the 'file' URI scheme is used" do
+        uri = "file:///fakemod/my/file"
+        @indirection.terminus(:file).expects(:find)
+        @test_class.find(uri)
+    end
+
+    it "should use the file terminus when a fully qualified path is provided" do
+        uri = "/fakemod/my/file"
+        @indirection.terminus(:file).expects(:find)
+        @test_class.find(uri)
+    end
+
+    it "should use the configuration to test whether the request is allowed" do
+        uri = "puppetmounts:///fakemod/my/file"
+        config = mock 'configuration'
+        @indirection.terminus(:file_server).stubs(:configuration).returns config
+
+        @indirection.terminus(:file_server).expects(:find)
+        config.expects(:authorized?).returns(true)
+        @test_class.find(uri, :node => "foo", :ip => "bar")
+    end
+end
+

data/spec/shared_behaviours/memory_terminus.rb

@@ -0,0 +1,32 @@
+#
+#  Created by Luke Kanies on 2008-4-8.
+#  Copyright (c) 2008. All rights reserved.
+
+describe "A Memory Terminus", :shared => true do
+    it "should find no instances by default" do
+        @searcher.find(@request).should be_nil
+    end
+
+    it "should be able to find instances that were previously saved" do
+        @searcher.save(@request)
+        @searcher.find(@request).should equal(@instance)
+    end
+
+    it "should replace existing saved instances when a new instance with the same name is saved" do
+        @searcher.save(@request)
+        two = stub 'second', :name => @name
+        trequest = stub 'request', :key => @name, :instance => two
+        @searcher.save(trequest)
+        @searcher.find(@request).should equal(two)
+    end
+
+    it "should be able to remove previously saved instances" do
+        @searcher.save(@request)
+        @searcher.destroy(@request)
+        @searcher.find(@request).should be_nil
+    end
+
+    it "should fail when asked to destroy an instance that does not exist" do
+        proc { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+    end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--format
+s
+--colour
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+dir = File.expand_path(File.dirname(__FILE__))
+
+$LOAD_PATH.unshift("#{dir}/")
+$LOAD_PATH.unshift("#{dir}/../lib")
+$LOAD_PATH.unshift("#{dir}/../test/lib")  # Add the old test dir, so that we can still find our local mocha and spec
+
+# include any gems in vendor/gems
+Dir["#{dir}/../vendor/gems/**"].each do |path| 
+    libpath = File.join(path, "lib")
+    if File.directory?(libpath)
+        $LOAD_PATH.unshift(libpath)
+    else
+        $LOAD_PATH.unshift(path)
+    end
+end
+
+require 'puppettest'
+require 'puppettest/runnable_test'
+require 'mocha'
+require 'spec'
+
+# load any monkey-patches
+Dir["#{dir}/monkey_patches/*.rb"].map { |file| require file }
+
+Spec::Runner.configure do |config|
+    config.mock_with :mocha
+
+#  config.prepend_before :all do
+#      setup_mocks_for_rspec
+#      setup() if respond_to? :setup
+#  end
+#
+#  config.prepend_after :all do
+#      teardown() if respond_to? :teardown
+#  end
+end

data/spec/unit/executables/client/certhandler.rb

@@ -0,0 +1,122 @@
+#!/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/executables/client/certhandler'
+
+cert_handler = Puppet::Executables::Client::CertHandler
+
+describe cert_handler, "when handling certificates" do
+    before do 
+        @caclient = mock('caclient')
+        caclient_class = mock('caclient_class')
+        caclient_class.stubs(:new).returns(@caclient)
+        Puppet::Network::Client.stubs(:ca).returns(caclient_class)
+    end
+
+    describe "when reading or retrieving the certificate" do
+        before do
+            @handler = cert_handler.new(1,true)
+        end
+
+        it "should attempt to read the certificate" do
+            @handler.expects(:read_cert).returns true
+            @handler.read_retrieve
+        end
+
+        it "should delegate to Puppet::Network::HttpPool to read the certificate" do
+            Puppet::Network::HttpPool.expects(:read_cert).returns(true)
+            @handler.read_retrieve
+        end
+
+        it "should not attempt to retrieve a certificate if one can be read" do
+            @handler.stubs(:read_cert).returns true
+            @handler.expects(:retrieve_cert).never
+            @handler.read_retrieve
+        end
+
+        it "should attempt to retrieve a certificate if none can be read" do
+            @handler.stubs(:read_cert).returns false
+            @handler.expects(:retrieve_cert)
+            @handler.read_retrieve
+        end
+
+        it "should delegate to caclient to retrieve a certificate" do
+            @handler.stubs(:read_cert).returns false
+            @caclient.expects(:request_cert).returns(true)
+            @handler.stubs(:read_new_cert).returns(true)
+            @handler.read_retrieve
+        end
+
+        it "should return true if the certificate exists" do
+            @handler.stubs(:read_cert).returns true
+            @handler.read_retrieve.should be_true
+        end
+
+        it "should return false when getting a new cert" do
+            #This is the second call to httppool that happens in 'read_new_cert'
+            Puppet::Network::HttpPool.expects(:read_cert).returns(true)
+            @caclient.stubs(:request_cert).returns(true)
+            @handler.stubs(:read_cert).returns(false)
+            @handler.read_retrieve.should be_false
+        end
+    end
+
+    describe "when waiting for cert" do
+        before do
+            @handler = cert_handler.new(1,false)
+            @handler.stubs(:read_cert).returns false
+            #all waiting for cert tests should loop, which will always happen if sleep is called
+            #yeah, I put the expectation in the setup, deal with it
+            @handler.expects(:sleep).with(1)
+
+            #This is needed to get out of the loop
+            @handler.stubs(:read_new_cert).returns(true)
+        end
+
+        it "should loop when the cert request does not return a certificate" do
+            @caclient.stubs(:request_cert).times(2).returns(false).then.returns(true)
+            @handler.retrieve_cert
+        end
+
+        it "should loop when the cert request raises an Error" do
+            @caclient.stubs(:request_cert).times(2).raises(StandardError, 'Testing').then.returns(true)
+            @handler.retrieve_cert
+        end
+        
+        it "should loop when the new cert can't be read" do
+            @caclient.stubs(:request_cert).returns(true)
+            @handler.stubs(:read_new_cert).times(2).returns(false).then.returns(true)
+            @handler.retrieve_cert
+        end
+    end
+
+    describe "when in one time mode" do
+        before do
+            #true puts us in onetime mode
+            @handler = cert_handler.new(1,true)
+            @handler.stubs(:read_cert).returns false
+        end
+
+        it "should exit if the cert request does not return a certificate" do
+            @caclient.stubs(:request_cert).returns(false)
+            @handler.expects(:exit).with(1).raises(SystemExit)
+            lambda { @handler.retrieve_cert }.should raise_error(SystemExit)
+        end
+
+
+        it "should exit if the cert request raises an exception" do
+            @caclient.stubs(:request_cert).raises(StandardError, 'Testing')
+            @handler.expects(:exit).with(23).raises(SystemExit)
+            lambda { @handler.retrieve_cert }.should raise_error(SystemExit)
+        end
+        
+        it "should exit if the new cert can't be read" do
+            @caclient.stubs(:request_cert).returns(true)
+            #this is the second, call to httppool inside read_new_cert
+            Puppet::Network::HttpPool.stubs(:read_cert).returns(false)
+            @handler.expects(:exit).with(34).raises(SystemExit)
+            lambda { @handler.retrieve_cert }.should raise_error(SystemExit)
+        end
+    end
+end

data/spec/unit/file_serving/configuration.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/configuration'
+
+describe Puppet::FileServing::Configuration do
+    it "should make :new a private method" do
+        proc { Puppet::FileServing::Configuration.new }.should raise_error
+    end
+
+    it "should return the same configuration each time :create is called" do
+        Puppet::FileServing::Configuration.create.should equal(Puppet::FileServing::Configuration.create)
+    end
+
+    it "should have a method for removing the current configuration instance" do
+        old = Puppet::FileServing::Configuration.create
+        Puppet::FileServing::Configuration.clear_cache
+        Puppet::FileServing::Configuration.create.should_not equal(old)
+    end
+
+    after do
+        Puppet::FileServing::Configuration.clear_cache
+    end
+end
+
+describe Puppet::FileServing::Configuration do
+
+    before :each do
+        @path = "/path/to/configuration/file.conf"
+        Puppet.settings.stubs(:value).with(:fileserverconfig).returns(@path)
+    end
+
+    after :each do
+        Puppet::FileServing::Configuration.clear_cache
+    end
+
+    describe Puppet::FileServing::Configuration, " when initializing" do
+
+        it "should work without a configuration file" do
+            FileTest.stubs(:exists?).with(@path).returns(false)
+            proc { Puppet::FileServing::Configuration.create }.should_not raise_error
+        end
+
+        it "should parse the configuration file if present" do
+            FileTest.stubs(:exists?).with(@path).returns(true)
+            @parser = mock 'parser'
+            @parser.expects(:parse).returns({})
+            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+            Puppet::FileServing::Configuration.create
+        end
+
+        it "should determine the path to the configuration file from the Puppet settings" do
+            Puppet::FileServing::Configuration.create
+        end
+    end
+
+    describe Puppet::FileServing::Configuration, " when parsing the configuration file" do
+
+        before do
+            FileTest.stubs(:exists?).with(@path).returns(true)
+            @parser = mock 'parser'
+            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+        end
+
+        it "should set the mount list to the results of parsing" do
+            @parser.expects(:parse).returns("one" => mock("mount"))
+            config = Puppet::FileServing::Configuration.create
+            config.mounted?("one").should be_true
+        end
+
+        it "should not raise exceptions" do
+            @parser.expects(:parse).raises(ArgumentError)
+            proc { Puppet::FileServing::Configuration.create }.should_not raise_error
+        end
+
+        it "should replace the existing mount list with the results of reparsing" do
+            @parser.expects(:parse).returns("one" => mock("mount"))
+            config = Puppet::FileServing::Configuration.create
+            config.mounted?("one").should be_true
+            # Now parse again
+            @parser.expects(:parse).returns("two" => mock('other'))
+            config.send(:readconfig, false)
+            config.mounted?("one").should be_false
+            config.mounted?("two").should be_true
+        end
+
+        it "should not replace the mount list until the file is entirely parsed successfully" do
+            @parser.expects(:parse).returns("one" => mock("mount"))
+            @parser.expects(:parse).raises(ArgumentError)
+            config = Puppet::FileServing::Configuration.create
+            # Now parse again, so the exception gets thrown
+            config.send(:readconfig, false)
+            config.mounted?("one").should be_true
+        end
+    end
+
+    describe Puppet::FileServing::Configuration, " when finding files" do
+
+        before do
+            @parser = mock 'parser'
+            @parser.stubs(:changed?).returns true
+            FileTest.stubs(:exists?).with(@path).returns(true)
+            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+
+            @mount1 = stub 'mount', :name => "one"
+            @mounts = {"one" => @mount1}
+
+            Facter.stubs(:value).with("hostname").returns("whatever")
+
+            @config = Puppet::FileServing::Configuration.create
+        end
+
+        it "should fail if the uri does not match a leading slash followed by a valid mount name" do
+            @parser.expects(:parse).returns(@mounts)
+            proc { @config.file_path("something") }.should raise_error(ArgumentError)
+        end
+
+        it "should use the first term after the first slash for the mount name" do
+            @parser.expects(:parse).returns(@mounts)
+            FileTest.stubs(:exists?).returns(true)
+            @mount1.expects(:file)
+            @config.file_path("/one")
+        end
+
+        it "should use the remainder of the URI after the mount name as the file name" do
+            @parser.expects(:parse).returns(@mounts)
+            @mount1.expects(:file).with("something/else", {})
+            FileTest.stubs(:exists?).returns(true)
+            @config.file_path("/one/something/else")
+        end
+
+        it "should treat a bare name as a mount and no relative file" do
+            @parser.expects(:parse).returns(@mounts)
+            @mount1.expects(:file).with(nil, {})
+            FileTest.stubs(:exists?).returns(true)
+            @config.file_path("/one")
+        end
+
+        it "should treat a name with a trailing slash equivalently to a name with no trailing slash" do
+            @parser.expects(:parse).returns(@mounts)
+            @mount1.expects(:file).with(nil, {})
+            FileTest.stubs(:exists?).returns(true)
+            @config.file_path("/one/")
+        end
+
+        it "should return nil if the mount cannot be found" do
+            @parser.expects(:changed?).returns(true)
+            @parser.expects(:parse).returns({})
+            @config.file_path("/one/something").should be_nil
+        end
+
+        it "should return nil if the mount does not contain the file" do
+            @parser.expects(:parse).returns(@mounts)
+            @mount1.expects(:file).with("something/else", {}).returns(nil)
+            @config.file_path("/one/something/else").should be_nil
+        end
+
+        it "should return the fully qualified path if the mount exists" do
+            @parser.expects(:parse).returns(@mounts)
+            @mount1.expects(:file).with("something/else", {}).returns("/full/path")
+            @config.file_path("/one/something/else").should == "/full/path"
+        end
+
+        it "should reparse the configuration file when it has changed" do
+            @mount1.stubs(:file).returns("whatever")
+            @parser.expects(:changed?).returns(true)
+            @parser.expects(:parse).returns(@mounts)
+            FileTest.stubs(:exists?).returns(true)
+            @config.file_path("/one/something")
+
+            @parser.expects(:changed?).returns(true)
+            @parser.expects(:parse).returns({})
+            @config.file_path("/one/something").should be_nil
+        end
+    end
+
+    describe Puppet::FileServing::Configuration, " when checking authorization" do
+
+        before do
+            @parser = mock 'parser'
+            @parser.stubs(:changed?).returns true
+            FileTest.stubs(:exists?).with(@path).returns(true)
+            Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+
+            @mount1 = stub 'mount', :name => "one"
+            @mounts = {"one" => @mount1}
+            @parser.stubs(:parse).returns(@mounts)
+
+            Facter.stubs(:value).with("hostname").returns("whatever")
+
+            @config = Puppet::FileServing::Configuration.create
+        end
+
+        it "should return false if the mount cannot be found" do
+            @config.authorized?("/nope/my/file").should be_false
+        end
+
+        it "should use the mount to determine authorization" do
+            @mount1.expects(:allowed?)
+            @config.authorized?("/one/my/file")
+        end
+
+        it "should pass the client's name to the mount if provided" do
+            @mount1.expects(:allowed?).with("myhost", nil)
+            @config.authorized?("/one/my/file", :node => "myhost")
+        end
+
+        it "should pass the client's IP to the mount if provided" do
+            @mount1.expects(:allowed?).with("myhost", "myip")
+            @config.authorized?("/one/my/file", :node => "myhost", :ipaddress => "myip")
+        end
+
+        it "should return true if the mount allows the client" do
+            @mount1.expects(:allowed?).returns(true)
+            @config.authorized?("/one/my/file").should be_true
+        end
+
+        it "should return false if the mount denies the client"  do
+            @mount1.expects(:allowed?).returns(false)
+            @config.authorized?("/one/my/file").should be_false
+        end
+    end
+end