plaid 1.7.1 → 2.0.0.alpha

data/lib/plaid/models/account.rb

@@ -1,24 +0,0 @@
-module Plaid
-  class Account
-    attr_accessor :available_balance, :current_balance, :institution_type, :meta, :transactions, :numbers, :name, :id, :type, :subtype
-
-    def initialize(hash)
-      @id   = hash['_id']
-      @name = hash['meta']['name'] if hash['meta']
-      @type = hash['type']
-      @meta = hash['meta']
-      @institution_type  = hash['institution_type']
-
-      if hash['balance']
-        @available_balance = hash['balance']['available']
-        @current_balance   = hash['balance']['current']
-      end
-
-      # Depository account only, "checkings" or "savings"
-      # Available on live data, but not on the test data
-      @subtype = hash['subtype']
-
-      @numbers = hash['numbers'] ? hash['numbers'] : 'Upgrade user to access routing information for this account'
-    end
-  end
-end

data/lib/plaid/models/category.rb

@@ -1,17 +0,0 @@
-module Plaid
-  class Category
-    attr_accessor :type, :hierarchy, :id
-
-    def initialize(fields = {})
-      @type = fields['type']
-      @hierarchy = fields['hierarchy']
-      @id = fields['id']
-    end
-
-    # API: semi-private
-    # This method takes an array returned from the API and instantiates all of the categories
-    def self.all(res)
-      res.map { |cat| new(cat) }
-    end
-  end
-end

data/lib/plaid/models/exchange_token_response.rb

@@ -1,11 +0,0 @@
-module Plaid
-  class ExchangeTokenResponse
-    attr_accessor :access_token
-    attr_accessor :stripe_bank_account_token
-
-    def initialize(fields = {})
-      @access_token = fields['access_token']
-      @stripe_bank_account_token = fields['stripe_bank_account_token']
-    end
-  end
-end

data/lib/plaid/models/info.rb

@@ -1,12 +0,0 @@
-module Plaid
-  class Information
-    attr_accessor :names, :emails, :phone_numbers, :addresses
-
-    def initialize(hash)
-      @names = hash['names']
-      @emails = hash['emails']
-      @phone_numbers = hash['phone_numbers']
-      @addresses = hash['addresses']
-    end
-  end
-end

data/lib/plaid/models/institution.rb

@@ -1,22 +0,0 @@
-module Plaid
-  class Institution
-    attr_accessor :id, :name, :type, :has_mfa, :mfa, :credentials, :products
-
-    def initialize(fields = {})
-      @id = fields['id']
-      @name = fields['name']
-      @type = fields['type']
-      @has_mfa = fields['has_mfa']
-      @mfa = fields['mfa']
-      @credentials = fields['credentials']
-      @products = fields['products']
-    end
-
-    # API: semi-private
-    # This method takes an array returned from the API and instantiates all of the institutions
-    def self.all(res)
-      res.map { |inst| new(inst) }
-    end
-  end
-end
-

data/lib/plaid/models/transaction.rb

@@ -1,24 +0,0 @@
-module Plaid
-  class Transaction
-    attr_accessor :id, :account, :date, :amount, :name, :meta, :location, :pending, :score, :cat, :type, :category, :category_id, :pending_transaction
-
-    def initialize(fields = {})
-      @id = fields['_id']
-      @account = fields['_account']
-      @date = fields['date']
-      @amount = fields['amount']
-      @name = fields['name']
-      @location = fields['meta'].nil? ? {} : fields['meta']['location']
-      @pending = fields['pending']
-      @pending_transaction = fields['_pendingTransaction']
-      @score = fields['score']
-      @cat = Category.new({ 'id' => fields['category_id'], 'hierarchy' => fields['category'], 'type' => fields['type'] })
-
-      # Here for backwards compatibility only.
-      @type = fields['type']
-      @category = fields['category']
-      @category_id = fields['category_id']
-      @meta = fields['meta']
-    end
-  end
-end

data/lib/plaid/models/user.rb

