puppet 0.25.5 → 2.6.0

data/spec/integration/type/package.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Puppet::Type.type(:package), "when choosing a default package provider" do
-    before do
-        # the default provider is cached.
-        Puppet::Type.type(:package).defaultprovider = nil
-    end
-
-    def provider_name(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
-        Puppet::Type.type(:package).defaultprovider.should_not be_nil
-    end
-
-    it "should choose the correct provider each platform" do
-        unless default_provider = provider_name(Facter.value(:operatingsystem))
-            pending("No default provider specified in this test for %s" % Facter.value(:operatingsystem))
-        end
-        Puppet::Type.type(:package).defaultprovider.name.should == default_provider
-    end
-end

data/spec/integration/type/tidy.rb

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

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

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

@@ -1,37 +0,0 @@
-#!/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/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 = 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) }
-
-        threads = []
-        sync = Sync.new
-        9.times { |a|
-            threads << Thread.new {
-                9.times { |b|
-                    sync.synchronize(Sync::SH) {
-                        Puppet::Util::FileLocking.readlock(file) { |f|
-                            YAML.load(f.read).should == data
-                        }
-                    }
-                    sleep 0.01
-                    sync.synchronize(Sync::EX) {
-                        Puppet::Util::FileLocking.writelock(file) { |f|
-                            f.puts YAML.dump(data)
-                        }
-                    }
-                }
-            }
-        }
-        threads.each { |th| th.join }
-    end
-end

data/spec/integration/util/settings.rb

@@ -1,27 +0,0 @@
-#!/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/unit/agent.rb

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