braintree 4.24.0 → 4.26.0

data/lib/braintree/graphql_client.rb

@@ -30,5 +30,21 @@ module Braintree
       body = Zlib::GzipReader.new(StringIO.new(body)).read if response.header["Content-Encoding"] == "gzip"
       JSON.parse(body, :symbolize_names => true)
     end
+
+    def self.get_validation_errors(response)
+      return nil unless response.key?(:errors) && response[:errors].is_a?(Array)
+      validation_errors = response[:errors].map do |error|
+        {
+          :attribute => "",
+          :code => get_validation_error_code(error),
+          :message => error[:message]
+        }
+      end
+      {errors: validation_errors}
+    end
+
+    def self.get_validation_error_code(error)
+      error[:extensions] && error[:extensions][:legacyCode] rescue nil
+    end
   end
 end

data/lib/braintree/meta_checkout_card.rb

@@ -22,6 +22,7 @@ module Braintree
       attr_reader :last_4
       attr_reader :payroll
       attr_reader :prepaid
+      attr_reader :prepaid_reloadable
       attr_reader :product_id
       attr_reader :subscriptions
       attr_reader :token
@@ -74,11 +75,11 @@ module Braintree
 
       def self._attributes # :nodoc:
         [
-          :bin, :card_type, :cardholder_name, :created_at,
-          :customer_id, :customer_location, :expiration_month, :expiration_year,
-          :last_4, :token, :updated_at, :prepaid, :payroll, :product_id,
-          :commercial, :debit, :durbin_regulated, :healthcare,
-          :country_of_issuance, :issuing_bank, :image_url, :container_id
+          :bin, :card_type, :cardholder_name, :commercial,
+          :container_id, :country_of_issuance, :created_at, :customer_id,
+          :customer_location, :debit, :durbin_regulated, :expiration_month,
+          :expiration_year, :healthcare, :image_url, :issuing_bank, :last_4, :payroll, :prepaid,
+          :prepaid_reloadable, :product_id, :token, :updated_at
         ]
       end
 

data/lib/braintree/meta_checkout_token.rb

@@ -24,6 +24,7 @@ module Braintree
       attr_reader :last_4
       attr_reader :payroll
       attr_reader :prepaid
+      attr_reader :prepaid_reloadable
       attr_reader :product_id
       attr_reader :token
       attr_reader :unique_number_identifier
@@ -73,11 +74,11 @@ module Braintree
 
       def self._attributes # :nodoc:
         [
-          :bin, :card_type, :cardholder_name, :created_at,
-          :customer_id, :customer_location, :expiration_month, :expiration_year,
-          :last_4, :token, :updated_at, :prepaid, :payroll, :product_id,
-          :commercial, :debit, :durbin_regulated, :healthcare, :ecommerce_indicator,
-          :country_of_issuance, :issuing_bank, :image_url, :container_id, :cryptogram
+          :bin, :card_type, :cardholder_name, :commercial, :container_id, :country_of_issuance,
+          :created_at, :cryptogram, :customer_id, :customer_location, :debit, :durbin_regulated,
+          :ecommerce_indicator, :expiration_month, :expiration_year, :healthcare, :image_url,
+          :issuing_bank, :last_4, :payroll, :prepaid, :prepaid_reloadable, :product_id, :token,
+          :updated_at
         ]
       end
 

data/lib/braintree/paypal_payment_resource.rb

@@ -0,0 +1,22 @@
+module Braintree
+    class PayPalPaymentResource
+        include BaseModule
+
+        def self.update(*args)
+            Configuration.gateway.paypal_payment_resource.update(*args)
+        end
+
+        class << self
+            protected :new
+            def _new(*args)
+              self.new(*args)
+            end
+        end
+
+        def initialize(gateway, attributes)
+            @gateway = gateway
+            set_instance_variables_from_hash(attributes)
+        end
+    end
+end
+

data/lib/braintree/paypal_payment_resource_gateway.rb

