puppet 0.24.9 → 0.25.0

data/spec/integration/type/package.rb

@@ -9,7 +9,7 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
     end
 
     def provider_name(os)
-        {"Ubuntu" => :apt, "Debian" => :apt, "Darwin" => :apple, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
+        {"Ubuntu" => :apt, "Debian" => :apt, "Darwin" => :pkgdmg, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
     end
 
     it "should have a default provider" do

data/spec/integration/type/tidy.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet_spec/files'
+
+describe Puppet::Type.type(:tidy) do
+    include PuppetSpec::Files
+
+    # Testing #355.
+    it "should be able to remove dead links" do
+        dir = tmpfile("tidy_link_testing")
+        link = File.join(dir, "link")
+        target = tmpfile("no_such_file_tidy_link_testing")
+        Dir.mkdir(dir)
+        File.symlink(target, link)
+
+        tidy = Puppet::Type.type(:tidy).new :path => dir, :recurse => true
+
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource(tidy)
+
+        catalog.apply
+
+        FileTest.should_not be_symlink(link)
+    end
+end

data/spec/integration/util/autoload.rb

@@ -0,0 +1,114 @@
+#!/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/autoload'
+require 'fileutils'
+
+class AutoloadIntegrator
+    @things = []
+    def self.newthing(name)
+        @things << name
+    end
+
+    def self.thing?(name)
+        @things.include? name
+    end
+
+    def self.clear
+        @things.clear
+    end
+end
+
+require 'puppet_spec/files'
+
+describe Puppet::Util::Autoload do
+    include PuppetSpec::Files
+
+    def with_file(name, *path)
+        path = File.join(*path)
+        # Now create a file to load
+        File.open(path, "w") { |f|
+            f.puts "\nAutoloadIntegrator.newthing(:#{name.to_s})\n"
+            }
+        yield
+        File.delete(path)
+    end
+
+    def with_loader(name, path)
+        dir = tmpfile(name + path)
+        $: << dir
+        Dir.mkdir(dir)
+        rbdir = File.join(dir, path.to_s)
+        Dir.mkdir(rbdir)
+        loader = Puppet::Util::Autoload.new(name, path)
+        yield rbdir, loader
+        Dir.rmdir(rbdir)
+        Dir.rmdir(dir)
+        $:.pop
+        AutoloadIntegrator.clear
+    end
+
+    it "should make instances available by the loading class" do
+        loader = Puppet::Util::Autoload.new("foo", "bar")
+        Puppet::Util::Autoload["foo"].should == loader
+    end
+
+    it "should not fail when asked to load a missing file" do
+        Puppet::Util::Autoload.new("foo", "bar").load(:eh).should be_false
+    end
+
+    it "should load and return true when it successfully loads a file" do
+        with_loader("foo", "bar") { |dir,loader|
+            with_file(:mything, dir, "mything.rb") {
+                loader.load(:mything).should be_true
+                loader.should be_loaded(:mything)
+                AutoloadIntegrator.should be_thing(:mything)
+            }
+        }
+    end
+
+    it "should consider a file loaded when asked for the name without an extension" do
+        with_loader("foo", "bar") { |dir,loader|
+            with_file(:noext, dir, "noext.rb") {
+                loader.load(:noext)
+                loader.should be_loaded(:noext)
+            }
+        }
+    end
+
+    it "should consider a file loaded when asked for the name with an extension" do
+        with_loader("foo", "bar") { |dir,loader|
+            with_file(:noext, dir, "withext.rb") {
+                loader.load(:withext)
+                loader.should be_loaded("withext.rb")
+            }
+        }
+    end
+
+    it "should register the fact that the instance is loaded with the Autoload base class" do
+        with_loader("foo", "bar") { |dir,loader|
+            with_file(:baseload, dir, "baseload.rb") {
+                loader.load(:baseload)
+                Puppet::Util::Autoload.should be_loaded("bar/withext.rb")
+            }
+        }
+    end
+
+    it "should be able to load files directly from modules" do
+        modulepath = tmpfile("autoload_module_testing")
+        libdir = File.join(modulepath, "mymod", "lib", "foo")
+        FileUtils.mkdir_p(libdir)
+
+        file = File.join(libdir, "plugin.rb")
+
+        Puppet[:modulepath] = modulepath
+
+        with_loader("foo", "foo") do |dir, loader|
+            with_file(:plugin, file.split("/")) do
+                loader.load(:plugin)
+                loader.should be_loaded("plugin.rb")
+            end
+        end
+    end
+end

data/spec/integration/util/feature.rb

@@ -0,0 +1,54 @@
+#!/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/feature'
+require 'puppet_spec/files'
+
+describe Puppet::Util::Feature do
+    include PuppetSpec::Files
+
+    it "should be able to load features from disk" do
+        libdir = tmpfile("feature_lib")
+        Dir.mkdir(libdir)
+
+        $: << libdir
+
+        $features = Puppet::Util::Feature.new("feature_lib")
+
+        Dir.mkdir(File.join(libdir, "feature_lib"))
+
+        File.open(File.join(libdir, "feature_lib", "able_to_load.rb"), "w") do |f|
+            f.puts "$features.add(:able_to_load) { true }"
+        end
+
+        $features.should be_able_to_load
+    end
+
+    # TODO: Make this a spec test or remove it.
+    def test_dynamic_loading
+        $features = @features
+        cleanup { $features = nil }
+        # Now create a feature and make sure it loads.
+        FileUtils.mkdir_p(@path)
+        nope = File.join(@path, "nope.rb")
+        File.open(nope, "w") { |f|
+            f.puts "$features.add(:nope, :libs => %w{nosuchlib})"
+        }
+        assert_nothing_raised("Failed to autoload features") do
+            assert(! @features.nope?, "'nope' returned true")
+        end
+
+        # First make sure "yep?" returns false
+        assert_nothing_raised("Missing feature threw an exception") do
+            assert(! @features.notyep?, "'notyep' returned true before definition")
+        end
+
+        yep = File.join(@path, "yep.rb")
+        File.open(yep, "w") { |f|
+            f.puts "$features.add(:yep, :libs => %w{puppet})"
+        }
+
+        assert(@features.yep?, "false 'yep' is apparently cached or feature could not be loaded")
+    end
+end

data/spec/integration/util/file_locking.rb

@@ -7,8 +7,9 @@ require 'puppet/util/file_locking'
 describe Puppet::Util::FileLocking do
     it "should be able to keep file corruption from happening when there are multiple writers" do
         file = Tempfile.new("puppetspec")
+        filepath = file.path
         file.close!()
-        file = file.path
+        file = filepath
         data = {:a => :b, :c => "A string", :d => "another string", :e => %w{an array of strings}}
         File.open(file, "w") { |f| f.puts YAML.dump(data) }
 

data/spec/integration/util/settings.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet_spec/files'
+
+describe Puppet::Util::Settings do
+    include PuppetSpec::Files
+
+    it "should be able to make needed directories" do
+        settings = Puppet::Util::Settings.new
+        settings.setdefaults :main, :maindir => [tmpfile("main"), "a"]
+
+        settings.use(:main)
+
+        File.should be_directory(settings[:maindir])
+    end
+
+    it "should make its directories with the corret modes" do
+        settings = Puppet::Util::Settings.new
+        settings.setdefaults :main, :maindir => {:default => tmpfile("main"), :desc => "a", :mode => 0750}
+
+        settings.use(:main)
+
+        (File.stat(settings[:maindir]).mode & 007777).should == 0750
+    end
+end

data/spec/lib/puppet_spec/files.rb

@@ -0,0 +1,9 @@
+# A support module for testing files.
+module PuppetSpec::Files
+    def tmpfile(name)
+        source = Tempfile.new(name)
+        path = source.path
+        source.close!
+        path
+    end
+end

data/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb

@@ -20,6 +20,7 @@ module Spec
                         next
                     end
                     success = success & example_group.run(@options)
+                    Puppet.settings.clear
                 end
                 return success
             ensure

data/spec/monkey_patches/alias_should_to_must.rb

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

data/spec/shared_behaviours/file_server_terminus.rb

@@ -7,15 +7,21 @@ 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
+        Puppet::Util::Cacher.expire
+        FileTest.stubs(:exists?).returns true
         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)
+
+        @path = Tempfile.new("file_server_testing")
+        path = @path.path
+        @path.close!
+        @path = path
+
+        Dir.mkdir(@path)
+        File.open(File.join(@path, "myfile"), "w") { |f| f.print "my content" }
 
         # Use a real mount, so the integration is a bit deeper.
-        @mount1 = Puppet::FileServing::Configuration::Mount.new("one")
-        @mount1.path = "/my/mount/path"
+        @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
+        @mount1.path = @path
 
         @parser = stub 'parser', :changed? => false
         @parser.stubs(:parse).returns("one" => @mount1)
@@ -25,17 +31,14 @@ describe "Puppet::Indirector::FileServerTerminus", :shared => true do
         # Stub out the modules terminus
         @modules = mock 'modules terminus'
 
-        @request = Puppet::Indirector::Request.new(:indirection, :method, "puppetmounts://myhost/one/my/file")
+        @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile")
     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)
