plaid 13.2.0 → 42.0.0

data/test/test_link_token.rb

@@ -0,0 +1,131 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Item.
+class PlaidLinkTokenTest < PlaidTest
+  def test_create_required
+    link_token_create_request = Plaid::LinkTokenCreateRequest.new(
+      {
+        user:  {
+          client_user_id:  "user-id",
+        },
+        client_name:  "Plaid Test",
+        products:  ["auth", "transactions"],
+        country_codes:  ["GB"],
+        language:  "en",
+      }
+    )
+
+    link_token_response = client.link_token_create(
+      link_token_create_request
+    )
+
+    refute_empty(link_token_response.link_token)
+    refute_nil(link_token_response.expiration)
+    assert_kind_of(Plaid::LinkTokenCreateResponse, link_token_response)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def test_create_optional
+    link_token_create_request = Plaid::LinkTokenCreateRequest.new(
+      {
+        user: {
+          client_user_id:  "user-id",
+          legal_name:  "John Doe",
+          phone_number:  "+1 415 555 0123",
+          phone_number_verified_time:  "2020-01-01T00:00:00Z",
+          email_address:  "example@plaid.com",
+          email_address_verified_time:  "2020-01-01T00:00:00Z",
+        },
+        client_name:  "Plaid Test",
+        products:  ["auth", "transactions"],
+        country_codes:  ["GB"],
+        language:  "en",
+        webhook:  "https://sample-webhook.com",
+        link_customization_name:  "default",
+        account_filters:  {
+          depository:  {
+            account_subtypes:  ["checking", "savings"],
+          },
+        },
+      }
+    )
+
+    link_token_response = client.link_token_create(
+      link_token_create_request
+    )
+
+    refute_empty(link_token_response.link_token)
+    refute_nil(link_token_response.expiration)
+    assert_kind_of(Plaid::LinkTokenCreateResponse, link_token_response)
+  end
+
+  def test_create_and_get
+    link_token_create_request = Plaid::LinkTokenCreateRequest.new(
+      {
+        user: {
+          client_user_id:  "user-id",
+        },
+        client_name:  "Plaid Test",
+        products:  ["auth", "transactions"],
+        country_codes:  ["GB"],
+        language:  "en",
+        webhook:  "https://sample-webhook.com",
+        link_customization_name:  "default",
+        account_filters:  {
+          depository:  {
+            account_subtypes:  ["checking", "savings"],
+          },
+        },
+      },
+    )
+    create_link_token_response = client.link_token_create(
+      link_token_create_request
+    )
+
+    refute_empty(create_link_token_response.link_token)
+    refute_nil(create_link_token_response.expiration)
+
+    link_token_get_request = Plaid::LinkTokenGetRequest.new({
+      link_token:  create_link_token_response.link_token,
+    })
+
+    get_link_token_response = client.link_token_get(link_token_get_request)
+    refute_empty(get_link_token_response.link_token)
+    refute_nil(get_link_token_response.expiration)
+
+    assert_equal("Plaid Test", get_link_token_response.metadata.client_name)
+    assert_equal(%w[auth transactions], get_link_token_response.metadata.initial_products)
+    assert_equal("en", get_link_token_response.metadata.language)
+    assert_equal("https://sample-webhook.com", get_link_token_response.metadata.webhook)
+
+    get_link_token_response_hash = get_link_token_response.to_hash
+    assert_equal([:account_subtypes], get_link_token_response_hash[:metadata][:account_filters][:depository].keys)
+    assert_equal(%w[checking savings], get_link_token_response_hash[:metadata][:account_filters][:depository][:account_subtypes])
+  end
+
+  def test_create_and_get_create_extended_auth
+      link_token_create_request = Plaid::LinkTokenCreateRequest.new({
+        user: {
+          client_user_id:  "123-fake-user-id"
+        },
+        client_name:  "Plaid Test",
+        products:  ["auth"],
+        country_codes:  ["US"],
+        language:  "en",
+        auth:  {
+          auth_type_select_enabled:  true,
+          automated_microdeposits_enabled:  true,
+          instant_match_enabled:  true,
+          same_day_microdeposits_enabled:  true,
+        },
+      })
+      create_link_token_response = client.link_token_create(
+        link_token_create_request
+      )
+
+      refute_empty(create_link_token_response.link_token)
+      refute_nil(create_link_token_response.expiration)
+  end
+
+  # rubocop:enable Metrics/MethodLength
+end

