chassis 0.1.0

data/lib/chassis/version.rb

@@ -0,0 +1,3 @@
+module Chassis
+  VERSION = "0.1.0"
+end

data/lib/chassis/web_service.rb

@@ -0,0 +1,61 @@
+require 'sinatra'
+require 'sinatra/json'
+require 'rack/contrib/bounce_favicon'
+require 'rack/deflater'
+
+module Chassis
+  class WebService < Sinatra::Base
+    ParameterMissingError = Chassis.error do |key|
+      %Q{Request did not provide "#{@key}"}
+    end
+
+    helpers do
+      def extract!(key)
+        value = params.fetch(key.to_s) do
+          raise ParameterMissingError, key
+        end
+
+        raise ParameterMissingError, key unless value.is_a?(Hash)
+
+        value
+      end
+
+      def halt_json_error(code, errors = {})
+        json_error env.fetch('sinatra.error'), code, errors
+      end
+
+      def json_error(ex, code, errors = {})
+        halt code, { 'Content-Type' => 'application/json' }, JSON.dump({
+          error: { message: ex.message }
+        }.merge(errors))
+      end
+    end
+
+    error ParameterMissingError do
+      halt_json_error 400
+    end
+
+    error Chassis::UnknownFormFieldError do
+      halt_json_error 400
+    end
+
+    error Chassis::RecordNotFoundError do
+      halt_json_error 404
+    end
+
+    use Rack::NoRobots
+    use Rack::Bouncer
+    use ::Rack::BounceFavicon
+    use ::Rack::Deflater
+    use Rack::JsonBodyParser
+
+    set :cors, false
+
+    class << self
+      def setup_default_middleware(builder)
+        super
+        builder.use Manifold::Middleware if settings.cors?
+      end
+    end
+  end
+end

data/test/array_utils_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class ArrayUtilsTest < MiniTest::Unit::TestCase
+  def utils
+    Chassis::ArrayUtils
+  end
+
+  def test_extract_options_removes_options_hash_if_present
+    args = ['foo', { bar: 'baz' }]
+    options = utils.extract_options! args
+
+    assert_equal({ bar: 'baz' }, options)
+    assert_equal(%w(foo), args)
+  end
+
+  def test_extract_options_does_nothing_if_no_options
+    args = %w(foo)
+    options = utils.extract_options! args
+
+    assert_equal({}, options)
+    assert_equal(%w(foo), args)
+  end
+end

data/test/chassis_test.rb

@@ -0,0 +1,7 @@
+require_relative 'test_helper'
+
+class ChassisTest < MiniTest::Unit::TestCase
+  def test_it_should_define_a_version
+    assert Chassis::VERSION
+  end
+end

data/test/circuit_panel_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class CircuitPanelTest < MiniTest::Unit::TestCase
+  def test_circuit_method_returns_the_given_circuit
+    panel = Chassis.circuit_panel do
+      circuit :test, timeout: 10
+    end.new
+
+    circuit = panel.test
+    assert_kind_of Breaker::Circuit, circuit
+    assert_equal :test, circuit.name
+  end
+
+  def test_options_passed_to_circuit_are_set_on_the_circuit
+    panel = Chassis.circuit_panel do
+      circuit :test, timeout: 10
+    end.new
+
+    circuit = panel.test
+    assert_equal 10, circuit.timeout
+  end
+end

data/test/core_ext/array_test.rb

@@ -0,0 +1,8 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/array'
+
+class ArrayCoreExtTest < MiniTest::Unit::TestCase
+  def test_extract_options!
+    assert_equal({}, [].extract_options!)
+  end
+end

data/test/core_ext/hash_test.rb

@@ -0,0 +1,8 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/hash'
+
+class HashCoreExtTest < MiniTest::Unit::TestCase
+  def test_symbolize
+    assert_equal({ foo: 'bar' }, { 'foo' => 'bar' }.symbolize)
+  end
+end

data/test/core_ext/string_test.rb

@@ -0,0 +1,16 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/string'
+
+class StringCoreExtTest < MiniTest::Unit::TestCase
+  def test_underscore
+    assert_equal('foo_bar', 'FooBar'.underscore)
+  end
+
+  def test_demodulize
+    assert_equal('Bar', 'Foo::Bar'.demodulize)
+  end
+
+  def test_constantize
+    assert_equal self.class, self.class.name.constantize
+  end
+end