+        path = File.join(@path, "myfile")
 
         @terminus.find(@request).should be_instance_of(@test_class)
     end

data/spec/shared_behaviours/file_serving.rb

@@ -6,12 +6,18 @@
 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)
+
+        # It appears that the mocking somehow interferes with the caching subsystem.
+        # This mock somehow causes another terminus to get generated.
+        term = @indirection.terminus(:rest)
+        @indirection.stubs(:terminus).with(:rest).returns term
+        term.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).returns "foo"
         Puppet.settings.stubs(:value).with(:name).returns("puppetd")
         Puppet.settings.stubs(:value).with(:modulepath).returns("")
         @indirection.terminus(:rest).expects(:find)
@@ -20,20 +26,10 @@ describe "Puppet::FileServing::Files", :shared => true do
 
     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::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil))
+        Puppet.settings.stubs(:value).returns ""
         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)
@@ -52,13 +48,13 @@ describe "Puppet::FileServing::Files", :shared => true do
     end
 
     it "should use the configuration to test whether the request is allowed" do
-        uri = "puppetmounts:///fakemod/my/file"
-        config = mock 'configuration'
+        uri = "fakemod/my/file"
+        mount = mock 'mount'
+        config = stub 'configuration', :split_path => [mount, "eh"]
         @indirection.terminus(:file_server).stubs(:configuration).returns config
 
         @indirection.terminus(:file_server).expects(:find)
