braintree 4.40.0 → 4.42.0

data/spec/integration/braintree/credit_card_spec.rb

@@ -529,6 +529,37 @@ describe Braintree::CreditCard do
       expect(result.success?).to eq(true)
     end
 
+    it "can set the mastercard transaction link identifier when creating a credit card" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :mastercard_transaction_link_id => "1234567890123456789012",
+        },
+      )
+
+      expect(result.success?).to eq(true)
+    end
+
+    it "rejects a mastercard transaction link identifier that is not 22 characters" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :mastercard_transaction_link_id => "1234567890123456789012123",
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:credit_card).for(:external_vault).on(:mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::CreditCard::ExternalVault::MastercardTransactionLinkIdIsInvalid)
+    end
+
     context "card type indicators" do
       it "sets the prepaid field if the card is prepaid" do
         customer = Braintree::Customer.create!

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -147,6 +147,60 @@ describe Braintree::CreditCardVerification, "search" do
       expect(result.credit_card_verification.network_transaction_id).not_to be_nil
     end
 
+    it "creates a new verification with previous_mastercard_transaction_link_id" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "vaulted",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result).to be_success
+      expect(result.credit_card_verification.id).to match(/^\w{6,}$/)
+    end
+
+    it "rejects non-vaulted status with previous_mastercard_transaction_link_id" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "will_vault",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:verification).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Verification::ExternalVault::StatusWithPreviousMastercardTransactionLinkIdIsInvalid)
+    end
+
+    it "rejects previous_mastercard_transaction_link_id that is not 22 characters" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "vaulted",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012123",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:verification).for(:external_vault).on(:previous_mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::Verification::ExternalVault::PreviousMastercardTransactionLinkIdIsInvalid)
+    end
+
     it "creates a new verification from risk data param" do
       verification_params = {
         :credit_card => {

data/spec/integration/braintree/customer_spec.rb

@@ -102,6 +102,21 @@ describe Braintree::Customer do
       expect(result).to be_success
     end
 
+    it "supports creation with a mastercard_transaction_link_id external_vault param" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :external_vault => {
+            :mastercard_transaction_link_id => "1234567890123456789012",
+          },
+        },
+      )
+
+      expect(result).to be_success
+    end
+
     it "supports creation including risk data with customer_browser and customer_ip" do
       result = Braintree::Customer.create(
         :credit_card => {
@@ -2677,4 +2692,47 @@ describe Braintree::Customer do
     end
   end
 
+  describe "path traversal" do
+    it "self.update rejects a traversal customer_id and does not void the victim transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {:submit_for_settlement => false},
+      )
+      traversal_id = "../transactions/#{transaction.id}/void"
+
+      expect do
+        Braintree::Customer.update(traversal_id, :first_name => "HackerOne")
+      end.to raise_error(ArgumentError, "customer_id contains invalid characters")
+
+      unaffected_transaction = Braintree::Transaction.find(transaction.id)
+      expect(unaffected_transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+
+    it "self.delete rejects a traversal customer_id and does not delete the victim payment method" do
+      create_result = Braintree::Customer.create(:first_name => "Victim")
+      expect(create_result.success?).to eq(true)
+      customer = create_result.customer
+
+      credit_card_result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+      )
+      expect(credit_card_result.success?).to eq(true)
+      token = credit_card_result.credit_card.token
+      traversal_id = "../payment_methods/any/#{token}"
+
+      expect do
+        Braintree::Customer.delete(traversal_id)
+      end.to raise_error(ArgumentError, "customer_id contains invalid characters")
+
+      unaffected_credit_card = Braintree::CreditCard.find(token)
+      expect(unaffected_credit_card.token).to eq(token)
+    end
+  end
+
 end

data/spec/integration/braintree/transaction_idempotency_spec.rb

@@ -277,6 +277,36 @@ describe Braintree::Transaction, "idempotency" do
     end
   end
 
+  describe "reverse" do
+    it "returns original reverse on duplicate request with same api_request_key" do
+      api_request_key = "reverse-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      reverse_options = {
+        :api_request_key => api_request_key
+      }
+
+      reverse_result1 = Braintree::Transaction.reverse(transaction_id, reverse_options)
+      expect(reverse_result1).to be_success
+
+      reverse_result2 = Braintree::Transaction.reverse(transaction_id, reverse_options)
+      expect(reverse_result2).to be_success
+      expect(reverse_result1.transaction.id).to eq(reverse_result2.transaction.id)
+      expect(reverse_result2.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+    end
+  end
+
   describe "refund" do
     it "returns original refund on duplicate request with same api_request_key" do
       api_request_key = "refund-idempotency-key-#{rand(1000000)}"

data/spec/integration/braintree/transaction_search_spec.rb

@@ -257,6 +257,93 @@ describe Braintree::Transaction, "search" do
         expect(collection.maximum_size).to eq(0)
       end
 
+      it "searches on ach_type" do
+        same_day_transaction = Braintree::Transaction.find("sameday_ach_sameday_requested")
+        standard_transaction = Braintree::Transaction.find("standard_ach_standard_requested")
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is same_day_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::SameDay
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(same_day_transaction.id)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is same_day_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::Standard
+        end
+
+        expect(collection.maximum_size).to eq(0)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is standard_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::Standard
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(standard_transaction.id)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is standard_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::SameDay
+        end
+
+        expect(collection.maximum_size).to eq(0)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is same_day_transaction.id
+          search.ach_type.in [
+            Braintree::Transaction::AchType::SameDay,
+            Braintree::Transaction::AchType::Standard
+          ]
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(same_day_transaction.id)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is standard_transaction.id
+          search.ach_type.in [
+            Braintree::Transaction::AchType::SameDay,
+            Braintree::Transaction::AchType::Standard
+          ]
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(standard_transaction.id)
+
+        divergent_transaction = Braintree::Transaction.find("standard_ach_sameday_requested")
+        expect(divergent_transaction.ach_type).to eq(Braintree::Transaction::AchType::Standard)
+        expect(divergent_transaction.requested_ach_type).to eq(Braintree::Transaction::AchType::SameDay)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is divergent_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::Standard
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(divergent_transaction.id)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is divergent_transaction.id
+          search.ach_type.is Braintree::Transaction::AchType::SameDay
+        end
+
+        expect(collection.maximum_size).to eq(0)
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is divergent_transaction.id
+          search.ach_type.in [
+            Braintree::Transaction::AchType::SameDay,
+            Braintree::Transaction::AchType::Standard
+          ]
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(divergent_transaction.id)
+      end
+
       it "searches on credit_card_customer_location" do
         transaction = Braintree::Transaction.sale!(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -661,6 +748,14 @@ describe Braintree::Transaction, "search" do
           end
         end.to raise_error(ArgumentError)
       end
+
+      it "raises an exception on invalid ach_type" do
+        expect do
+          Braintree::Transaction.search do |search|
+            search.ach_type.is "invalid_ach_type"
+          end
+        end.to raise_error(ArgumentError)
+      end
     end
 
     context "range fields" do

data/spec/integration/braintree/transaction_spec.rb

@@ -5013,6 +5013,23 @@ describe Braintree::Transaction do
           expect(result.transaction.network_transaction_id).not_to be_nil
         end
 
+        it "accepts previous_mastercard_transaction_link_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(true)
+          expect(result.transaction.network_transaction_id).not_to be_nil
+        end
+
         it "rejects non-vaulted status with previous_network_transaction_id" do
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -5029,6 +5046,40 @@ describe Braintree::Transaction do
           expect(result.success?).to eq(false)
           expect(result.errors.for(:transaction).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::StatusWithPreviousNetworkTransactionIdIsInvalid)
         end
+
+        it "rejects non-vaulted status with previous_mastercard_transaction_link_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::StatusWithPreviousMastercardTransactionLinkIdIsInvalid)
+        end
+
+        it "rejects previous_mastercard_transaction_link_id that is not 22 characters" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012123",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:external_vault).on(:previous_mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::PreviousMastercardTransactionLinkIdIsInvalid)
+        end
       end
 
       context "Non-(Visa/Mastercard/Discover/AmEx) card types" do
@@ -5233,6 +5284,28 @@ describe Braintree::Transaction do
         transaction = Braintree::Transaction.find(transaction.id)
         expect(transaction.refund_ids.sort).to eq([transaction_1.id, transaction_2.id].sort)
       end
+
+      it "allows partial refund with surcharge_amount" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :surcharge_amount => "1.00",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :options => {
+            :submit_for_settlement => true
+          },
+        )
+        config = Braintree::Configuration.instantiate
+        config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
+        transaction = Braintree::Transaction.find(transaction.id)
+
+        result = Braintree::Transaction.refund(transaction.id, :amount => transaction.amount / 2, :surcharge_amount => "0.50")
+        expect(result.success?).to eq(true)
+        expect(result.transaction.type).to eq("credit")
+        expect(result.transaction.surcharge_amount).to eq(BigDecimal("0.50"))
+      end
     end
 
     it "returns a successful result if successful" do
@@ -5272,6 +5345,28 @@ describe Braintree::Transaction do
       expect(result.success?).to eq(false)
       expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled)
     end