data/test/delegate_test.rb

@@ -0,0 +1,41 @@
+require_relative 'test_helper'
+
+class DelegateTest < MiniTest::Unit::TestCase
+  class Delegator
+    include Chassis.delegate(:add, to: :object)
+
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+  end
+
+  def test_methods_are_delegated
+    delegate = Class.new do
+      def add(number)
+        number + 5
+      end
+    end.new
+
+    delegator = Delegator.new delegate
+
+    assert_equal 10, delegator.add(5)
+  end
+
+  def test_raises_an_error_if_no_object_to_delegate_to
+    delegator = Delegator.new nil
+
+    assert_raises Chassis::DelegationError do
+      delegator.add 1
+    end
+  end
+
+  def test_fails_with_an_error_if_nothing_to_delegate_to
+    assert_raises ArgumentError do
+      Class.new do
+        include Chassis.delegate(:foo, :bar)
+      end
+    end
+  end
+end

data/test/dirty_session_test.rb

@@ -0,0 +1,138 @@
+require_relative 'test_helper'
+
+class DirtySessionTest < MiniTest::Unit::TestCase
+  class Person
+    include Chassis::Initializable
+
+    attr_accessor :name, :email, :id
+  end
+
+  attr_reader :person
+
+  def setup
+    @person = Person.new do |person|
+      person.name = 'adam'
+      person.email = 'example@example.com'
+      person.id = 1
+    end
+  end
+
+  def test_initialize_as_clean
+    session = Chassis::DirtySession.new person
+    assert session.clean?
+    refute session.dirty?
+  end
+
+  def test_assigning_new_value_marks_the_session_dirty
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+  end
+
+  def test_changes_can_be_tested_via_query_method
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_respond_to session, :name_changed?, "Session should respond to changed queries"
+    assert session.name_changed?
+  end
+
+  def test_changes_include_all_new_assignments
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_equal(Set.new([:name]), session.changes)
+  end
+
+  def test_changes_are_accessible
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_equal({ name: 'foo' }, session.new_values)
+  end
+
+  def test_assigning_a_new_value_records_the_original_value
+    original_name = person.name
+    assert original_name, "Precondition: person must have a name"
+
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_equal({ name: original_name}, session.original_values)
+  end
+
+  def test_original_values_are_accessible_via_an_original_method
+    original_name = person.name
+    assert original_name, "Precondition: person must have a name"
+
+    session = Chassis::DirtySession.new person
+    session.name = 'foo'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_respond_to session, :original_name, "Session should respond to original_XXX methods"
+    assert_equal original_name, session.original_name
+  end
+
+  def test_assigning_the_same_value_does_not_count_as_a_change
+    original_name = person.name
+    assert original_name, "Precondition: person must have a name"
+
+    session = Chassis::DirtySession.new person
+    session.name = original_name
+
+    assert session.clean?, "Setting the same value should not count as a change"
+    refute session.dirty?
+  end
+
+  def test_assigning_the_same_value_multiple_times_saves_the_initial_value
+    original_name = person.name
+    assert original_name, "Precondition: person must have a name"
+
+    session = Chassis::DirtySession.new person
+    session.name = 'matthew'
+    session.name = 'michael'
+
+    refute session.clean?
+    assert session.dirty?
+
+    assert_equal original_name, session.original_name
+  end
+
+  def test_reset_moves_session_to_initial_state
+    original_name = person.name
+    assert original_name, "Precondition: person must have a name"
+
+    session = Chassis::DirtySession.new person
+    session.name = 'matthew'
+
+    refute session.clean?
+    assert session.dirty?
+
+    session.reset!
+
+    assert session.clean?
+    refute session.dirty?
+
+    assert_empty session.changes
+    assert_empty session.new_values
+    assert_empty session.original_values
+
+    refute session.name_changed?
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+class ErrorTest < MiniTest::Unit::TestCase
+  def test_delegates_to_tnt
+    klass = Chassis.error do |foo|
+      "#{foo} bar"
+    end
+
+    error = klass.new "Adam"
+    assert_equal "Adam bar", error.message
+  end
+end

data/test/faraday_test.rb

