puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/util/log/rate_limited_logger_spec.rb

@@ -1,51 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/util/log/rate_limited_logger'
-
-describe Puppet::Util::Log::RateLimitedLogger do
-
-  subject { Puppet::Util::Log::RateLimitedLogger.new(60) }
-
-  before do
-    Time.stubs(:now).returns(0)
-  end
-
-  it "should be able to log all levels" do
-    Puppet::Util::Log.eachlevel do |level|
-      subject.should respond_to(level)
-    end
-  end
-
-  it "should fail if given an invalid time interval" do
-    expect { Puppet::Util::Log::RateLimitedLogger.new('foo') }.to raise_error(ArgumentError)
-  end
-
-  it "should not log the same message more than once within the given interval" do
-    Puppet::Util::Log.expects(:create).once
-    subject.info('foo')
-    subject.info('foo')
-  end
-
-  it "should allow the same message to be logged after the given interval has passed" do
-    Puppet::Util::Log.expects(:create).twice
-    subject.info('foo')
-    Time.stubs(:now).returns(60)
-    subject.info('foo')
-  end
-
-  it "should rate-limit different message strings separately" do
-    Puppet::Util::Log.expects(:create).times(3)
-    subject.info('foo')
-    subject.info('bar')
-    subject.info('baz')
-    subject.info('foo')
-    subject.info('bar')
-    subject.info('baz')
-  end
-
-  it "should limit the same message in different log levels independently" do
-    Puppet::Util::Log.expects(:create).twice
-    subject.info('foo')
-    subject.warning('foo')
-  end
-end

data/spec/unit/util/monkey_patches/lines_spec.rb

@@ -1,83 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/util/monkey_patches/lines'
-
-class Puppet::Util::MonkeyPatches::Lines::TestHelper < String
-  include Puppet::Util::MonkeyPatches::Lines
-end
-
-describe Puppet::Util::MonkeyPatches::Lines::TestHelper do
-  ["\n", "\n\n", "$", "$$", "@", "@@"].each do |sep|
-    context "with #{sep.inspect}" do
-      it "should delegate to each_line if given a block" do
-        subject.expects(:each_line).with(sep)
-        subject.lines(sep) do |x| nil end
-      end
-
-      it "should delegate to each_line without a block" do
-        subject.expects(:enum_for).with(:each_line, sep)
-        subject.lines(sep)
-      end
-
-      context "with one line" do
-        context "with trailing separator" do
-          subject { described_class.new("foo" + sep) }
-
-          it "should yield the string" do
-            got = []
-            subject.lines(sep) do |x| got << x end
-            got.should == ["foo#{sep}"]
-          end
-
-          it "should return the string" do
-            subject.lines(sep).to_a.should == ["foo#{sep}"]
-          end
-        end
-
-        context "without trailing separator" do
-          subject { described_class.new("foo") }
-
-          it "should yield the string" do
-            got = []
-            subject.lines(sep) do |x| got << x end
-            got.should == ["foo"]
-          end
-
-          it "should return the string" do
-            subject.lines(sep).to_a.should == ["foo"]
-          end
-        end
-      end
-
-      context "with multiple lines" do
-        context "with trailing separator" do
-          subject { described_class.new("foo#{sep}bar#{sep}baz#{sep}") }
-
-          it "should yield the strings" do
-            got = []
-            subject.lines(sep) do |x| got << x end
-            got.should == ["foo#{sep}", "bar#{sep}", "baz#{sep}"]
-          end
-
-          it "should return the strings" do
-            subject.lines(sep).to_a.should == ["foo#{sep}", "bar#{sep}", "baz#{sep}"]
-          end
-        end
-
-        context "without trailing separator" do
-          subject { described_class.new("foo#{sep}bar#{sep}baz") }
-
-          it "should yield the strings" do
-            got = []
-            subject.lines(sep) do |x| got << x end
-            got.should == ["foo#{sep}", "bar#{sep}", "baz"]
-          end
-
-          it "should return the strings" do
-            subject.lines(sep).to_a.should == ["foo#{sep}", "bar#{sep}", "baz"]
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/util/queue/stomp_spec.rb