+
+    it "accepts surcharge_amount field in refund" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :surcharge_amount => "1.00",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :submit_for_settlement => true
+        },
+      )
+      config = Braintree::Configuration.instantiate
+      config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
+      transaction = Braintree::Transaction.find(transaction.id)
+
+      result = Braintree::Transaction.refund(transaction.id, :surcharge_amount => "1.00")
+      expect(result.success?).to eq(true)
+      expect(result.transaction.type).to eq("credit")
+      expect(result.transaction.surcharge_amount).to eq(BigDecimal("1.00"))
+    end
   end
 
   describe "self.refund!" do
@@ -7295,6 +7390,85 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "self.reverse" do
+    it "voids a voidable transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+      )
+
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.id).to eq(transaction.id)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+      expect(result.transaction.refunded_transaction_id).to be_nil
+    end
+
+    it "returns an error when reversing twice without an api request key" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+      )
+
+      expect(Braintree::Transaction.reverse(transaction.id)).to be_success
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:base).first.code).to eq(
+        Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled,
+      )
+    end
+
+    it "voids an explicitly created voidable refund" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :submit_for_settlement => true
+        },
+      )
+      Braintree::TestTransaction.settle(transaction.id)
+      refund = Braintree::Transaction.refund!(transaction.id)
+
+      result = Braintree::Transaction.reverse(refund.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.id).to eq(refund.id)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+      expect(result.transaction.refunded_transaction_id).to eq(transaction.id)
+    end
+
+    it "refunds a settled transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :submit_for_settlement => true
+        },
+      )
+      Braintree::TestTransaction.settle(transaction.id)
+
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(result.transaction.refunded_transaction_id).to eq(transaction.id)
+    end
+  end
+
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(
@@ -8179,7 +8353,7 @@ describe Braintree::Transaction do
   end
 
   context "Surcharge Amount" do
-    it "accepts surcharge_amount field" do
+    it "accepts surcharge_amount field for sale transactions" do
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => "10.00",
@@ -8193,5 +8367,41 @@ describe Braintree::Transaction do
       expect(result.success?).to eq(true)
       expect(result.transaction.surcharge_amount).to eq(BigDecimal("1.00"))
     end
+
+    it "accepts surcharge_amount field for blind credit" do
+      result = Braintree::Transaction.create(
+        :type => "credit",
+        :amount => "10.00",
+        :surcharge_amount => "1.00",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2029"
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.surcharge_amount).to eq(BigDecimal("1.00"))
+    end
+  end
+
+  describe "path traversal" do
+    it "self.void rejects a traversal transaction_id and does not void the victim transaction" do
+      victim_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {:submit_for_settlement => false},
+      )
+      traversal_id = "../transactions/#{victim_transaction.id}"
+
+      expect do
+        Braintree::Transaction.void(traversal_id)
+      end.to raise_error(ArgumentError, "transaction_id contains invalid characters")
+
+      unaffected_transaction = Braintree::Transaction.find(victim_transaction.id)
+      expect(unaffected_transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
   end
 end

data/spec/unit/braintree/client_token_spec.rb

@@ -20,6 +20,78 @@ module Braintree
           )
         }.to raise_error(ArgumentError, /created_at, public_key/)
       end
