diff --git a/lib/puppet/module.rb b/lib/puppet/module.rb
index 8da19c2ce..43266b2b5 100644
--- a/lib/puppet/module.rb
+++ b/lib/puppet/module.rb
@@ -1,204 +1,204 @@
 require 'puppet/util/logging'
 
 # Support for modules
 class Puppet::Module
   class Error < Puppet::Error; end
   class MissingModule < Error; end
   class IncompatibleModule < Error; end
   class UnsupportedPlatform < Error; end
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
 
   include Puppet::Util::Logging
 
   TEMPLATES = "templates"
   FILES = "files"
   MANIFESTS = "manifests"
   PLUGINS = "plugins"
 
   FILETYPES = [MANIFESTS, FILES, TEMPLATES, PLUGINS]
 
   # Return an array of paths by splitting the +modulepath+ config
   # parameter. Only consider paths that are absolute and existing
   # directories
   def self.modulepath(environment = nil)
     Puppet::Node::Environment.new(environment).modulepath
   end
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
   # absolute, or if there is no module whose name is the first component
   # of +path+, return +nil+
   def self.find(modname, environment = nil)
     return nil unless modname
     Puppet::Node::Environment.new(environment).module(modname)
   end
 
   attr_reader :name, :environment
   attr_writer :environment
 
   attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
 
   def has_metadata?
     return false unless metadata_file
 
     FileTest.exist?(metadata_file)
   end
 
   def initialize(name, environment = nil)
     @name = name
 
     assert_validity
 
     if environment.is_a?(Puppet::Node::Environment)
       @environment = environment
     else
       @environment = Puppet::Node::Environment.new(environment)
     end
 
     load_metadata if has_metadata?
 
     validate_puppet_version
     validate_dependencies
   end
 
   FILETYPES.each do |type|
     # A boolean method to let external callers determine if
     # we have files of a given type.
     define_method(type +'?') do
       return false unless path
       return false unless FileTest.exist?(subpath(type))
       return true
     end
 
     # A method for returning a given file of a given type.
     # e.g., file = mod.manifest("my/manifest.pp")
     #
     # If the file name is nil, then the base directory for the
     # file type is passed; this is used for fileserving.
     define_method(type.to_s.sub(/s$/, '')) do |file|
       return nil unless path
 
       # If 'file' is nil then they're asking for the base path.
       # This is used for things like fileserving.
       if file
         full_path = File.join(subpath(type), file)
       else
         full_path = subpath(type)
       end
 
       return nil unless FileTest.exist?(full_path)
       return full_path
     end
   end
 
   def exist?
     ! path.nil?
   end
 
   # Find the first 'files' directory.  This is used by the XMLRPC fileserver.
   def file_directory
     subpath("files")
   end
 
   def license_file
     return @license_file if defined?(@license_file)
 
     return @license_file = nil unless path
     @license_file = File.join(path, "License")
   end
 
   def load_metadata
     data = PSON.parse File.read(metadata_file)
     [:source, :author, :version, :license, :puppetversion].each do |attr|
       unless value = data[attr.to_s]
         unless attr == :puppetversion
           raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
         end
       end
       send(attr.to_s + "=", value)
     end
   end
 
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.{pp,rb}' for empty modules.
   def match_manifests(rest)
     pat = File.join(path, MANIFESTS, rest || 'init')
     [manifest("init.pp"),manifest("init.rb")].compact + Dir.
       glob(pat + (File.extname(pat).empty? ? '.{pp,rb}' : '')).
       reject { |f| FileTest.directory?(f) }
   end
 
   def metadata_file
     return @metadata_file if defined?(@metadata_file)
 
     return @metadata_file = nil unless path
     @metadata_file = File.join(path, "metadata.json")
   end
 
   # Find this module in the modulepath.
   def path
     environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.exist?(d) }
   end
 
   # Find all plugin directories.  This is used by the Plugins fileserving mount.
   def plugin_directory
     subpath("plugins")
   end
 
   def requires(name, version = nil)
     @requires ||= []
     @requires << [name, version]
   end
 
   def supports(name, version = nil)
     @supports ||= []
     @supports << [name, version]
   end
 
   def to_s
     result = "Module #{name}"
     result += "(#{path})" if path
     result
   end
 
   def validate_dependencies
     return unless defined?(@requires)
 
     @requires.each do |name, version|
       unless mod = environment.module(name)
         raise MissingModule, "Missing module #{name} required by #{self.name}"
       end
 
       if version and mod.version != version
         raise IncompatibleModule, "Required module #{name} is version #{mod.version} but #{self.name} requires #{version}"
       end
     end
   end
 
   def validate_puppet_version
     return unless puppetversion and puppetversion != Puppet.version
     raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
   end
 
   private
 
   def subpath(type)
     return File.join(path, type) unless type.to_s == "plugins"
 
     backward_compatible_plugins_dir
   end
 
   def backward_compatible_plugins_dir
     if dir = File.join(path, "plugins") and FileTest.exist?(dir)
