http_api_client 0.1.0

data/lib/http_api_client.rb

@@ -0,0 +1,67 @@
+require "http_api_client/version"
+require "http_api_client/errors"
+require "http_api_client/config"
+require "http_api_client/client"
+
+module HttpApiClient
+
+
+  def self.env
+    if @env
+      @env
+    elsif rails
+      rails.env
+    else
+      "test"
+    end
+  end
+
+  def self.env=(env)
+    @env = env
+  end
+
+  def self.logger
+    if rails
+      rails.logger
+    else
+      puts 'Logger not defined, using stub logger that does nothing. Set logger via HttpApiClient.logger = my_logger'
+      StubLogger
+    end
+  end
+
+  def self.params_encoder
+    if rails
+      RailsParamsEncoder
+    else
+      Faraday::Utils.default_params_encoder
+    end
+  end
+
+  private
+
+  def self.rails
+    Module.const_get('Rails')
+  rescue NameError
+    nil
+  end
+
+  class StubLogger
+
+    def self.info(message)
+      #Stub implementation
+    end
+
+    def self.debug(message)
+      #Stub implementation
+    end
+
+    def self.warn(message)
+      #Stub implementation
+    end
+
+    def self.error(message)
+      #Stub implementation
+    end
+
+  end
+end

data/spec/config/http_api_clients.yml

@@ -0,0 +1,6 @@
+test:
+  my_client:
+    protocol: 'http'
+    server: test-server
+    port: 80
+    base_uri: test-base-uri

data/spec/config/http_api_clients_with_basic_auth.yml

@@ -0,0 +1,8 @@
+test:
+  my_client:
+    protocol: 'https'
+    server: test-server
+    port: 443
+    base_uri: test-base-uri
+    http_basic_username: admin
+    http_basic_password: password

data/spec/config/http_api_clients_with_request_id.yml

@@ -0,0 +1,7 @@
+test:
+  my_client:
+    protocol: 'http'
+    server: test-server
+    port: 80
+    base_uri: test-base-uri
+    include_request_id_header: true

data/spec/config/http_api_clients_with_self_signed_cert.yml

@@ -0,0 +1,7 @@
+test:
+  my_client:
+    protocol: 'https'
+    server: test-server
+    port: 443
+    base_uri: test-base-uri
+    ca_file:  /usr/local/etc/nginx/test-server.crt

data/spec/config/http_api_clients_with_ssl.yml

@@ -0,0 +1,6 @@
+test:
+  my_client:
+    protocol: 'https'
+    server: test-server
+    port: 443
+    base_uri: test-base-uri

data/spec/http_api_client_spec.rb

@@ -0,0 +1,58 @@
+require 'http_api_client'
+
+describe HttpApiClient do
+
+  context "without rails" do
+
+    describe ".env" do
+      it 'returns "test" by default' do
+        expect(HttpApiClient.env).to eq 'test'
+      end
+
+      it 'can be set' do
+        HttpApiClient.env = 'staging'
+        expect(HttpApiClient.env).to eq 'staging'
+        HttpApiClient.env = nil
+      end
+    end
+
+    describe ".logger" do
+      it 'returns a stub logger' do
+        expect(HttpApiClient.logger).to_not be_nil
+      end
+    end
+
+  end
+
+  context "with rails" do
+
+    before :each do
+      allow(HttpApiClient).to receive(:rails).and_return(StubRails)
+    end
+
+    describe ".env" do
+      it 'returns the current rails environment' do
+        expect(HttpApiClient.env).to eq StubRails.env
+      end
+    end
+
+    describe ".logger" do
+      it 'returns the rails logger' do
+        expect(HttpApiClient.logger).to eq StubRails.logger
+      end
+    end
+
+  end
+
+  class StubRails
+
+    def self.env
+      'custom_env'
+    end
+
+    def self.logger
+      'rails_logger'
+    end
+  end
+
+end