@@ -1,137 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/util/queue'
-
-describe Puppet::Util::Queue, :if => Puppet.features.stomp? do
-  it 'should load :stomp client appropriately' do
-    Puppet::Util::Queue.queue_type_to_class(:stomp).name.should == 'Puppet::Util::Queue::Stomp'
-  end
-end
-
-describe 'Puppet::Util::Queue::Stomp', :if => Puppet.features.stomp? do
-  before do
-    # So we make sure we never create a real client instance.
-    # Otherwise we'll try to connect, and that's bad.
-    Stomp::Client.stubs(:new).returns stub("client", :publish => true)
-  end
-
-  it 'should be registered with Puppet::Util::Queue as :stomp type' do
-    Puppet::Util::Queue.queue_type_to_class(:stomp).should == Puppet::Util::Queue::Stomp
-  end
-
-  describe "when initializing" do
-    it "should create a Stomp client instance" do
-      Stomp::Client.expects(:new).returns stub("stomp_client", :publish => true)
-      Puppet::Util::Queue::Stomp.new
-    end
-
-    it "should provide helpful failures when the queue source is not a valid source" do
-      Puppet[:queue_source] = "-----"
-
-      expect { Puppet::Util::Queue::Stomp.new }.to raise_error(ArgumentError, /not a Stomp URL/)
-    end
-
-    it "should fail unless the queue source is a stomp URL" do
-      Puppet[:queue_source] = "http://foo/bar"
-
-      expect { Puppet::Util::Queue::Stomp.new }.to raise_error(ArgumentError, /not a Stomp URL/)
-    end
-
-    it "should fail somewhat helpfully if the Stomp client cannot be created" do
-      Stomp::Client.expects(:new).raises RuntimeError
-      expect { Puppet::Util::Queue::Stomp.new }.to raise_error(ArgumentError)
-    end
-
-    list = %w{user password host port}
-    {"user" => "myuser", "password" => "mypass", "host" => "foohost", "port" => 42}.each do |name, value|
-      it "should use the #{name} from the queue source as the queueing #{name}" do
-        Puppet[:queue_source] = "stomp://myuser:mypass@foohost:42/"
-
-        Stomp::Client.expects(:new).with { |*args| args[list.index(name)] == value }
-        Puppet::Util::Queue::Stomp.new
-      end
-    end
-
-    it "should create a reliable client instance" do
-      Puppet[:queue_source] = "stomp://myuser@foohost:42/"
-
-      Stomp::Client.expects(:new).with { |*args| args[4] == true }
-      Puppet::Util::Queue::Stomp.new
-    end
-  end
-
-  describe "when publishing a message" do
-    before do
-      @client = stub 'client', :publish => true
-      Stomp::Client.stubs(:new).returns @client
-      @queue = Puppet::Util::Queue::Stomp.new
-    end
-
-    it "should publish it to the queue client instance" do
-      @client.expects(:publish).with { |queue, msg, options| msg == "Smite!" }
-      @queue.publish_message('fooqueue', 'Smite!')
-    end
-
-    it "should publish it to the transformed queue name" do
-      @client.expects(:publish).with { |queue, msg, options| queue == "/queue/fooqueue" }
-      @queue.publish_message('fooqueue', 'Smite!')
-    end
-
-    it "should publish it as a persistent message" do
-      @client.expects(:publish).with { |queue, msg, options| options[:persistent] == true }
-      @queue.publish_message('fooqueue', 'Smite!')
-    end
-
-    it "should use send when the gem does not support publish" do
-      Stomp::Client.stubs(:new).returns(stub('client', :send => true))
-      Puppet::Util::Queue::Stomp.new.publish_message('fooqueue', 'Smite!')
-    end
-  end
-
-  describe "when subscribing to a queue" do
-    before do
-      @client = stub 'client', :acknowledge => true, :publish => true
-      Stomp::Client.stubs(:new).returns @client
-      @queue = Puppet::Util::Queue::Stomp.new
-    end
-
-    it "should subscribe via the queue client instance" do
-      @client.expects(:subscribe)
-      @queue.subscribe('fooqueue')
-    end
-
-    it "should subscribe to the transformed queue name" do
-      @client.expects(:subscribe).with { |queue, options| queue == "/queue/fooqueue" }
-      @queue.subscribe('fooqueue')
-    end
-
-    it "should specify that its messages should be acknowledged" do
-      @client.expects(:subscribe).with { |queue, options| options[:ack] == :client }
-      @queue.subscribe('fooqueue')
-    end
-
-    it "should yield the body of any received message" do
-      message = mock 'message'
-      message.expects(:body).returns "mybody"
-
-      @client.expects(:subscribe).yields(message)
-
-      body = nil
-      @queue.subscribe('fooqueue') { |b| body = b }
-      body.should == "mybody"
-    end
-
-    it "should acknowledge all successfully processed messages" do
-      message = stub 'message', :body => "mybode"
-
-      @client.stubs(:subscribe).yields(message)
-      @client.expects(:acknowledge).with(message)
-
-      @queue.subscribe('fooqueue') { |b| "eh" }
-    end
-  end
-
-  it 'should transform the simple queue name to "/queue/<queue_name>"' do
-    Puppet::Util::Queue::Stomp.new.stompify_target('blah').should == '/queue/blah'
-  end
-end

