puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/network/http/handler_spec.rb

@@ -1,7 +1,7 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/http/handler'
-require 'puppet/network/rest_authorization'
+require 'puppet/network/authorization'
 
 class HttpHandled
   include Puppet::Network::HTTP::Handler
@@ -17,7 +17,7 @@ describe Puppet::Network::HTTP::Handler do
   end
 
   it "should include the Rest Authorization system" do
-    Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::RestAuthorization)
+    Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::Authorization)
   end
 
   it "should have a method for initializing" do
@@ -80,7 +80,7 @@ describe Puppet::Network::HTTP::Handler do
       @handler.process(@request, @response)
     end
 
-    it "should call the 'do' method and delegate authorization to the RestAuthorization layer" do
+    it "should call the 'do' method and delegate authorization to the authorization layer" do
       @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
       @handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, @request, @response)
@@ -125,22 +125,6 @@ describe Puppet::Network::HTTP::Handler do
       @handler.request_format(@request).should == "s"
     end
 
-    it "should deserialize YAML parameters" do
-      params = {'my_param' => [1,2,3].to_yaml}
-
-      decoded_params = @handler.send(:decode_params, params)
-
-      decoded_params.should == {:my_param => [1,2,3]}
-    end
-
-    it "should ignore tags on YAML parameters" do
-      params = {'my_param' => "--- !ruby/object:Array {}"}
-
-      decoded_params = @handler.send(:decode_params, params)
-
-      decoded_params[:my_param].should be_a(Hash)
-    end
-
     describe "when finding a model instance" do
       before do
         @indirection.stubs(:find).returns @result

data/spec/unit/network/http/mongrel/rest_spec.rb

@@ -1,9 +1,9 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/network/http'
 
-describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?, :'fails_on_ruby_1.9.2' => true do
+describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel? do
   before do
     require 'puppet/network/http/mongrel/rest'
   end
@@ -210,33 +210,15 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
-      it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-        @params["myheader"] = "/CN=host.domain.com"
-        @handler.params(@request)
-      end
-
-      it "should retrieve the hostname by matching the certificate parameter" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+      it "should retrieve the hostname by matching the certificate parameter from the header in :ssl_client_header" do
+        Puppet[:ssl_client_header] = "myheader"
         @params["myheader"] = "/CN=host.domain.com"
         @handler.params(@request)[:node].should == "host.domain.com"
       end
 
