puppet 3.0.0.rc5 → 3.0.0.rc7

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

@@ -12,13 +12,8 @@ end
 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
+  let(:address) { '127.0.0.1' }
+  let(:port) { 31337 }
 
   let(:server) do
     s = Puppet::Network::HTTP::WEBrick.new
@@ -43,25 +38,15 @@ describe Puppet::Network::HTTP::WEBrick do
 
   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 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
-
-    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/)
+      server.listen(address, port)
+      expect { server.listen(address, port) }.to raise_error(RuntimeError, /server is already listening/)
     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)
+      server.listen(address, port)
     end
 
     it "should configure a logger for webrick" do
@@ -71,7 +56,7 @@ describe Puppet::Network::HTTP::WEBrick do
         args[:Logger] == :mylogger
       }.returns(mock_webrick)
 
-      server.listen(listen_params)
+      server.listen(address, port)
     end
 
     it "should configure SSL for webrick" do
@@ -81,11 +66,11 @@ describe Puppet::Network::HTTP::WEBrick do
         args[:Ssl] == :testing and args[:Other] == :yay
       }.returns(mock_webrick)
 
-      server.listen(listen_params)
+      server.listen(address, port)
     end
 
     it "should be listening" do
-      server.listen(listen_params)
+      server.listen(address, port)
       server.should be_listening
     end
 
@@ -94,7 +79,7 @@ describe Puppet::Network::HTTP::WEBrick 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 => [:rest]))
+        server.listen(address, port)
       end
     end
   end
@@ -106,12 +91,12 @@ describe Puppet::Network::HTTP::WEBrick do
 
     it "should order webrick server to stop" do
       mock_webrick.expects(:shutdown)
-      server.listen(listen_params)
+      server.listen(address, port)
       server.unlisten
     end
 
     it "should no longer be listening" do
-      server.listen(listen_params)
+      server.listen(address, port)
       server.unlisten
       server.should_not be_listening
     end

data/spec/unit/network/server_spec.rb

@@ -3,145 +3,87 @@ require 'spec_helper'
 require 'puppet/network/server'
 
 describe Puppet::Network::Server do
+  let(:port) { 8140 }
+  let(:address) { '0.0.0.0' }
+  let(:server) {
+    server = Puppet::Network::Server.new(address, port)
+    server.stubs(:close_streams)
+    server
+  }
+
   before do
-    @mock_http_server_class = mock('http server class')
+    @mock_http_server = mock('http server')
     Puppet.settings.stubs(:use)
     Puppet.run_mode.stubs(:name).returns :master
-    Puppet[:servertype] = :suparserver
-    Puppet[:bindaddress] = ""
-    Puppet[:masterport] = 8140
-    Puppet::Network::HTTP.stubs(:server_class_by_type).returns(@mock_http_server_class)
-    Puppet[:servertype] = :suparserver
-    @server = Puppet::Network::Server.new(:port => 31337)
-    @server.stubs(:close_streams).returns(nil)
+    Puppet::Network::HTTP::WEBrick.stubs(:new).returns(@mock_http_server)
   end
 
   describe "when initializing" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-      Puppet[:bindaddress] = ""
       Puppet[:masterport] = ''
     end
 
-    it 'should fail if an unknown option is provided' do
-      expect { Puppet::Network::Server.new(:foo => 31337) }.to raise_error(ArgumentError)
-    end
-
-    it "should allow specifying a listening port" do
-      Puppet[:bindaddress] = ''
-      @server = Puppet::Network::Server.new(:port => 31337)
-      @server.port.should == 31337
-    end
-
-    it "should use the :bindaddress setting to determine the default listening address" do
-      Puppet[:masterport] = ''
-      Puppet[:bindaddress] = "10.0.0.1"
-      @server = Puppet::Network::Server.new
-      @server.address.should == "10.0.0.1"
-    end
-
-    it "should set the bind address to '127.0.0.1' if the default address is an empty string and the server type is mongrel" do
-      Puppet[:servertype] = "mongrel"
-      Puppet[:bindaddress] = ""
-      @server = Puppet::Network::Server.new
-      @server.address.should == '127.0.0.1'
-    end
-
-    it "should set the bind address to '0.0.0.0' if the default address is an empty string and the server type is webrick" do
-      Puppet[:servertype] = "webrick"
-      Puppet[:bindaddress] = ""
-      @server = Puppet::Network::Server.new
-      @server.address.should == '0.0.0.0'
-    end
-
-    it "should use the Puppet configurator to find a default listening port" do
-      Puppet[:bindaddress] = ''
-      Puppet[:masterport] = 6667
-      @server = Puppet::Network::Server.new
-      @server.port.should == 6667
-    end
-
-    it "should use the Puppet configurator to determine which HTTP server will be used to provide access to clients" do
-      Puppet[:servertype] = :suparserver
-      @server = Puppet::Network::Server.new(:port => 31337)
-      @server.server_type.should == :suparserver
-    end
-
-    it "should ask the Puppet::Network::HTTP class to fetch the proper HTTP server class" do
-      Puppet::Network::HTTP.expects(:server_class_by_type).with(:suparserver).returns(@mock_http_server_class)
-      @server = Puppet::Network::Server.new(:port => 31337)
-    end
-
-    it "should fail if the HTTP server class is unknown" do
-      Puppet::Network::HTTP.stubs(:server_class_by_type).returns(nil)
-      expect { Puppet::Network::Server.new(:port => 31337) }.to raise_error(ArgumentError)
-    end
-
     it "should allow registering REST handlers" do
