finapps 0.0.14.pre

data/lib/finapps/rest/connection.rb

@@ -0,0 +1,77 @@
+require 'pp'
+
+module FinApps
+  module REST
+    module Connection
+      include FinApps::REST::Defaults
+
+      # @param [Hash] company_credentials
+      # @param [Hash] config
+      # @return [Faraday::Connection]
+      def set_up_connection(company_credentials, config)
+        logger.debug "##{__method__.to_s} => Started"
+
+        company_credentials.validate_required_strings!
+        logger.debug "##{__method__.to_s} => company_credentials passed validation."
+
+        host = config[:host]
+        validate_host_url! host
+
+        base_url = "#{host}/v#{API_VERSION}"
+        logger.debug " base_url: #{base_url}"
+
+        timeout = config[:timeout].blank? ? DEFAULTS[:timeout] : config[:timeout]
+        logger.debug " timeout: #{timeout}"
+
+        user_identifier = config[:user_identifier]
+        logger.debug " user_identifier: #{user_identifier}" if user_identifier.present?
+
+        user_token = config[:user_token]
+        logger.debug ' user_token: [REDACTED]' if user_token.present?
+
+        connection = Faraday.new(:url => base_url,
+                                 :request => {
+                                     :open_timeout => timeout,
+                                     :timeout => timeout},
+                                 :headers => {
+                                     :accept => HEADERS[:accept],
+                                     :user_agent => HEADERS[:user_agent]}) do |conn|
+
+          # Request Middleware
+          conn.use FinApps::Middleware::ApiToken, company_credentials
+          conn.request :json
+          conn.request :retry
+          conn.request :multipart
+          conn.request :url_encoded
+          if user_identifier.blank? || user_token.blank?
+            logger.debug "##{__method__.to_s} => User credentials were not provided. Authentication header not set."
+          else
+            conn.request :basic_auth, user_identifier, user_token
+            logger.debug "##{__method__.to_s} => Basic Authentication header set for provided user credentials."
+          end
+
+          # Response Middleware
+          conn.use FinApps::Middleware::RaiseHttpExceptions
+          conn.response :rashify
+          conn.response :json, :content_type => /\bjson$/
+          conn.use FinApps::Middleware::ResponseLogger
+
+          # Adapter (ensure that the adapter is always last.)
+          conn.adapter :typhoeus
+        end
+
+        logger.debug "##{__method__.to_s} => Completed"
+        connection
+      end
+
+      private
+      def validate_host_url!(host_url)
+        raise MissingArgumentsError.new 'Missing argument: host_url.' if host_url.blank?
+        raise InvalidArgumentsError.new 'Invalid argument: host_url does not specify a valid protocol (http/https).' unless host_url.start_with?('http://', 'https://')
+
+        logger.debug "##{__method__.to_s} => host [#{host_url}] passed validation."
+      end
+
+    end
+  end
+end

data/lib/finapps/rest/defaults.rb

@@ -0,0 +1,36 @@
+module FinApps
+  module REST
+    module Defaults
+
+      API_VERSION = '1'
+
+      HEADERS = {
+          :accept => 'application/json',
+          :user_agent => "finapps-ruby/#{FinApps::VERSION} (#{RUBY_ENGINE}/#{RUBY_PLATFORM} #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
+      }
+
+      # noinspection SpellCheckingInspection
+      DEFAULTS = {
+          :host => 'https://www.financialapps.com',
+          :timeout => 30,
+          :proxy_addr => nil,
+          :proxy_port => nil,
+          :proxy_user => nil,
+          :proxy_pass => nil,
+          :retry_limit => 1,
+          :log_level => Logger::INFO
+      }
+
+
+      END_POINTS = {
+          :users_create => 'users/new',
+          :users_login => 'users/login',
+          :users_delete => 'users/:public_id/delete',
+          :institutions_search => 'institutions/:search_term/search',
+          :institutions_form => 'institutions/:site_id/form',
+          :institutions_add => 'institutions/:site_id/add',
+      }
+
+    end
+  end
+end

data/lib/finapps/rest/errors.rb