-      warning "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
+      Puppet.warning "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
       return dir
     else
       return File.join(path, "lib")
     end
   end
 
   def assert_validity
     raise InvalidName, "Invalid module name; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
   end
 end
diff --git a/spec/unit/indirector/queue_spec.rb b/spec/unit/indirector/queue_spec.rb
index 00463ee0f..bbe00c75f 100755
--- a/spec/unit/indirector/queue_spec.rb
+++ b/spec/unit/indirector/queue_spec.rb
@@ -1,121 +1,124 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/queue'
 
 class Puppet::Indirector::Queue::TestClient
 end
 
 class FooExampleData
   attr_accessor :name
 
   def self.pson_create(pson)
     new(pson['data'].to_sym)
   end
 
   def initialize(name = nil)
     @name = name if name
   end
 
   def render(format = :pson)
     to_pson
   end
 
   def to_pson(*args)
     {:type => self.class.to_s, :data => name}.to_pson(*args)
   end
 end
 
 describe Puppet::Indirector::Queue, :if => Puppet.features.pson? do
   before :each do
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
     @store_class = Class.new(Puppet::Indirector::Queue) do
       def self.to_s
         'MyQueue::MyType'
       end
     end
     @store = @store_class.new
 
     @subject_class = FooExampleData
     @subject = @subject_class.new
     @subject.name = :me
 
     Puppet.settings.stubs(:value).returns("bogus setting data")
     Puppet.settings.stubs(:value).with(:queue_type).returns(:test_client)
     Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
 
     @request = stub 'request', :key => :me, :instance => @subject
   end
 
   it "should require PSON" do
     Puppet.features.expects(:pson?).returns false
 
     lambda { @store_class.new }.should raise_error(ArgumentError)
   end
 
   it 'should use the correct client type and queue' do
     @store.queue.should == :my_queue
     @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
   end
 
   describe "when saving" do
     it 'should render the instance using pson' do
       @subject.expects(:render).with(:pson)
       @store.client.stubs(:send_message)
       @store.save(@request)
     end
 
     it "should send the rendered message to the appropriate queue on the client" do
       @subject.expects(:render).returns "mypson"
 
       @store.client.expects(:send_message).with(:my_queue, "mypson")
 
       @store.save(@request)
     end
 
     it "should catch any exceptions raised" do
       @store.client.expects(:send_message).raises ArgumentError
 
       lambda { @store.save(@request) }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when subscribing to the queue" do
     before do
       @store_class.stubs(:model).returns @model
     end
 
     it "should use the model's Format support to intern the message from pson" do
       @model.expects(:convert_from).with(:pson, "mymessage")
 
       @store_class.client.expects(:subscribe).yields("mymessage")
       @store_class.subscribe {|o| o }
     end
 
     it "should yield each interned received message" do
       @model.stubs(:convert_from).returns "something"
 
       @subject_two = @subject_class.new
       @subject_two.name = :too
 
       @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
 
       received = []
       @store_class.subscribe do |obj|
         received.push(obj)
       end
 
       received.should == %w{something something}
     end
 
     it "should log but not propagate errors" do
       @store_class.client.expects(:subscribe).yields("foo")
       @store_class.expects(:intern).raises ArgumentError
       Puppet.expects(:err)