-      @server = Puppet::Network::Server.new(:port => 31337, :handlers => [ :foo, :bar, :baz])
-      expect { @server.unregister(:foo, :bar, :baz) }.to_not raise_error
+      server = Puppet::Network::Server.new(address, port, [:foo, :bar, :baz])
+      expect { server.unregister(:foo, :bar, :baz) }.to_not raise_error
     end
 
     it "should not be listening after initialization" do
-      Puppet::Network::Server.new(:port => 31337).should_not be_listening
+      Puppet::Network::Server.new(address, port).should_not be_listening
     end
 
     it "should use the :main setting section" do
       Puppet.settings.expects(:use).with { |*args| args.include?(:main) }
-      @server = Puppet::Network::Server.new(:port => 31337)
+      Puppet::Network::Server.new(address, port)
     end
 
     it "should use the :application setting section" do
       Puppet.settings.expects(:use).with { |*args| args.include?(:application) }
 
-      @server = Puppet::Network::Server.new(:port => 31337)
+      Puppet::Network::Server.new(address, port)
     end
   end
 
-  # We don't test the method, because it's too much of a Unix-y pain.
-  it "should be able to daemonize" do
-    @server.should respond_to(:daemonize)
-  end
-
   describe "when being started" do
     before do
-      @server.stubs(:listen)
-      @server.stubs(:create_pidfile)
+      server.stubs(:listen)
+      server.stubs(:create_pidfile)
     end
 
     it "should listen" do
-      @server.expects(:listen)
-      @server.start
+      server.expects(:listen)
+      server.start
     end
 
     it "should create its PID file" do
-      @server.expects(:create_pidfile)
-      @server.start
+      server.expects(:create_pidfile)
+      server.start
     end
   end
 
   describe "when being stopped" do
     before do
-      @server.stubs(:unlisten)
-      @server.stubs(:remove_pidfile)
+      server.stubs(:unlisten)
+      server.stubs(:remove_pidfile)
     end
 
     it "should unlisten" do
-      @server.expects(:unlisten)
-      @server.stop
+      server.expects(:unlisten)
+      server.stop
     end
 
     it "should remove its PID file" do
-      @server.expects(:remove_pidfile)
-      @server.stop
+      server.expects(:remove_pidfile)
+      server.stop
     end
   end
 
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.run_mode.expects(:name).returns "me"
-      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
-      @server.create_pidfile
+      Puppet::Util.expects(:synchronize_on).with("me", Sync::EX)
+      server.create_pidfile
     end
 
     it "should lock the pidfile using the Pidlock class" do
@@ -153,7 +95,7 @@ describe Puppet::Network::Server do
       Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
 
       pidfile.expects(:lock).returns true
-      @server.create_pidfile
+      server.create_pidfile
     end
 
     it "should fail if it cannot lock" do
@@ -165,7 +107,7 @@ describe Puppet::Network::Server do
 
       pidfile.expects(:lock).returns false
 
-      expect { @server.create_pidfile }.to raise_error /Could not create PID/
+      expect { server.create_pidfile }.to raise_error /Could not create PID/
     end
   end
 
@@ -173,7 +115,7 @@ describe Puppet::Network::Server do
     it "should use an exclusive mutex" do
       Puppet.run_mode.expects(:name).returns "me"
       Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
