puppet 0.24.6 → 0.24.7

data/spec/unit/module.rb

@@ -0,0 +1,247 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Puppet::Module, " when building its search path" do
+    include PuppetTest
+
+    it "should fully qualify unqualified paths in the search path" do
+        Puppet[:modulepath] = "something:/my/something"
+        File.stubs(:directory?).returns(true)
+        Puppet::Module.modulepath.should == [File.join(Dir.getwd, 'something'), "/my/something"]
+    end
+
+    it "should ignore paths that do not exist" do
+        Puppet[:modulepath] = "/yes:/no"
+        File.expects(:directory?).with("/yes").returns(true)
+        File.expects(:directory?).with("/no").returns(false)
+        Puppet::Module.modulepath.should == %w{/yes}
+    end
+
+    it "should prepend PUPPETLIB in search path when set" do
+        Puppet[:modulepath] = "/my/mod:/other/mod"
+        ENV["PUPPETLIB"] = "/env/mod:/myenv/mod"
+        File.stubs(:directory?).returns(true)
+        Puppet::Module.modulepath.should == %w{/env/mod /myenv/mod /my/mod /other/mod}
+    end
+
+    it "should use the environment-specific search path when a node environment is provided" do
+        Puppet.settings.expects(:value).with(:modulepath, "myenv").returns("/mone:/mtwo")
+        File.stubs(:directory?).returns(true)
+        Puppet::Module.modulepath("myenv").should == %w{/mone /mtwo}
+    end
+
+    after do
+        ENV["PUPPETLIB"] = nil
+    end
+end
+
+describe Puppet::Module, " when searching for modules" do
+    it "should find modules in the search path" do
+        path = %w{/dir/path}
+        Puppet::Module.stubs(:modulepath).returns(path)
+        File.stubs(:directory?).returns(true)
+        mod = Puppet::Module.find("mymod")
+        mod.should be_an_instance_of(Puppet::Module)
+        mod.path.should == "/dir/path/mymod"
+    end
+
+    it "should not search for fully qualified modules" do
+        path = %w{/dir/path}
+        Puppet::Module.expects(:modulepath).never
+        File.expects(:directory?).never
+        Puppet::Module.find("/mymod").should be_nil
+    end
+
+    it "should search for modules in the order specified in the search path" do
+        Puppet[:modulepath] = "/one:/two:/three"
+        Puppet::Module.stubs(:modulepath).returns %w{/one /two /three}
+        File.expects(:directory?).with("/one/mod").returns(false)
+        File.expects(:directory?).with("/two/mod").returns(true)
+        File.expects(:directory?).with("/three/mod").never
+        mod = Puppet::Module.find("mod")
+        mod.path.should == "/two/mod"
+    end
+
+    it "should use a node environment if specified" do
+        Puppet::Module.expects(:modulepath).with("myenv").returns([])
+        Puppet::Module.find("mymod", "myenv")
+    end
+end
+
+describe Puppet::Module, " when searching for templates" do
+    it "should return fully-qualified templates directly" do
+        Puppet::Module.expects(:modulepath).never
+        Puppet::Module.find_template("/my/template").should == "/my/template"
+    end
+
+    it "should return the template from the first found module" do
+        Puppet[:modulepath] = "/one:/two"
+        File.stubs(:directory?).returns(true)
+        Puppet::Module.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+    end
+    
+    it "should return the file in the templatedir if it exists" do
+        Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
+        Puppet[:modulepath] = "/one:/two"
+        File.stubs(:directory?).returns(true)
+        File.stubs(:exists?).returns(true)
+        Puppet::Module.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+    end
+
+    it "should raise an error if no valid templatedir exists" do
+        Puppet::Module.stubs(:templatepath).with(nil).returns(nil)
+        lambda { Puppet::Module.find_template("mytemplate") }.should raise_error
+    end
+
+    it "should not raise an error if no valid templatedir exists and the template exists in a module" do
+        Puppet::Module.stubs(:templatepath).with(nil).returns(nil)
+        Puppet[:modulepath] = "/one:/two"
+        File.stubs(:directory?).returns(true)
+        File.stubs(:exists?).returns(true)
+        Puppet::Module.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+    end
+
+    it "should use the main templatedir if no module is found" do
+        Puppet::Module.stubs(:templatepath).with(nil).returns(["/my/templates"])
+        Puppet::Module.expects(:find).with("mymod", nil).returns(nil)
+        Puppet::Module.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+    end
+
+    it "should return unqualified templates directly in the template dir" do
+        Puppet::Module.stubs(:templatepath).with(nil).returns(["/my/templates"])
+        Puppet::Module.expects(:find).never
+        Puppet::Module.find_template("mytemplate").should == "/my/templates/mytemplate"
+    end
+
+    it "should accept relative templatedirs" do
+        Puppet[:templatedir] = "my/templates"
+        File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
+        Puppet::Module.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
+    end
+
+    it "should use the environment templatedir if no module is found and an environment is specified" do
+        Puppet::Module.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
+        Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
+        Puppet::Module.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+    end
+
+    it "should use first dir from environment templatedir if no module is found and an environment is specified" do
+        Puppet::Module.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
+        Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
+        Puppet::Module.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+    end
+
+    it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
+        Puppet::Module.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+        File.expects(:exists?).with("/one/templates/mytemplate").returns(true)
+        Puppet::Module.expects(:find).never
+        Puppet::Module.find_template("mytemplate").should == "/one/templates/mytemplate"
+    end
+
+    it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
+        Puppet::Module.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+        File.expects(:exists?).with("/one/templates/mytemplate").returns(false)
+        File.expects(:exists?).with("/two/templates/mytemplate").returns(true)
+        Puppet::Module.expects(:find).never
+        Puppet::Module.find_template("mytemplate").should == "/two/templates/mytemplate"
+    end
+
+    it "should use the node environment if specified" do
+        Puppet.settings.stubs(:value).returns.returns("/my/directory")
+        Puppet.settings.expects(:value).with(:modulepath, "myenv").returns("/my/modules")
+        File.stubs(:directory?).returns(true)
+        Puppet::Module.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
+    end
+
+    after { Puppet.settings.clear }
+end
+
+describe Puppet::Module, " when searching for manifests when no module is found" do
+    before do
+        File.stubs(:find).returns(nil)
+    end
+
+    it "should not look for modules when paths are fully qualified" do
+        Puppet.expects(:value).with(:modulepath).never
+        file = "/fully/qualified/file.pp"
+        Dir.stubs(:glob).with(file).returns([file])
+        Puppet::Module.find_manifests(file)
+    end
+
+    it "should directly return fully qualified files" do
+        file = "/fully/qualified/file.pp"
+        Dir.stubs(:glob).with(file).returns([file])
+        Puppet::Module.find_manifests(file).should == [file]
+    end
+
+    it "should match against provided fully qualified patterns" do
+        pattern = "/fully/qualified/pattern/*"
+        Dir.expects(:glob).with(pattern).returns(%w{my file list})
+        Puppet::Module.find_manifests(pattern).should == %w{my file list}
+    end
+
+    it "should look for files relative to the current directory" do
+        cwd = Dir.getwd
+        Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
+        Puppet::Module.find_manifests("foobar/init.pp").should == ["#{cwd}/foobar/init.pp"]
+    end
+
+    it "should only return files, not directories" do
+        pattern = "/fully/qualified/pattern/*"
+        file = "/my/file"
+        dir = "/my/directory"
+        Dir.expects(:glob).with(pattern).returns([file, dir])
+        FileTest.expects(:directory?).with(file).returns(false)
+        FileTest.expects(:directory?).with(dir).returns(true)
+        Puppet::Module.find_manifests(pattern).should == [file]
+    end
+end
+
+describe Puppet::Module, " when searching for manifests in a found module" do
+    it "should return the manifests from the first found module" do
+        Puppet[:modulepath] = "/one:/two"
+        File.stubs(:directory?).returns(true)
+        Dir.expects(:glob).with("/one/mymod/manifests/init.pp").returns(%w{/one/mymod/manifests/init.pp})
+        Puppet::Module.find_manifests("mymod/init.pp").should == ["/one/mymod/manifests/init.pp"]
+    end
+
+    it "should use the node environment if specified" do
+        Puppet.settings.expects(:value).with(:modulepath, "myenv").returns("/env/modules")
+        File.stubs(:directory?).returns(true)
+        Dir.expects(:glob).with("/env/modules/mymod/manifests/envmanifest.pp").returns(%w{/env/modules/mymod/manifests/envmanifest.pp})
+        Puppet::Module.find_manifests("mymod/envmanifest.pp", :environment => "myenv").should == ["/env/modules/mymod/manifests/envmanifest.pp"]
+    end
+
+    it "should return all manifests matching the glob pattern" do
+        Puppet.settings.expects(:value).with(:modulepath, nil).returns("/my/modules")
+        File.stubs(:directory?).returns(true)
+        Dir.expects(:glob).with("/my/modules/mymod/manifests/yay/*.pp").returns(%w{/one /two})
+        Puppet::Module.find_manifests("mymod/yay/*.pp").should == %w{/one /two}
+    end
+
+    it "should not return directories" do
+        Puppet.settings.expects(:value).with(:modulepath, nil).returns("/my/modules")
+        File.stubs(:directory?).returns(true)
+        Dir.expects(:glob).with("/my/modules/mymod/manifests/yay/*.pp").returns(%w{/one /two})
+        FileTest.expects(:directory?).with("/one").returns false
+        FileTest.expects(:directory?).with("/two").returns true
+        Puppet::Module.find_manifests("mymod/yay/*.pp").should == %w{/one}
+    end
+
+    it "should default to the 'init.pp' file in the manifests directory" do
+        Puppet.settings.expects(:value).with(:modulepath, nil).returns("/my/modules")
+        File.stubs(:directory?).returns(true)
+        Dir.expects(:glob).with("/my/modules/mymod/manifests/init.pp").returns(%w{my manifest})
+        Puppet::Module.find_manifests("mymod").should == %w{my manifest}
+    end
+
+    after { Puppet.settings.clear }
+end
+
+describe Puppet::Module, " when returning files" do
+    it "should return the path to the module's 'files' directory" do
+        mod = Puppet::Module.send(:new, "mymod", "/my/mod")
+        mod.files.should == "/my/mod/files"
+    end
+end

