puppet 4.4.0-universal-darwin

data/spec/unit/application/doc_spec.rb

@@ -0,0 +1,335 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/application/doc'
+require 'puppet/util/reference'
+require 'puppet/util/rdoc'
+
+describe Puppet::Application::Doc do
+  before :each do
+    @doc = Puppet::Application[:doc]
+    @doc.stubs(:puts)
+    @doc.preinit
+    Puppet::Util::Log.stubs(:newdestination)
+  end
+
+  it "should declare an other command" do
+    expect(@doc).to respond_to(:other)
+  end
+
+  it "should declare a rdoc command" do
+    expect(@doc).to respond_to(:rdoc)
+  end
+
+  it "should declare a fallback for unknown options" do
+    expect(@doc).to respond_to(:handle_unknown)
+  end
+
+  it "should declare a preinit block" do
+    expect(@doc).to respond_to(:preinit)
+  end
+
+  describe "in preinit" do
+    it "should set references to []" do
+      @doc.preinit
+
+      expect(@doc.options[:references]).to eq([])
+    end
+
+    it "should init mode to text" do
+      @doc.preinit
+
+      expect(@doc.options[:mode]).to eq(:text)
+    end
+
+    it "should init format to to_markdown" do
+      @doc.preinit
+
+      expect(@doc.options[:format]).to eq(:to_markdown)
+    end
+  end
+
+  describe "when handling options" do
+    [:all, :outputdir, :verbose, :debug, :charset].each do |option|
+      it "should declare handle_#{option} method" do
+        expect(@doc).to respond_to("handle_#{option}".to_sym)
+      end
+
+      it "should store argument value when calling handle_#{option}" do
+        @doc.options.expects(:[]=).with(option, 'arg')
+        @doc.send("handle_#{option}".to_sym, 'arg')
+      end
+    end
+
+    it "should store the format if valid" do
+      Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(true)
+
+      @doc.handle_format('format')
+      expect(@doc.options[:format]).to eq('to_format')
+    end
+
+    it "should raise an error if the format is not valid" do
+      Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(false)
+      expect { @doc.handle_format('format') }.to raise_error(RuntimeError, /Invalid output format/)
+    end
+
+    it "should store the mode if valid" do
+      Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
+
+      @doc.handle_mode('mode')
+      expect(@doc.options[:mode]).to eq(:mode)
+    end
+
+    it "should store the mode if :rdoc" do
+      Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
+
+      @doc.handle_mode('rdoc')
+      expect(@doc.options[:mode]).to eq(:rdoc)
+    end
+
+    it "should raise an error if the mode is not valid" do
+      Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
+      expect { @doc.handle_mode('unknown') }.to raise_error(RuntimeError, /Invalid output mode/)
+    end
+
+    it "should list all references on list and exit" do
+      reference = stubs 'reference'
+      ref = stubs 'ref'
+      Puppet::Util::Reference.stubs(:references).returns([reference])
+
+      Puppet::Util::Reference.expects(:reference).with(reference).returns(ref)
+      ref.expects(:doc)
+
+      expect { @doc.handle_list(nil) }.to exit_with 0
+    end
+
+    it "should add reference to references list with --reference" do
+      @doc.options[:references] = [:ref1]
+
+      @doc.handle_reference('ref2')
+
+      expect(@doc.options[:references]).to eq([:ref1,:ref2])
+    end
+  end
+
+  describe "during setup" do
+
+    before :each do
+      Puppet::Log.stubs(:newdestination)
+      @doc.command_line.stubs(:args).returns([])
+    end
+
+    it "should default to rdoc mode if there are command line arguments" do
+      @doc.command_line.stubs(:args).returns(["1"])
+      @doc.stubs(:setup_rdoc)
+
+      @doc.setup
+      expect(@doc.options[:mode]).to eq(:rdoc)
+    end
+
+    it "should call setup_rdoc in rdoc mode" do
+      @doc.options[:mode] = :rdoc
+
+      @doc.expects(:setup_rdoc)
+
+      @doc.setup
+    end
+
+    it "should call setup_reference if not rdoc" do
+      @doc.options[:mode] = :test
+
+      @doc.expects(:setup_reference)
+
+      @doc.setup
+    end
+
+    describe "configuring logging" do
+      before :each do
+        Puppet::Util::Log.stubs(:newdestination)
+      end
+
+      describe "with --debug" do
+        before do
+          @doc.options[:debug] = true
+        end
+
+        it "should set log level to debug" do
+          @doc.setup
+          expect(Puppet::Util::Log.level).to eq(:debug)
+        end
+
+        it "should set log destination to console" do
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+          @doc.setup
+        end
+      end
+
+      describe "with --verbose" do
+        before do
+          @doc.options[:verbose] = true
+        end
+
+        it "should set log level to info" do
+          @doc.setup
+          expect(Puppet::Util::Log.level).to eq(:info)
+        end
+
+        it "should set log destination to console" do
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+          @doc.setup
+        end
+      end
+
+      describe "without --debug or --verbose" do
+        before do
+          @doc.options[:debug] = false
+          @doc.options[:verbose] = false
+        end
+
+        it "should set log level to warning" do
+          @doc.setup
+          expect(Puppet::Util::Log.level).to eq(:warning)
+        end
+
+        it "should set log destination to console" do
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+          @doc.setup
+        end
+      end
+    end
+
+    describe "in non-rdoc mode" do
+      it "should get all non-dynamic reference if --all" do
+        @doc.options[:all] = true
+        static = stub 'static', :dynamic? => false
+        dynamic = stub 'dynamic', :dynamic? => true
+        Puppet::Util::Reference.stubs(:reference).with(:static).returns(static)
+        Puppet::Util::Reference.stubs(:reference).with(:dynamic).returns(dynamic)
+        Puppet::Util::Reference.stubs(:references).returns([:static,:dynamic])
+
+        @doc.setup_reference
+        expect(@doc.options[:references]).to eq([:static])
+      end
+
+      it "should default to :type if no references" do
+        @doc.setup_reference
+        expect(@doc.options[:references]).to eq([:type])
+      end
+    end
+
+    describe "in rdoc mode" do
+      describe "when there are unknown args" do
+        it "should expand --modulepath if any" do
+          @doc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
+          Puppet.settings.stubs(:handlearg)
+
+          @doc.setup_rdoc
+
+          expect(@doc.unknown_args[0][:arg]).to eq(File.expand_path('path'))
+        end
+
+        it "should give them to Puppet.settings" do
+          @doc.unknown_args = [ { :opt => :option, :arg => :argument } ]
+          Puppet.settings.expects(:handlearg).with(:option,:argument)
+
+          @doc.setup_rdoc
+        end
+      end
+
+      it "should operate in master run_mode" do
+        expect(@doc.class.run_mode.name).to eq(:master)
+
+        @doc.setup_rdoc
+      end
+    end
+  end
+
+  describe "when running" do
+    describe "in rdoc mode" do
+      include PuppetSpec::Files
+
+      let(:envdir) { tmpdir('env') }
+      let(:modules) { File.join(envdir, "modules") }
+      let(:modules2) { File.join(envdir, "modules2") }
+      let(:manifests) { File.join(envdir, "manifests") }
+
+      before :each do
+        @doc.manifest = false
+        Puppet.stubs(:info)
+        Puppet[:trace] = false
+        Puppet[:modulepath] = modules
+        Puppet[:manifest] = manifests
+        @doc.options[:all] = false
+        @doc.options[:outputdir] = 'doc'
+        @doc.options[:charset] = nil
+        Puppet.settings.stubs(:define_settings)
+        Puppet::Util::RDoc.stubs(:rdoc)
+        @doc.command_line.stubs(:args).returns([])
+      end
+
+      around(:each) do |example|
+        FileUtils.mkdir_p(modules)
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
+          example.run
+        end
+      end
+
+      it "should set document_all on --all" do
+        @doc.options[:all] = true
+        Puppet.settings.expects(:[]=).with(:document_all, true)
+
+        expect { @doc.rdoc }.to exit_with(0)
+      end
+
+      it "should call Puppet::Util::RDoc.rdoc in full mode" do
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
+        expect { @doc.rdoc }.to exit_with(0)
+      end
+
+      it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
+        @doc.options[:charset] = 'utf-8'
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], "utf-8")
+        expect { @doc.rdoc }.to exit_with(0)
+      end
+
+      it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
+        @doc.options[:outputdir] = false
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
+        expect { @doc.rdoc }.to exit_with(0)
+      end
+
+      it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
+        @doc.manifest = true
+        Puppet::Util::RDoc.expects(:manifestdoc)
+        expect { @doc.rdoc }.to exit_with(0)
+      end
+
+      it "should get modulepath and manifest values from the environment" do
+        FileUtils.mkdir_p(modules)
+        FileUtils.mkdir_p(modules2)
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym,
+          [modules, modules2],
+          "envmanifests/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
+           Puppet::Util::RDoc.stubs(:rdoc).with('doc', [modules.to_s, modules2.to_s, env.manifest.to_s], nil)
+          expect { @doc.rdoc }.to exit_with(0)
+        end
+      end
+    end
+
+    describe "in the other modes" do
+      it "should get reference in given format" do
+        reference = stub 'reference'
+        @doc.options[:mode] = :none
+        @doc.options[:references] = [:ref]
+        Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
+        @doc.options[:format] = :format
+        @doc.stubs(:exit)
+
+        reference.expects(:send).with { |format,contents| format == :format }.returns('doc')
+        @doc.other
+      end
+    end
+  end
+end

