puppet 3.5.0.rc1-x86-mingw32

data/spec/unit/util/profiler/logging_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+
+describe Puppet::Util::Profiler::Logging do
+  let(:logger) { SimpleLog.new }
+  let(:identifier) { "Profiling ID" }
+  let(:profiler) { TestLoggingProfiler.new(logger, identifier) }
+
+  it "returns the value of the profiled segment" do
+    retval = profiler.profile("Testing") { "the return value" }
+
+    retval.should == "the return value"
+  end
+
+  it "propogates any errors raised in the profiled segment" do
+    expect do
+      profiler.profile("Testing") { raise "a problem" }
+    end.to raise_error("a problem")
+  end
+
+  it "logs the explanation of the profile results" do
+    profiler.profile("Testing") { }
+
+    logger.messages.first.should =~ /the explanation/
+  end
+
+  it "logs results even when an error is raised" do
+    begin
+      profiler.profile("Testing") { raise "a problem" }
+    rescue
+      logger.messages.first.should =~ /the explanation/
+    end
+  end
+
+  it "describes the profiled segment" do
+    profiler.profile("Tested measurement") { }
+
+    logger.messages.first.should =~ /PROFILE \[#{identifier}\] \d Tested measurement/
+  end
+
+  it "indicates the order in which segments are profiled" do
+    profiler.profile("Measurement") { }
+    profiler.profile("Another measurement") { }
+
+    logger.messages[0].should =~ /1 Measurement/
+    logger.messages[1].should =~ /2 Another measurement/
+  end
+
+  it "indicates the nesting of profiled segments" do
+    profiler.profile("Measurement") { profiler.profile("Nested measurement") { } }
+    profiler.profile("Another measurement") { profiler.profile("Another nested measurement") { } }
+
+    logger.messages[0].should =~ /1.1 Nested measurement/
+    logger.messages[1].should =~ /1 Measurement/
+    logger.messages[2].should =~ /2.1 Another nested measurement/
+    logger.messages[3].should =~ /2 Another measurement/
+  end
+
+  class TestLoggingProfiler < Puppet::Util::Profiler::Logging
+    def start
+      "the start"
+    end
+
+    def finish(context)
+      "the explanation of #{context}"
+    end
+  end
+
+  class SimpleLog
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+
+    def call(msg)
+      @messages << msg
+    end
+  end
+end
+

data/spec/unit/util/profiler/none_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+
+describe Puppet::Util::Profiler::None do
+  let(:profiler) { Puppet::Util::Profiler::None.new }
+
+  it "returns the value of the profiled block" do
+    retval = profiler.profile("Testing") { "the return value" }
+
+    retval.should == "the return value"
+  end
+end

data/spec/unit/util/profiler/object_counts_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+
+describe Puppet::Util::Profiler::ObjectCounts do
+  it "reports the changes in the system object counts" do
+    pending("Can only count objects on ruby 1.9 or greater", :if => RUBY_VERSION < '1.9') do
+      profiler = Puppet::Util::Profiler::ObjectCounts.new(nil, nil)
+
+      message = profiler.finish(profiler.start)
+
+      message.should =~ / T_STRING: \d+, /
+    end
+  end
+end

data/spec/unit/util/profiler/wall_clock_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+
+describe Puppet::Util::Profiler::WallClock do
+
+  it "logs the number of seconds it took to execute the segment" do
+    profiler = Puppet::Util::Profiler::WallClock.new(nil, nil)
+
+    message = profiler.finish(profiler.start)
+
+    message.should =~ /took \d\.\d{4} seconds/
+  end
+end

data/spec/unit/util/pson_spec.rb

@@ -0,0 +1,71 @@
+#! /usr/bin/env ruby
+# Encoding: UTF-8
+require 'spec_helper'
+
+require 'puppet/util/pson'
+
+class PsonUtil
+  include Puppet::Util::Pson
+end
+
+describe Puppet::Util::Pson do
+  it "should fail if no data is provided" do
+    expect {
+      PsonUtil.new.pson_create("type" => "foo")
+    }.to raise_error(ArgumentError, /No data provided in pson data/)
+  end
+
+  it "should call 'from_data_hash' with the provided data" do
+    pson = PsonUtil.new
+    pson.expects(:from_data_hash).with("mydata")
+    pson.pson_create("type" => "foo", "data" => "mydata")
+  end
+
+  {
+    'foo' => '"foo"',
+    1 => '1',
+    "\x80" => "\"\x80\"",
+    [] => '[]'
+  }.each do |str, expect|
+    it "should be able to encode #{str.inspect}" do
+      got = str.to_pson
+      if got.respond_to? :force_encoding
+        got.force_encoding('binary').should == expect.force_encoding('binary')
+      else
+        got.should == expect
+      end
+    end
+  end
+
+  it "should be able to handle arbitrary binary data" do
+    bin_string = (1..20000).collect { |i| ((17*i+13*i*i) % 255).chr }.join
+    parsed = PSON.parse(%Q{{ "type": "foo", "data": #{bin_string.to_pson} }})["data"]
+
+    if parsed.respond_to? :force_encoding
+      parsed.force_encoding('binary')
+      bin_string.force_encoding('binary')
+    end
+
+    parsed.should == bin_string
+  end
+
+  it "should be able to handle UTF8 that isn't a real unicode character" do
+    s = ["\355\274\267"]
+    PSON.parse( [s].to_pson ).should == [s]
+  end
+
+  it "should be able to handle UTF8 for \\xFF" do
+    s = ["\xc3\xbf"]
+    PSON.parse( [s].to_pson ).should == [s]
+  end
+
+  it "should be able to handle invalid UTF8 bytes" do
+    s = ["\xc3\xc3"]
+    PSON.parse( [s].to_pson ).should == [s]
+  end
+
+  it "should be able to parse JSON containing UTF-8 characters in strings" do
+    s = '{ "foö": "bár" }'
+    lambda { PSON.parse s }.should_not raise_error
+  end
+end

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

@@ -0,0 +1,137 @@
+#! /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

@@ -0,0 +1,95 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/util/queue'
+require 'spec/mocks'
+
+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

@@ -0,0 +1,599 @@
+#! /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
+    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 = stub 'env'
+      Puppet::Node::Environment.stubs(:new).returns(env)
+      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