@@ -1,189 +0,0 @@
-require_relative 'account'
-require_relative 'transaction'
-require_relative 'info'
-require 'json'
-
-module Plaid
-  class User
-    attr_accessor :accounts, :transactions, :access_token, :type, :permissions, :api_res, :pending_mfa_questions, :info, :information
-
-    # API: public
-    # Use this method to select the MFA method
-    def select_mfa_method(selection, type=nil)
-      type = self.type if type.nil?
-      auth_path = self.permissions.last + '/step'
-      res = Connection.post(auth_path, { options: { send_method: selection }.to_json, access_token: self.access_token, type: type })
-      update(res, self.permissions.last)
-    end
-
-    # API: public
-    # Use this method to send back the MFA code or answer
-    def mfa_authentication(auth, type = nil)
-      type = self.type if type.nil?
-      auth_path = self.permissions.last + '/step'
-      res = Connection.post(auth_path, { mfa: auth, access_token: self.access_token, type: type })
-      self.accounts = []
-      self.transactions = []
-      update(res)
-    end
-
-    # API: public
-    # Use this method to find out API levels available for this user
-    def permit?(auth_level)
-      self.permissions.include? auth_level
-    end
-
-    # API: public
-    # Use this method to upgrade a user to another api level
-    def upgrade(api_level=nil)
-      if api_level.nil?
-        api_level = 'auth' unless self.permit? 'auth'
-        api_level = 'connect' unless self.permit? 'connect'
-      end
-      res = Connection.post('upgrade', { access_token: self.access_token, upgrade_to: api_level })
-
-      # Reset accounts and transaction
-      self.accounts = []
-      self.transactions = []
-      update(res)
-    end
-
-    # API: public
-    # Use this method to delete a user from the Plaid API
-    def delete_user
-      Connection.delete('info', { access_token: self.access_token })
-    end
-
-    ### Internal build methods
-    def initialize
-      self.accounts = []
-      self.transactions = []
-      self.permissions = []
-      self.access_token = ''
-      self.api_res = ''
-      self.info = {}
-    end
-
-    # API: semi-private
-    # This class method instantiates a new Account object and updates it with the results
-    # from the API
-    def self.build(res, api_level = nil)
-      self.new.update(res, api_level)
-    end
-
-    # API: semi-private
-    # This method updates Account with the results returned from the API
-    def update(res, api_level = nil)
-      self.permit! api_level
-
-      if res[:msg].nil?
-        populate_user!(res)
-        clean_up_user!
-      else
-        set_mfa_request!(res)
-      end
-
-      self
-    end
-
-    # Internal helper methods
-
-    # API: semi-private
-    # Internal helper method to set the available API levels
-    def permit!(api_level)
-      return if api_level.nil? || self.permit?(api_level)
-      self.permissions << api_level
-    end
-
-    # API: semi-private
-    # Gets auth, connect, or info of the user
-    # TODO: (2.0) auth_level should be symbols instead of string
-    def get(auth_level, options = {})
-      return false unless self.permit? auth_level
-      case auth_level
-      when 'auth'
-        update(Connection.post('auth/get', access_token: self.access_token))
-      when 'connect'
-        payload = { access_token: self.access_token }.merge(options)
-        update(Connection.post('connect/get', payload))
-      when 'info'
-        update(Connection.secure_get('info', self.access_token))
-      else
-        raise "Invalid auth level: #{auth_level}"
-      end
-    end
-
-    # API: semi-private
-    def get_auth
-      get('auth')
-    end
-
-    # API: semi-private
-    def get_connect(options={})
-      get('connect', options)
-    end
-
-    # API: semi-private
-    def get_info
-      get('info')
-    end
-
-    # API: semi-private
-    # Helper method to update user information
-    # Requires 'info' api level
-    def update_info(username,pass,pin=nil)
-      return false unless self.permit? 'info'
-
-      payload = { username: username, password: pass, access_token: self.access_token }
-      payload.merge!(pin: pin) if pin
-      update(Plaid.patch('info', payload))
-    end
-
-    # API: semi-private
-    # Helper method to update user balance
-    def update_balance
-      update(Connection.post('balance', { access_token: self.access_token }))
-    end
-
-    private
-
-    def clean_up_user!
-      self.accounts.select! { |c| c.instance_of? Account }
-    end
-
-    def set_mfa_request!(res)
-      self.access_token = res[:body]['access_token']
-      self.pending_mfa_questions = res[:body]
-      self.api_res = res[:msg]
-    end
-
-    def populate_user!(res)
-      res['accounts'].each do |account|
-        if self.accounts.none? { |h| h.id == account['_id'] }
-          self.accounts << Account.new(account)
-        end
-      end if res['accounts']
-
-      res['transactions'].each do |transaction|
-        if self.transactions.any? { |t| t == transaction['_id'] }
-          owned_transaction = self.transactions.find { |h| h == transaction['_id'] }
-          owned_transaction.new(transaction)
-        else
-          self.transactions << Transaction.new(transaction)
-        end
-      end if res['transactions']
-
-      self.pending_mfa_questions = {}
-      self.information = Information.new(res['info']) if res['info']
-      self.api_res = 'success'
-
-      # TODO: Remove the following line when upgrading to V-2
-      self.info.merge!(res['info']) if res['info']
-      # End TODO
-
-      self.access_token = res['access_token'].split[0]
-      self.type = res['access_token'].split[1]
-    end
-
-  end
-end

