routemaster-drain 1.1.0 → 2.0.0

data/lib/routemaster/errors.rb

@@ -0,0 +1,73 @@
+module Routemaster
+  module Errors
+    class BaseError < RuntimeError
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+        super(message)
+      end
+
+      def errors
+        body['errors']
+      end
+
+      def message
+        raise NotImplementedError
+      end
+
+      def body
+        @body ||= deserialized_body
+      end
+
+      private
+
+      def deserialized_body
+        @env.body.empty? ? {} : JSON.parse(@env.body)
+      end
+    end
+
+    class UnauthorizedResourceAccessError < BaseError
+      def message
+        "Unauthorized Resource Access Error"
+      end
+    end
+
+    class InvalidResourceError < BaseError
+      def message
+        "Invalid Resource Error"
+      end
+    end
+
+    class ResourceNotFoundError < BaseError
+      def message
+        "Resource Not Found Error"
+      end
+    end
+
+    class FatalResourceError < BaseError
+      def message
+        "Fatal Resource Error. body: #{body}, url: #{env.url}, method: #{env.method}"
+      end
+    end
+
+    class ConflictResourceError < BaseError
+      def message
+        "ConflictResourceError Resource Error"
+      end
+    end
+
+    class IncompatibleVersionError < BaseError
+      def message
+        headers = env.request_headers.select { |k, _| k != 'Authorization' }
+        "Incompatible Version Error. headers: #{headers}, url: #{env.url}, method: #{env.method}"
+      end
+    end
+
+    class ResourceThrottlingError < BaseError
+      def message
+        "Resource Throttling Error"
+      end
+    end
+  end
+end

data/lib/routemaster/middleware/error_handling.rb

@@ -0,0 +1,28 @@
+require 'faraday_middleware'
+require 'routemaster/errors'
+
+module Routemaster
+  module Middleware
+    class ErrorHandling < Faraday::Response::Middleware
+      ERRORS_MAPPING = {
+        (400..400) => Errors::InvalidResourceError,
+        (401..401) => Errors::UnauthorizedResourceAccessError,
+        (403..403) => Errors::UnauthorizedResourceAccessError,
+        (404..404) => Errors::ResourceNotFoundError,
+        (409..409) => Errors::ConflictResourceError,
+        (412..412) => Errors::IncompatibleVersionError,
+        (413..413) => Errors::InvalidResourceError,
+        (429..429) => Errors::ResourceThrottlingError,
+        (407..500) => Errors::FatalResourceError
+      }.freeze
+
+      def on_complete(env)
+        ERRORS_MAPPING.each do |range, error_class|
+          if range.include?(env[:status])
+            raise error_class.new(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/routemaster/middleware/{caching.rb → response_caching.rb}

@@ -2,9 +2,10 @@ require 'wisper'
 
 module Routemaster
   module Middleware
-    class Caching
+    class ResponseCaching
       KEY_TEMPLATE = 'cache:{url}'
-      FIELD_TEMPLATE = 'v:{version},l:{locale}'
+      BODY_FIELD_TEMPLATE = 'v:{version},l:{locale},body'
+      HEADERS_FIELD_TEMPLATE = 'v:{version},l:{locale},headers'
       VERSION_REGEX = /application\/json;v=(?<version>\S*)/.freeze
 
       def initialize(app, cache: Config.cache_redis, listener: nil)
@@ -27,27 +28,38 @@ module Routemaster
           response = response_env.response
 
           if response.success?
-            @cache.hset(cache_key(env), cache_field(env), response.body)
-            @cache.expire(cache_key(env), @expiry)
+            @cache.multi do |multi|
+              multi.hset(cache_key(env), body_cache_field(env), response.body)
+              multi.hset(cache_key(env), headers_cache_field(env), Marshal.dump(response.headers))
+              multi.expire(cache_key(env), @expiry)
+            end
             @listener._publish(:cache_miss, url(env)) if @listener
           end
         end
       end
 
       def fetch_from_cache(env)
-        payload = @cache.hget(cache_key(env), cache_field(env))
+        body = @cache.hget(cache_key(env), body_cache_field(env))
+        headers = @cache.hget(cache_key(env), headers_cache_field(env))
 
-        if payload
+        if body && headers
           @listener._publish(:cache_hit, url(env)) if @listener
           Faraday::Response.new(status: 200,
-                                body: payload,
-                                response_headers: {})
+                                body: body,
+                                response_headers: Marshal.load(headers),
+                                request: {})
         end
       end
 
