puppet 0.24.9 → 0.25.0

data/spec/unit/application/puppetdoc.rb

@@ -0,0 +1,345 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/application/puppetdoc'
+
+describe "puppetdoc" do
+    before :each do
+        @puppetdoc = Puppet::Application[:puppetdoc]
+        @puppetdoc.stubs(:puts)
+        @puppetdoc.run_preinit
+        Puppet::Util::Log.stubs(:newdestination)
+        Puppet::Util::Log.stubs(:level=)
+    end
+
+    it "should ask Puppet::Application to not parse Puppet configuration file" do
+        @puppetdoc.should_parse_config?.should be_false
+    end
+
+    it "should declare a other command" do
+        @puppetdoc.should respond_to(:other)
+    end
+
+    it "should declare a rdoc command" do
+        @puppetdoc.should respond_to(:rdoc)
+    end
+
+    it "should declare a trac command" do
+        @puppetdoc.should respond_to(:trac)
+    end
+
+    it "should declare a fallback for unknown options" do
+        @puppetdoc.should respond_to(:handle_unknown)
+    end
+
+    it "should declare a preinit block" do
+        @puppetdoc.should respond_to(:run_preinit)
+    end
+
+    describe "in preinit" do
+        it "should set references to []" do
+            @puppetdoc.run_preinit
+
+            @puppetdoc.options[:references].should == []
+        end
+
+        it "should init mode to text" do
+            @puppetdoc.run_preinit
+
+            @puppetdoc.options[:mode].should == :text
+        end
+
+        it "should init format to to_rest" do
+            @puppetdoc.run_preinit
+
+            @puppetdoc.options[:format].should == :to_rest
+        end
+    end
+
+    describe "when handling options" do
+        [:all, :outputdir, :verbose, :debug].each do |option|
+            it "should declare handle_#{option} method" do
+                @puppetdoc.should respond_to("handle_#{option}".to_sym)
+            end
+
+            it "should store argument value when calling handle_#{option}" do
+                @puppetdoc.options.expects(:[]=).with(option, 'arg')
+                @puppetdoc.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)
+
+            @puppetdoc.options.expects(:[]=).with(:format, 'to_format')
+
+            @puppetdoc.handle_format('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)
+            lambda { @puppetdoc.handle_format('format') }
+        end
+
+        it "should store the mode if valid" do
+            Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
+
+            @puppetdoc.options.expects(:[]=).with(:mode, :mode)
+
+            @puppetdoc.handle_mode('mode')
+        end
+
+        it "should store the mode if :rdoc" do
+            Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
+
+            @puppetdoc.options.expects(:[]=).with(:mode, :rdoc)
+
+            @puppetdoc.handle_mode('rdoc')
+        end
+
+        it "should raise an error if the mode is not valid" do
+            Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
+            lambda { @puppetdoc.handle_mode('unknown') }
+        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)
+            @puppetdoc.expects(:exit)
+
+            @puppetdoc.handle_list(nil)
+        end
+
+        it "should add reference to references list with --reference" do
+            @puppetdoc.options[:references] = [:ref1]
+
+            @puppetdoc.handle_reference('ref2')
+
+            @puppetdoc.options[:references].should == [:ref1,:ref2]
+        end
+    end
+
+    describe "during setup" do
+
+        before :each do
+            Puppet::Log.stubs(:newdestination)
+            ARGV.stubs(:size).returns(0)
+        end
+
+        it "should default to rdoc mode if there are command line arguments" do
+            ARGV.stubs(:size).returns(1)
+            @puppetdoc.stubs(:setup_rdoc)
+
+            @puppetdoc.options.expects(:[]=).with(:mode,:rdoc)
+
+            @puppetdoc.run_setup
+        end
+
+        it "should call setup_rdoc in rdoc mode" do
+            @puppetdoc.options.stubs(:[]).with(:mode).returns(:rdoc)
+
+            @puppetdoc.expects(:setup_rdoc)
+
+            @puppetdoc.run_setup
+        end
+
+        it "should call setup_reference if not rdoc" do
+            @puppetdoc.options.stubs(:[]).with(:mode).returns(:test)
+
+            @puppetdoc.expects(:setup_reference)
+
+            @puppetdoc.run_setup
+        end
+
+        describe "in non-rdoc mode" do
+
+            it "should get all non-dynamic reference if --all" do
+                @puppetdoc.options.stubs(:[]).with(:all).returns(true)
+                @puppetdoc.options.stubs(:[]).with(:references).returns([])
+                static = stub 'static', :dynamic? => false
+                dynamic = stub 'dynamic', :dynamic? => true
+                Reference.stubs(:reference).with(:static).returns(static)
+                Reference.stubs(:reference).with(:dynamic).returns(dynamic)
+                Reference.stubs(:references).returns([:static,:dynamic])
+
+                @puppetdoc.options.stubs(:[]=).with(:references, [:static])
+
+                @puppetdoc.setup_reference
+            end
+
+            it "should default to :type if no references" do
+                @puppetdoc.options.stubs(:[]).with(:all).returns(false)
+                array = stub 'array', :empty? => true
+                @puppetdoc.options.stubs(:[]).with(:references).returns(array)
+
+                array.expects(:<<).with(:type)
+
+                @puppetdoc.setup_reference
+            end
+
+        end
+
+        describe "in rdoc mode" do
+
+            before :each do
+                @puppetdoc.options.stubs(:[]).returns(false)
+                Puppet.stubs(:[]=).with(:name, "puppetmasterd")
+                Puppet.stubs(:parse_config)
+                Puppet::Util::Log.stubs(:level=)
+                Puppet::Util::Log.stubs(:newdestination)
+            end
+
+            describe "when there are unknown args" do
+
+                it "should expand --modulepath if any" do
+                    @puppetdoc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
+                    Puppet.settings.stubs(:handlearg)
+
+                    File.expects(:expand_path).with("path")
+
+                    @puppetdoc.setup_rdoc
+                end
+
+                it "should expand --manifestdir if any" do
+                    @puppetdoc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
+                    Puppet.settings.stubs(:handlearg)
+
+                    File.expects(:expand_path).with("path")
+
+                    @puppetdoc.setup_rdoc
+                end
+
+                it "should give them to Puppet.settings" do
+                    @puppetdoc.unknown_args = [ { :opt => :option, :arg => :argument } ]
+                    Puppet.settings.expects(:handlearg).with(:option,:argument)
+
+                    @puppetdoc.setup_rdoc
+                end
+            end
+
+            it "should pretend to be puppetmasterd" do
+                Puppet.expects(:[]=).with(:name, "puppetmasterd")
+
+                @puppetdoc.setup_rdoc
+            end
+
+            it "should parse puppet configuration" do
+                Puppet.expects(:parse_config)
+
+                @puppetdoc.setup_rdoc
+            end
+
+            it "should set log level to debug if --debug" do
+                @puppetdoc.options.stubs(:[]).with(:debug).returns(true)
+                Puppet::Util::Log.expects(:level=).with(:debug)
+
+                @puppetdoc.setup_rdoc
+            end
+
+            it "should set log level to info if --verbose" do
+                @puppetdoc.options.stubs(:[]).with(:verbose).returns(true)
+                Puppet::Util::Log.expects(:level=).with(:info)
+
+                @puppetdoc.setup_rdoc
+            end
+
+            it "should set log destination to console if --verbose" do
+                @puppetdoc.options.stubs(:[]).with(:verbose).returns(true)
+
+                Puppet::Util::Log.expects(:newdestination).with(:console)
+
+                @puppetdoc.setup_rdoc
+            end
+
+            it "should set log destination to console if --debug" do
+                @puppetdoc.options.stubs(:[]).with(:debug).returns(true)
+
+                Puppet::Util::Log.expects(:newdestination).with(:console)
+
+                @puppetdoc.setup_rdoc
+            end
+
+        end
+
+    end
+
+    describe "when running" do
+        before :each do
+        end
+
+        describe "in trac mode" do
+            it "should call trac for each reference" do
+                ref = stub 'ref'
+                Puppet::Util::Reference.stubs(:reference).with(:ref).returns(ref)
+                @puppetdoc.options.stubs(:[]).with(:references).returns([:ref])
+                @puppetdoc.options.stubs(:[]).with(:mode).returns(:trac)
+
+                ref.expects(:trac)
+
+                @puppetdoc.trac
+            end
+        end
+
+        describe "in rdoc mode" do
+            before :each do
+                @puppetdoc.manifest = false
+                Puppet.stubs(:info)
+                Puppet.stubs(:[]).with(:trace).returns(false)
+                Puppet.stubs(:[]).with(:modulepath).returns('modules')
+                Puppet.stubs(:[]).with(:manifestdir).returns('manifests')
+                @puppetdoc.options.stubs(:[]).with(:all).returns(false)
+                @puppetdoc.options.stubs(:[]).with(:outputdir).returns('doc')
+                Puppet.settings.stubs(:[]=).with(:document_all, false)
+                Puppet.settings.stubs(:setdefaults)
+                Puppet::Util::RDoc.stubs(:rdoc)
+                @puppetdoc.stubs(:exit)
+                File.stubs(:expand_path).with('modules').returns('modules')
+                File.stubs(:expand_path).with('manifests').returns('manifests')
+                @old = ARGV.dup
+                ARGV.clear
+            end
+
+            after :each do
+                ARGV << @old
+            end
+
+            it "should set document_all on --all" do
+                @puppetdoc.options.expects(:[]).with(:all).returns(true)
+                Puppet.settings.expects(:[]=).with(:document_all, true)
+
+                @puppetdoc.rdoc
+            end
+
+            it "should call Puppet::Util::RDoc.rdoc in full mode" do
+                Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'])
+                @puppetdoc.rdoc
+            end
+
+            it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
+                @puppetdoc.manifest = true
+                Puppet::Util::RDoc.expects(:manifestdoc)
+                @puppetdoc.rdoc
+            end
+        end
+
+        describe "in the other modes" do
+            it "should get reference in given format" do
+                reference = stub 'reference'
+                @puppetdoc.options.stubs(:[]).with(:mode).returns(:none)
+                @puppetdoc.options.stubs(:[]).with(:references).returns([:ref])
+                Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
+                @puppetdoc.options.stubs(:[]).with(:format).returns(:format)
+                @puppetdoc.stubs(:exit)
+
+                reference.expects(:send).with { |format,contents| format == :format }.returns('doc')
+                @puppetdoc.other
+            end
+        end
+
+    end
+end

