plaid 1.4.3 → 1.5.0

data/spec/user_spec.rb

@@ -1,186 +1,175 @@
 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
+RSpec.describe Plaid::User do
+  let(:auth_user)    { Plaid.add_user('auth',   'plaid_test', 'plaid_good', 'wells') }
+  let(:connect_user) { Plaid.add_user('connect','plaid_test', 'plaid_good', 'wells') }
+  let(:info_user)    { Plaid.add_user('info',   'plaid_test', 'plaid_good', 'wells') }
 
-  describe 'user vars' do
+  context '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 }
+      let(:user) { Plaid.add_user('connect','plaid_test','plaid_good','wells') }
+      it { expect(user.accounts.first.id).not_to be_nil }
     end
 
     context 'valid user has accounts and accounts contain type attribute' do
-      user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
+      let(:user) { Plaid.add_user('connect','plaid_test','plaid_good','wells') }
       it { expect(user.accounts.first.type).to eq('depository') }
     end
-
-    context 'gets a valid user with accounts and transactions' do
-      user = Plaid.set_user('test_wells',['connect'])
-      it{ expect(user.transactions).to be_truthy}
-    end
-
-    context 'gets a valid user with accounts' do
-      user = Plaid.set_user('test_wells',['auth'])
-      it{ expect(user.accounts).to be_truthy}
-    end
-
-    #TODO: Fully vet the info api endpoint for the beta functions before adding this as a supported function.
-=begin
-    context 'gets a valid user with info' do
-      user = Plaid.set_user('test_wells',['info'])
-      it{ expect(user.accounts).to be_truthy}
-    end
-
-
-    context 'gets a fully validated user with all access granted' do
-      user = Plaid.set_user('test_wells',['connect','info','auth'])
-      it{ expect(user.transactions).to be_truthy}
-    end
-=end
-
   end
 
   # MFA specs - after user is instantiated,
   describe '#mfa_authentication' do
+    let(:user) { Plaid.add_user('connect','plaid_test', 'plaid_good','bofa') }
+    let(:new_mfa_user) { user.mfa_authentication('tomato') }
 
     context 'enters correct credentials for MFA auth and authenticates' do
-      new_mfa_user = Plaid.add_user('connect','plaid_test', 'plaid_good','bofa')
-      new_mfa_user.mfa_authentication('tomato')
-      it { expect(new_mfa_user.accounts).to be_truthy }
+      it { expect(new_mfa_user.accounts).not_to be_empty }
     end
 
     context 'enters old method of adding type strongly in each method and authenticates correctly using 2FA' do
-      new_mfa_user = Plaid.add_user('connect','plaid_test', 'plaid_good','bofa')
-      new_mfa_user.mfa_authentication('tomato','bofa')
+      let(:new_mfa_user) { 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_test', 'plaid_good','bofa')
-      mfa_again.mfa_authentication('again')
+      let(:mfa_again) { user.mfa_authentication('again') }
       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_test', 'plaid_good','bofa')
-      mfa_user.mfa_authentication('tomato')
-      mfa_user = Plaid.add_user('connect','plaid_test', 'plaid_good','bofa')
-      it { expect { mfa_user.mfa_authentication('bad') }.to raise_error }
+      let(:mfa_user) { user.mfa_authentication('tomato') }
+      let(:mfa_bad)  { mfa_user; Plaid.add_user('connect','plaid_test', 'plaid_good','bofa') }
+      it { expect { mfa_bad.mfa_authentication('bad') }.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_chase"}) }
+      let(:new_mfa_user) { Plaid.add_user('auth', 'plaid_test', 'plaid_good', 'chase', nil, '{"list":true}') }
+      let(:expected_questions) do
+           {
+             "type"=>"list",
+             "mfa"=> [
+               {"mask"=>"xxx-xxx-5309", "type"=>"phone"},
+               {"mask"=>"t..t@plaid.com", "type"=>"email"}
+             ],
+             "access_token"=>"test_chase"
+           }
+      end
+      it { expect(new_mfa_user.pending_mfa_questions).to eql(expected_questions) }
     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_chase"}) }
+      let(:user) { Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}') }
+      let(:new_mfa_user) { user.select_mfa_method({mask: 'xxx-xxx-5309' }, 'chase') }
+      let(:expected_pending_questions) do
+        {
+          "type" => "device",
+          "mfa"  => { "message" => "Code sent to xxx-xxx-5309" },
+          "access_token" => "test_chase"
+        }
+      end
+      it { expect(new_mfa_user.pending_mfa_questions).to eql(expected_pending_questions) }
     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'})
-      new_mfa_user.mfa_authentication(1234)
-      it { expect(new_mfa_user.accounts).to be_truthy }
-    end
-  end
+      let(:user) { Plaid.add_user('auth','plaid_test','plaid_good','chase',nil,'{"list":true}') }
+      let(:user_select_method) { user.select_mfa_method({mask:'xxx-xxx-5309'}) }
+      let(:new_mfa_user) { user_select_method.mfa_authentication(1234) }
 
-  # 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 }
+      it { expect(new_mfa_user.accounts).not_to be_empty }
     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 'when authenticating' do
+    # Auth specs
+    describe '#get_auth' do
 
-    context 'has access and returns accounts' do
-      it { expect(connect_user.permissions[0]).to eq('connect') }
-    end
+      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(auth_user.permissions.include? 'connect' ).to be false }
+      context 'does not have access to auth' do
+        it { expect(connect_user.permissions.include? 'auth' ).to eql(false) }
+      end
     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')
+    # Connect specs
+    describe '#get_connect' do
+      context 'has access and returns accounts' do
+        it { expect(connect_user.permissions[0]).to eq('connect') }
+      end
 
-    context 'has access and returns user info' do
-      it { expect(info_user.permissions[0]).to eq('info') }
+      context 'does not have access to auth' do
+        it { expect(auth_user.permissions.include? 'connect' ).to eql(false) }
+      end
     end
 
-    context 'does not have access to info' do
-      it{ expect(auth_user.permissions.include? 'info' ).to be false }
+    # Get info specs
+    describe '#get_info' do
+      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 eql(false) }
+      end
     end
   end
 
   describe '#get_balance' do
