puppet 0.24.9 → 0.25.0

data/spec/unit/indirector/file_metadata/modules.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-10-18.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/indirector/file_metadata/modules'
-
-describe Puppet::Indirector::FileMetadata::Modules do
-    it "should be registered with the file_metadata indirection" do
-        Puppet::Indirector::Terminus.terminus_class(:file_metadata, :modules).should equal(Puppet::Indirector::FileMetadata::Modules)
-    end
-
-    it "should be a subclass of the ModuleFiles terminus" do
-        Puppet::Indirector::FileMetadata::Modules.superclass.should equal(Puppet::Indirector::ModuleFiles)
-    end
-end
-
-describe Puppet::Indirector::FileMetadata::Modules, " when finding metadata" do
-    before do
-        @finder = Puppet::Indirector::FileMetadata::Modules.new
-        @finder.stubs(:environment).returns(nil)
-        @module = Puppet::Module.new("mymod", "/path/to")
-        @finder.stubs(:find_module).returns(@module)
-
-        @request = Puppet::Indirector::Request.new(:metadata, :find, "puppetmounts://hostname/modules/mymod/my/file")
-    end
-
-    it "should return nil if the file is not found" do
-        FileTest.expects(:exists?).with("/path/to/files/my/file").returns false
-        @finder.find(@request).should be_nil
-    end
-
-    it "should retrieve the instance's attributes if the file is found" do
-        FileTest.expects(:exists?).with("/path/to/files/my/file").returns true
-        instance = mock 'metadta'
-        Puppet::FileServing::Metadata.expects(:new).returns instance
-        instance.expects :collect_attributes
-        @finder.find(@request)
-    end
-end

data/spec/unit/indirector/module_files.rb

