plaid 13.2.0 → 42.0.0

data/test/test_auth.rb

@@ -0,0 +1,61 @@
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::Auth.
+class PlaidAuthTest < PlaidTest
+  def setup
+    create_item initial_products: [:auth]
+  end
+
+  def test_get
+    auth_get_request = Plaid::AuthGetRequest.new
+    auth_get_request.access_token = access_token
+
+    response = client.auth_get(auth_get_request)
+    assert_kind_of(Plaid::AuthGetResponse, response)
+
+    refute_empty(response.accounts)
+    refute_nil(response.numbers)
+    assert_kind_of(Plaid::AuthGetNumbers, response.numbers)
+
+    account_id = response.accounts[0].account_id
+    auth_get_request = Plaid::AuthGetRequest.new
+
+    options_payload = {}
+    options_payload[:account_ids] = [account_id]
+
+    auth_get_request.access_token = access_token
+    auth_get_request.options = options_payload
+
+    response = client.auth_get(auth_get_request)
+    assert_equal 1, response.numbers.ach.size
+  end
+
+  def test_get_invalid_access_token
+    auth_get_request = Plaid::AuthGetRequest.new
+    auth_get_request.access_token = BAD_STRING
+
+    begin
+      client.auth_get(auth_get_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_ACCESS_TOKEN")
+    end
+  end
+
+  def test_get_invalid_options
+    auth_get_request = Plaid::AuthGetRequest.new
+
+    options_payload = {}
+    options_payload[:account_ids] = [BAD_STRING]
+
+    auth_get_request.access_token = access_token
+    auth_get_request.options = options_payload
+
+    begin
+      client.auth_get(auth_get_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+end

data/test/test_bank_transfers.rb

@@ -0,0 +1,219 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::BankTransfers.
+class PlaidBankTransfersTest < PlaidTest
+  attr_reader :account
+
+  def setup
+    create_item initial_products: [:auth]
+
+    accounts_get_request = Plaid::AccountsGetRequest.new({
+      :access_token => access_token,
+    })
+
+    account_resp = client.accounts_get(accounts_get_request)
+    @account = account_resp.accounts[0]
+  end
+
+  # Helper method to create a bank transfer
+  def create_bank_transfer
+    bank_transfer_create_request = Plaid::BankTransferCreateRequest.new(
+      {
+        :idempotency_key => Random.rand(0..1_000_000_000).to_s,
+        :access_token => access_token,
+        :account_id => account.account_id,
+        :type => Plaid::BankTransferType::CREDIT,
+        :network => Plaid::BankTransferNetwork::ACH,
+        :amount => "1.00",
+        :iso_currency_code => "USD",
+        :description => "plaid",
+        :ach_class => "ppd",
+        :user => {
+          legal_name: "Firstname Lastname",
+        },
+      }
+    )
+
+    create_response = client.bank_transfer_create(bank_transfer_create_request)
+    refute_nil(create_response)
+    assert_kind_of(Plaid::BankTransfer, create_response.bank_transfer)
+    refute_nil(create_response.bank_transfer.id)
+    assert_equal(account.account_id, create_response.bank_transfer.account_id)
+    create_response.bank_transfer
+  end
+
+  # Used in case data is slow to propagate to read replica DB
+  def request_and_retry(func, bt)
+    num_retries = 3
+    retries = 0
+    while retries < num_retries
+      retries += 1
+      begin
+        res = func.call(bt)
+      rescue Exception => e
+        if retries < num_retries
+          puts "retrying failed test after sleeping for 1 second"
+          sleep(1)
+          next
+        else
+          puts "failed after retries"
+          raise e
+        end
+      end
+      return
+    end
+  end
+
+  def create_and_post_bank_transfer
+    bank_transfer = create_bank_transfer
+    checks = lambda do |bank_transfer|
+      sandbox_bank_transfer_simulate_request = Plaid::SandboxBankTransferSimulateRequest.new(
+        {
+          :bank_transfer_id => bank_transfer.id,
+          :event_type => Plaid::BankTransferEventType::POSTED,
+        }
+      )
+
+      simulate_response = client.sandbox_bank_transfer_simulate(sandbox_bank_transfer_simulate_request)
+      refute_nil(simulate_response)
+      assert_kind_of(Plaid::SandboxBankTransferSimulateResponse, simulate_response)
+    end
+    request_and_retry(checks, bank_transfer)
+    bank_transfer
+  end
+
+  def test_create_success
+    create_bank_transfer
+  end
+
+  def test_create_invalid_field
+    begin
+      client.bank_transfer_create({})
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "MISSING_FIELDS")
+    end
+  end
+
+  def test_sandbox_bank_transfer_simulate_success
+    create_and_post_bank_transfer
+  end
+
+  def test_cancel_success
+    bank_transfer = create_bank_transfer
+    checks = lambda do |bank_transfer|
+      bank_transfer_cancel_request = Plaid::BankTransferCancelRequest.new({
+        :bank_transfer_id => bank_transfer.id,
+      })
+
+      cancel_response = client.bank_transfer_cancel(bank_transfer_cancel_request)
+      refute_nil(cancel_response)
+      assert_kind_of(Plaid::BankTransferCancelResponse, cancel_response)
+    end
+    request_and_retry(checks, bank_transfer)
+  end
+
+  def test_cancel_not_cancelable
+    bank_transfer = create_and_post_bank_transfer
+
+    bank_transfer_cancel_request = Plaid::BankTransferCancelRequest.new({
+      :bank_transfer_id => bank_transfer.id,
+    })
+
+    begin
+      client.bank_transfer_cancel(bank_transfer_cancel_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "BANK_TRANSFER_NOT_CANCELLABLE")
+    end
+  end
+
+  def test_migrate_account_success
+    migrate_account_request = Plaid::BankTransferMigrateAccountRequest.new({
+      :account_number => "100000000",
+      :routing_number => "121122676",
+      :account_type => "checking",
+    })
+
+    migrate_account_response = client.bank_transfer_migrate_account(migrate_account_request)
+    refute_nil(migrate_account_response)
+    assert_kind_of(Plaid::BankTransferMigrateAccountResponse, migrate_account_response)
+    refute_nil(migrate_account_response.access_token)
+    refute_nil(migrate_account_response.account_id)
+  end
+
+  def test_origination_balance_get_success
+    bank_transfer_balance_get_request = Plaid::BankTransferBalanceGetRequest.new()
+
+    balance_get_response = client.bank_transfer_balance_get(bank_transfer_balance_get_request)
+    refute_nil(balance_get_response)
+    refute_nil(balance_get_response.balance)
+  end
+
+  def test_get_success
+    bank_transfer = create_bank_transfer
+    checks = lambda do |bank_transfer|
+      bank_transfer_get_request = Plaid::BankTransferGetRequest.new({
+        :bank_transfer_id => bank_transfer.id,
+      })
+
+      get_response = client.bank_transfer_get(bank_transfer_get_request)
+      refute_nil(get_response)
+      assert_kind_of(Plaid::BankTransferGetResponse, get_response)
+      assert_equal(get_response.bank_transfer, bank_transfer)
+    end
+    request_and_retry(checks, bank_transfer)
+  end
+
+  def test_list_success
+    bank_transfer = create_bank_transfer
+    checks = lambda do |bank_transfer|
+      bank_transfer_list_request = Plaid::BankTransferListRequest.new({
+        :count => 1,
+      })
+
+      list_response = client.bank_transfer_list(bank_transfer_list_request)
+      refute_nil(list_response)
+      assert_kind_of(Plaid::BankTransferListResponse, list_response)
+      refute_nil(list_response.bank_transfers)
+      assert_equal(1, list_response.bank_transfers.length)
+      assert_equal(bank_transfer, list_response.bank_transfers[0])
+    end
+    request_and_retry(checks, bank_transfer)
+  end
+
+  def test_event_sync_success
+    bank_transfer = create_and_post_bank_transfer
+    checks = lambda do |bank_transfer|
+      bank_transfer_event_sync_request = Plaid::BankTransferEventSyncRequest.new({
+        :after_id => 0,
+      })
+
+      event_sync_response = client.bank_transfer_event_sync(bank_transfer_event_sync_request)
+      refute_nil(event_sync_response)
+      assert_kind_of(Plaid::BankTransferEventSyncResponse, event_sync_response)
+      refute_nil(event_sync_response.bank_transfer_events)
+      assert(event_sync_response.bank_transfer_events.length >= 2)
+    end
+    request_and_retry(checks, bank_transfer)
+  end
+
+  def test_event_list_success
+    bank_transfer = create_and_post_bank_transfer
+    checks = lambda do |bank_transfer|
+      bank_transfer_list_request = Plaid::BankTransferEventListRequest.new({
+        bank_transfer_id: bank_transfer.id,
+      })
+
+      event_list_response = client.bank_transfer_event_list(bank_transfer_list_request)
+      refute_nil(event_list_response)
+      assert_kind_of(Plaid::BankTransferEventListResponse, event_list_response)
+      refute_nil(event_list_response.bank_transfer_events)
+      assert_equal(1, event_list_response.bank_transfer_events.length)
+      event_list_response.bank_transfer_events.each do |event|
+        assert_equal(bank_transfer.id, event.bank_transfer_id)
+      end
+    end
+    request_and_retry(checks, bank_transfer)
+  end
+end

data/test/test_categories.rb

@@ -0,0 +1,10 @@
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::CategoriesGet.
+class PlaidCategoriesTest < PlaidTest
+  def test_get
+    response = client.categories_get({})
+    assert_instance_of(Plaid::CategoriesGetResponse, response)
+    refute_empty(response.to_hash)
+  end
+end

data/test/test_configuration.rb

@@ -0,0 +1,27 @@
+
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Configuration.
+class PlaidConfigurationTest < PlaidTest
+  def test_api_host
+    configuration = Plaid::Configuration.new
+
+    configuration.server_index = 0
+    assert_equal "https://production.plaid.com",
+                 configuration.base_url
+
+    configuration.server_index = 1
+    assert_equal "https://sandbox.plaid.com",
+                 configuration.base_url
+
+    assert_raises(ArgumentError) do
+      configuration.server_index = 2
+      configuration.base_url
+    end
+
+    assert_raises(ArgumentError) do
+      configuration.server_index = 3
+      configuration.base_url
+    end
+  end
+end

data/test/test_enrich.rb

@@ -0,0 +1,60 @@
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::Enrich.
+class PlaidEnrichTest < PlaidTest
+  def test_get
+    sample_transactions_to_enrich = [
+      Plaid::ClientProvidedTransaction.new({
+        id: "1",
+        description: "TST *JETTIES BAGELS",
+        amount: 10.00,
+        direction: Plaid::EnrichTransactionDirection::OUTFLOW,
+        location: Plaid::ClientProvidedTransactionLocation.new({
+          city: "Ipswich",
+          region: "MA",
+        }),
+        iso_currency_code: "USD",
+      }),
+      Plaid::ClientProvidedTransaction.new({
+        id: "2",
+        description: "AMAZON.COM*MJ3LO9AN2",
+        amount: 10.00,
+        direction: Plaid::EnrichTransactionDirection::OUTFLOW,
+        iso_currency_code: "USD",
+      }),
+      Plaid::ClientProvidedTransaction.new({
+        id: "3",
+        description: "GOOGLE *FRESHBOOKS",
+        amount: 10.00,
+        direction: Plaid::EnrichTransactionDirection::OUTFLOW,
+        iso_currency_code: "USD",
+      }),
+      Plaid::ClientProvidedTransaction.new({
+        id: "4",
+        description: "EARNIN TRANSFER",
+        amount: 100.00,
+        direction: Plaid::EnrichTransactionDirection::INFLOW,
+        iso_currency_code: "USD",
+      })
+    ]
+
+    transactions_enrich_get_request = Plaid::TransactionsEnrichRequest.new
+
+    transactions_enrich_get_request.account_type = "depository"
+    transactions_enrich_get_request.transactions = sample_transactions_to_enrich
+
+    response = client.transactions_enrich(transactions_enrich_get_request)
+    assert_kind_of(Plaid::TransactionsEnrichResponse, response)
+
+    refute_empty(response.enriched_transactions)
+    assert_equal(sample_transactions_to_enrich.length, response.enriched_transactions.length)
+
+    response.enriched_transactions.each do |item|
+      assert_kind_of(Float, item.amount)
+      refute_nil(item.description)
+      refute_nil(item.direction)
+      refute_nil(item.enrichments)
+      refute_nil(item.id)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,118 @@
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+
+require "plaid"
+require "minitest/autorun"
+require "minitest/around/unit"
+require "json"
+
+# Internal: Default read timeout for HTTP calls in seconds.
+NETWORK_TIMEOUT = 600
+
+class PlaidTest < Minitest::Test
+  attr_reader :client, :item, :access_token
+
+  def create_client
+    configuration = Plaid::Configuration.new
+    configuration.server_index = Plaid::Configuration::Environment["sandbox"]
+    configuration.timeout = NETWORK_TIMEOUT
+    configuration.api_key["PLAID-CLIENT-ID"] = ENV["PLAID_RUBY_CLIENT_ID"]
+    configuration.api_key["PLAID-SECRET"] = ENV["PLAID_RUBY_SECRET"]
+    configuration.api_key["Plaid-Version"] = "2020-09-14"
+
+    api_client = Plaid::ApiClient.new(
+      configuration
+    )
+
+    @client = Plaid::PlaidApi.new(api_client)
+    @client_id = ENV["PLAID_RUBY_CLIENT_ID"]
+  end
+
+  # Helper used to create a test item with given products
+  def create_item(institution_id: SANDBOX_INSTITUTION,
+                  initial_products: [:transactions],
+                  transactions_start_date: nil,
+                  transactions_end_date: nil,
+                  webhook: nil,
+                  options: nil)
+    sandbox_public_token_create_request = Plaid::SandboxPublicTokenCreateRequest.new
+
+    options_payload = {}
+    options_payload[:webhook] = webhook unless webhook.nil?
+    options_payload[:transactions] = {
+      start_date: transactions_start_date.is_a?(String) ? transactions_start_date : transactions_start_date.to_date.strftime("%Y-%m-%d"),
+      end_date: transactions_end_date.is_a?(String) ? transactions_end_date : transactions_end_date.to_date.strftime("%Y-%m-%d"),
+    } unless transactions_start_date.nil? || transactions_end_date.nil?
+    options_payload = options_payload.merge(options) unless options.nil?
+
+    sandbox_public_token_create_request.options = options_payload
+    sandbox_public_token_create_request.institution_id = institution_id
+    sandbox_public_token_create_request.initial_products = initial_products
+
+    begin
+      public_token_response = @client.sandbox_public_token_create(sandbox_public_token_create_request)
+    end
+
+    # public_token must be present
+    refute_empty(public_token_response.to_hash)
+
+    public_token = public_token_response.public_token
+
+    # exchange public_token for access_token
+    item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new
+    item_public_token_exchange_request.public_token = public_token
+
+    exchange_token_response = client.item_public_token_exchange(item_public_token_exchange_request)
+
+    @access_token = exchange_token_response.access_token
+    refute_empty(@access_token)
+
+    item_get_request = Plaid::ItemGetRequest.new
+    item_get_request.access_token = @access_token
+
+    @item = client.item_get(item_get_request)
+    refute_empty(@item.to_hash)
+  end
+
+  # If create_item was used, remove the item
+  def teardown
+    if access_token
+      item_remove_request = Plaid::ItemRemoveRequest.new
+      item_remove_request.access_token = access_token
+
+      begin
+        @client.item_remove(item_remove_request)
+      end
+    end
+  end
+
+  # This method is called around every test method.
+  def around
+    create_client
+    yield
+  end
+
+  BAD_STRING = "ABCDEFG1234567".freeze
+
+  BAD_ARRAY = ["ABCDEFG1234567"].freeze
+
+  SANDBOX_INSTITUTION = "ins_109508".freeze
+
+  SANDBOX_INSTITUTION_NAME = "First Platypus Bank".freeze
+
+  SANDBOX_INSTITUTIONS = %w[ins_109508 ins_109509 ins_109510
+                            ins_109511 ins_109512].freeze
+
+  # NOTE: Data is only generated over the past 2 years.  Ensure that the date
+  # range used for transactions/get is within 2 years old or otherwise the tests will not work properly
+
+  START_DATE = "2020-01-01".freeze
+  END_DATE = "2021-01-01".freeze
+end

data/test/test_identity.rb

@@ -0,0 +1,38 @@
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::Identity.
+class PlaidIdentityTest < PlaidTest
+  def test_get
+    create_item initial_products: [:identity]
+
+    identity_get_request = Plaid::IdentityGetRequest.new
+    identity_get_request.access_token = access_token
+
+    response = client.identity_get(identity_get_request)
+    assert_kind_of(Plaid::IdentityGetResponse, response)
+
+    refute_empty(response.accounts)
+
+    response.accounts.each do |account|
+      refute_empty(account.owners)
+      account.owners.each do |identity|
+        refute_empty(identity.addresses)
+        refute_empty(identity.emails)
+        refute_empty(identity.names)
+        refute_empty(identity.phone_numbers)
+      end
+    end
+  end
+
+  def test_get_invalid_access_token
+    identity_get_request = Plaid::IdentityGetRequest.new
+    identity_get_request.access_token = BAD_STRING
+
+    begin
+      client.identity_get(identity_get_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_ACCESS_TOKEN")
+    end
+  end
+end

data/test/test_identity_verification.rb

@@ -0,0 +1,56 @@
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::IdentityVerification.
+
+TEMPLATE_ID = "flwtmp_aWogUuKsL6NEHU"
+CLIENT_USER_ID = "idv-user-" + Time.now.to_i.to_s
+EMAIL = CLIENT_USER_ID + "@example.com"
+class PlaidIdentityVerificationTest < PlaidTest
+  def test_all_routes
+    user = Plaid::IdentityVerificationCreateRequestUser.new({
+        :email_address => EMAIL,
+    })
+    identity_verification_create_request = Plaid::IdentityVerificationCreateRequest.new({
+        :client_user_id => CLIENT_USER_ID,
+        :is_shareable => true,
+        :template_id => TEMPLATE_ID,
+        :gave_consent => true,
+        :user => user,
+    })
+    response = client.identity_verification_create(identity_verification_create_request)
+    assert_kind_of(Plaid::IdentityVerificationCreateResponse, response)
+    refute_nil(response.shareable_url)
+    assert_equal("active", response.status)
+
+    retry_user = Plaid::IdentityVerificationRequestUser.new({
+         :email_address => EMAIL,
+     })
+    identity_verification_retry_request = Plaid::IdentityVerificationRetryRequest.new({
+        :template_id => TEMPLATE_ID,
+        :client_user_id => CLIENT_USER_ID,
+        :strategy => Plaid::Strategy::RESET,
+        :user => retry_user,
+    })
+    response = client.identity_verification_retry(identity_verification_retry_request)
+    assert_kind_of(Plaid::IdentityVerificationRetryResponse, response)
+    refute_nil(response.shareable_url)
+    assert_equal("active", response.status)
+    
+    identity_verification_list_request = Plaid::IdentityVerificationListRequest.new({
+        :template_id => TEMPLATE_ID,
+        :client_user_id => CLIENT_USER_ID,
+    })
+    response = client.identity_verification_list(identity_verification_list_request)
+    assert_kind_of(Plaid::IdentityVerificationListResponse, response)
+    refute_nil(response.identity_verifications[0])
+    assert_equal(CLIENT_USER_ID, response.identity_verifications[0].client_user_id)
+
+    identity_verification_id = response.identity_verifications[0].id
+    identity_verification_get_request = Plaid::IdentityVerificationGetRequest.new({
+        :identity_verification_id => identity_verification_id,
+    })
+    response = client.identity_verification_get(identity_verification_get_request)
+    assert_kind_of(Plaid::IdentityVerificationGetResponse, response)
+    assert_equal(identity_verification_id, response.id)
+  end
+end