-      it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
-        @params.merge!(
-          "myheader"   => "SUCCESS",
-          "certheader" => "/CN=host.domain.com"
-        )
-        @handler.params(@request)
-      end
-
-      it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+      it "should use :ssl_client_header and :ssl_client_verify_header to determine the parameter for checking whether the host certificate is valid" do
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         @params.merge!(
           "myheader"   => "SUCCESS",
           "certheader" => "/CN=host.domain.com"
@@ -245,8 +227,8 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         @params.merge!(
           "myheader"   => "whatever",
           "certheader" => "/CN=host.domain.com"
@@ -255,8 +237,8 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         @params.merge!(
           "myheader"   => nil,
           "certheader" => "SUCCESS"
@@ -265,8 +247,7 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        Puppet[:ssl_client_header] = "myheader"
         @params["myheader"] = nil
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(@request)[:node].should == "host.domain.com"

data/spec/unit/network/http/mongrel_spec.rb

@@ -1,16 +1,16 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/http'
 
-describe "Puppet::Network::HTTP::Mongrel", "after initializing", :if => Puppet.features.mongrel?, :'fails_on_ruby_1.9.2' => true do
-  it "should not be listening", :'fails_on_ruby_1.9.2' => true do
+describe "Puppet::Network::HTTP::Mongrel", "after initializing", :if => Puppet.features.mongrel? do
+  it "should not be listening" do
     require 'puppet/network/http/mongrel'
 
     Puppet::Network::HTTP::Mongrel.new.should_not be_listening
   end
 end
 
-describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => Puppet.features.mongrel?, :'fails_on_ruby_1.9.2' => true do
+describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => Puppet.features.mongrel? do
   before do
     require 'puppet/network/http/mongrel'
 
@@ -20,10 +20,7 @@ describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => P
     @mock_mongrel.stubs(:register)
     Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
 
-    @mock_puppet_mongrel = mock('puppet_mongrel')
-    Puppet::Network::HTTPServer::Mongrel.stubs(:new).returns(@mock_puppet_mongrel)
-
-    @listen_params = { :address => "127.0.0.1", :port => 31337, :protocols => [ :rest, :xmlrpc ], :xmlrpc_handlers => [ :status, :fileserver ] }
+    @listen_params = { :address => "127.0.0.1", :port => 31337 }
   end
 
   it "should fail if already listening" do
@@ -31,10 +28,6 @@ describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => P
     Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
   end
 
-  it "should require at least one protocol" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
-  end
-
   it "should require a listening address to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
   end
@@ -66,40 +59,17 @@ describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => P
 
       @server.listen(@listen_params)
     end
-
-    it "should use a Mongrel + REST class to configure Mongrel when REST services are requested" do
-      @server.expects(:class_for_protocol).with(:rest).at_least_once.returns(Puppet::Network::HTTP::MongrelREST)
-      @server.listen(@listen_params)
-    end
-  end
-
-  describe "when providing XMLRPC services" do
-    it "should do nothing if no xmlrpc handlers have been provided" do
-      Puppet::Network::HTTPServer::Mongrel.expects(:new).never
-      @server.listen(@listen_params.merge(:xmlrpc_handlers => []))
-    end
-
-    it "should create an instance of the existing Mongrel http server with the right handlers" do
-      Puppet::Network::HTTPServer::Mongrel.expects(:new).with([:status, :master]).returns(@mock_puppet_mongrel)
-      @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
-    end
-
-    it "should register the Mongrel server instance at /RPC2" do
-      @mock_mongrel.expects(:register).with("/RPC2", @mock_puppet_mongrel)
-
-      @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
-    end
   end
 end
 
-describe "Puppet::Network::HTTP::Mongrel", "when turning off listening", :if => Puppet.features.mongrel?, :'fails_on_ruby_1.9.2' => true do
+describe "Puppet::Network::HTTP::Mongrel", "when turning off listening", :if => Puppet.features.mongrel? do
   before do
     @mock_mongrel = mock('mongrel httpserver')
     @mock_mongrel.stubs(:run)
     @mock_mongrel.stubs(:register)
     Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
     @server = Puppet::Network::HTTP::Mongrel.new
-    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
+    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ]}
   end
 
   it "should fail unless listening" do

data/spec/unit/network/http/rack/rest_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/rest'
@@ -91,23 +91,6 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
           @handler.set_response(@response, @file, 200)
         end
       end
-
-      it "should ensure the body has been read on success" do
-        req = mk_req('/production/report/foo', :method => 'PUT')
-        req.body.expects(:read).at_least_once
-
-        Puppet::Transaction::Report.stubs(:save)
-
-        @handler.process(req, @response)
-      end
-
-      it "should ensure the body has been partially read on failure" do
-        req = mk_req('/production/report/foo')
-        req.body.expects(:read).with(1)
-        req.stubs(:check_authorization).raises(Exception)
-
-        @handler.process(req, @response)
-      end
     end
 
     describe "and determining the request parameters" do
@@ -178,52 +161,35 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
     end
 
     describe "with pre-validated certificates" do
-
-      it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-        req = mk_req('/', "myheader" => "/CN=host.domain.com")
-        @handler.params(req)
-      end
-
-      it "should retrieve the hostname by matching the certificate parameter" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+      it "should retrieve the hostname by matching the certificate parameter given in :ssl_client_header" do
+        Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "/CN=host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
-        req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
-        @handler.params(req)
-      end
-
-      it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_true
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "whatever", "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
-        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
-        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet[:ssl_client_header] = "certheader"
+        Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => nil, "certheader" => "/CN=host.domain.com")
         @handler.params(req)[:authenticated].should be_false
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => nil)
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(req)[:node].should == "host.domain.com"

data/spec/unit/network/http/rack_spec.rb

@@ -1,47 +1,11 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
-require 'puppet/network/handler'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 
 describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
-  describe "while initializing" do
-
-    it "should require a protocol specification" do
-      Proc.new { Puppet::Network::HTTP::Rack.new({}) }.should raise_error(ArgumentError)
-    end
-
-    it "should not accept imaginary protocols" do
-      Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:foo]}) }.should raise_error(ArgumentError)
-    end
-
-    it "should accept the REST protocol" do
-      Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:rest]}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "should create a RackREST instance" do
-      Puppet::Network::HTTP::RackREST.expects(:new)
-      Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
-    end
-
-    describe "with XMLRPC enabled" do
-
-      it "should require XMLRPC handlers" do
-        Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc]}) }.should raise_error(ArgumentError)
-      end
-
-      it "should create a RackXMLRPC instance" do
-        Puppet::Network::HTTP::RackXMLRPC.expects(:new)
-        Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc], :xmlrpc_handlers => [:Status]})
-      end
-
-    end
-
-  end
-
   describe "when called" do
