plaid 13.2.0 → 17.1.0

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

data/test/test_deposit_switch.rb

@@ -0,0 +1,73 @@
+require_relative "test_helper"
+
+class PlaidDepositSwitchTest < PlaidTest
+  # rubocop:disable Metrics/MethodLength
+  def test_all_routes
+    # import item
+    item_import_request = Plaid::ItemImportRequest.new
+
+    item_import_request.products = %w[identity auth]
+    item_import_request.user_auth = {
+      user_id: "user_good",
+      auth_token: "pass_good",
+    }
+
+    import_response = client.item_import(
+      item_import_request
+    )
+
+    refute_empty(import_response.access_token)
+    access_token = import_response.access_token
+    assert_kind_of(Plaid::ItemImportResponse, import_response)
+
+    # get account id
+    accounts_get_request = Plaid::AccountsGetRequest.new
+    accounts_get_request.access_token = access_token
+
+    get_accounts_response = client.accounts_get(accounts_get_request)
+    refute_empty(get_accounts_response.accounts)
+    assert_kind_of(Plaid::AccountsGetResponse, get_accounts_response)
+
+    depository_accounts = get_accounts_response.accounts.select do |account|
+      account.type == "depository"
+    end
+    account_id = depository_accounts[0].account_id
+
+    # create deposit switch
+    deposit_switch_create_request = Plaid::DepositSwitchCreateRequest.new
+    deposit_switch_create_request.target_account_id = account_id
+    deposit_switch_create_request.target_access_token = access_token
+
+    create_response = client.deposit_switch_create(
+      deposit_switch_create_request
+    )
+    assert_kind_of(Plaid::DepositSwitchCreateResponse, create_response)
+
+    refute_empty(create_response.deposit_switch_id)
+    deposit_switch_id = create_response.deposit_switch_id
+
+    # get deposit switch
+    deposit_switch_get_request = Plaid::DepositSwitchGetRequest.new()
+    deposit_switch_get_request.deposit_switch_id = deposit_switch_id
+
+    get_response = client.deposit_switch_get(deposit_switch_get_request)
+    assert_kind_of(Plaid::DepositSwitchGetResponse, get_response)
+
+    refute_empty(get_response.deposit_switch_id)
+    refute_empty(get_response.target_item_id)
+    refute_empty(get_response.target_account_id)
+    refute_empty(get_response.state)
+    refute_nil(get_response.date_created)
+
+    # create deposit switch token
+    deposit_switch_create_token_request = Plaid::DepositSwitchTokenCreateRequest.new
+    deposit_switch_create_token_request.deposit_switch_id = deposit_switch_id
+
+    create_token_response = client.deposit_switch_token_create(deposit_switch_create_token_request)
+
+    refute_empty(create_token_response.deposit_switch_token)
+    refute_empty(create_token_response.deposit_switch_token_expiration_time)
+  end
+end
+
+# rubocop:enable Metrics/MethodLength

data/test/test_helper.rb

