finapps 1.0.8 → 2.0.2

data/lib/finapps/utils/logging.rb

@@ -1,95 +0,0 @@
-module FinApps
-  module Logging
-
-    SEVERITY_LABEL = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN)
-    PROTECTED_KEYS = %w(login login1 password password1 password_confirm token)
-    FORMAT = "\033[%sm[%s#%d] %5s -- %s: %s\033[0m\n"
-    FORMAT_TAG = "\033[%sm[%s#%d] %5s -- %s: %s %s\033[0m\n"
-    SEVERITY_COLOR_MAP = {:debug => '0', :info => '32', :warn => '33', :error => '31', :fatal => '31', :unknown => '0;37'}
-
-
-    class << self;
-      attr_accessor :tag, :level;
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
-
-    # noinspection SpellCheckingInspection
-    def logger
-
-      @logger ||= begin
-        require 'logger' unless defined?(::Logger)
-        ::Logger.new(STDOUT).tap do |log|
-          log.progname = "#{self.class.to_s}"
-          log.level = Logging.level if Logging.level.present?
-          log.formatter = proc do |severity, time, progname, msg|
-            Logging.tag.present? ?
-                FORMAT_TAG % [severity_to_color(severity), format_datetime(time), $$, severity, progname, Logging.tag.to_s, msg2str(msg)] :
-                FORMAT % [severity_to_color(severity), format_datetime(time), $$, severity, progname, msg2str(msg)]
-
-          end
-        end
-      end
-
-    end
-
-    def logger_config(config)
-      Logging.tag= config[:logger_tag] if config[:logger_tag].present?
-      Logging.level = config[:log_level] if config[:log_level].present?
-    end
-
-    # noinspection SpellCheckingInspection
-    def set_up_logger_session_params(uuid, session_id)
-      if uuid.present? || session_id.present?
-        uuid ||= '-'
-        session_id ||= '-'
-        logger.formatter = proc do |severity, time, progname, msg|
-          "[%s#%d] %5s -- %s: [#{uuid}] [#{session_id}] %s\n" % [format_datetime(time), $$, severity, progname, msg2str(msg)]
-        end
-      end
-    end
-
-    # @param [Hash] hash
-    def skip_sensitive_data(hash)
-      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] = self.skip_sensitive_data(value)
-          elsif value.is_a?(Array)
-            filtered_hash[key] = value.map { |v| v.is_a?(Hash) ? self.skip_sensitive_data(v) : v }
-          end
-        end
-
-        filtered_hash
-      else
-        hash
-      end
-    end
-
-    private
-    def format_datetime(time)
-      time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ' % time.usec
-    end
-
-    def msg2str(msg)
-      case msg
-        when ::String
-          msg
-        when ::Exception
-          "#{ msg.message } (#{ msg.class })\n" << (msg.backtrace || []).join("\n")
-        else
-          msg.inspect
-      end
-    end
-
-    def severity_to_color(severity)
-      SEVERITY_COLOR_MAP[severity.downcase.to_sym]
-    end
-
-  end
-end

data/lib/finapps/utils/utils.rb

@@ -1,57 +0,0 @@
-class Object
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are all blank.
-  #
-  # This simplifies:
-  #
-  #   if address.nil? || address.empty?
-  #
-  # ...to:
-  #
-  #   if address.blank?
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-
-  # An object is present if it's not <tt>blank?</tt>.
-  def present?
-    !blank?
-  end
-
-  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
-  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
-  #
-  # This is handy for any representation of objects where blank is the same
-  # as not present at all. For example, this simplifies a common check for
-  # HTTP POST/query parameters:
-  #
-  #   state   = params[:state]   if params[:state].present?
-  #   country = params[:country] if params[:country].present?
-  #   region  = state || country || 'US'
-  #
-  # ...becomes:
-  #
-  #   region = params[:state].presence || params[:country].presence || 'US'
-  def presence
-    self if present?
-  end
-
-  def trim
-    respond_to?(:strip) ? self.strip : self
-  end
-end
-
-
-
-class Hash
-  def validate_required_strings!
-    self.each do |key, value|
-      raise FinApps::REST::MissingArgumentsError.new "Missing argument: #{key}." if value.blank?
-      raise FinApps::REST::InvalidArgumentsError.new "Invalid #{key} specified: #{value.inspect} must be a string or symbol." unless value.is_a?(String) || value.is_a?(Symbol)
-    end
-  end
-
-  def compact
-    self.delete_if { |_, v| v.nil? }
-  end
-end

