finapps_core 2.0.2

data/lib/finapps_core/rest/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module REST
+    # Represents the client configuration options
+    class Configuration # :nodoc:
+      using ObjectExtensions
+
+      attr_accessor :host,
+                    :tenant_identifier, :tenant_token,
+                    :user_identifier, :user_token,
+                    :proxy, :timeout, :retry_limit, :log_level
+
+      def initialize(options={})
+        non_nil_options = options.select {|_, value| !value.nil? }
+        FinAppsCore::REST::Defaults::DEFAULTS.merge(non_nil_options)
+                                             .each {|key, value| public_send("#{key}=", value) }
+        raise FinAppsCore::InvalidArgumentsError.new "Invalid argument. {host: #{host}}" unless valid_host?
+        raise FinAppsCore::InvalidArgumentsError.new "Invalid argument. {timeout: #{timeout}}" unless timeout.integer?
+      end
+
+      def valid_user_credentials?
+        FinAppsCore::REST::Credentials.new(user_identifier, user_token).valid?
+      end
+
+      private
+
+      def valid_host?
+        host.start_with?('http://', 'https://')
+      end
+    end
+  end
+end

data/lib/finapps_core/rest/connection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module REST
+    module Connection # :nodoc:
+      # @return [Faraday::Connection]
+      def faraday(config, logger)
+        options = {
+          url: "#{config.host}/v#{Defaults::API_VERSION}/",
+          request: {open_timeout: config.timeout,
+                    timeout: config.timeout}
+        }
+
+        Faraday.new(options) do |conn|
+          conn.request :accept_json
+          conn.request :user_agent
+          conn.request :tenant_authentication, config.tenant_identifier, config.tenant_token
+          conn.request :json
+          conn.request :retry
+          conn.request :multipart
+          conn.request :url_encoded
+          conn.request :no_encoding_basic_authentication, config.user_token if config.valid_user_credentials?
+
+          conn.use FinAppsCore::Middleware::RaiseError
+          conn.response :rashify
+          conn.response :json, content_type: /\bjson$/
+          conn.response :custom_logger, logger, bodies: (ENV['SILENT_LOG_BODIES'] != 'true')
+
+          # Adapter (ensure that the adapter is always last.)
+          conn.adapter :typhoeus
+        end
+      end
+      module_function :faraday # becomes available as a *private instance method* to classes that mix in the module
+    end
+  end
+end

data/lib/finapps_core/rest/credentials.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module REST
+    # represents both tenant and user credentials
+    class Credentials
+      using ObjectExtensions
+      using StringExtensions
+
+      attr_reader :identifier, :token
+
+      def initialize(identifier, token)
+        @identifier = identifier
+        @token = token
+      end
+
+      def valid?
+        identifier.present? && token.present?
+      end
+    end
+  end
+end

data/lib/finapps_core/rest/defaults.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module REST
+    module Defaults
+      API_VERSION = '2'
+
+      # noinspection SpellCheckingInspection
+      DEFAULTS = {
+        host:             'https://api.financialapps.com',
+        user_identifier:  nil,
+        user_token:       nil,
+        timeout:          30,
+        proxy:            nil,
+        retry_limit:      1,
+        log_level:        Logger::INFO
+      }.freeze
+    end
+  end
+end

data/lib/finapps_core/rest/resources.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module REST
+    class Resources # :nodoc:
+      include FinAppsCore::Utils::ParameterFilter
+      require 'erb'
+
+      attr_reader :client
+
+      # @param [FinAppsCore::REST::Client] client
+      # @return [FinAppsCore::REST::Resources]
+      def initialize(client)
+        raise MissingArgumentsError.new 'Missing argument: client.' if client.nil?
+        @client = client
+      end
+
+      def list(path=nil)
+        path = end_point.to_s if path.nil?
+        request_with_body(path, :get, {})
+      end
+
+      def create(params={}, path=nil)
+        request_with_body(path, :post, params)
+      end
+
+      def update(params={}, path=nil)
+        request_with_body(path, :put, params)
+      end
+
+      def show(id=nil, path=nil)
+        request_without_body(path, :get, id)
+      end
+
+      def destroy(id=nil, path=nil)
+        request_without_body(path, :delete, id)
+      end
+
+      def request_without_body(path, method, id)
+        raise MissingArgumentsError.new 'Missing argument: id.' if id.nil? && path.nil?
+        path = "#{end_point}/:id".sub ':id', ERB::Util.url_encode(id) if path.nil?
+        request_with_body path, method, {}
+      end
+
+      def request_with_body(path, method, params)
+        path = end_point if path.nil?
+        logger.debug "#{self.class.name}##{__method__} => path: #{path} params: #{skip_sensitive_data(params)}"
+
+        client.send_request path, method, params
+      end
+
+      protected
+
+      def logger
+        client.logger
+      end
+
+      def end_point
+        self.class.name.split('::').last.downcase
+      end
+    end
+  end
+end