data/spec/unit/application/face_base_spec.rb

@@ -0,0 +1,437 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/application/face_base'
+require 'tmpdir'
+
+class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
+end
+
+describe Puppet::Application::FaceBase do
+  let :app do
+    app = Puppet::Application::FaceBase::Basetest.new
+    app.command_line.stubs(:subcommand_name).returns('subcommand')
+    Puppet::Util::Log.stubs(:newdestination)
+    app
+  end
+
+  after :each do
+    app.class.clear_everything_for_tests
+  end
+
+  describe "#find_global_settings_argument" do
+    it "should not match --ca to --ca-location" do
+      option = mock('ca option', :optparse_args => ["--ca"])
+      Puppet.settings.expects(:each).yields(:ca, option)
+
+      expect(app.find_global_settings_argument("--ca-location")).to be_nil
+    end
+  end
+
+  describe "#parse_options" do
+    before :each do
+      app.command_line.stubs(:args).returns %w{}
+    end
+
+    describe "with just an action" do
+      before(:each) do
+        # We have to stub Signal.trap to avoid a crazy mess where we take
+        # over signal handling and make it impossible to cancel the test
+        # suite run.
+        #
+        # It would be nice to fix this elsewhere, but it is actually hard to
+        # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
+        Signal.stubs(:trap)
+        app.command_line.stubs(:args).returns %w{foo}
+        app.preinit
+        app.parse_options
+      end
+
+      it "should set the face based on the type" do
+        expect(app.face.name).to eq(:basetest)
+      end
+
+      it "should find the action" do
+        expect(app.action).to be
+        expect(app.action.name).to eq(:foo)
+      end
+    end
+
+    it "should stop if the first thing found is not an action" do
+      app.command_line.stubs(:args).returns %w{banana count_args}
+
+      expect { app.run }.to exit_with(1)
+
+      expect(@logs.map(&:message)).to eq(["'basetest' has no 'banana' action.  See `puppet help basetest`."])
+    end
+
+    it "should use the default action if not given any arguments" do
+      app.command_line.stubs(:args).returns []
+      action = stub(:options => [], :render_as => nil)
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      expect(app.action).to eq(action)
+      expect(app.arguments).to eq([ { } ])
+    end
+
+    it "should use the default action if not given a valid one" do
+      app.command_line.stubs(:args).returns %w{bar}
+      action = stub(:options => [], :render_as => nil)
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      expect(app.action).to eq(action)
+      expect(app.arguments).to eq([ 'bar', { } ])
+    end
+
+    it "should have no action if not given a valid one and there is no default action" do
+      app.command_line.stubs(:args).returns %w{bar}
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+      app.stubs(:main)
+      expect { app.run }.to exit_with(1)
+      expect(@logs.first.message).to match(/has no 'bar' action./)
+    end
+
+    [%w{something_I_cannot_do},
+     %w{something_I_cannot_do argument}].each do |input|
+      it "should report unknown actions nicely" do
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(:main)
+        expect { app.run }.to exit_with(1)
+        expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
+      end
+    end
+
+    [%w{something_I_cannot_do --unknown-option},
+     %w{something_I_cannot_do argument --unknown-option}].each do |input|
+      it "should report unknown actions even if there are unknown options" do
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(:main)
+        expect { app.run }.to exit_with(1)
+        expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
+      end
+    end
+
+    it "should report a sensible error when options with = fail" do
+      app.command_line.stubs(:args).returns %w{--action=bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
+    end
+
+    it "should fail if an action option is before the action" do
+      app.command_line.stubs(:args).returns %w{--action foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
+    end
+
+    it "should fail if an unknown option is before the action" do
+      app.command_line.stubs(:args).returns %w{--bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
+    end
+
+    it "should fail if an unknown option is after the action" do
+      app.command_line.stubs(:args).returns %w{foo --bar}
+      expect { app.preinit; app.parse_options }.
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
+    end
+
+    it "should accept --bar as an argument to a mandatory option after action" do
+      app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
+    end
+
+    it "should accept --bar as an argument to a mandatory option before action" do
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
+    end
+
+    it "should not skip when --foo=bar is given" do
+      app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
+    end
+
+    it "does not skip when a puppet global setting is given as one item" do
+      app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "does not skip when a puppet global setting is given as two items" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :debug to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --debug}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :verbose to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --verbose}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    { "boolean options before" => %w{--trace foo},
+      "boolean options after"  => %w{foo --trace}
+    }.each do |name, args|
+      it "should accept global boolean settings #{name} the action" do
+        app.command_line.stubs(:args).returns args
+        Puppet.settings.initialize_global_settings(args)
+        app.preinit
+        app.parse_options
+        expect(Puppet[:trace]).to be_truthy
+      end
+    end
+
+    { "before" => %w{--syslogfacility user1 foo},
+      " after" => %w{foo --syslogfacility user1}
+    }.each do |name, args|
+      it "should accept global settings with arguments #{name} the action" do
+        app.command_line.stubs(:args).returns args
+        Puppet.settings.initialize_global_settings(args)
+        app.preinit
+        app.parse_options
+        expect(Puppet[:syslogfacility]).to eq("user1")
+      end
+    end
+
+    it "should handle application-level options" do
+      app.command_line.stubs(:args).returns %w{--verbose return_true}
+      app.preinit
+      app.parse_options
+      expect(app.face.name).to eq(:basetest)
+    end
+  end
+
+  describe "#setup" do
+    it "should remove the action name from the arguments" do
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      app.preinit
+      app.parse_options
+      app.setup
+      expect(app.arguments).to eq([{ :mandatory => "--bar" }])
+    end
+
+    it "should pass positional arguments" do
+      myargs = %w{--mandatory --bar foo bar baz quux}
+      app.command_line.stubs(:args).returns(myargs)
+      app.preinit
+      app.parse_options
+      app.setup
+      expect(app.arguments).to eq(['bar', 'baz', 'quux', { :mandatory => "--bar" }])
+    end
+  end
+
+  describe "#main" do
+    before :each do
+      app.stubs(:puts)          # don't dump text to screen.
+
+      app.face      = Puppet::Face[:basetest, '0.0.1']
+      app.action    = app.face.get_action(:foo)
+      app.arguments = ["myname", "myarg"]
+    end
+
+    it "should send the specified verb and name to the face" do
+      app.face.expects(:foo).with(*app.arguments)
+      expect { app.main }.to exit_with(0)
+    end
+
+    it "should lookup help when it cannot do anything else" do
+      app.action = nil
+      Puppet::Face[:help, :current].expects(:help).with(:basetest)
+      expect { app.main }.to exit_with(1)
+    end
+
+    it "should use its render method to render any result" do
+      app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
+      expect { app.main }.to exit_with(0)
+    end
+  end
+
+  describe "error reporting" do
+    before :each do
+      app.stubs(:puts)          # don't dump text to screen.
+
+      app.render_as = :json
+      app.face      = Puppet::Face[:basetest, '0.0.1']
+      app.arguments = [{}]      # we always have options in there...
+    end
+
+    it "should exit 0 when the action returns true" do
+      app.action    = app.face.get_action :return_true
+      expect { app.main }.to exit_with(0)
+    end
+
+    it "should exit 0 when the action returns false" do
+      app.action = app.face.get_action :return_false
+      expect { app.main }.to exit_with(0)
+    end
+
+    it "should exit 0 when the action returns nil" do
+      app.action = app.face.get_action :return_nil
+      expect { app.main }.to exit_with(0)
+    end
+
+    it "should exit non-0 when the action raises" do
+      app.action = app.face.get_action :return_raise
+      expect { app.main }.not_to exit_with(0)
+    end
+
+    it "should use the exit code set by the action" do
+      app.action = app.face.get_action :with_specific_exit_code
+      expect { app.main }.to exit_with(5)
+    end
+  end
+
+  describe "#render" do
+    before :each do
+      app.face      = Puppet::Interface.new('basetest', '0.0.1')
+      app.action    = Puppet::Interface::Action.new(app.face, :foo)
+    end
+
+    context "default rendering" do
+      before :each do app.setup end
+
+      ["hello", 1, 1.0].each do |input|
+        it "should just return a #{input.class.name}" do
+          expect(app.render(input, {})).to eq(input)
+        end
+      end
+
+      [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
+        it "should render Array as one item per line" do
+          expect(app.render(input, {})).to eq(input.collect { |item| item.to_s + "\n" }.join(''))
+        end
+      end
+
+      it "should render a non-trivially-keyed Hash with using pretty printed PSON" do
+        hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
+        expect(app.render(hash, {})).to eq(PSON.pretty_generate(hash).chomp)
+      end
+
+      it "should render a {String,Numeric}-keyed Hash into a table" do
+        object = Object.new
+        hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
+          5 => 5, 6.0 => 6 }
+
+        # Gotta love ASCII-betical sort order.  Hope your objects are better
+        # structured for display than my test one is. --daniel 2011-04-18
+        expect(app.render(hash, {})).to eq <<EOT
+5      5
+6.0    6
+four   #{object.to_pson.chomp}
+one    1
+three  {}
+two    []
+EOT
+      end
+
+      it "should render a hash nicely with a multi-line value" do
+        pending "Moving to PSON rather than PP makes this unsupportable."
+        hash = {
+          "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
+          "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
+        }
+        expect(app.render(hash, {})).to eq <<EOT
+number  {"1"=>"1111111111111111111111111111111111111111",
+         "2"=>"2222222222222222222222222222222222222222",
+         "3"=>"3333333333333333333333333333333333333333"}
+text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+         "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+         "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
+EOT
+      end
+
+      describe "when setting the rendering method" do
+        after do
+          # need to reset the when_rendering block so that other tests can set it later
+          app.action.instance_variable_set("@when_rendering", {})
+        end
+
+        it "should invoke the action rendering hook while rendering" do
+          app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
+          expect(app.render("bi-polar?", {})).to eq("bi-winning!")
+        end
+
+        it "should invoke the action rendering hook with args and options while rendering" do
+          app.action.instance_variable_set("@when_rendering", {})
+          app.action.when_invoked = proc { |name, options| 'just need to match arity for rendering' }
+          app.action.set_rendering_method_for(
+            :console,
+            proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
+          )
+          expect(app.render("bi-polar?", ['bob', {:altername => 'sue'}])).to eq("I'm bob, no wait, I'm sue")
+        end
+      end
+
+      it "should render JSON when asked for json" do
+        app.render_as = :json
+        json = app.render({ :one => 1, :two => 2 }, {})
+        expect(json).to match(/"one":\s*1\b/)
+        expect(json).to match(/"two":\s*2\b/)
+        expect(PSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
+      end
+    end
+
+    it "should fail early if asked to render an invalid format" do
+      app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
+      # We shouldn't get here, thanks to the exception, and our expectation on
+      # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
+      Puppet::Face[:help, :current].expects(:help).never
+
+      Puppet.expects(:err).with("Could not parse application options: I don't know how to render 'interpretive-dance'")
+
+      expect { app.run }.to exit_with(1)
+    end
+
+    it "should work if asked to render a NetworkHandler format" do
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as pson}
+      expect {
+        expect { app.run }.to exit_with(0)
+      }.to have_printed(/3/)
+    end
+
+    it "should invoke when_rendering hook 's' when asked to render-as 's'" do
+      app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
+      app.action = app.face.get_action(:with_s_rendering_hook)
+      expect {
+        expect { app.run }.to exit_with(0)
+      }.to have_printed(/you invoked the 's' rendering hook/)
+    end
+  end
+
+  describe "#help" do
+    it "should generate help for --help" do
+      app.command_line.stubs(:args).returns %w{--help}
+      Puppet::Face[:help, :current].expects(:help)
+      expect { app.run }.to exit_with(0)
+    end
+
+    it "should generate help for -h" do
+      app.command_line.stubs(:args).returns %w{-h}
+      Puppet::Face[:help, :current].expects(:help)
+      expect { app.run }.to exit_with(0)
+    end
+  end
+end