@@ -0,0 +1,109 @@
+require "minitest/autorun"
+require "minitest/around/unit"
+require "json"
+
+require_relative "../lib/plaid"
+
+# 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,51 @@
+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
+class PlaidIdentityVerificationTest < PlaidTest
+  def test_all_routes
+    user = Plaid::IdentityVerificationRequestUser.new({
+        :client_user_id => CLIENT_USER_ID,
+        :email_address => CLIENT_USER_ID + "@example.com",
+    })
+    identity_verification_create_request = Plaid::IdentityVerificationCreateRequest.new({
+        :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)
+
+    identity_verification_retry_request = Plaid::IdentityVerificationRetryRequest.new({
+        :template_id => TEMPLATE_ID,
+        :client_user_id => CLIENT_USER_ID,
+        :strategy => Plaid::Strategy::RESET,
+    })
+    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

data/test/test_institutions.rb

@@ -0,0 +1,159 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Institutions.
+class PlaidInstitutionsTest < PlaidTest
+  def test_get
+    institutions_get_request = Plaid::InstitutionsGetRequest.new({
+      :count => 3,
+      :offset => 4,
+      :country_codes => ["US"],
+    })
+
+    response = client.institutions_get(institutions_get_request)
+    assert_equal(3, response.to_hash[:institutions].length)
+  end
+
+  def test_get_with_options
+    institutions_get_request = Plaid::InstitutionsGetRequest.new({
+      :count => 3,
+      :offset => 4,
+      :country_codes => ["US"],
+      :options => {
+        products: ["transactions"],
+        include_optional_metadata: true,
+      },
+    })
+    response = client.institutions_get institutions_get_request
+
+    assert_kind_of(Plaid::InstitutionsGetResponse, response)
+    assert_equal(3, response.institutions.length)
+  end
+
+  def test_get_invalid_parameters
+    assert_raises(ArgumentError) do
+      institutions_get_request = Plaid::InstitutionsGetRequest.new({
+        :count => BAD_STRING,
+        :offset => BAD_STRING,
+        :country_codes => ["XX"],
+      })
+    end
+  end
+
+  def test_get_by_id
+    institutions_get_by_id_request = Plaid::InstitutionsGetByIdRequest.new({
+      :institution_id => SANDBOX_INSTITUTION,
+      :country_codes => ["US"],
+    })
+
+    response = client.institutions_get_by_id(institutions_get_by_id_request)
+
+    assert_equal(SANDBOX_INSTITUTION, response.institution.institution_id)
+    assert_equal(["US"], response.institution.country_codes)
+    assert_kind_of(Plaid::InstitutionsGetByIdResponse, response)
+  end
+
+  def test_get_by_id_invalid_parameters
+    institutions_get_by_id_request = Plaid::InstitutionsGetByIdRequest.new({
+      :institution_id => BAD_STRING,
+      :country_codes => ["US"],
+    })
+
+    begin
+      client.institutions_get_by_id institutions_get_by_id_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_INSTITUTION")
+    end
+  end
+
+  def test_get_by_id_include_optional_metadata
+    institutions_get_by_id_request = Plaid::InstitutionsGetByIdRequest.new({
+      :institution_id => SANDBOX_INSTITUTION,
+      :country_codes => ["US"],
+      :options => { include_optional_metadata: true },
+    })
+
+    response = client.institutions_get_by_id(institutions_get_by_id_request)
+    assert_equal(SANDBOX_INSTITUTION, response.institution.institution_id)
+    assert_kind_of(Plaid::InstitutionsGetByIdResponse, response)
+  end
+
+  def test_get_by_id_include_status_false
+    institutions_get_by_id_request = Plaid::InstitutionsGetByIdRequest.new({
+      :institution_id => SANDBOX_INSTITUTION,
+      :country_codes => ["US"],
+    })
+
+    response = client.institutions_get_by_id(institutions_get_by_id_request)
+    assert_equal(SANDBOX_INSTITUTION, response.institution.institution_id)
+    assert_nil(response.institution.status)
+    assert_kind_of(Plaid::InstitutionsGetByIdResponse, response)
+  end
+
+  def test_search
+    institutions_search_request = Plaid::InstitutionsSearchRequest.new({
+      :query => SANDBOX_INSTITUTION_NAME,
+      :products => [:transactions],
+      :country_codes => ["US"],
+    })
+
+    response = client.institutions_search(institutions_search_request)
+    refute_empty(response.institutions)
+    assert_kind_of(Plaid::InstitutionsSearchResponse, response)
+  end
+
+  def test_search_with_include_optional_metadata
+    institutions_search_request = Plaid::InstitutionsSearchRequest.new({
+      :query => SANDBOX_INSTITUTION_NAME,
+      :products => [:transactions],
+      :country_codes => ["US"],
+      :options => { include_optional_metadata: true },
+    })
+
+    response = client.institutions_search institutions_search_request
+    refute_empty(response.institutions)
+    assert_kind_of(Plaid::InstitutionsSearchResponse, response)
+  end
+
+  def test_search_with_products
+    institutions_search_request = Plaid::InstitutionsSearchRequest.new({
+      :query => SANDBOX_INSTITUTION_NAME,
+      :products => [:transactions],
+      :country_codes => ["US"],
+    })
+
+    response = client.institutions_search institutions_search_request
+    refute_empty(response.institutions)
+    assert_kind_of(Plaid::InstitutionsSearchResponse, response)
+  end
+
+  def test_search_invalid_products
+    institutions_search_request = Plaid::InstitutionsSearchRequest.new({
+      :query => SANDBOX_INSTITUTION_NAME,
+      :products => BAD_ARRAY,
+      :country_codes => ["XX"],
+    })
+
+    begin
+      client.institutions_search institutions_search_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_PRODUCT")
+    end
+  end
+
+  def test_search_bad_products
+    institutions_search_request = Plaid::InstitutionsSearchRequest.new({
+      :query => SANDBOX_INSTITUTION_NAME,
+      :products => BAD_STRING,
+      :country_codes => ["XX"],
+    })
+
+    begin
+      client.institutions_search institutions_search_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_type"], "INVALID_REQUEST")
+    end
+  end
+end