data/test/test_monitor.rb

@@ -0,0 +1,55 @@
+require "date"
+
+require_relative 'test_helper'
+
+# Internal: The test for Plaid::WatchlistScreening.
+
+WATCHLIST_PROGRAM_ID = "prg_egdF5fGjY8fWqk"
+LEGAL_NAME = "Domingo Huang"
+CLIENT_USER_ID = "monitor-user-" + Time.now.to_i.to_s
+DOCUMENT_NUMBER = "123456789"
+class PlaidMonitorTest < PlaidTest
+  def test_screening_individual
+    date_of_birth = Time.now.to_date
+    search_terms = Plaid::WatchlistScreeningRequestSearchTerms.new({
+        :watchlist_program_id => WATCHLIST_PROGRAM_ID,
+        :legal_name => LEGAL_NAME,
+        :country => Plaid::CountryCode::US,
+        :date_of_birth => date_of_birth,
+        :document_number => DOCUMENT_NUMBER,
+    })
+    monitor_create_request = Plaid::WatchlistScreeningIndividualCreateRequest.new({
+        :client_user_id => CLIENT_USER_ID,
+        :search_terms => search_terms,
+    })
+    response = client.watchlist_screening_individual_create(monitor_create_request)
+    assert_kind_of(Plaid::WatchlistScreeningIndividualCreateResponse, response)
+    assert_equal(LEGAL_NAME, response.search_terms.legal_name)
+    assert_equal(DOCUMENT_NUMBER, response.search_terms.document_number)
+    assert_equal(date_of_birth, response.search_terms.date_of_birth)
+    assert_equal(Plaid::CountryCode::US, response.search_terms.country)
+
+    monitor_update_request = Plaid::WatchlistScreeningIndividualUpdateRequest.new({
+        :watchlist_screening_id => response.id,
+        :status => Plaid::WatchlistScreeningStatus::PENDING_REVIEW,
+    })
+    response = client.watchlist_screening_individual_update(monitor_update_request)
+    assert_kind_of(Plaid::WatchlistScreeningIndividualUpdateResponse, response)
+    assert_equal(Plaid::WatchlistScreeningStatus::PENDING_REVIEW, response.status)
+
+    monitor_list_request = Plaid::WatchlistScreeningIndividualListRequest.new({
+        :watchlist_program_id => WATCHLIST_PROGRAM_ID,
+        :client_user_id => CLIENT_USER_ID,
+    })
+    response = client.watchlist_screening_individual_list(monitor_list_request)
+    assert_kind_of(Plaid::WatchlistScreeningIndividualListResponse, response)
+    assert_equal(1, response.watchlist_screenings.length)
+
+    monitor_get_request = Plaid::WatchlistScreeningIndividualGetRequest.new({
+        :watchlist_screening_id => response.watchlist_screenings[0].id,
+    })
+    response = client.watchlist_screening_individual_get(monitor_get_request)
+    assert_kind_of(Plaid::WatchlistScreeningIndividualGetResponse, response)
+    assert_equal(LEGAL_NAME, response.search_terms.legal_name)
+  end
+end

data/test/test_payment_initiation.rb

