braintree 2.104.0 → 3.3.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -13,7 +13,8 @@ describe Braintree::PaymentMethod do
       context "plaid verified nonce" do
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
@@ -49,7 +50,8 @@ describe Braintree::PaymentMethod do
           Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
           Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
         ].each do |method|
-          it "succeeds and verifies via #{method}" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "succeeds and verifies via #{method}" do
             customer = Braintree::Customer.create.customer
             result = Braintree::PaymentMethod.create(
               :payment_method_nonce => nonce,
@@ -183,7 +185,8 @@ describe Braintree::PaymentMethod do
 
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
@@ -219,7 +222,8 @@ describe Braintree::PaymentMethod do
       context "non plaid verified nonce" do
         let(:nonce) { generate_non_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,

data/spec/integration/braintree/subscription_spec.rb

@@ -19,23 +19,21 @@ describe Braintree::Subscription do
         :plan_id => SpecHelper::TriallessPlan[:id]
       )
 
-      date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
       result.success?.should == true
       result.subscription.id.should =~ /^\w{6}$/
       result.subscription.status.should == Braintree::Subscription::Status::Active
       result.subscription.plan_id.should == "integration_trialless_plan"
 
-      result.subscription.first_billing_date.should match(date_format)
-      result.subscription.next_billing_date.should match(date_format)
-      result.subscription.billing_period_start_date.should match(date_format)
-      result.subscription.billing_period_end_date.should match(date_format)
-      result.subscription.paid_through_date.should match(date_format)
+      expect(result.subscription.first_billing_date).to be_a Date
+      expect(result.subscription.next_billing_date).to be_a Date
+      expect(result.subscription.billing_period_start_date).to be_a Date
+      expect(result.subscription.billing_period_end_date).to be_a Date
+      expect(result.subscription.paid_through_date).to be_a Date
 
       result.subscription.created_at.between?(Time.now - 60, Time.now).should == true
       result.subscription.updated_at.between?(Time.now - 60, Time.now).should == true
 
       result.subscription.failure_count.should == 0
-      result.subscription.next_bill_amount.should == "12.34"
       result.subscription.next_billing_period_amount.should == "12.34"
       result.subscription.payment_method_token.should == @credit_card.token
 
@@ -68,7 +66,6 @@ describe Braintree::Subscription do
         :id => new_id
       )
 
-      date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
       result.success?.should == true
       result.subscription.id.should == new_id
     end
@@ -195,7 +192,7 @@ describe Braintree::Subscription do
         )
 
         result.success?.should == true
-        result.subscription.first_billing_date.should == (Date.today + 3).to_s
+        result.subscription.first_billing_date.should == Date.today + 3
         result.subscription.status.should == Braintree::Subscription::Status::Pending
       end
 
@@ -678,20 +675,18 @@ describe Braintree::Subscription do
         :plan_id => SpecHelper::TriallessPlan[:id]
       )
 
-      date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
       subscription.id.should =~ /^\w{6}$/
       subscription.status.should == Braintree::Subscription::Status::Active
       subscription.plan_id.should == "integration_trialless_plan"
 
-      subscription.first_billing_date.should match(date_format)
-      subscription.next_billing_date.should match(date_format)
-      subscription.billing_period_start_date.should match(date_format)
-      subscription.billing_period_end_date.should match(date_format)
-      subscription.paid_through_date.should match(date_format)
+      expect(subscription.first_billing_date).to be_a Date
+      expect(subscription.next_billing_date).to be_a Date
+      expect(subscription.billing_period_start_date).to be_a Date
+      expect(subscription.billing_period_end_date).to be_a Date
+      expect(subscription.paid_through_date).to be_a Date
 
       subscription.failure_count.should == 0
       subscription.current_billing_cycle.should == 1
-      subscription.next_bill_amount.should == "12.34"
       subscription.next_billing_period_amount.should == "12.34"
       subscription.payment_method_token.should == @credit_card.token
     end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -468,7 +468,7 @@ describe Braintree::Transaction, "search" do
         )
         SpecHelper.settle_transaction transaction.id
 
-        refund_transaction = transaction.refund.new_transaction
+        refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
 
         collection = Braintree::Transaction.search do |search|
           search.credit_card_cardholder_name.is cardholder_name
@@ -1316,12 +1316,12 @@ describe Braintree::Transaction, "search" do
     end
 
     context "when the search times out" do
-      it "raises a Down for Maintenance Error" do
+      it "raises a UnexpectedError" do
         expect {
           collection = Braintree::Transaction.search do |search|
             search.amount.is -10
           end
-        }.to raise_error(Braintree::DownForMaintenanceError)
+        }.to raise_error(Braintree::UnexpectedError)
       end
     end
   end

data/spec/integration/braintree/transaction_spec.rb

@@ -123,8 +123,8 @@ describe Braintree::Transaction do
 
   describe "self.create" do
     describe "risk data" do
