puppet 2.6.8 → 2.6.9

data/lib/puppet/reference/#providers.rb#

@@ -1,123 +0,0 @@
-# This doesn't get stored in trac, since it changes every time.
-providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
-  types = []
-  newPuppet::Type.loadall
-  Puppet::Type.eachtype do |klass|
-    next unless klass.providers.length > 0
-    types << klass
-  end
-  types.sort! { |a,b| a.name.to_s <=> b.name.to_s }
-
-  command_line = Puppet::Util::CommandLine.new
-  types.reject! { |type| ! command_line.args.include?(type.name.to_s) } unless command_line.args.empty?
-
-  ret = "Details about this host:\n\n"
-
-  # Throw some facts in there, so we know where the report is from.
-  ["Ruby Version", "Puppet Version", "Operating System", "Operating System Release"].each do |label|
-    name = label.gsub(/\s+/, '')
-    value = Facter.value(name)
-    ret += option(label, value)
-  end
-  ret += "\n"
-
-  count = 1
-
-  # Produce output for each type.
-  types.each do |type|
-    features = type.features
-    ret += "\n" # add a trailing newline
-
-    # Now build up a table of provider suitability.
-    headers = %w{Provider Suitable?} + features.collect { |f| f.to_s }.sort
-
-    table_data = {}
-
-    functional = false
-    notes = []
-    begin
-      default = type.defaultprovider.name
-    rescue Puppet::DevError
-      default = "none"
-    end
-    type.providers.sort { |a,b| a.to_s <=> b.to_s }.each do |pname|
-      data = []
-      table_data[pname] = data
-      provider = type.provider(pname)
-
-      # Add the suitability note
-      if missing = provider.suitable?(false) and missing.empty?
-        data << "*X*"
-        suit = true
-        functional = true
-      else
-        data << "[#{count}]_" # A pointer to the appropriate footnote
-        suit = false
-      end
-
-      # Add a footnote with the details about why this provider is unsuitable, if that's the case
-      unless suit
-        details = ".. [#{count}]\n"
-        missing.each do |test, values|
-          case test
-          when :exists
-            details += "  - Missing files #{values.join(", ")}\n"
-          when :variable
-            values.each do |name, facts|
-              if Puppet.settings.valid?(name)
-                details += "  - Setting #{name} (currently #{Puppet.settings.value(name).inspect}) not in list #{facts.join(", ")}\n"
-              else
-                details += "  - Fact #{name} (currently #{Facter.value(name).inspect}) not in list #{facts.join(", ")}\n"
-              end
-            end
-          when :true
-            details += "  - Got #{values} true tests that should have been false\n"
-          when :false
-            details += "  - Got #{values} false tests that should have been true\n"
-          when :feature
-            details += "  - Missing features #{values.collect { |f| f.to_s }.join(",")}\n"
-          end
-        end
-        notes << details
-
-        count += 1
-      end
-
-      # Add a note for every feature
-      features.each do |feature|
-        if provider.features.include?(feature)
-          data << "*X*"
-        else
-          data << ""
-        end
-      end
-    end
-
-    ret += h(type.name.to_s + "_", 2)
-
-    ret += "[#{type.name}](#{"http://docs.puppetlabs.com/references/stable/type.html##{type.name}"})\n\n"
-    ret += option("Default provider", default)
-    ret += doctable(headers, table_data)
-
-    notes.each do |note|
-      ret += note + "\n"
-    end
-
-    ret += "\n"
-  end
-
-  ret += "\n"
-
-  ret
-end
-providers.header = "
-Puppet resource types are usually backed by multiple implementations called `providers`,
-which handle variance between platforms and tools.
-
-Different providers are suitable or unsuitable on different platforms based on things
-like the presence of a given tool.
-
-Here are all of the provider-backed types and their different providers.  Any unmentioned
-types do not use providers yet.
-
-"

data/spec/unit/indirector/certificate_status/#file_spec.rb#