data/spec/unit/util/queue_spec.rb

@@ -1,94 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/util/queue'
-
-def make_test_client_class(n)
-  c = Class.new do
-    class <<self
-      attr_accessor :name
-      def to_s
-        name
-      end
-    end
-  end
-  c.name = n
-  c
-end
-
-mod = Puppet::Util::Queue
-client_classes = { :default => make_test_client_class('Bogus::Default'), :setup => make_test_client_class('Bogus::Setup') }
-
-describe Puppet::Util::Queue do
-  before :all do
-    mod.register_queue_type(client_classes[:default], :default)
-    mod.register_queue_type(client_classes[:setup], :setup)
-  end
-
-  before :each do
-    @class = Class.new do
-      extend mod
-    end
-  end
-
-  after :all do
-    instances = mod.instance_hash(:queue_clients)
-    [:default, :setup, :bogus, :aardvark, :conflict, :test_a, :test_b].each{ |x| instances.delete(x) }
-  end
-
-  context 'when determining a type name from a class' do
-    it 'should handle a simple one-word class name' do
-      mod.queue_type_from_class(make_test_client_class('Foo')).should == :foo
-    end
-
-    it 'should handle a simple two-word class name' do
-      mod.queue_type_from_class(make_test_client_class('FooBar')).should == :foo_bar
-    end
-
-    it 'should handle a two-part class name with one terminating word' do
-      mod.queue_type_from_class(make_test_client_class('Foo::Bar')).should == :bar
-    end
-
-    it 'should handle a two-part class name with two terminating words' do
-      mod.queue_type_from_class(make_test_client_class('Foo::BarBah')).should == :bar_bah
-    end
-  end
-
-  context 'when registering a queue client class' do
-    c = make_test_client_class('Foo::Bogus')
-    it 'uses the proper default name logic when type is unspecified' do
-      mod.register_queue_type(c)
-      mod.queue_type_to_class(:bogus).should == c
-    end
-
-    it 'uses an explicit type name when provided' do
-      mod.register_queue_type(c, :aardvark)
-      mod.queue_type_to_class(:aardvark).should == c
-    end
-
-    it 'throws an exception when type names conflict' do
-      mod.register_queue_type( make_test_client_class('Conflict') )
-      lambda { mod.register_queue_type( c, :conflict) }.should raise_error
-    end
-
-    it 'handle multiple, non-conflicting registrations' do
-      a = make_test_client_class('TestA')
-      b = make_test_client_class('TestB')
-      mod.register_queue_type(a)
-      mod.register_queue_type(b)
-      mod.queue_type_to_class(:test_a).should == a
-      mod.queue_type_to_class(:test_b).should == b
-    end
-
-    it 'throws an exception when type name is unknown' do
-      lambda { mod.queue_type_to_class(:nope) }.should raise_error
-    end
-  end
-
-  context 'when determining client type' do
-    it 'returns client class based on the :queue_type setting' do
-      Puppet[:queue_type] = :myqueue
-      Puppet::Util::Queue.expects(:queue_type_to_class).with(:myqueue).returns "eh"
-      @class.client_class.should == "eh"
-    end
-  end
-end