data/spec/plaid/config_spec.rb

@@ -1,67 +0,0 @@
-describe 'Plaid.config' do
-  around(:each) do |example|
-    old_customer_id          = Plaid.customer_id
-    old_secret               = Plaid.secret
-    old_environment_location = Plaid.environment_location
-
-    Plaid.config do |p|
-      p.customer_id          = customer_id
-      p.secret               = secret
-      p.environment_location = environment_location
-    end
-
-    example.run
-
-    Plaid.config do |p|
-      p.customer_id          = old_customer_id
-      p.secret               = old_secret
-      p.environment_location = old_environment_location
-    end
-  end
-
-  let(:customer_id) { 'test_id' }
-  let(:secret)      { 'test_secret' }
-  let(:dev_url)  { 'https://tartan.plaid.com/' }
-  let(:prod_url) { 'https://api.plaid.com/' }
-
-
-  let(:user) { Plaid.add_user('connect', 'plaid_test', 'plaid_good', 'wells') }
-
-  context ':environment_location' do
-    context 'with trailing slash' do
-      let(:environment_location) { 'http://example.org/' }
-      it 'leaves it as-is' do
-        expect(Plaid.environment_location).to eql(environment_location)
-      end
-    end
-
-    context 'without trailing slash' do
-      let(:environment_location) { 'http://example.org' }
-      it 'adds a trailing slash' do
-        expect(Plaid.environment_location).to eql(environment_location + '/')
-      end
-    end
-  end
-
-  context 'has valid dev keys' do
-    let(:environment_location) { dev_url }
-    it { expect(user).to be_instance_of Plaid::User }
-  end
-
-  context 'has valid production keys' do
-    let(:environment_location) { prod_url }
-    it { expect(user).to be_instance_of Plaid::User }
-  end
-
-  context 'has invalid dev keys' do
-    let(:secret) { 'test_bad' }
-    let(:environment_location) { dev_url }
-    it { expect { user }.to raise_error(Plaid::Unauthorized, 'secret or client_id invalid') }
-  end
-
-  context 'has invalid production keys' do
-    let(:secret) { 'test_bad' }
-    let(:environment_location) { prod_url }
-    it { expect { user }.to raise_error(Plaid::Unauthorized, 'secret or client_id invalid') }
-  end
-end

data/spec/plaid/connection_spec.rb