data/spec/http_client/client_spec.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+require 'http_api_client/client'
+
+module HttpApiClient
+  describe Client do
+
+    let(:client) { Client.new(:my_client, 'spec/config/http_api_clients.yml') }
+
+    let(:get_response)    { double('get response', body: '{"id": 1}', status: 200) }
+    let(:post_response)   { double('post response', body: '{"id": 1}', status: 200) }
+    let(:put_response)    { double('put response', body: '{"id": 1}', status: 200) }
+    let(:delete_response) { double('delete response', body: nil, status: 200) }
+
+    let(:connection) { double('connection', get: get_response, post: post_response, put: put_response, delete: delete_response) }
+
+    let(:base_get_headers) do
+      { 'Accept' => 'application/json' }
+    end
+
+    let(:base_update_headers) do
+      base_get_headers.merge({ 'Accept' => 'application/json', 'Content-Type' => 'application/json' })
+    end
+
+    before do
+      client.stub(:connection).and_return connection
+    end
+
+    describe "#find" do
+      it "calls http connection with get and correct url" do
+        connection.should_receive(:get).with('/test-base-uri/path/1', {}, base_get_headers)
+        client.find('/path', 1)
+      end
+    end
+
+    describe "#find_all" do
+      it "calls http connection with correct url without query" do
+        connection.should_receive(:get).with('/test-base-uri/resources', {}, base_get_headers)
+        client.find_all('/resources')
+      end
+
+      it "calls http connection with correct url with query" do
+        connection.should_receive(:get).with("/test-base-uri/resources", { a: 1 }, base_get_headers)
+        client.find_all('/resources', { a: 1 })
+      end
+    end
+
+    describe "#find_nested" do
+      it "calls http connection with get and correct url" do
+        connection.should_receive(:get).with('/test-base-uri/resource/1/resources', {}, base_get_headers)
+        client.find_nested('/resource', 1, '/resources')
+      end
+    end
+
+    describe "#create" do
+
+      context "with auth params" do
+        let(:client) do
+          klass = Class.new(Client) do
+            def auth_params
+              {:key => 'one'}
+            end
+          end
+          klass.new(:my_client, 'spec/config/http_api_clients_with_basic_auth.yml')
+        end
+
+        it "calls http connection with post and correct url and post data" do
+          payload = { text: "hello", :key => 'one' }
+          connection.should_receive(:post).with('/test-base-uri/path', JSON.fast_generate(payload), base_update_headers)
+          client.create('/path', payload)
+        end
+      end
+
+      it "calls http connection with post and correct url and post data" do
+        payload = { text: "hello"}
+        connection.should_receive(:post).with('/test-base-uri/path', JSON.fast_generate(payload), base_update_headers)
+        client.create('/path', payload)
+      end
+
+    end
+
+    describe "#delete" do
+      it "calls http connection with delete and correct url" do
+        connection.should_receive(:delete).with('/test-base-uri/path/1', base_update_headers)
+        client.destroy('/path', 1)
+      end
+    end
+
+    describe "auth_params" do
+      it "appends auth params to request" do
+        client.stub(:auth_params).and_return({ token: 'abc123' })
+        connection.should_receive(:get).with("/test-base-uri/protected", { token: 'abc123' }, base_get_headers)
+        client.get('/protected')
+      end
+    end
+
+    describe "response status code handling" do
+
+      context "with a response with a status code in the 200 range" do
+        let(:response) { double('response', :body => '{"id": 1}', status: 200) }
+
+        describe "response" do
+          it "returns expected response body as hash" do
+            response = client.find('/path', 1)
+            expect(response['id']).to eq 1
+          end
+        end
+      end
+
+      context "with a response in the 400 range" do
+        let(:get_response) { double('response', :body => '{"id": 1}', status: 404) }
+
+        describe "raising exceptions" do
+          it "raises the expected exception for the status" do
+            lambda { client.find('/path', 1) }.should raise_error(Errors::NotFound)
+          end
+        end
+      end
+
+      context "with a response in the 500 range" do
+        let(:get_response) { double('response', :body => '{"id": 1}', status: 500) }
+
+        describe "raising exceptions" do
+          it "raises the expected exception for the status" do
+            lambda { client.find('/path', 1) }.should raise_error(Errors::InternalServerError)
+          end
+        end
+      end
+
+    end
+
+    context 'without request id tracking configured' do
+      it "does not add the Request-Id header to the request" do
+        connection.should_receive(:get).with('/test-base-uri/path/1', {}, base_get_headers)
+        client.find('/path', 1)
+      end
+    end
+
+    context "with request id tracking configured" do
+
+      let(:client) { Client.new(:my_client, 'spec/config/http_api_clients_with_request_id.yml') }
+
+      let(:request_id) { 'abc-123' }
+
+      before do
+        Thread.current[:request_id] = request_id
+      end
+
+      it "adds the Request-Id header to the request" do
+        connection.should_receive(:get).with('/test-base-uri/path/1', {}, base_get_headers.merge('X-Request-Id' => request_id))
+        client.find('/path', 1)
+      end
+    end
+
+  end
+end
+

data/spec/http_client/config_spec.rb

@@ -0,0 +1,32 @@
+# require 'spec_helper'
+require 'http_api_client/config'
+module HttpApiClient
+
+  describe Config do
+
+    let(:config) { Config.new(config_file) }
+
+    context "with an invalid config file" do
+
+      let(:config_file) { 'invalid' }
+
+      it "raises error" do
+        expect{ config }.to raise_error("Could not load config file: #{config_file}")
+      end
+    end
+
+    context "with a valid config file" do
+
+      let(:config_file) { 'spec/config/http_api_clients.yml' }
+
+      it 'loads the config for the environment' do
+        expect(config.my_client.protocol).to eql 'http'
+        expect(config.my_client.server).to eql 'test-server'
+        expect(config.my_client.port).to eql 80
+        expect(config.my_client.base_uri).to eql 'test-base-uri'
+      end
+    end
+
+  end
+
+end