data/spec/unit/application/puppetmasterd.rb

@@ -0,0 +1,456 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/application/puppetmasterd'
+
+describe "PuppetMaster" do
+    before :each do
+        @puppetmasterd = Puppet::Application[:puppetmasterd]
+        @daemon = stub_everything 'daemon'
+        Puppet::Daemon.stubs(:new).returns(@daemon)
+        Puppet::Util::Log.stubs(:newdestination)
+        Puppet::Util::Log.stubs(:level=)
+
+        Puppet::Node.stubs(:terminus_class=)
+        Puppet::Node.stubs(:cache_class=)
+        Puppet::Node::Facts.stubs(:terminus_class=)
+        Puppet::Node::Facts.stubs(:cache_class=)
+        Puppet::Transaction::Report.stubs(:terminus_class=)
+        Puppet::Resource::Catalog.stubs(:terminus_class=)
+    end
+
+    it "should ask Puppet::Application to parse Puppet configuration file" do
+        @puppetmasterd.should_parse_config?.should be_true
+    end
+
+    it "should declare a main command" do
+        @puppetmasterd.should respond_to(:main)
+    end
+
+    it "should declare a parseonly command" do
+        @puppetmasterd.should respond_to(:parseonly)
+    end
+
+    it "should declare a compile command" do
+        @puppetmasterd.should respond_to(:compile)
+    end
+
+    it "should declare a preinit block" do
+        @puppetmasterd.should respond_to(:run_preinit)
+    end
+
+    describe "during preinit" do
+        before :each do
+            @puppetmasterd.stubs(:trap)
+        end
+
+        it "should catch INT" do
+            @puppetmasterd.stubs(:trap).with { |arg,block| arg == :INT }
+
+            @puppetmasterd.run_preinit
+        end
+
+        it "should create a Puppet Daemon" do
+            Puppet::Daemon.expects(:new).returns(@daemon)
+
+            @puppetmasterd.run_preinit
+        end
+
+        it "should give ARGV to the Daemon" do
+            argv = stub 'argv'
+            ARGV.stubs(:dup).returns(argv)
+            @daemon.expects(:argv=).with(argv)
+
+            @puppetmasterd.run_preinit
+        end
+
+    end
+
+    [:debug,:verbose].each do |option|
+        it "should declare handle_#{option} method" do
+            @puppetmasterd.should respond_to("handle_#{option}".to_sym)
+        end
+
+        it "should store argument value when calling handle_#{option}" do
+            @puppetmasterd.options.expects(:[]=).with(option, 'arg')
+            @puppetmasterd.send("handle_#{option}".to_sym, 'arg')
+        end
+    end
+
+    describe "when applying options" do
+        before do
+            @old_argv = ARGV.dup
+            ARGV.clear
+        end
+
+        after do
+            ARGV.clear
+            @old_argv.each { |a| ARGV << a }
+        end
+
+        it "should set the log destination with --logdest" do
+            Puppet::Log.expects(:newdestination).with("console")
+
+            @puppetmasterd.handle_logdest("console")
+        end
+
+        it "should put the setdest options to true" do
+            @puppetmasterd.options.expects(:[]=).with(:setdest,true)
+
+            @puppetmasterd.handle_logdest("console")
+        end
+
+        it "should parse the log destination from ARGV" do
+            ARGV << "--logdest" << "/my/file"
+
+            Puppet::Util::Log.expects(:newdestination).with("/my/file")
+
+            @puppetmasterd.parse_options
+        end
+    end
+
+    describe "during setup" do
+
+        before :each do
+            Puppet::Log.stubs(:newdestination)
+            Puppet.stubs(:settraps)
+            Puppet::Log.stubs(:level=)
+            Puppet::SSL::CertificateAuthority.stubs(:instance)
+            Puppet::SSL::CertificateAuthority.stubs(:ca?)
+            Puppet.settings.stubs(:use)
+
+            @puppetmasterd.options.stubs(:[]).with(any_parameters)
+        end
+
+        it "should set log level to debug if --debug was passed" do
+            @puppetmasterd.options.stubs(:[]).with(:debug).returns(true)
+
+            Puppet::Log.expects(:level=).with(:debug)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should set log level to info if --verbose was passed" do
+            @puppetmasterd.options.stubs(:[]).with(:verbose).returns(true)
+
+            Puppet::Log.expects(:level=).with(:info)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should set console as the log destination if no --logdest and --daemonize" do
+            @puppetmasterd.stubs(:[]).with(:daemonize).returns(:false)
+
+            Puppet::Log.expects(:newdestination).with(:syslog)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should set syslog as the log destination if no --logdest and not --daemonize" do
+            Puppet::Log.expects(:newdestination).with(:syslog)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should set syslog as the log destination if --rack" do
+            @puppetmasterd.options.stubs(:[]).with(:rack).returns(:true)
+
+            Puppet::Log.expects(:newdestination).with(:syslog)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should print puppet config if asked to in Puppet config" do
+            @puppetmasterd.stubs(:exit)
+            Puppet.settings.stubs(:print_configs?).returns(true)
+
+            Puppet.settings.expects(:print_configs)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should exit after printing puppet config if asked to in Puppet config" do
+            Puppet.settings.stubs(:print_configs?).returns(true)
+
+            lambda { @puppetmasterd.run_setup }.should raise_error(SystemExit)
+        end
+
+        it "should tell Puppet.settings to use :main,:ssl and :puppetmasterd category" do
+            Puppet.settings.expects(:use).with(:main,:puppetmasterd,:ssl)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should set node facst terminus to yaml" do
+            Puppet::Node::Facts.expects(:terminus_class=).with(:yaml)
+
+            @puppetmasterd.run_setup
+        end
+
+        it "should cache class in yaml" do
+            Puppet::Node.expects(:cache_class=).with(:yaml)
+
+            @puppetmasterd.run_setup
+        end
+
+        describe "with no ca" do
+
+            it "should set the ca_location to none" do
+                Puppet::SSL::Host.expects(:ca_location=).with(:none)
+
+                @puppetmasterd.run_setup
+            end
+
+        end
+
+        describe "with a ca configured" do
+
+            before :each do
+                Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
+            end
+
+            it "should set the ca_location to local" do
+                Puppet::SSL::Host.expects(:ca_location=).with(:local)
+
+                @puppetmasterd.run_setup
+            end
+
+            it "should tell Puppet.settings to use :ca category" do
+                Puppet.settings.expects(:use).with(:ca)
+
+                @puppetmasterd.run_setup
+            end
+
+            it "should instantiate the CertificateAuthority singleton" do
+                Puppet::SSL::CertificateAuthority.expects(:instance)
+
+                @puppetmasterd.run_setup
+            end
+
+
+        end
+
+    end
+
+    describe "when running" do
+
+        it "should dispatch to parseonly if parseonly is set" do
+            Puppet.stubs(:[]).with(:parseonly).returns(true)
+
+            @puppetmasterd.get_command.should == :parseonly
+        end
+
+        it "should dispatch to compile if called with --compile" do
+            @puppetmasterd.options[:node] = "foo"
+            @puppetmasterd.get_command.should == :compile
+        end
+
+        it "should dispatch to main if parseonly is not set" do
+            Puppet.stubs(:[]).with(:parseonly).returns(false)
+            @puppetmasterd.options[:node] = nil
+
+            @puppetmasterd.get_command.should == :main
+        end
+
+        describe "the parseonly command" do
+            before :each do
+                Puppet.stubs(:[]).with(:environment)
+                Puppet.stubs(:[]).with(:manifest).returns("site.pp")
+                @interpreter = stub_everything
+                Puppet.stubs(:err)
+                @puppetmasterd.stubs(:exit)
+                Puppet::Parser::Interpreter.stubs(:new).returns(@interpreter)
+            end
+
+            it "should delegate to the Puppet Parser" do
+
+                @interpreter.expects(:parser)
+
+                @puppetmasterd.parseonly
+            end
+
+            it "should exit with exit code 0 if no error" do
+                @puppetmasterd.expects(:exit).with(0)
+
+                @puppetmasterd.parseonly
+            end
+
+            it "should exit with exit code 1 if error" do
+                @interpreter.stubs(:parser).raises(Puppet::ParseError)
+
+                @puppetmasterd.expects(:exit).with(1)
+
+                @puppetmasterd.parseonly
+            end
+
+        end
+
+        describe "the compile command" do
+            before do
+                Puppet.stubs(:[]).with(:environment)
+                Puppet.stubs(:[]).with(:manifest).returns("site.pp")
+                @interpreter = stub_everything
+                Puppet.stubs(:err)
+                @puppetmasterd.stubs(:exit)
+                Puppet::Parser::Interpreter.stubs(:new).returns(@interpreter)
+                Puppet.features.stubs(:json?).returns true
+            end
+
+            it "should fail if json isn't available" do
+                Puppet.features.expects(:json?).returns false
+                lambda { @puppetmasterd.compile }.should raise_error
+            end
+
+            it "should compile a catalog for the specified node" do
+                @puppetmasterd.options[:node] = "foo"
+                Puppet::Resource::Catalog.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
+                $stdout.stubs(:puts)
+
+                @puppetmasterd.compile
+            end
+
+            it "should render the catalog to json and print the output" do
+                @puppetmasterd.options[:node] = "foo"
+                catalog = Puppet::Resource::Catalog.new
+                catalog.expects(:render).with(:json).returns "myjson"
+                Puppet::Resource::Catalog.expects(:find).returns catalog
+
+                $stdout.expects(:puts).with("myjson")
+                @puppetmasterd.compile
+            end
+
+            it "should exit with error code 30 if no catalog can be found" do
+                @puppetmasterd.options[:node] = "foo"
+                Puppet::Resource::Catalog.expects(:find).returns nil
+                @puppetmasterd.expects(:exit).with(30)
+                $stderr.expects(:puts)
+
+                @puppetmasterd.compile
+            end
+
+            it "should exit with error code 30 if there's a failure" do
+                @puppetmasterd.options[:node] = "foo"
+                Puppet::Resource::Catalog.expects(:find).raises ArgumentError
+                @puppetmasterd.expects(:exit).with(30)
+                $stderr.expects(:puts)
+
+                @puppetmasterd.compile
+            end
+        end
+
+        describe "the main command" do
+            before :each do
+                @puppetmasterd.run_preinit
+                @server = stub_everything 'server'
+                Puppet::Network::Server.stubs(:new).returns(@server)
+                @app = stub_everything 'app'
+                Puppet::SSL::Host.stubs(:localhost)
+                Puppet::SSL::CertificateAuthority.stubs(:ca?)
+                Process.stubs(:uid).returns(1000)
+                Puppet.stubs(:service)
+                Puppet.stubs(:[])
+                Puppet.stubs(:notice)
+                Puppet.stubs(:start)
+            end
+
+            it "should create a Server" do
+                Puppet::Network::Server.expects(:new)
+
+                @puppetmasterd.main
+            end
+
+            it "should give the server to the daemon" do
+                @daemon.expects(:server=).with(@server)
+
+                @puppetmasterd.main
+            end
+
+            it "should create the server with the right XMLRPC handlers" do
+                Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket]}
+
+                @puppetmasterd.main
+            end
+
+            it "should create the server with a :ca xmlrpc handler if needed" do
+                Puppet.stubs(:[]).with(:ca).returns(true)
+                Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers].include?(:CA) }
+
+                @puppetmasterd.main
+            end
+
+            it "should generate a SSL cert for localhost" do
+                Puppet::SSL::Host.expects(:localhost)
+
+                @puppetmasterd.main
+            end
+
+            it "should make sure to *only* hit the CA for data" do
+                Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
+
+                Puppet::SSL::Host.expects(:ca_location=).with(:only)
+
+                @puppetmasterd.main
+            end
+
+            it "should drop privileges if running as root" do
+                Process.stubs(:uid).returns(0)
+
+                Puppet::Util.expects(:chuser)
+
+                @puppetmasterd.main
+            end
+
+            it "should daemonize if needed" do
+                Puppet.stubs(:[]).with(:daemonize).returns(true)
+
+                @daemon.expects(:daemonize)
+
+                @puppetmasterd.main
+            end
+
+            it "should start the service" do
+                @daemon.expects(:start)
+
+                @puppetmasterd.main
+            end
+
+            describe "with --rack" do
+                confine "Rack is not available" => Puppet.features.rack?
+
+                before do
+                    require 'puppet/network/http/rack'
+                    Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
+                end
+
+                it "it should create the app with REST and XMLRPC support" do
+                    @puppetmasterd.options.stubs(:[]).with(:rack).returns(:true)
+
+                    Puppet::Network::HTTP::Rack.expects(:new).with { |args|
+                        args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket] and
+                        args[:protocols] == [:rest, :xmlrpc]
+                    }
+
+                    @puppetmasterd.main
+                end
+
+                it "it should not start a daemon" do
+                    @puppetmasterd.options.stubs(:[]).with(:rack).returns(:true)
+
+                    @daemon.expects(:start).never
+
+                    @puppetmasterd.main
+                end
+
+                it "it should return the app" do
+                    @puppetmasterd.options.stubs(:[]).with(:rack).returns(:true)
+
+                    app = @puppetmasterd.main
+                    app.should equal(@app)
+                end
+
+            end
+
+        end
+    end
+end