faraday_cage 0.0.1

data/lib/faraday_cage/server.rb

@@ -0,0 +1,32 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+
+require 'faraday_cage/rack_middleware'
+
+module FaradayCage
+  class Server
+
+    attr_reader :app
+
+    def initialize(app = FaradayCage.app)
+      if app
+        @app = app
+      else
+        raise Error, 'No Rack app configured. Please see documentation for details.'
+      end
+
+      @middleware = RackMiddleware.new(app)
+    end
+
+    def connection
+      @connection ||= Faraday.new(FaradayCage.default_host) do |conn|
+        if FaradayCage.middleware.respond_to?(:call)
+          FaradayCage.middleware.call(conn)
+        end
+
+        conn.adapter :rack, app
+      end
+    end
+  end # Server
+end # FaradayCage

data/lib/faraday_cage/status.rb

@@ -0,0 +1,164 @@
+module FaradayCage
+  ##
+  # Wraps status codes to provide various helper methods for testing a response.
+  #
+  # @example Testing whether a status is successful.
+  #
+  #     status.success?
+  #
+  # @example Getting a status name.
+  #
+  #     status.name
+  #     # => :service_unavailable
+  #
+  # @example Comparing a status.
+  #
+  #     status == 200
+  #     # => true
+  #
+  # @example Converting a status.
+  #
+  #     status.to_i
+  #     # => 422
+  #     status.to_sym
+  #     # => :unprocessable_entity
+  #
+  # @example Testing a status by name.
+  #
+  #     status.forbidden?
+  #     # => false
+  class Status
+    MAPPINGS = {
+      100 => :continue,
+      101 => :switching_protocols,
+      102 => :processing,
+      200 => :ok,
+      201 => :created,
+      202 => :accepted,
+      203 => :non_authoritative_information,
+      204 => :no_content,
+      205 => :reset_content,
+      206 => :partial_content,
+      207 => :multi_status,
+      226 => :im_used,
+      300 => :multiple_choices,
+      301 => :moved_permanently,
+      302 => :found,
+      303 => :see_other,
+      304 => :not_modified,
+      305 => :use_proxy,
+      307 => :temporary_redirect,
+      400 => :bad_request,
+      401 => :unauthorized,
+      402 => :payment_required,
+      403 => :forbidden,
+      404 => :not_found,
+      405 => :method_not_allowed,
+      406 => :not_acceptable,
+      407 => :proxy_authentication_required,
+      408 => :request_timeout,
+      409 => :conflict,
+      410 => :gone,
+      411 => :length_required,
+      412 => :precondition_failed,
+      413 => :request_entity_too_large,
+      414 => :request_uri_too_long,
+      415 => :unsupported_media_type,
+      416 => :requested_range_not_satisfiable,
+      417 => :expectation_failed,
+      422 => :unprocessable_entity,
+      423 => :locked,
+      424 => :failed_dependency,
+      426 => :upgrade_required,
+      500 => :internal_server_error,
+      501 => :not_implemented,
+      502 => :bad_gateway,
+      503 => :service_unavailable,
+      504 => :gateway_timeout,
+      505 => :http_version_not_supported,
+      507 => :insufficient_storage,
+      510 => :not_extended
+    }
+
+    MAPPINGS.each do |code, method|
+      class_eval <<-RUBY
+        def #{method}?
+          code == #{code}
+        end
+      RUBY
+    end
+
+    attr_reader :code
+
+    def initialize(code)
+      @code = code.to_i
+    end
+
+    def ==(object)
+      if object.respond_to?(:code)
+        object.code == code
+      else
+        object == code || object == name
+      end
+    end
+
+    def name
+      @name ||= MAPPINGS[code]
+    end
+
+    def to_i
+      code
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def to_sym
+      name
+    end
+
+    def inspect
+      "#<#{self.class} code: #{code.inspect} name: #{name.inspect}>"
+    end
+
+    def type
+      @type ||= case code
+      when 100..199 then :informational
+      when 200..299 then :success
+      when 300..399 then :redirect
+      when 400..499 then :client_error
+      when 500..599 then :server_error
+      else               :unknown
+      end
+    end
+
+    def informational?
+      type == :informational
+    end
+
+    def success?
+      type == :success
+    end
+
+    def redirect?
+      type == :redirect
+    end
+
+    def client_error?
+      type == :client_error
+    end
+
+    def server_error?
+      type == :server_error
+    end
+
+    def error?
+      client_error? || server_error?
+    end
+
+    def unknown?
+      type == :unknown
+    end
+  end # Status
+end # FaradayCage

