plaid 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00be434d6e58902d9c47db517d0907f668fe620c
-  data.tar.gz: c60a4d95dc87cbff07092a77af43e03bc4f7c1f3
+  metadata.gz: 850b922bf86cae1a44608e0cb0c418c3219d75c1
+  data.tar.gz: 94feeeb9e8c679ba72c6f7d9f59641f20a28c2b5
 SHA512:
-  metadata.gz: f0d01df929e6ea2c7a3c3329304814189d78a6074e07507c07124f8c54e60cf1cfc6c2fd8740d35fef964fec26003996576792ddc905ce29ae992b5a4b8c457a
-  data.tar.gz: c90dc4c04e8f953c197a8838984cb53a584ce33325c48112fee5972719179195f153f3f3fb3010e70b76353ae00662feded4ad6a37dd0f653aae73493a05aa7e
+  metadata.gz: fb4406c54faaae17871f06da31d98cc374859738d5c06f59dd38f7f4d0471f078c2b34b26b3064a2ae93694f7ee5fb6c698b86b25608b024d52cd1b3b3e086a7
+  data.tar.gz: 994baa65df1ba115d2013fef8152e3a9c7efc0ed2bb4d8f5c9d6e6319d297d50ba0fb26c4a153b01b0e9c977afc4c7dc6c88b642e3aa9f4be2ea5d508ff81da6

data/README.md

@@ -6,9 +6,7 @@ Ruby bindings for the Plaid API
 
 This version is a beta version that contains failing tests for the new 'info' endpoint. While these have been tested individually on real accounts the tests here will fail with the test accounts supplied. These will be updated soon with test credentials.
 
-Latest stable version: **1.2.2**
-
-Last stable version: 1.1.2
+Latest stable version: **1.3.0**
 
 **Warning: If you have been using any version < 1 please switch to the correct branch (V0.1.6). Installing without specifying a version from RubyGems results in V1.1 build. **
 

data/lib/plaid/user/info/info.rb

@@ -0,0 +1,23 @@
+require 'plaid/util'
+module Plaid
+  class Information
+    include Plaid::Util
+    # Define vars for info
+    attr_accessor(:names, :emails, :phone_numbers, :addresses)
+
+    def new
+      self.names = []
+      self.emails = []
+      self.phone_numbers = []
+      self.addresses = ''
+    end
+
+    def update_info(res)
+      self.names = res['names']
+      self.emails = res['emails']
+      self.phone_numbers = res['phone_numbers']
+      self.addresses = res['addresses']
+    end
+  end
+
+end

data/lib/plaid/user/user.rb

@@ -1,5 +1,6 @@
 require_relative 'account/account'
 require_relative 'transaction/transaction'
+require_relative 'info/info'
 require 'plaid/util'
 require 'json'
 module Plaid
@@ -7,15 +8,10 @@ module Plaid
     include Plaid::Util
 
     # Define user vars
-    attr_accessor(:accounts, :transactions, :access_token, :permissions, :api_res, :pending_mfa_questions, :info)
+    attr_accessor(:accounts, :transactions, :access_token, :permissions, :api_res, :pending_mfa_questions, :info, :information)
 
     def initialize
-      self.accounts = []
-      self.transactions = []
-      self.permissions = []
-      self.access_token = ''
-      self.api_res = ''
-      self.info = {}
+      self.accounts = [], self.transactions = [], self.permissions = [], self.access_token = '', self.api_res = '', self.info = {}, self.information = Information.new
     end
 
     # Instantiate a new user with the results of the successful API call
@@ -46,9 +42,11 @@ module Plaid
       end
     end
 
-    def get_connect
+    def get_connect(options=nil)
       if self.permissions.include? 'connect'
-        res = Plaid.post('connect/get',{access_token:self.access_token})
+        payload = {access_token:self.access_token}
+        payload.merge!(options) if options
+        res = Plaid.post('connect/get',payload)
         build_user(res)
       else
         false
@@ -99,33 +97,10 @@ module Plaid
     def build_user(res,api_level=nil)
       begin
         if res[:msg].nil?
