onfido 1.1.1 → 2.0.0

data/Rakefile

@@ -1 +0,0 @@
-require 'bundler/gem_tasks'

data/lib/onfido/configuration.rb

@@ -1,47 +0,0 @@
-module Onfido
-  module Configuration
-    REGION_HOSTS = {
-      us: "api.us.onfido.com",
-      ca: "api.ca.onfido.com"
-    }.freeze
-
-    attr_accessor :api_key, :region, :open_timeout, :read_timeout
-
-    def self.extended(base)
-      base.reset
-    end
-
-    def configure
-      yield self
-    end
-
-    def reset
-      self.api_key = nil
-      self.region = nil
-      self.open_timeout = 30
-      self.read_timeout = 80
-      RestClient.log = nil
-    end
-
-    def logger=(log)
-      unless log.respond_to?(:<<)
-        raise "#{log.class} doesn't seem to behave like a logger!"
-      end
-
-      RestClient.log = log
-    end
-
-    def logger
-      RestClient.log ||= NullLogger.new
-    end
-
-    def endpoint
-      region_host = region ? REGION_HOSTS[region.downcase.to_sym] : "api.onfido.com"
-      unless region_host
-        raise "The region \"#{region.downcase}\" is not currently supported"
-      end
-
-      "https://#{region_host}/v3/"
-    end
-  end
-end

data/lib/onfido/null_logger.rb

@@ -1,5 +0,0 @@
-module Onfido
-  class NullLogger
-    def <<(*args); end
-  end
-end

data/spec/integrations/exceptions_spec.rb

@@ -1,72 +0,0 @@
-describe Onfido::Resource do
-  let(:resource) { described_class.new }
-  let(:api_key) { 'some_key' }
-
-  before { allow(Onfido).to receive(:api_key).and_return(api_key) }
-
-  context '4xx response' do
-    it 'raises a custom error' do
-      path = '4xx_response'
-
-      expect { resource.get(path: path) }.
-        to raise_error(Onfido::RequestError, 'Something went wrong')
-    end
-  end
-
-  context 'unexpected error format' do
-    it 'raises a custom error' do
-      path = 'unexpected_error_format'
-
-      expect { resource.get(path: path) }.
-        to raise_error(Onfido::RequestError, /response code was 400/)
-    end
-  end
-
-  context 'unparseable JSON 5xx' do
-    it 'raises a server error' do
-      path = 'unparseable_response'
-
-      expect { resource.get(path: path) }.
-        to raise_error(Onfido::ServerError, /response code was 504/)
-    end
-  end
-
-  context 'timeout' do
-    before do
-      allow(RestClient::Request).
-        to receive(:execute).
-        and_raise(RestClient::RequestTimeout)
-    end
-
-    it 'raises a ConnectionError' do
-      expect { resource.get(path: Onfido.endpoint) }.
-        to raise_error(Onfido::ConnectionError, /Could not connect/)
-    end
-  end
-
-  context 'broken connection' do
-    before do
-      allow(RestClient::Request).
-        to receive(:execute).
-        and_raise(RestClient::ServerBrokeConnection)
-    end
-
-    it 'raises a ConnectionError' do
-      expect { resource.get(path: Onfido.endpoint) }.
-        to raise_error(Onfido::ConnectionError, /connection to the server/)
-    end
-  end
-
-  context "bad SSL certificate" do
-    before do
-      allow(RestClient::Request).
-        to receive(:execute).
-        and_raise(RestClient::SSLCertificateNotVerified.new(nil))
-    end
-
-    it 'raises a ConnectionError' do
-      expect { resource.get(path: Onfido.endpoint) }.
-        to raise_error(Onfido::ConnectionError, /SSL certificate/)
-    end
-  end
-end

data/spec/onfido/resource_spec.rb