@@ -1,259 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-10-19.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/indirector/module_files'
-
-
-describe Puppet::Indirector::ModuleFiles do
-
-    before :each do
-        Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-        @model = mock 'model'
-        @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
-        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
-  
-        @module_files_class = Class.new(Puppet::Indirector::ModuleFiles) do
-            def self.to_s
-                "Testing::Mytype"
-            end
-        end
-  
-        @module_files = @module_files_class.new
-  
-        @uri = "puppetmounts://host/modules/my/local/file"
-        @module = Puppet::Module.new("mymod", "/module/path")
-
-        @request = stub 'request', :key => @uri, :options => {}, :node => nil, :ip => nil, :method => :find
-    end
-
-    describe Puppet::Indirector::ModuleFiles, " when finding files" do
-
-        it "should strip off the leading '/modules' mount name" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            @module_files.find(@request)
-        end
-
-        it "should not strip off leading terms that start with '/modules' but are longer words" do
-            @request.stubs(:key).returns "puppetmounts://host/modulestart/my/local/file"
-            Puppet::Module.expects(:find).with('modulestart', "myenv").returns nil
-            @module_files.find(@request)
-        end
-
-        it "should search for a module whose name is the first term in the remaining file path" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            @module_files.find(@request)
-        end
-
-        it "should search for a file relative to the module's files directory" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file")
-            @module_files.find(@request)
-        end
-
-        it "should return nil if the module does not exist" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns nil
-            @module_files.find(@request).should be_nil
-        end
-
-        it "should return nil if the module exists but the file does not" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(false)
-            @module_files.find(@request).should be_nil
-        end
-
-        it "should return an instance of the model if a module is found and the file exists" do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
-            @model.expects(:new).returns(:myinstance)
-            @module_files.find(@request).should == :myinstance
-        end
-
-        it "should use the node's environment to look up the module if the node name is provided" do
-            node = stub "node", :environment => "testing"
-            Puppet::Node.expects(:find).with("mynode").returns(node)
-            Puppet::Module.expects(:find).with('my', "testing")
-
-            @request.stubs(:node).returns "mynode"
-            @module_files.find(@request)
-        end
-
-        it "should use the default environment setting to look up the module if the node name is not provided" do
-            env = stub "environment", :name => "testing"
-            Puppet::Node::Environment.stubs(:new).returns(env)
-            Puppet::Module.expects(:find).with('my', "testing")
-            @module_files.find(@request)
-        end
-    end
-
-    describe Puppet::Indirector::ModuleFiles, " when returning instances" do
-
-        before do
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
-            @instance = mock 'instance'
-        end
-
-        it "should create the instance with the key used to find the instance" do
-            @model.expects(:new).with { |key, *options| key == @uri }
-            @module_files.find(@request)
-        end
-
-        it "should create the instance with the path at which the instance was found" do
-            @model.expects(:new).with { |key, options| options[:path] == "/module/path/files/local/file" }
-            @module_files.find(@request)
-        end
-
-        it "should set the provided :links setting on to the instance if one is provided" do
-            @model.expects(:new).returns(@instance)
-            @instance.expects(:links=).with(:mytest)
-
-            @request.options[:links] = :mytest
-            @module_files.find(@request)
-        end
-
-        it "should not set a :links value if no :links parameter is provided" do
-            @model.expects(:new).returns(@instance)
-            @module_files.find(@request)
-        end
-    end
-
-    describe Puppet::Indirector::ModuleFiles, " when authorizing" do
-
-        before do
-            @configuration = mock 'configuration'
-            Puppet::FileServing::Configuration.stubs(:create).returns(@configuration)
-        end
-
-        it "should have an authorization hook" do
-            @module_files.should respond_to(:authorized?)
-        end
-
-        it "should deny the :destroy method" do
-            @request.expects(:method).returns :destroy
-            @module_files.authorized?(@request).should be_false
-        end
-
-        it "should deny the :save method" do
-            @request.expects(:method).returns :save
-            @module_files.authorized?(@request).should be_false
-        end
-
-        it "should use the file server configuration to determine authorization" do
-            @configuration.expects(:authorized?)
-            @module_files.authorized?(@request)
-        end
-
-        it "should use the path directly from the URI if it already includes /modules" do
-            @request.expects(:key).returns "puppetmounts://host/modules/my/file"
-            @configuration.expects(:authorized?).with { |uri, *args| uri == "/modules/my/file" }
-            @module_files.authorized?(@request)
-        end
-
-        it "should add /modules to the file path if it's not included in the URI" do
-            @request.expects(:key).returns "puppetmounts://host/my/file"
-            @configuration.expects(:authorized?).with { |uri, *args| uri == "/modules/my/file" }
-            @module_files.authorized?(@request)
-        end
-
-        it "should pass the node name to the file server configuration" do
-            @request.expects(:key).returns "puppetmounts://host/my/file"
-            @configuration.expects(:authorized?).with { |key, options| options[:node] == "mynode" }
-            @request.stubs(:node).returns "mynode"
-            @module_files.authorized?(@request)
-        end
-
-        it "should pass the IP address to the file server configuration" do
-            @request.expects(:ip).returns "myip"
-            @configuration.expects(:authorized?).with { |key, options| options[:ipaddress] == "myip" }
-            @module_files.authorized?(@request)
-        end
-
-        it "should return false if the file server configuration denies authorization" do
-            @configuration.expects(:authorized?).returns(false)
-            @module_files.authorized?(@request).should be_false
-        end
-
-        it "should return true if the file server configuration approves authorization" do
-            @configuration.expects(:authorized?).returns(true)
-            @module_files.authorized?(@request).should be_true
-        end
-    end
-
-    describe Puppet::Indirector::ModuleFiles, " when searching for files" do
-
-        it "should strip off the leading '/modules' mount name" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            @module_files.search(@request)
-        end
-
-        it "should not strip off leading terms that start with '/modules' but are longer words" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('modulestart', "myenv").returns nil
-            @request.stubs(:key).returns "puppetmounts://host/modulestart/my/local/file"
-            @module_files.search @request
-        end
-
-        it "should search for a module whose name is the first term in the remaining file path" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            @module_files.search(@request)
-        end
-
-        it "should search for a file relative to the module's files directory" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file")
-            @module_files.search(@request)
-        end
-
-        it "should return nil if the module does not exist" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns nil
-            @module_files.search(@request).should be_nil
-        end
-
-        it "should return nil if the module exists but the file does not" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(false)
-            @module_files.search(@request).should be_nil
-        end
-
-        it "should use the node's environment to look up the module if the node name is provided" do
-            node = stub "node", :environment => "testing"
-            Puppet::Node.expects(:find).with("mynode").returns(node)
-            Puppet::Module.expects(:find).with('my', "testing")
-            @request.stubs(:node).returns "mynode"
-            @module_files.search(@request)
-        end
-
-        it "should use the default environment setting to look up the module if the node name is not provided and the environment is not set to ''" do
-            env = stub 'env', :name => "testing"
-            Puppet::Node::Environment.stubs(:new).returns(env)
-            Puppet::Module.expects(:find).with('my', "testing")
-            @module_files.search(@request)
-        end
-
-        it "should use :path2instances from the terminus_helper to return instances if a module is found and the file exists" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
-            @module_files.expects(:path2instances).with(@request, "/module/path/files/local/file")
-            @module_files.search(@request)
-        end
-
-        it "should pass the request directly to :path2instances" do
-            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
-            Puppet::Module.expects(:find).with('my', "myenv").returns @module
-            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
-            @module_files.expects(:path2instances).with(@request, "/module/path/files/local/file")
-            @module_files.search(@request)
-        end
-    end
-end