@@ -0,0 +1,94 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::PaymentInitiation.
+class PlaidPaymentInitiationTest < PlaidTest
+  # rubocop:disable Metrics/MethodLength
+  def test_all_routes
+    # create recipient
+    payment_initiation_recipient_create_request = Plaid::PaymentInitiationRecipientCreateRequest.new
+    payment_initiation_recipient_create_request.name = "John Doe"
+    payment_initiation_recipient_create_request.iban = "GB33BUKB20201555555555"
+    payment_initiation_recipient_create_request.address = {
+      street: ["Street Name 999"],
+      city: "City",
+      postal_code: "99999",
+      country: "GB",
+    }
+    payment_initiation_recipient_create_request.bacs = {
+      account: "26207729",
+      sort_code: "560029",
+    }
+
+    create_recipient_response = client.payment_initiation_recipient_create(
+      payment_initiation_recipient_create_request
+    )
+    recipient_id = create_recipient_response.recipient_id
+    refute_empty(recipient_id)
+
+    # get recipient
+    payment_initiation_recipient_get_request = Plaid::PaymentInitiationRecipientGetRequest.new
+    payment_initiation_recipient_get_request.recipient_id = recipient_id
+
+    get_recipient_response = client.payment_initiation_recipient_get(
+      payment_initiation_recipient_get_request
+    )
+
+    refute_empty(get_recipient_response.recipient_id)
+    refute_empty(get_recipient_response.name)
+    refute_empty(get_recipient_response.iban)
+    refute_empty(get_recipient_response.bacs.to_hash)
+    assert_kind_of(Plaid::RecipientBACSNullable, get_recipient_response.bacs)
+    refute_empty(get_recipient_response.address.to_hash)
+    assert_kind_of(Plaid::PaymentInitiationAddress, get_recipient_response.address)
+    assert_kind_of(Plaid::PaymentInitiationRecipientGetResponse, get_recipient_response)
+
+    # list recipients
+    payment_initiation_recipient_list_request = Plaid::PaymentInitiationRecipientListRequest.new
+
+    list_recipients_response = client.payment_initiation_recipient_list(payment_initiation_recipient_list_request)
+    refute_empty(list_recipients_response.recipients)
+
+    # create payment
+    payment_initiation_payment_create_request = Plaid::PaymentInitiationPaymentCreateRequest.new
+    payment_initiation_payment_create_request.recipient_id = recipient_id
+    payment_initiation_payment_create_request.reference = "testpayment"
+    payment_initiation_payment_create_request.amount = {
+      value: 100.00,
+      currency: "GBP",
+    }
+
+    create_payment_response = client.payment_initiation_payment_create(
+      payment_initiation_payment_create_request
+    )
+
+    payment_id = create_payment_response.payment_id
+    refute_empty(payment_id)
+    assert_kind_of(Plaid::PaymentInitiationPaymentCreateResponse, create_payment_response)
+
+    # get payment
+    payment_initiation_payment_get_request = Plaid::PaymentInitiationPaymentGetRequest.new
+    payment_initiation_payment_get_request.payment_id = payment_id
+
+    get_payment_response = client.payment_initiation_payment_get(payment_initiation_payment_get_request)
+
+    refute_empty(get_payment_response.payment_id)
+    refute_empty(get_payment_response.reference)
+    refute_empty(get_payment_response.amount.to_hash)
+    assert_kind_of(Plaid::PaymentAmount, get_payment_response.amount)
+    refute_empty(get_payment_response.status)
+    refute_empty(get_payment_response.recipient_id)
+    assert_kind_of(Plaid::PaymentInitiationPaymentGetResponse, get_payment_response)
+
+    # list payments
+    payment_initiation_payment_list_request = Plaid::PaymentInitiationPaymentListRequest.new
+    payment_initiation_payment_list_request.count = 10
+
+    list_payments_response = client.payment_initiation_payment_list(
+      payment_initiation_payment_list_request
+    )
+    refute_empty(list_payments_response.payments)
+    assert_kind_of(Plaid::PaymentInitiationPaymentListResponse, list_payments_response)
+  end
+
+  # rubocop:enable Metrics/MethodLength
+end

data/test/test_processor.rb

@@ -0,0 +1,52 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Processor.
+class PlaidProcessorTest < PlaidTest
+  def setup
+    create_item initial_products: [:auth]
+  end
+
+  def test_stripe_bank_account_token_create_invalid_account_id
+    processor_token_create_request = Plaid::ProcessorStripeBankAccountTokenCreateRequest.new
+    processor_token_create_request.access_token = access_token
+    processor_token_create_request.account_id = BAD_STRING
+
+    begin
+      client.processor_stripe_bank_account_token_create processor_token_create_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+      assert_equal(json_response["error_message"], "account_id must be a valid account ID")
+    end
+  end
+
+  def test_dwolla_processor_token_create_invalid_account_id
+    processor_token_create_request = Plaid::ProcessorTokenCreateRequest.new
+    processor_token_create_request.access_token = access_token
+    processor_token_create_request.account_id = BAD_STRING
+    processor_token_create_request.processor = "dwolla"
+
+    begin
+      client.processor_token_create processor_token_create_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+      assert_equal(json_response["error_message"], "account_id must be a valid account ID")
+    end
+  end
+
+  def test_ocrolus_processor_token_create_invalid_account_id
+    processor_token_create_request = Plaid::ProcessorTokenCreateRequest.new
+    processor_token_create_request.access_token = access_token
+    processor_token_create_request.account_id = BAD_STRING
+    processor_token_create_request.processor = "ocrolus"
+
+    begin
+      client.processor_token_create processor_token_create_request
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+      assert_equal(json_response["error_message"], "account_id must be a valid account ID")
+    end
+  end
+end

