hatetepe 0.5.2 → 0.6.0.pre

data/spec/integration/keep_alive_spec.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe do
+  include_context :server_client_pair
+
+  let(:server_config) do
+    { handlers: [SpecHandler, Hatetepe::Server::KeepAlive] }
+  end
+  let(:client_config) do
+    { handlers: [Hatetepe::Client::KeepAlive] }
+  end
+
+  let(:responses) do
+    requests.each do |request|
+      client.perform(request)
+    end
+
+    requests.map do |request|
+      request.served.sync.tap do |response|
+        response.finished.sync if response
+      end
+    end
+  end
+
+  describe Hatetepe::Server, 'with KeepAlive' do
+    let(:requests) do
+      [finished_request(:get, '/sleep'), finished_request]
+    end
+
+    it 'sends responses in the correct order' do
+      expect(responses[0].body).to eq('/sleep')
+      expect(responses[1].body).to eq('/')
+    end
+
+    describe 'and HTTP/1.1 request' do
+      let(:requests) { [finished_request] }
+
+      it 'assumes Connection: keep-alive' do
+        expect(client).not_to be_closed
+        expect(server).not_to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'keep-alive')
+      end
+    end
+
+    describe 'and HTTP/1.0 request' do
+      let(:requests) do
+        [finished_request.tap { |r| r.http_version = 1.0 }]
+      end
+
+      it 'assumes Connection: close' do
+        responses
+        tick
+        expect(client).to be_closed_by_remote
+        expect(server).to be_closed_by_self
+
+        expect(responses[0].headers).to include('Connection' => 'close')
+      end
+    end
+
+    describe 'and Connection: keep-alive' do
+      let(:requests) do
+        [finished_request(:get, '/', { 'Connection' => 'keep-alive' })
+          .tap { |r| r.http_version = 1.0 }]
+      end
+
+      it 'keeps the connection open' do
+        expect(client).not_to be_closed
+        expect(server).not_to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'keep-alive')
+      end
+    end
+
+    describe 'and Connection: close' do
+      let(:requests) do
+        [finished_request(:get, '/', 'Connection' => 'close')]
+      end
+
+      it 'closes the connection after sending the response' do
+        responses
+        tick
+        expect(client).to be_closed_by_remote
+        expect(server).to be_closed_by_self
+
+        expect(responses[0].headers).to include('Connection' => 'close')
+      end
+    end
+  end
+
+  describe Hatetepe::Client, 'with KeepAlive' do
+    let(:requests) do
+      [finished_request(:get, '/close'), finished_request]
+    end
+
+    it 'negotiates keep-alive before sending further requests' do
+      expect_any_instance_of(SpecHandler)
+        .to receive(:serve).once.and_call_original
+
+      expect(responses[0].body).to eq('/close')
+      expect(responses[1]).to be_nil
+    end
+  end
+end

data/spec/integration/smoke_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Smoke test' do
+  include_context :server_client_pair
+
+  let(:response) { client.request(:get, '/') }
+  let(:request)  { intercepted_requests[0] }
+
+  it 'exchanges request and response' do
+    expect(response.status).to  be(200)
+    expect(response.headers).to include('Content-Length' => '1')
+    expect(response.body).to    eq('/')
+
+    expect(request.http_method).to be(:get)
+    expect(request.uri).to         eq('/')
+    expect(request.headers).to     include('Content-Length' => '0')
+    expect(request.body).to        eq('')
+  end
+end