data/spec/unit/indirector/ssl_rsa/file.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-9-22.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/sslcertificates/monkey_patch'
-require 'puppet/indirector/ssl_rsa/file'
-
-
-describe Puppet::Indirector::SslRsa::File do
-
-    it "should be a subclass of the File terminus class" do
-        Puppet::Indirector::SslRsa::File.superclass.should equal(Puppet::Indirector::File)
-    end
-    
-    it "should have documentation" do
-        Puppet::Indirector::SslRsa::File.doc.should be_instance_of(String)
-    end
-end
-
-describe Puppet::Indirector::SslRsa::File, " when choosing a path for a ca key" do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Indirector::SslRsa::File.new
-        @name = :ca
-    end
-
-    it "should use the cadir" do
-        Puppet.settings.stubs(:value).with(:cadir).returns("/dir")
-        @file.path(@name).should =~ /^\/dir/
-    end
-
-    it "should use 'ca_key.pem' as the file name" do
-        @file.path(@name).should =~ /ca_key\.pem$/
-    end
-end
-
-describe Puppet::Indirector::SslRsa::File, " when choosing a path for a non-ca key" do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Indirector::SslRsa::File.new
-        @name = :publickey
-    end
-
-    it "should use the publickeydir" do
-        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
-        @file.path(@name).should =~ /^\/dir/
-    end
-
-    it "should use the key name with the pem file extension" do
-        @file.path(@name).should =~ /#{@name}\.pem$/
-    end
-end
-
-describe Puppet::Indirector::SslRsa::File, " when saving" do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Indirector::SslRsa::File.new
-
-        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
-        @key = stub "key", :name => "foo"
-    end
-
-    it "should store the rsa key to disk in pem format" do
-        @key.expects(:to_pem).returns(:data)
-        @path = "/dir/foo.pem"
-        filehandle = mock "filehandle"
-        File.expects(:open).with(@path, "w").yields(filehandle)
-        filehandle.expects(:print).with(:data)
-        @file.save(@key)
-    end
-end
-
-describe Puppet::Indirector::SslRsa::File, " when finding a key by name" do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Indirector::SslRsa::File.new
-
-        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
-        @name = "foo"
-    end
-
-    it "should return the key as a key object on success" do
-        @path = "/dir/foo.pem"
-        FileTest.stubs(:exists?).with(@path).returns(true)
-        File.stubs(:read).with(@path).returns(:data)
-        OpenSSL::PKey::RSA.expects(:new).with(:data).returns(:mykey)
-        @file.find(@name).should == :mykey
-    end
-
-    it "should return 'nil' on failure" do
-        @path = "/dir/foo.pem"
-        FileTest.stubs(:exists?).with(@path).returns(false)
-        @file.find(@name).should == nil
-    end
-end
-
-describe Puppet::Indirector::SslRsa::File, " when removing a key" do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Indirector::SslRsa::File.new
-
-        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
-        @name = "foo"
-    end
-
-    it "should remove the key from disk and return true" do
-        @path = "/dir/foo.pem"
-        FileTest.stubs(:exists?).with(@path).returns(true)
-        File.stubs(:unlink).with(@path).returns(true)
-        @file.destroy(@name).should == true
-    end
-
-    it "should return an exception on failure" do
-        @path = "/dir/foo.pem"
-        FileTest.stubs(:exists?).with(@path).returns(false)
-        @file.destroy(@name).should == nil
-    end
-end

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

@@ -1,442 +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/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