data/spec/middleware/api_token_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe FinApps::Middleware::ApiToken do
-
-  describe '#call' do
-
-    fake_app = Proc.new { |env| env }
-    valid_credentials = {:company_identifier => 'id', :company_token => 'token'}
-
-    context 'when company_identifier is NOT provided' do
-      let(:api_token) { FinApps::Middleware::ApiToken.new fake_app, valid_credentials.select { |x| x!= :company_identifier } }
-      it { expect { api_token.call({}) }.to raise_error(FinApps::REST::MissingArgumentsError) }
-    end
-
-    context 'when company_token is NOT provided' do
-      let(:api_token) { FinApps::Middleware::ApiToken.new fake_app, valid_credentials.select { |x| x!= :company_token } }
-      it { expect { api_token.call({}) }.to raise_error(FinApps::REST::MissingArgumentsError) }
-    end
-
-    context 'when company credentials were provided' do
-
-      let(:api_token) { FinApps::Middleware::ApiToken.new fake_app, valid_credentials }
-      let(:expected_header_value) { "#{valid_credentials[:company_identifier]}=#{valid_credentials[:company_token]}" }
-      subject(:call) { api_token.call({:request_headers => {}}) }
-
-      it { expect { call }.not_to raise_error }
-      it 'should generate the X-FinApps-Token header' do
-        expect(call[:request_headers]['X-FinApps-Token']).to eq(expected_header_value)
-      end
-    end
-
-  end
-end
-

data/spec/rest/connection_spec.rb

@@ -1,40 +0,0 @@
-require 'base64'
-
-RSpec.describe FinApps::REST::Connection do
-
-  let(:dummy_class) { Class.new { extend FinApps::REST::Connection } }
-  let(:valid_credentials) { {:company_identifier => 'id', :company_token => 'token'} }
-  let(:user_credentials) { {:user_identifier => 'user_id', :user_token => 'user_token'} }
-
-  it { expect(dummy_class).to respond_to(:set_up_connection) }
-
-  describe '#set_up_connection' do
-
-    context 'when using valid company credentials' do
-      subject(:set_up_connection) { dummy_class.set_up_connection(valid_credentials, {}) }
-      it { expect(set_up_connection).to be_an_instance_of(Faraday::Connection) }
-      it { expect(set_up_connection.headers).to include({'Accept' => FinApps::REST::Defaults::HEADERS[:accept]}) }
-      it { expect(set_up_connection.headers).to include({'User-Agent' => FinApps::REST::Defaults::HEADERS[:user_agent]}) }
-      context 'when NOT providing user credentials' do
-        it { expect(set_up_connection.builder.handlers).not_to include(Faraday::Request::BasicAuthentication) }
-      end
-    end
-
-    context 'when using valid user credentials' do
-      subject(:set_up_connection) { dummy_class.set_up_connection(valid_credentials, user_credentials) }
-      let(:header) { Faraday::Request::BasicAuthentication.header(user_credentials[:user_identifier], user_credentials[:user_token]) }
-
-      it { expect(set_up_connection.builder.handlers).to include(Faraday::Request::BasicAuthentication) }
-      it 'sets a proper authorization header' do
-        stub_request(:get, "#{FinApps::REST::Defaults::DEFAULTS[:host]}/auth-echo").to_return(:status => 200)
-        expect(set_up_connection.get('/auth-echo').env.request_headers).to include({:authorization => header})
-      end
-    end
-
-    context 'using an invalid host_url parameter' do
-      subject(:set_up_connection) { dummy_class.set_up_connection(valid_credentials, {:host => 'yahoo.com'}) }
-      it { expect { set_up_connection }.to raise_error(FinApps::REST::InvalidArgumentsError) }
-    end
-
-  end
-end

data/spec/rest/users_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe FinApps::REST::Users do
-
-  context 'after initialized' do
-    let(:users) { FinApps::REST::Users.new(FinApps::REST::Client.new(:id, :token)) }
-
-    [:show, :create, :update, :update_password, :login, :delete].each do |method|
-      it "responds to #{method}" do
-        expect(users).to respond_to(method)
-      end
-    end
-
-    describe '#show' do
-
-      context 'when public_id is NOT provided' do
-        it { expect { users.show(nil) }.to raise_error(FinApps::REST::MissingArgumentsError) }
-      end
-
-      it { expect(users.show(1)[0]).to be_an_instance_of(FinApps::REST::User) }
-
-    end
-
-  end
-
-end

data/spec/utils/logging_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FinApps::Logging do
-
-  let(:dummy_class) { Class.new { extend FinApps::Logging } }
-  let(:simple_hash) { {:login => 'login', :password => 'secret'} }
-  let(:deep_hash) { {:parameters => {:login => 'login', :password => 'secret'}} }
-  let(:array_of_hashes) { {:parameters => [{:login => 'login', :password => 'secret'},
-                                           {:login1 => 'login1', :password1 => 'secret1'},
-                                           {:user => 'user', :token => 'secret'}]} }
-
-  it 'should redact protected keys on a simple Hash' do
-    redacted = dummy_class.skip_sensitive_data simple_hash
-    expect(redacted[:password]).to eq('[REDACTED]')
-  end
-
-  it 'should redact protected keys on a deep Hash' do
-    redacted = dummy_class.skip_sensitive_data deep_hash
-    expect(redacted[:parameters][:password]).to eq('[REDACTED]')
-  end
-
-  it 'should redact protected keys on an array of Hashes' do
-    redacted = dummy_class.skip_sensitive_data array_of_hashes
-    expect(redacted[:parameters][0][:password]).to eq('[REDACTED]')
-    expect(redacted[:parameters][1][:password1]).to eq('[REDACTED]')
-    expect(redacted[:parameters][2][:token]).to eq('[REDACTED]')
-  end
-end