plaid 13.0.0 → 14.0.0.beta.4

data/test/test_item.rb

@@ -0,0 +1,285 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Item.
+class PlaidItemTest < PlaidTest # rubocop:disable Metrics/ClassLength
+  def test_create
+    create_item
+    refute_empty(@item.item.to_hash)
+
+    assert_equal(["transactions"], @item.item.billed_products)
+    assert_equal(SANDBOX_INSTITUTION, @item.item.institution_id)
+  end
+
+  def test_create_invalid_institution
+    begin
+      create_item institution_id: BAD_STRING
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_INSTITUTION")
+    end
+  end
+
+  def test_create_invalid_initial_products
+    begin
+      create_item initial_products: BAD_ARRAY
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "PRODUCTS_NOT_SUPPORTED")
+    end
+  end
+
+  def test_create_bad_initial_products
+    begin
+      create_item initial_products: 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_create_with_options
+    create_item(transactions_start_date: "2016-01-01",
+                transactions_end_date: "2016-02-01",
+                webhook: "https://plaid.com/webhook-test")
+
+    refute_empty(item.item.to_hash)
+    assert_equal("https://plaid.com/webhook-test", item.item.webhook)
+  end
+
+  def test_create_with_additional_options
+    options = { transactions: { start_date: "2016-01-01",
+                                end_date: "2016-02-01" },
+                webhook: "https://plaid.com/webhook-test" }
+
+    create_item(options: options)
+
+    refute_empty(item.item.to_hash)
+    assert_equal("https://plaid.com/webhook-test", item.item.webhook)
+  end
+
+  def test_create_with_options_date_objects
+    create_item(transactions_start_date: Date.parse("2016-01-01"),
+                transactions_end_date: Date.parse("2017-01-01"),
+                webhook: "https://plaid.com/webhook-test")
+
+    refute_empty(item.item.to_hash)
+    assert_equal("https://plaid.com/webhook-test", item.item.webhook)
+  end
+
+  def test_create_with_invalid_options
+    assert_raises(Plaid::ApiError) do
+      create_item(transactions_start_date: BAD_STRING,
+                  transactions_end_date: BAD_STRING,
+                  webhook: BAD_STRING)
+    end
+  end
+
+  def test_get
+    create_item
+
+    item_get_request = Plaid::ItemGetRequest.new
+    item_get_request.access_token = access_token
+
+    item = client.item_get(item_get_request)
+    refute_empty(item.item.to_hash)
+    refute_empty(item.status.to_hash)
+    assert_kind_of(Plaid::ItemGetResponse, item)
+  end
+
+  def test_get_valid_access_token
+    item_get_request = Plaid::ItemGetRequest.new
+    item_get_request.access_token = BAD_STRING
+
+    begin
+      item = client.item_get(item_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_remove
+    create_item
+
+    item_remove_request = Plaid::ItemRemoveRequest.new
+    item_remove_request.access_token = access_token
+
+    remove_response = client.item_remove(item_remove_request)
+    refute_empty(remove_response.to_hash)
+    assert_kind_of(Plaid::ItemRemoveResponse, remove_response)
+
+    # Don't remove it in teardown again
+    @access_token = nil
+  end
+
+  def test_remove_invalid_access_token
+    item_remove_request = Plaid::ItemRemoveRequest.new
+    item_remove_request.access_token = BAD_STRING
+
+    begin
+      remove_response = client.item_remove(item_remove_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_public_token_exchange_token
+    create_item
+
+    sandbox_public_token_create_request = Plaid::SandboxPublicTokenCreateRequest.new
+    sandbox_public_token_create_request.institution_id = SANDBOX_INSTITUTION
+    sandbox_public_token_create_request.initial_products = ["transactions"]
+
+    public_token_response = client.sandbox_public_token_create(
+      sandbox_public_token_create_request
+    )
+
+    refute_empty(public_token_response.public_token)
+
+    item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new
+    item_public_token_exchange_request.public_token = public_token_response.public_token
+
+    exchange_token_response = client.item_public_token_exchange(
+      item_public_token_exchange_request
+    )
+    refute_empty(exchange_token_response.access_token)
+  end
+
+  def test_exchange_token_invalid_public_token
+    item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new
+    item_public_token_exchange_request.public_token = BAD_STRING
+
+    begin
+      client.item_public_token_exchange(item_public_token_exchange_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_PUBLIC_TOKEN")
+    end
+  end
+
+  def test_public_token_sandbox
+    sandbox_public_token_create_request = Plaid::SandboxPublicTokenCreateRequest.new
+    sandbox_public_token_create_request.institution_id = SANDBOX_INSTITUTION
+    sandbox_public_token_create_request.initial_products = ["transactions"]
+
+    public_token_response = client.sandbox_public_token_create(
+      sandbox_public_token_create_request
+    )
+    refute_empty(public_token_response.public_token)
+  end
+
+  def test_fire_webhook_sandbox
+    sandbox_public_token_create_request = Plaid::SandboxPublicTokenCreateRequest.new
+    sandbox_public_token_create_request.institution_id = SANDBOX_INSTITUTION
+    sandbox_public_token_create_request.initial_products = ["transactions"]
+    sandbox_public_token_create_request.options = {
+      webhook: "https://httpstat.us/200"
+    }
+
+    public_token_response = client.sandbox_public_token_create(
+      sandbox_public_token_create_request
+    )
+
+    refute_empty(public_token_response.public_token)
+
+    item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new
+    item_public_token_exchange_request.public_token = public_token_response.public_token
+
+    exchange_token_response = client.item_public_token_exchange(
+      item_public_token_exchange_request
+    )
+
+    sandbox_item_fire_webhook_request = Plaid::SandboxItemFireWebhookRequest.new
+
+    sandbox_item_fire_webhook_request.access_token = exchange_token_response.access_token
+    sandbox_item_fire_webhook_request.webhook_code = "DEFAULT_UPDATE"
+
+    fire_webhook_response = client.sandbox_item_fire_webhook(
+      sandbox_item_fire_webhook_request
+    )
+    assert_equal true, fire_webhook_response.webhook_fired
+  end
+
+  def test_access_token_invalidate
+    create_item
+
+    item_access_token_invalidate_request = Plaid::ItemAccessTokenInvalidateRequest.new
+    item_access_token_invalidate_request.access_token = access_token
+
+    invalidate_response = client.item_access_token_invalidate(item_access_token_invalidate_request)
+    refute_empty(invalidate_response.new_access_token)
+
+    @access_token = invalidate_response.new_access_token
+  end
+
+  def test_access_token_invalidate_invalid_access_token
+    item_access_token_invalidate_request = Plaid::ItemAccessTokenInvalidateRequest.new
+    item_access_token_invalidate_request.access_token = BAD_STRING
+
+    begin
+      client.item_access_token_invalidate(item_access_token_invalidate_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_webhook_update
+    create_item
+
+    item_webhook_update_request = Plaid::ItemWebhookUpdateRequest.new
+    item_webhook_update_request.access_token = access_token
+    item_webhook_update_request.webhook = "https://plaid.com/webhook-test"
+
+    webhook_response = client.item_webhook_update(
+      item_webhook_update_request
+    )
+
+    assert_equal "https://plaid.com/webhook-test",
+                 webhook_response.item.webhook
+  end
+
+  def test_webhook_update_invalid_access_token
+    item_webhook_update_request = Plaid::ItemWebhookUpdateRequest.new
+    item_webhook_update_request.access_token = BAD_STRING
+    item_webhook_update_request.webhook = "https://plaid.com/webhook-test"
+
+    begin
+      client.item_webhook_update(item_webhook_update_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_webhook_update_invalid_webhook
+    create_item
+
+    item_webhook_update_request = Plaid::ItemWebhookUpdateRequest.new
+    item_webhook_update_request.access_token = access_token
+    item_webhook_update_request.webhook = BAD_STRING
+
+    begin
+      client.item_webhook_update(item_webhook_update_request)
+    rescue Plaid::ApiError => e
+      json_response = JSON.parse(e.response_body)
+      assert_equal(json_response["error_code"], "INVALID_FIELD")
+    end
+  end
+
+  def test_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)
+  end
+end

data/test/test_liabilities.rb

@@ -0,0 +1,45 @@
+require_relative "test_helper"
+
+# Internal: The test for Plaid::Liabilities.
+class PlaidLiabilitiesTest < PlaidTest
+  def test_get
+    create_item initial_products: [:liabilities], institution_id: "ins_1"
+
+    liabilities_get_request = Plaid::LiabilitiesGetRequest.new
+    liabilities_get_request.access_token = access_token
+
+    response = client.liabilities_get(liabilities_get_request)
+
+    refute_empty(response.accounts)
+    refute_empty(response.liabilities.to_hash)
+    refute_empty(response.liabilities.student)
+    refute_empty(response.liabilities.credit)
+    assert_kind_of(Plaid::LiabilitiesGetResponse, response)
+
+    account_id = response.accounts[7].account_id
+
+    options_payload = {}
+    options_payload[:account_ids] = [account_id]
+
+    liabilities_get_request = Plaid::LiabilitiesGetRequest.new
+    liabilities_get_request.access_token = access_token
+    liabilities_get_request.options = options_payload
+
+    response = client.liabilities_get(
+      liabilities_get_request
+    )
+    assert_equal(1, response.liabilities.student.size)
+  end
+
+  def test_get_invalid_access_token
+    liabilities_get_request = Plaid::LiabilitiesGetRequest.new
+    liabilities_get_request.access_token = BAD_STRING
+
+    begin
+      client.liabilities_get(liabilities_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_link_token.rb

@@ -0,0 +1,97 @@
+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 => "123-fake-user-id" },
+      :client_name => "Plaid Test",
+      :products => %w[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 => "123-fake-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 => %w[auth transactions],
+      :country_codes => ["GB"],
+      :language => "en",
+      :webhook => "https://sample-webhook.com",
+      :link_customization_name => "default",
+      :account_filters => {
+        :depository => {
+          :account_subtypes => %w[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 => "123-fake-user-id" },
+      :client_name => "Plaid Test",
+      :products => %w[auth transactions],
+      :country_codes => ["GB"],
+      :language => "en",
+      :webhook => "https://sample-webhook.com",
+      :link_customization_name => "default",
+      :account_filters => {
+        :depository => {
+          :account_subtypes => %w[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
+
+  # rubocop:enable Metrics/MethodLength
+end

data/test/test_payment_initiation.rb

@@ -0,0 +1,95 @@
+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::NullableRecipientBACS, 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_payment_list(payment_initiation_recipient_list_request)
+    refute_empty(list_recipients_response.payments)
+
+    # 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.last_status_update)
+    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