@@ -1,188 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
-require 'puppet/ssl/host'
-require 'puppet/indirector/certificate_status'
-require 'tempfile'
-
-describe "Puppet::Indirector::CertificateStatus::File" do
-  include PuppetSpec::Files
-
-  before do
-    Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
-    @terminus = Puppet::SSL::Host.indirection.terminus(:file)
-
-    @tmpdir = tmpdir("certificate_status_ca_testing")
-    Puppet[:confdir] = @tmpdir
-    Puppet[:vardir] = @tmpdir
-
-    # localcacert is where each client stores the CA certificate
-    # cacert is where the master stores the CA certificate
-    # Since we need to play the role of both for testing we need them to be the same and exist
-    Puppet[:cacert] = Puppet[:localcacert]
-  end
-
-  def generate_csr(host)
-    host.generate_key
-    csr = Puppet::SSL::CertificateRequest.new(host.name)
-    csr.generate(host.key.content)
-    Puppet::SSL::CertificateRequest.indirection.save(csr)
-  end
-
-  def sign_csr(host)
-    host.desired_state = "signed"
-    @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
-  end
-
-  def generate_signed_cert(host)
-    generate_csr(host)
-    sign_csr(host)
-
-    @terminus.find(Puppet::Indirector::Request.new(:certificate_status, :find, host.name, host))
-  end
-
-  def generate_revoked_cert(host)
-    generate_signed_cert(host)
-
-    host.desired_state = "revoked"
-
-    @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
-  end
-
-  it "should be a terminus on SSL::Host" do
-    @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::File)
-  end
-
-  it "should create a CA instance if none is present" do
-    @terminus.ca.should be_instance_of(Puppet::SSL::CertificateAuthority)
-  end
-
-  describe "when creating the CA" do
-    it "should fail if it is not a valid CA" do
-      Puppet::SSL::CertificateAuthority.expects(:ca?).returns false
-      lambda { @terminus.ca }.should raise_error(ArgumentError, "This process is not configured as a certificate authority")
-    end
-  end
-
-  it "should be indirected with the name 'certificate_status'" do
-    Puppet::SSL::Host.indirection.name.should == :certificate_status
-  end
-
-  describe "when finding" do
-    before do
-      @host = Puppet::SSL::Host.new("foo")
-      Puppet.settings.use(:main)
-    end
-
-    it "should return the Puppet::SSL::Host when a CSR exists for the host" do
-      generate_csr(@host)
-      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
-
-      retrieved_host = @terminus.find(request)
-
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
-    end
-
-    it "should return the Puppet::SSL::Host when a public key exist for the host" do
-      generate_signed_cert(@host)
-      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
-
-      retrieved_host = @terminus.find(request)
-
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
-    end
-
-    it "should return nil when neither a CSR nor public key exist for the host" do
-      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
-      @terminus.find(request).should == nil
-    end
-  end
-
-  describe "when saving" do
-    before do
-      @host = Puppet::SSL::Host.new("foobar")
-      Puppet.settings.use(:main)
-    end
-
-    describe "when signing a cert" do
-      before do
-        @host.desired_state = "signed"
-        @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
-      end
-
-      it "should fail if no CSR is on disk" do
-        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /certificate request/)
-      end
-
-      it "should sign the on-disk CSR when it is present" do
-        signed_host = generate_signed_cert(@host)
-
-        signed_host.state.should == "signed"
-        Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
-      end
-    end
-
-    describe "when revoking a cert" do
-      before do
-        @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
-      end
-
-      it "should fail if no certificate is on disk" do
-        @host.desired_state = "revoked"
-        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /Cannot revoke/)
-      end
-
-      it "should revoke the certificate when it is present" do
-        generate_revoked_cert(@host)
-
-        @host.state.should == 'revoked'
-      end
-    end
-  end
-
-  describe "when deleting" do
-    before do
-      Puppet.settings.use(:main)
-    end
-
-    it "should not delete anything if no certificate, request, or key is on disk" do
-      host = Puppet::SSL::Host.new("clean_me")
-      request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_me", host)
-      @terminus.destroy(request).should == "Nothing was deleted"
-    end
-
-    it "should clean certs, cert requests, keys" do
-      signed_host = Puppet::SSL::Host.new("clean_signed_cert")
-      generate_signed_cert(signed_host)
-      signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
-      @terminus.destroy(signed_request).should == "Deleted for host clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
-
-      requested_host = Puppet::SSL::Host.new("clean_csr")
-      generate_csr(requested_host)
-      csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
-      @terminus.destroy(csr_request).should == "Deleted for 'host clean_signed_cert': Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
-    end
-  end
-
-  describe "when searching" do
-    it "should return a list of all hosts with certificate requests, signed certs, or revoked certs" do
-      Puppet.settings.use(:main)
-
-      signed_host = Puppet::SSL::Host.new("signed_host")
-      generate_signed_cert(signed_host)
-
-      requested_host = Puppet::SSL::Host.new("requested_host")
-      generate_csr(requested_host)
-
-      revoked_host = Puppet::SSL::Host.new("revoked_host")
-      generate_revoked_cert(revoked_host)
-
-      retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
-
-      results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
-      results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
-    end
-  end
-end