data/lib/finapps_core/utils/loggeable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module Utils
+    # Adds logging capabilities when included into other classes
+    module Loggeable
+      def logger
+        @logger ||= begin
+          require 'logger'
+          ::Logger.new(STDOUT)
+        end
+      end
+    end
+  end
+end

data/lib/finapps_core/utils/parameter_filter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module FinAppsCore
+  module Utils
+    module ParameterFilter
+      using StringExtensions
+      PROTECTED_KEYS = %w(login login1 username password password1 password_confirm token
+                          x-finapps-token authorization).freeze
+
+      def skip_sensitive_data(hash)
+        if hash.is_a? String
+          hash = hash.json_to_hash
+        end
+        if hash.is_a? Hash
+          filtered_hash = hash.clone
+          filtered_hash.each do |key, value|
+            if PROTECTED_KEYS.include? key.to_s.downcase
+              filtered_hash[key] = '[REDACTED]'
+            elsif value.is_a?(Hash)
+              filtered_hash[key] = skip_sensitive_data(value)
+            elsif value.is_a?(Array)
+              filtered_hash[key] = value.map {|v| v.is_a?(Hash) ? skip_sensitive_data(v) : v }
+            end
+          end
+
+          filtered_hash
+        else
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/finapps_core/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module FinAppsCore
+  VERSION = '2.0.2'
+end

data/lib/tasks/releaser.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+desc 'Bumps the version to the next patch level, tags and pushes the code to
+origin repository and releases the gem. BOOM!'
+
+# https://github.com/svenfuchs/gem-release
+
+task :release do
+  system 'gem bump --tag --release'
+end

data/spec/core_extensions/object/blank_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+RSpec.describe ObjectExtensions do
+  context 'when refining Object' do
+    using ObjectExtensions
+
+    describe '#blank?' do
+      # An object is blank if it's false, empty, or a whitespace string.
+      context 'for false' do
+        it { expect(false.blank?).to eq(true) }
+      end
+      context 'for empty arrays' do
+        it { expect([].blank?).to eq(true) }
+      end
+      context 'for empty hashes' do
+        it { expect({}.blank?).to eq(true) }
+      end
+      context 'for whitespace string' do
+        it { expect(''.blank?).to eq(true) }
+      end
+    end
+
+    describe '#present?' do
+      # An object is present if it's not blank.
+      context 'for not blank objects' do
+        it { expect(1.present?).to eq(true) }
+      end
+
+      context 'for blank objects' do
+        it { expect(false.present?).to eq(false) }
+      end
+    end
+
+    describe '#presence' do
+      # Returns the receiver if it's present otherwise returns +nil+.
+      context 'returns the receiver when the receiver is present' do
+        it { expect(true.presence).to eq(true) }
+      end
+
+      context 'returns nil when the receiver is not present' do
+        it { expect(false.presence).to be_nil }
+      end
+    end
+  end
+end

data/spec/core_extensions/object/is_integer_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+RSpec.describe ObjectExtensions do
+  context 'when refining Object' do
+    using ObjectExtensions
+
+    describe '#integer?' do
+      context 'for integers' do
+        subject { 1 + rand(10) }
+        it { expect(subject.integer?).to eq(true) }
+      end
+      context 'for non integers' do
+        subject { rand }
+        it { expect(subject.integer?).to eq(false) }
+      end
+    end
+  end
+end

data/spec/middleware/request/accept_json_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::Middleware::AcceptJson do
+  let(:fake_app) { proc {|env| env } }
+  describe '#call' do
+    subject { FinAppsCore::Middleware::AcceptJson.new(fake_app) }
+    env = {request_headers: {}}
+
+    it('generates a UserAgent header') do
+      expect(subject.call(env)[:request_headers][FinAppsCore::Middleware::AcceptJson::KEY]).to eq('application/json')
+    end
+  end
+end