@@ -0,0 +1,110 @@
+module FinApps
+  module REST
+
+    # Custom error class for rescuing from all FinApps errors
+    class Error < StandardError;
+      attr_reader :response
+
+      def initialize(ex, response = nil)
+        @wrapped_exception = nil
+        @response = response
+
+        if ex.respond_to?(:backtrace)
+          super(ex.message)
+          @wrapped_exception = ex
+        elsif ex.respond_to?(:each_key)
+          super("the server responded with status #{ex[:status]}")
+          @response = ex
+        else
+          super(ex.to_s)
+        end
+      end
+
+      def backtrace
+        if @wrapped_exception
+          @wrapped_exception.backtrace
+        else
+          super
+        end
+      end
+
+      def inspect
+        %(#<#{self.class}>)
+      end
+
+      # @return [Array<String>]
+      def error_messages
+        @response.present? ? @response[:error_messages] : []
+      end
+
+    end
+
+    # Raised when required arguments are missing
+    class MissingArgumentsError < Error
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    # Raised when invalid arguments are detected
+    class InvalidArgumentsError < Error
+      def initialize(message)
+        super(message)
+      end
+    end
+
+
+    # Client Error 4xx
+    # The 4xx class of status code is intended for cases in which the client seems to have erred.
+    class ClientError < Error
+    end
+
+    class BadRequest < ClientError
+    end
+
+    class Unauthorized < ClientError
+    end
+
+    class Forbidden < ClientError
+    end
+
+    class NotFound < ClientError
+    end
+
+    class MethodNotAllowed < ClientError
+    end
+
+    class NotAcceptable < ClientError
+    end
+
+    class ConnectionFailed < ClientError
+    end
+
+    class Conflict < ClientError
+    end
+
+
+    # Server Error 5xx
+    #
+    # Response status codes beginning with the digit "5" indicate cases in which the server is aware
+    # that it has erred or is incapable of performing the request.
+    class ServerError < Error
+    end
+
+    class InternalServerError < ServerError
+    end
+
+    class BadGateway < ServerError
+    end
+
+    class ServiceUnavailable < ServerError
+    end
+
+    class GatewayTimeout < ServerError
+    end
+
+    class VersionNotSupported < ServerError
+    end
+
+  end
+end

data/lib/finapps/rest/institutions.rb

@@ -0,0 +1,32 @@
+module FinApps
+  module REST
+
+    class Institutions < FinApps::REST::Resources
+
+      # @param [String] term
+      # @return [Array<FinApps::REST::Institution>, Array<String>]
+      def search(term)
+        logger.debug "##{__method__.to_s} => Started"
+
+        raise MissingArgumentsError.new 'Missing argument: term.' if term.blank?
+        logger.debug "##{__method__.to_s} => term: #{term}"
+
+        path = END_POINTS[:institutions_search].sub! ':search_term', term.to_s
+
+        institutions, error_messages = @client.get(path) do |r|
+          r.body.each { |i| Institution.new(i) }
+        end
+
+        logger.debug "##{__method__.to_s} => Completed"
+        return institutions, error_messages
+      end
+
+
+    end
+
+    class Institution < FinApps::REST::Resource
+      attr_accessor :base_url, :display_name, :site_id, :org_display_name
+    end
+
+  end
+end

data/lib/finapps/rest/resource.rb

@@ -0,0 +1,13 @@
+module FinApps
+  module REST
+    class Resource
+
+      # @param [Hash] hash
+      def initialize(hash)
+        hash.each { |k, v| instance_variable_set("@#{k}", v) unless v.nil? } if hash.present?
+        self
+      end
+
+    end
+  end
+end

data/lib/finapps/rest/resources.rb

@@ -0,0 +1,17 @@
+module FinApps
+  module REST
+    class Resources
+
+      include FinApps::REST::Defaults
+      include FinApps::Logging
+
+      # @param [FinApps::REST::Client] client
+      # @return [FinApps::REST::Resources]
+      def initialize(client)
+        @client = client
+        logger.debug "##{__method__.to_s} => #{self.class.name} initialized."
+      end
+
+    end
+  end
+end

data/lib/finapps/rest/users.rb

@@ -0,0 +1,45 @@
+module FinApps
+  module REST
+
+    class Users < FinApps::REST::Resources
+      include FinApps::Logging
+
+      # @param [Hash] params
+      # @return [FinApps::REST::User, Array<String>]
+      def create(params = {})
+        logger.debug "##{__method__.to_s} => Started"
+        user, error_messages = @client.post(END_POINTS[:users_create], params) { |r| User.new(r.body) }
+        logger.debug "##{__method__.to_s} => Completed"
+
+        return user, error_messages
+      end
+
+      # @param [Hash] params
+      # @return [FinApps::REST::User, Array<String>]
+      def login(params = {})
+        logger.debug "##{__method__.to_s} => Started"
+        user, error_messages = @client.post(END_POINTS[:users_login], params) { |r| User.new(r.body) }
+        logger.debug "##{__method__.to_s} => Completed"
+
+        return user, error_messages
+      end
+
+      # @param [String] public_id
+      # @return [Array<String>]
+      def delete(public_id)
+        logger.debug "##{__method__.to_s} => Started"
+        raise MissingArgumentsError.new 'Missing argument: public_id.' if public_id.blank?
+        _, error_messages = @client.delete(END_POINTS[:users_delete].sub! ':public_id', public_id.to_s)
+        logger.debug "##{__method__.to_s} => Completed"
+
+        error_messages
+      end
+
+    end
+
+    class User < FinApps::REST::Resource
+      attr_accessor :public_id, :token, :email, :first_name, :last_name, :postal_code
+    end
+
+  end
+end

data/lib/finapps/utils/logging.rb

@@ -0,0 +1,78 @@
+module FinApps
+  module Logging
+
+    SEVERITY_LABEL = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN)
+    PROTECTED_KEYS = [:password, :password_confirm]
+
+    class << self;
+      attr_accessor :tag;
+    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.formatter = proc do |severity, time, progname, msg|
+            Logging.tag.present? ?
+                "[%s#%d] %5s -- %s: %s %s\n" % [format_datetime(time), $$, severity, progname, Logging.tag.to_s, msg2str(msg)] :
+                "[%s#%d] %5s -- %s: %s\n" % [format_datetime(time), $$, severity, progname, msg2str(msg)]
+
+          end
+        end
+      end
+
+    end
+
+    def set_up_logger_level(logger_level)
+      unless logger_level.blank? || @logger.level == logger_level
+        @logger.info "##{__method__.to_s} => Setting logger level to #{SEVERITY_LABEL[logger_level]}"
+        @logger.level = logger_level
+      end
+    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
+        redacted = hash.clone
+        redacted.update(redacted) { |key, v1| (PROTECTED_KEYS.include? key) ? '[REDACTED]' : v1 }
+      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
+
+  end
+end