@@ -0,0 +1,36 @@
+module Braintree
+    class PayPalPaymentResourceGateway
+        include BaseModule
+
+        def initialize(gateway)
+            @gateway = gateway
+            @config = gateway.config
+            @config.assert_has_access_token_or_keys
+        end
+
+        def update(attributes)
+            Util.verify_keys(PayPalPaymentResourceGateway._update_signature, attributes)
+            response = @config.http.put("#{@config.base_merchant_path}/paypal/payment_resource", :paypal_payment_resource => attributes)
+            if response[:payment_method_nonce]
+                SuccessfulResult.new(:payment_method_nonce => PaymentMethodNonce._new(@gateway, response[:payment_method_nonce]))
+            elsif response[:api_error_response]
+                ErrorResult.new(@gateway, response[:api_error_response])
+            else
+                raise UnexpectedError, "expected :paypal_payment_resource or :api_error_response"
+            end
+        end
+
+        def self._update_signature
+            [
+                :amount,
+                {:amount_breakdown => [:discount, :handling, :insurance, :item_total, :shipping, :shipping_discount, :tax_total]},
+                :currency_iso_code, :custom_field, :description,
+                {:line_items => [:description, :image_url, :kind, :name, :product_code, :quantity, :total_amount, :unit_amount, :unit_tax_amount, :url]},
+                :order_id, :payee_email, :payment_method_nonce,
+                {:shipping => [:country_name, :country_code_alpha2, :country_code_alpha3, :country_code_numeric, :extended_address, :first_name, {:international_phone => [:country_code, :national_number]},
+                :last_name, :locality, :postal_code, :region, :street_address]},
+                {:shipping_options => [:amount, :id, :label, :selected, :type]}
+            ]
+        end
+    end
+end

data/lib/braintree/successful_result.rb

@@ -24,6 +24,8 @@ module Braintree
     attr_reader :supported_networks
     attr_reader :transaction
     attr_reader :us_bank_account_verification
+    attr_reader :session_id
+    attr_reader :customer_recommendations
 
     def initialize(attributes = {})
       @attrs = attributes.keys

data/lib/braintree/test/credit_card.rb

@@ -3,6 +3,7 @@ module Braintree
     module CreditCardNumbers
       module CardTypeIndicators
         Prepaid           = "4111111111111210"
+        PrepaidReloadable = "4229989900000002"
         Commercial        = "4111111111131010"
         Payroll           = "4111111114101010"
         Healthcare        = "4111111510101010"

data/lib/braintree/transaction/apple_pay_details.rb

@@ -21,6 +21,7 @@ module Braintree
       attr_reader :payment_instrument_name
       attr_reader :payroll
       attr_reader :prepaid
+      attr_reader :prepaid_reloadable
       attr_reader :product_id
       attr_reader :source_card_last4
       attr_reader :source_description

data/lib/braintree/transaction/credit_card_details.rb

@@ -20,6 +20,7 @@ module Braintree
       attr_reader :last_4
       attr_reader :payroll
       attr_reader :prepaid
+      attr_reader :prepaid_reloadable
       attr_reader :product_id
       attr_reader :token
       attr_reader :unique_number_identifier
@@ -34,23 +35,24 @@ module Braintree
 
       def inspect
         attr_order = [
-          :token,
           :bin,
-          :last_4,
           :card_type,
-          :expiration_date,
           :cardholder_name,
+          :commercial,
+          :country_of_issuance,
           :customer_location,
-          :prepaid,
-          :healthcare,
-          :durbin_regulated,
           :debit,
-          :commercial,
+          :durbin_regulated,
+          :expiration_date,
+          :healthcare,
+          :image_url,
+          :issuing_bank,
+          :last_4,
           :payroll,
+          :prepaid,
+          :prepaid_reloadable,
           :product_id,
-          :country_of_issuance,
-          :issuing_bank,
-          :image_url,
+          :token,
           :unique_number_identifier,
         ]
 

data/lib/braintree/transaction/google_pay_details.rb

@@ -5,27 +5,28 @@ module Braintree
 
       attr_reader :bin
       attr_reader :card_type