-      def cache_field(env)
-        FIELD_TEMPLATE
-        .gsub('{version}', version(env).to_s)
+      def body_cache_field(env)
+        BODY_FIELD_TEMPLATE
+          .gsub('{version}', version(env).to_s)
+          .gsub('{locale}', locale(env).to_s)
+      end
+
+      def headers_cache_field(env)
+        HEADERS_FIELD_TEMPLATE
+          .gsub('{version}', version(env).to_s)
           .gsub('{locale}', locale(env).to_s)
       end
 

data/lib/routemaster/resources/rest_resource.rb

@@ -0,0 +1,26 @@
+require 'routemaster/api_client'
+
+module Routemaster
+  module Resources
+    class RestResource
+      attr_reader :url
+
+      def initialize(url, client: nil)
+        @url = url
+        @client = client || Routemaster::APIClient.new(response_class: Responses::HateoasResponse)
+      end
+
+      def create(params)
+        @client.post(@url, body: params)
+      end
+
+      def show(id=nil)
+        @client.get(@url.gsub('{id}', id.to_s))
+      end
+
+      def index
+        @client.get(@url)
+      end
+    end
+  end
+end

data/lib/routemaster/responses/hateoas_response.rb

@@ -0,0 +1,51 @@
+require 'faraday_middleware'
+require 'routemaster/api_client'
+require 'routemaster/responses/hateoas_response'
+require 'routemaster/resources/rest_resource'
+require 'forwardable'
+require 'json'
+
+module Routemaster
+  module Responses
+    class HateoasResponse
+      extend Forwardable
+
+      attr_reader :response
+      def_delegators :@response, :body, :status, :headers, :success?
+
+      def initialize(response, client: nil)
+        @response = response
+        @client = client || Routemaster::APIClient.new(response_class: Routemaster::Responses::HateoasResponse)
+      end
+
+      def method_missing(m, *args, &block)
+        method_name = m.to_s
+        normalized_method_name = method_name == '_self' ? 'self' : method_name
+
+        if _links.keys.include?(normalized_method_name)
+          unless respond_to?(method_name)
+            resource = Resources::RestResource.new(_links[normalized_method_name]['href'], client: @client)
+
+            self.class.send(:define_method, method_name) do |*m_args|
+              resource
+            end
+
+            resource
+          end
+        else
+          super
+        end
+      end
+
+      def body_without_links
+        body.reject { |key, _| ['_links'].include?(key) }
+      end
+
+      private
+
+      def _links
+        @links ||= @response.body.fetch('_links', {})
+      end
+    end
+  end
+end

data/routemaster-drain.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency     'faraday', '>= 0.9.0'
   spec.add_runtime_dependency     'faraday_middleware'
   spec.add_runtime_dependency     'net-http-persistent', '< 3' # 3.x is currently incompatible with faraday
-  spec.add_runtime_dependency     'rack', '>= 1.6.2'
+  spec.add_runtime_dependency     'rack', '>= 1.4.5'
   spec.add_runtime_dependency     'wisper', '~> 1.6.1'
   spec.add_runtime_dependency     'hashie'
   spec.add_runtime_dependency     'redis-namespace'

data/spec/routemaster/{fetcher_spec.rb → api_client_spec.rb}

@@ -2,10 +2,10 @@ require 'spec_helper'
 require 'spec/support/uses_dotenv'
 require 'spec/support/uses_redis'
 require 'spec/support/uses_webmock'
-require 'routemaster/fetcher'
+require 'routemaster/api_client'
 require 'json'
 
-describe Routemaster::Fetcher do
+describe Routemaster::APIClient do
   uses_dotenv
   uses_redis
   uses_webmock
@@ -24,6 +24,14 @@ describe Routemaster::Fetcher do
           'content-type' => 'application/json;v=1'
         }
       )