data/test/test_sandbox.rb

@@ -0,0 +1,31 @@
+require_relative 'test_helper'
+
+class PlaidSandboxTest < PlaidTest
+    # rubocop:disable Metrics/MethodLength
+    def test_sandbox_income_verification
+        skip "TODO (czhou): unskip when tests are fixed"
+        # test sandbox public token for income verification
+        sandbox_public_token_create_request = Plaid::SandboxPublicTokenCreateRequest.new
+        sandbox_public_token_create_request.institution_id = SANDBOX_INSTITUTION
+        sandbox_public_token_create_request.initial_products = ["income_verification"]
+        
+        options_payload = {}
+        options_payload[:income_verification] = {
+            income_verification: {
+                income_source_types: ["bank"],
+                bank_income: {
+                    days_requested: 180,
+                }
+            }
+        }
+        
+        sandbox_public_token_create_request.options = options_payload
+
+        public_token_response = client.sandbox_public_token_create(
+        sandbox_public_token_create_request
+        )
+
+        refute_empty(public_token_response.to_hash)
+        refute_empty(public_token_response.public_token)
+    end
+end

data/test/test_statements.rb

@@ -0,0 +1,77 @@
+require_relative "test_helper"
+require "date"
+
+# Internal: The test for Plaid::Statements.
+class PlaidStatementsTest < PlaidTest
+  def test_full_flow # rubocop:disable Metrics/MethodLength
+    create_item initial_products: [:statements],
+                        options: {
+                            statements: {
+                                start_date: "2023-11-01",
+                                end_date: "2023-12-01"
+                            }
+                        }
+
+    # 1. /statements/list
+    response = poll_for_statements_list(access_token)
+    refute_empty(response.accounts)
+    refute_empty(response.accounts[0].statements)
+    assert_kind_of(Plaid::StatementsListResponse, response)
+
+    # 2. /statements/download
+    response.accounts.each do |account|
+      account.statements.each do |statement|
+        statements_download_request = Plaid::StatementsDownloadRequest.new
+        statements_download_request.access_token = access_token
+        statements_download_request.statement_id = statement.statement_id
+
+        file, status_code, headers = client.statements_download_with_http_info(statements_download_request)
+        assert_equal(status_code, 200)
+        assert_equal(headers["content-type"], "application/pdf")
+
+        sha = Digest::SHA2.new
+        File.open(file.path) do |f|
+          while chunk = f.read(256) # only load 256 bytes at a time
+            sha << chunk
+          end
+        end
+
+        assert_equal(headers["plaid-content-hash"], sha.hexdigest)
+      end
+    end
+
+    # 3. /statements/refresh
+    statements_refresh_request = Plaid::StatementsRefreshRequest.new
+    statements_refresh_request.access_token = access_token
+    statements_refresh_request.start_date = "2024-01-01"
+    statements_refresh_request.end_date = "2024-02-01"
+
+    response = client.statements_refresh(statements_refresh_request)
+    assert_kind_of(Plaid::StatementsRefreshResponse, response)
+    refute_empty(response.request_id)
+
+    # 4. /statements/list
+    response = poll_for_statements_list(access_token)
+    refute_empty(response.accounts)
+    refute_empty(response.accounts[0].statements)
+    assert_kind_of(Plaid::StatementsListResponse, response)
+  end
+end
+
+def poll_for_statements_list(access_token)
+  response = nil
+  10.times do
+    begin
+      statements_list_request = Plaid::StatementsListRequest.new
+      statements_list_request.access_token = access_token
+      response = @client.statements_list(statements_list_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 statements list"
+  response
+end

data/test/test_transactions.rb

@@ -0,0 +1,168 @@
+require "date"
+
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Transactions.
+class PlaidTransactionsTest < PlaidTest # rubocop:disable Metrics/ClassLength
+  START_DATE = (Date.today - 365)
+  END_DATE = Date.today
+
+  def setup
+    create_item initial_products: [:transactions],
+                transactions_start_date: START_DATE,
+                transactions_end_date: END_DATE
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/LineLength
+  # rubocop:disable Style/GuardClause
+
+  # Helper method to get transactions - retry up to 5 times with
+  # a backoff delay to wait out PRODUCT_NOT_READY errors
+  def get_transactions_with_retries(access_token, start_date, end_date, count: nil, offset: nil, account_ids: nil, options: nil)
+    num_retries = 5
+    retries = 0
+    while retries < num_retries
+      retries += 1
+      begin
+        options_payload = {}
+        options_payload[:account_ids] = account_ids unless account_ids.nil?
+        options_payload[:count] = count unless count.nil?
+        options_payload[:offset] = offset unless offset.nil?
+        options_payload.merge!(options) unless options.nil?
+
+        transactions_get_request = Plaid::TransactionsGetRequest.new
+        transactions_get_request.access_token = access_token
+        transactions_get_request.start_date = start_date
+        transactions_get_request.end_date = end_date
+        transactions_get_request.options = options_payload
+
+        response = client.transactions_get(transactions_get_request)
+      rescue Plaid::ApiError => e
+        if retries < num_retries
+          sleep(retries * 2)
+          next
+        else
+          raise e
+        end
+      end
+    end
+    response
+  end
+
+  def test_get
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE)
+
+    refute_empty(response.accounts)
+    refute_empty(response.transactions)
+
+    account_id = response.accounts[0].account_id
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE,
+                                             account_ids: [account_id])
+    refute_empty(response.transactions)
+
+    response.transactions.each do |transaction|
+      refute_nil(transaction.transaction_id)
+      refute_nil(transaction.account_id)
+      refute_nil(transaction.pending)
+      refute_nil(transaction.transaction_type)
+      refute_nil(transaction.payment_meta)
+      refute_nil(transaction.date)
+      refute_nil(transaction.name)
+      refute_nil(transaction.amount)
+      refute_nil(transaction.location)
+      refute_nil(transaction.iso_currency_code)
+    end
+  end
+
+  # # rubocop:enable Metrics/MethodLength
+  # # rubocop:enable Metrics/LineLength
+  # # rubocop:enable Style/GuardClause
+
+  def test_get_date_objects
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE)
+    refute_empty(response.accounts)
+    refute_empty(response.transactions)
+
+    account_id = response.accounts[0].account_id
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE,
+                                             account_ids: [account_id])
+    refute_empty(response.transactions)
+  end
+
+  def test_get_invalid_access_token
+    begin
+      get_transactions_with_retries(BAD_STRING, START_DATE, END_DATE)
+    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_dates
+    begin
+      get_transactions_with_retries(access_token, BAD_STRING, BAD_STRING)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+
+  def test_get_with_options
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE,
+                                             count: 2,
+                                             offset: 1)
+    assert_equal(2, response.transactions.length)
+  end
+
+  def test_get_with_additional_options
+    response = get_transactions_with_retries(access_token,
+                                             START_DATE,
+                                             END_DATE,
+                                             options: { count: 2,
+                                                        offset: 1 })
+    assert_equal(2, response.transactions.length)
+  end
+
+  def test_get_invalid_options
+    begin
+      get_transactions_with_retries(access_token,
+                                    START_DATE,
+                                    END_DATE,
+                                    count: BAD_STRING,
+                                    offset: BAD_STRING)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+
+  def test_refresh_invalid_access_token
+    transactions_refresh_request = Plaid::TransactionsRefreshRequest.new
+    transactions_refresh_request.access_token = BAD_STRING
+
+    begin
+      client.transactions_refresh(transactions_refresh_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_refresh
+    transactions_refresh_request = Plaid::TransactionsRefreshRequest.new
+    transactions_refresh_request.access_token = access_token
+
+    response = client.transactions_refresh(transactions_refresh_request)
+  end
+end

data/test/test_webhooks.rb

@@ -0,0 +1,22 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Webhooks.
+class PlaidWebhooksTest < PlaidTest
+  def test_get_verification_key
+    key_id = "6c5516e1-92dc-479e-a8ff-5a51992e0001"
+
+    webhook_verification_key_get_request = Plaid::WebhookVerificationKeyGetRequest.new
+    webhook_verification_key_get_request.key_id = key_id
+
+    webhook_verification_key_response = client.webhook_verification_key_get(webhook_verification_key_get_request)
+
+    refute_empty(webhook_verification_key_response.key.to_hash)
+    refute_empty(webhook_verification_key_response.key.alg)
+    refute_empty(webhook_verification_key_response.key.crv)
+    refute_empty(webhook_verification_key_response.key.kid)
+    refute_empty(webhook_verification_key_response.key.kty)
+    refute_empty(webhook_verification_key_response.key.use)
+    refute_empty(webhook_verification_key_response.key.x)
+    refute_empty(webhook_verification_key_response.key.y)
+  end
+end