-          res['accounts'].each do |account|
-            if self.accounts.any? { |h| h == account['_id'] }
-              owned_account = self.accounts.find { |h| h == account['_id'] }
-              owned_account.new(account)
-            else
-              self.accounts << new_account(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 << new_transaction(transaction)
-            end
-          end if res['transactions']
-          self.permissions << api_level unless self.permissions.include? api_level && api_level.nil?
-          self.api_res = 'success'
-          self.pending_mfa_questions = ''
-          self.info.merge!(res['info']) if res['info']
-          self.access_token = res['access_token']
+          populate_user(self,res,api_level)
           clean_up_user(self)
         else
-          self.access_token = res[:body]['access_token']
-          self.pending_mfa_questions = res[:body]
-          self.api_res = res[:msg]
-          self.permissions << api_level unless self.permissions.include? api_level && api_level.nil?
+          set_mfa_request(self,res,api_level)
         end
       rescue => e
         error_handler(e)
@@ -153,5 +128,42 @@ module Plaid
       user
     end
 
+    def set_mfa_request(user,res,api_level)
+      user.access_token = res[:body]['access_token']
+      user.pending_mfa_questions = res[:body]
+      user.api_res = res[:msg]
+      user.permissions << api_level unless self.permissions.include? api_level && api_level.nil?
+    end
+
+    def populate_user(user,res,api_level)
+      res['accounts'].each do |account|
+        if user.accounts.any? { |h| h == account['_id'] }
+          owned_account = user.accounts.find { |h| h == account['_id'] }
+          owned_account.new(account)
+        else
+          user.accounts << new_account(account)
+        end
+      end if res['accounts']
+
+      res['transactions'].each do |transaction|
+        if user.transactions.any? { |t| t == transaction['_id'] }
+          owned_transaction = user.transactions.find { |h| h == transaction['_id'] }
+          owned_transaction.new(transaction)
+        else
+          user.transactions << new_transaction(transaction)
+        end
+      end if res['transactions']
+
+      user.permissions << api_level unless user.permissions.include? api_level && api_level.nil?
+      user.pending_mfa_questions = ''
+      user.information.update_info(res['info']) if res['info']
+      user.api_res = 'success'
+
+      # TODO: Remove the following line when upgrading to V-2
+      user.info.merge!(res['info']) if res['info']
+      # End TODO
+      user.access_token = res['access_token']
+    end
+
   end
 end

data/lib/plaid/util.rb

@@ -14,13 +14,16 @@ module Plaid
     def get(path,id=nil)
       uri = build_uri(path,id)
       res = Net::HTTP.get(uri)
-      JSON.parse(res)
+      parse_get_response(res)
     end
 
     def patch(path,options={})
       uri = build_uri(path)
       options.merge!({client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret')})
-      res = Net::HTTP.patch(uri,options)
+      req = Net::HTTP::Patch.new(uri)
+      req.body = URI.encode_www_form(options) if options
+      req.content_type = 'multipart/form-data'
+      res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
       parse_response(res)
     end
 
@@ -30,7 +33,7 @@ module Plaid
       req = Net::HTTP::Delete.new(uri)
       req.body = URI.encode_www_form(options) if options
       req.content_type = 'multipart/form-data'
-      res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
+      Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
     end
 
     def error_handler(err,res=nil)
@@ -85,5 +88,22 @@ module Plaid
       end
     end
 
+    def parse_get_response(res)
+      body = JSON.parse(res)
+      if body.class == Array
+        body
+      else
+        if body['code'].nil?
+          body
+        else
+          if body['code'] == 1401 || body['code'] == 1501 || body['code'] == 1601
+            error_handler('Not Found',body)
+          else
+            body
+          end
+        end
+      end
+    end
+
   end
 end

data/lib/plaid/version.rb

@@ -1,3 +1,3 @@
 module Plaid
-  VERSION = '1.2.3'
+  VERSION = '1.3.0'
 end

data/spec/add_user_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper.rb'
+# Authentication flow specs - returns Plaid::User
+describe '.add_user' do
+
+  Plaid.config do |p|
+    p.customer_id = 'test_id'
+    p.secret = 'test_secret'
+    p.environment_location = 'https://tartan.plaid.com/'
+  end
+
+  context 'has correct credentials for single factor auth, authenticates to the connect level of api access' do
+    user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'has correct credentials for single factor auth, authenticates to the auth level of api access' do
+    user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
+    it { expect(user.accounts[0].numbers.nil?).to be_falsey }
+  end
+
+  context 'has correct credentials for single factor auth, authenticates to the info level of api access' do
+    user = Plaid.add_user('info','plaid_test','plaid_good','wells')
+    it { expect(user.info).to be_truthy }
+  end
+
+  context 'has correct username, but incorrect password for single factor auth under auth level of api access' do
+    it { expect{Plaid.add_user('auth','plaid_test','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has incorrect username under auth level of api access' do
+    it { expect{Plaid.add_user('auth','plaid_bad','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has correct username, but incorrect password for single factor auth under connect level of api access' do
+    it { expect{Plaid.add_user('connect','plaid_test','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has incorrect username under connect level of api access' do
+    it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has correct username, but incorrect password for single factor auth under info level of api access' do
+    it { expect{Plaid.add_user('info','plaid_test','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has incorrect username under info level of api access' do
+    it { expect{Plaid.add_user('info','plaid_bad','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'enters pin for extra parameter authentication required by certain institutions' do
+    user = Plaid.add_user('connect','plaid_test','plaid_good','usaa','1234')
+    it { expect(user.api_res).to eq 'Requires further authentication' }
+  end
+
+  context 'enters incorrect pin for extra parameter authentication required by certain institutions' do
+    it { expect{Plaid.add_user('connect','plaid_test','plaid_good','usaa','0000')}.to raise_error }
+  end
+
+  context 'has to enter MFA credentials' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
+    it { expect(user.api_res).to eq 'Requires further authentication' }
+  end
+
+  context 'enters correct information with locked account' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_locked','wells')
+    it { expect(user.api_res).to eq 'User account is locked' }
+  end
+
+  context 'enters webhook option as part of standard call' do
+    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'enters webhook option as part of mfa required institution authentication' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
+    it { expect(user.api_res).to eq 'Requires further authentication' }
+  end
+
+  context 'requests pending transactions from an institution' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{pending: true})
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'sets the login only option to true' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true})
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'requests a list of options for code based MFA' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','citi',{list: true})
+    it { expect(user.pending_mfa_questions.nil?).to be_falsey }
+  end
+
+  context 'sets a start date for transactions' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true, start_date:'10 days ago'})
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'sets an end date for transactions' do
+    user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true, end_date: '10 days ago'})
+    it { expect(user.accounts.empty?).to be_falsey }
+  end
+
+  context 'sets start and end dates for transactions' do
+    user = Plaid.add_user('connect','plaid_test','plaid_good','wells',"{'gte':'05/10/2014' , 'lte':'06/10/2014'}")
+    it{ expect(user.transactions).to be_truthy }
+  end
+end

data/spec/category_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper.rb'
+# Category specs
+describe '#Category' do
+
+  before :all do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_secret'
+      p.environment_location = 'https://tartan.plaid.com/'
+    end
+  end
+
+  context 'when a single category is found' do
+    category = Plaid.category('17001013')
+    it { expect(category.class).to eq (Plaid::Category) }
+  end
+
+  context 'when all categories are found' do
+    category = Plaid.category
+    it { expect(category).to be_kind_of(Array)}
+  end
+
+  context 'when category is not found' do
+    it { expect { Plaid.category('dumb_cat') }.to raise_error }
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,40 @@
+# Configuration specs - used in gem configuration
+describe '.config' do
+  context 'has valid dev keys' do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_secret'
+      p.environment_location = 'https://tartan.plaid.com/'
+    end
+    res = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+    it { expect(res).to be_instance_of Plaid::User }
+  end
+
+  context 'has valid production keys' do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_secret'
+      p.environment_location = 'https://api.plaid.com/'
+    end
+    res = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+    it { expect(res).to be_instance_of Plaid::User }
+  end
+
+  context 'has invalid dev keys' do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_bad'
+      p.environment_location = 'https://tartan.plaid.com/'
+    end
+    it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
+  end
+
+  context 'has invalid production keys' do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_bad'
+      p.environment_location = 'https://api.plaid.com/'
+    end
+    it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
+  end
+end

data/spec/institution_spec.rb

@@ -0,0 +1,25 @@
+# Institution specs
+describe '#Institution' do
+
+  before :all do
+    Plaid.config do |p|
+      p.customer_id = 'test_id'
+      p.secret = 'test_secret'
+      p.environment_location = 'https://tartan.plaid.com/'
+    end
+  end
+
+  context 'when a single institution is found' do
+    institution = Plaid.institution('5301a93ac140de84910000e0')
+    it { expect(institution.class).to eq(Plaid::Institution) }
+  end
+
+  context 'when all institutions are found' do
+    institution = Plaid.institution
+    it { expect(institution).to be_kind_of(Array) }
+  end
+
+  context 'when institution is not found' do
+    it { expect { Plaid.institution('dumb_bank') }.to raise_error }
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper.rb'
+########## Plaid instantiated user specs ##########
+describe '#User' do
+
+  Plaid.config do |p|
+    p.customer_id = 'test_id'
+    p.secret = 'test_secret'
+    p.environment_location = 'https://tartan.plaid.com/'
+  end
+
+  describe 'user vars' do
+
+    context 'valid user has accounts and accounts contain id attribute' do
+      user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+      it { expect(user.accounts.first.id).to be_truthy }
+    end
+
+    context 'valid user has accounts and accounts contain type attribute' do
+      user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+      it { expect(user.accounts.first.type).to eq('depository') }
+    end
+  end
+
+  # MFA specs - after user is instantiated,
+  describe '#mfa_authentication' do
+
+    context 'enters correct credentials for MFA auth and authenticates' do
+      new_mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
+      new_mfa_user.mfa_authentication('tomato','bofa')
+      it { expect(new_mfa_user.accounts).to be_truthy }
+    end
+
+    context 'has to enter another round of MFA credentials' do
+      mfa_again = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
+      mfa_again.mfa_authentication('again','bofa')
+      it { expect(mfa_again.api_res).to eq 'Requires further authentication' }
+    end
+
+    context 'enters incorrect credentials for MFA auth' do
+      mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
+      mfa_user.mfa_authentication('tomato','bofa')
+      mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
+      it { expect { mfa_user.mfa_authentication('bad','bofa') }.to raise_error }
+    end
+
+    context 'requests list of MFA credentials' do
+      new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
+      it { expect(new_mfa_user.pending_mfa_questions).to eq({"type"=>"list", "mfa"=>[{"mask"=>"xxx-xxx-5309", "type"=>"phone"}, {"mask"=>"t..t@plaid.com", "type"=>"email"}], "access_token"=>"test"}) }
+    end
+
+    context 'selects MFA method and returns successful response' do
+      new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
+      new_mfa_user.select_mfa_method({mask:'xxx-xxx-5309'},'chase')
+      it { expect(new_mfa_user.pending_mfa_questions).to eq({"type"=>"device", "mfa"=>{"message"=>"Code sent to xxx-xxx-5309"}, "access_token"=>"test"}) }
+    end
+
+    context 'selects MFA method, and delivers correct payload to authenticate user' do
+      new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
+      new_mfa_user.select_mfa_method({mask:'xxx-xxx-5309'},'chase')
+      new_mfa_user.mfa_authentication(1234,'chase')
+      it { expect(new_mfa_user.accounts).to be_truthy }
+    end
+  end
+
+  # Auth specs
+  describe '#get_auth' do
+    auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
+    connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+
+    context 'has access and returns accounts' do
+      it { expect(auth_user.permissions[0]).to eq('auth') }
+    end
+
+    context 'does not have access to auth' do
+      it{ expect(connect_user.permissions.include? 'auth' ).to be false }
+    end
+  end
+
+  # Connect specs
+  describe '#get_connect' do
+    auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
+    connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+
+    context 'has access and returns accounts' do
+      it { expect(connect_user.permissions[0]).to eq('connect') }
+    end
+
+    context 'does not have access to auth' do
+      it{ expect(auth_user.permissions.include? 'connect' ).to be false }
+    end
+  end
+
+  # Get info specs
+  describe '#get_info' do
+    info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
+    auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
+
+    context 'has access and returns user info' do
+      it { expect(info_user.permissions[0]).to eq('info') }
+    end
+
+    context 'does not have access to info' do
+      it{ expect(auth_user.permissions.include? 'info' ).to be false }
+    end
+  end
+
+  describe '#get_balance' do
+    user = Plaid.add_user('info','plaid_test','plaid_good','wells')
+    user.update_balance
+    context 'updates user accounts' do
+      it { expect(user.accounts.empty?).to be_falsey }
+    end
+
+    context 'should not double up accounts or transactions' do
+      dup = user.accounts.select{|element| user.accounts.count(element) > 1}
+      dup = dup.length + user.transactions.select{|element| user.transactions.count(element) > 1}.length
+      it{ expect(dup).to eq(0) }
+    end
+
+    end
+
+=begin TODO: This test needs to pass, currently test credentials are failing
+  describe '#update_info' do
+    info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
+    context 'updates information correctly' do
+      it { expect { info_user.update_info('plaid_test','plaid_good') }.to_not raise_error  }
+    end
+  end
+=end
+
+  describe '#delete_user' do
+    info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
+    info_user.delete_user
+
+    context 'updates information correctly' do
+      it { expect { info_user.get_info }.to raise_error }
+    end
+  end
+
+  describe '#upgrade' do
+    auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
+    connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+
+    context 'auth upgrade is successful' do
+      connect_user.upgrade('auth')
+      it { expect{ connect_user.get_auth }.to_not raise_error }
+    end
+
+    context 'connect upgrade is successful' do
+      auth_user.upgrade('connect')
+      it { expect{ auth_user.get_connect }.to_not raise_error }
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plaid
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Justin Crites
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-15 00:00:00.000000000 Z
+date: 2015-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,13 +72,18 @@ files:
 - lib/plaid/config.rb
 - lib/plaid/institution/institution.rb
 - lib/plaid/user/account/account.rb
+- lib/plaid/user/info/info.rb
 - lib/plaid/user/transaction/transaction.rb
 - lib/plaid/user/user.rb
 - lib/plaid/util.rb
 - lib/plaid/version.rb
 - plaid.gemspec
-- spec/plaid_spec.rb
+- spec/add_user_spec.rb
+- spec/category_spec.rb
+- spec/config_spec.rb
+- spec/institution_spec.rb
 - spec/spec_helper.rb
+- spec/user_spec.rb
 homepage: https://github.com/plaid/plaid-ruby
 licenses:
 - MIT
@@ -104,5 +109,9 @@ signing_key:
 specification_version: 4
 summary: Ruby bindings for Plaid
 test_files:
-- spec/plaid_spec.rb
+- spec/add_user_spec.rb
+- spec/category_spec.rb
+- spec/config_spec.rb
+- spec/institution_spec.rb
 - spec/spec_helper.rb
+- spec/user_spec.rb

data/spec/plaid_spec.rb

@@ -1,526 +0,0 @@
-require 'spec_helper.rb'
-########## Plaid specs ##########
-describe Plaid do
-
-  # Configuration specs - used in gem configuration
-  describe '.config' do
-    context 'has valid dev keys' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      res = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-      it { expect(res).to be_instance_of Plaid::User }
-    end
-
-    context 'has valid production keys' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://api.plaid.com/'
-      end
-      res = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-      it { expect(res).to be_instance_of Plaid::User }
-    end
-
-    context 'has invalid dev keys' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_bad'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has invalid production keys' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_bad'
-        p.environment_location = 'https://api.plaid.com/'
-      end
-      it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
-    end
-  end
-
-  # Authentication flow specs - returns Plaid::User
-  # TODO: Abstract the config from each section with the result in passing tests
-  describe '.add_user' do
-
-    context 'has correct credentials for single factor auth, authenticates to the connect level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-
-    context 'has correct credentials for single factor auth, authenticates to the auth level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-      it { expect(user.accounts[0].numbers.nil?).to be_falsey }
-    end
-
-    context 'has correct credentials for single factor auth, authenticates to the info level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-      it { expect(user.info).to be_truthy }
-    end
-
-    context 'has correct username, but incorrect password for single factor auth under auth level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('auth','plaid_test','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has incorrect username under auth level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('auth','plaid_bad','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has correct username, but incorrect password for single factor auth under connect level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('connect','plaid_test','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has incorrect username under connect level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has correct username, but incorrect password for single factor auth under info level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('info','plaid_test','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'has incorrect username under info level of api access' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('info','plaid_bad','plaid_bad','wells')}.to raise_error }
-    end
-
-    context 'enters pin for extra parameter authentication required by certain institutions' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_test','plaid_good','usaa','1234')
-      it { expect(user.api_res).to eq 'Requires further authentication' }
-    end
-
-    context 'enters incorrect pin for extra parameter authentication required by certain institutions' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect{Plaid.add_user('connect','plaid_test','plaid_good','usaa','0000')}.to raise_error }
-    end
-
-    context 'has to enter MFA credentials' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
-      it { expect(user.api_res).to eq 'Requires further authentication' }
-    end
-
-    context 'enters correct information with locked account' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_locked','wells')
-      it { expect(user.api_res).to eq 'User account is locked' }
-    end
-
-    context 'enters webhook option as part of standard call' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-
-    context 'enters webhook option as part of mfa required institution authentication' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
-      it { expect(user.api_res).to eq 'Requires further authentication' }
-    end
-
-    context 'requests pending transactions from an institution' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{pending: true})
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-
-    context 'sets the login only option to true' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true})
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-
-    context 'requests a list of options for code based MFA' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','citi',{list: true})
-      it { expect(user.pending_mfa_questions.nil?).to be_falsey }
-    end
-
-    context 'sets a start date for transactions' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true, start_date:'10 days ago'})
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-
-    context 'sets an end date for transactions' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      user = Plaid.add_user('connect','plaid_selections', 'plaid_good','wells',{login_only:true, end_date: '10 days ago'})
-      it { expect(user.accounts.empty?).to be_falsey }
-    end
-  end
-
-  # Institution specs
-  describe '#Institution' do
-    context 'when a single institution is found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      institution = Plaid.institution('5301a93ac140de84910000e0')
-      it { expect(institution.class).to eq(Plaid::Institution) }
-    end
-
-    context 'when all institutions are found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      institution = Plaid.institution
-      it { expect(institution).to be_kind_of(Array) }
-    end
-
-=begin TODO: Get this test passing
-    context 'when institution is not found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      res = Plaid.institution('dumb_bank')
-      it { expect(res).to eq('Bank not found') }
-    end
-=end
-  end
-
-  # Category specs
-  describe '#Category' do
-    context 'when a single category is found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      category = Plaid.category('17001013')
-      it { expect(category.class).to eq (Plaid::Category) }
-    end
-
-    context 'when all categories are found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      category = Plaid.category
-      it { expect(category).to be_kind_of(Array)}
-    end
-
-=begin TODO: Get this test passing
-    context 'when category is not found' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      it { expect { Plaid.category('dumb_cat') }.to raise_error }
-    end
-=end
-
-  end
-  ########## Plaid instantiated user specs ##########
-
-  describe '#User' do
-
-    describe 'user vars' do
-
-      context 'valid user has accounts and accounts contain id attribute' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-        user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-        it { expect(user.accounts.first.id).to be_truthy }
-      end
-
-      context 'valid user has accounts and accounts contain type attribute' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-        user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-        it { expect(user.accounts.first.type).to eq('depository') }
-      end
-    end
-
-    # MFA specs - after user is instantiated,
-    describe '#mfa_authentication' do
-
-      context 'enters correct credentials for MFA auth and authenticates' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-        new_mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
-        new_mfa_user.mfa_authentication('tomato','bofa')
-        it { expect(new_mfa_user.accounts).to be_truthy }
-      end
-
-      context 'has to enter another round of MFA credentials' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-        mfa_again = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
-        mfa_again.mfa_authentication('again','bofa')
-        it { expect(mfa_again.api_res).to eq 'Requires further authentication' }
-      end
-
-      context 'enters incorrect credentials for MFA auth' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-        mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
-        mfa_user.mfa_authentication('tomato','bofa')
-        mfa_user = Plaid.add_user('connect','plaid_selections', 'plaid_good','bofa')
-        it { expect { mfa_user.mfa_authentication('bad','bofa') }.to raise_error }
-      end
-
-      context 'requests list of MFA credentials' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-
-        new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
-        it { expect(new_mfa_user.pending_mfa_questions).to eq({"type"=>"list", "mfa"=>[{"mask"=>"xxx-xxx-5309", "type"=>"phone"}, {"mask"=>"t..t@plaid.com", "type"=>"email"}], "access_token"=>"test"}) }
-      end
-
-      context 'selects MFA method and returns successful response' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-
-        new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
-        new_mfa_user.select_mfa_method({mask:'xxx-xxx-5309'},'chase')
-        it { expect(new_mfa_user.pending_mfa_questions).to eq({"type"=>"device", "mfa"=>{"message"=>"Code sent to xxx-xxx-5309"}, "access_token"=>"test"}) }
-      end
-
-      context 'selects MFA method, and delivers correct payload to authenticate user' do
-        Plaid.config do |p|
-          p.customer_id = 'test_id'
-          p.secret = 'test_secret'
-          p.environment_location = 'https://tartan.plaid.com/'
-        end
-
-        new_mfa_user = Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}')
-        new_mfa_user.select_mfa_method({mask:'xxx-xxx-5309'},'chase')
-        new_mfa_user.mfa_authentication(1234,'chase')
-        it { expect(new_mfa_user.accounts).to be_truthy }
-      end
-    end
-
-    # Auth specs
-    describe '#get_auth' do
-      auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-      connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-
-      context 'has access and returns accounts' do
-        it { expect(auth_user.permissions[0]).to eq('auth') }
-      end
-
-      context 'does not have access to auth' do
-        it{ expect(connect_user.permissions.include? 'auth' ).to be false }
-      end
-    end
-
-    # Connect specs
-    describe '#get_connect' do
-      auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-      connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-
-      context 'has access and returns accounts' do
-        it { expect(connect_user.permissions[0]).to eq('connect') }
-      end
-
-      context 'does not have access to auth' do
-        it{ expect(auth_user.permissions.include? 'connect' ).to be false }
-      end
-    end
-
-    # Get info specs
-    describe '#get_info' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-      info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-      auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-
-      context 'has access and returns user info' do
-        it { expect(info_user.permissions[0]).to eq('info') }
-      end
-
-      context 'does not have access to info' do
-        it{ expect(auth_user.permissions.include? 'info' ).to be false }
-      end
-    end
-
-    describe '#get_balance' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-
-      user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-      user.update_balance
-      context 'updates user accounts' do
-        it { expect(user.accounts.empty?).to be_falsey }
-      end
-
-      context 'should not double up accounts or transactions' do
-        dup = user.accounts.select{|element| user.accounts.count(element) > 1}
-        dup = dup.length + user.transactions.select{|element| user.transactions.count(element) > 1}.length
-        it{ expect(dup).to eq(0) }
-      end
-
-    end
-
-=begin
-    describe '#update_info' do
-      info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-
-      context 'updates information correctly' do
-        it { expect { info_user.update_info('info','plaid_test','plaid_new','wells') }.to be_truthy }
-      end
-    end
-=end
-
-    describe '#delete_user' do
-      Plaid.config do |p|
-        p.customer_id = 'test_id'
-        p.secret = 'test_secret'
-        p.environment_location = 'https://tartan.plaid.com/'
-      end
-
-      info_user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-      info_user.delete_user
-
-      context 'updates information correctly' do
-        it { expect { info_user.get_info }.to raise_error }
-      end
-    end
-
-    # Upgrade specs - either pass or fails
-=begin TODO: Write upgrade methods to pass without paying
-    describe '#upgrade' do
-      auth_user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-      connect_user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-
-      context 'auth upgrade is successful' do
-        connect_user.upgrade
-        it { expect(connect_user.get_auth).to be_truthy }
-      end
-
-      context 'connect upgrade is successful' do
-        auth_user.upgrade
-        it { expect(auth_user.get_connect).to be_truthy }
-      end
-    end
-=end
-
-  end
-end