+
+      @post_req = stub_request(:post, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
     end
 
     it 'GETs from the URL' do
@@ -31,6 +39,15 @@ describe Routemaster::Fetcher do
       expect(@req).to have_been_requested
     end
 
+    context 'POST request' do
+      subject { fetcher.post(url, body: {}, headers: headers) }
+
+      it 'POSTs from the URL' do
+        subject
+        expect(@post_req).to have_been_requested
+      end
+    end
+
     it 'has :status, :headers, :body' do
       expect(subject.status).to eq(200)
       expect(subject.headers).to have_key('content-type')
@@ -56,5 +73,19 @@ describe Routemaster::Fetcher do
         expect(req.headers).to include('X-Custom-Header')
       end
     end
+
+    context 'when response_class is present' do
+      before do
+        class DummyResponse
+          def initialize(res, client: nil); end
+        end
+      end
+
+      let(:fetcher) { described_class.new(response_class: DummyResponse) }
+
+      it 'returns a response_class instance as a response' do
+        expect(subject).to be_an_instance_of(DummyResponse)
+      end
+    end
   end
 end

data/spec/routemaster/cache_spec.rb

@@ -3,7 +3,7 @@ require 'spec/support/uses_redis'
 require 'spec/support/uses_dotenv'
 require 'spec/support/uses_webmock'
 require 'routemaster/cache'
-require 'routemaster/fetcher'
+require 'routemaster/api_client'
 
 module Routemaster
   describe Cache do
@@ -27,8 +27,8 @@ module Routemaster
       context 'with no options' do
         let(:options) { {} }
 
-        it 'calls get on the fetcher with no version and locale headers' do
-          expect_any_instance_of(Fetcher)
+        it 'calls get on the api client with no version and locale headers' do
+          expect_any_instance_of(APIClient)
             .to receive(:get)
             .with(url, headers: { 'Accept' => 'application/json' })
             .and_call_original
@@ -40,8 +40,8 @@ module Routemaster
       context 'with a specific version' do
         let(:options) { { version: 2 } }
 
-        it 'calls get on the fetcher with version header' do
-          expect_any_instance_of(Fetcher)
+        it 'calls get on the api client with version header' do
+          expect_any_instance_of(APIClient)
             .to receive(:get)
             .with(url, headers: { 'Accept' => 'application/json;v=2' })
             .and_call_original
@@ -53,8 +53,8 @@ module Routemaster
       context 'with a specific locale' do
         let(:options) { { locale: 'fr' } }
 
-        it 'calls get on the fetcher with locale header' do
-          expect_any_instance_of(Fetcher)
+        it 'calls get on the api client with locale header' do
+          expect_any_instance_of(APIClient)
             .to receive(:get)
             .with(url, headers: { 'Accept' => 'application/json', 'Accept-Language' => 'fr' })
             .and_call_original

data/spec/routemaster/integration/api_client_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'spec/support/uses_redis'
+require 'spec/support/uses_dotenv'
+require 'routemaster/api_client'
+require 'webrick'
+
+RSpec.describe 'Api client integration specs' do
+  uses_dotenv
+  uses_redis
+
+  let!(:log) { WEBrick::Log.new '/dev/null' }
+  let(:service) do
+    WEBrick::HTTPServer.new(Port: 8000, DocumentRoot: Dir.pwd, Logger: log).tap do |server|
+      [400, 401, 403, 404, 409, 412, 413, 429, 500].each do |status_code|
+        server.mount_proc "/#{status_code}" do |req, res|
+          res.status = status_code
+          res.body = { field: 'test' }.to_json
+        end
+      end
+    end
+  end
+
+  before do
+    @pid = fork do
+      trap 'INT' do service.shutdown end
+      service.start
+    end
+    sleep(0.5) # leave sometime for the previous webrick to teardown
+  end
+
+  after do
+    Process.kill('KILL', @pid)
+    Process.wait(@pid)
+  end
+
+  subject { Routemaster::APIClient.new }
+  let(:host) { 'http://localhost:8000' }
+
+  describe 'error handling' do
+    it 'raises an ResourceNotFoundError on 404' do
+      expect { subject.get(host + '/404') }.to raise_error(Routemaster::Errors::ResourceNotFoundError)
+    end
+
+    it 'raises an InvalidResourceError on 400' do
+      expect { subject.get(host + '/400') }.to raise_error(Routemaster::Errors::InvalidResourceError)
+    end
+
+    it 'raises an UnauthorizedResourceAccessError on 401' do
+      expect { subject.get(host + '/401') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccessError)
+    end
+
+    it 'raises an UnauthorizedResourceAccessError on 403' do
+      expect { subject.get(host + '/403') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccessError)
+    end
+
+    it 'raises an ConflictResourceError on 409' do
+      expect { subject.get(host + '/409') }.to raise_error(Routemaster::Errors::ConflictResourceError)
+    end
+
+    it 'raises an IncompatibleVersionError on 412' do
+      expect { subject.get(host + '/412') }.to raise_error(Routemaster::Errors::IncompatibleVersionError)
+    end
+
+    it 'raises an InvalidResourceError on 413' do
+      expect { subject.get(host + '/413') }.to raise_error(Routemaster::Errors::InvalidResourceError)
+    end
+
+    it 'raises an ResourceThrottlingError on 429' do
+      expect { subject.get(host + '/429') }.to raise_error(Routemaster::Errors::ResourceThrottlingError)
+    end
+
+    it 'raises an FatalResourceError on 500' do
+      expect { subject.get(host + '/500') }.to raise_error(Routemaster::Errors::FatalResourceError)
+    end
+  end
+end

data/spec/routemaster/integration/cache_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe 'Requests with caching' do
   subject { Routemaster::Cache.new }
 
   describe 'GET request' do
-    let(:cache_keys) { ["cache:#{url}", "v:,l:"] }
+    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
+    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
     let(:url) { 'http://localhost:8000/test' }
 
     context 'when there is no previous cached response' do
@@ -44,10 +45,16 @@ RSpec.describe 'Requests with caching' do
 
       it 'sets the new response onto the cache' do
         expect { subject.get(url) }
-          .to change { Routemaster::Config.cache_redis.hget(*cache_keys)}
+          .to change { Routemaster::Config.cache_redis.hget(*body_cache_keys)}
           .from(nil)
           .to({ field: 'test'}.to_json)
       end
+
+      it 'sets the response headers onto the cache' do
+        expect { subject.get(url) }
+          .to change { Routemaster::Config.cache_redis.hget(*headers_cache_keys)}
+          .from(nil)
+      end
     end
 
     context 'when there is a previous cached response' do
@@ -61,7 +68,7 @@ RSpec.describe 'Requests with caching' do
 
       it 'does not make an http call' do
         response = subject.get(url)
-        expect(response.headers['server']).to be_nil
+        expect(response.env.request).to be_empty
       end
     end
   end

data/spec/routemaster/middleware/authenticate_spec.rb

@@ -8,11 +8,11 @@ describe Routemaster::Middleware::Authenticate do
   let(:app) { described_class.new(ErrorRackApp.new, options) }
   let(:listener) { double 'listener', on_authenticate: nil }
   let(:options) {{ uuid: 'demo' }}
-  
+
   def perform
     post '/whatever'
   end
-  
+
   before { Wisper.subscribe(listener, scope: described_class.name, prefix: true) }
   after { Wisper::GlobalListeners.clear }
 

data/spec/routemaster/resources/rest_resource_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'routemaster/resources/rest_resource'
+
+module Routemaster
+  module Resources
+    RSpec.describe RestResource do
+      let(:url) { 'test_url' }
+      let(:client) { double('Client') }
+      let(:params) { {} }
+
+      subject { described_class.new(url, client: client) }
+
+      describe '#create' do
+        it 'posts to the given url' do
+          expect(client).to receive(:post).with(url, body: params)
+          subject.create(params)
+        end
+      end
+
+      describe '#show' do
+        it 'gets to the given url' do
+          expect(client).to receive(:get).with(url)
+          subject.show(1)
+        end
+      end
+
+      describe '#index' do
+        it 'gets to the given url' do
+          expect(client).to receive(:get).with(url)
+          subject.index
+        end
+      end
+    end
+  end
+end

data/spec/routemaster/responses/hateoas_response_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'routemaster/responses/hateoas_response'
+
+module Routemaster
+  module Responses
+    RSpec.describe HateoasResponse do
+      let(:response) { double('Response', status: status, body: body, headers: headers) }
+      let(:status) { 200 }
+      let(:body) { {}.to_json }
+      let(:headers) { {} }
+
+      subject { described_class.new(response) }
+
+      context 'link traversal' do
+        let(:body) do
+          {
+            '_links' => {
+              'self' => { 'href' => 'self_url' },
+              'resource_a' => { 'href' => 'resource_a_url' },
+              'resource_b' => { 'href' => 'resource_b_url' }
+            }
+          }
+        end
+
+        it 'creates a method for every key in _links attribute' do
+          expect(subject.resource_a.url).to eq('resource_a_url')
+          expect(subject.resource_b.url).to eq('resource_b_url')
+        end
+
+        it 'creates a _self method if there is a link with name self' do
+          expect(subject._self.url).to eq('self_url')
+        end
+
+        it 'raise an exception when requested link does not exist' do
+          expect { subject.some_unsupported_link }.to raise_error(NoMethodError)
+        end
+
+        describe '#body_without_links' do
+          before do
+            body.merge!('foo' => 'bar')
+          end
+
+          it 'returns the body without the _links key' do
+            expect(subject.body_without_links).to eq({ 'foo' => 'bar' })
+          end
+        end
+      end
+    end
+  end
+end