plaid 13.0.0 → 14.0.0.beta.1

data/templates/ruby/gemspec.mustache

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+=begin
+{{> api_info}}
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+require "{{gemName}}/version"
+
+Gem::Specification.new do |s|
+  s.name        = "{{gemName}}{{^gemName}}{{{appName}}}{{/gemName}}"
+  s.version     = {{moduleName}}::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Plaid"]
+  s.email       = ["{{gemAuthorEmail}}{{^gemAuthorEmail}}{{infoEmail}}{{/gemAuthorEmail}}"]
+  s.homepage    = "https://plaid.com"
+  s.summary     = "{{gemSummary}}{{^gemSummary}}{{{appName}}} Ruby Gem{{/gemSummary}}"
+  s.description = "Ruby gem wrapper for the Plaid API. Read more at the homepage, the wiki, or in the Plaid documentation."
+  s.license     = "{{{gemLicense}}}{{^gemLicense}}MIT{{/gemLicense}}"
+  s.required_ruby_version = "{{{gemRequiredRubyVersion}}}{{^gemRequiredRubyVersion}}>= 2.4{{/gemRequiredRubyVersion}}"
+
+  {{#isFaraday}}
+  s.add_runtime_dependency 'faraday', '~> 1.0', '>= 1.0.1'
+  {{/isFaraday}}
+  {{^isFaraday}}
+  s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1'
+  {{/isFaraday}}
+
+  s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
+  s.add_development_dependency 'bundler', '~> 2.2.9'
+  s.add_development_dependency 'dotenv'
+  s.add_development_dependency 'minitest', '~> 5.14'
+  s.add_development_dependency 'minitest-around', '~> 0.5.0'
+  s.add_development_dependency 'rake', '>= 13.0'
+  s.add_development_dependency 'rubocop', '~> 0.91.0'
+
+  s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ["lib"]
+end

data/test/test_accounts.rb

@@ -0,0 +1,103 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::AccountsGetRequest.
+class PlaidAccountsTest < PlaidTest
+  def setup
+    create_item initial_products: [:transactions]
+  end
+
+  def test_get
+    accounts_get_request = Plaid::AccountsGetRequest.new
+    accounts_get_request.access_token = access_token
+
+    response = client.accounts_get(accounts_get_request)
+    refute_empty(response.to_hash)
+    assert_kind_of(Plaid::AccountsGetResponse, response)
+
+    account_id = response.accounts[0].account_id
+
+    options_payload = {}
+    options_payload[:account_ids] = [account_id]
+    accounts_get_request.options = options_payload
+
+    response_w_id = client.accounts_get(accounts_get_request)
+    assert_equal(1, response_w_id.accounts.size)
+  end
+
+  def test_get_invalid_access_token
+    accounts_get_request = Plaid::AccountsGetRequest.new
+    accounts_get_request.access_token = BAD_STRING
+
+    begin
+      client.accounts_get(accounts_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
+    accounts_get_request = Plaid::AccountsGetRequest.new
+    accounts_get_request.access_token = access_token
+
+    options_payload = {}
+    options_payload[:account_ids] = [BAD_STRING]
+    accounts_get_request.options = options_payload
+
+    begin
+      client.accounts_get(accounts_get_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+
+  def test_balance_get
+    balance_get_request = Plaid::AccountsBalanceGetRequest.new
+    balance_get_request.access_token = access_token
+
+    response = client.accounts_balance_get(balance_get_request)
+    refute_empty(response.accounts)
+    assert_kind_of(Plaid::AccountsGetResponse, response)
+
+    account_id = response.accounts[0].account_id
+
+    options_payload = {}
+    options_payload[:account_ids] = [account_id]
+
+    accounts_balance_get_request = Plaid::AccountsBalanceGetRequest.new
+    accounts_balance_get_request.access_token = access_token
+    accounts_balance_get_request.options = options_payload
+
+    response_w_id = client.accounts_balance_get(accounts_balance_get_request)
+    assert_equal 1, response_w_id.accounts.size
+  end
+
+  def test_balance_get_invalid_access_token
+    accounts_balance_get_request = Plaid::AccountsBalanceGetRequest.new
+    accounts_balance_get_request.access_token = BAD_STRING
+
+    begin
+      client.accounts_balance_get(accounts_balance_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_balance_get_invalid_options
+    options_payload = {}
+    options_payload[:account_ids] = [BAD_STRING]
+
+    accounts_balance_get_request = Plaid::AccountsBalanceGetRequest.new
+    accounts_balance_get_request.access_token = access_token
+    accounts_balance_get_request.options = options_payload
+
+    begin
+      client.accounts_balance_get(accounts_balance_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_asset_report.rb

@@ -0,0 +1,147 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::AssetReport.
+class PlaidAssetReportTest < PlaidTest
+  def test_full_flow # rubocop:disable Metrics/MethodLength
+    # Create an item with the "assets" product.
+    create_item initial_products: [:assets]
+
+    # Create an asset report.
+    days_requested = 60
+    options = {
+      client_report_id: "123",
+      webhook: "https://www.example.com",
+      user: {
+        client_user_id: "789",
+        first_name: "Jane",
+        middle_name: "Leah",
+        last_name: "Doe",
+        ssn: "123-45-6789",
+        phone_number: "(555) 123-4567",
+        email: "jane.doe@example.com",
+      },
+    }
+    asset_report_create_request = Plaid::AssetReportCreateRequest.new
+    asset_report_create_request.access_tokens = [access_token]
+    asset_report_create_request.days_requested = days_requested
+    asset_report_create_request.options = options
+
+    response = client.asset_report_create(asset_report_create_request)
+
+    refute_empty(response.asset_report_id)
+    refute_empty(response.asset_report_token)
+    asset_report_token = response.asset_report_token
+    assert_kind_of(Plaid::AssetReportCreateResponse, response)
+
+    # Poll until report generation has finished.
+    response = poll_for_asset_report(asset_report_token)
+    refute_empty(response.report.to_hash)
+    assert_kind_of(Plaid::AssetReportGetResponse, response)
+
+    # Retrieve the report as an Asset Report with Insights.
+    asset_report_get_request = Plaid::AssetReportGetRequest.new
+    asset_report_get_request.asset_report_token = asset_report_token
+    asset_report_get_request.include_insights = true
+
+    response = client.asset_report_get(asset_report_get_request)
+
+    refute_empty(response.report.to_hash)
+    assert_kind_of(Plaid::AssetReportGetResponse, response)
+
+    # Get the asset report as a PDF in a tempfile.
+    asset_report_pdf_get_request = Plaid::AssetReportPDFGetRequest.new
+    asset_report_pdf_get_request.asset_report_token = asset_report_token
+
+    pdf = client.asset_report_pdf_get(asset_report_pdf_get_request)
+    refute_empty(pdf.path)
+    assert_kind_of(Tempfile, pdf)
+
+    # Test opening pdf contents
+    # require 'fileutils'
+    # FileUtils.mv(pdf.path, "test.pdf")
+
+    # # Create a filtered copy of the report.
+    account_ids_to_exclude = [response.report.items[0].accounts[0].account_id]
+    asset_report_filter_request = Plaid::AssetReportFilterRequest.new
+    asset_report_filter_request.asset_report_token = asset_report_token
+    asset_report_filter_request.account_ids_to_exclude = account_ids_to_exclude
+
+    response = client.asset_report_filter(
+      asset_report_filter_request
+    )
+    refute_empty(response.asset_report_token)
+    assert_kind_of(Plaid::AssetReportFilterResponse, response)
+
+    response = poll_for_asset_report(asset_report_token)
+    refute_empty(response.report.to_hash)
+    assert_kind_of(Plaid::AssetReportGetResponse, response)
+
+    # Create refreshed copy of the report.
+    asset_report_refresh_request = Plaid::AssetReportRefreshRequest.new
+    asset_report_refresh_request.asset_report_token = asset_report_token
+    asset_report_refresh_request.days_requested = 10
+
+    response = client.asset_report_refresh(asset_report_refresh_request)
+    refute_empty(response.asset_report_token)
+    assert_kind_of(Plaid::AssetReportRefreshResponse, response)
+
+    response = poll_for_asset_report(response.asset_report_token)
+    refute_empty(response.report.to_hash)
+    assert_kind_of(Plaid::AssetReportGetResponse, response)
+
+    # Create an audit copy token.
+    asset_report_audit_copy_create_request = Plaid::AssetReportAuditCopyCreateRequest.new
+    asset_report_audit_copy_create_request.asset_report_token = asset_report_token
+    asset_report_audit_copy_create_request.auditor_id = @client_id
+
+    response = client.asset_report_audit_copy_create(
+      asset_report_audit_copy_create_request
+    )
+    audit_copy_token = response.audit_copy_token
+    refute_empty(audit_copy_token)
+    assert_kind_of(Plaid::AssetReportAuditCopyCreateResponse, response)
+
+    # Get the audit copy.
+    asset_report_audit_copy_get_request = Plaid:: AssetReportAuditCopyGetRequest.new
+    asset_report_audit_copy_get_request.audit_copy_token = audit_copy_token
+
+    response = @client.asset_report_audit_copy_get(asset_report_audit_copy_get_request)
+    refute_empty(response.report.to_hash)
+    assert_kind_of(Plaid::AssetReportGetResponse, response)
+
+    # Remove the audit copy.
+    asset_report_audit_copy_remove_request = Plaid::AssetReportAuditCopyRemoveRequest.new
+    asset_report_audit_copy_remove_request.audit_copy_token = audit_copy_token
+
+    response = @client.asset_report_audit_copy_remove(asset_report_audit_copy_remove_request)
+    assert_equal(response.removed, true)
+    assert_kind_of(Plaid::AssetReportAuditCopyRemoveResponse, response)
+
+    # Remove the asset report.
+    asset_report_remove_request = Plaid::AssetReportRemoveRequest.new
+    asset_report_remove_request.asset_report_token = asset_report_token
+
+    response = @client.asset_report_remove(asset_report_remove_request)
+    assert_equal(response.removed, true)
+    assert_kind_of(Plaid::AssetReportRemoveResponse, response)
+  end
+end
+
+def poll_for_asset_report(asset_report_token)
+  response = nil
+  50.times do
+    begin
+      asset_report_get_request = Plaid::AssetReportGetRequest.new
+      asset_report_get_request.asset_report_token = asset_report_token
+
+      response = @client.asset_report_get(asset_report_get_request)
+      break
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      raise e if json_response["error_code"] != "PRODUCT_NOT_READY"
+      sleep 1
+    end
+  end
+  assert response, "Timed out while waiting for asset report generation"
+  response
+end

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(2, 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