data/spec/unit/network/client.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-24.
+#  Copyright (c) 2008. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/client'
+
+describe Puppet::Network::Client do
+    before do
+        Puppet.settings.stubs(:use).returns(true)
+        Puppet::Network::HttpPool.stubs(:cert_setup)
+    end
+
+    describe "when keep-alive is enabled" do
+        before do
+            Puppet::Network::HttpPool.stubs(:keep_alive?).returns true
+        end
+        it "should start the http client up on creation" do
+            http = mock 'http'
+            http.stub_everything
+            http.expects(:start)
+            Net::HTTP.stubs(:new).returns http
+
+            # Pick a random subclass...
+            Puppet::Network::Client.master.new :Server => Puppet[:server]
+        end
+    end
+
+    describe "when keep-alive is disabled" do
+        before do
+            Puppet::Network::HttpPool.stubs(:keep_alive?).returns false
+        end
+        it "should not start the http client up on creation" do
+            http = mock 'http'
+            http.stub_everything
+            http.expects(:start).never
+            Net::HTTP.stubs(:new).returns http
+
+            # Pick a random subclass...
+            Puppet::Network::Client.master.new :Server => Puppet[:server]
+        end
+    end
+end

data/spec/unit/network/client/master.rb

@@ -0,0 +1,442 @@
+#!/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/network/client/master'
+
+describe Puppet::Network::Client::Master, " when retrieving the catalog" do
+    before do
+        Puppet.settings.stubs(:use).returns(true)
+        @master = mock 'master'
+        @client = Puppet::Network::Client.master.new(
+            :Master => @master
+        )
+        @facts = {"one" => "two", "three" => "four"}
+    end
+
+    it "should initialize the metadata store" do
+        @client.class.stubs(:facts).returns(@facts)
+        @client.expects(:dostorage)
+        @master.stubs(:getconfig).returns(nil)
+        @client.getconfig
+    end
+
+    it "should collect facts to use for catalog retrieval" do
+        @client.stubs(:dostorage)
+        @client.class.expects(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns(nil)
+        @client.getconfig
+    end
+
+    it "should fail if no facts could be collected" do
+        @client.stubs(:dostorage)
+        @client.class.expects(:facts).returns({})
+        @master.stubs(:getconfig).returns(nil)
+        proc { @client.getconfig }.should raise_error(Puppet::Network::ClientError)
+    end
+
+    it "should retrieve plugins if :pluginsync is enabled" do
+        file = "/path/to/cachefile"
+        @client.stubs(:cachefile).returns(file)
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        Puppet.settings.expects(:value).with(:pluginsync).returns(true)
+        @client.expects(:getplugins)
+        @client.stubs(:get_actual_config).returns(nil)
+        FileTest.stubs(:exist?).with(file).returns(true)
+        @client.stubs(:use_cached_config).returns(true)
+        @client.class.stubs(:facts).returns(@facts)
+        @client.getconfig
+    end
+
+    it "should use the cached catalog if no catalog could be retrieved" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).raises(ArgumentError.new("whev"))
+        @client.expects(:use_cached_config).with(true)
+        @client.getconfig
+    end
+
+    describe "when the catalog format is set to yaml" do
+        before do
+            Puppet.settings.stubs(:value).returns "foo"
+            Puppet.settings.stubs(:value).with(:pluginsync).returns false
+            Puppet.settings.stubs(:value).with(:configtimeout).returns 10
+            Puppet.settings.stubs(:value).with(:factsync).returns false
+            Puppet.settings.stubs(:value).with(:catalog_format).returns "yaml"
+        end
+
+        it "should request a yaml-encoded catalog" do
+            @client.stubs(:dostorage)
+            @client.class.stubs(:facts).returns(@facts)
+            @master.expects(:getconfig).with { |*args| args[1] == "yaml" }
+
+            @client.getconfig
+        end
+
+        it "should load the retrieved catalog using YAML" do
+            @client.stubs(:dostorage)
+            @client.class.stubs(:facts).returns(@facts)
+            @master.stubs(:getconfig).returns("myconfig")
+
+            config = mock 'config'
+            YAML.expects(:load).with("myconfig").returns(config)
+
+            @client.stubs(:setclasses)
+
+            config.stubs(:classes)
+            config.stubs(:to_catalog).returns(config)
+            config.stubs(:host_config=)
+            config.stubs(:from_cache).returns(true)
+
+            @client.getconfig
+        end
+
+        it "should use the cached catalog if the retrieved catalog cannot be converted from YAML" do
+            @client.stubs(:dostorage)
+            @client.class.stubs(:facts).returns(@facts)
+            @master.stubs(:getconfig).returns("myconfig")
+
+            YAML.expects(:load).with("myconfig").raises(ArgumentError)
+
+            @client.expects(:use_cached_config).with(true)
+
+            @client.getconfig
+        end
+    end
+
+    describe "from Marshal" do
+        before do
+            Puppet.settings.stubs(:value).returns "foo"
+            Puppet.settings.stubs(:value).with(:pluginsync).returns false
+            Puppet.settings.stubs(:value).with(:configtimeout).returns 10
+            Puppet.settings.stubs(:value).with(:factsync).returns false
+            Puppet.settings.stubs(:value).with(:catalog_format).returns "marshal"
+        end
+
+        it "should load the retrieved catalog using Marshal" do
+            @client.stubs(:dostorage)
+            @client.class.stubs(:facts).returns(@facts)
+            @master.stubs(:getconfig).returns("myconfig")
+
+            config = mock 'config'
+            Marshal.expects(:load).with("myconfig").returns(config)
+
+            @client.stubs(:setclasses)
+
+            config.stubs(:classes)
+            config.stubs(:to_catalog).returns(config)
+            config.stubs(:host_config=)
+            config.stubs(:from_cache).returns(true)
+
+            @client.getconfig
+        end
+
+        it "should use the cached catalog if the retrieved catalog cannot be converted from Marshal" do
+            @client.stubs(:dostorage)
+            @client.class.stubs(:facts).returns(@facts)
+            @master.stubs(:getconfig).returns("myconfig")
+
+            Marshal.expects(:load).with("myconfig").raises(ArgumentError)
+
+            @client.expects(:use_cached_config).with(true)
+
+            @client.getconfig
+        end
+    end
+
+    it "should set the classes.txt file with the classes listed in the retrieved catalog" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        config = mock 'config'
+        YAML.expects(:load).with("myconfig").returns(config)
+
+        config.expects(:classes).returns(:myclasses)
+        @client.expects(:setclasses).with(:myclasses)
+
+        config.stubs(:to_catalog).returns(config)
+        config.stubs(:host_config=)
+        config.stubs(:from_cache).returns(true)
+
+        @client.getconfig
+    end
+
+    it "should convert the retrieved catalog to a RAL catalog" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        yamlconfig = mock 'yaml config'
+        YAML.stubs(:load).returns(yamlconfig)
+
+        @client.stubs(:setclasses)
+
+        config = mock 'config'
+
+        yamlconfig.stubs(:classes)
+        yamlconfig.expects(:to_catalog).returns(config)
+
+        config.stubs(:host_config=)
+        config.stubs(:from_cache).returns(true)
+
+        @client.getconfig
+    end
+
+    it "should use the cached catalog if the retrieved catalog cannot be converted to a RAL catalog" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        yamlconfig = mock 'yaml config'
+        YAML.stubs(:load).returns(yamlconfig)
+
+        @client.stubs(:setclasses)
+
+        config = mock 'config'
+
+        yamlconfig.stubs(:classes)
+        yamlconfig.expects(:to_catalog).raises(ArgumentError)
+
+        @client.expects(:use_cached_config).with(true)
+
+        @client.getconfig
+    end
+
+    it "should clear the failed catalog if using the cached catalog after failing to instantiate the retrieved catalog" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        yamlconfig = mock 'yaml config'
+        YAML.stubs(:load).returns(yamlconfig)
+
+        @client.stubs(:setclasses)
+
+        config = mock 'config'
+
+        yamlconfig.stubs(:classes)
+        yamlconfig.stubs(:to_catalog).raises(ArgumentError)
+
+        @client.stubs(:use_cached_config).with(true)
+
+        @client.expects(:clear)
+
+        @client.getconfig
+    end
+
+    it "should cache the retrieved yaml catalog if it is not from the cache and is valid" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        yamlconfig = mock 'yaml config'
+        YAML.stubs(:load).returns(yamlconfig)
+
+        @client.stubs(:setclasses)
+
+        config = mock 'config'
+
+        yamlconfig.stubs(:classes)
+        yamlconfig.expects(:to_catalog).returns(config)
+
+        config.stubs(:host_config=)
+
+        config.expects(:from_cache).returns(false)
+
+        @client.expects(:cache).with("myconfig")
+
+        @client.getconfig
+    end
+
+    it "should mark the catalog as a host catalog" do
+        @client.stubs(:dostorage)
+        @client.class.stubs(:facts).returns(@facts)
+        @master.stubs(:getconfig).returns("myconfig")
+
+        yamlconfig = mock 'yaml config'
+        YAML.stubs(:load).returns(yamlconfig)
+
+        @client.stubs(:setclasses)
+
+        config = mock 'config'
+
+        yamlconfig.stubs(:classes)
+        yamlconfig.expects(:to_catalog).returns(config)
+
+        config.stubs(:from_cache).returns(true)
+
+        config.expects(:host_config=).with(true)
+
+        @client.getconfig
+    end
+end
+
+describe Puppet::Network::Client::Master, " when using the cached catalog" do
+    before do
+        Puppet.settings.stubs(:use).returns(true)
+        @master = mock 'master'
+        @client = Puppet::Network::Client.master.new(
+            :Master => @master
+        )
+        @facts = {"one" => "two", "three" => "four"}
+    end
+
+    it "should return do nothing and true if there is already an in-memory catalog" do
+        @client.catalog = :whatever
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config.should be_true
+        end
+    end
+
+    it "should return do nothing and false if it has been told there is a failure and :nocacheonfailure is enabled" do
+        Puppet.settings.expects(:value).with(:usecacheonfailure).returns(false)
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config(true).should be_false
+        end
+    end
+
+    it "should return false if no cached catalog can be found" do
+        @client.expects(:retrievecache).returns(nil)
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config().should be_false
+        end
+    end
+
+    it "should return false if the cached catalog cannot be instantiated" do
+        YAML.expects(:load).raises(ArgumentError)
+        @client.expects(:retrievecache).returns("whatever")
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config().should be_false
+        end
+    end
+
+    it "should warn if the cached catalog cannot be instantiated" do
+        YAML.stubs(:load).raises(ArgumentError)
+        @client.stubs(:retrievecache).returns("whatever")
+        Puppet.expects(:warning).with { |m| m.include?("Could not load cache") }
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config().should be_false
+        end
+    end
+
+    it "should clear the client if the cached catalog cannot be instantiated" do
+        YAML.stubs(:load).raises(ArgumentError)
+        @client.stubs(:retrievecache).returns("whatever")
+        @client.expects(:clear)
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config().should be_false
+        end
+    end
+
+    it "should return true if the cached catalog can be instantiated" do
+        config = mock 'config'
+        YAML.stubs(:load).returns(config)
+
+        ral_config = mock 'ral config'
+        ral_config.stubs(:from_cache=)
+        ral_config.stubs(:host_config=)
+        config.expects(:to_catalog).returns(ral_config)
+
+        @client.stubs(:retrievecache).returns("whatever")
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config().should be_true
+        end
+    end
+
+    it "should set the catalog instance variable if the cached catalog can be instantiated" do
+        config = mock 'config'
+        YAML.stubs(:load).returns(config)
+
+        ral_config = mock 'ral config'
+        ral_config.stubs(:from_cache=)
+        ral_config.stubs(:host_config=)
+        config.expects(:to_catalog).returns(ral_config)
+
+        @client.stubs(:retrievecache).returns("whatever")
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config()
+        end
+
+        @client.catalog.should equal(ral_config)
+    end
+
+    it "should mark the catalog as a host_config if valid" do
+        config = mock 'config'
+        YAML.stubs(:load).returns(config)
+
+        ral_config = mock 'ral config'
+        ral_config.stubs(:from_cache=)
+        ral_config.expects(:host_config=).with(true)
+        config.expects(:to_catalog).returns(ral_config)
+
+        @client.stubs(:retrievecache).returns("whatever")
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config()
+        end
+
+        @client.catalog.should equal(ral_config)
+    end
+
+    it "should mark the catalog as from the cache if valid" do
+        config = mock 'config'
+        YAML.stubs(:load).returns(config)
+
+        ral_config = mock 'ral config'
+        ral_config.expects(:from_cache=).with(true)
+        ral_config.stubs(:host_config=)
+        config.expects(:to_catalog).returns(ral_config)
+
+        @client.stubs(:retrievecache).returns("whatever")
+        Puppet::Network::Client::Master.publicize_methods :use_cached_config do
+            @client.use_cached_config()
+        end
+
+        @client.catalog.should equal(ral_config)
+    end
+
+    describe "when calling splay" do
+        it "should do nothing if splay is not enabled" do
+            Puppet.stubs(:[]).with(:splay).returns(false)
+            @client.expects(:rand).never
+            @client.send(:splay)
+        end
+
+        describe "when splay is enabled" do
+            before do
+                Puppet.stubs(:[]).with(:splay).returns(true)
+                Puppet.stubs(:[]).with(:splaylimit).returns(42)
+            end
+
+            it "should sleep for a random time plus 1" do
+                @client.expects(:rand).with(43).returns(43)
+                @client.expects(:sleep).with(43)
+                @client.send(:splay)
+            end
+
+            it "should inform that it is splayed" do
+                @client.stubs(:rand).with(43).returns(43)
+                @client.stubs(:sleep).with(43)
+                Puppet.expects(:info)
+                @client.send(:splay)
+            end
+
+            it "should set splay = true" do
+                @client.stubs(:rand).returns(43)
+                @client.stubs(:sleep)
+                @client.send(:splay)
+                @client.send(:splayed?).should == true
+            end
+
+            it "should do nothing if already splayed" do
+                @client.stubs(:rand).returns(43).at_most_once
+                @client.stubs(:sleep).at_most_once
+                @client.send(:splay)
+                @client.send(:splay)
+            end
+        end 
+    end
+end