data/spec/unit/util/rdoc/parser_spec.rb

@@ -1,608 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe "RDoc::Parser", :if => Puppet.features.rdoc1? do
-  before :all do
-    require 'puppet/resource/type_collection'
-    require 'puppet/util/rdoc/parser'
-    require 'puppet/util/rdoc/code_objects'
-    require 'rdoc/options'
-    require 'rdoc/rdoc'
-  end
-
-  include PuppetSpec::Files
-
-  before :each do
-    stub_file = stub('init.pp', :stat => stub())
-    # Ruby 1.8.7 needs the following call to be stubs and not expects
-    Puppet::FileSystem.stubs(:stat).with('init.pp').returns stub() # stub_file
-    @top_level = stub_everything 'toplevel', :file_relative_name => "init.pp"
-    @parser = RDoc::Parser.new(@top_level, "module/manifests/init.pp", nil, Options.instance, RDoc::Stats.new)
-  end
-
-  describe "when scanning files" do
-    around(:each) do |example|
-      Puppet.override({
-          :current_environment => Puppet::Node::Environment.create(:doc, [], '/somewhere/etc/manifests/site.pp')
-        },
-        "A fake current environment that the application would have established by now"
-      ) do
-
-        example.run
-      end
-    end
-
-    it "should parse puppet files with the puppet parser" do
-      @parser.stubs(:scan_top_level)
-      parser = stub 'parser'
-      Puppet::Parser::Parser.stubs(:new).returns(parser)
-      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
-      parser.expects(:file=).with("module/manifests/init.pp")
-      parser.expects(:file=).with do |args|
-        args =~ /.*\/etc\/manifests\/site.pp/
-      end
-
-      @parser.scan
-    end
-
-    it "should scan the ast for Puppet files" do
-      parser = stub_everything 'parser'
-      Puppet::Parser::Parser.stubs(:new).returns(parser)
-      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
-
-      @parser.expects(:scan_top_level)
-
-      @parser.scan
-    end
-
-    it "should return a PuppetTopLevel to RDoc" do
-      parser = stub_everything 'parser'
-      Puppet::Parser::Parser.stubs(:new).returns(parser)
-      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
-
-      @parser.expects(:scan_top_level)
-
-      @parser.scan.should be_a(RDoc::PuppetTopLevel)
-    end
-
-    it "should scan the top level even if the file has already parsed" do
-      known_type = stub 'known_types'
-      env = Puppet.lookup(:current_environment)
-      env.stubs(:known_resource_types).returns(known_type)
-      known_type.expects(:watching_file?).with("module/manifests/init.pp").returns(true)
-      @parser.expects(:scan_top_level)
-
-      @parser.scan
-    end
-  end
-
-  describe "when scanning top level entities" do
-    let(:environment) { Puppet::Node::Environment.create(:env, []) }
-
-    before :each do
-      @resource_type_collection = resource_type_collection = stub_everything('resource_type_collection')
-      environment.stubs(:known_resource_types).returns(@resource_type_collection)
-      @parser.stubs(:split_module).returns("module")
-
-      @topcontainer = stub_everything 'topcontainer'
-      @container = stub_everything 'container'
-      @module = stub_everything 'module'
-      @container.stubs(:add_module).returns(@module)
-      @parser.stubs(:get_class_or_module).returns([@container, "module"])
-    end
-
-    it "should read any present README as module documentation" do
-      FileTest.stubs(:readable?).with("module/README").returns(true)
-      FileTest.stubs(:readable?).with("module/README.rdoc").returns(false)
-      File.stubs(:open).returns("readme")
-      @parser.stubs(:parse_elements)
-
-      @module.expects(:add_comment).with("readme", "module/manifests/init.pp")
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should read any present README.rdoc as module documentation" do
-      FileTest.stubs(:readable?).with("module/README.rdoc").returns(true)
-      FileTest.stubs(:readable?).with("module/README").returns(false)
-      File.stubs(:open).returns("readme")
-      @parser.stubs(:parse_elements)
-
-      @module.expects(:add_comment).with("readme", "module/manifests/init.pp")
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should prefer README.rdoc over README as module documentation" do
-      FileTest.stubs(:readable?).with("module/README.rdoc").returns(true)
-      FileTest.stubs(:readable?).with("module/README").returns(true)
-      File.stubs(:open).with("module/README", "r").returns("readme")
-      File.stubs(:open).with("module/README.rdoc", "r").returns("readme.rdoc")
-      @parser.stubs(:parse_elements)
-
-      @module.expects(:add_comment).with("readme.rdoc", "module/manifests/init.pp")
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should tell the container its module name" do
-      @parser.stubs(:parse_elements)
-
-      @topcontainer.expects(:module_name=).with("module")
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should not document our toplevel if it isn't a valid module" do
-      @parser.stubs(:split_module).returns(nil)
-
-      @topcontainer.expects(:document_self=).with(false)
-      @parser.expects(:parse_elements).never
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should set the module as global if we parse the global manifests (ie __site__ module)" do
-      @parser.stubs(:split_module).returns(RDoc::Parser::SITE)
-      @parser.stubs(:parse_elements)
-
-      @topcontainer.expects(:global=).with(true)
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should attach this module container to the toplevel container" do
-      @parser.stubs(:parse_elements)
-
-      @container.expects(:add_module).with(RDoc::PuppetModule, "module").returns(@module)
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should defer ast parsing to parse_elements for this module" do
-      @parser.expects(:parse_elements).with(@module, @resource_type_collection)
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-
-    it "should defer plugins parsing to parse_plugins for this module" do
-      @parser.input_file_name = "module/lib/puppet/parser/function.rb"
-
-      @parser.expects(:parse_plugins).with(@module)
-
-      @parser.scan_top_level(@topcontainer, environment)
-    end
-  end
-
-  describe "when finding modules from filepath" do
-    let(:environment) {
-      Puppet::FileSystem.expects(:directory?).with("/path/to/modules").at_least_once.returns(true)
-      Puppet::Node::Environment.create(:env, ["/path/to/modules"])
-    }
-
-    it "should return the module name for modulized puppet manifests" do
-      File.stubs(:identical?).with("/path/to/modules", "/path/to/modules").returns(true)
-      @parser.split_module("/path/to/modules/mymodule/manifests/init.pp", environment).should == "mymodule"
-    end
-
-    it "should return <site> for manifests not under module path" do
-      File.stubs(:identical?).returns(false)
-      @parser.split_module("/path/to/manifests/init.pp", environment).should == RDoc::Parser::SITE
-    end
-
-    it "should handle windows paths with drive letters", :if => Puppet.features.microsoft_windows? && Puppet.features.rdoc1? do
-      @parser.split_module("C:/temp/init.pp", environment).should == RDoc::Parser::SITE
-    end
-  end
-
-  describe "when parsing AST elements" do
-    before :each do
-      @klass = stub_everything 'klass', :file => "module/manifests/init.pp", :name => "myclass", :type => :hostclass
-      @definition = stub_everything 'definition', :file => "module/manifests/init.pp", :type => :definition, :name => "mydef"
-      @node = stub_everything 'node', :file => "module/manifests/init.pp", :type => :node, :name => "mynode"
-
-      @resource_type_collection = resource_type_collection = Puppet::Resource::TypeCollection.new("env")
-      @parser.instance_eval { @known_resource_types = resource_type_collection }
-
-      @container = stub_everything 'container'
-    end
-
-    it "should document classes in the parsed file" do
-      @resource_type_collection.add_hostclass(@klass)
-
-      @parser.expects(:document_class).with("myclass", @klass, @container)
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should not document class parsed in an other file" do
-      @klass.stubs(:file).returns("/not/same/path/file.pp")
-      @resource_type_collection.add_hostclass(@klass)
-
-      @parser.expects(:document_class).with("myclass", @klass, @container).never
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should document vardefs for the main class" do
-      @klass.stubs(:name).returns :main
-      @resource_type_collection.add_hostclass(@klass)
-
-      code = stub 'code', :is_a? => false
-      @klass.stubs(:name).returns("")
-      @klass.stubs(:code).returns(code)
-
-      @parser.expects(:scan_for_vardef).with(@container, code)
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should document definitions in the parsed file" do
-      @resource_type_collection.add_definition(@definition)
-
-      @parser.expects(:document_define).with("mydef", @definition, @container)
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should not document definitions parsed in an other file" do
-      @definition.stubs(:file).returns("/not/same/path/file.pp")
-      @resource_type_collection.add_definition(@definition)
-
-      @parser.expects(:document_define).with("mydef", @definition, @container).never
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should document nodes in the parsed file" do
-      @resource_type_collection.add_node(@node)
-
-      @parser.expects(:document_node).with("mynode", @node, @container)
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-
-    it "should not document node parsed in an other file" do
-      @node.stubs(:file).returns("/not/same/path/file.pp")
-      @resource_type_collection.add_node(@node)
-
-      @parser.expects(:document_node).with("mynode", @node, @container).never
-
-      @parser.parse_elements(@container, @resource_type_collection)
-    end
-  end
-
-  describe "when documenting definition" do
-    before(:each) do
-      @define = stub_everything 'define', :arguments => [], :doc => "mydoc", :file => "file", :line => 42
-      @class = stub_everything 'class'
-      @parser.stubs(:get_class_or_module).returns([@class, "mydef"])
-    end
-
-    it "should register a RDoc method to the current container" do
-      @class.expects(:add_method).with { |m| m.name == "mydef"}
-      @parser.document_define("mydef", @define, @class)
-    end
-
-    it "should attach the documentation to this method" do
-      @class.expects(:add_method).with { |m| m.comment = "mydoc" }
-
-      @parser.document_define("mydef", @define, @class)
-    end
-
-    it "should produce a better error message on unhandled exception" do
-      @class.expects(:add_method).raises(ArgumentError)
-
-      lambda { @parser.document_define("mydef", @define, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
-    end
-
-    it "should convert all definition parameter to string" do
-      arg = stub 'arg'
-      val = stub 'val'
-
-      @define.stubs(:arguments).returns({arg => val})
-
-      arg.expects(:to_s).returns("arg")
-      val.expects(:to_s).returns("val")
-
-      @parser.document_define("mydef", @define, @class)
-    end
-  end
-
-  describe "when documenting nodes" do
-    before :each do
-      @code = stub_everything 'code'
-      @node = stub_everything 'node', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
-      @rdoc_node = stub_everything 'rdocnode'
-
-      @class = stub_everything 'class'
-      @class.stubs(:add_node).returns(@rdoc_node)
-    end
-
-    it "should add a node to the current container" do
-      @class.expects(:add_node).with("mynode", "parent").returns(@rdoc_node)
-      @parser.document_node("mynode", @node, @class)
-    end
-
-    it "should associate the node documentation to the rdoc node" do
-      @rdoc_node.expects(:add_comment).with("mydoc", "file")
-      @parser.document_node("mynode", @node, @class)
-    end
-
-    it "should scan for include and require" do
-      @parser.expects(:scan_for_include_or_require).with(@rdoc_node, @code)
-      @parser.document_node("mynode", @node, @class)
-    end
-
-    it "should scan for variable definition" do
-      @parser.expects(:scan_for_vardef).with(@rdoc_node, @code)
-      @parser.document_node("mynode", @node, @class)
-    end
-
-    it "should scan for resources if needed" do
-      Puppet[:document_all] = true
-      @parser.expects(:scan_for_resource).with(@rdoc_node, @code)
-      @parser.document_node("mynode", @node, @class)
-    end
-
-    it "should produce a better error message on unhandled exception" do
-      @class.stubs(:add_node).raises(ArgumentError)
-
-      lambda { @parser.document_node("mynode", @node, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
-    end
-  end
-
-  describe "when documenting classes" do
-    before :each do
-      @code = stub_everything 'code'
-      @class = stub_everything 'class', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
-      @rdoc_class = stub_everything 'rdoc-class'
-
-      @module = stub_everything 'class'
-      @module.stubs(:add_class).returns(@rdoc_class)
-      @parser.stubs(:get_class_or_module).returns([@module, "myclass"])
-    end
-
-    it "should add a class to the current container" do
-      @module.expects(:add_class).with(RDoc::PuppetClass, "myclass", "parent").returns(@rdoc_class)
-      @parser.document_class("mynode", @class, @module)
-    end
-
-    it "should set the superclass" do
-      @rdoc_class.expects(:superclass=).with("parent")
-      @parser.document_class("mynode", @class, @module)
-    end
-
-    it "should associate the node documentation to the rdoc class" do
-      @rdoc_class.expects(:add_comment).with("mydoc", "file")
-      @parser.document_class("mynode", @class, @module)
-    end
-
-    it "should scan for include and require" do
-      @parser.expects(:scan_for_include_or_require).with(@rdoc_class, @code)
-      @parser.document_class("mynode", @class, @module)
-    end
-
-    it "should scan for resources if needed" do
-      Puppet[:document_all] = true
-      @parser.expects(:scan_for_resource).with(@rdoc_class, @code)
-      @parser.document_class("mynode", @class, @module)
-    end
-
-    it "should produce a better error message on unhandled exception" do
-      @module.stubs(:add_class).raises(ArgumentError)
-
-      lambda { @parser.document_class("mynode", @class, @module) }.should raise_error(Puppet::ParseError, /in file at line 42/)
-    end
-  end
-
-  describe "when scanning for includes and requires" do
-
-    def create_stmt(name)
-      stmt_value = stub "#{name}_value", :to_s => "myclass"
-
-      Puppet::Parser::AST::Function.new(
-        :name      => name,
-        :arguments => [stmt_value],
-        :doc       => 'mydoc'
-      )
-    end
-
-    before(:each) do
-      @class = stub_everything 'class'
-      @code = stub_everything 'code'
-      @code.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).returns(true)
-    end
-
-    it "should also scan mono-instruction code" do
-      @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
-
-      @parser.scan_for_include_or_require(@class, create_stmt("include"))
-    end
-
-    it "should register recursively includes to the current container" do
-      @code.stubs(:children).returns([ create_stmt("include") ])
-
-      @class.expects(:add_include)#.with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
-      @parser.scan_for_include_or_require(@class, [@code])
-    end
-
-    it "should register requires to the current container" do
-      @code.stubs(:children).returns([ create_stmt("require") ])
-
-      @class.expects(:add_require).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
-      @parser.scan_for_include_or_require(@class, [@code])
-    end
-  end
-
-  describe "when scanning for realized virtual resources" do
-
-    def create_stmt
-      stmt_value = stub "resource_ref", :to_s => "File[\"/tmp/a\"]"
-      Puppet::Parser::AST::Function.new(
-        :name      => 'realize',
-        :arguments => [stmt_value],
-        :doc       => 'mydoc'
-      )
-    end
-
-    before(:each) do
-      @class = stub_everything 'class'
-      @code = stub_everything 'code'
-      @code.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).returns(true)
-    end
-
-    it "should also scan mono-instruction code" do
-      @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
-
-      @parser.scan_for_realize(@class,create_stmt)
-    end
-
-    it "should register recursively includes to the current container" do
-      @code.stubs(:children).returns([ create_stmt ])
-
-      @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
-      @parser.scan_for_realize(@class, [@code])
-    end
-  end
-
-  describe "when scanning for variable definition" do
-    before :each do
-      @class = stub_everything 'class'
-
-      @stmt = stub_everything 'stmt', :name => "myvar", :value => "myvalue", :doc => "mydoc"
-      @stmt.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).returns(false)
-      @stmt.stubs(:is_a?).with(Puppet::Parser::AST::VarDef).returns(true)
-
-      @code = stub_everything 'code'
-      @code.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).returns(true)
-    end
-
-    it "should recursively register variables to the current container" do
-      @code.stubs(:children).returns([ @stmt ])
-
-      @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
-      @parser.scan_for_vardef(@class, [ @code ])
-    end
-
-    it "should also scan mono-instruction code" do
-      @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
-
-      @parser.scan_for_vardef(@class, @stmt)
-    end
-  end
-
-  describe "when scanning for resources" do
-    before :each do
-      @class = stub_everything 'class'
-      @stmt = Puppet::Parser::AST::Resource.new(
-        :type       => "File",
-        :instances  => Puppet::Parser::AST::BlockExpression.new(:children => [
-          Puppet::Parser::AST::ResourceInstance.new(
-            :title => Puppet::Parser::AST::Name.new(:value => "myfile"),
-            :parameters => Puppet::Parser::AST::BlockExpression.new(:children => [])
-          )
-        ]),
-        :doc        => 'mydoc'
-      )
-
-      @code = stub_everything 'code'
-      @code.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).returns(true)
-    end
-
-    it "should register a PuppetResource to the current container" do
-      @code.stubs(:children).returns([ @stmt ])
-
-      @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
-      @parser.scan_for_resource(@class, [ @code ])
-    end
-
-    it "should also scan mono-instruction code" do
-      @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
-
-      @parser.scan_for_resource(@class, @stmt)
-    end
-  end
-
-  describe "when parsing plugins" do
-    before :each do
-      @container = stub 'container'
-    end
-
-    it "should delegate parsing custom facts to parse_facts" do
-      @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/facter/test.rb", nil, Options.instance, RDoc::Stats.new)
-
-      @parser.expects(:parse_fact).with(@container)
-      @parser.parse_plugins(@container)
-    end
-
-    it "should delegate parsing plugins to parse_plugins" do
-      @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/functions/test.rb", nil, Options.instance, RDoc::Stats.new)
-
-      @parser.expects(:parse_puppet_plugin).with(@container)
-      @parser.parse_plugins(@container)
-    end
-  end
-
-  describe "when parsing plugins" do
-    before :each do
-      @container = stub_everything 'container'
-    end
-
-    it "should add custom functions to the container" do
-      File.stubs(:open).yields("# documentation
-      module Puppet::Parser::Functions
-      	newfunction(:myfunc, :type => :rvalue) do |args|
-      		File.dirname(args[0])
-      	end
-      end".split("\n"))
-
-      @container.expects(:add_plugin).with do |plugin|
-        plugin.comment == "documentation\n" #and
-        plugin.name == "myfunc"
-      end
-
-      @parser.parse_puppet_plugin(@container)
-    end
-
-    it "should add custom types to the container" do
-      File.stubs(:open).yields("# documentation
-      Puppet::Type.newtype(:mytype) do
-      end".split("\n"))
-
-      @container.expects(:add_plugin).with do |plugin|
-        plugin.comment == "documentation\n" #and
-        plugin.name == "mytype"
-      end
-
-      @parser.parse_puppet_plugin(@container)
-    end
-  end
-
-  describe "when parsing facts" do
-    before :each do
-      @container = stub_everything 'container'
-      File.stubs(:open).yields(["# documentation", "Facter.add('myfact') do", "confine :kernel => :linux", "end"])
-    end
-
-    it "should add facts to the container" do
-      @container.expects(:add_fact).with do |fact|
-        fact.comment == "documentation\n" and
-        fact.name == "myfact"
-      end
-
-      @parser.parse_fact(@container)
-    end
-
-    it "should add confine to the parsed facts" do
-      ourfact = nil
-      @container.expects(:add_fact).with do |fact|
-        ourfact = fact
-        true
-      end
-
-      @parser.parse_fact(@container)
-      ourfact.confine.should == { :type => "kernel", :value => ":linux" }
-    end
-  end
-end