+      attr_reader :commercial
+      attr_reader :country_of_issuance
+      attr_reader :debit
+      attr_reader :durbin_regulated
       attr_reader :expiration_month
       attr_reader :expiration_year
+      attr_reader :global_id
       attr_reader :google_transaction_id
+      attr_reader :healthcare
       attr_reader :image_url
+      attr_reader :issuing_bank
       attr_reader :last_4
+      attr_reader :payroll
+      attr_reader :prepaid
+      attr_reader :prepaid_reloadable
+      attr_reader :product_id
       attr_reader :source_card_last_4
       attr_reader :source_card_type
       attr_reader :source_description
       attr_reader :token
       attr_reader :virtual_card_last_4
       attr_reader :virtual_card_type
-      attr_reader :prepaid
-      attr_reader :healthcare
-      attr_reader :debit
-      attr_reader :durbin_regulated
-      attr_reader :commercial
-      attr_reader :payroll
-      attr_reader :issuing_bank
-      attr_reader :country_of_issuance
-      attr_reader :product_id
-      attr_reader :global_id
 
       def initialize(attributes)
         set_instance_variables_from_hash attributes unless attributes.nil?

data/lib/braintree/transaction/meta_checkout_card_details.rb

@@ -22,6 +22,7 @@ module Braintree
         attr_reader :last_4
         attr_reader :payroll
         attr_reader :prepaid
+        attr_reader :prepaid_reloadable
         attr_reader :product_id
         attr_reader :token
         attr_reader :unique_number_identifier
@@ -36,8 +37,10 @@ module Braintree
         end
 
         def inspect
-          attr_order = [:token, :bin, :last_4, :card_type, :expiration_date, :cardholder_name, :customer_location, :prepaid,
-          :healthcare, :durbin_regulated, :debit, :commercial, :payroll, :product_id, :country_of_issuance, :issuing_bank, :image_url, :container_id]
+          attr_order = [
+            :bin, :card_type, :cardholder_name, :commercial, :container_id, :country_of_issuance,
+            :customer_location, :debit, :durbin_regulated, :expiration_date, :healthcare, :image_url,
+            :issuing_bank, :last_4, :payroll, :prepaid, :prepaid_reloadable, :product_id, :token]
           formatted_attrs = attr_order.map do |attr|
             "#{attr}: #{send(attr).inspect}"
           end

data/lib/braintree/transaction/meta_checkout_token_details.rb

@@ -24,6 +24,7 @@ module Braintree
         attr_reader :last_4
         attr_reader :payroll
         attr_reader :prepaid
+        attr_reader :prepaid_reloadable
         attr_reader :product_id
         attr_reader :token
         attr_reader :unique_number_identifier
@@ -38,8 +39,11 @@ module Braintree
         end
 
         def inspect
-          attr_order = [:container_id, :cryptogram, :ecommerce_indicator, :token, :bin, :last_4, :card_type, :expiration_date, :cardholder_name, :customer_location, :prepaid,
-          :healthcare, :durbin_regulated, :debit, :commercial, :payroll, :product_id, :country_of_issuance, :issuing_bank, :is_network_tokenized, :image_url]
+          attr_order = [
+            :bin, :card_type, :cardholder_name, :commercial, :container_id, :country_of_issuance,
+            :cryptogram, :customer_location, :debit, :durbin_regulated, :ecommerce_indicator,
+            :expiration_date, :healthcare, :image_url, :is_network_tokenized, :issuing_bank, :last_4,
+            :payroll, :prepaid, :prepaid_reloadable, :product_id, :token]
           formatted_attrs = attr_order.map do |attr|
             "#{attr}: #{send(attr).inspect}"
           end

data/lib/braintree/transaction/visa_checkout_card_details.rb

@@ -20,6 +20,7 @@ module Braintree
       attr_reader :last_4
       attr_reader :payroll
       attr_reader :prepaid
+      attr_reader :prepaid_reloadable
       attr_reader :product_id
       attr_reader :token
 
