braintree 4.25.0 → 4.27.0

data/spec/integration/braintree/transaction_spec.rb

@@ -267,6 +267,19 @@ describe Braintree::Transaction do
         expect(result.transaction.credit_card_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
         expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
       end
+
+      it "sets the prepaid_reloadable field if the card is prepaid reloadable" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
     end
 
     describe "sca_exemption" do
@@ -1974,108 +1987,6 @@ describe Braintree::Transaction do
       end
     end
 
-    context "service fees" do
-      it "allows specifying service fees" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(true)
-        expect(result.transaction.service_fee_amount).to eq(BigDecimal("1.00"))
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::ServiceFeeAmountNotAllowedOnMasterMerchantAccount
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if no service fee is present on a sub merchant account transaction" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::SubMerchantAccountRequiresServiceFeeAmount
-        expect(result.errors.for(:transaction).on(:merchant_account_id)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if service fee amount is negative" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "-1.00",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountCannotBeNegative)
-      end
-
-      it "raises an error if service fee amount is invalid" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "invalid amount",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountFormatIsInvalid)
-      end
-    end
-
-    context "escrow" do
-      it "allows specifying transactions to be held for escrow" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "10.00",
-          :options => {:hold_in_escrow => true},
-        )
-
-        expect(result.success?).to eq(true)
-        expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-          :options => {:hold_in_escrow => true},
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
-        expect(result.errors.for(:transaction).on(:base)[0].code).to eq(expected_error_code)
-      end
-    end
-
     context "client API" do
       it "can create a transaction with a shared card nonce" do
         nonce = nonce_for_new_payment_method(
@@ -2183,6 +2094,7 @@ describe Braintree::Transaction do
         meta_checkout_card_details.last_4.should == "1881"
         meta_checkout_card_details.masked_number.should == "401288******1881"
         meta_checkout_card_details.prepaid.should == "No"
+        meta_checkout_card_details.prepaid_reloadable.should == "Unknown"
       end
 
       it "can create a transaction with a fake meta checkout token nonce" do
@@ -2213,6 +2125,7 @@ describe Braintree::Transaction do
         meta_checkout_token_details.last_4.should == "1881"
         meta_checkout_token_details.masked_number.should == "401288******1881"
         meta_checkout_token_details.prepaid.should == "No"
+        meta_checkout_token_details.prepaid_reloadable.should == "Unknown"
       end
 
       it "can create a transaction with a fake apple pay nonce" do
@@ -5724,7 +5637,6 @@ describe Braintree::Transaction do
       end
     end
 
-
     context "3rd party Card on File Network Token" do
       it "Works with all params" do
         params = {
@@ -6119,24 +6031,6 @@ describe Braintree::Transaction do
       expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement)
     end
 
-    context "service fees" do
-      it "returns an error result if amount submitted for settlement is less than service fee amount" do
-        transaction = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "06/2009"
-          },
-          :service_fee_amount => "1.00",
-        ).transaction
-        result = Braintree::Transaction.submit_for_settlement(transaction.id, "0.01")
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount)
-      end
-    end
-
     it "succeeds when industry data is provided" do
       transaction = Braintree::Transaction.create(
         :type => "sale",
@@ -6700,101 +6594,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.release_from_escrow" do
-    it "returns the transaction if successful" do
-      original_transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.release_from_escrow(original_transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "returns an error result if escrow_status is not HeldForEscrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotReleaseFromEscrow)
-    end
-  end
-
-  describe "self.release_from_escrow!" do
-    it "returns the transaction when successful" do
-      original_transaction = create_escrowed_transcation
-
-      transaction = Braintree::Transaction.release_from_escrow!(original_transaction.id)
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "raises an error when transaction is not successful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      expect do
-        Braintree::Transaction.release_from_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  describe "self.cancel_release" do
-    it "returns the transaction if successful" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "returns an error result if escrow_status is not ReleasePending" do
-      transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(false)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotCancelRelease)
-    end
-  end
-
-  describe "self.cancel_release!" do
-    it "returns the transaction when release is cancelled" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      transaction = Braintree::Transaction.cancel_release!(transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "raises an error when release cannot be cancelled" do
-      transaction = create_escrowed_transcation
-
-      expect {
-        transaction = Braintree::Transaction.cancel_release!(transaction.id)
-      }.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.credit" do
     it "returns a successful result with type=credit if successful" do
       result = Braintree::Transaction.credit(
@@ -7080,76 +6879,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.hold_in_escrow" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      result = Braintree::Transaction.hold_in_escrow(result.transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "returns an error result if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      result = Braintree::Transaction.hold_in_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotHoldInEscrow)
-    end
-  end
-
-  describe "self.hold_in_escrow!" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      transaction = Braintree::Transaction.hold_in_escrow!(result.transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "raises an error if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      expect do
-        Braintree::Transaction.hold_in_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(
@@ -7359,24 +7088,6 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
-  def create_escrowed_transcation
-    transaction = Braintree::Transaction.sale!(
-      :amount => Braintree::Test::TransactionAmounts::Authorize,
-      :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-      :credit_card => {
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
-      },
-      :service_fee_amount => "1.00",
-      :options => {:hold_in_escrow => true},
-    )
-
-    config = Braintree::Configuration.instantiate
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/escrow")
-    Braintree::Transaction.find(transaction.id)
-  end
-
   context "paypal" do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(
@@ -8007,4 +7718,4 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -34,13 +34,13 @@ unless defined?(SPEC_HELPER_LOADED)
     AibSwedenMaMerchantAccountId = "aib_swe_ma"
     AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
     CardProcessorBRLMerchantAccountId = "card_processor_brl"
+    CardProcessorBRLPayFacMerchantAccountId = "card_processor_brl_payfac"
     DefaultMerchantAccountId = "sandbox_credit_card"
     FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
     FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
     FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
     HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
-    NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
     PinlessDebitMerchantAccountId = "pinless_debit"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -39,6 +39,7 @@ describe Braintree::ApplePayCard do
       :payment_instrument_name => nil,
       :payroll => "No",
       :prepaid => "No",
+      :prepaid_reloadable => "No",
       :product_id => "MAC",
       :source_card_last4 => "1234",
       :source_description => "blah",

data/spec/unit/braintree/configuration_spec.rb

@@ -399,7 +399,7 @@ describe Braintree::Configuration do
 
     it "is qa.braintreegateway.com for qa" do
       Braintree::Configuration.environment = :qa
-      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa2.braintreepayments.com")
+      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa.braintreepayments.com")
     end
 
     it "can by changed by configuring the production endpoint" do

data/spec/unit/braintree/credit_card_spec.rb

@@ -266,4 +266,9 @@ describe Braintree::CreditCard do
       end
     end
   end
+
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
 end

data/spec/unit/braintree/google_pay_card_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::GooglePayCard do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
+end

data/spec/unit/braintree/meta_checkout_card_spec.rb

@@ -1,60 +1,62 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::MetaCheckoutCard do
-    let(:attributes) do {
+  let(:attributes) do {
 
-        :bin => "abc1234",
-        :container_id => "a-container-id",
-        :card_type => "Visa",
-        :cardholder_name => "Meta Checkout Card CardHolder",
-        :commercial => "NO",
-        :country_of_issuance => "US",
-        :created_at => "2023-05-05T21:28:37Z",
-        :debit => "NO",
-        :durbin_regulated => "NO",
-        :expiration_month => "05",
-        :expiration_year => "2024",
-        :healthcare => "NO",
-        :last_4 => "1234",
-        :payroll => "NO",
-        :prepaid => "NO",
-        :token => "token1",
-        :unique_number_identifier => "abc1234",
-        :updated_at => "2023-05-05T21:28:37Z"
-    }
-    end
+    :bin => "abc1234",
+    :card_type => "Visa",
+    :cardholder_name => "Meta Checkout Card CardHolder",
+    :commercial => "NO",
+    :container_id => "a-container-id",
+    :country_of_issuance => "US",
+    :created_at => "2023-05-05T21:28:37Z",
+    :debit => "NO",
+    :durbin_regulated => "NO",
+    :expiration_month => "05",
+    :expiration_year => "2024",
+    :healthcare => "NO",
+    :last_4 => "1234",
+    :payroll => "NO",
+    :prepaid => "NO",
+    :prepaid_reloadable => "NO",
+    :token => "token1",
+    :unique_number_identifier => "abc1234",
+    :updated_at => "2023-05-05T21:28:37Z"
+  }
+  end
 
-    describe "unit tests" do
-        it "initializes with the correct attributes" do
-            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+  describe "unit tests" do
+    it "initializes with the correct attributes" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
 
-            card.bin.should == "abc1234"
-            card.container_id.should == "a-container-id"
-            card.card_type.should == "Visa"
-            card.cardholder_name.should == "Meta Checkout Card CardHolder"
-            card.commercial == "NO"
-            card.country_of_issuance == "US"
-            card.created_at == "2023-05-05T21:28:37Z"
-            card.updated_at == "2023-05-05T21:28:37Z"
-            card.debit == "NO"
-            card.payroll == "NO"
-            card.prepaid == "NO"
-            card.healthcare == "NO"
-            card.token == "token1"
-            card.unique_number_identifier == "abc1234"
-            card.expiration_month.should == "05"
-            card.expiration_year.should == "2024"
-            card.last_4.should == "1234"
-        end
+      card.bin.should == "abc1234"
+      card.card_type.should == "Visa"
+      card.cardholder_name.should == "Meta Checkout Card CardHolder"
+      card.commercial == "NO"
+      card.container_id.should == "a-container-id"
+      card.country_of_issuance == "US"
+      card.created_at == "2023-05-05T21:28:37Z"
+      card.debit == "NO"
+      card.expiration_month.should == "05"
+      card.expiration_year.should == "2024"
+      card.healthcare == "NO"
+      card.last_4.should == "1234"
+      card.payroll == "NO"
+      card.prepaid == "NO"
+      card.prepaid_reloadable == "NO"
+      card.token == "token1"
+      card.unique_number_identifier == "abc1234"
+      card.updated_at == "2023-05-05T21:28:37Z"
+    end
 
-        it "sets expiration date correctly" do
-            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
-            card.expiration_date.should == "05/2024"
-        end
+    it "sets expiration date correctly" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+      card.expiration_date.should == "05/2024"
+    end
 
-        it "masks the card number correctly" do
-            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
-            card.masked_number.should == "abc1234******1234"
-        end
+    it "masks the card number correctly" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+      card.masked_number.should == "abc1234******1234"
     end
-end
+  end
+end

data/spec/unit/braintree/meta_checkout_token_spec.rb

@@ -17,6 +17,7 @@ describe Braintree::MetaCheckoutToken do
         :last_4 => "1234",
         :payroll => "NO",
         :prepaid => "NO",
+        :prepaid_reloadable => "NO",
         :token => "token1",
         :unique_number_identifier => "abc1234",
         :updated_at => "2023-05-05T21:28:37Z",
@@ -40,6 +41,7 @@ describe Braintree::MetaCheckoutToken do
             card.debit == "NO"
             card.payroll == "NO"
             card.prepaid == "NO"
+            card.prepaid_reloadable == "NO"
             card.healthcare == "NO"
             card.token == "token1"
             card.unique_number_identifier == "abc1234"
@@ -60,4 +62,4 @@ describe Braintree::MetaCheckoutToken do
             card.masked_number.should == "abc1234******1234"
         end
     end
-end
+end

data/spec/unit/braintree/payment_method_nonce_spec.rb

@@ -15,7 +15,8 @@ describe Braintree::PaymentMethodNonce do
         :liability_shifted => false
       },
       :bin_data => {
-        :country_of_issuance => "USA"
+        :country_of_issuance => "USA",
+        :prepaid_reloadable => "Yes"
       },
     )
   }
@@ -29,6 +30,8 @@ describe Braintree::PaymentMethodNonce do
       expect(payment_method_nonce.three_d_secure_info.liability_shift_possible).to be false
       expect(payment_method_nonce.three_d_secure_info.liability_shifted).to be false
       expect(payment_method_nonce.bin_data.country_of_issuance).to eq("USA")
+      expect(payment_method_nonce.bin_data.prepaid_reloadable).to eq("Yes")
+
     end
   end