content_gateway 0.1.0

data/lib/content_gateway.rb

@@ -0,0 +1,23 @@
+require "ostruct"
+require "logger"
+require "timeout"
+require "benchmark"
+require "json"
+require "rest-client"
+require "active_support/cache"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/date_time/calculations"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ContentGateway
+  extend self
+
+  def logger
+  end
+end
+
+require "content_gateway/version"
+require "content_gateway/exceptions"
+require "content_gateway/cache"
+require "content_gateway/request"
+require "content_gateway/gateway"

data/spec/integration/content_gateway/gateway_spec.rb

@@ -0,0 +1,410 @@
+require "spec_helper"
+
+describe ContentGateway::Gateway do
+  let! :url_generator do
+    url_generator = double('url_generator')
+    allow(url_generator).to receive(:generate).with(resource_path, {}).and_return("http://api.com/servico")
+    url_generator
+  end
+
+  let! :config do
+    OpenStruct.new(
+      cache: ActiveSupport::Cache::NullStore.new,
+      cache_expires_in: 15.minutes,
+      cache_stale_expires_in: 1.hour,
+      proxy: "proxy"
+    )
+  end
+
+  let :gateway do
+    ContentGateway::Gateway.new "API XPTO", config, url_generator, headers: headers
+  end
+
+  let :params do
+    { "a|b" => 1, name: "a|b|c" }
+  end
+
+  let :headers do
+    { key: 'value' }
+  end
+
+  let :resource_path do
+    "anything"
+  end
+
+  let(:timeout) { 0.1 }
+
+  let :cached_response do
+    response = "cached response"
+    response.instance_eval do
+      def code
+        200
+      end
+    end
+    response
+  end
+
+  before do
+    config.cache.clear
+  end
+
+  describe ".new" do
+    it "default_params should be optional" do
+      expect(ContentGateway::Gateway.new("API XPTO", config, url_generator)).to be_kind_of(ContentGateway::Gateway)
+    end
+  end
+
+  describe "#get" do
+    let :resource_url do
+      url_generator.generate(resource_path, {})
+    end
+
+    let :stale_cache_key do
+      "stale:#{resource_url}"
+    end
+
+    let :default_expires_in do
+      config.cache_expires_in
+    end
+
+    let :default_stale_expires_in do
+      config.cache_stale_expires_in
+    end
+
+    context "with all request params" do
+      before do
+        stub_request(method: :get, proxy: config.proxy, url: resource_url, headers: headers)
+      end
+
+      it "should do request with http get" do
+        gateway.get resource_path
+      end
+
+      context "with cache" do
+        it "should cache responses" do
+          cache_store = double("cache_store")
+          expect(cache_store).to receive(:fetch).with(resource_url, expires_in: default_expires_in)
+          config.cache = cache_store
+
+          gateway.get resource_path
+        end
+
+        it "should keep stale cache" do
+          stub_request(url: resource_url, proxy: config.proxy, headers: headers) { cached_response }
+
+          cache_store = double("cache_store")
+          expect(cache_store).to receive(:fetch).with(resource_url, expires_in: default_expires_in).and_yield
+          expect(cache_store).to receive(:write).with(stale_cache_key, cached_response, expires_in: default_stale_expires_in)
+          config.cache = cache_store
+
+          gateway.get resource_path
+        end
+
+        describe "timeout control" do
+          before do
+            stub_request(method: :get, url: resource_url, proxy: config.proxy, headers: headers) {
+              sleep(0.3)
+            }
+          end
+
+          it "should accept 'timeout' to overwrite the default value" do
+            expect(Timeout).to receive(:timeout).with(timeout)
+            gateway.get resource_path, timeout: timeout
+          end
+
+          it "should block requests that expire the configured timeout" do
+            expect { gateway.get resource_path, timeout: timeout }.to raise_error ContentGateway::TimeoutError
+          end
+
+          it "should block cache requests that expire the configured timeout" do
+            allow(config.cache).to receive(:fetch) { sleep(1) }
+            expect { gateway.get resource_path, timeout: timeout }.to raise_error ContentGateway::TimeoutError
+          end
+        end
+
+        context "with stale cache" do
+          context "on timeout" do
+            before do
+              cache_store = double("cache_store")
+              allow(cache_store).to receive(:fetch).with(resource_url, expires_in: default_expires_in).and_raise(Timeout::Error)
+              allow(cache_store).to receive(:read).with(stale_cache_key).and_return(cached_response)
+              config.cache = cache_store
+            end
+
+            it "should serve stale" do
+              expect(gateway.get(resource_path, timeout: timeout)).to eql "cached response"
+            end
+          end
+
+          context "on server error" do
+            before do
+              stub_request_with_error({method: :get, url: resource_url, proxy: config.proxy, headers: headers}, RestClient::InternalServerError.new(nil, 500))
+
+              cache_store = double("cache_store")
+              allow(cache_store).to receive(:fetch).with(resource_url, expires_in: default_expires_in).and_yield
+              allow(cache_store).to receive(:read).with(stale_cache_key).and_return(cached_response)
+              config.cache = cache_store
+            end
+
+            it "should serve stale" do
+              expect(gateway.get(resource_path)).to eql "cached response"
+            end
+          end
+        end
+      end
+
+      context "with skip_cache parameter" do
+        it "shouldn't cache requests" do
+          cache_store = double("cache_store")
+          expect(cache_store).not_to receive(:fetch).with(resource_url, expires_in: default_expires_in)
+          config.cache = cache_store
+
+          gateway.get resource_path, skip_cache: true
+        end
+
+        describe "timeout control" do
+          let(:timeout) { 0.1 }
+
+          before do
+            stub_request(method: :get, url: resource_url, proxy: config.proxy, headers: headers) {
+              sleep(0.3)
+            }
+          end
+
+          it "should ignore 'timeout' parameter" do
+            expect(Timeout).not_to receive(:timeout).with(timeout)
+            gateway.get resource_path, skip_cache: true, timeout: timeout
+          end
+        end
+
+        context "on server error" do
+          before do
+            stub_request_with_error({method: :get, url: resource_url, proxy: config.proxy, headers: headers}, RestClient::InternalServerError.new(nil, 500))
+
+            cache_store = double("cache_store")
+            expect(cache_store).not_to receive(:fetch).with(resource_url, expires_in: default_expires_in).and_yield
+            config.cache = cache_store
+          end
+
+          it "should ignore cache" do
+            expect { gateway.get(resource_path, skip_cache: true) }.to raise_error ContentGateway::ServerError
+          end
+        end
+      end
+
+      it "should raise NotFound exception on 404 error" do
+        stub_request_with_error({ method: :get, url: resource_url, proxy: config.proxy, headers: headers }, RestClient::ResourceNotFound.new)
+        expect { gateway.get resource_path }.to raise_error ContentGateway::ResourceNotFound
+      end
+
+      it "should raise Conflict exception on 409 error" do
+        stub_request_with_error({ method: :get, url: resource_url, proxy: config.proxy, headers: headers }, RestClient::Conflict.new)
+        expect { gateway.get resource_path }.to raise_error ContentGateway::ConflictError
+      end
+
+      it "should raise ServerError exception on 500 error" do
+        stub_request_with_error({ method: :get, url: resource_url, proxy: config.proxy, headers: headers }, RestClient::Exception.new(nil, 500))
+        expect { gateway.get resource_path }.to raise_error ContentGateway::ServerError
+      end
+
+      it "should raise ConnectionFailure exception on other errors" do
+        stub_request_with_error({ method: :get, url: resource_url, proxy: config.proxy, headers: headers }, SocketError.new)
+        expect { gateway.get resource_path }.to raise_error ContentGateway::ConnectionFailure
+      end
+
+      it "should accept a 'expires_in' parameter to overwrite the default value" do
+        expires_in = 3.minutes
+        cache_store = double("cache_store")
+        expect(cache_store).to receive(:fetch).with(resource_url, expires_in: expires_in)
+        config.cache = cache_store
+        gateway.get resource_path, expires_in: expires_in
+      end
+
+      it "should accept a 'stale_expires_in' parameter to overwrite the default value" do
+        stub_request(url: resource_url, proxy: config.proxy, headers: headers) { cached_response }
+
+        stale_expires_in = 5.minutes
+        cache_store = double("cache_store")
+        allow(cache_store).to receive(:fetch).with(resource_url, expires_in: default_expires_in).and_yield
+        expect(cache_store).to receive(:write).with(stale_cache_key, cached_response, expires_in: stale_expires_in)
+        config.cache = cache_store
+
+        gateway.get resource_path, stale_expires_in: stale_expires_in
+      end
+    end
+
+    context "without proxy" do
+      before do
+        config.proxy = nil
+        stub_request(method: :get, url: resource_url, headers: headers)
+      end
+
+      it "should do request with http get" do
+        gateway.get resource_path
+      end
+    end
+
+    context "overwriting headers" do
+      let :novos_headers do
+        { key2: 'value2' }
+      end
+
+      before do
+        stub_request(method: :get, proxy: config.proxy, url: resource_url, headers: novos_headers)
+      end
+
+      it "should do request with http get" do
+        gateway.get resource_path, headers: novos_headers
+      end
+    end
+  end
+
+  describe "#get_json" do
+    it "should convert the get result to JSON" do
+      expect(gateway).to receive(:get).with(resource_path, params).and_return({ "a" => 1 }.to_json)
+      expect(gateway.get_json(resource_path, params)).to eql("a" => 1)
+    end
+  end
+
+  describe "#post_json" do
+    it "should convert the post result to JSON" do
+      expect(gateway).to receive(:post).with(resource_path, params).and_return({ "a" => 1 }.to_json)
+      expect(gateway.post_json(resource_path, params)).to eql("a" => 1)
+    end
+  end
+
+  describe "#put_json" do
+    it "should convert the put result to JSON" do
+      expect(gateway).to receive(:put).with(resource_path, params).and_return({ "a" => 1 }.to_json)
+      expect(gateway.put_json(resource_path, params)).to eql("a" => 1)
+    end
+  end
+
+  describe "#post" do
+    let :resource_url do
+      url_generator.generate(resource_path, {})
+    end
+
+    let :payload do
+      { param: "value" }
+    end
+
+    it "should do request with http post" do
+      stub_request(method: :post, url: resource_url, proxy: config.proxy, payload: payload)
+      gateway.post resource_path, payload: payload
+    end
+
+    it "should raise NotFound exception on 404 error" do
+      stub_request_with_error({ method: :post, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::ResourceNotFound.new)
+      expect { gateway.post resource_path, payload: payload }.to raise_error ContentGateway::ResourceNotFound
+    end
+
+    it "should raise UnprocessableEntity exception on 401 error" do
+      stub_request_with_error({ method: :post, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::Unauthorized.new)
+      expect { gateway.post resource_path, payload: payload }.to raise_error(ContentGateway::UnauthorizedError)
+    end
+
+    it "should raise Forbidden exception on 403 error" do
+      stub_request_with_error({ method: :post, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::Forbidden.new)
+      expect { gateway.post resource_path, payload: payload }.to raise_error(ContentGateway::Forbidden)
+    end
+
+    it "should raise ConnectionFailure exception on 500 error" do
+      stub_request_with_error({ method: :post, url: resource_url, proxy: config.proxy, payload: payload }, SocketError.new)
+      expect { gateway.post resource_path, payload: payload }.to raise_error ContentGateway::ConnectionFailure
+    end
+  end
+
+  describe "#delete" do
+    let :resource_url do
+      url_generator.generate(resource_path, {})
+    end
+
+    let :payload do
+      { param: "value" }
+    end
+
+    it "should do request with http post" do
+      stub_request(method: :delete, url: resource_url, proxy: config.proxy, payload: payload)
+      gateway.delete resource_path, payload: payload
+    end
+
+    it "should raise NotFound exception on 404 error" do
+      stub_request_with_error({ method: :delete, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::ResourceNotFound.new)
+      expect { gateway.delete resource_path, payload: payload }.to raise_error ContentGateway::ResourceNotFound
+    end
+
+    it "should raise UnprocessableEntity exception on 401 error" do
+      stub_request_with_error({ method: :delete, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::Unauthorized.new)
+      expect { gateway.delete resource_path, payload: payload }.to raise_error(ContentGateway::UnauthorizedError)
+    end
+
+    it "should raise Forbidden exception on 403 error" do
+      stub_request_with_error({ method: :delete, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::Forbidden.new)
+      expect { gateway.delete resource_path, payload: payload }.to raise_error(ContentGateway::Forbidden)
+    end
+
+    it "should raise ConnectionFailure exception on 500 error" do
+      stub_request_with_error({ method: :delete, url: resource_url, proxy: config.proxy, payload: payload }, SocketError.new)
+      expect { gateway.delete resource_path, payload: payload }.to raise_error ContentGateway::ConnectionFailure
+    end
+  end
+
+  describe "#put" do
+    let :resource_url do
+      gateway.generate_url(resource_path)
+    end
+
+    let :payload do
+      { param: "value" }
+    end
+
+    it "should do request with http put" do
+      stub_request(method: :put, url: resource_url, proxy: config.proxy, payload: payload)
+      gateway.put resource_path, payload: payload
+    end
+
+    it "should raise NotFound exception on 404 error" do
+      stub_request_with_error({ method: :put, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::ResourceNotFound.new)
+      expect { gateway.put resource_path, payload: payload }.to raise_error ContentGateway::ResourceNotFound
+    end
+
+    it "should raise UnprocessableEntity exception on 422 error" do
+      stub_request_with_error({ method: :put, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::UnprocessableEntity)
+      expect { gateway.put resource_path, payload: payload }.to raise_error ContentGateway::ValidationError
+    end
+
+    it "should raise Forbidden exception on 403 error" do
+      stub_request_with_error({ method: :put, url: resource_url, proxy: config.proxy, payload: payload }, RestClient::Forbidden.new)
+      expect { gateway.put resource_path, payload: payload }.to raise_error(ContentGateway::Forbidden)
+    end
+
+    it "should raise ConnectionFailure exception on 500 error" do
+      stub_request_with_error({ method: :put, url: resource_url, proxy: config.proxy, payload: payload }, SocketError.new)
+      expect { gateway.put resource_path, payload: payload }.to raise_error ContentGateway::ConnectionFailure
+    end
+  end
+
+  private
+
+  def stub_request(opts, payload = {}, &block)
+    opts = { method: :get, proxy: :none }.merge(opts)
+    request = RestClient::Request.new(opts)
+    allow(RestClient::Request).to receive(:new).with(opts).and_return(request)
+
+    allow(request).to receive(:execute) do
+      block.call if block_given?
+    end
+
+    request
+  end
+
+  def stub_request_with_error(opts, exc)
+    opts = { method: :get, proxy: :none }.merge(opts)
+
+    request = RestClient::Request.new(opts)
+    allow(RestClient::Request).to receive(:new).with(opts).and_return(request)
+
+    allow(request).to receive(:execute).and_raise(exc)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+ENV['RACK_ENV'] = 'test'
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'byebug'
+require 'rspec'
+require 'content_gateway'
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+  SimpleCov.coverage_dir 'coverage/rspec'
+rescue LoadError
+  # ignore simplecov in ruby < 1.9
+end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/unit/content_gateway/cache_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+describe ContentGateway::Cache do
+  subject do
+    ContentGateway::Cache.new(config, url, method, params)
+  end
+
+  let(:config) { OpenStruct.new(cache: cache_store) }
+
+  let(:cache_store) { double("cache store", write: nil) }
+
+  let(:url) { "/url" }
+
+  let(:method) { :get }
+
+  let(:params) { {} }
+
+  describe "#use?" do
+    context "when skip_cache is true" do
+      let(:params) { { skip_cache: true } }
+
+      it "shouldn't use cache" do
+        expect(subject.use?).to eql false
+      end
+    end
+
+    context "when method isn't get or head" do
+      let(:method) { :post }
+
+      it "shouldn't use cache" do
+        expect(subject.use?).to eql false
+      end
+    end
+
+    context "when method is get" do
+      let(:method) { :get }
+
+      it "should use cache" do
+        expect(subject.use?).to eql true
+      end
+    end
+
+    context "when method is head" do
+      let(:method) { :head }
+
+      it "should use cache" do
+        expect(subject.use?).to eql true
+      end
+    end
+  end
+
+  describe "#fetch" do
+    let(:request) { double("request", execute: "data") }
+
+    context "when cache hits" do
+      before do
+        expect(Timeout).to receive(:timeout) do |timeout, &arg|
+          arg.call
+        end
+
+        expect(cache_store).to receive(:fetch).with(url, expires_in: 100).and_return("cached data")
+      end
+
+      it "should return the cached data" do
+        expect(subject.fetch(request, expires_in: 100)).to eql "cached data"
+      end
+    end
+
+    context "when cache misses" do
+      context "and request succeeds" do
+        before do
+          expect(Timeout).to receive(:timeout) do |timeout, &arg|
+            arg.call
+          end
+
+          expect(cache_store).to receive(:fetch) do |url, params, &arg|
+            arg.call
+          end
+        end
+
+        it "should set status to 'MISS'" do
+          subject.fetch(request)
+
+          expect(subject.status).to eql "MISS"
+        end
+
+        it "should return the request data" do
+          expect(subject.fetch(request)).to eql "data"
+        end
+
+        it "should write the request data to stale cache" do
+          expect(cache_store).to receive(:write).with("stale:/url", "data", expires_in: 15)
+
+          subject.fetch(request, stale_expires_in: 15)
+        end
+      end
+    end
+  end
+
+  describe "#serve_stale" do
+    before do
+      expect(cache_store).to receive(:read).with("stale:/url").and_return(return_value)
+    end
+
+    context "when data are successfully read from stale cache" do
+      let(:return_value) { "stale cache data" }
+
+      it "should return the stale data" do
+        expect(subject.serve_stale).to eql "stale cache data"
+      end
+
+      it "should set status to 'STALE'" do
+        subject.serve_stale
+        expect(subject.status).to eql "STALE"
+      end
+    end
+
+    context "when data can't be read from stale cache" do
+      let(:return_value) { nil }
+
+      it "should raise ContentGateway::StaleCacheNotAvailableError" do
+        expect { subject.serve_stale }.to raise_error ContentGateway::StaleCacheNotAvailableError
+      end
+    end
+  end
+
+  describe "#stale_key" do
+    let(:url) { "http://example.com" }
+
+    it "should return the stale cache key" do
+      expect(subject.stale_key).to eql "stale:http://example.com"
+    end
+  end
+end