-
     before :all do
-      @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
+      @app = Puppet::Network::HTTP::Rack.new()
       # let's use Rack::Lint to verify that we're OK with the rack specification
       @linted = Rack::Lint.new(@app)
     end
@@ -75,26 +39,5 @@ describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
       Rack::Response.any_instance.expects(:finish).once
       @app.call(@env) # can't lint when finish is a stub
     end
-
-  end
-
-  describe "when serving XMLRPC" do
-
-    before :all do
-      @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest, :xmlrpc], :xmlrpc_handlers => [:Status]})
-      @linted = Rack::Lint.new(@app)
-    end
-
-    before :each do
-      @env = Rack::MockRequest.env_for('/RPC2', :method => 'POST')
-    end
-
-    it "should use RackXMLRPC to serve /RPC2 requests" do
-      Puppet::Network::HTTP::RackXMLRPC.any_instance.expects(:process).once
-      @linted.call(@env)
-    end
-
   end
-
 end
-

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/http'
 require 'webrick'
@@ -9,10 +9,20 @@ describe Puppet::Network::HTTP::WEBrickREST do
     Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
-  describe "when initializing", :'fails_on_ruby_1.9.2' => true do
+  describe "when initializing" do
     it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
-      Puppet::Network::HTTP::WEBrickREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
-      Puppet::Network::HTTP::WEBrickREST.new("my", "arguments")
+      server = WEBrick::HTTPServer.new(:BindAddress => '127.0.0.1',
+                                       # Probablistically going to succeed
+                                       # even if we run more than one test
+                                       # instance at once.
+                                       :Port        => 40000 + rand(10000),
+                                       # Just discard any log output, thanks.
+                                       :Logger      => stub_everything('logger'))
+
+      Puppet::Network::HTTP::WEBrickREST.any_instance.
+        expects(:initialize_for_puppet).with(:server => server, :handler => "arguments")
+
+      Puppet::Network::HTTP::WEBrickREST.new(server, "arguments")
     end
   end
 

data/spec/unit/network/http/webrick_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
-require 'puppet/network/handler'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick'
 
@@ -10,213 +9,148 @@ describe Puppet::Network::HTTP::WEBrick, "after initializing" do
   end
 end
 
-describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
-  before do
-    @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
-    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
-    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
-    @server = Puppet::Network::HTTP::WEBrick.new
-    [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
-    @listen_params = { :address => "127.0.0.1", :port => 31337, :xmlrpc_handlers => [], :protocols => [ :rest ] }
-  end
-
-  it "should fail if already listening" do
-    @server.listen(@listen_params)
-    Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
-  end
-
-  it "should require at least one protocol" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
+describe Puppet::Network::HTTP::WEBrick do
+  include PuppetSpec::Files
+
+  let(:listen_params) do
+    { :address => "127.0.0.1",
+      :port => 31337,
+      :protocols => [ :rest ],
+      :handlers => [ :node, :catalog ],
+    }
   end
 
-  it "should require a listening address to be specified" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
+  let(:server) do
+    s = Puppet::Network::HTTP::WEBrick.new
+    s.stubs(:setup_logger).returns(Hash.new)
+    s.stubs(:setup_ssl).returns(Hash.new)
+    s
   end
 
-  it "should require a listening port to be specified" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
+  let(:mock_webrick) do
+    stub('webrick',
+         :[] => {},
+         :listeners => [],
+         :status => :Running,
+         :mount => nil,
+         :start => nil,
+         :shutdown => nil)
   end
 
-  it "should tell webrick to listen on the specified address and port" do
-    WEBrick::HTTPServer.expects(:new).with {|args|
-      args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"
-    }.returns(@mock_webrick)
-    @server.listen(@listen_params)
+  before :each do
+    WEBrick::HTTPServer.stubs(:new).returns(mock_webrick)
   end
 
-  it "should configure a logger for webrick" do
-    @server.expects(:setup_logger).returns(:Logger => :mylogger)
-
-    WEBrick::HTTPServer.expects(:new).with {|args|
-      args[:Logger] == :mylogger
-    }.returns(@mock_webrick)
-
-    @server.listen(@listen_params)
-  end
+  describe "when turning on listening" do
+    it "should fail if already listening" do
+      server.listen(listen_params)
+      expect { server.listen(listen_params) }.to raise_error(RuntimeError, /server is already listening/)
+    end
 
-  it "should configure SSL for webrick" do
-    @server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
+    it "should require a listening address to be specified" do
+      listen_params.delete(:address)
+      expect { server.listen(listen_params) }.to raise_error(ArgumentError, /:address must be specified/)
+    end
 
-    WEBrick::HTTPServer.expects(:new).with {|args|
-      args[:Ssl] == :testing and args[:Other] == :yay
-    }.returns(@mock_webrick)
+    it "should require a listening port to be specified" do
+      listen_params.delete(:port)
+      expect { server.listen(listen_params) }.to raise_error(ArgumentError, /:port must be specified/)
+    end
 
-    @server.listen(@listen_params)
-  end
+    it "should tell webrick to listen on the specified address and port" do
+      WEBrick::HTTPServer.expects(:new).with {|args|
+        args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"
+      }.returns(mock_webrick)
+      server.listen(listen_params)
+    end
 
-  it "should be listening" do
-    @server.listen(@listen_params)
-    @server.should be_listening
-  end
+    it "should configure a logger for webrick" do
+      server.expects(:setup_logger).returns(:Logger => :mylogger)
 
-  describe "when the REST protocol is requested" do
-    it "should register the REST handler at /" do
-      # We don't care about the options here.
-      @mock_webrick.expects(:mount).with { |path, klass, options| path == "/" and klass == Puppet::Network::HTTP::WEBrickREST }
+      WEBrick::HTTPServer.expects(:new).with {|args|
+        args[:Logger] == :mylogger
+      }.returns(mock_webrick)
 
-      @server.listen(@listen_params.merge(:protocols => [:rest]))
+      server.listen(listen_params)
     end
-  end
-
-  describe "when the XMLRPC protocol is requested" do
-    before do
-      @servlet = mock 'servlet'
 
-      Puppet::Network::XMLRPC::WEBrickServlet.stubs(:new).returns @servlet
+    it "should configure SSL for webrick" do
+      server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
 
-      @master_handler = mock('master_handler')
-      @file_handler = mock('file_handler')
+      WEBrick::HTTPServer.expects(:new).with {|args|
+        args[:Ssl] == :testing and args[:Other] == :yay
+      }.returns(mock_webrick)
 
-      @master = mock 'master'
-      @file = mock 'file'
-      @master_handler.stubs(:new).returns @master
-      @file_handler.stubs(:new).returns @file
-
-      Puppet::Network::Handler.stubs(:handler).with(:master).returns @master_handler
-      Puppet::Network::Handler.stubs(:handler).with(:fileserver).returns @file_handler
+      server.listen(listen_params)
     end
 
-    it "should do nothing if no xmlrpc handlers have been specified" do
-      Puppet::Network::Handler.expects(:handler).never
-
-      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => []))
+    it "should be listening" do
+      server.listen(listen_params)
+      server.should be_listening
     end
 
-    it "should look the handler classes up via their base class" do
-      Puppet::Network::Handler.expects(:handler).with(:master).returns @master_handler
-      Puppet::Network::Handler.expects(:handler).with(:fileserver).returns @file_handler
+    describe "when the REST protocol is requested" do
+      it "should register the REST handler at /" do
+        # We don't care about the options here.
+        mock_webrick.expects(:mount).with("/", Puppet::Network::HTTP::WEBrickREST, anything)
 
-      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+        server.listen(listen_params.merge(:protocols => [:rest]))
+      end
     end
+  end
 
-    it "should create an instance for each requested xmlrpc handler" do
-      @master_handler.expects(:new).returns @master
-      @file_handler.expects(:new).returns @file
-
-      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+  describe "when turning off listening" do
+    it "should fail unless listening" do
+      expect { server.unlisten }.to raise_error(RuntimeError, /server is not listening/)
     end
 
-    it "should create a webrick servlet with the xmlrpc handler instances" do
-      Puppet::Network::XMLRPC::WEBrickServlet.expects(:new).with([@master, @file]).returns @servlet
-
-      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    it "should order webrick server to stop" do
+      mock_webrick.expects(:shutdown)
+      server.listen(listen_params)
+      server.unlisten
     end
 
