plaid 1.7.1 → 2.0.0.alpha

data/spec/plaid/error_spec.rb

@@ -1,10 +0,0 @@
-describe Plaid::PlaidError do
-  describe "#new" do
-    it "allows code, message and resolution" do
-      error = Plaid::PlaidError.new 1, "testing", "fix it"
-      expect(error.code).to eq(1)
-      expect(error.message).to eq("testing")
-      expect(error.resolve).to eq("fix it")
-    end
-  end
-end

data/spec/plaid/models/account_spec.rb

@@ -1,37 +0,0 @@
-describe Plaid::Account do
-  # API: semi-private
-  describe '.new' do
-    subject { Plaid::Account.new(results) }
-
-    def self.with_results(_results, &examples)
-      context "with results #{_results}" do
-        let(:results) { _results }
-        instance_eval(&examples)
-      end
-    end
-
-    with_results('meta' => {'name' => 'Name'}) do it { expect(subject.name).to eql('Name') } end
-    with_results('_id' =>  'ID')   do it { expect(subject.id).to   eql('ID') }   end
-    with_results('type' => 'Type') do it { expect(subject.type).to eql('Type') } end
-    with_results('type' => 'STyp') do it { expect(subject.type).to eql('STyp') } end
-    with_results('meta' => nil)    do it { expect(subject.meta).to be_nil }      end
-    with_results('meta' => {})     do it { expect(subject.meta).to eql({}) }     end
-
-    with_results('balance' => { 'available' => 100.00 } ) do it { expect(subject.available_balance).to eql(100.00) } end
-    with_results('balance' => { 'current'   => 200.00 } ) do it { expect(subject.current_balance).to   eql(200.00) } end
-
-    with_results('institution_type' => 'Type') do it { expect(subject.institution_type).to eql('Type') } end
-
-    with_results('numbers' => nil) do
-      it { expect(subject.numbers).to eql('Upgrade user to access routing information for this account') }
-    end
-
-    with_results('numbers' => {}) do
-      it { expect(subject.numbers).to eql({}) }
-    end
-
-    with_results({}) do
-      it { expect(subject.name).to eq nil } # doesn't blow up if 'meta' is missing
-    end
-  end
-end

data/spec/plaid/models/category_spec.rb

@@ -1,16 +0,0 @@
-describe Plaid::Category do
-  context 'when a single category is found' do
-    let(:category) { Plaid.category('17001013') }
-    it { expect(category).to be_kind_of(Plaid::Category) }
-  end
-
-  context 'when all categories are found' do
-    let(: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(Plaid::NotFound, 'unable to find category') }
-  end
-
-end

data/spec/plaid/models/institution_spec.rb

@@ -1,19 +0,0 @@
-describe Plaid::Institution do
-  context 'when a single institution is found' do
-    let(:institution) { Plaid.institution('5301a93ac140de84910000e0') }
-
-    it { expect(institution).to be_kind_of(Plaid::Institution) }
-    it { expect(institution.mfa).to be_kind_of(Array) }
-    it { expect(institution.products).to be_kind_of(Array) }
-    it { expect(institution.credentials).to be_kind_of(Hash) }
-  end
-
-  context 'when all institutions are found' do
-    let(: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(Plaid::NotFound, 'unable to find institution') }
-  end
-end

data/spec/plaid/models/transaction_spec.rb

@@ -1,28 +0,0 @@
-describe Plaid::Transaction do
-  # API: semi-private
-  describe '.new' do
-    # The reason this looks weird is because it is. This will be refactored for 2.0
-    subject { Plaid::Transaction.new(results) }
-
-    def self.with_results(_results, &examples)
-      context "with results #{_results}" do
-        let(:results) { _results }
-        instance_eval(&examples)
-      end
-    end
-
-    with_results('_id'      =>  'ID')       do it { expect(subject.id).to       eql('ID') }       end
-    with_results('_account' =>  'acct')     do it { expect(subject.account).to  eql('acct') }     end
-    with_results('date'     => '00/00/00')  do it { expect(subject.date).to     eql('00/00/00') } end
-    with_results('amount'   => 100.00)      do it { expect(subject.amount).to   eql(100.00) }     end
-    with_results('name'     =>  'Name')     do it { expect(subject.name).to     eql('Name') }     end
-    with_results('meta'     => {} )         do it { expect(subject.meta).to     eql({}) }         end
-    with_results('meta'     => {'location' => 'Location'}) do it { expect(subject.location).to eql('Location') } end
-    with_results('pending'  =>  true)       do it { expect(subject.pending).to  eql(true) }       end
-    with_results('score'    =>  200)        do it { expect(subject.score).to    eql(200) }        end
-    with_results('type'     =>  'Type')     do it { expect(subject.type).to     eql('Type') }     end
-
-    with_results('category'    => 'Category') do it { expect(subject.category).to    eql('Category') } end
-    with_results('category_id' => 100)        do it { expect(subject.category_id).to eql(100) } end
-  end
-end

data/spec/plaid/models/user_spec.rb