+
+      @store_class.expects(:puts)
+
       @store_class.subscribe {|o| o }
     end
   end
 end
 
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index 37dad7e25..0b4873f5f 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -1,545 +1,545 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Puppet::Module do
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
     FileTest.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns "yep"
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should == "yep"
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns nil
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should be_nil
   end
 
   it "should support a 'version' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.version = 1.09
     mod.version.should == 1.09
   end
 
   it "should support a 'source' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.source = "http://foo/bar"
     mod.source.should == "http://foo/bar"
   end
 
   it "should support a 'project_page' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.project_page = "http://foo/bar"
     mod.project_page.should == "http://foo/bar"
   end
 
   it "should support an 'author' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.author = "Luke Kanies <luke@madstop.com>"
     mod.author.should == "Luke Kanies <luke@madstop.com>"
   end
 
   it "should support a 'license' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.license = "GPL2"
     mod.license.should == "GPL2"
   end
 
   it "should support a 'summary' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.summary = "GPL2"
     mod.summary.should == "GPL2"
   end
 
   it "should support a 'description' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.description = "GPL2"
     mod.description.should == "GPL2"
   end
 
   it "should support specifying a compatible puppet version" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     mod.puppetversion.should == "0.25"
   end
 
   it "should validate that the puppet version is compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.expects(:version).returns "0.25"
     mod.validate_puppet_version
   end
 
   it "should fail if the specified puppet version is not compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.stubs(:version).returns "0.24"
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when specifying required modules" do
     it "should support specifying a required module" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
     end
 
     it "should support specifying multiple required modules" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
     end
 
     it "should support specifying a required module and version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
     end
 
     it "should fail when required modules are missing" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
 
       mod.environment.expects(:module).with("foobar").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should fail when required modules are present but of the wrong version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 2.0
 
       mod.environment.expects(:module).with("foobar").returns foobar
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::IncompatibleModule)
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
       mod = Puppet::Module.new("mymod")
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should fail when some dependencies are present but others aren't" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
 
       mod.environment.expects(:module).with("foobar").returns Puppet::Module.new("foobar")
       mod.environment.expects(:module).with("baz").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should have valid dependencies when all dependencies are met" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
       mod.requires "baz"
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 1.0
 
       baz = Puppet::Module.new("baz")
 
       mod.environment.expects(:module).with("foobar").returns foobar
       mod.environment.expects(:module).with("baz").returns baz
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should validate its dependendencies on initialization" do
       Puppet::Module.any_instance.expects(:validate_dependencies)
       Puppet::Module.new("mymod")
     end
   end
 
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris"
     end
 
     it "should support specifying a supported platform and version" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris", 1.0
     end
 
     it "should fail when not running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
 
       mod.supports "hpux"
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::UnsupportedPlatform)
     end
 
     it "should fail when supported platforms are present but of the wrong version" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when no supported platforms have been specified" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       lambda { mod.validate_supported_platform }.should_not raise_error
     end
 
     it "should be considered supported when running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when running on any of multiple supported platforms" do
       pending "Not sure how to send client platform to the module"
     end
 
     it "should validate its platform support on initialization" do
       pending "Not sure how to send client platform to the module"
     end
   end
 
   it "should return nil if asked for a module whose name is 'nil'" do
     Puppet::Module.find(nil, "myenv").should be_nil
   end
 
   it "should provide support for logging" do
     Puppet::Module.ancestors.should be_include(Puppet::Util::Logging)
   end
 
   it "should be able to be converted to a string" do
     Puppet::Module.new("foo").to_s.should == "Module foo"
   end
 
   it "should add the path to its string form if the module is found" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a"
     mod.to_s.should == "Module foo(/a)"
   end
 
   it "should fail if its name is not alphanumeric" do
     lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
     lambda { Puppet::Module.new }.should raise_error(ArgumentError)
   end
 
   it "should convert an environment name into an Environment instance" do
     Puppet::Module.new("foo", "prod").environment.should be_instance_of(Puppet::Node::Environment)
   end
 
   it "should accept an environment at initialization" do
     Puppet::Module.new("foo", :prod).environment.name.should == :prod
   end
 
   it "should use the default environment if none is provided" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo").environment.should equal(env)
   end
 
   it "should use any provided Environment instance" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo", env).environment.should equal(env)
   end
 
   it "should return the path to the first found instance in its environment's module paths as its path" do
     mod = Puppet::Module.new("foo")
     env = mock 'environment'
     mod.stubs(:environment).returns env
 
     env.expects(:modulepath).returns %w{/a /b /c}
 
     FileTest.expects(:exist?).with("/a/foo").returns false
     FileTest.expects(:exist?).with("/b/foo").returns true
     FileTest.expects(:exist?).with("/c/foo").never
 
     mod.path.should == "/b/foo"
   end
 
   it "should be considered existent if it exists in at least one module path" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns "/a/foo"
     mod.should be_exist
   end
 
   it "should be considered nonexistent if it does not exist in any of the module paths" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns nil
     mod.should_not be_exist
   end
 
   [:plugins, :templates, :files, :manifests].each do |filetype|
     dirname = filetype == :plugins ? "lib" : filetype.to_s
     it "should be able to return individual #{filetype}" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == path
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should consider #{filetype} to be absent if the module base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return nil when asked for individual #{filetype} if the module does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       base = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
 
   %w{plugins files}.each do |filetype|
     short = filetype.sub(/s$/, '')
     dirname = filetype == "plugins" ? "lib" : filetype.to_s
     it "should be able to return the #{short} directory" do
       Puppet::Module.new("foo").should respond_to(short + "_directory")
     end
 
     it "should return the path to the #{short} directory" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
 
       mod.send(short + "_directory").should == "/a/foo/#{dirname}"
     end
   end
 
   it "should throw a warning if plugins are in a 'plugins' directory rather than a 'lib' directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     FileTest.expects(:exist?).with("/a/foo/plugins").returns true
 