-      @server.remove_pidfile
+      server.remove_pidfile
     end
 
     it "should do nothing if the pidfile is not present" do
@@ -181,7 +123,7 @@ describe Puppet::Network::Server do
       Puppet[:pidfile] = "/my/file"
       Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
 
-      @server.remove_pidfile
+      server.remove_pidfile
     end
 
     it "should unlock the pidfile using the Pidlock class" do
@@ -189,7 +131,7 @@ describe Puppet::Network::Server do
       Puppet[:pidfile] = "/my/file"
       Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
 
-      @server.remove_pidfile
+      server.remove_pidfile
     end
   end
 
@@ -199,199 +141,144 @@ describe Puppet::Network::Server do
     end
 
     it "should allow registering an indirection for client access by specifying its indirection name" do
-      expect { @server.register(:foo) }.to_not raise_error
+      expect { server.register(:foo) }.to_not raise_error
     end
 
     it "should require that the indirection be valid" do
       Puppet::Indirector::Indirection.expects(:model).with(:foo).returns nil
-      expect { @server.register(:foo) }.to raise_error(ArgumentError)
+      expect { server.register(:foo) }.to raise_error(ArgumentError)
     end
 
     it "should require at least one indirection name when registering indirections for client access" do
-      expect { @server.register }.to raise_error(ArgumentError)
+      expect { server.register }.to raise_error(ArgumentError)
     end
 
     it "should allow for numerous indirections to be registered at once for client access" do
-      expect { @server.register(:foo, :bar, :baz) }.to_not raise_error
+      expect { server.register(:foo, :bar, :baz) }.to_not raise_error
     end
 
     it "should allow the use of indirection names to specify which indirections are to be no longer accessible to clients" do
-      @server.register(:foo)
-      expect { @server.unregister(:foo) }.to_not raise_error
+      server.register(:foo)
+      expect { server.unregister(:foo) }.to_not raise_error
     end
 
     it "should leave other indirections accessible to clients when turning off indirections" do
-      @server.register(:foo, :bar)
-      @server.unregister(:foo)
-      expect { @server.unregister(:bar)}.to_not raise_error
+      server.register(:foo, :bar)
+      server.unregister(:foo)
+      expect { server.unregister(:bar)}.to_not raise_error
     end
 
     it "should allow specifying numerous indirections which are to be no longer accessible to clients" do
-      @server.register(:foo, :bar)
-      expect { @server.unregister(:foo, :bar) }.to_not raise_error
+      server.register(:foo, :bar)
+      expect { server.unregister(:foo, :bar) }.to_not raise_error
     end
 
     it "should not turn off any indirections if given unknown indirection names to turn off" do
-      @server.register(:foo, :bar)
-      expect { @server.unregister(:foo, :bar, :baz) }.to raise_error(ArgumentError)
-      expect { @server.unregister(:foo, :bar) }.to_not raise_error
+      server.register(:foo, :bar)
+      expect { server.unregister(:foo, :bar, :baz) }.to raise_error(ArgumentError)
+      expect { server.unregister(:foo, :bar) }.to_not raise_error
     end
 
     it "should not allow turning off unknown indirection names" do
-      @server.register(:foo, :bar)
-      expect { @server.unregister(:baz) }.to raise_error(ArgumentError)
+      server.register(:foo, :bar)
+      expect { server.unregister(:baz) }.to raise_error(ArgumentError)
     end
 
     it "should disable client access immediately when turning off indirections" do
-      @server.register(:foo, :bar)
-      @server.unregister(:foo)
-      expect { @server.unregister(:foo) }.to raise_error(ArgumentError)
+      server.register(:foo, :bar)
+      server.unregister(:foo)
+      expect { server.unregister(:foo) }.to raise_error(ArgumentError)
     end
 
     it "should allow turning off all indirections at once" do
-      @server.register(:foo, :bar)
-      @server.unregister
-      [ :foo, :bar, :baz].each do |indirection|
-        expect { @server.unregister(indirection) }.to raise_error(ArgumentError)
+      server.register(:foo, :bar)
+      server.unregister
+      [:foo, :bar, :baz].each do |indirection|
+        expect { server.unregister(indirection) }.to raise_error(ArgumentError)
       end
     end
   end
 
