finapps 2.1.4 → 2.2.1

data/lib/finapps/rest/defaults.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  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_POINTS = {
-        users_create:              'users/new',
-        users_update:              'user',
-        users_update_password:     'user/password',
-        users_delete:              'users/:public_id',
-        users_show:                'users/:public_id',
-        users_login:               'users/login',
-
-        relevance_rulesets_list:   'relevance/ruleset/names',
-        relevance_rulesets_show:   'relevance/ruleset/:ruleset_name',
-        relevance_rulesets_run:    'relevance/run',
-
-        institutions_list:         'institutions/:search_term/search',
-        institutions_form:         'institutions/:site_id/form',
-
-        user_institutions_list:    'institutions/user',
-        user_institutions_add:     'institutions/:site_id/add',
-        user_institutions_show:    'institutions/user/:user_institution_id',
-        user_institutions_update:  'institutions/user/:user_institution_id/credentials',
-        user_institutions_delete:  'institutions/user/:user_institution_id',
-        user_institutions_status:  'institutions/user/:user_institution_id/status',
-        user_institutions_mfa:     'institutions/user/:user_institution_id/mfa',
-        user_institutions_refresh: 'institutions/user/refresh',
-        user_institutions_form:    'institutions/user/:user_institution_id/form',
-
-        transactions_show:         'transaction/:transaction_id',
-        transactions_list:         'transactions/search',
-        transactions_update:       'transactions/edit',
-
-        categories_list:           'categories',
-        categories_new:            'categories',
-        categories_update:         'categories',
-        categories_show:           'categories/:category_id',
-        categories_delete:         'categories/:category_id',
-
-        budget_models_list:        'budget/templates',
-        budget_models_show:        'budget/template/:budget_model_id',
-
-        budget_calculation_create: 'budget/template/:budget_model_id/:income',
-        budget_calculation_show:   'categories',
-
-        budget_update:             'budget',
-        budget_show:               'budget/:start_date/:end_date',
-
-        cashflow_show:             'cashflow/:start_date/:end_date',
-
-        alert_list:                'alerts/:page/:requested/:sort/:asc/:read',
-        alert_update:              'alerts/:alert_id/:read',
-        alert_delete:              'alerts/:alert_id',
-
-        alert_definition_list:     'alerts/definitions',
-        alert_definition_show:     'alerts/definitions/:alert_name',
-
-        alert_settings_show:       'alerts/settings',
-        alert_settings_update:     'alerts/settings',
-
-        alert_preferences_show:    'alerts/preferences',
-        alert_preferences_update:  'alerts/preferences'
-
-      }.freeze
-    end
-  end
-end

data/lib/finapps/rest/resources.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module REST
-    class Resources # :nodoc:
-      include FinApps::Utils::ParameterFilter
-      require 'erb'
-
-      attr_reader :client
-
-      # @param [FinApps::REST::Client] client
-      # @return [FinApps::REST::Resources]
-      def initialize(client)
-        raise MissingArgumentsError.new 'Missing argument: client.' if client.nil?
-        raise InvalidArgumentsError.new 'Invalid argument: client.' unless client.is_a?(FinApps::REST::Client)
-
-        @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/utils/loggeable.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  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/utils/parameter_filter.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  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/spec/core_extensions/hash/compact_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-RSpec.describe HashExtensions do
-  context 'when refining hash' do
-    using HashExtensions
-
-    subject { {a: true, b: false, c: nil} }
-
-    describe '#compact' do
-      it 'returns a hash with non nil values' do
-        expect(subject.compact).to eq(a: true, b: false)
-        expect(subject).to eq(a: true, b: false, c: nil)
-      end
-    end
-    describe '#compact!' do
-      it 'replaces current hash with non nil values' do
-        expect(subject.compact!).to eq(a: true, b: false)
-        expect(subject).to eq(a: true, b: false)
-      end
-    end
-  end
-end

data/spec/core_extensions/object/is_integer_spec.rb

@@ -1,17 +0,0 @@
-# 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

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

data/spec/middleware/request/no_encoding_basic_authentication_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-RSpec.describe FinApps::Middleware::NoEncodingBasicAuthentication do
-  let(:valid_credentials) { VALID_CREDENTIALS }
-  let(:key) { FinApps::Middleware::NoEncodingBasicAuthentication::KEY }
-
-  describe '#call' do
-    fake_app = proc {|env| env }
-
-    context 'when credentials were provided' do
-      let(:middleware) do
-        FinApps::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) { {FinApps::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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-RSpec.describe FinApps::Middleware::TenantAuthentication do
-  let(:valid_tenant_options) { VALID_CREDENTIALS }
-  let(:key) { FinApps::Middleware::TenantAuthentication::KEY }
-
-  describe '#call' do
-    fake_app = proc {|env| env }
-
-    context 'when company credentials were provided' do
-      let(:middleware) do
-        FinApps::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) { {FinApps::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

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

data/spec/middleware/response/raise_error_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-RSpec.describe FinApps::Middleware::RaiseError do
-  let(:fake_app) { proc {|env| env } }
-  Env = Struct.new(:status, :response_headers, :body)
-
-  describe '#on_complete' do
-    subject { FinApps::Middleware::RaiseError.new(fake_app) }
-
-    context 'for succesful 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

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-RSpec.describe FinApps::REST::BaseClient do
-  let(:valid_tenant_options) do
-    {tenant_identifier: VALID_CREDENTIALS[:identifier],
-     tenant_token: VALID_CREDENTIALS[:token]}
-  end
-  subject { FinApps::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(FinApps::REST::Configuration)
-    end
-  end
-
-  describe '#user_credentials?' do
-    context 'when user credentials were not set' do
-      it { expect(subject.user_credentials?).to eq(false) }
-    end
-    context 'when user credentials were set' do
-      subject { FinApps::REST::BaseClient.new(valid_tenant_options.merge(user_identifier: 1, user_token: 2)) }
-      it { expect(subject.user_credentials?).to eq(true) }
-    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 FinApps::InvalidArgumentsError if method is NOT supported' do
-      expect { subject.send_request('fake_path', :option) }.to raise_error(FinApps::InvalidArgumentsError,
-                                                                           'Method not supported: option.')
-    end
-
-    it 'should raise FinApps::MissingArgumentsError if method is NOT provided' do
-      expect { subject.send_request(nil, :get) }.to raise_error(FinApps::MissingArgumentsError,
-                                                                'Missing argument: path.')
-    end
-
-    it 'should raise FinApps::MissingArgumentsError if path is NOT provided' do
-      expect { subject.send_request('fake_path', nil) }.to raise_error(FinApps::MissingArgumentsError,
-                                                                       'Missing argument: method.')
-    end
-
-    context 'when method and path are provided' do
-      subject { FinApps::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 { FinApps::REST::BaseClient.new(valid_tenant_options).send_request('users', :options) }
-
-        it do
-          expect { subject.send_request(nil, :get) }
-            .to raise_error(FinApps::InvalidArgumentsError, 'Method not supported: options.')
-        end
-      end
-
-      context 'for client errors' do
-        subject { FinApps::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 { FinApps::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 { FinApps::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