@@ -0,0 +1,749 @@
+require_relative "test_helper"
+
+class FaradayTest < MiniTest::Unit::TestCase
+  def setup
+    Harness.config.queue = Harness::SyncQueue.new
+    Harness.config.collector = Harness::FakeCollector.new
+  end
+
+  def stats
+    Harness.config.collector
+  end
+
+  def build(url = nil, options = {}, &block)
+    Faraday.new url, options, &block
+  end
+
+  def test_instruments_all_requests
+    faraday = build do |conn|
+      conn.request :instrumentation
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, JSON.dump(foo: 'bar')]
+        end
+      end
+    end
+
+    faraday.get 'test'
+
+    refute_empty stats.timers
+    timer = stats.timers.first
+
+    assert_equal 'faraday.get', timer.name
+  end
+
+  def test_instrumentation_namespace_can_be_customized
+    faraday = build 'http://example.com' do |conn|
+      conn.request :instrumentation, 'http'
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, JSON.dump(foo: 'bar')]
+        end
+      end
+    end
+
+    faraday.get 'test'
+
+    refute_empty stats.timers
+    timer = stats.timers.first
+
+    assert_equal 'http.get', timer.name
+  end
+
+  def test_sends_requests_in_json
+    faraday = build do |conn|
+      conn.request :encode_json
+
+      conn.adapter :test do |stub|
+        stub.post 'test' do |env|
+          json = JSON.load env.fetch(:body)
+          [200, {'Content-Type' => 'text/plain'}, json.fetch('foo')]
+        end
+      end
+    end
+
+    response = faraday.post 'test', foo: 'bar'
+
+    assert_equal 'bar', response.body
+  end
+
+  def test_parses_json_bodies
+    faraday = build do |conn|
+      conn.request :encode_json
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.post 'test' do |env|
+          [ 200, 
+            {'Requested-Type' => env.fetch(:request_headers).fetch('Content-Type')},
+            env.fetch(:body)
+          ]
+        end
+      end
+    end
+
+    response = faraday.post 'test', foo: 'bar'
+
+    assert_equal(JSON.dump({ 'foo' => 'bar' }), response.body)
+    assert_equal 'application/json', response.headers.fetch('Requested-Type')
+  end
+
+  def test_does_not_parse_nil_bodies
+    faraday = build do |conn|
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, nil]
+        end
+      end
+    end
+
+    response = faraday.get 'test'
+
+    assert_nil response[:body]
+  end
+
+  def test_does_not_parse_empty_bodies
+    faraday = build do |conn|
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, '']
+        end
+      end
+    end
+
+    response = faraday.get 'test'
+
+    assert_nil response[:body]
+  end
+
+  def test_does_not_parse_empty_strings
+    faraday = build do |conn|
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, '      ']
+        end
+      end
+    end
+
+    response = faraday.get 'test'
+
+    assert_nil response[:body]
+  end
+
+  def test_does_not_parse_204s
+    faraday = build do |conn|
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [204, {'Content-Type' => 'application/json'}, '']
+        end
+      end
+    end
+
+    response = faraday.get 'test'
+
+    assert_nil response[:body]
+  end
+
+  def test_does_not_parse_304s
+    faraday = build do |conn|
+      conn.response :parse_json
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [304, {'Content-Type' => 'application/json'}, '']
+        end
+      end
+    end
+
+    response = faraday.get 'test'
+
+    assert_nil response[:body]
+  end
+
+  def test_logs_requests
+    stream = StringIO.new
+    logger = Logger.new stream
+    logger.level = :debug
+
+    faraday = build 'http://example.com' do |conn|
+      conn.response :logging, logger
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {}, 'dead']
+        end
+      end
+    end
+
+    faraday.get 'test', { foo: 'bar' }, { 'This-Header' => 'has_a_value' }
+
+    stream.rewind ; content = stream.read
+
+    assert_includes content, 'http://example.com/test'
+    assert_includes content, 'This-Header'
+    assert_includes content, 'has_a_value'
+    assert_includes content, 'foo'
+    assert_includes content, 'bar'
+  end
+
+  def test_logs_responses
+    stream = StringIO.new
+    logger = Logger.new stream
+    logger.level = :debug
+
+    faraday = build 'http://example.com' do |conn|
+      conn.response :logging, logger
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'This-Header' => 'has_a_value'}, 'the_body']
+        end
+      end
+    end
+
+    faraday.get 'test'
+
+    stream.rewind ; content = stream.read
+
+    assert_includes content, '200'
+    assert_includes content, 'This-Header'
+    assert_includes content, 'has_a_value'
+    assert_includes content, 'the_body'
+  end
+
+  def test_raises_a_bad_request_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [400, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpBadRequestError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_an_unauthorized_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [401, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpUnauthorizedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_payment_required_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [402, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpPaymentRequiredError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_forbidden_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [403, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpForbiddenError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_not_found_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [404, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpNotFoundError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_method_not_allowed_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [405, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpMethodNotAllowedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_an_unacceptable_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [406, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpNotAcceptableError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_proxy_auth_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [407, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpProxyAuthenticationRequiredError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_timeout_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [408, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpRequestTimeoutError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_conflict_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [409, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpConflictError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_a_gone_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [410, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpGoneError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_length_required
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [411, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpLengthRequiredError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_precondition_failed
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [412, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpPreconditionFailedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_request_entity_too_large
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [413, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpRequestEntityTooLargeError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_request_uri_too_long
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [414, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpRequestUriTooLongError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_unsupported_media_type
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [415, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpUnsupportedMediaTypeError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_range_not_satisfiable
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [416, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpRequestRangeNotSatisfiableError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_expectation_failed
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [417, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpExpectationFailedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_unprocessable_entity
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [422, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpUnprocessableEntityError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_locked_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [423, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpLockedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_failed_dependency_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [424, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpFailedDependencyError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_upgrade_require_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [426, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpUpgradeRequiredError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_internal_server_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [500, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpInternalServerError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_not_implemented_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [501, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpNotImplementedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_bad_gateway_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [502, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpBadGatewayError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_service_unavailable
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [503, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpServiceUnavailableError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_gateway_timeout
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [504, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpGatewayTimeoutError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_http_version_not_supported_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [505, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpVersionNotSupportedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_insuffcient_storage
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [507, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpInsufficientStorageError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_raises_not_extended_error
+    faraday = build do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [510, {}, 'dead']
+        end
+      end
+    end
+
+    assert_raises Chassis::HttpNotExtendedError do
+      response = faraday.get 'test'
+    end
+  end
+
+  def test_server_errors_contain_useful_information
+    faraday = build 'http://example.com' do |conn|
+      conn.response :server_error_handler
+      conn.adapter :test do |stub|
+        stub.get 'test.error' do
+          [500, {}, 'dead']
+        end
+      end
+    end
+
+    begin
+      faraday.get 'test.error'
+    rescue => ex
+      exception = ex
+    end
+
+    assert exception
+    msg = exception.to_s
+    assert_includes msg, "http://example.com/test.error"
+  end
+
+  def test_has_factory_for_faraday_connections
+    faraday = Chassis.faraday 'http://example.com'
+
+    stack = faraday.builder.handlers
+
+    assert_includes stack, Chassis::Instrumentation
+    assert_includes stack, Chassis::EncodeJson
+    assert_includes stack, Chassis::ParseJson
+    assert_includes stack, Chassis::ServerErrorHandler
+    assert_includes stack, Chassis::Logging
+  end
+
+  def test_factory_can_change_the_namespace
+    faraday = Chassis.faraday 'http://example.com', namespace: 'test' do |conn|
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {'Content-Type' => 'application/json'}, JSON.dump(foo: 'bar')]
+        end
+      end
+    end
+
+    faraday.get 'test'
+
+    refute_empty stats.timers
+    timer = stats.timers.first
+
+    assert_equal 'test.get', timer.name
+  end
+
+  def test_factory_can_change_the_logger
+    stream = StringIO.new
+    logger = Logger.new stream
+    logger.level = :debug
+
+    faraday = Chassis.faraday 'http://example.com', logger: logger do |conn|
+      conn.adapter :test do |stub|
+        stub.get 'test' do
+          [200, {}, 'dead']
+        end
+      end
+    end
+
+    faraday.get 'test', { foo: 'bar' }, { 'This-Header' => 'has_a_value' }
+
+    stream.rewind ; content = stream.read
+
+    assert_includes content, 'http://example.com/test'
+    assert_includes content, 'This-Header'
+    assert_includes content, 'has_a_value'
+    assert_includes content, 'foo'
+    assert_includes content, 'bar'
+  end
+end