@@ -1,191 +0,0 @@
-describe Plaid::Connection do
-  let(:stub_url) { "https://tartan.plaid.com/testing" }
-  let(:bad_req_response) {  {"code" => 1005, "message" => "invalid credentials", "resolve" => "The username or password provided is not correct."}.to_json }
-  let(:unauth_response) { {"code" => 1105, "message" => "bad access_token", "resolve" => "This access_token appears to be corrupted."}.to_json }
-  let(:req_fail_response) {  {"code" => 1200, "message" => "invalid credentials", "resolve" => "The username or password provided is not correct."}.to_json }
-  let(:req_not_found) {  {"code" =>  1600, "message" => "product not found", "resolve" => "This product doesn't exist yet, we're actually not sure how you reached this error..."}.to_json }
-
-  describe "#post" do
-    it "sends a post request" do
-      stub = stub_request(:post, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      Plaid::Connection.post("testing")
-      expect(stub).to have_requested(:post, stub_url)
-    end
-
-    it "returns response on 200 response" do
-      stub = stub_request(:post, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      response = Plaid::Connection.post("testing")
-      expect(response).to eq({"response" => "OK"})
-    end
-
-    it "returns message on 201 response" do
-      stub = stub_request(:post, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
-      response = Plaid::Connection.post("testing")
-      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
-    end
-
-    it "throws Plaid::BadRequest on 400 response" do
-      stub = stub_request(:post, stub_url).to_return(status: 400, body: bad_req_response)
-      expect { Plaid::Connection.post("testing") }.to raise_error(Plaid::BadRequest, "invalid credentials")
-    end
-
-    it "throws Plaid::Unauthorized on 401 response" do
-      stub = stub_request(:post, stub_url).to_return(status: 401, body: unauth_response)
-      expect { Plaid::Connection.post("testing") }.to raise_error(Plaid::Unauthorized, "bad access_token")
-    end
-
-    it "throws Plaid::RequestFailed on 402 response" do
-      stub = stub_request(:post, stub_url).to_return(status: 402, body: req_fail_response)
-      expect { Plaid::Connection.post("testing") }.to raise_error(Plaid::RequestFailed, "invalid credentials")
-    end
-
-    it "throws a Plaid::NotFound on 404 response" do
-      stub = stub_request(:post, stub_url).to_return(status: 404, body: req_not_found)
-      expect { Plaid::Connection.post("testing") }.to raise_error(Plaid::NotFound, "product not found")
-    end
-
-    it "throws a Plaid::ServerError on empty response" do
-      stub = stub_request(:post, stub_url).to_return(status: 504, body: '')
-      expect { Plaid::Connection.post("testing") }.to raise_error(Plaid::ServerError, '')
-    end
-  end
-
-  describe "#get" do
-    it "sends a get request" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      Plaid::Connection.get("testing")
-      expect(stub).to have_requested(:get, stub_url)
-    end
-
-    it "returns response when no code available" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      response = Plaid::Connection.get("testing")
-      expect(response).to eq({"response" => "OK"})
-    end
-
-    it "returns response when code not [1301, 1401, 1501, 1601]" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1502, "response" => "OK"}.to_json})
-      response = Plaid::Connection.get("testing")
-      expect(response).to eq({"code" => 1502, "response" => "OK"})
-    end
-
-    it "throws 404 for 1301 code" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1301, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
-      expect { Plaid::Connection.get("testing")}.to raise_error(Plaid::NotFound, "Doesn't matter")
-    end
-
-    it "throws 404 for 1401 code" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1401, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
-      expect { Plaid::Connection.get("testing")}.to raise_error(Plaid::NotFound, "Doesn't matter")
-    end
-
-    it "throws 404 for 1501 code" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1501, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
-      expect { Plaid::Connection.get("testing")}.to raise_error(Plaid::NotFound, "Doesn't matter")
-    end
-
-    it "throws 404 for 1601 code" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1601, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
-      expect { Plaid::Connection.get("testing")}.to raise_error(Plaid::NotFound, "Doesn't matter")
-    end
-
-  end
-
-  describe "#secure_get" do
-    it "sends a secure get request" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      Plaid::Connection.secure_get("testing", "test_wells")
-      expect(stub).to have_requested(:get, stub_url).with(:body => {:access_token => "test_wells"})
-    end
-
-    it "returns response on 200 response" do
-      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      response = Plaid::Connection.secure_get("testing", "test_wells")
-      expect(response).to eq({"response" => "OK"})
-    end
-
-    it "returns message on 201 response" do
-      stub = stub_request(:get, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
-      response = Plaid::Connection.secure_get("testing", "test_wells")
-      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
-    end
-
-    it "throws Plaid::BadRequest on 400 response" do
-      stub = stub_request(:get, stub_url).to_return(status: 400, body: bad_req_response)
-      expect { Plaid::Connection.secure_get("testing", "test_wells") }.to raise_error(Plaid::BadRequest, "invalid credentials")
-    end
-
-    it "throws Plaid::Unauthorized on 401 response" do
-      stub = stub_request(:get, stub_url).to_return(status: 401, body: unauth_response)
-      expect { Plaid::Connection.secure_get("testing", "test_wells") }.to raise_error(Plaid::Unauthorized, "bad access_token")
-    end
-
-    it "throws Plaid::RequestFailed on 402 response" do
-      stub = stub_request(:get, stub_url).to_return(status: 402, body: req_fail_response)
-      expect { Plaid::Connection.secure_get("testing", "test_wells") }.to raise_error(Plaid::RequestFailed, "invalid credentials")
-    end
-
-    it "throws a Plaid::NotFound on 404 response" do
-      stub = stub_request(:get, stub_url).to_return(status: 404, body: req_not_found)
-      expect { Plaid::Connection.secure_get("testing", "test_wells") }.to raise_error(Plaid::NotFound, "product not found")
-    end
-
-    it "throws a Plaid::ServerError on empty response" do
-      stub = stub_request(:get, stub_url).to_return(status: 504, body: '')
-      expect { Plaid::Connection.secure_get("testing", "test_wells") }.to raise_error(Plaid::ServerError, '')
-    end
-  end
-
-  describe "#patch" do
-    it "sends a patch request" do
-      stub = stub_request(:patch, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      Plaid::Connection.patch("testing")
-      expect(stub).to have_requested(:patch, stub_url)
-    end
-
-    it "returns response on 200 response" do
-      stub = stub_request(:patch, stub_url).to_return({:body => {"response" => "OK"}.to_json})
-      response = Plaid::Connection.patch("testing")
-      expect(response).to eq({"response" => "OK"})
-    end
-
-    it "returns message on 201 response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
-      response = Plaid::Connection.patch("testing")
-      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
-    end
-
-    it "throws Plaid::BadRequest on 400 response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 400, body: bad_req_response)
-      expect { Plaid::Connection.patch("testing") }.to raise_error(Plaid::BadRequest, "invalid credentials")
-    end
-
-    it "throws Plaid::Unauthorized on 401 response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 401, body: unauth_response)
-      expect { Plaid::Connection.patch("testing") }.to raise_error(Plaid::Unauthorized, "bad access_token")
-    end
-
-    it "throws Plaid::RequestFailed on 402 response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 402, body: req_fail_response)
-      expect { Plaid::Connection.patch("testing") }.to raise_error(Plaid::RequestFailed, "invalid credentials")
-    end
-
-    it "throws a Plaid::NotFound on 404 response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 404, body: req_not_found)
-      expect { Plaid::Connection.patch("testing") }.to raise_error(Plaid::NotFound, "product not found")
-    end
-
-    it "throws a Plaid::ServerError on empty response" do
-      stub = stub_request(:patch, stub_url).to_return(status: 504, body: '')
-      expect { Plaid::Connection.patch("testing") }.to raise_error(Plaid::ServerError, '')
-    end
-  end
-
-  describe "#delete" do
-    it "sends a delete request" do
-      stub = stub_request(:delete, stub_url)
-      Plaid::Connection.delete("testing")
-      expect(stub).to have_requested(:delete, stub_url)
-    end
-  end
-end