@@ -32,8 +33,10 @@ module Braintree
       end
 
       def inspect
-        attr_order = [:token, :bin, :last_4, :card_type, :expiration_date, :cardholder_name, :customer_location, :prepaid,
-        :healthcare, :durbin_regulated, :debit, :commercial, :payroll, :product_id, :country_of_issuance, :issuing_bank, :image_url, :call_id]
+        attr_order = [
+          :bin, :call_id, :card_type, :cardholder_name, :commercial, :country_of_issuance, :customer_location,
+          :debit, :durbin_regulated, :expiration_date, :healthcare, :image_url, :issuing_bank, :last_4, :payroll,
+          :prepaid, :prepaid_reloadable, :product_id, :token]
         formatted_attrs = attr_order.map do |attr|
           "#{attr}: #{send(attr).inspect}"
         end

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 4
-    Minor = 24
+    Minor = 26
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/lib/braintree/visa_checkout_card.rb

@@ -23,6 +23,7 @@ module Braintree
     attr_reader :last_4
     attr_reader :payroll
     attr_reader :prepaid
+    attr_reader :prepaid_reloadable
     attr_reader :product_id
     attr_reader :subscriptions
     attr_reader :token
@@ -75,11 +76,10 @@ module Braintree
 
     def self._attributes
       [
-        :billing_address, :bin, :card_type, :cardholder_name, :created_at,
-        :customer_id, :customer_location, :expiration_month, :expiration_year,
-        :last_4, :token, :updated_at, :prepaid, :payroll, :product_id,
-        :commercial, :debit, :durbin_regulated, :healthcare,
-        :country_of_issuance, :issuing_bank, :image_url, :call_id
+        :bin, :billing_address, :card_type, :cardholder_name, :commercial, :container_id, :country_of_issuance,
+        :created_at, :customer_id, :customer_location, :debit, :durbin_regulated, :expiration_month,
+        :expiration_year, :healthcare, :image_url, :issuing_bank, :last_4, :payroll, :prepaid,
+        :prepaid_reloadable, :product_id, :token, :updated_at
       ]
     end
 

data/lib/braintree.rb

@@ -51,6 +51,7 @@ require "braintree/customer"
 require "braintree/customer_gateway"
 require "braintree/granted_payment_instrument_update"
 require "braintree/customer_search"
+require "braintree/customer_session_gateway"
 require "braintree/descriptor"
 require "braintree/digest"
 require "braintree/discount"
@@ -75,6 +76,16 @@ require "braintree/exchange_rate_quote_input"
 require "braintree/exchange_rate_quote_response"
 require "braintree/exchange_rate_quote_request"
 require "braintree/gateway"
+require "braintree/graphql/enums/recommendations"
+require "braintree/graphql/enums/recommended_payment_option"
+require "braintree/graphql/inputs/create_customer_session_input"
+require "braintree/graphql/inputs/customer_recommendations_input"
+require "braintree/graphql/inputs/customer_session_input"
+require "braintree/graphql/inputs/phone_input"
+require "braintree/graphql/inputs/update_customer_session_input"
+require "braintree/graphql/types/customer_recommendations_payload"
+require "braintree/graphql/types/payment_options"
+require "braintree/graphql/unions/customer_recommendations"
 require "braintree/graphql_client"
 require "braintree/google_pay_card"
 require "braintree/local_payment_completed"
@@ -106,6 +117,8 @@ require "braintree/payment_method_nonce_gateway"
 require "braintree/payment_method_parser"
 require "braintree/paypal_account"
 require "braintree/paypal_account_gateway"
+require "braintree/paypal_payment_resource"
+require "braintree/paypal_payment_resource_gateway"
 require "braintree/plan"
 require "braintree/plan_gateway"
 require "braintree/processor_response_types"

data/spec/integration/braintree/credit_card_spec.rb

