# encoding: utf-8

require 'spec_helper'

describe Hatetepe::Server do
  let(:server) { described_class.new(config, connection) }

  let(:config) do
    { address: localhost, port: random_port, handlers: [handler_class] }
  end
  let(:connection) do
    double('connection', parse:     nil,
                         closed:    double('closed', then: nil),
                         serialize: nil,
                         close: nil)
  end
  let(:handler_class) { double('handler_class', new: handler) }
  let(:handler)       { double('handler', setup: nil, respond: nil) }

  describe '.start' do
    specify { pending }
  end

  describe '#initialize' do
    subject! { server }

    its(:config) { should be(config) }

    it 'sets up connection' do
      expect(connection).to        have_received(:parse)
        .with(server.method(:serve))
      expect(connection.closed).to have_received(:then)
        .with(server.method(:shutdown))
    end

    it 'sets up handlers' do
      expect(handler_class).to have_received(:new)
        .with(config, server, connection)
      expect(handler).to       have_received(:setup)
    end
  end

  describe '#serve' do
    let(:request)  { open_request }
    let(:response) { open_response }

    before do
      allow(server).to  receive(:respond)
      allow(handler).to receive(:serve) { |_, served|
        @served = served
        @fiber = Fiber.current
      }
    end

    subject! { server.serve(request) }

    it 'sets up correlation' do
      @served.fulfill(response)
      tick
      expect(server).to have_received(:respond).with(request, response)
    end

    it 'notifies the handlers' do
      expect(handler).to    have_received(:serve)
        .with(request, kind_of(Hatetepe::Promise))
      expect(@fiber).not_to be(Fiber.current)
    end
  end

  describe '#respond' do
    let(:request)  { open_request }
    let(:response) { open_response }

    subject! { server.respond(request, response) }

    it 'writes response to underlying connection' do
      expect(connection).to have_received(:serialize).with(response)
    end

    it 'notifies the handlers' do
      expect(handler).to have_received(:respond).with(request, response)
    end
  end

  describe '#close' do
    subject! { server.close }

    it 'closes the underlying connection' do
      expect(connection).to have_received(:close)
    end
  end

  describe '#teardown' do
    specify { pending }
  end
end