-    mod.expects(:warning)
-
     mod.plugin_directory.should == "/a/foo/plugins"
+    @logs.first.message.should == "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
+    @logs.first.level.should == :warning
   end
 
   it "should default to 'lib' for the plugins directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     mod.plugin_directory.should == "/a/foo/lib"
   end
 end
 
 describe Puppet::Module, " when building its search path" do
   it "should use the current environment's search path if no environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with(nil).returns env
 
     Puppet::Module.modulepath.should == "eh"
   end
 
   it "should use the specified environment's search path if an environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with("foo").returns env
 
     Puppet::Module.modulepath("foo").should == "eh"
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod")
     @mod.stubs(:path).returns "/a"
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
 
   it "should return all manifests matching the glob pattern" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
     FileTest.stubs(:directory?).returns false
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo bar}
   end
 
   it "should not return directories" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
 
     FileTest.expects(:directory?).with("foo").returns false
     FileTest.expects(:directory?).with("bar").returns true
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo}
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
     Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
 
   it "should return all manifests matching the glob pattern in all existing paths" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{a b})
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{a b}
   end
 
   it "should match the glob pattern plus '.{pp,rb}' if no extention is specified" do
     Dir.expects(:glob).with("/a/manifests/yay/foo.{pp,rb}").returns(%w{yay})
 
     @mod.match_manifests("yay/foo").should == %w{yay}
   end
 
   it "should return an empty array if no manifests matched" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
 end
 
 describe Puppet::Module do
   before do
     Puppet::Module.any_instance.stubs(:path).returns "/my/mod/path"
     @module = Puppet::Module.new("foo")
   end
 
   it "should use 'License' in its current path as its metadata file" do
     @module.license_file.should == "/my/mod/path/License"
   end
 
   it "should return nil as its license file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").license_file.should be_nil
   end
 
   it "should cache the license file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.license_file.should == mod.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
     @module.metadata_file.should == "/my/mod/path/metadata.json"
   end
 
   it "should return nil as its metadata file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").metadata_file.should be_nil
   end
 
   it "should cache the metadata file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.metadata_file.should == mod.metadata_file
   end
 
   it "should know if it has a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
 
     @module.should be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
     @module.should respond_to(:load_metadata)
   end
 
   it "should parse its metadata file on initialization if it is present" do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
     Puppet::Module.new("yay")
   end
 
   describe "when loading the medatada file", :if => Puppet.features.json? do
     before do
       @data = {
         :license => "GPL2",
         :author => "luke",
         :version => "1.0",
         :source => "http://foo/",
         :puppetversion => "0.25"
       }
       @text = @data.to_json
 
       @module = Puppet::Module.new("foo")
       @module.stubs(:metadata_file).returns "/my/file"
       File.stubs(:read).with("/my/file").returns @text
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
         @module.load_metadata
         @module.send(attr).should == @data[attr.to_sym]
       end
 
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_json
         File.stubs(:read).with("/my/file").returns @text
         lambda { @module.load_metadata }.should raise_error(Puppet::Module::MissingMetadata)
       end
     end
 
     it "should set puppetversion if present in the metadata file" do
       @module.load_metadata
       @module.puppetversion.should == @data[:puppetversion]
     end
 
 
     it "should fail if the discovered name is different than the metadata name"
   end
 end