@@ -449,6 +449,18 @@ describe Braintree::CreditCard do
         expect(credit_card.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
       end
 
+      it "sets the prepaid reloadable field if the card is prepaid reloadable" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+      end
+
       it "sets the healthcare field if the card is healthcare" do
         customer = Braintree::Customer.create!
         result = Braintree::CreditCard.create(

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -322,6 +322,30 @@ describe Braintree::CreditCardVerification, "search" do
         found_verification = Braintree::CreditCardVerification.find(verification_id)
         expect(found_verification.credit_card[:prepaid]).to eq(Braintree::CreditCard::Prepaid::Yes)
       end
+
+      it "returns prepaid_reloadable on a prepaid card" do
+        cardholder_name = "Tom #{rand(1_000_000)} Smith"
+
+        Braintree::Customer.create(
+          :credit_card => {
+          :cardholder_name => cardholder_name,
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+          :cvv => "200",
+          :options => {
+            :verify_card => true
+        }
+        })
+
+        search_results = Braintree::CreditCardVerification.search do |search|
+          search.credit_card_cardholder_name.is cardholder_name
+        end
+
+        verification_id = search_results.first.id
+
+        found_verification = Braintree::CreditCardVerification.find(verification_id)
+        expect(found_verification.credit_card[:prepaid_reloadable]).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+      end
     end
   end
 

data/spec/integration/braintree/customer_session_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::CustomerSessionGateway do
+  let(:gateway) do
+    Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "pwpp_multi_account_merchant",
+      :public_key => "pwpp_multi_account_merchant_public_key",
+      :private_key => "pwpp_multi_account_merchant_private_key",
+    )
+  end
+
+  describe "create" do
+    it "can create customer session without email and phone" do
+      input = Braintree::CreateCustomerSessionInput.new(merchant_account_id: "usd_pwpp_multi_account_merchant_account")
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).not_to be_nil
+    end
+
+    it "can can create customer session with merchant provided session id" do
+      merchant_session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
+      input = Braintree::CreateCustomerSessionInput.new(
+        session_id: merchant_session_id,
+      )
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).to eq(merchant_session_id)
+    end
+
+    it "can create customer session with API-derived session id" do
+      input = Braintree::CreateCustomerSessionInput.new({})
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).not_to be_nil
+    end
+
+    it "cannot create duplicate customer session" do
+      existing_session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
+      input = Braintree::CreateCustomerSessionInput.new(
+        session_id: existing_session_id,
+      )
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("Session IDs must be unique per merchant.")
+    end
+  end
+
+  describe "update" do
+    it "can update a customer session" do
+      session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
+      create_input = Braintree::CreateCustomerSessionInput.new(
+        merchant_account_id: "usd_pwpp_multi_account_merchant_account",
+        session_id: session_id,
+      )
+
+      gateway.customer_session.create_customer_session(create_input)
+
+      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
+
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+
+      result = gateway.customer_session.update_customer_session(update_input)
+
+      expect(result.success?).to eq(true)
+      expect(result.session_id).to eq(session_id)
+
+    end
+
+    it "cannot update a non-existent customer session" do
+      session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
+      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+
+      result = gateway.customer_session.update_customer_session(update_input)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("does not exist")
+    end
+  end
+
+  describe "customer recommendations" do
+    it "can get customer recommendations" do
+      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
+      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        session_id: "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC",
+        recommendations: recommendations,
+        customer: customer,
+      )
+      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      expect(result.success?).to eq(true)
+      payload = result.customer_recommendations
+      expect(payload.is_in_paypal_network).to eq(true)
+      payment_options = payload.recommendations.payment_options
+      expect(payment_options[0].payment_option).to eq(Braintree::RecommendedPaymentOption::PAYPAL)
+      expect(payment_options[0].recommended_priority).to equal(1)
+    end
+
+    it "cannot get customer recommendations for non-existent session" do
+      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
+      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        session_id: "11EF-34BC-2702904B-9026-C3ECF4BAC765",
+        recommendations: recommendations,
+        customer: customer,
+      )
+      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("does not exist")
+    end
+  end
+
+  private
+
+  def build_customer_session(session_id = nil)
+    customer = build_customer_session_input("PR1_test@example.com", "4085005002")
+
+    input = session_id ? CreateCustomerSessionInput.new(customer: customer, session_id: session_id) : CreateCustomerSessionInput.new(customer => customer)
+    @gateway.customer_session.create_customer_session(input)
+  end
+
+  def build_customer_session_input(email, phone_number)
+    {
+      email: email,
+      device_fingerprint_id: "test",
+      phone: {country_phone_code: "1", phone_number: phone_number},
+      paypal_app_installed: true,
+      venmo_app_installed: true,
+      user_agent: "Mozilla"
+    }
+  end
+
+end