data/spec/middleware/request/no_encoding_basic_authentication_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::Middleware::NoEncodingBasicAuthentication do
+  let(:valid_credentials) { VALID_CREDENTIALS }
+  let(:key) { FinAppsCore::Middleware::NoEncodingBasicAuthentication::KEY }
+
+  describe '#call' do
+    fake_app = proc {|env| env }
+
+    context 'when credentials were provided' do
+      let(:middleware) do
+        FinAppsCore::Middleware::NoEncodingBasicAuthentication.new(fake_app, VALID_CREDENTIALS[:token])
+      end
+      let(:expected_header) { "Basic #{valid_credentials[:token]}" }
+
+      context 'when header was not previously set' do
+        let(:request_env) { {request_headers: {}} }
+        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+
+        it('generates a header') { expect(actual_header).to eq(expected_header) }
+      end
+
+      context 'when header was previously set' do
+        let(:existing_header) { {FinAppsCore::Middleware::NoEncodingBasicAuthentication::KEY => 'foo'} }
+        let(:request_env) { {request_headers: existing_header} }
+        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+
+        it('does not override existing header') { expect(actual_header).to eq('foo') }
+        it('does not generate a header') { expect(actual_header).to_not eq(expected_header) }
+      end
+    end
+  end
+end

data/spec/middleware/request/tenant_authentication_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::Middleware::TenantAuthentication do
+  let(:valid_tenant_options) { VALID_CREDENTIALS }
+  let(:key) { FinAppsCore::Middleware::TenantAuthentication::KEY }
+
+  describe '#call' do
+    fake_app = proc {|env| env }
+
+    context 'when company credentials were provided' do
+      let(:middleware) do
+        FinAppsCore::Middleware::TenantAuthentication.new(fake_app,
+                                                          VALID_CREDENTIALS[:identifier],
+                                                          VALID_CREDENTIALS[:token])
+      end
+      let(:expected_header) { "#{valid_tenant_options[:identifier]}=#{valid_tenant_options[:token]}" }
+
+      context 'when header was not previously set' do
+        let(:request_env) { {request_headers: {}} }
+        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+
+        it('generates a Tenant Authentication header') { expect(actual_header).to eq(expected_header) }
+      end
+
+      context 'when header was previously set' do
+        let(:existing_header) { {FinAppsCore::Middleware::TenantAuthentication::KEY => 'foo'} }
+        let(:request_env) { {request_headers: existing_header} }
+        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+
+        it('does not override existing Tenant Authentication header') { expect(actual_header).to eq('foo') }
+        it('does not generate a Tenant Authentication header') { expect(actual_header).to_not eq(expected_header) }
+      end
+    end
+  end
+end

data/spec/middleware/request/user_agent_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::Middleware::UserAgent do
+  let(:fake_app) { proc {|env| env } }
+  describe '#call' do
+    subject { FinAppsCore::Middleware::UserAgent.new(fake_app) }
+    env = {request_headers: {}}
+
+    it('generates a UserAgent header') do
+      expect(subject.call(env)[:request_headers][FinAppsCore::Middleware::UserAgent::KEY]).to start_with('finapps-ruby')
+    end
+  end
+end

data/spec/middleware/response/raise_error_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::Middleware::RaiseError do
+  let(:fake_app) { proc {|env| env } }
+  Env = Struct.new(:status, :response_headers, :body)
+
+  describe '#on_complete' do
+    subject { FinAppsCore::Middleware::RaiseError.new(fake_app) }
+
+    context 'for successful requests' do
+      let(:env) { Env.new(200) }
+      it { expect { subject.on_complete(env) }.not_to raise_error }
+    end
+    context 'for client errors' do
+      let(:env) { Env.new(401, {}, '{"messages":["Invalid User Identifier or Credentials"]}') }
+      error_message = 'the server responded with status 401'
+      it { expect { subject.on_complete(env) }.to raise_error(Faraday::Error::ClientError, error_message) }
+    end
+    context 'for connection failed error' do
+      let(:env) { Env.new(407) }
+      error_message = '407 "Proxy Authentication Required"'
+      it { expect { subject.on_complete(env) }.to raise_error(Faraday::Error::ConnectionFailed, error_message) }
+    end
+  end
+end