-      it "returns decision, device_data_captured and id" do
-        with_advanced_fraud_integration_merchant do
+      it "returns decision, device_data_captured, id, transaction_risk_score, and decision_reasons" do
+        with_fraud_protection_enterprise_merchant do
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => 1_00,
@@ -134,15 +134,17 @@ describe Braintree::Transaction do
             }
           )
           result.transaction.risk_data.should be_a(Braintree::RiskData)
-          result.transaction.risk_data.should respond_to(:id)
-          result.transaction.risk_data.should respond_to(:decision)
-          result.transaction.risk_data.should respond_to(:device_data_captured)
-          result.transaction.risk_data.should respond_to(:fraud_service_provider)
+          result.transaction.risk_data.id.should_not be_nil
+          result.transaction.risk_data.decision.should_not be_nil
+          result.transaction.risk_data.decision_reasons.should_not be_nil
+          result.transaction.risk_data.device_data_captured.should_not be_nil
+          result.transaction.risk_data.fraud_service_provider.should_not be_nil
+          expect(result.transaction.risk_data).to respond_to(:transaction_risk_score)
         end
       end
 
       it "handles validation errors for invalid risk data attributes" do
-        with_advanced_fraud_integration_merchant do
+        with_advanced_fraud_kount_integration_merchant do
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -159,7 +161,6 @@ describe Braintree::Transaction do
             }
           )
           result.success?.should == false
-          result.errors.for(:transaction).for(:risk_data).on(:customer_browser).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerBrowserIsTooLong
           result.errors.for(:transaction).for(:risk_data).on(:customer_device_id).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerDeviceIdIsTooLong
           result.errors.for(:transaction).for(:risk_data).on(:customer_location_zip).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerLocationZipInvalidCharacters
           result.errors.for(:transaction).for(:risk_data).on(:customer_tenure).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerTenureIsTooLong
@@ -182,6 +183,42 @@ describe Braintree::Transaction do
       end
     end
 
+    describe "sca_exemption" do
+      context "with a valid request" do
+        it "succeeds" do
+          requested_exemption = "low_value"
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::VisaCountryOfIssuanceIE,
+              :expiration_date => "05/2009"
+            },
+            :sca_exemption => requested_exemption,
+          )
+          expect(result).to be_success
+          expect(result.transaction.sca_exemption_requested).to eq(requested_exemption)
+        end
+      end
+
+      context "with an invalid request" do
+        it "returns an error" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :sca_exemption => "invalid_sca_exemption_value",
+          )
+          sca_exemption_invalid = Braintree::ErrorCodes::Transaction::ScaExemptionInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:transaction).map(&:code)).to eq([sca_exemption_invalid])
+        end
+      end
+    end
+
     describe "industry data" do
       context "for lodging" do
         it "accepts valid industry data" do
@@ -445,6 +482,7 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.expiration_date.should == "05/2009"
       result.transaction.credit_card_details.customer_location.should == "US"
       result.transaction.retrieval_reference_number.should_not be_nil
+      result.transaction.acquirer_reference_number.should be_nil
     end
 
     it "returns a successful network response code if successful" do
@@ -509,7 +547,7 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.customer_location.should == "US"
     end
 
-    it "accepts additional security parameters: device_session_id and fraud_merchant_id" do
+    it "accepts additional security parameters: device_data" do
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -517,8 +555,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
         },
-        :device_session_id => "abc123",
-        :fraud_merchant_id => "7"
+        :device_data => "device_data",
       )
 
       result.success?.should == true
@@ -895,7 +932,7 @@ describe Braintree::Transaction do
       end
 
       it "exposes the fraud gateway rejection reason" do
-        with_advanced_fraud_integration_merchant do
+        with_advanced_fraud_kount_integration_merchant do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
@@ -910,7 +947,7 @@ describe Braintree::Transaction do
       end
 
       it "exposes the risk_threshold gateway rejection reason (via test cc num)" do
-        with_advanced_fraud_integration_merchant do
+        with_advanced_fraud_kount_integration_merchant do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
@@ -925,7 +962,7 @@ describe Braintree::Transaction do
       end
 
       it "exposes the risk_threshold gateway rejection reason (via test test nonce)" do
-        with_advanced_fraud_integration_merchant do
+        with_advanced_fraud_kount_integration_merchant do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :payment_method_nonce => Braintree::Test::Nonce::GatewayRejectedRiskThresholds,
@@ -1372,22 +1409,6 @@ describe Braintree::Transaction do
       end
     end
 
-    context "recurring" do
-      it "marks a transaction as recurring" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :recurring => true
-        )
-        result.success?.should == true
-        result.transaction.recurring.should == true
-      end
-    end
-
     context "transaction_source" do
       it "marks a transactions as recurring_first" do
         result = Braintree::Transaction.create(
@@ -1804,106 +1825,83 @@ describe Braintree::Transaction do
         apple_pay_details.token.should_not be_nil
       end
 
-      it "can create a transaction with a fake android pay proxy card nonce" do
+      it "can create a transaction with a fake google pay proxy card nonce" do
         customer = Braintree::Customer.create!
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover
         )
         result.success?.should == true
         result.transaction.should_not be_nil