data/spec/integration/braintree/customer_spec.rb

@@ -991,18 +991,19 @@ describe Braintree::Customer do
       expect(found_customer.apple_pay_cards).not_to be_nil
       apple_pay_card = found_customer.apple_pay_cards.first
       expect(apple_pay_card).to be_a Braintree::ApplePayCard
-      expect(apple_pay_card.token).not_to be_nil
-      expect(apple_pay_card.expiration_year).not_to be_nil
-      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
       expect(apple_pay_card.commercial).not_to be_nil
       expect(apple_pay_card.country_of_issuance).not_to be_nil
       expect(apple_pay_card.debit).not_to be_nil
       expect(apple_pay_card.durbin_regulated).not_to be_nil
+      expect(apple_pay_card.expiration_year).not_to be_nil
       expect(apple_pay_card.healthcare).not_to be_nil
       expect(apple_pay_card.issuing_bank).not_to be_nil
+      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
       expect(apple_pay_card.payroll).not_to be_nil
       expect(apple_pay_card.prepaid).not_to be_nil
+      expect(apple_pay_card.prepaid_reloadable).not_to be_nil
       expect(apple_pay_card.product_id).not_to be_nil
+      expect(apple_pay_card.token).not_to be_nil
     end
 
     it "returns associated google pay proxy cards" do
@@ -1016,18 +1017,19 @@ describe Braintree::Customer do
       expect(found_customer.payment_methods.size).to eq(1)
       google_pay_card = found_customer.google_pay_cards.first
       expect(google_pay_card).to be_a Braintree::GooglePayCard
-      expect(google_pay_card.token).not_to be_nil
-      expect(google_pay_card.expiration_year).not_to be_nil
-      expect(google_pay_card.is_network_tokenized?).to eq(false)
       expect(google_pay_card.commercial).not_to be_nil
       expect(google_pay_card.country_of_issuance).not_to be_nil
       expect(google_pay_card.debit).not_to be_nil
       expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.expiration_year).not_to be_nil
       expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.is_network_tokenized?).to eq(false)
       expect(google_pay_card.issuing_bank).not_to be_nil
       expect(google_pay_card.payroll).not_to be_nil
       expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.prepaid_reloadable).not_to be_nil
       expect(google_pay_card.product_id).not_to be_nil
+      expect(google_pay_card.token).not_to be_nil
     end
 
     it "returns associated google pay network tokens" do
@@ -1052,6 +1054,7 @@ describe Braintree::Customer do
       expect(google_pay_card.issuing_bank).not_to be_nil
       expect(google_pay_card.payroll).not_to be_nil
       expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.prepaid_reloadable).not_to be_nil
       expect(google_pay_card.product_id).not_to be_nil
     end
 
@@ -1912,4 +1915,17 @@ describe Braintree::Customer do
       end
     end
   end
+
+  it "returns prepaid_reloadable from VisaCheckoutCard" do
+    result = Braintree::Customer.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+    )
+    expect(result.success?).to eq(true)
+
+    found_customer = Braintree::Customer.find(result.customer.id)
+    expect(found_customer.visa_checkout_cards).not_to be_nil
+    visa_checkout_card = found_customer.visa_checkout_cards.first
+    expect(visa_checkout_card).to be_a Braintree::VisaCheckoutCard
+    expect(visa_checkout_card.prepaid_reloadable).not_to be_nil
+  end
 end