@@ -1,172 +0,0 @@
-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') }
-
-  context 'user vars' do
-    context 'valid user has accounts and accounts contain id attribute' do
-      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
-      let(: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
-    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
-      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
-      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
-      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
-      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(Plaid::RequestFailed, 'invalid mfa') }
-    end
-
-    context 'requests list of MFA credentials' do
-      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
-      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
-      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) }
-
-      it { expect(new_mfa_user.accounts).not_to be_empty }
-    end
-  end
-
-  context 'when authenticating' do
-    # Auth specs
-    describe '#get_auth' do
-
-      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 eql(false) }
-      end
-    end
-
-    # Connect specs
-    describe '#get_connect' do
-      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 eql(false) }
-      end
-    end
-
-    # 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
-    subject { user.tap(&:update_balance) }
-    let(:user) { Plaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
-
-    context 'updates user accounts' do
-      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 'does not double up accounts or transactions' do
-      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
-
-  describe '#update_info' do
-    let(:info_user) { Plaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
-    context 'updates information correctly' do
-      # 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
-
-  describe '#delete_user' do
-    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 { subject.get_info }.to raise_error(Plaid::Unauthorized, 'client_id missing') }
-    end
-  end
-
-  describe '#upgrade' do
-    subject { user.tap(&upgrade!) }
-    let(:upgrade!) { ->(x) { x.upgrade(upgrade_level) } }
-    let(:upgrade_level) { raise 'Define upgrade level' }
-
-    context 'auth upgrade is successful' do
-      let(:user)          { connect_user }
-      let(:upgrade_level) { 'auth' }
-      it { expect{ subject.get_auth }.to_not raise_error }
-    end
-
-    context 'connect upgrade is successful' do
-      let(:user)          { auth_user }
-      let(:upgrade_level) { 'connect' }
-      it { expect{ subject.get_connect }.to_not raise_error }
-    end
-  end
-
-  # This stuff needs to be tested and rewritten. Have already
-  # surfaced up a bug in it
-  pending '#populate_user'
-
-end

data/spec/plaid_spec.rb

@@ -1,263 +0,0 @@
-# Authentication flow specs - returns Plaid::User
-
-describe Plaid do
-  let(:api_level) { raise "Define let(:api_level)" }
-  let(:username)  { raise "Define let(:username)" }
-  let(:password)  { raise "Define let(:password)" }
-  let(:type)      { raise "Define let(:type)" }
-  let(:pin)       { nil }
-  let(:options)   { nil }
-
-  describe '.add_user' do
-    let(:user) { Plaid.add_user api_level, username, password, type, pin, options }
-
-    context 'with correct credentials for single user auth' do
-      let(:username)  { 'plaid_test' }
-      let(:password)  { 'plaid_good' }
-      let(:type)      { 'wells' }
-
-      context 'and "connect" level of api access' do
-        let(:api_level) { 'connect' }
-
-        it { expect(user.accounts).not_to be_empty }
-
-        context 'with webhook' do
-          let(:options) { { login_only: true, webhook: 'test.com/test.endpoint.aspx' } }
-          it { expect(user.accounts).not_to be_empty }
-        end
-
-        context 'when account is locked' do
-          let(:password) { 'plaid_locked' }
-
-          it 'raises a locked error' do
-            expect { user }.to raise_error(Plaid::RequestFailed) { |error|
-              expect(error.code).to eq(1205)
-            }
-          end
-        end
-
-        context 'with connection options' do
-          context 'when requests pending transactions from an institution' do
-            let(:options) { { pending: true } }
-            it { expect(user.accounts).not_to be_empty }
-          end
-
-          context 'when login only is true' do
-            let(:options) { { login_only: true } }
-            it { expect(user.accounts).not_to be_empty }
-          end
-
-          context 'sets a start date for transactions' do
-            let(:options) { { login_only: true, start_date: '10 days ago'} }
-            it { expect(user.accounts).not_to be_empty }
-          end
-
-          context 'sets an end date for transactions' do
-            let(:options) { { login_only: true, end_date: '10 days ago'} }
-            it { expect(user.accounts).not_to be_empty }
-          end
-
-          context 'sets start and end dates for transactions' do
-            let(:options) { { gte: "05/10/2014" , lte: "06/10/2014" } }
-            it { expect(user.transactions).not_to be_nil }
-          end
-
-          pending 'with JSON-encoded string for options'
-        end
-      end
-
-      context 'and "auth" level of api access' do
-        let(:api_level) { 'auth' }
-        it { expect(user.accounts.first.numbers).not_to be_empty }
-      end
-
-      context 'and "info" level of api access' do
-        let(:api_level) { 'info' }
-        it { expect(user.info).not_to be_empty }
-      end
-    end
-
-    context 'with incorrect credentials for single factor auth' do
-      # Set up correct credentials. Override with bad element
-      # within each context block
-      let(:username)  { 'plaid_test' }
-      let(:password)  { 'plaid_good' }
-      let(:type)      { 'wells' }
-
-      context 'at "auth" level api access' do
-        let(:api_level) { 'auth' }
-
-        context 'using incorrect password' do
-          let(:password) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-
-        context 'using incorrect username' do
-          let(:username) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-      end
-
-      context 'at "connect" level api access' do
-        let(:api_level) { 'connect' }
-
-        context 'using incorrect password' do
-          let(:password) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-
-        context 'using incorrect username' do
-          let(:username) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-      end
-
-      context 'at "info" level api access' do
-        let(:api_level) { 'info' }
-
-        context 'using incorrect password' do
-          let(:password) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-
-        context 'using incorrect username' do
-          let(:username) { 'plaid_bad' }
-          it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid credentials') }
-        end
-      end
-    end
-
-    context 'when institution requires PIN' do
-      let(:api_level) { 'connect' }
-      let(:username)  { 'plaid_test' }
-      let(:password)  { 'plaid_good' }
-      let(:type)      { 'usaa' }
-
-      context 'using correct PIN' do
-        let(:pin) { '1234' }
-        it { expect(user.api_res).to eq 'Requires further authentication' }
-      end
-
-      context 'using incorrect PIN' do
-        let(:pin) { '0000' }
-        it { expect { user }.to raise_error(Plaid::RequestFailed, 'invalid pin') }
-      end
-    end
-
-    context 'when institution requires MFA' do
-      let(:api_level) { 'connect' }
-      let(:username)  { 'plaid_test' }
-      let(:password)  { 'plaid_good' }
-      let(:type)      { 'bofa' }
-
-      context 'with only standard credentials' do
-        it { expect(user.api_res).to eq 'Requires further authentication' }
-      end
-
-      context 'with options' do
-        context 'with webhook' do
-          let(:options) { { login_only: true, webhook: 'test.com/test.endpoint.aspx' } }
-          it { expect(user.api_res).to eq 'Requires further authentication' }
-        end
-
-        context 'requests a list of options for code based MFA' do
-          let(:type) { 'citi' }
-          let(:options) { { list: true } }
-
-          it { expect(user.pending_mfa_questions).not_to be_nil }
-        end
-      end
-    end
-  end
-
-  describe '.set_user' do
-    subject { Plaid.set_user(access_token) }
-    let(:access_token) { 'test' }
-
-    it { expect(subject.access_token).to eq(access_token)}
-
-    context 'gets a valid user with accounts and transactions' do
-      let(:user) { Plaid.set_user('test_wells',['connect']) }
-      it { expect(user.transactions).not_to be_empty }
-    end
-
-    context 'gets a valid user with accounts' do
-      let(:user) { Plaid.set_user('test_wells',['auth']) }
-      it { expect(user.accounts).not_to be_empty }
-    end
-
-    #TODO: Fully vet the info api endpoint for the beta functions before adding this as a supported function.
-    pending 'need to vet the info api endpoint' do
-      context 'gets a valid user with info' do
-        let(: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
-        let(:user) { Plaid.set_user('test_wells', ['connect', 'info', 'auth']) }
-        it { expect(user.transactions).to be_truthy}
-      end
-    end
-  end
-
-  describe '.exchange_token' do
-    subject { Plaid.exchange_token('test,chase,connected', 'QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK') }
-
-    it { expect(subject.access_token).to eql('test_chase') }
-  end
-
-  describe '.transactions' do
-    subject { Plaid.transactions(access_token, options) }
-    let(:access_token) { 'test_wells' }
-    let(:options)      { nil }
-
-    context 'without options' do
-      it 'returns all accounts' do
-        expect(subject.accounts).not_to be_empty
-      end
-
-      it 'returns all transactions' do
-        expect(subject.transactions).not_to be_empty
-      end
-    end
-
-    context 'when filtering by account' do
-      let(:options) { { account: account } }
-      let(:account) { 'QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK' }
-
-      it 'returns a subset of transactions' do
-        expect(subject.transactions.size).to eql(2)
-      end
-
-      it 'return only transactions from the requested account' do
-        expect(subject.transactions.map(&:account).uniq).to eql([account])
-      end
-    end
-
-    context 'when filtering by date' do
-      let(:options) { { gte: "2014-07-24", lte: "2014-07-25" } }
-
-      it 'returns a subset of transactions' do
-        expect(subject.transactions.size).to eql(1)
-      end
-
-      it 'return only transactions from the requested date range' do
-        expect(subject.transactions.map(&:date).uniq).to eql(['2014-07-24'])
-      end
-    end
-
-    context 'when filtering by account and date' do
-      let(:options) { { account: account , gte: "2014-07-24", lte: "2014-07-25" } }
-      let(:account) { 'XARE85EJqKsjxLp6XR8ocg8VakrkXpTXmRdOo' }
-
-      it 'returns a subset of transactions' do
-        expect(subject.transactions.size).to eql(1)
-      end
-
-      it 'returns only transactions from the requested account and date range' do
-        expect(subject.transactions.map(&:date).uniq).to eql(['2014-07-24'])
-        expect(subject.transactions.map(&:account).uniq).to eql([account])
-      end
-    end
-  end
-end