-        android_pay_details = result.transaction.android_pay_details
-        android_pay_details.should_not be_nil
-        android_pay_details.bin.should_not be_nil
-        android_pay_details.card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_details.last_4.should == "1117"
-        android_pay_details.virtual_card_last_4.should == "1117"
-        android_pay_details.source_description.should == "Discover 1111"
-        android_pay_details.expiration_month.to_i.should > 0
-        android_pay_details.expiration_year.to_i.should > 0
-        android_pay_details.google_transaction_id.should == "google_transaction_id"
-        android_pay_details.image_url.should_not be_nil
-        android_pay_details.is_network_tokenized?.should == false
-        android_pay_details.token.should be_nil
-        android_pay_details.prepaid.should_not be_nil
-        android_pay_details.healthcare.should_not be_nil
-        android_pay_details.debit.should_not be_nil
-        android_pay_details.durbin_regulated.should_not be_nil
-        android_pay_details.commercial.should_not be_nil
-        android_pay_details.payroll.should_not be_nil
-        android_pay_details.product_id.should_not be_nil
-      end
-
-      it "can create a vaulted transaction with a fake android pay proxy card nonce" do
+        google_pay_details = result.transaction.google_pay_details
+        google_pay_details.should_not be_nil
+        google_pay_details.bin.should_not be_nil
+        google_pay_details.card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_details.last_4.should == "1117"
+        google_pay_details.virtual_card_last_4.should == "1117"
+        google_pay_details.source_description.should == "Discover 1111"
+        google_pay_details.expiration_month.to_i.should > 0
+        google_pay_details.expiration_year.to_i.should > 0
+        google_pay_details.google_transaction_id.should == "google_transaction_id"
+        google_pay_details.image_url.should_not be_nil
+        google_pay_details.is_network_tokenized?.should == false
+        google_pay_details.token.should be_nil
+        google_pay_details.prepaid.should_not be_nil
+        google_pay_details.healthcare.should_not be_nil
+        google_pay_details.debit.should_not be_nil
+        google_pay_details.durbin_regulated.should_not be_nil
+        google_pay_details.commercial.should_not be_nil
+        google_pay_details.payroll.should_not be_nil
+        google_pay_details.product_id.should_not be_nil
+      end
+
+      it "can create a vaulted transaction with a fake google pay proxy card nonce" do
         customer = Braintree::Customer.create!
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
           :options => { :store_in_vault_on_success => true }
         )
         result.success?.should == true
         result.transaction.should_not be_nil
-        android_pay_details = result.transaction.android_pay_details
-        android_pay_details.should_not be_nil
-        android_pay_details.card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_details.last_4.should == "1117"
-        android_pay_details.virtual_card_last_4.should == "1117"
-        android_pay_details.source_description.should == "Discover 1111"
-        android_pay_details.expiration_month.to_i.should > 0
-        android_pay_details.expiration_year.to_i.should > 0
-        android_pay_details.google_transaction_id.should == "google_transaction_id"
-        android_pay_details.image_url.should_not be_nil
-        android_pay_details.is_network_tokenized?.should == false
-        android_pay_details.token.should_not be_nil
-      end
-
-      it "can create a transaction with a fake android pay network token nonce" do
+        google_pay_details = result.transaction.google_pay_details
+        google_pay_details.should_not be_nil
+        google_pay_details.card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_details.last_4.should == "1117"
+        google_pay_details.virtual_card_last_4.should == "1117"
+        google_pay_details.source_description.should == "Discover 1111"
+        google_pay_details.expiration_month.to_i.should > 0
+        google_pay_details.expiration_year.to_i.should > 0
+        google_pay_details.google_transaction_id.should == "google_transaction_id"
+        google_pay_details.image_url.should_not be_nil
+        google_pay_details.is_network_tokenized?.should == false
+        google_pay_details.token.should_not be_nil
+      end
+
+      it "can create a transaction with a fake google pay network token nonce" do
         customer = Braintree::Customer.create!
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayMasterCard
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard
         )
         result.success?.should == true
         result.transaction.should_not be_nil