data/lib/finapps/utils/utils.rb

@@ -0,0 +1,51 @@
+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 MissingArgumentsError.new "Missing argument: #{key}." if value.blank?
+      raise InvalidArgumentsError.new "Invalid #{key} specified: #{value.inspect} must be a string or symbol." unless value.is_a?(String) || value.is_a?(Symbol)
+    end
+  end
+end

data/lib/finapps/version.rb

@@ -0,0 +1,3 @@
+module FinApps
+  VERSION = '0.0.14.pre'
+end

data/lib/finapps.rb

@@ -0,0 +1,25 @@
+require 'finapps/version' unless defined?(FinApps::VERSION)
+require 'logger' unless defined?(::Logger)
+require 'pp'
+
+require 'faraday'
+require 'faraday_middleware'
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
+
+require 'finapps/rest/defaults'
+require 'finapps/rest/errors'
+require 'finapps/utils/logging'
+require 'finapps/utils/utils'
+
+require 'finapps/rest/resource'
+require 'finapps/rest/resources'
+require 'finapps/rest/users'
+require 'finapps/rest/institutions'
+
+require 'finapps/middleware/api_token'
+require 'finapps/middleware/raise_http_exceptions'
+require 'finapps/middleware/response_logger'
+
+require 'finapps/rest/connection'
+require 'finapps/rest/client'

data/spec/rest/client_spec.rb

@@ -0,0 +1,61 @@
+require 'rspec'
+require 'finapps'
+
+module FinApps
+
+  describe FinApps::REST::Client do
+
+    before do
+      @client = FinApps::REST::Client.new :company_identifier, :company_token
+    end
+
+    describe '#new' do
+      context 'when company credentials are NOT provided' do
+        it 'should raise a MissingArgumentsError exception' do
+          expect { FinApps::REST::Client.new nil, nil }.to raise_error(FinApps::REST::MissingArgumentsError)
+        end
+      end
+
+      context 'when company credentials are of invalid type' do
+        it 'should raise an InvalidArgumentsError exception' do
+          expect{FinApps::REST::Client.new 1, 2}.to raise_error(FinApps::REST::InvalidArgumentsError)
+        end
+      end
+
+      context 'when company credentials are provided' do
+        it 'returns a client object' do
+          expect(@client).to be_an_instance_of(FinApps::REST::Client)
+        end
+      end
+    end
+
+    describe '#get' do
+      it 'responds to get' do
+        expect(@client).to respond_to(:get)
+      end
+    end
+
+    describe '#post' do
+      it 'responds to post' do
+        expect(@client).to respond_to(:post)
+      end
+    end
+
+    describe '.users' do
+      it 'returns a Users object' do
+        expect(@client.users).to be_an_instance_of(FinApps::REST::Users)
+      end
+    end
+
+    describe '#connection' do
+      it 'looks like Faraday connection' do
+        expect(@client.send(:connection)).to respond_to(:run_request)
+      end
+      it 'memoizes the connection' do
+        c1, c2 = @client.send(:connection), @client.send(:connection)
+        expect(c1.object_id).to eq(c2.object_id)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,84 @@
+require 'finapps'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+
+
+end