data/spec/unit/resource/#type_collection_spec.rb#

@@ -1,463 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/resource/type_collection'
-require 'puppet/resource/type'
-
-describe Puppet::Resource::TypeCollection do
-  include PuppetSpec::Files
-  before do
-    @instance = Puppet::Resource::Type.new(:hostclass, "foo")
-    @code = Puppet::Resource::TypeCollection.new("env")
-  end
-
-  it "should require an environment at initialization" do
-    env = Puppet::Node::Environment.new("testing")
-    Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
-  end
-
-  it "should convert the environment into an environment instance if a string is provided" do
-    env = Puppet::Node::Environment.new("testing")
-    Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
-  end
-
-  it "should create a 'loader' at initialization" do
-    Puppet::Resource::TypeCollection.new("testing").loader.should be_instance_of(Puppet::Parser::TypeLoader)
-  end
-
-  it "should be able to add a resource type" do
-    Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
-  end
-
-  it "should consider '<<' to be an alias to 'add' but should return self" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:add).with "foo"
-    loader.expects(:add).with "bar"
-    loader << "foo" << "bar"
-  end
-
-  it "should set itself as the code collection for added resource types" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-
-    node = Puppet::Resource::Type.new(:node, "foo")
-
-    @code.add(node)
-    @code.node("foo").should equal(node)
-
-    node.resource_type_collection.should equal(@code)
-  end
-
-  it "should store node resource types as nodes" do
-    node = Puppet::Resource::Type.new(:node, "foo")
-
-    @code.add(node)
-    @code.node("foo").should equal(node)
-  end
-
-  it "should store hostclasses as hostclasses" do
-    klass = Puppet::Resource::Type.new(:hostclass, "foo")
-
-    @code.add(klass)
-    @code.hostclass("foo").should equal(klass)
-  end
-
-  it "should store definitions as definitions" do
-    define = Puppet::Resource::Type.new(:definition, "foo")
-
-    @code.add(define)
-    @code.definition("foo").should equal(define)
-  end
-
-  it "should merge new classes with existing classes of the same name" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    first = Puppet::Resource::Type.new(:hostclass, "foo")
-    second = Puppet::Resource::Type.new(:hostclass, "foo")
-    loader.add first
-    first.expects(:merge).with(second)
-    loader.add(second)
-  end
-
-  it "should remove all nodes, classes, and definitions when cleared" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.add Puppet::Resource::Type.new(:hostclass, "class")
-    loader.add Puppet::Resource::Type.new(:definition, "define")
-    loader.add Puppet::Resource::Type.new(:node, "node")
-
-    loader.clear
-    loader.hostclass("class").should be_nil
-    loader.definition("define").should be_nil
-    loader.node("node").should be_nil
-  end
-
-  describe "when looking up names" do
-    before do
-      @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
-    end
-
-    it "should support looking up with multiple namespaces" do
-      @code.add @type
-      @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
-    end
-
-    it "should not attempt to import anything when the type is already defined" do
-      @code.add @type
-      @code.loader.expects(:import).never
-      @code.find_hostclass(%w{ns}, "klass").should equal(@type)
-    end
-
-    describe "that need to be loaded" do
-      it "should use the loader to load the files" do
-        @code.loader.expects(:load_until).with(["ns"], "klass")
-        @code.find_or_load(["ns"], "klass", :hostclass)
-      end
-
-      it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
-        @code.loader.expects(:load_until).with(["ns"], "klass")
-        @code.find_or_load("Ns", "Klass", :hostclass)
-      end
-
-      it "should attempt to find the type when the loader yields" do
-        @code.loader.expects(:load_until).yields
-        @code.expects(:find).with(["ns"], "klass", :hostclass).times(2).returns(false).then.returns(true)
-        @code.find_or_load("ns", "klass", :hostclass)
-      end
-
-      it "should return the result of 'load_until'" do
-        @code.loader.expects(:load_until).returns "foo"
-        @code.find_or_load("Ns", "Klass", :hostclass).should == "foo"
-      end
-
-      it "should return nil if the name isn't found" do
-        @code.stubs(:load_until).returns(nil)
-        @code.find_or_load("Ns", "Klass", :hostclass).should be_nil
-      end
-    end
-  end
-
-  %w{hostclass node definition}.each do |data|
-    before do
-      @instance = Puppet::Resource::Type.new(data, "foo")
-    end
-
-    it "should have a method for adding a #{data}" do
-      Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
-    end
-
-    it "should use the name of the instance to add it" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      loader.send("add_#{data}", @instance)
-      loader.send(data, @instance.name).should equal(@instance)
-    end
-
-    unless data == "hostclass"
-      it "should fail to add a #{data} when one already exists" do
-        loader = Puppet::Resource::TypeCollection.new("env")
-        loader.add @instance
-        lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
-      end
-    end
-
-    it "should return the added #{data}" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-
-      loader.add(@instance).should equal(@instance)
-    end
-
-    it "should be able to retrieve #{data} by name" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "bar")
-      loader.add instance
-      loader.send(data, "bar").should equal(instance)
-    end
-
-    it "should retrieve #{data} insensitive to case" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "Bar")
-      loader.add instance
-      loader.send(data, "bAr").should equal(instance)
-    end
-
-    it "should return nil when asked for a #{data} that has not been added" do
-      Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
-    end
-
-    it "should be able to retrieve all #{data}s" do
-      plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "foo")
-      loader.add instance
-      loader.send(plurals[data]).should == { "foo" => instance }
-    end
-  end
-
-  describe "when finding a qualified instance" do
-    it "should return any found instance if the instance name is fully qualified" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      loader.find("namespace", "::foo::bar", :hostclass).should equal(instance)
-    end
-
-    it "should return nil if the instance name is fully qualified and no such instance exists" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      loader.find("namespace", "::foo::bar", :hostclass).should be_nil
-    end
-
-    it "should be able to find classes in the base namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo")
-      loader.add instance
-      loader.find("", "foo", :hostclass).should equal(instance)
-    end
-
-    it "should return the partially qualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find("foo", "bar::baz", :hostclass).should equal(instance)
-    end
-
-    it "should be able to find partially qualified objects in any of the provided namespaces" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find(["nons", "foo", "otherns"], "bar::baz", :hostclass).should equal(instance)
-    end
-
-    it "should return the unqualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      loader.find("foo", "bar", :hostclass).should equal(instance)
-    end
-
-    it "should return the unqualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      loader.find("foo::bar::baz", "bar", :hostclass).should equal(instance)
-    end
-
-    it "should should return the partially qualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find("foo::bar", "bar::baz", :hostclass).should equal(instance)
-    end
-
-    it "should return the qualified object if it exists in the root namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find("foo::bar", "foo::bar::baz", :hostclass).should equal(instance)
-    end
-
-    it "should return nil if the object cannot be found" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find("foo::bar", "eh", :hostclass).should be_nil
-    end
-
-    describe "when topscope has a class that has the same name as a local class" do
-      before do
-        @loader = Puppet::Resource::TypeCollection.new("env")
-        [ "foo::bar", "bar" ].each do |name|
-          @loader.add Puppet::Resource::Type.new(:hostclass, name)
-        end
-      end
-
-      it "should favor the local class, if the name is unqualified" do
-        @loader.find("foo", "bar",   :hostclass).name.should == 'foo::bar'
-      end
-
-      it "should only look in the topclass, if the name is qualified" do
-        @loader.find("foo", "::bar", :hostclass).name.should == 'bar'
-      end
-
-    end
-
-    it "should not look in the local scope for classes when the name is qualified" do
-        @loader = Puppet::Resource::TypeCollection.new("env")
-        @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
-
-        @loader.find("foo", "::bar", :hostclass).should == nil
-    end
-
-  end
-
-  it "should use the generic 'find' method with an empty namespace to find nodes" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find).with("", "bar", :node)
-    loader.find_node(stub("ignored"), "bar")
-  end
-
-  it "should use the 'find_or_load' method to find hostclasses" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :hostclass)
-    loader.find_hostclass("foo", "bar")
-  end
-
-  it "should use the 'find_or_load' method to find definitions" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :definition)
-    loader.find_definition("foo", "bar")
-  end
-
-  it "should indicate whether any nodes are defined" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
-    loader.should be_nodes
-  end
-
-  it "should indicate whether no nodes are defined" do
-    Puppet::Resource::TypeCollection.new("env").should_not be_nodes
-  end
-
-  describe "when finding nodes" do
-    before :each do
-      @loader = Puppet::Resource::TypeCollection.new("env")
-    end
-
-    it "should return any node whose name exactly matches the provided node name" do
-      node = Puppet::Resource::Type.new(:node, "foo")
-      @loader << node
-
-      @loader.node("foo").should equal(node)
-    end
-
-    it "should return the first regex node whose regex matches the provided node name" do
-      node1 = Puppet::Resource::Type.new(:node, /\w/)
-      node2 = Puppet::Resource::Type.new(:node, /\d/)
-      @loader << node1 << node2
-
-      @loader.node("foo10").should equal(node1)
-    end
-
-    it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
-      node1 = Puppet::Resource::Type.new(:node, /\w/)
-      node2 = Puppet::Resource::Type.new(:node, "foo")
-      @loader << node1 << node2
-
-      @loader.node("foo").should equal(node2)
-    end
-  end
-
-  describe "when managing files" do
-    before do
-      @loader = Puppet::Resource::TypeCollection.new("env")
-      Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
-    end
-
-    it "should have a method for specifying a file should be watched" do
-      @loader.should respond_to(:watch_file)
-    end
-
-    it "should have a method for determining if a file is being watched" do
-      @loader.watch_file("/foo/bar")
-      @loader.should be_watching_file("/foo/bar")
-    end
-
-    it "should use LoadedFile to watch files" do
-      Puppet::Util::LoadedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
-      @loader.watch_file("/foo/bar")
-    end
-
-    it "should be considered stale if any files have changed" do
-      file1 = stub 'file1', :changed? => false
-      file2 = stub 'file2', :changed? => true
-      Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
-      @loader.watch_file("/foo/bar")
-      @loader.watch_file("/other/bar")
-
-      @loader.should be_stale
-    end
-
-    it "should not be considered stable if no files have changed" do
-      file1 = stub 'file1', :changed? => false
-      file2 = stub 'file2', :changed? => false
-      Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
-      @loader.watch_file("/foo/bar")
-      @loader.watch_file("/other/bar")
-
-      @loader.should_not be_stale
-    end
-  end
-
-  describe "when performing initial import" do
-    before do
-      @parser = Puppet::Parser::Parser.new("test")
-      Puppet::Parser::Parser.stubs(:new).returns @parser
-      @code = Puppet::Resource::TypeCollection.new("env")
-    end
-
-    it "should set the parser's string to the 'code' setting and parse if code is available" do
-      Puppet.settings[:code] = "my code"
-      @parser.expects(:string=).with "my code"
-      @parser.expects(:parse)
-      @code.perform_initial_import
-    end
-
-    it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
-      filename = tmpfile('myfile')
-      File.open(filename, 'w'){|f| }
-      Puppet.settings[:manifest] = filename
-      @parser.expects(:file=).with filename
-      @parser.expects(:parse)
-      @code.perform_initial_import
-    end
-
-    it "should pass the manifest file to the parser even if it does not exist on disk" do
-      filename = tmpfile('myfile')
-      Puppet.settings[:code] = ""
-      Puppet.settings[:manifest] = filename
-      @parser.expects(:file=).with(filename).once
-      @parser.expects(:parse).once
-      @code.perform_initial_import
-    end
-
-    it "should fail helpfully if there is an error importing" do
-      File.stubs(:exist?).returns true
-      @parser.expects(:parse).raises ArgumentError
-      @parser.stubs(:file=)
-      lambda { @code.perform_initial_import }.should raise_error(Puppet::Error)
-    end
-
-    it "should mark the type collection as needing a reparse when there is an error parsing" do
-      @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
-
-      lambda { @code.perform_initial_import }.should raise_error(Puppet::Error, /Syntax error at .../)
-      @code.require_reparse?.should be_true
-    end
-  end
-
-  describe "when determining the configuration version" do
-    before do
-      @code = Puppet::Resource::TypeCollection.new("env")
-    end
-
-    it "should default to the current time" do
-      time = Time.now
-
-      Time.stubs(:now).returns time
-      @code.version.should == time.to_i
-    end
-
-    it "should use the output of the environment's config_version setting if one is provided" do
-      @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
-
-      Puppet::Util.expects(:execute).with(["/my/foo"]).returns "output\n"
-      @code.version.should == "output"
-    end
-
-    it "should raise a puppet parser error if executing config_version fails" do
-      @code.environment.stubs(:[]).with(:config_version).returns("test")
-      Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
-
-      lambda { @code.version }.should raise_error(Puppet::ParseError)
-    end
-
-  end
-
-end