-    user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-    user.update_balance
+    subject { user.tap(&:update_balance) }
+    let(:user) { Plaid.add_user('info','plaid_test','plaid_good','wells') }
+
     context 'updates user accounts' do
-      it { expect(user.accounts.empty?).to be_falsey }
+      it { expect(subject.accounts).not_to be_empty }
     end
 
+    # TODO: This test needs to be rewritten better, such as using #uniq instead of this
     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
-
+      let(:total_duplicates) { duplicate_accounts.length + duplicate_transactions.length }
+      let(:duplicate_accounts)     { subject.accounts.select {|element| user.accounts.count(element) > 1} }
+      let(:duplicate_transactions) { subject.transactions.select {|element| user.transactions.count(element) > 1} }
+      it{ expect(total_duplicates).to eql(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')
+    let(: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  }
+      # TODO: This test needs to pass, currently test credentials are failing
+      pending { 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
+    subject { info_user.tap(&:delete_user) }
+    let(:info_user) { Plaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
 
     context 'updates information correctly' do
-      it { expect { info_user.get_info }.to raise_error }
+      it { expect { subject.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')
+    subject { user.tap(&upgrade!) }
+    let(:upgrade!) { ->(x) { x.upgrade(upgrade_level) } }
+    let(:upgrade_level) { raise 'Define upgrade level' }
 
     context 'auth upgrade is successful' do
-      connect_user.upgrade('auth')
-      it { expect{ connect_user.get_auth }.to_not raise_error }
+      let(:user)          { connect_user }
+      let(:upgrade_level) { 'auth' }
+      it { expect{ subject.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 }
+      let(:user)          { auth_user }
+      let(:upgrade_level) { 'connect' }
+      it { expect{ subject.get_connect }.to_not raise_error }
     end
   end
 
-end
+  # This stuff needs to be tested and rewritten. Have alredy
+  # surfaced up a bug in it
+  pending "#populate_user"
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plaid
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.5.0
 platform: ruby
 authors:
 - Justin Crites
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby gem wrapper for the Plaid API. Read more at the homepage, the wiki,
   or the plaid documentation.
 email:
@@ -67,22 +95,24 @@ files:
 - README.md
 - Rakefile
 - lib/plaid.rb
-- lib/plaid/add_user.rb
-- lib/plaid/category/category.rb
 - 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/connection.rb
+- lib/plaid/models/account.rb
+- lib/plaid/models/category.rb
+- lib/plaid/models/exchange_token_response.rb
+- lib/plaid/models/info.rb
+- lib/plaid/models/institution.rb
+- lib/plaid/models/transaction.rb
+- lib/plaid/models/user.rb
 - lib/plaid/version.rb
 - plaid.gemspec
-- spec/add_user_spec.rb
+- spec/account_spec.rb
 - spec/category_spec.rb
 - spec/config_spec.rb
 - spec/institution_spec.rb
+- spec/plaid_spec.rb
 - spec/spec_helper.rb
+- spec/transaction_spec.rb
 - spec/user_spec.rb
 homepage: https://github.com/plaid/plaid-ruby
 licenses:
@@ -109,9 +139,11 @@ signing_key:
 specification_version: 4
 summary: Ruby bindings for Plaid
 test_files:
-- spec/add_user_spec.rb
+- spec/account_spec.rb
 - spec/category_spec.rb
 - spec/config_spec.rb
 - spec/institution_spec.rb
+- spec/plaid_spec.rb
 - spec/spec_helper.rb
+- spec/transaction_spec.rb
 - spec/user_spec.rb

data/lib/plaid/add_user.rb

@@ -1,24 +0,0 @@
-module Plaid
-  module AddUser
-      def add_user(api_level,username,password,type,pin=nil,options=nil)
-        begin
-          payload = {username:username,password:password,type:type}
-          payload.merge!(pin:pin) if pin
-          payload.merge!(options: options) if options
-          res = self.post(api_level,payload)
-          self.user(res,api_level)
-        rescue => e
-          error_handler(e)
-        end
-      end
-
-    def set_user(token,api_level=[],type=nil)
-      token = token + '_' + type unless type.nil?
-      begin
-        self.existing_user(token,api_level)
-      rescue => e
-        error_handler(e)
-      end
-    end
-  end
-end

data/lib/plaid/category/category.rb

@@ -1,29 +0,0 @@
-require 'plaid/util'
-module Plaid
-  class Category
-    include Plaid::Util
-
-    attr_accessor(:type, :hierarchy, :id, :cat_array)
-
-    def instantiate_all_categories(res)
-      self.cat_array = []
-      res.each do |cat|
-        category = Category.new
-        self.cat_array << category.build_category(cat)
-      end
-      self.cat_array
-    end
-
-    def instantiate_one_category(res)
-      self.build_category(res)
-      self
-    end
-
-    protected
-
-    def build_category(cat)
-      self.type = cat['type'], self.hierarchy = cat['hierarchy'], self.id = cat['id']
-    end
-
-  end
-end

data/lib/plaid/institution/institution.rb

@@ -1,29 +0,0 @@
-require 'plaid/util'
-module Plaid
-  class Institution
-    include Plaid::Util
-
-    attr_accessor(:id, :name, :type, :has_mfa, :mfa, :inst_array)
-
-    def instantiate_all_institutions(res)
-      self.inst_array = []
-      res.each do |inst|
-        institution = Institution.new
-        inst_array << institution.build_institution(inst)
-      end
-      self.inst_array
-    end
-
-    def instantiate_one_institution(res)
-      self.build_institution(res)
-      self
-    end
-
-    protected
-
-    def build_institution(inst)
-      self.id = inst['id'], self.name = inst['name'], self.type = inst['type'], self.has_mfa =inst['has_mfa'], self.mfa = inst['mfa']
-    end
-
-  end
-end

data/lib/plaid/user/account/account.rb

@@ -1,35 +0,0 @@
-require 'plaid/util'
-module Plaid
-  class Account
-    include Plaid::Util
-    # Define vars for user accounts
-    attr_accessor(:available_balance, :current_balance, :institution_type, :meta, :transactions, :numbers, :name, :id, :type)
-
-    # Instantiate a new account with the results of the successful API call
-    # Build an array of nested transactions, and return self if successful
-    def new(res)
-      begin
-        self.name = res['name'], self.available_balance = res['balance']['available'], self.current_balance = res['balance']['current'], self.institution_type = res['institution_type'], self.id = res['_id'], self.type = res['type']
-        self.meta = res['meta'] if res['meta']
-        res['numbers'] ? self.numbers = res['numbers'] : self.numbers = 'Upgrade user to access routing information for this account'
-      rescue => e
-        error_handler(e)
-      else
-        self
-      end
-    end
-
-    def update_account(res)
-      begin
-        self.name = res['name'], self.available_balance = res['balance']['available'], self.current_balance = res['balance']['current'], self.institution_type = res['institution_type'], self.id = res['_id'], self.type = res['type']
-        self.meta = res['meta'] if res['meta']
-        res['numbers'] ? self.numbers = res['numbers'] : self.numbers = 'Upgrade user to access routing information for this account'
-      rescue => e
-        error_handler(e)
-      else
-        self
-      end
-    end
-
-  end
-end

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

@@ -1,23 +0,0 @@
-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/transaction/transaction.rb

@@ -1,19 +0,0 @@
-require 'plaid/util'
-module Plaid
-  class Transaction
-    include Plaid::Util
-    # Define vars for user accounts
-    attr_accessor(:id, :account, :amount, :name, :meta, :location, :pending, :score, :type, :category, :category_id)
-
-    # Instantiate a new account with the results of the successful API call
-    # Build an array of nested transactions, and return self if successful
-    def new(res)
-      begin
-        self.id = res['_id'], self.account = res['_account'], self.amount = res['amount'], self.name = res['name'], self.meta = res['meta'], self.location = res['location'], self.pending = res['pending'], self.score = res['score'], self.type = res['type'], self.category = res['category'], self.category_id = res['category_id']
-      rescue => e
-        error_handler(e)
-      end
-    end
-
-  end
-end