-        config.expects(:authorized?).returns(true)
+        mount.expects(:allowed?).returns(true)
         @test_class.find(uri, :node => "foo", :ip => "bar")
     end
 end
-

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
 dir = File.expand_path(File.dirname(__FILE__))
 
 $LOAD_PATH.unshift("#{dir}/")
+$LOAD_PATH.unshift("#{dir}/lib") # a spec-specific test lib 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| 
+Dir["#{dir}/../vendor/gems/**"].each do |path|
     libpath = File.join(path, "lib")
     if File.directory?(libpath)
         $LOAD_PATH.unshift(libpath)
@@ -18,7 +19,11 @@ require 'puppettest'
 require 'puppettest/runnable_test'
 require 'mocha'
 gem 'rspec', '=1.2.2'
-require 'spec'
+require 'spec/autorun'
+
+# So everyone else doesn't have to include this base constant.
+module PuppetSpec
+end
 
 # load any monkey-patches
 Dir["#{dir}/monkey_patches/*.rb"].map { |file| require file }
@@ -31,7 +36,19 @@ Spec::Runner.configure do |config|
 #      setup() if respond_to? :setup
 #  end
 #
-#  config.prepend_after :all do
-#      teardown() if respond_to? :teardown
-#  end
+    config.prepend_after :each do
+        Puppet.settings.clear
+        Puppet::Node::Environment.clear
+    end
+end
+
+# Set the confdir and vardir to gibberish so that tests
+# have to be correctly mocked.
+Puppet[:confdir] = "/dev/null"
+Puppet[:vardir] = "/dev/null"
+
+# We need this because the RAL uses 'should' as a method.  This
+# allows us the same behaviour but with a different method name.
+class Object
+    alias :must :should
 end