data/spec/integration/streaming_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Request body streaming' do
+  include_context :server_client_pair
+
+  let(:bodies) { [] }
+  let(:chunks) { [] }
+
+  before do
+    client.perform(request)
+    tick(2)
+    intercepted_requests[0].finished.on_progress do |chunk|
+      bodies << intercepted_requests[0].body.dup
+      chunks << chunk
+    end
+  end
+
+  let(:request) { default_request }
+
+  subject! do
+    %w[foo bar baz].each do |chunk|
+      request.finished.progress(chunk)
+      tick
+    end
+    tick
+  end
+
+  it 'progressively sends the body' do
+    expect(intercepted_requests[0].headers)
+      .to include('Transfer-Encoding' => 'chunked')
+
+    expect(bodies).to eq(%w[foo foobar foobarbaz])
+    expect(chunks).to eq(%w[foo bar baz])
+  end
+end
+
+describe 'Response body streaming' do
+  include_context :server_client_pair
+
+  let(:bodies) { [] }
+  let(:chunks) { [] }
+
+  let(:response) { client.request(:get, '/streaming') }
+
+  subject! { response }
+
+  before do
+    response.finished.on_progress do |chunk|
+      bodies << response.body.dup
+      chunks << chunk
+    end
+    response.finished.sync
+  end
+
+  it 'progressively receives the body' do
+    expect(bodies).to eq(%w[foo foobar foobarbaz])
+    expect(chunks).to eq(%w[foo bar baz])
+  end
+end

