Revert back to before(:all) for adapter_lint

Using let-style RSpec and lazily creating our servers before every
test is good from a test purity point of view but increases greatly the
risk of port collisions when we attempt to find a free port to run
our adapter in adapter_lint (bearing in mind that Socket#close only
releases the Ruby resources, and the socket persists in a TIME_WAIT
state for an indeterminate period of time at OS level).

Revert to before(:all) and create only one server that will be used
for the duration of all tests in adapter_lint. We still need to sleep
 to ensure our 'free' ports are available, but we reduce the risk of
 servers being unavailable. This also has the happy side effect of
 making the tests somewhat faster.

Author: rgarner

lib/webmachine/spec/adapter_lint.rb

@@ -1,68 +1,72 @@
 require "webmachine/spec/test_resource"
 require "net/http"
 
+ADDRESS = "127.0.0.1"
+
 shared_examples_for :adapter_lint do
-  attr_accessor :client
-
-  let(:address) { "127.0.0.1" }
-  let(:port) do
-    s = TCPServer.new(address, 0)
-    p = s.addr[1]
-    s.close       # This does not close the socket at OS level, just frees from Ruby.
-                  # The socket will be in TIME_WAIT http://www.ssfnet.org/Exchange/tcp/tcpTutorialNotes.html
-                  # "The main thing to recognize about connection teardown is that a connection in
-                  #  the TIME_WAIT state cannot move to the CLOSED state until it has waited for two times
-                  #  the maximum amount of time an IP datagram might live in the Inter net."
-
-    sleep(0.005)  # This is just about the best we can do. Any more slows the tests,
-                  # any less and we get intermittent silent port collisions
-    p
-  end
-
-  let(:application) do
-    application = Webmachine::Application.new
-    application.dispatcher.add_route ["test"], Test::Resource
-
-    application.configure do |c|
-      c.ip = address
-      c.port = port
+  attr_reader :client
+
+  class TestApplicationNotResponsive < Timeout::Error; end
+
+  def find_free_port
+    temp_server = TCPServer.new(ADDRESS, 0)
+    port = temp_server.addr[1]
+    temp_server.close # only frees Ruby resource, socket is in TIME_WAIT at OS level
+                      # so we can't have our adapter use it too quickly
+
+    sleep(0.1)        # 'Wait' for temp_server to *really* close, not just TIME_WAIT
+    port
+  end
+
+  def create_test_application(port)
+    Webmachine::Application.new.tap do |application|
+      application.dispatcher.add_route ["test"], Test::Resource
+
+      application.configure do |c|
+        c.ip   = ADDRESS
+        c.port = port
+      end
     end
+  end
 
-    application
+  def run_application(adapter_class, application)
+    adapter = adapter_class.new(application)
+    Thread.abort_on_exception = true
+    Thread.new { adapter.run }
   end
 
-  let(:client) do
-    client = Net::HTTP.new(application.configuration.ip, port)
-    # Wait until the server is responsive
-    Timeout.timeout(5) do
+  def wait_until_server_responds_to(client)
+    Timeout.timeout(5, TestApplicationNotResponsive) do
       begin
         client.start
       rescue Errno::ECONNREFUSED
         sleep(0.01)
         retry
       end
     end
-    client
   end
 
-  before do
-    @adapter = described_class.new(application)
+  before(:all) do
+    @port = find_free_port
+    application = create_test_application(@port)
 
-    Thread.abort_on_exception = true
-    @server_thread = Thread.new { @adapter.run }
-    sleep(0.01)
+    adapter_class = described_class
+    @server_thread = run_application(adapter_class, application)
+
+    @client = Net::HTTP.new(application.configuration.ip, @port)
+    wait_until_server_responds_to(client)
   end
 
-  after do
-    client.finish
+  after(:all) do
+    @client.finish
     @server_thread.kill
   end
 
   it "provides the request URI" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.request_uri"
     response = client.request(request)
-    expect(response.body).to eq("http://#{address}:#{port}/test")
+    expect(response.body).to eq("http://#{ADDRESS}:#{@port}/test")
   end
 
   # context do