data/spec/unit/agent.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-11-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/agent'
+
+class AgentTestClient
+    def run
+        # no-op
+    end
+    def stop
+        # no-op
+    end
+end
+
+describe Puppet::Agent do
+    before do
+        @agent = Puppet::Agent.new(AgentTestClient)
+
+        # So we don't actually try to hit the filesystem.
+        @agent.stubs(:lock).yields
+    end
+
+    it "should set its client class at initialization" do
+        Puppet::Agent.new("foo").client_class.should == "foo"
+    end
+
+    it "should include the Locker module" do
+        Puppet::Agent.ancestors.should be_include(Puppet::Agent::Locker)
+    end
+
+    it "should create an instance of its client class and run it when asked to run" do
+        client = mock 'client'
+        AgentTestClient.expects(:new).returns client
+
+        client.expects(:run)
+
+        @agent.stubs(:running?).returns false
+        @agent.run
+    end
+
+    it "should determine its lock file path by asking the client class" do
+        AgentTestClient.expects(:lockfile_path).returns "/my/lock"
+        @agent.lockfile_path.should == "/my/lock"
+    end
+
+    it "should be considered running if the lock file is locked" do
+        lockfile = mock 'lockfile'
+
+        @agent.expects(:lockfile).returns lockfile
+        lockfile.expects(:locked?).returns true
+
+        @agent.should be_running
+    end
+
+    describe "when being run" do
+        before do
+            @agent.stubs(:running?).returns false
+        end
+
+        it "should splay" do
+            @agent.expects(:splay)
+            @agent.stubs(:running?).returns false
+
+            @agent.run
+        end
+
+        it "should do nothing if already running" do
+            @agent.expects(:running?).returns true
+            AgentTestClient.expects(:new).never
+            @agent.run
+        end
+
+        it "should do nothing if it is in the process of stopping" do
+            @agent.expects(:stopping?).returns true
+            AgentTestClient.expects(:new).never
+            @agent.run
+        end
+
+        it "should not fail if a client class instance cannot be created" do
+            AgentTestClient.expects(:new).raises "eh"
+            Puppet.expects(:err)
+            @agent.run
+        end
+
+        it "should not fail if there is an exception while running its client" do
+            client = AgentTestClient.new
+            AgentTestClient.expects(:new).returns client
+            client.expects(:run).raises "eh"
+            Puppet.expects(:err)
+            @agent.run
+        end
+
+        it "should use a mutex to restrict multi-threading" do
+            client = AgentTestClient.new
+            AgentTestClient.expects(:new).returns client
+
+            mutex = mock 'mutex'
+            @agent.expects(:sync).returns mutex
+
+            mutex.expects(:synchronize)
+            client.expects(:run).never # if it doesn't run, then we know our yield is what triggers it
+            @agent.run
+        end
+
+        it "should use a filesystem lock to restrict multiple processes running the agent" do
+            client = AgentTestClient.new
+            AgentTestClient.expects(:new).returns client
+
+            @agent.expects(:lock)
+
+            client.expects(:run).never # if it doesn't run, then we know our yield is what triggers it
+            @agent.run
+        end
+
+        it "should make its client instance available while running" do
+            client = AgentTestClient.new
+            AgentTestClient.expects(:new).returns client
+
+            client.expects(:run).with { @agent.client.should equal(client); true }
+            @agent.run
+        end
+
+        it "should run the client instance with any arguments passed to it" do
+            client = AgentTestClient.new
+            AgentTestClient.expects(:new).returns client
+
+            client.expects(:run).with("testargs")
+            @agent.run("testargs")
+        end
+    end
+
+    describe "when splaying" do
+        before do
+            Puppet.settings.stubs(:value).with(:splay).returns true
+            Puppet.settings.stubs(:value).with(:splaylimit).returns "10"
+        end
+
+        it "should do nothing if splay is disabled" do
+            Puppet.settings.expects(:value).returns false
+            @agent.expects(:sleep).never
+            @agent.splay
+        end
+
+        it "should do nothing if it has already splayed" do
+            @agent.expects(:splayed?).returns true
+            @agent.expects(:sleep).never
+            @agent.splay
+        end
+
+        it "should log that it is splaying" do
+            @agent.stubs :sleep
+            Puppet.expects :info
+            @agent.splay
+        end
+
+        it "should sleep for a random portion of the splaylimit plus 1" do
+            Puppet.settings.expects(:value).with(:splaylimit).returns "50"
+            @agent.expects(:rand).with(51).returns 10
+            @agent.expects(:sleep).with(10)
+            @agent.splay
+        end
+
+        it "should mark that it has splayed" do
+            @agent.stubs(:sleep)
+            @agent.splay
+            @agent.should be_splayed
+        end
+    end
+
+    describe "when stopping" do
+        it "should do nothing if already stopping" do
+            @agent.expects(:stopping?).returns true
+            @agent.stop
+        end
+
+        it "should stop the client if one is available and it responds to 'stop'" do
+            client = AgentTestClient.new
+
+            @agent.stubs(:client).returns client
+            client.expects(:stop)
+            @agent.stop
+        end
+
+        it "should mark itself as stopping while waiting for the client to stop" do
+            client = AgentTestClient.new
+
+            @agent.stubs(:client).returns client
+            client.expects(:stop).with { @agent.should be_stopping; true }
+
+            @agent.stop
+        end
+    end
+
+    describe "when starting" do
+        before do
+            @agent.stubs(:observe_signal)
+        end
+
+        it "should create a timer with the runinterval, a tolerance of 1, and :start? set to true" do
+            Puppet.settings.expects(:value).with(:runinterval).returns 5
+            timer = stub 'timer', :sound_alarm => nil
+            EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).returns timer
+
+            @agent.stubs(:run)
+            @agent.start
+        end
+
+        it "should run once immediately" do
+            timer = mock 'timer'
+            EventLoop::Timer.expects(:new).returns timer
+
+            timer.expects(:sound_alarm)
+
+            @agent.start
+        end
+
+        it "should run within the block passed to the timer" do
+            timer = stub 'timer', :sound_alarm => nil
+            EventLoop::Timer.expects(:new).returns(timer).yields
+            @agent.expects(:run)
+
+            @agent.start
+        end
+    end
+
+    describe "when restarting" do
+        it "should configure itself for a delayed restart if currently running" do
+            @agent.expects(:running?).returns true
+
+            @agent.restart
+
+            @agent.should be_needing_restart
+        end
+
+        it "should hup itself if not running" do
+            @agent.expects(:running?).returns false
+
+            Process.expects(:kill).with(:HUP, $$)
+
+            @agent.restart
+        end
+
+        it "should turn off the needing_restart switch" do
+            @agent.expects(:running?).times(2).returns(true).then.returns false
+
+            Process.stubs(:kill)
+
+            # First call sets up the switch
+            @agent.restart
+
+            # Second call should disable it
+            @agent.restart
+            @agent.should_not be_needing_restart
+        end
+    end
+end