data/spec/integration/timeouts_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hatetepe::Client, 'in connecting state' do
+  # connect to a non-existing host to provoke connection timeout
+  let(:address) { '1.2.3.4' }
+  let(:client_config) do
+    { address: address, port: random_port,
+      handlers: [Hatetepe::Client::Timeouts] }
+  end
+  let!(:client)  { Hatetepe::Client.new(client_config) }
+
+  after { client.close }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(client.config).to include(connect_timeout: 2.0)
+  end
+
+  describe 'with :connect_timeout option' do
+    let(:client_config) do
+      { address: address, port: random_port, connect_timeout: 0.01,
+        handlers: [Hatetepe::Client::Timeouts] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      if client.closed_reason == Errno::ENOTCONN
+        pending 'Requires network connection'
+      else
+        expect(client).to be_closed_by_timeout
+      end
+    end
+  end
+end
+
+describe Hatetepe::Client, 'in idle state' do
+  include_context :server_client_pair
+
+  let(:client_config) { { handlers: [Hatetepe::Client::Timeouts] } }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(client.config).to include(connect_timeout: 2.0)
+  end
+
+  describe 'with :timeout option' do
+    let(:client_config) do
+      { timeout: 0.01, handlers: [Hatetepe::Client::Timeouts] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      expect(client).to be_closed_by_timeout
+      expect(server).to be_closed_by_remote
+    end
+  end
+end
+
+describe Hatetepe::Server, 'in idle state' do
+  include_context :server_client_pair
+
+  let(:server_config) { { handlers: [Hatetepe::Server::Timeouts] } }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(server.config).to include(timeout: 2.0)
+  end
+
+  describe 'with :timeout option' do
+    let(:server_config) do
+      { timeout: 0.01, handlers: [Hatetepe::Server::Timeouts] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      expect(client).to be_closed_by_remote
+      expect(server).to be_closed_by_timeout
+    end
+  end
+end

data/spec/shared/integration/server_client_pair.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+shared_context :server_client_pair do
+  let(:server_config) { { handlers: [SpecHandler] } }
+  let(:client_config) { { handlers: [] } }
+  let(:interceptor)   { double('interceptor') }
+
+  let(:server_and_client) do
+    server_client_pair(server_config, client_config, interceptor)
+  end
+
+  let(:intercepted_requests) { [] }
+
+  before do
+    allow(interceptor)
+      .to receive(:serve) { |request| intercepted_requests << request }
+  end
+
+  let!(:server) { server_and_client[0] }
+  let!(:client) { server_and_client[1] }
+
+  after do
+    server.close
+    client.close
+  end
+end

data/spec/spec_helper.rb

@@ -1,16 +1,47 @@
-begin
-  require "awesome_print"
-rescue LoadError
+# encoding: utf-8
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+  end
 end
 
-require "em-synchrony"
+require 'hatetepe'
+require 'weakref'
+
+require 'awesome_print'
+
+require 'devtools/spec_helper'
+
+RSpec.configure do |config|
+  config.include(SpecHelper)
+
+  config.around do |example|
+    EM.run do
+      fiber = Fiber.new do
+        example.call
+        EM.stop
+        EM.next_tick {}
+      end
+
+      EM.add_timer(0.5) do
+        EM.stop
+        EM.next_tick {}
+        raise 'Example timed out'
+      end
 
-RSpec.configure do |c|
-  c.around do |example|
-    EM.synchrony do
-      EM.heartbeat_interval = 0.01
-      example.call
-      EM.next_tick { EM.stop }
+      fiber.resume
     end
   end
 end

data/spec/support/handler.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+class SpecHandler
+  def initialize(config, server, connection)
+  end
+
+  def serve(request)
+    response = response_for(request)
+    request.served.fulfill(response)
+  end
+
+  private
+
+  def response_for(request)
+    case request.uri
+    when '/'          then root_response.tap(&fulfill)
+    when '/sleep'     then sleep_response.tap(&fulfill)
+    when '/close'     then close_response.tap(&fulfill)
+    when '/streaming' then streaming_response
+    end
+  end
+
+  def fulfill
+    proc { |response| response.finished.fulfill }
+  end
+
+  def root_response
+    Hatetepe::Response.new(200, { 'Content-Type' => 'text/plain' }, '/')
+  end
+
+  def sleep_response
+    SpecHelper.async_sleep(0.01)
+    Hatetepe::Response.new(200, { 'Content-Type' => 'text/plain' }, '/sleep')
+  end
+
+  def close_response
+    Hatetepe::Response.new(200,
+                           { 'Content-Type' => 'text/plain',
+                             'Connection' => 'close' },
+                           '/close')
+  end
+
+  def streaming_response
+    response = Hatetepe::Response.new(200, 'Content-Type' => 'text/plain')
+    SpecHelper.defer do
+      %w[foo bar baz].each do |chunk|
+        SpecHelper.tick(2)
+        response.body << chunk
+        response.finished.progress(chunk)
+      end
+      response.finished.fulfill
+    end
+    response
+  end
+end

data/spec/support/helper.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module SpecHelper
+  def async_sleep(seconds)
+    fiber = Fiber.current
+    EM.add_timer(seconds) { fiber.resume }
+    Fiber.yield
+  end
+  module_function :async_sleep
+
+  def tick(ticks = 1)
+    fiber = Fiber.current
+    EM.next_tick { fiber.resume }
+    Fiber.yield
+
+    tick(ticks - 1) if ticks > 1
+  end
+  module_function :tick
+
+  def defer
+    EM.next_tick do
+      Fiber.new { yield }.resume
+    end
+  end
+  module_function :defer
+
+  def default_request(http_method = :get, uri = '/', headers = {})
+    Hatetepe::Request.new(http_method, uri, headers)
+  end
+
+  def finished_request(*args)
+    default_request(*args).tap { |request| request.finished.fulfill }
+  end
+
+  def default_response(status = 200, headers = {})
+    Hatetepe::Response.new(status, headers)
+  end
+
+  def finished_response(*args)
+    default_response(*args).tap { |response| response.finished.fulfill }
+  end
+
+  def localhost
+    '127.0.0.1'
+  end
+
+  def random_port
+    server = TCPServer.new(localhost, 0)
+    server.addr[1]
+  ensure
+    server.shutdown
+  end
+
+  def server_client_pair(server_config, client_config, interceptor)
+    server = nil
+    inspect_server(server_config) do |_, s, _|
+      server = s
+      interceptor
+    end
+
+    config = { address: localhost, port: random_port }
+    Hatetepe::Server.start(config.merge(server_config))
+    client = Hatetepe::Client.new(config.merge(client_config))
+
+    tick
+    [server, client]
+  end
+
+  def inspect_server(server_config, &block)
+    interceptor_class = double('interceptor_class')
+    allow(interceptor_class).to receive(:new, &block)
+    server_config[:handlers].unshift(interceptor_class)
+  end
+end