-        android_pay_details = result.transaction.android_pay_details
-        android_pay_details.should_not be_nil
-        android_pay_details.card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_details.last_4.should == "4444"
-        android_pay_details.virtual_card_last_4.should == "4444"
-        android_pay_details.source_description.should == "MasterCard 4444"
-        android_pay_details.expiration_month.to_i.should > 0
-        android_pay_details.expiration_year.to_i.should > 0
-        android_pay_details.google_transaction_id.should == "google_transaction_id"
-        android_pay_details.is_network_tokenized?.should == true
-      end
-
-      it "can create a transaction with a fake amex express checkout card nonce" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::AmexExpressCheckout,
-          :options => {:store_in_vault => true}
-        )
-        result.success?.should == true
-        result.transaction.should_not be_nil
-        checkout_details = result.transaction.amex_express_checkout_details
-        checkout_details.should_not be_nil
-        checkout_details.card_type.should == "American Express"
-        checkout_details.token.should respond_to(:to_str)
-        checkout_details.bin.should =~ /\A\d{6}\z/
-        checkout_details.expiration_month.should =~ /\A\d{2}\z/
-        checkout_details.expiration_year.should =~ /\A\d{4}\z/
-        checkout_details.card_member_number.should =~ /\A\d{4}\z/
-        checkout_details.card_member_expiry_date.should =~ /\A\d{2}\/\d{2}\z/
-        checkout_details.image_url.should include(".png")
-        checkout_details.source_description.should =~ /\AAmEx \d{4}\z/
+        google_pay_details = result.transaction.google_pay_details
+        google_pay_details.should_not be_nil
+        google_pay_details.card_type.should == Braintree::CreditCard::CardType::MasterCard
+        google_pay_details.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
+        google_pay_details.last_4.should == "4444"
+        google_pay_details.virtual_card_last_4.should == "4444"
+        google_pay_details.source_description.should == "MasterCard 4444"
+        google_pay_details.expiration_month.to_i.should > 0
+        google_pay_details.expiration_year.to_i.should > 0
+        google_pay_details.google_transaction_id.should == "google_transaction_id"
+        google_pay_details.is_network_tokenized?.should == true
       end
 
       it "can create a transaction with a fake venmo account nonce" do
@@ -2703,6 +2701,22 @@ describe Braintree::Transaction do
         end
       end
 
+      context "billing agreement" do
+        it "can create a paypal billing agreement" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
+            :options => {:store_in_vault => true}
+          )
+
+          result.should be_success
+          result.transaction.paypal_details.should_not be_nil
+          result.transaction.paypal_details.debug_id.should_not be_nil
+          result.transaction.paypal_details.billing_agreement_id.should_not be_nil
+        end
+      end
+
       context "local payments" do
         it "can create a local payment transaction with a nonce" do
           result = Braintree::Transaction.create(
@@ -2865,14 +2879,6 @@ describe Braintree::Transaction do
           }.to raise_error(ArgumentError)
         end
 
-        it "assigns the refund_id on the original transaction" do
-          transaction = create_paypal_transaction_for_refund
-          refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
-          transaction = Braintree::Transaction.find(transaction.id)
-
-          transaction.refund_id.should == refund_transaction.id
-        end
-
         it "assigns the refunded_transaction_id to the original transaction" do
           transaction = create_paypal_transaction_for_refund
           refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
@@ -2902,7 +2908,13 @@ describe Braintree::Transaction do
           response = config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
           result = Braintree::Transaction.refund(transaction.id, :amount => "2046.00")
           result.success?.should == false
-          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::RefundAuthSoftDeclined
+          result.transaction.id.should =~ /^\w{6,}$/
+          result.transaction.type.should == "credit"
+          result.transaction.status.should == Braintree::Transaction::Status::ProcessorDeclined
+          result.transaction.processor_response_code.should == "2046"
+          result.transaction.processor_response_text.should == "Declined"
+          result.transaction.processor_response_type.should == Braintree::ProcessorResponseTypes::SoftDeclined
+          result.transaction.additional_processor_response.should == "2046 : Declined"
         end
 
         it "handles hard declined refund authorizations" do
@@ -2917,7 +2929,13 @@ describe Braintree::Transaction do
           response = config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
           result = Braintree::Transaction.refund(transaction.id, :amount => "2009.00")
           result.success?.should == false
-          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::RefundAuthHardDeclined
+          result.transaction.id.should =~ /^\w{6,}$/
+          result.transaction.type.should == "credit"
+          result.transaction.status.should == Braintree::Transaction::Status::ProcessorDeclined
+          result.transaction.processor_response_code.should == "2009"
+          result.transaction.processor_response_text.should == "No Such Issuer"
+          result.transaction.processor_response_type.should == Braintree::ProcessorResponseTypes::HardDeclined
+          result.transaction.additional_processor_response.should == "2009 : No Such Issuer"
         end
       end
 
@@ -4289,7 +4307,7 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).for(:external_vault).on(:status)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::StatusIsInvalid
       end
 
-      context "Visa/Mastercard/Discover" do
+      context "Visa/Mastercard/Discover/AmEx" do
         it "accepts status" do
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -4341,12 +4359,12 @@ describe Braintree::Transaction do
         end
       end
 