data/lib/faraday_cage/version.rb

@@ -0,0 +1,3 @@
+module FaradayCage
+  VERSION = '0.0.1'
+end

data/spec/faraday_cage/config_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe FaradayCage::Config do
+
+  describe '#initialize' do
+
+    it 'sets the default host' do
+      expect(described_class.new.default_host).to eq('http://example.com')
+    end
+  end
+
+  describe '#app' do
+
+    let(:app) do
+      nil
+    end
+
+    subject(:config) do
+      described_class.new.tap do |config|
+        config.app = app
+      end
+    end
+
+    context 'when an app is set' do
+
+      let(:app) do
+        :foo
+      end
+
+      it 'returns the set app' do
+        expect(config.app).to eq(:foo)
+      end
+    end
+
+    context 'when an app is not set' do
+
+      context 'when Rails is defined' do
+
+        it 'returns #default_rails_app' do
+          stub_const('Rails', Class.new)
+          config.should_receive(:default_rails_app).and_return(:bar)
+          expect(config.app).to eq(:bar)
+        end
+      end
+
+      context 'when Rails is not defined' do
+
+        it 'returns nil' do
+          expect(config.app).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#middleware' do
+
+    subject(:config) do
+      described_class.new
+    end
+
+    context 'when a block is given' do
+
+      it 'stores the provided block as a proc' do
+        block = -> { 'blah blah blah' }
+        config.middleware(&block)
+        expect(config.middleware).to eq(block)
+      end
+    end
+  end
+end

data/spec/faraday_cage/rack_middleware_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe FaradayCage::RackMiddleware do
+
+  describe '#initialize' do
+
+    it 'initializes with the provided app' do
+      expect(described_class.new(:foo).app).to eq(:foo)
+    end
+  end
+
+  describe '#call' do
+
+    let(:app) do
+      ->(env) { [123, { foo: 'bar' }, ['it works!']] }
+    end
+
+    subject(:middleware) do
+      described_class.new(app)
+    end
+
+    context 'when request is for /__identify__' do
+
+      let(:env) do
+        { 'PATH_INFO' => '/__identify__' }
+      end
+
+      it 'has a 200 status code' do
+        expect(middleware.call(env)[0]).to eq(200)
+      end
+
+      it 'has a content type of text/plain' do
+        expect(middleware.call(env)[1]).to eq({ 'Content-Type' => 'text/plain' })
+      end
+
+      it 'returns the object ID of the app' do
+        expect(middleware.call(env)[2]).to eq([middleware.app.object_id.to_s])
+      end
+    end
+
+    context 'when request is not for /__identify__' do
+
+      let(:env) do
+        { 'PATH_INFO' => '/something_else' }
+      end
+
+      it 'calls the app and returns the response' do
+        expect(middleware.call(env)).to eq([123, { foo: 'bar' }, ['it works!']])
+      end
+    end
+  end
+end

data/spec/faraday_cage/server_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe FaradayCage::Server do
+
+  describe '#initialize' do
+
+    let(:app) do
+      double('Rack app')
+    end
+
+    it 'wraps the provided app in RackMiddleware' do
+      expect(described_class.new(app).app).to eq(app)
+    end
+
+    context 'when there is no default app configured' do
+
+      it 'raises an error' do
+        expect { described_class.new }.to raise_error(FaradayCage::Error)
+      end
+    end
+  end
+
+  describe '#connection' do
+
+    subject(:server) do
+      described_class.new(double('Rack app'))
+    end
+
+    it 'returns a Faraday::Connection' do
+      expect(server.connection).to be_a(Faraday::Connection)
+    end
+
+    it 'sets the URL to FaradayCage.default_host' do
+      expect(server.connection.url_prefix).to eq(URI.parse(FaradayCage.default_host))
+    end
+
+    it 'uses the Rack adapter' do
+      expect(server.connection.builder.handlers.first).to eq(Faraday::Adapter::Rack)
+    end
+
+    context 'when FaradayCage.middleware is set' do
+
+      let(:middleware) do
+        double('middleware')
+      end
+
+      it 'calls the stored proc with the connection' do
+        FaradayCage.should_receive(:middleware).at_least(1).times.and_return(middleware)
+        middleware.should_receive(:respond_to?).with(:call).and_return(true)
+        middleware.should_receive(:call) { |conn| expect(conn).to be_a(Faraday::Connection) }
+        server.connection
+      end
+    end
+  end
+end

data/spec/faraday_cage/status_spec.rb