diff --git a/spec/unit/network/handler/fileserver_spec.rb b/spec/unit/network/handler/fileserver_spec.rb
index b37d4f551..9d34e9cdd 100644
--- a/spec/unit/network/handler/fileserver_spec.rb
+++ b/spec/unit/network/handler/fileserver_spec.rb
@@ -1,170 +1,170 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/network/handler/fileserver'
 
 describe Puppet::Network::Handler::FileServer do
   include PuppetSpec::Files
 
   def create_file(filename)
     File.open(filename, "w") { |f| f.puts filename}
   end
 
   def create_nested_file
     dirname = File.join(@basedir, "nested_dir")
     Dir.mkdir(dirname)
     file = File.join(dirname, "nested_dir_file")
     create_file(file)
   end
 
   before do
     @basedir = tmpdir("test_network_handler")
     @file = File.join(@basedir, "aFile")
     @link = File.join(@basedir, "aLink")
     create_file(@file)
     @mount = Puppet::Network::Handler::FileServer::Mount.new("some_path", @basedir)
   end
 
   it "should list a single directory" do
     @mount.list("/", false, false).should == [["/", "directory"]]
   end
 
   it "should list a file within a directory when given the file path" do
     @mount.list("/aFile", false, "false").should == [["/", "file"]]
   end
 
   it "should list a file within a directory when given the file path with recursion" do
     @mount.list("/aFile", true, "false").should == [["/", "file"]]
   end
 
   it "should return nil for a non-existent path" do
     @mount.list("/no_such_file", false, false).should be(nil)
   end
 
   it "should list a symbolic link as a file when given the link path" do
     File.symlink(@file, @link)
     @mount.list("/aLink", false, false).should == [["/", "file"]]
   end
 
   it "should return nil for a dangling symbolic link when given the link path" do
     File.symlink("/some/where", @link)
     @mount.list("/aLink", false, false).should be(nil)
   end
 
   it "should list directory contents of a flat directory structure when asked to recurse" do
     list = @mount.list("/", true, false)
     list.should include(["/aFile", "file"])
     list.should include(["/", "directory"])
     list.should have(2).items
   end
 
   it "should list the contents of a nested directory" do
     create_nested_file
     list = @mount.list("/", true, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the contents of a directory ignoring files that match" do
     create_nested_file
     list = @mount.list("/", true, "*File")
     list.sort.should == [   ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the contents of a directory ignoring directories that match" do
     create_nested_file
     list = @mount.list("/", true, "*nested_dir")
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ].sort
   end
 
   it "should list the contents of a directory ignoring all ignore patterns that match" do
     create_nested_file
     list = @mount.list("/", true, ["*File" , "*nested_dir"])
     list.should == [ ["/", "directory"] ]
   end
 
   it "should list the directory when recursing to a depth of zero" do
     create_nested_file
     list = @mount.list("/", 0, false)
     list.should == [["/", "directory"]]
   end
 
   it "should list the base directory and files and nested directory to a depth of one" do
     create_nested_file
     list = @mount.list("/", 1, false)
     list.sort.should == [ ["/aFile", "file"], ["/nested_dir", "directory"], ["/", "directory"] ].sort
   end
 
   it "should list the base directory and files and nested directory to a depth of two" do
     create_nested_file
     list = @mount.list("/", 2, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list the base directory and files and nested directory to a depth greater than the directory structure" do
     create_nested_file
     list = @mount.list("/", 42, false)
     list.sort.should == [   ["/aFile", "file"], ["/", "directory"] , ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
   end
 
   it "should list a valid symbolic link as a file when recursing base dir" do
     File.symlink(@file, @link)
     list = @mount.list("/", true, false)
     list.sort.should == [ ["/", "directory"], ["/aFile", "file"], ["/aLink", "file"] ].sort
   end
 
   it "should not error when a dangling symlink is present" do
     File.symlink("/some/where", @link)
     lambda { @mount.list("/", true, false) }.should_not raise_error
   end
 
   it "should return the directory contents of valid entries when a dangling symlink is present" do
     File.symlink("/some/where", @link)
     list = @mount.list("/", true, false)
     list.sort.should == [ ["/aFile", "file"], ["/", "directory"] ].sort
   end
 
   describe Puppet::Network::Handler::FileServer::PluginMount do
     PLUGINS = Puppet::Network::Handler::FileServer::PLUGINS
 
     # create a module plugin hierarchy
     def create_plugin(mod, plugin)
       dirname = File.join(@basedir, mod)
       Dir.mkdir(dirname)
       plugins = File.join(dirname, PLUGINS)
       Dir.mkdir(plugins)
       facter = File.join(plugins, plugin)
       Dir.mkdir(facter)
       create_file(File.join(facter,"fact.rb"))
     end
 
     before :each do
       @modules = ["one","two"]
       @modules.each { |m| create_plugin(m, "facter") }
 
       Puppet::Node::Environment.new.stubs(:modulepath).returns @basedir
 
       @mount = Puppet::Network::Handler::FileServer::PluginMount.new(PLUGINS)
       @mount.allow("*")
     end
 
     it "should list a file within a directory when given the file path with recursion" do
       @mount.list("facter/fact.rb", true, "false").should == [["/", "file"], ["/", "file"]]
     end
 
     it "should return a merged view of all plugins for all modules" do
       list = @mount.list("facter",true,false)
       list.should == [["/", "directory"], ["/fact.rb", "file"], ["/", "directory"], ["/fact.rb", "file"]]
     end
 
     it "should not fail for inexistant plugins type" do
-      lambda { @mount.list("puppet/parser",true,false) }.should_not raise_error
+      @mount.list("puppet/parser",true,false)
     end
 
   end
 
   after do
     FileUtils.rm_rf(@basedir)
   end
 
 end
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 6cc393d91..2ed279fd9 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -1,443 +1,443 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser do
 
   ast = Puppet::Parser::AST
 
   before :each do
     @known_resource_types = Puppet::Resource::TypeCollection.new("development")
     @parser = Puppet::Parser::Parser.new "development"
     @parser.stubs(:known_resource_types).returns @known_resource_types
     @true_ast = Puppet::Parser::AST::Boolean.new :value => true
   end
 
   it "should require an environment at initialization" do
     lambda { Puppet::Parser::Parser.new }.should raise_error(ArgumentError)
   end
 
   it "should set the environment" do
     env = Puppet::Node::Environment.new
     Puppet::Parser::Parser.new(env).environment.should == env
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Parser::Parser.new("testing").environment.should == env
   end
 
   it "should be able to look up the environment-specific resource type collection" do
     rtc = Puppet::Node::Environment.new("development").known_resource_types
     parser = Puppet::Parser::Parser.new "development"
     parser.known_resource_types.should equal(rtc)
   end
 
   it "should delegate importing to the known resource type loader" do
     parser = Puppet::Parser::Parser.new "development"
     parser.known_resource_types.loader.expects(:import).with("newfile", "current_file")
     parser.lexer.expects(:file).returns "current_file"
     parser.import("newfile")
   end
 
   describe "when parsing files" do
     before do
       FileTest.stubs(:exist?).returns true
       File.stubs(:read).returns ""
       @parser.stubs(:watch_file)
     end
 
     it "should treat files ending in 'rb' as ruby files" do
       @parser.expects(:parse_ruby_file)
       @parser.file = "/my/file.rb"
       @parser.parse
     end
   end
 
   describe "when parsing append operator" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse("$var += something") }.should_not raise_error
     end
 
     it "shouldraise syntax error on incomplete syntax " do
       lambda { @parser.parse("$var += ") }.should raise_error
     end
 
     it "should call ast::VarDef with append=true" do
       ast::VarDef.expects(:new).with { |h| h[:append] == true }
       @parser.parse("$var += 2")
     end
 
     it "should work with arrays too" do
       ast::VarDef.expects(:new).with { |h| h[:append] == true }
       @parser.parse("$var += ['test']")
     end
 
   end
 
   describe "when parsing selector" do
     it "should support hash access on the left hand side" do
       lambda { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.should_not raise_error
     end
   end
 
   describe "when parsing 'if'" do
     it "not, it should create the correct ast objects" do
       ast::Not.expects(:new).with { |h| h[:value].is_a?(ast::Boolean) }
       @parser.parse("if ! true { $var = 1 }")
     end
 
     it "boolean operation, it should create the correct ast objects" do
       ast::BooleanOperator.expects(:new).with {
         |h| h[:rval].is_a?(ast::Boolean) and h[:lval].is_a?(ast::Boolean) and h[:operator]=="or"
       }
       @parser.parse("if true or true { $var = 1 }")
 
     end
 
     it "comparison operation, it should create the correct ast objects" do
       ast::ComparisonOperator.expects(:new).with {
         |h| h[:lval].is_a?(ast::Name) and h[:rval].is_a?(ast::Name) and h[:operator]=="<"
       }
       @parser.parse("if 1 < 2 { $var = 1 }")
 
     end
 
   end
 
   describe "when parsing if complex expressions" do
     it "should create a correct ast tree" do
       aststub = stub_everything 'ast'
       ast::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]==">"
       }.returns(aststub)
       ast::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]=="=="
       }.returns(aststub)
       ast::BooleanOperator.expects(:new).with {
         |h| h[:rval]==aststub and h[:lval]==aststub and h[:operator]=="and"
       }
       @parser.parse("if (1 > 2) and (1 == 2) { $var = 1 }")
     end
 
     it "should raise an error on incorrect expression" do
       lambda { @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }") }.should raise_error
     end
 
   end
 
   describe "when parsing resource references" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse('exec { test: param => File["a"] }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple references" do
       lambda { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceReference" do
       ast::Resource.stubs(:new)
       ast::ResourceReference.expects(:new).with { |arg|
         arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(ast::ASTArray)
       }
       @parser.parse('exec { test: command => File["a","b"] }')
     end
   end
 
   describe "when parsing resource overrides" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse('Resource["title"] { param => value }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple overrides" do
       lambda { @parser.parse('Resource["title1","title2"] { param => value }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceOverride" do
       ast::ResourceOverride.expects(:new).with { |arg|
         arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:parameters].is_a?(ast::ResourceParam)
       }
       @parser.parse('Resource["title1","title2"] { param => value }')
     end
 
   end
 
   describe "when parsing if statements" do
 
     it "should not raise errors with empty if" do
       lambda { @parser.parse("if true { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty else" do
       lambda { @parser.parse("if false { notice('if') } else { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty if and else" do
       lambda { @parser.parse("if false { } else { }") }.should_not raise_error
     end
 
     it "should create a nop node for empty branch" do
       ast::Nop.expects(:new)
       @parser.parse("if true { }")
     end
 
     it "should create a nop node for empty else branch" do
       ast::Nop.expects(:new)
       @parser.parse("if true { notice('test') } else { }")
     end
 
     it "should build a chain of 'ifs' if there's an 'elsif'" do
       ast = @parser.parse(<<-PP)
         if true { notice('test') } elsif true {} else { }
       PP
     end
 
   end
 
   describe "when parsing function calls" do
 
     it "should not raise errors with no arguments" do
       lambda { @parser.parse("tag()") }.should_not raise_error
     end
 
     it "should not raise errors with rvalue function with no args" do
       lambda { @parser.parse("$a = template()") }.should_not raise_error
     end
 
     it "should not raise errors with arguments" do
       lambda { @parser.parse("notice(1)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments" do
       lambda { @parser.parse("notice(1,2)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments and a trailing comma" do
       lambda { @parser.parse("notice(1,2,)") }.should_not raise_error
     end
 
   end
 
   describe "when parsing arrays with trailing comma" do
 
     it "should not raise errors with a trailing comma" do
       lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
     end
   end
 
   describe "when providing AST context" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
     end
 
     it "should include the lexer's line" do
       @parser.ast_context[:line].should == 50
     end
 
     it "should include the lexer's file" do
       @parser.ast_context[:file].should == "/foo/bar"
     end
 
     it "should include the docs if directed to do so" do
       @parser.ast_context(true)[:doc].should == "whev"
     end
 
     it "should not include the docs when told not to" do
       @parser.ast_context(false)[:doc].should be_nil
     end
 
     it "should not include the docs by default" do
       @parser.ast_context[:doc].should be_nil
     end
   end
 
   describe "when building ast nodes" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
-      @class = stub 'class', :use_docs => false
+      @class = Puppet::Resource::Type.new(:hostclass, "myclass", :use_docs => false)
     end
 
     it "should return a new instance of the provided class created with the provided options" do
       @class.expects(:new).with { |opts| opts[:foo] == "bar" }
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should merge the ast context into the provided options" do
       @class.expects(:new).with { |opts| opts[:file] == "/foo" }
       @parser.expects(:ast_context).returns :file => "/foo"
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should prefer provided options over AST context" do
       @class.expects(:new).with { |opts| opts[:file] == "/bar" }
       @lexer.expects(:file).returns "/foo"
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should include docs when the AST class uses them" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new)
       @parser.expects(:ast_context).with{ |docs, line| docs == true }.returns({})
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should get docs from lexer using the correct AST line number" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new).with{ |a| a[:doc] == "doc" }
       @lexer.expects(:getcomment).with(12).returns "doc"
       @parser.ast(@class, :file => "/bar", :line => 12)
     end
   end
 
   describe "when creating a node" do
     before :each do
       @lexer = stub 'lexer'
       @lexer.stubs(:getcomment)
       @parser.stubs(:lexer).returns(@lexer)
       @node = stub_everything 'node'
       @parser.stubs(:ast_context).returns({})
       @parser.stubs(:node).returns(nil)
 
       @nodename = stub 'nodename', :is_a? => false, :value => "foo"
       @nodename.stubs(:is_a?).with(Puppet::Parser::AST::HostName).returns(true)
     end
 
     it "should return an array of nodes" do
       @parser.newnode(@nodename).should be_instance_of(Array)
     end
 
     it "should initialize the ast context with the correct line number" do
       @parser.expects(:ast_context).with { |a,b| b == 123 }.returns({})
       @parser.newnode(@nodename, { :line => 123 })
     end
   end
 
   %w{class define}.each do |entity|
     describe "when creating a #{entity}" do
       before :each do
         @parser.stubs(:ast_context).returns({})
 
         @name = stub "#{entity}name", :is_a? => false, :value => "foo"
       end
 
       it "should create and add the correct resource type" do
         instance = stub 'instance'
         Puppet::Resource::Type.expects(:new).returns(instance)
         @parser.known_resource_types.expects(:add).with(instance)
         @parser.send("new#{entity}", @name)
       end
 
       it "should initialize the ast context with the correct line number" do
         @parser.expects(:ast_context).with { |a,b| b == 123 }.returns({})
         @parser.send("new#{entity}", @name, { :line => 123 })
       end
     end
   end
 
   describe "when retrieving a specific node" do
     it "should delegate to the known_resource_types node" do
       @known_resource_types.expects(:node).with("node")
 
       @parser.node("node")
     end
   end
 
   describe "when retrieving a specific class" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:hostclass).with("class")
 
       @parser.hostclass("class")
     end
   end
 
   describe "when retrieving a specific definitions" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:definition).with("define")
 
       @parser.definition("define")
     end
   end
 
   describe "when determining the configuration version" do
     it "should determine it from the resource type collection" do
       @parser.known_resource_types.expects(:version).returns "foo"
       @parser.version.should == "foo"
     end
   end
 
   describe "when looking up definitions" do
     it "should use the known resource types to check for them by name" do
       @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:definition).returns(:this_value)
       @parser.find_definition("namespace","name").should == :this_value
     end
   end
 
   describe "when looking up hostclasses" do
     it "should use the known resource types to check for them by name" do
       @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass).returns(:this_value)
       @parser.find_hostclass("namespace","name").should == :this_value
     end
   end
 
   describe "when parsing classes" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should create new classes" do
       @parser.parse("class foobar {}")
       @krt.hostclass("foobar").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should correctly set the parent class when one is provided" do
       @parser.parse("class foobar inherits yayness {}")
       @krt.hostclass("foobar").parent.should == "yayness"
     end
 
     it "should correctly set the parent class for multiple classes at a time" do
       @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}")
       @krt.hostclass("foobar").parent.should == "yayness"
       @krt.hostclass("boo").parent.should == "bar"
     end
 
     it "should define the code when some is provided" do
       @parser.parse("class foobar { $var = val }")
       @krt.hostclass("foobar").code.should_not be_nil
     end
 
     it "should define parameters when provided" do
       @parser.parse("class foobar($biz,$baz) {}")
       @krt.hostclass("foobar").arguments.should == {"biz" => nil, "baz" => nil}
     end
   end
 
   describe "when parsing resources" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should be able to parse class resources" do
       @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar", :arguments => {"biz" => nil}))
       lambda { @parser.parse("class { foobar: biz => stuff }") }.should_not raise_error
     end
 
     it "should correctly mark exported resources as exported" do
       @parser.parse("@@file { '/file': }")
       @krt.hostclass("").code[0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
       @parser.parse("@file { '/file': }")
       @krt.hostclass("").code[0].virtual.should be_true
     end
   end
 end