-      context "Non-(Visa/Mastercard/Discover) card types" do
+      context "Non-(Visa/Mastercard/Discover/AmEx) card types" do
         it "accepts status" do
           result = Braintree::Transaction.create(
             :type => "sale",
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
+              :number => Braintree::Test::CreditCardNumbers::JCBs[0],
               :expiration_date => "05/2009"
             },
             :external_vault => {
@@ -4362,7 +4380,7 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.create(
             :type => "sale",
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
+              :number => Braintree::Test::CreditCardNumbers::JCBs[0],
               :expiration_date => "05/2009"
             },
             :external_vault => {
@@ -4374,25 +4392,7 @@ describe Braintree::Transaction do
           result.success?.should == true
           result.transaction.network_transaction_id.should be_nil
         end
-
-        it "rejects previous_network_transaction_id" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
-              :expiration_date => "05/2009"
-            },
-            :external_vault => {
-              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
-              :previous_network_transaction_id => "123456789012345",
-            },
-            :amount => "10.00",
-          )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:external_vault).on(:previous_network_transaction_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::CardTypeIsInvalid
-        end
       end
-
     end
 
     context "account_type" do
@@ -4571,14 +4571,6 @@ describe Braintree::Transaction do
       result.transaction.type.should == "credit"
     end
 
-    it "assigns the refund_id on the original transaction" do
-      transaction = create_transaction_to_refund
-      refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
-      transaction = Braintree::Transaction.find(transaction.id)
-
-      transaction.refund_id.should == refund_transaction.id
-    end
-
     it "assigns the refunded_transaction_id to the original transaction" do
       transaction = create_transaction_to_refund
       refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
@@ -4986,8 +4978,75 @@ describe Braintree::Transaction do
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
 
+    it "validates currency_iso_code and creates transaction" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :currency_iso_code => "USD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == true
+      result.transaction.currency_iso_code == "USD"
+    end
+
+    it "validates currency_iso_code and returns error" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :currency_iso_code => "CAD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:currency_iso_code)[0].code.should == Braintree::ErrorCodes::Transaction::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
+    it "validates currency_iso_code and creates transaction with specified merchant account" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :currency_iso_code => "USD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == true
+      result.transaction.currency_iso_code == "USD"
+      result.transaction.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+    end
+
+    it "validates currency_iso_code and returns error with specified merchant account" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :currency_iso_code => "CAD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:currency_iso_code)[0].code.should == Braintree::ErrorCodes::Transaction::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
     it "skips advanced fraud checking if transaction[options][skip_advanced_fraud_checking] is set to true" do
-      with_advanced_fraud_integration_merchant do
+      with_advanced_fraud_kount_integration_merchant do
         result = Braintree::Transaction.sale(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :credit_card => {
@@ -5020,11 +5079,11 @@ describe Braintree::Transaction do
       result.transaction.status.should == Braintree::Transaction::Status::Authorized
     end
 
-    context "Android Pay params" do
+    context "Google Pay params" do
       it "works with full params" do
         params = {
           :amount => "3.12",
-          :android_pay_card => {
+          :google_pay_card => {
             :number => "4012888888881881",
             :cryptogram => "AAAAAAAA/COBt84dnIEcwAA3gAAGhgEDoLABAAhAgAABAAAALnNCLw==",
             :google_transaction_id => "25469d622c1dd37cb1a403c6d438e850",
@@ -5043,7 +5102,7 @@ describe Braintree::Transaction do
       it "works with only number, cryptogram, expiration and transaction ID (network tokenized card)" do
         params = {
           :amount => "3.12",
-          :android_pay_card => {
+          :google_pay_card => {
             :number => "4012888888881881",
             :cryptogram => "AAAAAAAA/COBt84dnIEcwAA3gAAGhgEDoLABAAhAgAABAAAALnNCLw==",
             :google_transaction_id => "25469d622c1dd37cb1a403c6d438e850",
@@ -5059,7 +5118,7 @@ describe Braintree::Transaction do
       it "works with only number, expiration and transaction ID (non-tokenized card)" do
         params = {
           :amount => "3.12",
-          :android_pay_card => {
+          :google_pay_card => {
             :number => "4012888888881881",
             :google_transaction_id => "25469d622c1dd37cb1a403c6d438e850",
             :expiration_month => "10",
@@ -6048,184 +6107,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.create_from_transparent_redirect" do
-    it "returns a successful result if successful" do
-      params = {
-        :transaction => {
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          }
-        }
-      }
-      tr_data_params = {
-        :transaction => {
-          :type => "sale"
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Transaction.create_transaction_url)
-      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
-
-      result.success?.should == true
-      transaction = result.transaction
-      transaction.type.should == "sale"
-      transaction.amount.should == BigDecimal("1000.00")
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2009"
-    end
-
-    it "raises an error with a message if given invalid params" do
-      params = {
-        :transaction => {
-          :bad => "value",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          }
-        }
-      }
-      tr_data_params = {
-        :transaction => {
-          :type => "sale"
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Transaction.create_transaction_url)
-
-      expect do
-        Braintree::Transaction.create_from_transparent_redirect(query_string_response)
-      end.to raise_error(Braintree::AuthorizationError, "Invalid params: transaction[bad]")
-    end
-
-    it "can put any param in tr_data" do
-      params = {
-
-      }
-      tr_data_params = {
-        :transaction => {
-          :amount => "100.00",
-          :order_id => "123",
-          :channel => "MyShoppingCartProvider",
-          :type => "sale",
-          :credit_card => {
-            :cardholder_name => "The Cardholder",
-            :number => "5105105105105100",
-            :expiration_date => "05/2011",
-            :cvv => "123"
-          },
-          :customer => {
-            :first_name => "Dan",
-            :last_name => "Smith",
-            :company => "Braintree",
-            :email => "dan@example.com",
-            :phone => "419-555-1234",
-            :fax => "419-555-1235",
-            :website => "http://braintreepayments.com"
-          },
-          :billing => {
-            :first_name => "Carl",
-            :last_name => "Jones",
-            :company => "Braintree",
-            :street_address => "123 E Main St",
-            :extended_address => "Suite 403",
-            :locality => "Chicago",
-            :region => "IL",
-            :postal_code => "60622",
-            :country_name => "United States of America"
-          },
-          :shipping => {
-            :first_name => "Andrew",
-            :last_name => "Mason",
-            :company => "Braintree",
-            :street_address => "456 W Main St",
-            :extended_address => "Apt 2F",
-            :locality => "Bartlett",
-            :region => "IL",
-            :postal_code => "60103",
-            :country_name => "United States of America"
-          }
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Transaction.create_transaction_url)
-      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
-
-      transaction = result.transaction
-      transaction.id.should =~ /\A\w{6,}\z/
-      transaction.type.should == "sale"
-      transaction.status.should == Braintree::Transaction::Status::Authorized
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.order_id.should == "123"
-      transaction.channel.should == "MyShoppingCartProvider"
-      transaction.processor_response_code.should == "1000"
-      transaction.authorization_expires_at.between?(Time.now, Time.now + (60 * 60 * 24 * 60)).should == true
-      transaction.created_at.between?(Time.now - 60, Time.now).should == true
-      transaction.updated_at.between?(Time.now - 60, Time.now).should == true
-      transaction.credit_card_details.bin.should == "510510"
-      transaction.credit_card_details.last_4.should == "5100"
-      transaction.credit_card_details.cardholder_name.should == "The Cardholder"
-      transaction.credit_card_details.masked_number.should == "510510******5100"
-      transaction.credit_card_details.card_type.should == "MasterCard"
-      transaction.avs_error_response_code.should == nil
-      transaction.avs_postal_code_response_code.should == "M"
-      transaction.avs_street_address_response_code.should == "M"
-      transaction.cvv_response_code.should == "M"
-      transaction.customer_details.first_name.should == "Dan"
-      transaction.customer_details.last_name.should == "Smith"
-      transaction.customer_details.company.should == "Braintree"
-      transaction.customer_details.email.should == "dan@example.com"
-      transaction.customer_details.phone.should == "419-555-1234"
-      transaction.customer_details.fax.should == "419-555-1235"
-      transaction.customer_details.website.should == "http://braintreepayments.com"
-      transaction.billing_details.first_name.should == "Carl"
-      transaction.billing_details.last_name.should == "Jones"
-      transaction.billing_details.company.should == "Braintree"
-      transaction.billing_details.street_address.should == "123 E Main St"
-      transaction.billing_details.extended_address.should == "Suite 403"
-      transaction.billing_details.locality.should == "Chicago"
-      transaction.billing_details.region.should == "IL"
-      transaction.billing_details.postal_code.should == "60622"
-      transaction.billing_details.country_name.should == "United States of America"
-      transaction.shipping_details.first_name.should == "Andrew"
-      transaction.shipping_details.last_name.should == "Mason"
-      transaction.shipping_details.company.should == "Braintree"
-      transaction.shipping_details.street_address.should == "456 W Main St"
-      transaction.shipping_details.extended_address.should == "Apt 2F"
-      transaction.shipping_details.locality.should == "Bartlett"
-      transaction.shipping_details.region.should == "IL"
-      transaction.shipping_details.postal_code.should == "60103"
-      transaction.shipping_details.country_name.should == "United States of America"
-    end
-
-    it "returns an error result if validations fail" do
-      params = {
-        :transaction => {
-          :amount => "",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          }
-        }
-      }
-      tr_data_params = {
-        :transaction => {
-          :type => "sale"
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Transaction.create_transaction_url)
-      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
-
-      result.success?.should == false
-      result.params[:transaction].should == {:amount => "", :type => "sale", :credit_card => {:expiration_date => "05/2009"}}
-      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
-    end
-  end
-
   describe "self.find" do
     it "finds the transaction with the given id" do
       result = Braintree::Transaction.create(
@@ -6267,6 +6148,12 @@ describe Braintree::Transaction do
       end.to raise_error(Braintree::NotFoundError, 'transaction with id "invalid-id" not found')
     end
 
+    it "finds a transaction and returns an acquirer_reference_number if the transaction has one" do
+      transaction = Braintree::Transaction.find("transactionwithacquirerreferencenumber")
+
+      transaction.acquirer_reference_number.should == "123456789 091019"
+    end
+
     context "disbursement_details" do
       it "includes disbursement_details on found transactions" do
         found_transaction = Braintree::Transaction.find("deposittransaction")
@@ -6274,7 +6161,8 @@ describe Braintree::Transaction do
         found_transaction.disbursed?.should == true
         disbursement = found_transaction.disbursement_details
 
-        disbursement.disbursement_date.should == "2013-04-10"
+        expect(disbursement.disbursement_date).to be_a Date
+        expect(disbursement.disbursement_date).to eq Date.parse("2013-04-10")
         disbursement.settlement_amount.should == "100.00"
         disbursement.settlement_currency_iso_code.should == "USD"
         disbursement.settlement_currency_exchange_rate.should == "1"
@@ -6352,15 +6240,21 @@ describe Braintree::Transaction do
       it "returns all the three_d_secure_info" do
         transaction = Braintree::Transaction.find("threedsecuredtransaction")
 
+        expect(transaction.three_d_secure_info.authentication).to have_key(:trans_status)
+        expect(transaction.three_d_secure_info.authentication).to have_key(:trans_status_reason)
+        expect(transaction.three_d_secure_info.lookup).to have_key(:trans_status)
+        expect(transaction.three_d_secure_info.lookup).to have_key(:trans_status_reason)
+        transaction.three_d_secure_info.cavv.should == "somebase64value"
+        transaction.three_d_secure_info.ds_transaction_id.should == "dstxnid"
+        transaction.three_d_secure_info.eci_flag.should == "07"
         transaction.three_d_secure_info.enrolled.should == "Y"
-        transaction.three_d_secure_info.should be_liability_shifted
+        transaction.three_d_secure_info.pares_status.should == "Y"
         transaction.three_d_secure_info.should be_liability_shift_possible
+        transaction.three_d_secure_info.should be_liability_shifted
         transaction.three_d_secure_info.status.should == "authenticate_successful"
-        transaction.three_d_secure_info.cavv.should == "somebase64value"
-        transaction.three_d_secure_info.xid.should == "xidvalue"
-        transaction.three_d_secure_info.eci_flag.should == "07"
+        expect(transaction.three_d_secure_info.three_d_secure_authentication_id).to be
         transaction.three_d_secure_info.three_d_secure_version.should == "1.0.2"
-        transaction.three_d_secure_info.ds_transaction_id.should == "dstxnid"
+        transaction.three_d_secure_info.xid.should == "xidvalue"
       end
 
       it "is nil if the transaction wasn't 3d secured" do
@@ -6519,151 +6413,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "refund" do
-    context "partial refunds" do
-      it "allows partial refunds" do
-        transaction = create_transaction_to_refund
-        result = transaction.refund(transaction.amount / 2)
-        result.success?.should == true
-        result.new_transaction.type.should == "credit"
-      end
-    end
-
-    it "returns a successful result if successful" do
-      transaction = create_transaction_to_refund
-      transaction.status.should == Braintree::Transaction::Status::Settled
-      result = transaction.refund
-      result.success?.should == true
-      result.new_transaction.type.should == "credit"
-    end
-
-    it "assigns the refund_id on the original transaction" do
-      transaction = create_transaction_to_refund
-      refund_transaction = transaction.refund.new_transaction
-      transaction = Braintree::Transaction.find(transaction.id)
-
-      transaction.refund_id.should == refund_transaction.id
-    end
-
-    it "assigns the refunded_transaction_id to the original transaction" do
-      transaction = create_transaction_to_refund
-      refund_transaction = transaction.refund.new_transaction
-
-      refund_transaction.refunded_transaction_id.should == transaction.id
-    end
-
-    it "returns an error if already refunded" do
-      transaction = create_transaction_to_refund
-      result = transaction.refund
-      result.success?.should == true
-      result = transaction.refund
-      result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::HasAlreadyBeenRefunded
-    end
-
-    it "returns an error result if unsettled" do
-      transaction = Braintree::Transaction.create!(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        }
-      )
-      result = transaction.refund
-      result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
-    end
-  end
-
-  describe "submit_for_settlement" do
-    it "returns a successful result if successful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      result = transaction.submit_for_settlement
-      result.success?.should == true
-    end
-
-    it "can submit a specific amount for settlement" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      transaction.amount.should == BigDecimal("1000.00")
-      result = transaction.submit_for_settlement("999.99")
-      result.success?.should == true
-      transaction.amount.should == BigDecimal("999.99")
-    end
-
-    it "updates the transaction attributes" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      transaction.amount.should == BigDecimal("1000.00")
-      result = transaction.submit_for_settlement("999.99")
-      result.success?.should == true
-      transaction.amount.should == BigDecimal("999.99")
-      transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
-      transaction.updated_at.between?(Time.now - 60, Time.now).should == true
-    end
-
-    it "returns an error result if unsuccessful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      transaction.amount.should == BigDecimal("1000.00")
-      result = transaction.submit_for_settlement("1000.01")
-      result.success?.should == false
-      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsTooLarge
-      result.params[:transaction][:amount].should == "1000.01"
-    end
-  end
-
-  describe "submit_for_settlement!" do
-    it "returns the transaction if successful" do
-      original_transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      transaction = original_transaction.submit_for_settlement!
-      transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
-      transaction.id.should == original_transaction.id
-    end
-
-    it "raises a ValidationsFailed if unsuccessful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "06/2009"
-        }
-      )
-      transaction.amount.should == BigDecimal("1000.00")
-      expect do
-        transaction.submit_for_settlement!("1000.01")
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "status_history" do
     it "returns an array of StatusDetail" do
       transaction = Braintree::Transaction.sale!(
@@ -6673,10 +6422,10 @@ describe Braintree::Transaction do
           :expiration_date => "05/2009"
         }
       )
-      transaction.submit_for_settlement!
-      transaction.status_history.size.should == 2
-      transaction.status_history[0].status.should == Braintree::Transaction::Status::Authorized
-      transaction.status_history[1].status.should == Braintree::Transaction::Status::SubmittedForSettlement
+      result = Braintree::Transaction.submit_for_settlement!(transaction.id)
+      result.status_history.size.should == 2
+      result.status_history[0].status.should == Braintree::Transaction::Status::Authorized
+      result.status_history[1].status.should == Braintree::Transaction::Status::SubmittedForSettlement
     end
   end
 
@@ -6731,7 +6480,7 @@ describe Braintree::Transaction do
           :expiration_date => "05/2010"
         }
       )
-      transaction = customer.credit_cards[0].sale(:amount => "100.00").transaction
+      transaction = Braintree::CreditCard.sale(customer.credit_cards[0].token, {:amount => "100.00"}).transaction
       transaction.vault_credit_card.should == customer.credit_cards[0]
     end
 
@@ -6756,7 +6505,7 @@ describe Braintree::Transaction do
           :expiration_date => "05/2010"
         }
       )
-      transaction = customer.credit_cards[0].sale(:amount => "100.00").transaction
+      transaction = Braintree::CreditCard.sale(customer.credit_cards[0].token, :amount => "100.00").transaction
       transaction.vault_customer.should == customer
     end
 
@@ -6773,68 +6522,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "void" do
-    it "returns a successful result if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        }
-      )
-      result.success?.should == true
-      transaction = result.transaction
-      transaction.status.should == Braintree::Transaction::Status::Authorized
-      void_result = transaction.void
-      void_result.success?.should == true
-      void_result.transaction.should == transaction
-      transaction.status.should == void_result.transaction.status
-    end
-
-    it "returns an error result if unsuccessful" do
-      transaction = Braintree::Transaction.sale(
-        :amount => Braintree::Test::TransactionAmounts::Decline,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        }
-      ).transaction
-      transaction.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      result = transaction.void
-      result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotBeVoided
-    end
-  end
-
-  describe "void!" do
-    it "returns the transaction if successful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        }
-      )
-      transaction.void!.should == transaction
-      transaction.status.should == Braintree::Transaction::Status::Voided
-    end
-
-    it "raises a ValidationsFailed if unsuccessful" do
-      transaction = Braintree::Transaction.sale(
-        :amount => Braintree::Test::TransactionAmounts::Decline,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        }
-      ).transaction
-      transaction.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      expect do
-        transaction.void!
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   def create_transaction_to_refund
     transaction = Braintree::Transaction.sale!(
       :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -7194,4 +6881,91 @@ describe Braintree::Transaction do
       transaction.processed_with_network_token?.should == false
     end
   end
+
+  describe "installments" do
+    it "creates a transaction with an installment count" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.installment_count).to eq(12)
+    end
+
+    it "creates a transaction with a installments during capture" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+        :options => {
+          :submit_for_settlement => true,
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      transaction = result.transaction
+      expect(transaction.installment_count).to eq(12)
+
+      installments = transaction.installments
+      expect(installments.map(&:id)).to match_array((1..12).map { |i| "#{transaction.id}_INST_#{i}" })
+      expect(installments.map(&:amount)).to match_array([BigDecimal("8.33")] * 11 + [BigDecimal("8.38")])
+    end
+
+    it "can refund a transaction with installments" do
+      sale_result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+        :options => {
+          :submit_for_settlement => true,
+        },
+      )
+
+      expect(sale_result.success?).to eq(true)
+      sale_transaction = sale_result.transaction
+
+      refund_result = Braintree::Transaction.refund(sale_transaction.id, "49.99")
+
+      expect(refund_result.success?).to eq(true)
+      refund_transaction = refund_result.transaction
+      installments = refund_transaction.refunded_installments
+
+      (1..11).each do |i|
+        installment = installments.find { |installment| installment.id == "#{sale_transaction.id}_INST_#{i}" }
+
+        expect(installment.amount).to eq(BigDecimal("8.33"))
+        expect(installment.adjustments.map(&:amount)).to match_array([BigDecimal("-4.16")])
+        expect(installment.adjustments.map(&:kind)).to match_array([Braintree::Transaction::Installment::Adjustment::Kind::Refund])
+      end
+
+      installment = installments.find { |installment| installment.id == "#{sale_transaction.id}_INST_12" }
+
+      expect(installment.amount).to eq(BigDecimal("8.38"))
+      expect(installment.adjustments.map(&:amount)).to match_array([BigDecimal("-4.23")])
+      expect(installment.adjustments.map(&:kind)).to match_array([Braintree::Transaction::Installment::Adjustment::Kind::Refund])
+    end
+  end
 end