plaid 13.0.0 → 14.0.0.beta.1

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_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 => 1,
+      :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 => 1,
+      :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

data/test/test_investments.rb

@@ -0,0 +1,205 @@
+require "date"
+
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Investments.
+class PlaidInvestmentsTest < PlaidTest # rubocop:disable Metrics/ClassLength
+  def setup
+    create_item initial_products: [:investments],
+                transactions_start_date: START_DATE,
+                transactions_end_date: END_DATE
+  end
+
+  # rubocop:disable Metrics/MethodLength
+
+  def test_investment_transactions_get
+    investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+    investments_transactions_get_request.access_token = access_token
+    investments_transactions_get_request.start_date = START_DATE
+    investments_transactions_get_request.end_date = END_DATE
+
+    response = client.investments_transactions_get(investments_transactions_get_request)
+
+    refute_empty(response.accounts)
+    refute_empty(response.investment_transactions)
+    assert_kind_of(Plaid::InvestmentsTransactionsGetResponse, response)
+
+    investment_account = response.accounts.find do |account|
+      account.type == "investment"
+    end
+
+    account_ids = [investment_account.account_id]
+    options_payload = {}
+    options_payload[:account_ids] = account_ids
+
+    investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+    investments_transactions_get_request.access_token = access_token
+    investments_transactions_get_request.options = options_payload
+    investments_transactions_get_request.start_date = START_DATE
+    investments_transactions_get_request.end_date = END_DATE
+
+    response = client.investments_transactions_get(investments_transactions_get_request)
+
+    refute_empty(response.investment_transactions)
+    assert_kind_of(Plaid::InvestmentsTransactionsGetResponse, response)
+
+    response.investment_transactions.each do |transaction|
+      refute_nil(transaction.investment_transaction_id)
+      refute_nil(transaction.account_id)
+      refute_nil(transaction.date)
+      refute_nil(transaction.name)
+      refute_nil(transaction.amount)
+    end
+  end
+
+  # rubocop:enable Metrics/MethodLength
+
+  def test_investment_transactions_get_date_objects
+    investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+    investments_transactions_get_request.access_token = access_token
+    investments_transactions_get_request.start_date = START_DATE
+    investments_transactions_get_request.end_date = END_DATE
+
+    response = client.investments_transactions_get(investments_transactions_get_request)
+
+    refute_empty(response.accounts)
+    refute_empty(response.investment_transactions)
+    assert_kind_of(Plaid::InvestmentsTransactionsGetResponse, response)
+
+    investment_account = response.accounts.find do |account|
+      account.type == "investment"
+    end
+
+    account_ids = [investment_account.account_id]
+    options_payload = {}
+    options_payload[:account_ids] = account_ids
+
+    investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+    investments_transactions_get_request.access_token = access_token
+    investments_transactions_get_request.options = options_payload
+    investments_transactions_get_request.start_date = Date.parse(START_DATE)
+    investments_transactions_get_request.end_date = Date.parse(END_DATE)
+
+    response = client.investments_transactions_get(investments_transactions_get_request)
+    refute_empty(response.investment_transactions)
+  end
+
+  def test_investment_transactions_get_invalid_access_token
+    begin
+      investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+      investments_transactions_get_request.access_token = BAD_STRING
+      investments_transactions_get_request.start_date = START_DATE
+      investments_transactions_get_request.end_date = END_DATE
+
+      client.investments_transactions_get(investments_transactions_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_investment_transactions_get_invalid_dates
+    begin
+      investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+      investments_transactions_get_request.access_token = access_token
+      investments_transactions_get_request.start_date = BAD_STRING
+      investments_transactions_get_request.end_date = BAD_STRING
+
+      client.investments_transactions_get(investments_transactions_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_investment_transactions_get_with_options
+    options_payload = {}
+    options_payload[:count] = 2
+    options_payload[:offset] = 1
+
+    investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+    investments_transactions_get_request.access_token = access_token
+    investments_transactions_get_request.options = options_payload
+    investments_transactions_get_request.start_date = START_DATE
+    investments_transactions_get_request.end_date = END_DATE
+
+    response = client.investments_transactions_get(investments_transactions_get_request)
+    assert_equal(2, response.investment_transactions.length)
+    assert_kind_of(Plaid::InvestmentsTransactionsGetResponse, response)
+  end
+
+  def test_investment_transactions_get_invalid_options
+    begin
+      options_payload = {}
+      options_payload[:count] = BAD_STRING
+      options_payload[:offset] = BAD_STRING
+
+      investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new
+      investments_transactions_get_request.access_token = access_token
+      investments_transactions_get_request.start_date = BAD_STRING
+      investments_transactions_get_request.end_date = BAD_STRING
+
+      client.investments_transactions_get(investments_transactions_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_holdings_get
+    investments_holdings_get_request = Plaid::InvestmentsHoldingsGetRequest.new
+    investments_holdings_get_request.access_token = access_token
+
+    response = client.investments_holdings_get(investments_holdings_get_request)
+
+    refute_empty(response.accounts)
+    refute_empty(response.holdings)
+    refute_empty(response.securities)
+
+    investment_account = response.accounts.find do |account|
+      account.type == "investment"
+    end
+
+    account_id = investment_account.account_id
+    investments_holdings_get_request = Plaid::InvestmentsHoldingsGetRequest.new
+    investments_holdings_get_request.access_token = access_token
+
+    options_payload = {}
+    options_payload[:account_ids] = [account_id]
+    investments_holdings_get_request.options = options_payload
+
+    response = client.investments_holdings_get(investments_holdings_get_request)
+
+    response.holdings.each do |holding|
+      assert_equal account_id, holding.account_id
+    end
+  end
+
+  def test_holdings_get_invalid_access_token
+    investments_holdings_get_request = Plaid::InvestmentsHoldingsGetRequest.new
+    investments_holdings_get_request.access_token = BAD_STRING
+
+    begin
+      response = client.investments_holdings_get(investments_holdings_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_holdings_get_invalid_options
+    investments_holdings_get_request = Plaid::InvestmentsHoldingsGetRequest.new
+    investments_holdings_get_request.access_token = access_token
+
+    options_payload = {}
+    options_payload[:account_ids] = [BAD_STRING]
+    investments_holdings_get_request.options = options_payload
+
+    begin
+      response = client.investments_holdings_get(investments_holdings_get_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+end