@@ -0,0 +1,375 @@
+require 'spec_helper'
+
+describe FaradayCage::Status do
+
+  describe '#initialize' do
+
+    it 'initializes with a status code' do
+      described_class.new(200)
+    end
+
+    it 'converts the status code to an integer' do
+      expect(described_class.new('500').code).to eq(500)
+    end
+  end
+
+  FaradayCage::Status::MAPPINGS.each do |code, mapping|
+
+    describe "##{mapping}?" do
+
+      it "returns true when #code equals #{code}" do
+        expect(described_class.new(code).send(:"#{mapping}?")).to be_true
+      end
+
+      it "returns false when #code does not equal #{code}" do
+        expect(described_class.new(0).send(:"#{mapping}?")).to be_false
+      end
+    end
+  end
+
+  describe '#name' do
+
+    it 'returns the mapping for the code' do
+      FaradayCage::Status::MAPPINGS.should_receive(:[]).with(5678).and_return(:foo)
+      expect(described_class.new(5678).name).to eq(:foo)
+    end
+
+    it 'caches the mapping' do
+      status = described_class.new(200)
+      expect(status.name.object_id).to eq(status.name.object_id)
+    end
+
+    context 'when there is no mapping for the code' do
+
+      it 'returns nil' do
+        expect(described_class.new(0).name).to be_nil
+      end
+    end
+  end
+
+  describe '#==' do
+
+    subject(:status) do
+      described_class.new(404)
+    end
+
+    context 'when provided object responds to #code' do
+
+      context 'when codes match' do
+
+        it 'returns true' do
+          expect(status == double('object', code: 404)).to be_true
+        end
+      end
+
+      context 'when codes do not match' do
+
+        it 'returns false' do
+          expect(status == double('object', code: 444)).to be_false
+        end
+      end
+    end
+
+    context 'when provided object does not respond to #code' do
+
+      context 'when object matches #code' do
+
+        it 'returns true' do
+          expect(status == 404).to be_true
+        end
+      end
+
+      context 'when object matches #name' do
+
+        it 'returns true' do
+          expect(status == :not_found).to be_true
+        end
+      end
+
+      context 'when object matches neither #code nor #name' do
+
+        it 'returns false' do
+          expect(status == nil).to be_false
+        end
+      end
+    end
+  end
+
+  describe '#to_i' do
+
+    it 'returns the code' do
+      status = described_class.new(42)
+      status.should_receive(:code).and_return(12)
+      expect(status.to_i).to eq(12)
+    end
+  end
+
+  describe '#to_s' do
+
+    it 'returns the name as a string' do
+      status = described_class.new(420)
+      status.should_receive(:name).and_return(:enhance_your_cool)
+      expect(status.to_s).to eq('enhance_your_cool')
+    end
+  end
+
+  describe '#to_sym' do
+
+    it 'returns the name' do
+      status = described_class.new(100)
+      status.should_receive(:name).and_return(:bar)
+      expect(status.to_sym).to eq(:bar)
+    end
+  end
+
+  describe '#inspect' do
+
+    subject(:inspection) do
+      described_class.new(200).inspect
+    end
+
+    it 'returns a string' do
+      expect(inspection).to be_a(String)
+    end
+
+    it 'includes the class name' do
+      expect(inspection).to include('#<FaradayCage::Status')
+    end
+
+    it 'includes the status code' do
+      expect(inspection).to include('code: 200')
+    end
+
+    it 'includes the status name' do
+      expect(inspection).to include('name: :ok')
+    end
+  end
+
+  describe '#type' do
+
+    context 'when #code is between 100 and 199' do
+      it 'returns :informational' do
+        expect(described_class.new(99).type).to_not eq(:informational)
+
+        (100..199).each do |code|
+          expect(described_class.new(code).type).to eq(:informational)
+        end
+
+        expect(described_class.new(200).type).to_not eq(:informational)
+      end
+    end
+
+    context 'when #code is between 200 and 299' do
+
+      it 'returns :success' do
+        expect(described_class.new(199).type).to_not eq(:success)
+
+        (200..299).each do |code|
+          expect(described_class.new(code).type).to eq(:success)
+        end
+
+        expect(described_class.new(300).type).to_not eq(:success)
+      end
+    end
+
+    context 'when #code is between 300 and 399' do
+
+      it 'returns :redirect' do
+        expect(described_class.new(299).type).to_not eq(:redirect)
+
+        (300..399).each do |code|
+          expect(described_class.new(code).type).to eq(:redirect)
+        end
+
+        expect(described_class.new(400).type).to_not eq(:redirect)
+      end
+    end
+
+    context 'when #code is between 400 and 499' do
+
+      it 'returns :client_error' do
+        expect(described_class.new(399).type).to_not eq(:client_error)
+
+        (400..499).each do |code|
+          expect(described_class.new(code).type).to eq(:client_error)
+        end
+
+        expect(described_class.new(500).type).to_not eq(:client_error)
+      end
+    end
+
+    context 'when #code is between 500 and 599' do
+
+      it 'returns :redirect' do
+        expect(described_class.new(499).type).to_not eq(:server_error)
+
+        (500..599).each do |code|
+          expect(described_class.new(code).type).to eq(:server_error)
+        end
+
+        expect(described_class.new(600).type).to_not eq(:server_error)
+      end
+    end
+
+    context 'when #code is not between 100 and 599' do
+
+      it 'returns :unknown' do
+        (0..99).each do |code|
+          expect(described_class.new(code).type).to eq(:unknown)
+        end
+
+        (600..1000).each do |code|
+          expect(described_class.new(code).type).to eq(:unknown)
+        end
+      end
+    end
+  end
+
+  describe 'status type matchers' do
+
+    subject(:status) do
+      described_class.new(rand(0..1000))
+    end
+
+    describe '#informational?' do
+
+      context 'when #type is :informational' do
+
+        it 'returns true' do
+          status.should_receive(:type).and_return(:informational)
+          expect(status.informational?).to be_true
+        end
+      end
+
+      context 'when #type is not :informational' do
+
+        it 'returns false' do
+          status.should_receive(:type).and_return(:dreadful)
+          expect(status.informational?).to be_false
+        end
+      end
+    end
+
+    describe '#success?' do
+
+      context 'when #type is :success' do
+
+        it 'returns true' do
+          status.should_receive(:type).and_return(:success)
+          expect(status.success?).to be_true
+        end
+      end
+
+      context 'when #type is not :success' do
+
+        it 'returns false' do
+          status.should_receive(:type).and_return(:failure)
+          expect(status.success?).to be_false
+        end
+      end
+    end
+
+    describe '#redirect?' do
+
+      describe 'when #type is :redirect' do
+
+        it 'returns true' do
+          status.should_receive(:type).and_return(:redirect)
+          expect(status.redirect?).to be_true
+        end
+      end
+
+      describe 'when #type is not redirect' do
+
+        it 'returns false' do
+          status.should_receive(:type).and_return(:stay_here)
+          expect(status.redirect?).to be_false
+        end
+      end
+    end
+
+    describe '#client_error?' do
+
+      context 'when #type is :client_error' do
+
+        it 'returns true' do
+          status.should_receive(:type).at_least(1).times.and_return(:client_error)
+          expect(status.client_error?).to be_true
+        end
+      end
+
+      context 'when #type is not :client_error' do
+
+        it 'returns false' do
+          status.should_receive(:type).at_least(1).times.and_return(:not_an_error)
+          expect(status.client_error?).to be_false
+        end
+      end
+    end
+
+    describe '#server_error?' do
+
+      context 'when #type is :server_error' do
+
+        it 'returns true' do
+          status.should_receive(:type).and_return(:server_error)
+          expect(status.server_error?).to be_true
+        end
+      end
+
+      context 'when #type is not :server_error' do
+
+        it 'returns false' do
+          status.should_receive(:type).and_return(:useless)
+          expect(status.server_error?).to be_false
+        end
+      end
+    end
+
+    describe '#error?' do
+
+      context 'when #type is :client_error' do
+
+        it 'returns true' do
+          status.should_receive(:type).at_least(1).times.and_return(:client_error)
+          expect(status.error?).to be_true
+        end
+      end
+
+      context 'when #type is :server_error' do
+
+        it 'returns true' do
+          status.should_receive(:type).at_least(1).times.and_return(:server_error)
+          expect(status.error?).to be_true
+        end
+      end
+
+      context 'when #type is neither :client_error nor :server_error' do
+
+        it 'returns false' do
+          status.should_receive(:type).at_least(1).times.and_return(:operator_error)
+          expect(status.error?).to be_false
+        end
+      end
+    end
+
+    describe '#unknown?' do
+
+      context 'when #type is :unknown' do
+
+        it 'returns true' do
+          status.should_receive(:type).and_return(:unknown)
+          expect(status.unknown?).to be_true
+        end
+      end
+
+      context 'when #type is not unknown' do
+
+        it 'returns false' do
+          status.should_receive(:type).and_return(:known)
+          expect(status.unknown?).to be_false
+        end
+      end
+    end
+  end
+end