+
+      context "with preferred_payment_method_token" do
+        let(:config) { SpecHelper::TestMerchantConfig }
+        let(:gateway) { Gateway.new(config) }
+        let(:http) { double(:http) }
+
+        before do
+          allow(config).to receive(:http).and_return(http)
+          allow(Configuration).to receive(:gateway).and_return(gateway)
+        end
+
+        def expect_client_token_post(options)
+          expect(http).to receive(:post).with(
+            "#{config.base_merchant_path}/client_token",
+            :client_token => options,
+          ).and_return(:client_token => {:value => "client-token"})
+        end
+
+        it "renames preferred_payment_method_token to payment_method_id" do
+          expect_client_token_post(
+            :payment_method_id => "a-pmt",
+            :version => ClientToken::DEFAULT_VERSION,
+          )
+
+          client_token = Braintree::ClientToken.generate(
+            :preferred_payment_method_token => "a-pmt",
+          )
+
+          expect(client_token).to eq("client-token")
+        end
+
+        it "renames string preferred_payment_method_token to payment_method_id" do
+          expect_client_token_post(
+            :payment_method_id => "a-pmt",
+            :version => ClientToken::DEFAULT_VERSION,
+          )
+
+          client_token = Braintree::ClientToken.generate(
+            "preferred_payment_method_token" => "a-pmt",
+          )
+
+          expect(client_token).to eq("client-token")
+        end
+
+        it "renames preferred_payment_method_token when the value is nil" do
+          expect_client_token_post(
+            :payment_method_id => nil,
+            :version => ClientToken::DEFAULT_VERSION,
+          )
+
+          client_token = Braintree::ClientToken.generate(
+            :preferred_payment_method_token => nil,
+          )
+
+          expect(client_token).to eq("client-token")
+        end
+
+        it "does not mutate the caller's options hash" do
+          options = {:preferred_payment_method_token => "a-pmt"}
+          expect(http).to receive(:post).twice.with(
+            "#{config.base_merchant_path}/client_token",
+            :client_token => {
+              :payment_method_id => "a-pmt",
+              :version => ClientToken::DEFAULT_VERSION,
+            },
+          ).and_return(:client_token => {:value => "client-token"})
+
+          expect(Braintree::ClientToken.generate(options)).to eq("client-token")
+          expect(Braintree::ClientToken.generate(options)).to eq("client-token")
+          expect(options).to eq(:preferred_payment_method_token => "a-pmt")
+        end
+      end
     end
 
     context "adding credit_card options with no customer ID" do