data/spec/http_client/connection_factory_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+# require 'spec_helper'
+
+require 'http_api_client/connection_factory'
+require 'http_api_client/config'
+
+module HttpApiClient
+
+  describe ConnectionFactory do
+
+
+    let(:config) { Config.new(config_file).send(client_id) }
+    let(:client_id) { 'my_client' }
+    let(:connection_factory) { ConnectionFactory.new(config) }
+    let(:connection) { connection_factory.create }
+
+    context "without ssl" do
+
+      let(:config_file) { 'spec/config/http_api_clients.yml' }
+
+      it "creates a connection based on config" do
+        expect(connection.url_prefix.to_s).to eq 'http://test-server/'
+      end
+
+      it "caches the connection for reuse" do
+        expect(connection).to eq connection
+      end
+    end
+
+    context "with ssl" do
+
+      context 'when a self-signed certificate authority is specified' do
+
+        let(:config_file) { 'spec/config/http_api_clients_with_self_signed_cert.yml' }
+
+        it "creates a connection based on config" do
+          expect(connection.url_prefix.to_s).to eq 'https://test-server/'
+        end
+
+        it 'sets ca_file path correctly' do
+          expect(connection.ssl.ca_file).to eq '/usr/local/etc/nginx/test-server.crt'
+        end
+      end
+
+      context 'when the machine is OSX' do
+
+        let(:config_file) { 'spec/config/http_api_clients_with_ssl.yml' }
+
+        before { connection_factory.stub(osx?: true) }
+
+        it "creates a connection based on config" do
+          expect(connection.url_prefix.to_s).to eq 'https://test-server/'
+        end
+
+        it "sets the ssl options" do
+          expect(connection.ssl.ca_file).to eq ConnectionFactory::OSX_CERT_PATH
+        end
+      end
+
+      context 'when the machine is not OSX' do
+
+        let(:config_file) { 'spec/config/http_api_clients_with_ssl.yml' }
+
+        before { connection_factory.stub(osx?: false) }
+
+        it "creates a connection based on config" do
+          expect(connection.url_prefix.to_s).to eq 'https://test-server/'
+        end
+
+        it "sets the ssl options" do
+          expect(connection.ssl.ca_path).to eq '/etc/ssl/certs'
+        end
+      end
+    end
+
+    describe 'http basic auth' do
+
+      context 'when auth is not specified' do
+
+        let(:config_file) { 'spec/config/http_api_clients.yml' }
+
+        it 'does not set the auth on the connection' do
+          expect(connection.headers[:Authorization]).to be_nil
+        end
+      end
+
+      context 'when auth is specified' do
+
+        let(:config_file) { 'spec/config/http_api_clients_with_basic_auth.yml' }
+
+        it 'sets the auth on the connection' do
+          expect(connection.headers[:Authorization]).to_not be_nil
+        end
+      end
+    end
+  end
+
+end

data/spec/http_client/errors_spec.rb

@@ -0,0 +1,35 @@
+
+require 'http_api_client/errors'
+
+module HttpApiClient
+  module Errors
+
+    describe BaseError do
+
+      let(:nested_error)  { double('nested', message: 'nested_message') }
+
+      let(:error) { BaseError.new("message", "response_body", nested_error) }
+
+      it "stores the response_body" do
+        expect(error.response_body).to eq "response_body"
+      end
+
+      it "stores the nested_error" do
+        expect(error.nested_error).to eq nested_error
+      end
+
+      it "returns the message in message (duh)" do
+        expect(error.message).to include "message"
+      end
+
+      it "returns the response_body in message" do
+        expect(error.message).to include "response_body"
+      end
+
+      it "returns the nested_error in message" do
+        expect(error.message).to include "nested_message"
+      end
+
+    end
+  end
+end

data/spec/http_client/timed_result_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'http_api_client/timed_result'
+
+module HttpApiClient
+
+  describe TimedResult do
+
+    context 'without extra log data' do
+
+      let(:request_id) { 'abc-123' }
+      let(:logger) { HttpApiClient.logger }
+
+      before do
+        TimedResult.stub(:millis_since).and_return 1000
+        Thread.current[:request_id] = request_id
+      end
+
+      it 'logs event with base data' do
+        logger.should_receive(:info).with("event=my_event, request_id=#{request_id}, timing=#{1000}")
+        TimedResult.time('my_event') {  }
+      end
+
+      it 'logs event with extra data' do
+        logger.should_receive(:info).with("event=my_event, request_id=#{request_id}, timing=#{1000}, foo=bar")
+        TimedResult.time('my_event', { foo: 'bar' }) {  }
+      end
+
+    end
+  end
+end