-  it "should provide a means of determining whether it is listening" do
-    @server.should respond_to(:listening?)
-  end
-
-  it "should provide a means of determining which HTTP server will be used to provide access to clients" do
-    @server.server_type.should == :suparserver
-  end
-
-  it "should provide a means of determining the listening address" do
-    @server.address.should == "127.0.0.1"
-  end
-
-  it "should provide a means of determining the listening port" do
-    @server.port.should == 31337
-  end
-
   it "should allow for multiple configurations, each handling different indirections" do
     Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
-    @server2 = Puppet::Network::Server.new(:port => 31337)
-    @server.register(:foo, :bar)
-    @server2.register(:foo, :xyzzy)
-    @server.unregister(:foo, :bar)
-    @server2.unregister(:foo, :xyzzy)
-    expect { @server.unregister(:xyzzy) }.to raise_error(ArgumentError)
-    expect { @server2.unregister(:bar) }.to raise_error(ArgumentError)
+    server2 = Puppet::Network::Server.new(address, port)
+    server.register(:foo, :bar)
+    server2.register(:foo, :xyzzy)
+    server.unregister(:foo, :bar)
+    server2.unregister(:foo, :xyzzy)
+    expect { server.unregister(:xyzzy) }.to raise_error(ArgumentError)
+    expect { server2.unregister(:bar) }.to raise_error(ArgumentError)
   end
 
   describe "when listening is off" do
     before do
-      @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
-      @server.stubs(:http_server).returns(@mock_http_server)
     end
 
     it "should indicate that it is not listening" do
-      @server.should_not be_listening
+      server.should_not be_listening
     end
 
     it "should not allow listening to be turned off" do
-      expect { @server.unlisten }.to raise_error(RuntimeError)
+      expect { server.unlisten }.to raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned on" do
-      expect { @server.listen }.to_not raise_error
+      expect { server.listen }.to_not raise_error
     end
 
   end
 
   describe "when listening is on" do
     before do
-      @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @mock_http_server.stubs(:unlisten)
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @server.listen
+      server.listen
     end
 
     it "should indicate that it is listening" do
-      @server.should be_listening
+      server.should be_listening
     end
 
     it "should not allow listening to be turned on" do
-      expect { @server.listen }.to raise_error(RuntimeError)
+      expect { server.listen }.to raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned off" do
-      expect { @server.unlisten }.to_not raise_error
+      expect { server.unlisten }.to_not raise_error
     end
   end
 
   describe "when listening is being turned on" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-
-      @server = Puppet::Network::Server.new(:port => 31337, :handlers => [:node])
-      @mock_http_server = mock('http server')
-      @mock_http_server.stubs(:listen)
-    end
-
-    it "should fetch an instance of an HTTP server" do
-      @server.stubs(:http_server_class).returns(@mock_http_server_class)
-      @mock_http_server_class.expects(:new).returns(@mock_http_server)
-      @server.listen
     end
 
     it "should cause the HTTP server to listen" do
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @mock_http_server.expects(:listen)
-      @server.listen
-    end
-
-    it "should pass the listening address to the HTTP server" do
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @mock_http_server.expects(:listen).with do |args|
-        args[:address] == '127.0.0.1'
-      end
-      @server.listen
-    end
-
-    it "should pass the listening port to the HTTP server" do
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @mock_http_server.expects(:listen).with do |args|
-        args[:port] == 31337
-      end
-      @server.listen
-    end
-
-    it "should pass a list of REST handlers to the HTTP server" do
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @mock_http_server.expects(:listen).with do |args|
-        args[:handlers] == [ :node ]
-      end
-      @server.listen
+      server = Puppet::Network::Server.new(address, port, [:node])
+      @mock_http_server.expects(:listen).with(address, port)
+      server.listen
     end
   end
 
   describe "when listening is being turned off" do
     before do
-      @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
-      @server.stubs(:http_server).returns(@mock_http_server)
-      @server.listen
+      server.stubs(:http_server).returns(@mock_http_server)
+      server.listen
     end
 
     it "should cause the HTTP server to stop listening" do
       @mock_http_server.expects(:unlisten)
-      @server.unlisten
+      server.unlisten
     end
 
     it "should not allow for indirections to be turned off" do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
-      @server.register(:foo)
-      expect { @server.unregister(:foo) }.to raise_error(RuntimeError)
+      server.register(:foo)
+      expect { server.unregister(:foo) }.to raise_error(RuntimeError)
     end
   end
 end