data/spec/rest/base_client_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+RSpec.describe FinAppsCore::REST::BaseClient do
+  let(:valid_tenant_options) do
+    {tenant_identifier: VALID_CREDENTIALS[:identifier],
+     tenant_token: VALID_CREDENTIALS[:token]}
+  end
+  subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options) }
+
+  RESPONSE = 0
+  ERROR_MESSAGES = 1
+  let(:return_array) { %i(RESPONSE ERROR_MESSAGES) }
+
+  describe '#new' do
+    it 'assigns @config' do
+      expect(subject.config).to be_a(FinAppsCore::REST::Configuration)
+    end
+  end
+
+  describe '#connection' do
+    it 'created a Faraday connection object' do
+      expect(subject.connection).to be_a(Faraday::Connection)
+    end
+
+    it 'memoizes the results' do
+      first = subject.connection
+      second = subject.connection
+      expect(first.object_id).to eq(second.object_id)
+    end
+  end
+
+  describe '#send_request' do
+    it 'should raise FinAppsCore::InvalidArgumentsError if method is NOT supported' do
+      expect { subject.send_request('fake_path', :option) }.to raise_error(FinAppsCore::InvalidArgumentsError,
+                                                                           'Method not supported: option.')
+    end
+
+    it 'should raise FinAppsCore::MissingArgumentsError if method is NOT provided' do
+      expect { subject.send_request(nil, :get) }.to raise_error(FinAppsCore::MissingArgumentsError,
+                                                                'Missing argument: path.')
+    end
+
+    it 'should raise FinAppsCore::MissingArgumentsError if path is NOT provided' do
+      expect { subject.send_request('fake_path', nil) }.to raise_error(FinAppsCore::MissingArgumentsError,
+                                                                       'Missing argument: method.')
+    end
+
+    context 'when method and path are provided' do
+      subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('relevance/ruleset/names', :get) }
+      let(:return_array) { %i(RESPONSE ERROR_MESSAGES) }
+
+      it('returns an array of 2 items') do
+        expect(subject).to be_a(Array)
+        expect(subject.size).to eq(return_array.length)
+      end
+
+      context 'for unsupported methods' do
+        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('users', :options) }
+
+        it do
+          expect { subject.send_request(nil, :get) }
+            .to raise_error(FinAppsCore::InvalidArgumentsError, 'Method not supported: options.')
+        end
+      end
+
+      context 'for client errors' do
+        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('client_error', :get) }
+
+        it('result is null') { expect(subject[RESPONSE]).to be_nil }
+        it('error_messages is an array') { expect(subject[ERROR_MESSAGES]).to be_a(Array) }
+        it('error_messages gets populated') { expect(subject[ERROR_MESSAGES].first).to eq 'Password Minimum size is 8' }
+      end
+
+      context 'for server errors' do
+        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('server_error', :get) }
+
+        it('the result should be nil') { expect(subject[RESPONSE]).to be_nil }
+        it { expect(subject[ERROR_MESSAGES]).not_to be_nil }
+        it { expect(subject[ERROR_MESSAGES]).to be_a(Array) }
+        it { expect(subject[ERROR_MESSAGES].first).to eq 'the server responded with status 500' }
+      end
+
+      context 'for proxy errors' do
+        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('proxy_error', :get) }
+
+        it { expect { subject }.to raise_error(Faraday::ConnectionFailed, '407 "Proxy Authentication Required"') }
+      end
+    end
+
+    context 'if a block is provided' do
+      it('gets executed on the response') do
+        expect(subject.send_request('relevance/ruleset/names', :get, &:status)[RESPONSE]).to eq(200)
+        expect(subject.send_request('relevance/ruleset/names', :get) {|r| r.body.length }[RESPONSE]).to eq(45)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    context 'for unsupported methods' do
+      it { expect { subject.unsupported }.to raise_error(NoMethodError) }
+    end
+  end
+
+  describe '#respond_to_missing?' do
+    context 'for supported methods' do
+      [:get, :post, :put, :delete].each do |method|
+        it("responds to #{method}") { expect(subject).to respond_to(method) }
+      end
+    end
+  end
+end