@@ -1,133 +0,0 @@
-require 'onfido/errors/connection_error'
-
-describe Onfido::Resource do
-  subject(:resource) { described_class.new }
-
-  let(:endpoint) { 'https://api.onfido.com/v3/' }
-  let(:path)     { 'addresses/pick' }
-  let(:url)      { endpoint + path }
-  let(:payload)  { { postcode: 'SE1 4NG' } }
-  let(:api_key)  { 'some_key' }
-
-  let(:response) do
-    {
-      'addresses' => [
-        {
-          'street' => 'Main Street',
-          'town' => 'London',
-          'postcode' => 'SW4 6EH',
-          'country' => 'GBR'
-        }
-      ]
-    }
-  end
-
-  before { allow(Onfido).to receive(:endpoint).and_return(endpoint) }
-  before { allow(Onfido).to receive(:api_key).and_return(api_key) }
-
-  describe '#method_missing' do
-    %i(patch).each do |method|
-      context "for unsupported HTTP method: #{method}" do
-        it 'raises an error' do
-          expect do
-            resource.public_send(method, path: endpoint)
-          end.to raise_error(NoMethodError)
-        end
-      end
-    end
-  end
-
-  describe "API key" do
-    subject(:resource) { described_class.new(specific_api_key) }
-
-    before do
-      expect(RestClient::Request).to receive(:execute).with(
-        url: url,
-        payload: Rack::Utils.build_query(payload),
-        method: :get,
-        headers: resource.send(:headers),
-        open_timeout: 30,
-        timeout: 80
-      ).and_call_original
-
-      WebMock.stub_request(:get, url).
-        to_return(body: response.to_json, status: 200)
-    end
-
-    context "when using a specific key" do
-      let(:specific_api_key) { "specific_key" }
-
-      it "uses that key when making the request" do
-        resource.get(path: path, payload: payload)
-
-        expect(WebMock).to have_requested(:get, url).with(
-          headers: {
-            'Authorization' => "Token token=#{specific_api_key}",
-            'Accept' => "application/json",
-            'User-Agent' => "onfido-ruby/#{Onfido::VERSION}"
-          }
-        )
-      end
-    end
-
-    context "when not using a specific key" do
-      let(:specific_api_key) { nil }
-
-      it "uses the general config key when making the request" do
-        resource.get(path: path, payload: payload)
-
-        expect(WebMock).to have_requested(:get, url).with(
-          headers: {
-            'Authorization' => "Token token=#{api_key}",
-            'Accept' => "application/json",
-            'User-Agent' => "onfido-ruby/#{Onfido::VERSION}"
-          }
-        )
-      end
-    end
-  end
-
-  describe "valid http methods" do
-    %i(get post put delete).each do |method|
-      context "for supported HTTP method: #{method}" do
-        context "with a success response" do
-          before do
-            expect(RestClient::Request).to receive(:execute).
-              with(
-                url: url,
-                payload: Rack::Utils.build_query(payload),
-                method: method,
-                headers: resource.send(:headers),
-                open_timeout: 30,
-                timeout: 80
-              ).and_call_original
-
-            WebMock.stub_request(method, url).
-              to_return(body: response.to_json,
-                        status: 200,
-                        headers: { "Content-Type" => "application/json" })
-          end
-
-          it 'makes a request to an endpoint' do
-            expect(resource.public_send(method, path: path, payload: payload)).
-              to eq(response)
-          end
-        end
-
-        context "with a timeout error response" do
-          before do
-            allow_any_instance_of(RestClient::ExceptionWithResponse).
-              to receive(:response).and_return(double(body: "", code: "408"))
-            expect(RestClient::Request).to receive(:execute).
-              and_raise(RestClient::ExceptionWithResponse)
-          end
-
-          it "raises a ConnectionError" do
-            expect { resource.public_send(method, path: path, payload: payload) }.
-              to raise_error(Onfido::ConnectionError)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/onfido_spec.rb

@@ -1,83 +0,0 @@
-describe Onfido do
-  subject(:onfido) { described_class }
-  after(:each) { onfido.reset }
-
-  context 'configuration' do
-    describe "default values" do
-      describe ".api_key" do
-        subject { onfido.api_key }
-        it { is_expected.to be_nil }
-      end
-
-      describe ".endpoint" do
-        subject { onfido.endpoint }
-        it { is_expected.to eq('https://api.onfido.com/v3/') }
-      end
-
-      describe ".logger" do
-        subject { onfido.logger }
-        it { is_expected.to be_an_instance_of(Onfido::NullLogger) }
-      end
-    end
-
-    describe "setting an API key" do
-      it 'changes the configuration to the new value' do
-        onfido.api_key = 'some_key'
-        expect(onfido.api_key).to eq('some_key')
-      end
-    end
-
-    describe 'using the US region' do
-      it 'should change endpoint' do
-        onfido.region = 'us'
-        expect(onfido.endpoint).to eq('https://api.us.onfido.com/v3/')
-      end
-    end
-
-    describe 'using the CA region' do
-      it 'should change endpoint' do
-        onfido.region = 'ca'
-        expect(onfido.endpoint).to eq('https://api.ca.onfido.com/v3/')
-      end
-    end
-
-    describe 'using an unsupported region' do
-      it 'should change endpoint' do
-        onfido.region = 'de'
-        expect { onfido.endpoint }.
-          to raise_error('The region "de" is not currently supported')
-      end
-    end
-
-    describe 'using an old API token' do
-      it 'should use old endpoint' do
-        onfido.api_key = "live_asdfghjkl1234567890qwertyuiop"
-        expect(onfido.endpoint).to eq('https://api.onfido.com/v3/')
-      end
-    end
-
-    describe '.logger' do
-      context 'when an option is passed' do
-        context 'when the option passed behaves like a logger' do
-          let(:logger_like) { double('LoggerLike', :<< => nil) }
-
-          it 'returns the option' do
-            onfido.logger = logger_like
-            expect(onfido.logger).to eq(logger_like)
-          end
-        end
-
-        context 'when the option passed does not behave like a logger' do
-          let(:non_logger) { double('NotLogger') }
-
-          it 'raises an error' do
-            expect { onfido.logger = non_logger }.
-              to raise_error(
-                "#{non_logger.class} doesn't seem to behave like a logger!"
-              )
-          end
-        end
-      end
-    end
-  end
-end