-    it "should mount the webrick servlet at /RPC2" do
-      @mock_webrick.stubs(:mount)
-      @mock_webrick.expects(:mount).with("/RPC2", @servlet)
-
-      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    it "should no longer be listening" do
+      server.listen(listen_params)
+      server.unlisten
+      server.should_not be_listening
     end
   end
-end
-
-
-describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a protocol" do
-  it "should require a protocol" do
-    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol }.should raise_error(ArgumentError)
-  end
-
-  it "should accept a protocol" do
-    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("bob") }.should_not raise_error(ArgumentError)
-  end
-
-  it "should use a WEBrick + REST class when a REST protocol is specified" do
-    Puppet::Network::HTTP::WEBrick.class_for_protocol("rest").should == Puppet::Network::HTTP::WEBrickREST
-  end
-
-  it "should fail when an unknown protocol is specified" do
-    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("abcdefg") }.should raise_error
-  end
-end
-
-describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do
-  before do
-    @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
-    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
-    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
-    @server = Puppet::Network::HTTP::WEBrick.new
-    [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
-    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
-  end
-
-  it "should fail unless listening" do
-    Proc.new { @server.unlisten }.should raise_error(RuntimeError)
-  end
-
-  it "should order webrick server to stop" do
-    @mock_webrick.expects(:shutdown)
-    @server.listen(@listen_params)
-    @server.unlisten
-  end
-
-  it "should no longer be listening" do
-    @server.listen(@listen_params)
-    @server.unlisten
-    @server.should_not be_listening
-  end
-end
-
-describe Puppet::Network::HTTP::WEBrick do
-  before do
-    @mock_webrick = stub('webrick', :[] => {})
-    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
-    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
-    @server = Puppet::Network::HTTP::WEBrick.new
-  end
 
   describe "when configuring an http logger" do
-    before do
-      Puppet.settings.stubs(:value).returns "something"
+    let(:server) { Puppet::Network::HTTP::WEBrick.new }
+
+    before :each do
       Puppet.settings.stubs(:use)
       @filehandle = stub 'handle', :fcntl => nil, :sync= => nil
 
       File.stubs(:open).returns @filehandle
     end
 
-    it "should use the settings for :main, :ssl, and the process name" do
-      Puppet.settings.stubs(:value).with(:name).returns "myname"
-      Puppet.settings.expects(:use).with(:main, :ssl, "myname")
+    it "should use the settings for :main, :ssl, and :application" do
+      Puppet.settings.expects(:use).with(:main, :ssl, :application)
 
-      @server.setup_logger
+      server.setup_logger
     end
 
     it "should use the masterlog if the run_mode is master" do
       Puppet.run_mode.stubs(:master?).returns(true)
-      Puppet.settings.expects(:value).with(:masterhttplog).returns "/master/log"
+      log = make_absolute("/master/log")
+      Puppet[:masterhttplog] = log
 
-      File.expects(:open).with("/master/log", "a+").returns @filehandle
+      File.expects(:open).with(log, "a+").returns @filehandle
 
-      @server.setup_logger
+      server.setup_logger
     end
 
     it "should use the httplog if the run_mode is not master" do
       Puppet.run_mode.stubs(:master?).returns(false)
-      Puppet.settings.expects(:value).with(:httplog).returns "/other/log"
+      log = make_absolute("/other/log")
+      Puppet[:httplog] = log
 
-      File.expects(:open).with("/other/log", "a+").returns @filehandle
+      File.expects(:open).with(log, "a+").returns @filehandle
 
-      @server.setup_logger
+      server.setup_logger
     end
 
     describe "and creating the logging filehandle" do
@@ -227,20 +161,20 @@ describe Puppet::Network::HTTP::WEBrick do
           @filehandle.expects(:fcntl).never
         end
 
-        @server.setup_logger
+        server.setup_logger
       end
 
       it "should sync the filehandle" do
         @filehandle.expects(:sync=).with(true)
 
-        @server.setup_logger
+        server.setup_logger
       end
     end
 
     it "should create a new WEBrick::Log instance with the open filehandle" do
       WEBrick::Log.expects(:new).with(@filehandle)
 
-      @server.setup_logger
+      server.setup_logger
     end
 
     it "should set debugging if the current loglevel is :debug" do
@@ -248,21 +182,21 @@ describe Puppet::Network::HTTP::WEBrick do
 
       WEBrick::Log.expects(:new).with { |handle, debug| debug == WEBrick::Log::DEBUG }
 
-      @server.setup_logger
+      server.setup_logger
     end
 
     it "should return the logger as the main log" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
-      @server.setup_logger[:Logger].should == logger
+      server.setup_logger[:Logger].should == logger
     end
 
     it "should return the logger as the access log using both the Common and Referer log format" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
-      @server.setup_logger[:AccessLog].should == [
+      server.setup_logger[:AccessLog].should == [
         [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
         [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT]
       ]
@@ -270,68 +204,70 @@ describe Puppet::Network::HTTP::WEBrick do
   end
 
   describe "when configuring ssl" do
-    before do
-      @key = stub 'key', :content => "mykey"
-      @cert = stub 'cert', :content => "mycert"
-      @host = stub 'host', :key => @key, :certificate => @cert, :name => "yay", :ssl_store => "mystore"
-
-      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns @cert
-
-      Puppet::SSL::Host.stubs(:localhost).returns @host
+    let(:server) { Puppet::Network::HTTP::WEBrick.new }
+    let(:localcacert) { make_absolute("/ca/crt") }
+    let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
+    let(:key) { stub 'key', :content => "mykey" }
+    let(:cert) { stub 'cert', :content => "mycert" }
+    let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
+
+    before :each do
+      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
+      Puppet::SSL::Host.stubs(:localhost).returns host
     end
 
     it "should use the key from the localhost SSL::Host instance" do
-      Puppet::SSL::Host.expects(:localhost).returns @host
-      @host.expects(:key).returns @key
+      Puppet::SSL::Host.expects(:localhost).returns host
+      host.expects(:key).returns key
 
-      @server.setup_ssl[:SSLPrivateKey].should == "mykey"
+      server.setup_ssl[:SSLPrivateKey].should == "mykey"
     end
 
     it "should configure the certificate" do
-      @server.setup_ssl[:SSLCertificate].should == "mycert"
+      server.setup_ssl[:SSLCertificate].should == "mycert"
     end
 
     it "should fail if no CA certificate can be found" do
       Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns nil
 
-      lambda { @server.setup_ssl }.should raise_error(Puppet::Error)
+      expect { server.setup_ssl }.to raise_error(Puppet::Error, /Could not find CA certificate/)
     end
 
     it "should specify the path to the CA certificate" do
-      Puppet.settings.stubs(:value).returns "whatever"
-      Puppet.settings.stubs(:value).with(:hostcrl).returns 'false'
-      Puppet.settings.stubs(:value).with(:localcacert).returns '/ca/crt'
+      Puppet.settings[:hostcrl] = 'false'
+      Puppet.settings[:localcacert] = localcacert
 
-      @server.setup_ssl[:SSLCACertificateFile].should == "/ca/crt"
+      server.setup_ssl[:SSLCACertificateFile].should == localcacert
     end
 
-    it "should start ssl immediately" do
-      @server.setup_ssl[:SSLStartImmediately].should be_true
+    it "should specify the path to the CA certificate" do
+      Puppet.settings[:hostcrl] = 'false'
+      Puppet.settings[:localcacert] = localcacert
+      Puppet.settings[:ssl_server_ca_auth] = ssl_server_ca_auth
+
+      server.setup_ssl[:SSLCACertificateFile].should == ssl_server_ca_auth
     end
 
-    it "should enable ssl" do
-      @server.setup_ssl[:SSLEnable].should be_true
+    it "should start ssl immediately" do
+      server.setup_ssl[:SSLStartImmediately].should be_true
     end
 
-    it "should reject SSLv2" do
-      @server.setup_ssl[:SSLOptions].should == OpenSSL::SSL::OP_NO_SSLv2
+    it "should enable ssl" do
+      server.setup_ssl[:SSLEnable].should be_true
     end
 
     it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
-      @server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
+      server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
     end
 
     it "should add an x509 store" do
-      Puppet.settings.stubs(:value).returns "whatever"
-      Puppet.settings.stubs(:value).with(:hostcrl).returns '/my/crl'
-
-      @host.expects(:ssl_store).returns "mystore"
+      host.expects(:ssl_store).returns "mystore"
 
-      @server.setup_ssl[:SSLCertificateStore].should == "mystore"
+      server.setup_ssl[:SSLCertificateStore].should == "mystore"
     end
 
     it "should set the certificate name to 'nil'" do
-      @server.setup_ssl[:SSLCertName].should be_nil
+      server.setup_ssl[:SSLCertName].should be_nil
     end
   end
 end