braintree 2.104.0 → 4.9.0

data/spec/integration/braintree/transaction_spec.rb

@@ -24,7 +24,7 @@ describe Braintree::Transaction do
           :country_code_alpha2 => "BT",
           :country_code_alpha3 => "BTN",
           :country_code_numeric => "064"
-        }
+        },
       )
       result.success?.should == true
 
@@ -34,7 +34,7 @@ describe Braintree::Transaction do
         :channel => "MyShoppingCartProvider",
         :options => {
           :submit_for_settlement => false
-        }
+        },
       )
       clone_result.success?.should == true
 
@@ -67,7 +67,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => "5105105105105100",
           :expiration_date => "05/2012"
-        }
+        },
       )
 
       result.success?.should be(true)
@@ -84,7 +84,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result = Braintree::Transaction.clone_transaction(transaction.id, :amount => "112.44")
       result.success?.should be(false)
@@ -100,7 +100,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       clone_transaction = Braintree::Transaction.clone_transaction!(transaction.id, :amount => "112.44", :options => {:submit_for_settlement => false})
       clone_transaction.id.should_not == transaction.id
@@ -112,7 +112,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       expect do
         clone_transaction = Braintree::Transaction.clone_transaction!(transaction.id, :amount => "im not a number")
@@ -123,26 +123,48 @@ 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,
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
               :expiration_date => "05/2009"
-            }
+            },
+          )
+          expect(result.transaction.risk_data).to be_a(Braintree::RiskData)
+          expect(result.transaction.risk_data.id).not_to be_nil
+          expect(result.transaction.risk_data.decision).not_to be_nil
+          expect(result.transaction.risk_data.decision_reasons).not_to be_nil
+          expect(result.transaction.risk_data).to respond_to(:device_data_captured)
+          expect(result.transaction.risk_data).to respond_to(:fraud_service_provider)
+          expect(result.transaction.risk_data).to respond_to(:transaction_risk_score)
+        end
+      end
+
+      it "returns decision, device_data_captured, id, liability_shift, and decision_reasons" do
+        with_chargeback_protection_merchant do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => 1_00,
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_date => "05/2009"
+            },
           )
-          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)
+          expect(result.transaction.risk_data).to be_a(Braintree::RiskData)
+          expect(result.transaction.risk_data.id).not_to be_nil
+          expect(result.transaction.risk_data.decision).not_to be_nil
+          expect(result.transaction.risk_data.decision_reasons).not_to be_nil
+          expect(result.transaction.risk_data).to respond_to(:device_data_captured)
+          expect(result.transaction.risk_data).to respond_to(:fraud_service_provider)
+          expect(result.transaction.risk_data).to respond_to(:liability_shift)
         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,
@@ -156,10 +178,9 @@ describe Braintree::Transaction do
               :customer_ip => "192.168.0.1",
               :customer_location_zip => "not-a-$#phone",
               :customer_tenure => "20#{"0" * 500}"
-            }
+            },
           )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:risk_data).on(:customer_browser).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerBrowserIsTooLong
+          expect(result.success?).to eq(false)
           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
@@ -175,13 +196,49 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
             :expiration_date => "05/2009"
-          }
+          },
         )
         result.transaction.credit_card_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
         result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::CreditCard
       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
@@ -215,7 +272,7 @@ describe Braintree::Transaction do
                   },
                 ],
               }
-            }
+            },
           )
           result.success?.should be(true)
         end
@@ -242,15 +299,15 @@ describe Braintree::Transaction do
                   },
                 ],
               }
-            }
+            },
           )
           result.success?.should be(false)
           invalid_folio = Braintree::ErrorCodes::Transaction::Industry::Lodging::FolioNumberIsInvalid
           check_out_date_must_follow_check_in_date = Braintree::ErrorCodes::Transaction::Industry::Lodging::CheckOutDateMustFollowCheckInDate
           room_rate_format_is_invalid = Braintree::ErrorCodes::Transaction::Industry::Lodging::RoomRateFormatIsInvalid
           invalid_additional_charge_kind = Braintree::ErrorCodes::Transaction::Industry::AdditionalCharge::KindIsInvalid
-          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should include *[invalid_folio, check_out_date_must_follow_check_in_date, room_rate_format_is_invalid]
-          result.errors.for(:transaction).for(:industry).for(:additional_charges).for(:index_0).on(:kind).map { |e| e.code }.sort.should include *[invalid_additional_charge_kind]
+          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should include(*[invalid_folio, check_out_date_must_follow_check_in_date, room_rate_format_is_invalid])
+          result.errors.for(:transaction).for(:industry).for(:additional_charges).for(:index_0).on(:kind).map { |e| e.code }.sort.should include(*[invalid_additional_charge_kind])
         end
       end
 
@@ -272,7 +329,7 @@ describe Braintree::Transaction do
                 :lodging_check_out_date => "2014-07-07",
                 :lodging_name => "Royal Caribbean",
               }
-            }
+            },
           )
           result.success?.should be(true)
         end
@@ -290,7 +347,7 @@ describe Braintree::Transaction do
               :data => {
                 :lodging_name => "Royal Caribbean"
               }
-            }
+            },
           )
           result.success?.should be(false)
           result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == [Braintree::ErrorCodes::Transaction::Industry::TravelCruise::TravelPackageIsInvalid]
@@ -364,7 +421,7 @@ describe Braintree::Transaction do
                   }
                 ]
               }
-            }
+            },
           )
           result.success?.should be(true)
         end
@@ -388,7 +445,7 @@ describe Braintree::Transaction do
                   }
                 ]
               }
-            }
+            },
           )
           result.success?.should be(false)
           result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == [Braintree::ErrorCodes::Transaction::Industry::TravelFlight::FareAmountCannotBeNegative]
@@ -407,7 +464,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Elo,
             :cvv => "737",
             :expiration_date => "10/2020"
-          }
+          },
         )
         result.success?.should == true
         result.transaction.id.should =~ /^\w{6,}$/
@@ -429,7 +486,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.id.should =~ /^\w{6,}$/
@@ -445,6 +502,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
@@ -454,7 +512,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       expect(result.success?).to eq(true)
       expect(result.transaction.type).to eq("sale")
@@ -476,7 +534,7 @@ describe Braintree::Transaction do
       oauth_gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
       access_token = Braintree::OAuthTestHelper.create_token(oauth_gateway, {
         :merchant_public_id => "integration_merchant_id",
@@ -485,7 +543,7 @@ describe Braintree::Transaction do
 
       gateway = Braintree::Gateway.new(
         :access_token => access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.transaction.create(
@@ -494,7 +552,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result.success?.should == true
@@ -509,7 +567,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 +575,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
@@ -538,7 +595,7 @@ describe Braintree::Transaction do
           :customer_ip => "192.168.0.1",
           :customer_location_zip => "91244",
           :customer_tenure => "20",
-        }
+        },
       )
 
       result.success?.should == true
@@ -548,7 +605,7 @@ describe Braintree::Transaction do
       result = Braintree::Customer.create()
       address_result = Braintree::Address.create(
         :customer_id => result.customer.id,
-        :country_code_alpha2 => "US"
+        :country_code_alpha2 => "US",
       )
 
       result = Braintree::Transaction.create(
@@ -559,7 +616,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result.success?.should == true
@@ -572,7 +629,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == false
       result.transaction.id.should =~ /^\w{6,}$/
@@ -591,7 +648,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == false
       result.transaction.id.should =~ /^\w{6,}$/
@@ -628,7 +685,7 @@ describe Braintree::Transaction do
         :options => {
           :add_billing_address_to_payment_method => true,
           :store_in_vault => true
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -658,7 +715,7 @@ describe Braintree::Transaction do
         :billing => {
           :country_name => "Botswana",
           :country_code_alpha2 => "US",
-        }
+        },
       )
 
       result.success?.should == false
@@ -674,7 +731,7 @@ describe Braintree::Transaction do
         },
         :billing => {
           :country_code_alpha2 => "ZZ"
-        }
+        },
       )
 
       result.success?.should == false
@@ -691,7 +748,7 @@ describe Braintree::Transaction do
         },
         :billing => {
           :country_code_alpha3 => "ZZZ"
-        }
+        },
       )
 
       result.success?.should == false
@@ -708,7 +765,7 @@ describe Braintree::Transaction do
         },
         :billing => {
           :country_code_numeric => "FOO"
-        }
+        },
       )
 
       result.success?.should == false
@@ -739,7 +796,7 @@ describe Braintree::Transaction do
         },
         :shipping => {
           :phone_number => "123-234-3456=098765"
-        }
+        },
       )
 
       result.success?.should == false
@@ -755,7 +812,7 @@ describe Braintree::Transaction do
         },
         :shipping => {
           :shipping_method => "urgent"
-        }
+        },
       )
 
       result.success?.should == false
@@ -771,7 +828,7 @@ describe Braintree::Transaction do
         },
         :billing => {
           :phone_number => "123-234-3456=098765"
-        }
+        },
       )
 
       result.success?.should == false
@@ -795,7 +852,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009",
               :cvv => "200"
-            }
+            },
           )
           result.success?.should == false
           result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::CVV
@@ -810,17 +867,17 @@ describe Braintree::Transaction do
         gateway = Braintree::Gateway.new(
           :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
           :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-          :logger => Logger.new("/dev/null")
+          :logger => Logger.new("/dev/null"),
         )
         result = gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"]
+          :payment_methods => ["credit_card", "paypal"],
         )
 
         gateway = Braintree::Gateway.new(
           :access_token => result.credentials.access_token,
-          :logger => Logger.new("/dev/null")
+          :logger => Logger.new("/dev/null"),
         )
 
         result = gateway.transaction.create(
@@ -829,7 +886,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2020"
-          }
+          },
         )
         result.success?.should == false
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ApplicationIncomplete
@@ -853,7 +910,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009"
-            }
+            },
           )
           result.success?.should == false
           result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVS
@@ -883,7 +940,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009",
               :cvv => "200"
-            }
+            },
           )
           result.success?.should == false
           result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVSAndCVV
@@ -895,14 +952,14 @@ 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 => {
               :number => Braintree::Test::CreditCardNumbers::Fraud,
               :expiration_date => "05/2017",
               :cvv => "333"
-            }
+            },
           )
           result.success?.should == false
           result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::Fraud
@@ -910,14 +967,14 @@ 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 => {
               :number => Braintree::Test::CreditCardNumbers::RiskThreshold,
               :expiration_date => "05/2017",
               :cvv => "333"
-            }
+            },
           )
           result.success?.should == false
           result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::RiskThreshold
@@ -925,7 +982,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,
@@ -954,7 +1011,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_month => "05",
           :expiration_year => "2011"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.credit_card_details.expiration_month.should == "05"
@@ -962,11 +1019,39 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.expiration_date.should == "05/2011"
     end
 
+    it "accepts exchange_rate_quote_id" do
+      result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+          },
+          :exchange_rate_quote_id => "dummyExchangeRateQuoteId-Brainree-Ruby",
+      )
+      result.success?.should == true
+      result.transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+
+    it "returns an error if provided invalid exchange_rate_quote_id" do
+      result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+          },
+          :exchange_rate_quote_id => "a" * 4010,
+      )
+      result.success?.should == false
+      result.errors.for(:transaction).on(:exchange_rate_quote_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExchangeRateQuoteIdTooLong
+    end
+
     it "returns some error if customer_id is invalid" do
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Decline,
-        :customer_id => 123456789
+        :customer_id => 123456789,
       )
       result.success?.should == false
       result.errors.for(:transaction).on(:customer_id)[0].code.should == "91510"
@@ -983,7 +1068,7 @@ describe Braintree::Transaction do
         },
         :custom_fields => {
           :store_me => "custom value"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.custom_fields.should == {:store_me => "custom value"}
@@ -998,7 +1083,7 @@ describe Braintree::Transaction do
         },
         :custom_fields => {
           :store_me => ""
-        }
+        },
       )
 
       result = Braintree::Transaction.find(create_result.transaction.id)
@@ -1016,7 +1101,7 @@ describe Braintree::Transaction do
         },
         :custom_fields => {
           :invalid_key => "custom value"
-        }
+        },
       )
       result.success?.should == false
       result.errors.for(:transaction).on(:custom_fields)[0].message.should == "Custom field is invalid: invalid_key."
@@ -1035,7 +1120,7 @@ describe Braintree::Transaction do
       }
       result = Braintree::Transaction.create(params[:transaction])
       result.success?.should == false
-      result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.params.should == {:transaction => {:type => "sale", :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
     end
 
     it "returns errors if validations fail (tests many errors at once for spec speed)" do
@@ -1055,7 +1140,7 @@ describe Braintree::Transaction do
       }
       result = Braintree::Transaction.create(params[:transaction])
       result.success?.should == false
-      result.errors.for(:transaction).on(:base).map{|error| error.code}.should include(Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer)
+      result.errors.for(:transaction).on(:base).map { |error| error.code }.should include(Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer)
       result.errors.for(:transaction).on(:customer_id)[0].code.should == Braintree::ErrorCodes::Transaction::CustomerIdIsInvalid
       result.errors.for(:transaction).on(:payment_method_token)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodTokenIsInvalid
       result.errors.for(:transaction).on(:type)[0].code.should == Braintree::ErrorCodes::Transaction::TypeIsInvalid
@@ -1086,7 +1171,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :account_type => "credit",
           }
-        }
+        },
       )
       result.success?.should == false
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountNotSupportedByProcessor
@@ -1130,13 +1215,13 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :customer_id => customer.id,
-        :payment_method_token => customer.credit_cards[0].token + "x"
+        :payment_method_token => customer.credit_cards[0].token + "x",
       )
       result.success?.should == false
       result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer
@@ -1148,7 +1233,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2010"
-          }
+          },
         )
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -1157,7 +1242,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12"
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.masked_number.should == "401288******1881"
@@ -1169,7 +1254,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2010"
-          }
+          },
         )
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -1179,7 +1264,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :options => { :store_in_vault => true }
+          :options => {:store_in_vault => true},
         )
         result.success?.should == true
         result.transaction.credit_card_details.masked_number.should == "401288******1881"
@@ -1193,7 +1278,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
 
       result = Braintree::Subscription.create(
@@ -1224,7 +1309,7 @@ describe Braintree::Transaction do
               :never_expires => true
             }
           ]
-        }
+        },
       )
 
       result.success?.should be(true)
@@ -1265,15 +1350,15 @@ describe Braintree::Transaction do
             :expiration_date => "05/2009"
           },
           :descriptor => {
-            :name => '123*123456789012345678',
-            :phone => '3334445555',
+            :name => "123*123456789012345678",
+            :phone => "3334445555",
             :url => "ebay.com"
-          }
+          },
         )
         result.success?.should == true
-        result.transaction.descriptor.name.should == '123*123456789012345678'
-        result.transaction.descriptor.phone.should == '3334445555'
-        result.transaction.descriptor.url.should == 'ebay.com'
+        result.transaction.descriptor.name.should == "123*123456789012345678"
+        result.transaction.descriptor.phone.should == "3334445555"
+        result.transaction.descriptor.url.should == "ebay.com"
       end
 
       it "has validation errors if format is invalid" do
@@ -1284,10 +1369,10 @@ describe Braintree::Transaction do
             :expiration_date => "05/2009"
           },
           :descriptor => {
-            :name => 'badcompanyname12*badproduct12',
-            :phone => '%bad4445555',
-            :url => '12345678901234'
-          }
+            :name => "badcompanyname12*badproduct12",
+            :phone => "%bad4445555",
+            :url => "12345678901234"
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:descriptor).on(:name)[0].code.should == Braintree::ErrorCodes::Descriptor::NameFormatIsInvalid
@@ -1304,14 +1389,14 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
           },
-          :tax_amount => '0.05',
+          :tax_amount => "0.05",
           :tax_exempt => false,
-          :purchase_order_number => '12345678901234567'
+          :purchase_order_number => "12345678901234567",
         )
         result.success?.should == true
         result.transaction.tax_amount.should == BigDecimal("0.05")
         result.transaction.tax_exempt.should == false
-        result.transaction.purchase_order_number.should == '12345678901234567'
+        result.transaction.purchase_order_number.should == "12345678901234567"
       end
 
       it "accepts tax_amount as a BigDecimal" do
@@ -1321,8 +1406,8 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
           },
-          :tax_amount => BigDecimal('1.99'),
-          :tax_exempt => true
+          :tax_amount => BigDecimal("1.99"),
+          :tax_exempt => true,
         )
         result.success?.should == true
         result.transaction.tax_amount.should == BigDecimal("1.99")
@@ -1338,7 +1423,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009"
             },
-            :tax_amount => 'abcd'
+            :tax_amount => "abcd",
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:tax_amount)[0].code.should == Braintree::ErrorCodes::Transaction::TaxAmountFormatIsInvalid
@@ -1351,7 +1436,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009"
             },
-            :purchase_order_number => 'a' * 18
+            :purchase_order_number => "a" * 18,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:purchase_order_number)[0].code.should == Braintree::ErrorCodes::Transaction::PurchaseOrderNumberIsTooLong
@@ -1364,7 +1449,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/2009"
             },
-            :purchase_order_number => "\303\237\303\245\342\210\202"
+            :purchase_order_number => "\303\237\303\245\342\210\202",
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:purchase_order_number)[0].code.should == Braintree::ErrorCodes::Transaction::PurchaseOrderNumberIsInvalid
@@ -1372,22 +1457,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(
@@ -1397,7 +1466,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :transaction_source => "recurring_first"
+          :transaction_source => "recurring_first",
         )
         result.success?.should == true
         result.transaction.recurring.should == true
@@ -1411,7 +1480,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :transaction_source => "recurring"
+          :transaction_source => "recurring",
         )
         result.success?.should == true
         result.transaction.recurring.should == true
@@ -1425,7 +1494,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :transaction_source => "merchant"
+          :transaction_source => "merchant",
         )
         result.success?.should == true
         result.transaction.recurring.should == false
@@ -1439,7 +1508,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :transaction_source => "moto"
+          :transaction_source => "moto",
         )
         result.success?.should == true
         result.transaction.recurring.should == false
@@ -1453,7 +1522,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :transaction_source => "invalid_value"
+          :transaction_source => "invalid_value",
         )
         result.success?.should == false
         result.errors.for(:transaction).on(:transaction_source)[0].code.should == Braintree::ErrorCodes::Transaction::TransactionSourceIsInvalid
@@ -1473,7 +1542,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :options => { :store_in_vault_on_success => true }
+            :options => {:store_in_vault_on_success => true},
           )
           result.success?.should == true
           result.transaction.vault_customer.last_name.should == "Doe"
@@ -1492,7 +1561,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :options => { :store_in_vault_on_success => true }
+            :options => {:store_in_vault_on_success => true},
           )
           result.success?.should == false
           result.transaction.vault_customer.should be_nil
@@ -1512,7 +1581,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :options => { :store_in_vault_on_success => false }
+            :options => {:store_in_vault_on_success => false},
           )
           result.success?.should == true
           result.transaction.vault_customer.should be_nil
@@ -1530,7 +1599,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :options => { :store_in_vault_on_success => false }
+            :options => {:store_in_vault_on_success => false},
           )
           result.success?.should == false
           result.transaction.vault_customer.should be_nil
@@ -1549,7 +1618,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :service_fee_amount => "1.00"
+          :service_fee_amount => "1.00",
         )
         result.success?.should == true
         result.transaction.service_fee_amount.should == BigDecimal("1.00")
@@ -1564,7 +1633,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :service_fee_amount => "1.00"
+          :service_fee_amount => "1.00",
         )
         result.success?.should == false
         expected_error_code = Braintree::ErrorCodes::Transaction::ServiceFeeAmountNotAllowedOnMasterMerchantAccount
@@ -1579,7 +1648,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
-          }
+          },
         )
         result.success?.should == false
         expected_error_code = Braintree::ErrorCodes::Transaction::SubMerchantAccountRequiresServiceFeeAmount
@@ -1589,7 +1658,7 @@ describe Braintree::Transaction do
       it "raises an error if service fee amount is negative" do
         result = Braintree::Transaction.create(
           :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "-1.00"
+          :service_fee_amount => "-1.00",
         )
         result.success?.should == false
         result.errors.for(:transaction).on(:service_fee_amount)[0].code.should == Braintree::ErrorCodes::Transaction::ServiceFeeAmountCannotBeNegative
@@ -1598,7 +1667,7 @@ describe Braintree::Transaction do
       it "raises an error if service fee amount is invalid" do
         result = Braintree::Transaction.create(
           :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "invalid amount"
+          :service_fee_amount => "invalid amount",
         )
         result.success?.should == false
         result.errors.for(:transaction).on(:service_fee_amount)[0].code.should == Braintree::ErrorCodes::Transaction::ServiceFeeAmountFormatIsInvalid
@@ -1616,7 +1685,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :service_fee_amount => "10.00",
-          :options => {:hold_in_escrow => true}
+          :options => {:hold_in_escrow => true},
         )
 
         result.success?.should == true
@@ -1633,7 +1702,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :service_fee_amount => "1.00",
-          :options => {:hold_in_escrow => true}
+          :options => {:hold_in_escrow => true},
         )
         result.success?.should == false
         expected_error_code = Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
@@ -1646,7 +1715,7 @@ describe Braintree::Transaction do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode
+          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode,
         )
         result.success?.should == true
         result.transaction.credit_card_details.bin.should == "400934"
@@ -1663,7 +1732,7 @@ describe Braintree::Transaction do
           },
           :options => {
             :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.venmo_sdk?.should == false
@@ -1678,14 +1747,14 @@ describe Braintree::Transaction do
             :expiration_month => "11",
             :expiration_year => "2099",
           },
-          :share => true
+          :share => true,
         )
         nonce.should_not be_nil
 
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
         result.success?.should == true
       end
@@ -1700,14 +1769,14 @@ describe Braintree::Transaction do
           },
           :client_token_options => {
             :customer_id => customer.id,
-          }
+          },
         )
         nonce.should_not be_nil
 
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
         result.success?.should == true
       end
@@ -1720,14 +1789,14 @@ describe Braintree::Transaction do
           },
           :client_token_options => {
             :customer_id => customer.id,
-          }
+          },
         )
         nonce.should_not be_nil
 
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
         result.success?.should == true
         result.transaction.paypal_details.should_not be_nil
@@ -1739,14 +1808,14 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
         result.success?.should == true
         result.transaction.paypal_details.should_not be_nil
@@ -1758,7 +1827,7 @@ describe Braintree::Transaction do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         )
         result.success?.should == true
         result.transaction.should_not be_nil
@@ -1788,7 +1857,7 @@ describe Braintree::Transaction do
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
-          :options => { :store_in_vault_on_success => true }
+          :options => {:store_in_vault_on_success => true},
         )
         result.success?.should == true
         result.transaction.should_not be_nil
@@ -1804,106 +1873,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,
-          :options => { :store_in_vault_on_success => true }
+          :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
-        )
-        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}
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
         )
         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
@@ -1912,7 +1958,7 @@ describe Braintree::Transaction do
           :merchant_account_id => SpecHelper::FakeVenmoAccountMerchantAccountId,
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
-          :options => {:store_in_vault => true}
+          :options => {:store_in_vault => true},
         )
         result.should be_success
 
@@ -1921,7 +1967,7 @@ describe Braintree::Transaction do
         venmo_account_details.should be_a(Braintree::Transaction::VenmoAccountDetails)
         venmo_account_details.token.should respond_to(:to_str)
         venmo_account_details.username.should == "venmojoe"
-        venmo_account_details.venmo_user_id.should == "Venmo-Joe-1"
+        venmo_account_details.venmo_user_id.should == "1234567891234567891"
         venmo_account_details.image_url.should include(".png")
         venmo_account_details.source_description.should == "Venmo Account: venmojoe"
       end
@@ -1932,7 +1978,7 @@ describe Braintree::Transaction do
           :merchant_account_id => SpecHelper::FakeVenmoAccountMerchantAccountId,
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
-          :options => {:store_in_vault => true, :venmo => {:profile_id => "integration_venmo_merchant_public_id" }}
+          :options => {:store_in_vault => true, :venmo => {:profile_id => "integration_venmo_merchant_public_id"}},
         )
         result.should be_success
       end
@@ -1942,7 +1988,7 @@ describe Braintree::Transaction do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable
+          :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable,
         )
         result.success?.should == true
         result.transaction.should_not be_nil
@@ -1957,7 +2003,7 @@ describe Braintree::Transaction do
           :paypal_account => {
             :payer_id => "PAYER-1234",
             :payment_id => "PAY-5678",
-          }
+          },
         )
 
         result.success?.should == true
@@ -1971,7 +2017,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -1981,7 +2027,7 @@ describe Braintree::Transaction do
           :payment_method_nonce => nonce,
           :paypal_account => {
             :payee_id => "fake-payee-id"
-          }
+          },
         )
 
         result.success?.should == true
@@ -1995,7 +2041,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2006,7 +2052,7 @@ describe Braintree::Transaction do
           :paypal_account => {},
           :options => {
             :payee_id => "fake-payee-id"
-          }
+          },
         )
 
         result.success?.should == true
@@ -2020,7 +2066,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2032,7 +2078,7 @@ describe Braintree::Transaction do
             :paypal => {
               :payee_id => "fake-payee-id"
             }
-          }
+          },
         )
 
         result.success?.should == true
@@ -2046,7 +2092,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2056,7 +2102,7 @@ describe Braintree::Transaction do
           :payment_method_nonce => nonce,
           :paypal_account => {
             :payee_email => "bt_seller_us@paypal.com"
-          }
+          },
         )
 
         result.success?.should == true
@@ -2070,7 +2116,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2081,7 +2127,7 @@ describe Braintree::Transaction do
           :paypal_account => {},
           :options => {
             :payee_email => "bt_seller_us@paypal.com"
-          }
+          },
         )
 
         result.success?.should == true
@@ -2095,7 +2141,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2107,7 +2153,7 @@ describe Braintree::Transaction do
             :paypal => {
               :payee_email => "bt_seller_us@paypal.com"
             }
-          }
+          },
         )
 
         result.success?.should == true
@@ -2121,7 +2167,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2133,7 +2179,7 @@ describe Braintree::Transaction do
             :paypal => {
               :custom_field => "Additional info"
             }
-          }
+          },
         )
 
         result.success?.should == true
@@ -2147,7 +2193,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2159,7 +2205,7 @@ describe Braintree::Transaction do
             :paypal => {
               :description => "A great product"
             }
-          }
+          },
         )
 
         result.success?.should == true
@@ -2173,7 +2219,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_new_payment_method(
           :paypal_account => {
             :consent_code => "PAYPAL_CONSENT_CODE",
-          }
+          },
         )
         nonce.should_not be_nil
 
@@ -2188,7 +2234,7 @@ describe Braintree::Transaction do
                 :key2 => "value2",
               }
             }
-          }
+          },
         )
 
         # note - supplementary data is not returned in response
@@ -2202,7 +2248,7 @@ describe Braintree::Transaction do
           SpecHelper::ThreeDSecureMerchantAccountId,
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_month => "12",
-          :expiration_year => "2012"
+          :expiration_year => "2012",
         )
 
         result = Braintree::Transaction.create(
@@ -2213,7 +2259,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
           },
-          :three_d_secure_token => three_d_secure_token
+          :three_d_secure_token => three_d_secure_token,
         )
 
         result.success?.should == true
@@ -2225,7 +2271,7 @@ describe Braintree::Transaction do
             :number => "4111111111111111",
             :expiration_month => "11",
             :expiration_year => "2099",
-          }
+          },
         )
         nonce.should_not be_nil
         result = Braintree::Transaction.create(
@@ -2237,7 +2283,7 @@ describe Braintree::Transaction do
             :three_d_secure => {
               :required => true,
             }
-          }
+          },
         )
 
         result.success?.should == false
@@ -2253,7 +2299,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "12/12",
-          }
+          },
         )
         result.success?.should == true
       end
@@ -2264,7 +2310,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2022"
+            :expiration_year => "2022",
           )
 
           result = Braintree::Transaction.create(
@@ -2275,7 +2321,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/22",
             },
-            :three_d_secure_authentication_id => three_d_secure_authentication_id
+            :three_d_secure_authentication_id => three_d_secure_authentication_id,
           )
 
           result.success?.should == true
@@ -2289,7 +2335,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :three_d_secure_authentication_id => nil
+            :three_d_secure_authentication_id => nil,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationIdIsInvalid
@@ -2299,7 +2345,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2012"
+            :expiration_year => "2012",
           )
 
           result = Braintree::Transaction.create(
@@ -2309,7 +2355,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::MasterCard,
               :expiration_date => "12/12",
             },
-            :three_d_secure_authentication_id => three_d_secure_authentication_id
+            :three_d_secure_authentication_id => three_d_secure_authentication_id,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionPaymentMethodDoesntMatchThreeDSecureAuthenticationPaymentMethod
@@ -2319,7 +2365,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2012"
+            :expiration_year => "2012",
           )
 
           result = Braintree::Transaction.create(
@@ -2330,7 +2376,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::MasterCard,
               :expiration_date => "12/12",
             },
-            :three_d_secure_authentication_id => three_d_secure_authentication_id
+            :three_d_secure_authentication_id => three_d_secure_authentication_id,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionPaymentMethodDoesntMatchThreeDSecureAuthenticationPaymentMethod
@@ -2340,7 +2386,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2012"
+            :expiration_year => "2012",
           )
           result = Braintree::Transaction.create(
             :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
@@ -2360,7 +2406,7 @@ describe Braintree::Transaction do
               :directory_response => "Y",
               :cavv_algorithm => "2",
               :ds_transaction_id => "some_ds_id",
-            }
+            },
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationIdWithThreeDSecurePassThruIsInvalid
@@ -2373,7 +2419,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2012"
+            :expiration_year => "2012",
           )
 
           result = Braintree::Transaction.create(
@@ -2384,7 +2430,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :three_d_secure_token => three_d_secure_token
+            :three_d_secure_token => three_d_secure_token,
           )
 
           result.success?.should == true
@@ -2399,7 +2445,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "12/12",
             },
-            :three_d_secure_token => nil
+            :three_d_secure_token => nil,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTokenIsInvalid
@@ -2410,7 +2456,7 @@ describe Braintree::Transaction do
             SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "12",
-            :expiration_year => "2012"
+            :expiration_year => "2012",
           )
 
           result = Braintree::Transaction.create(
@@ -2421,7 +2467,7 @@ describe Braintree::Transaction do
               :number => Braintree::Test::CreditCardNumbers::MasterCard,
               :expiration_date => "12/12",
             },
-            :three_d_secure_token => three_d_secure_token
+            :three_d_secure_token => three_d_secure_token,
           )
           result.success?.should == false
           result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionDataDoesntMatchVerify
@@ -2445,7 +2491,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
 
         result.success?.should == true
@@ -2470,7 +2516,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).on(:merchant_account_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureMerchantAccountDoesNotSupportCardType
@@ -2488,7 +2534,7 @@ describe Braintree::Transaction do
             :eci_flag => "",
             :cavv => "some_cavv",
             :xid => "some_xid",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:eci_flag)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureEciFlagIsRequired
@@ -2511,7 +2557,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:cavv)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureCavvIsRequired
@@ -2534,7 +2580,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:eci_flag)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureEciFlagIsInvalid
@@ -2557,7 +2603,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:three_d_secure_version)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureThreeDSecureVersionIsInvalid
@@ -2581,7 +2627,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:authentication_response)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationResponseIsInvalid
@@ -2605,7 +2651,7 @@ describe Braintree::Transaction do
             :directory_response => "abc",
             :cavv_algorithm => "2",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:directory_response)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureDirectoryResponseIsInvalid
@@ -2629,7 +2675,7 @@ describe Braintree::Transaction do
             :directory_response => "Y",
             :cavv_algorithm => "bad_alg",
             :ds_transaction_id => "some_ds_id",
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:cavv_algorithm)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureCavvAlgorithmIsInvalid
@@ -2641,12 +2687,12 @@ describe Braintree::Transaction do
         it "can create a transaction" do
           payment_method_result = Braintree::PaymentMethod.create(
             :customer_id => Braintree::Customer.create.customer.id,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
           )
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_token => payment_method_result.payment_method.token
+            :payment_method_token => payment_method_result.payment_method.token,
           )
 
           result.should be_success
@@ -2661,13 +2707,13 @@ describe Braintree::Transaction do
           payment_method_token = rand(36**3).to_s(36)
           nonce = nonce_for_paypal_account(
             :consent_code => "PAYPAL_CONSENT_CODE",
-            :token => payment_method_token
+            :token => payment_method_token,
           )
 
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => nonce
+            :payment_method_nonce => nonce,
           )
 
           result.should be_success
@@ -2683,14 +2729,14 @@ describe Braintree::Transaction do
           payment_method_token = rand(36**3).to_s(36)
           nonce = nonce_for_paypal_account(
             :consent_code => "PAYPAL_CONSENT_CODE",
-            :token => payment_method_token
+            :token => payment_method_token,
           )
 
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :payment_method_nonce => nonce,
-            :options => {:store_in_vault => true}
+            :options => {:store_in_vault => true},
           )
 
           result.success?.should == true
@@ -2703,12 +2749,28 @@ 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(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => Braintree::Test::Nonce::LocalPayment
+            :payment_method_nonce => Braintree::Test::Nonce::LocalPayment,
           )
 
           result.should be_success
@@ -2726,7 +2788,7 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
           )
 
           result.should be_success
@@ -2738,14 +2800,14 @@ describe Braintree::Transaction do
           payment_method_token = rand(36**3).to_s(36)
           nonce = nonce_for_paypal_account(
             :access_token => "PAYPAL_ACCESS_TOKEN",
-            :token => payment_method_token
+            :token => payment_method_token,
           )
 
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :payment_method_nonce => nonce,
-            :options => {:store_in_vault => true}
+            :options => {:store_in_vault => true},
           )
 
           result.success?.should == true
@@ -2765,7 +2827,7 @@ describe Braintree::Transaction do
             :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
             :options => {
               :submit_for_settlement => true
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::Settling
@@ -2776,7 +2838,7 @@ describe Braintree::Transaction do
         it "successfully voids a paypal transaction that's been authorized" do
           sale_transaction = Braintree::Transaction.sale!(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
           )
 
           void_transaction = Braintree::Transaction.void!(sale_transaction.id)
@@ -2787,7 +2849,7 @@ describe Braintree::Transaction do
         it "fails to void a paypal transaction that's been declined" do
           sale_transaction = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Decline,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
           ).transaction
 
           expect do
@@ -2857,6 +2919,19 @@ describe Braintree::Transaction do
           result.transaction.amount.should == transaction.amount/2
         end
 
+        it "allows merchant_account_id to be passed for the refund" do
+          transaction = create_transaction_to_refund
+
+          result = Braintree::Transaction.refund(
+            transaction.id,
+            :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          )
+
+          result.success?.should == true
+          result.transaction.type.should == "credit"
+          result.transaction.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+        end
+
         it "does not allow arbitrary options to be passed" do
           transaction = create_paypal_transaction_for_refund
 
@@ -2865,14 +2940,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
@@ -2883,7 +2950,7 @@ describe Braintree::Transaction do
         it "returns an error result if unsettled" do
           transaction = Braintree::Transaction.sale!(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
           )
           result = Braintree::Transaction.refund(transaction.id)
           result.success?.should == false
@@ -2896,13 +2963,19 @@ describe Braintree::Transaction do
             :payment_method_nonce => Braintree::Test::Nonce::Transactable,
             :options => {
               :submit_for_settlement => true
-            }
+            },
           )
           config = Braintree::Configuration.instantiate
           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
@@ -2911,13 +2984,19 @@ describe Braintree::Transaction do
             :payment_method_nonce => Braintree::Test::Nonce::Transactable,
             :options => {
               :submit_for_settlement => true
-            }
+            },
           )
           config = Braintree::Configuration.instantiate
           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
 
@@ -2925,13 +3004,13 @@ describe Braintree::Transaction do
         it "handles bad unvalidated nonces" do
           nonce = nonce_for_paypal_account(
             :access_token => "PAYPAL_ACCESS_TOKEN",
-            :consent_code => "PAYPAL_CONSENT_CODE"
+            :consent_code => "PAYPAL_CONSENT_CODE",
           )
 
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => nonce
+            :payment_method_nonce => nonce,
           )
 
           result.should_not be_success
@@ -2942,7 +3021,7 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.create(
             :type => "sale",
             :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :payment_method_nonce => "NON_EXISTENT_NONCE"
+            :payment_method_nonce => "NON_EXISTENT_NONCE",
           )
 
           result.should_not be_success
@@ -4070,7 +4149,7 @@ describe Braintree::Transaction do
                 :unit_of_measure => "gallon",
                 :total_amount => "10.1",
               },
-              ['Name #2'],
+              ["Name #2"],
               {
                 :quantity => "2.02",
                 :name => "Name #3",
@@ -4256,7 +4335,7 @@ describe Braintree::Transaction do
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
         payment_method_token = result.payment_method.token
 
@@ -4289,7 +4368,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 +4420,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 => {
@@ -4355,14 +4434,14 @@ describe Braintree::Transaction do
             :amount => "10.00",
           )
           result.success?.should == true
-          result.transaction.network_transaction_id.should be_nil
+          result.transaction.network_transaction_id.should_not be_nil
         end
 
         it "accepts blank previous_network_transaction_id" 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 => {
@@ -4372,27 +4451,9 @@ describe Braintree::Transaction do
             :amount => "10.00",
           )
           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
+          result.transaction.network_transaction_id.should_not be_nil
         end
       end
-
     end
 
     context "account_type" do
@@ -4409,7 +4470,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :account_type => "credit",
             }
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.account_type.should == "credit"
@@ -4428,7 +4489,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :account_type => "credit",
             }
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.account_type.should == "credit"
@@ -4448,7 +4509,7 @@ describe Braintree::Transaction do
               :account_type => "debit",
             },
             :submit_for_settlement => true,
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.account_type.should == "debit"
@@ -4467,7 +4528,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :account_type => "debit",
             },
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeDebitDoesNotSupportAuths
@@ -4486,7 +4547,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :account_type => "ach",
             },
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeIsInvalid
@@ -4504,7 +4565,7 @@ describe Braintree::Transaction do
             :credit_card => {
               :account_type => "credit",
             },
-          }
+          },
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeNotSupported
@@ -4520,7 +4581,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       transaction.id.should =~ /^\w{6,}$/
       transaction.type.should == "sale"
@@ -4538,7 +4599,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
-          }
+          },
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
@@ -4571,14 +4632,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
@@ -4602,7 +4655,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result = Braintree::Transaction.refund(transaction.id)
       result.success?.should == false
@@ -4639,7 +4692,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.id.should =~ /^\w{6,}$/
@@ -4695,7 +4748,7 @@ describe Braintree::Transaction do
           :postal_code => "60103",
           :country_name => "United States of America",
           :shipping_method => Braintree::Transaction::AddressDetails::ShippingMethod::Electronic
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -4759,7 +4812,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
@@ -4771,7 +4824,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.merchant_account_id.should == SpecHelper::DefaultMerchantAccountId
@@ -4790,7 +4843,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :store_in_vault => true
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -4825,7 +4878,7 @@ describe Braintree::Transaction do
         :options => {
           :store_in_vault => true,
           :add_billing_address_to_payment_method => true,
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -4870,7 +4923,7 @@ describe Braintree::Transaction do
         :options => {
           :store_in_vault => true,
           :store_shipping_address_in_vault => true,
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -4896,7 +4949,7 @@ describe Braintree::Transaction do
           :number => "5105105105105100",
           :expiration_date => "05/2012"
         },
-        :options => { :store_in_vault => true }
+        :options => {:store_in_vault => true},
       )
 
       result.success?.should == true
@@ -4914,7 +4967,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :submit_for_settlement => true
-        }
+        },
       )
       result.success?.should == true
       result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
@@ -4937,7 +4990,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :store_in_vault => true
-        }
+        },
       )
       result.success?.should == true
       transaction = result.transaction
@@ -4952,20 +5005,20 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       address = Braintree::Address.create!(
         :customer_id => customer.id,
-        :street_address => '123 Fake St.'
+        :street_address => "123 Fake St.",
       )
       result = Braintree::Transaction.sale(
         :amount => "100",
         :customer_id => customer.id,
-        :shipping_address_id => address.id
+        :shipping_address_id => address.id,
       )
       result.success?.should == true
       transaction = result.transaction
-      transaction.shipping_details.street_address.should == '123 Fake St.'
+      transaction.shipping_details.street_address.should == "123 Fake St."
       transaction.customer_details.id.should == customer.id
       transaction.shipping_details.id.should == address.id
     end
@@ -4982,12 +5035,95 @@ describe Braintree::Transaction do
       }
       result = Braintree::Transaction.sale(params[:transaction])
       result.success?.should == false
-      result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.params.should == {:transaction => {:type => "sale", :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
       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 "validates tax_amount for Aib domestic sweden transaction and returns error" do
+      params = {
+          :transaction => {
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AibSwedenMaMerchantAccountId,
+              :credit_card => {
+                  :number => Braintree::Test::CreditCardNumbers::Visa,
+                  :expiration_date => "05/2030"
+              }
+          }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:tax_amount)[0].code.should == Braintree::ErrorCodes::Transaction::TaxAmountIsRequiredForAibSwedish
+    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 => {
@@ -4996,7 +5132,7 @@ describe Braintree::Transaction do
           },
           :options => {
             :skip_advanced_fraud_checking => true
-          }
+          },
         )
         result.success?.should == true
         result.transaction.risk_data.should be_nil
@@ -5020,11 +5156,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 +5179,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 +5195,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",
@@ -5090,7 +5226,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
@@ -5112,7 +5248,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
@@ -5134,7 +5270,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
@@ -5157,7 +5293,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
 
@@ -5181,7 +5317,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::Authorized
@@ -5206,7 +5342,7 @@ describe Braintree::Transaction do
                 :currency_amount => "10.00",
                 :currency_iso_code => "USD"
               }
-            }
+            },
           )
           result.success?.should == true
           result.transaction.status.should == Braintree::Transaction::Status::Authorized
@@ -5226,7 +5362,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       transaction.id.should =~ /^\w{6,}$/
       transaction.type.should == "sale"
@@ -5243,7 +5379,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
-          }
+          },
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
@@ -5256,7 +5392,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
       result = Braintree::Transaction.submit_for_settlement(transaction.id)
       result.success?.should == true
@@ -5268,7 +5404,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
       transaction.amount.should == BigDecimal("1000.00")
       result = Braintree::Transaction.submit_for_settlement(transaction.id, "999.99")
@@ -5284,9 +5420,9 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
-      options = { :order_id => "ABC123" }
+      options = {:order_id => "ABC123"}
       result = Braintree::Transaction.submit_for_settlement(transaction.id, nil, options)
       result.success?.should == true
       result.transaction.order_id.should == "ABC123"
@@ -5299,13 +5435,13 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
 
       options = {
         :descriptor => {
-          :name => '123*123456789012345678',
-          :phone => '3334445555',
+          :name => "123*123456789012345678",
+          :phone => "3334445555",
           :url => "ebay.com"
         }
       }
@@ -5313,9 +5449,9 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.submit_for_settlement(transaction.id, nil, options)
       result.success?.should == true
       result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
-      result.transaction.descriptor.name.should == '123*123456789012345678'
-      result.transaction.descriptor.phone.should == '3334445555'
-      result.transaction.descriptor.url.should == 'ebay.com'
+      result.transaction.descriptor.name.should == "123*123456789012345678"
+      result.transaction.descriptor.phone.should == "3334445555"
+      result.transaction.descriptor.url.should == "ebay.com"
     end
 
     it "raises an error if an invalid option is passed in" do
@@ -5324,10 +5460,10 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
 
-      options = { :order_id => "ABC123", :invalid_option => "i'm invalid" }
+      options = {:order_id => "ABC123", :invalid_option => "i'm invalid"}
 
       expect do
         Braintree::Transaction.submit_for_settlement(transaction.id, nil, options)
@@ -5337,10 +5473,11 @@ describe Braintree::Transaction do
     it "returns an error result if settlement is too large" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
       transaction.amount.should == BigDecimal("1000.00")
       result = Braintree::Transaction.submit_for_settlement(transaction.id, "1000.01")
@@ -5355,7 +5492,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       ).transaction
       result = Braintree::Transaction.submit_for_settlement(transaction.id)
       result.success?.should == false
@@ -5372,7 +5509,7 @@ describe Braintree::Transaction do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "06/2009"
           },
-          :service_fee_amount => "1.00"
+          :service_fee_amount => "1.00",
         ).transaction
         result = Braintree::Transaction.submit_for_settlement(transaction.id, "0.01")
         result.success?.should == false
@@ -5395,7 +5532,7 @@ describe Braintree::Transaction do
             :currency_amount => "10.00",
             :currency_iso_code => "USD"
           }
-        }
+        },
       )
       result.success?.should == true
 
@@ -5419,7 +5556,7 @@ describe Braintree::Transaction do
             :currency_amount => "10.00",
             :currency_iso_code => "USD"
           }
-        }
+        },
       )
       result.success?.should == true
 
@@ -5439,7 +5576,7 @@ describe Braintree::Transaction do
             :discount_amount => "12.00",
             :tax_amount => "0",
           },
-        ]
+        ],
       )
       result.success?.should == true
       result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
@@ -5453,9 +5590,9 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
-      options = { :order_id => "ABC123" }
+      options = {:order_id => "ABC123"}
       transaction = Braintree::Transaction.submit_for_settlement!(original_transaction.id, "0.01", options)
       transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
       transaction.id.should == original_transaction.id
@@ -5465,10 +5602,11 @@ describe Braintree::Transaction do
     it "raises a ValidationsFailed if unsuccessful" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
       transaction.amount.should == BigDecimal("1000.00")
       expect do
@@ -5484,18 +5622,18 @@ describe Braintree::Transaction do
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
           :descriptor => {
-            :name => '123*123456789012345678',
-            :phone => '3334445555',
+            :name => "123*123456789012345678",
+            :phone => "3334445555",
             :url => "ebay.com"
           },
-          :order_id => '123',
+          :order_id => "123",
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "06/2009"
           },
           :options => {
             :submit_for_settlement => true
-          }
+          },
         )
       end
 
@@ -5503,16 +5641,16 @@ describe Braintree::Transaction do
         result = Braintree::Transaction.update_details(transaction.id, {
           :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
           :descriptor => {
-            :name => '456*123456789012345678',
-            :phone => '3334445555',
+            :name => "456*123456789012345678",
+            :phone => "3334445555",
             :url => "ebay.com",
           },
-          :order_id => '456'
+          :order_id => "456"
         })
         result.success?.should == true
         result.transaction.amount.should == BigDecimal(Braintree::Test::TransactionAmounts::Authorize) - 1
-        result.transaction.order_id.should == '456'
-        result.transaction.descriptor.name.should ==  '456*123456789012345678'
+        result.transaction.order_id.should == "456"
+        result.transaction.descriptor.name.should ==  "456*123456789012345678"
       end
 
       it "raises an error when a key is invalid" do
@@ -5520,11 +5658,11 @@ describe Braintree::Transaction do
           Braintree::Transaction.update_details(transaction.id, {
             :invalid_key => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
             :descriptor => {
-              :name => '456*123456789012345678',
-              :phone => '3334445555',
+              :name => "456*123456789012345678",
+              :phone => "3334445555",
               :url => "ebay.com",
             },
-            :order_id => '456'
+            :order_id => "456"
           })
         end.to raise_error(ArgumentError)
       end
@@ -5534,11 +5672,11 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.update_details(transaction.id, {
             :amount => "10000",
             :descriptor => {
-              :name => '456*123456789012345678',
-              :phone => '3334445555',
+              :name => "456*123456789012345678",
+              :phone => "3334445555",
               :url => "ebay.com",
             },
-            :order_id => '456'
+            :order_id => "456"
           })
           result.success?.should == false
           result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsTooLarge
@@ -5548,11 +5686,11 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.update_details(transaction.id, {
             :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
             :descriptor => {
-              :name => 'invalid descriptor name',
-              :phone => 'invalid phone',
-              :url => '12345678901234'
+              :name => "invalid descriptor name",
+              :phone => "invalid phone",
+              :url => "12345678901234"
             },
-            :order_id => '456'
+            :order_id => "456"
           })
           result.success?.should == false
           result.errors.for(:transaction).for(:descriptor).on(:name)[0].code.should == Braintree::ErrorCodes::Descriptor::NameFormatIsInvalid
@@ -5564,11 +5702,11 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.update_details(transaction.id, {
             :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
             :descriptor => {
-              :name => '456*123456789012345678',
-              :phone => '3334445555',
+              :name => "456*123456789012345678",
+              :phone => "3334445555",
               :url => "ebay.com",
             },
-            :order_id => 'x' * 256
+            :order_id => "x" * 256
           })
           result.success?.should == false
           result.errors.for(:transaction).on(:order_id)[0].code.should == Braintree::ErrorCodes::Transaction::OrderIdIsTooLong
@@ -5579,27 +5717,27 @@ describe Braintree::Transaction do
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
             :descriptor => {
-              :name => '123*123456789012345678',
-              :phone => '3334445555',
+              :name => "123*123456789012345678",
+              :phone => "3334445555",
               :url => "ebay.com"
             },
-            :order_id => '123',
+            :order_id => "123",
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
               :expiration_date => "05/2009"
             },
             :options => {
               :submit_for_settlement => true
-            }
+            },
           )
           result = Braintree::Transaction.update_details(transaction.id, {
             :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
             :descriptor => {
-              :name => '456*123456789012345678',
-              :phone => '3334445555',
+              :name => "456*123456789012345678",
+              :phone => "3334445555",
               :url => "ebay.com",
             },
-            :order_id => '456'
+            :order_id => "456"
           })
           result.success?.should == false
           result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::ProcessorDoesNotSupportUpdatingTransactionDetails
@@ -5613,24 +5751,24 @@ describe Braintree::Transaction do
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
           :descriptor => {
-            :name => '123*123456789012345678',
-            :phone => '3334445555',
+            :name => "123*123456789012345678",
+            :phone => "3334445555",
             :url => "ebay.com"
           },
-          :order_id => '123',
+          :order_id => "123",
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "06/2009"
-          }
+          },
         )
         result = Braintree::Transaction.update_details(transaction.id, {
           :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
           :descriptor => {
-            :name => '456*123456789012345678',
-            :phone => '3334445555',
+            :name => "456*123456789012345678",
+            :phone => "3334445555",
             :url => "ebay.com",
           },
-          :order_id => '456'
+          :order_id => "456"
         })
         result.success?.should == false
         result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotUpdateTransactionDetailsNotSubmittedForSettlement
@@ -5647,7 +5785,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)
@@ -5682,7 +5820,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100, :order_id => 1234)
@@ -5698,7 +5836,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100, :order_id => "1"*256)
@@ -5713,13 +5851,13 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(
         authorized_transaction.id,
         100,
-        :descriptor => { :name => "123*123456789012345678", :phone => "5555551234", :url => "url.com" }
+        :descriptor => {:name => "123*123456789012345678", :phone => "5555551234", :url => "url.com"},
       )
       result.success?.should == true
       partial_settlement_transaction = result.transaction
@@ -5735,7 +5873,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(
@@ -5743,9 +5881,9 @@ describe Braintree::Transaction do
         100,
         :descriptor => {
           :name => "invalid_format",
-          :phone => '%bad4445555',
-          :url => '12345678901234'
-        }
+          :phone => "%bad4445555",
+          :url => "12345678901234"
+        },
       )
       result.success?.should == false
       result.errors.for(:transaction).for(:descriptor).on(:name)[0].code.should == Braintree::ErrorCodes::Descriptor::NameFormatIsInvalid
@@ -5760,7 +5898,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)
@@ -5772,7 +5910,7 @@ describe Braintree::Transaction do
       authorized_transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :merchant_account_id => SpecHelper::FakeVenmoAccountMerchantAccountId,
-        :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount
+        :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)
@@ -5787,7 +5925,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)
@@ -5805,7 +5943,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.void(authorized_transaction.id)
@@ -5824,9 +5962,9 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
-      options = { :order_id => "ABC123" }
+      options = {:order_id => "ABC123"}
       transaction = Braintree::Transaction.submit_for_partial_settlement!(original_transaction.id, "0.01", options)
       transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
       transaction.order_id.should == options[:order_id]
@@ -5838,7 +5976,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "06/2009"
-        }
+        },
       )
       transaction.amount.should == BigDecimal("1000.00")
       expect do
@@ -5863,7 +6001,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
         },
-        :service_fee_amount => '1.00'
+        :service_fee_amount => "1.00",
       )
 
       transaction.escrow_status.should be_nil
@@ -5889,7 +6027,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
         },
-        :service_fee_amount => '1.00'
+        :service_fee_amount => "1.00",
       )
 
       transaction.escrow_status.should be_nil
@@ -5949,7 +6087,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.id.should =~ /^\w{6,}$/
@@ -5972,7 +6110,7 @@ describe Braintree::Transaction do
       }
       result = Braintree::Transaction.credit(params[:transaction])
       result.success?.should == false
-      result.params.should == {:transaction => {:type => 'credit', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.params.should == {:transaction => {:type => "credit", :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
 
@@ -5983,7 +6121,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
@@ -5995,7 +6133,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       result.transaction.merchant_account_id.should == SpecHelper::DefaultMerchantAccountId
@@ -6025,7 +6163,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       transaction.id.should =~ /^\w{6,}$/
       transaction.type.should == "credit"
@@ -6042,190 +6180,12 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
-          }
+          },
         )
       end.to raise_error(Braintree::ValidationsFailed)
     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(
@@ -6234,7 +6194,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result.success?.should == true
       created_transaction = result.transaction
@@ -6251,7 +6211,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
         },
-        :options => { :store_in_vault => true }
+        :options => {:store_in_vault => true},
       )
       result.success?.should == true
       created_transaction = result.transaction
@@ -6267,6 +6227,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 +6240,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"
@@ -6289,7 +6256,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
-          }
+          },
         )
         result.success?.should == true
         created_transaction = result.transaction
@@ -6339,7 +6306,7 @@ describe Braintree::Transaction do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2009"
-          }
+          },
         )
         result.success?.should == true
         created_transaction = result.transaction
@@ -6352,15 +6319,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
@@ -6402,7 +6375,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "12/12",
         },
-        :service_fee_amount => "10.00"
+        :service_fee_amount => "10.00",
       )
 
       result.transaction.escrow_status.should be_nil
@@ -6419,7 +6392,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       result = Braintree::Transaction.hold_in_escrow(transaction.id)
@@ -6437,7 +6410,7 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "12/12",
         },
-        :service_fee_amount => "10.00"
+        :service_fee_amount => "10.00",
       )
 
       result.transaction.escrow_status.should be_nil
@@ -6453,7 +6426,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
 
       expect do
@@ -6469,7 +6442,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       result = Braintree::Transaction.void(transaction.id)
       result.success?.should == true
@@ -6483,7 +6456,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       ).transaction
       result = Braintree::Transaction.void(transaction.id)
       result.success?.should == false
@@ -6498,7 +6471,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       )
       returned_transaction = Braintree::Transaction.void!(transaction.id)
       returned_transaction.should == transaction
@@ -6511,7 +6484,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
-        }
+        },
       ).transaction
       expect do
         Braintree::Transaction.void!(transaction.id)
@@ -6519,151 +6492,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!(
@@ -6671,12 +6499,12 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :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
 
@@ -6729,9 +6557,9 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :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
 
@@ -6742,7 +6570,7 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction.vault_credit_card.should == nil
     end
@@ -6754,9 +6582,9 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :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
 
@@ -6767,74 +6595,12 @@ describe Braintree::Transaction do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction.vault_customer.should == nil
     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,
@@ -6844,7 +6610,7 @@ describe Braintree::Transaction do
       },
       :options => {
         :submit_for_settlement => true
-      }
+      },
     )
 
     config = Braintree::Configuration.instantiate
@@ -6858,7 +6624,7 @@ describe Braintree::Transaction do
       :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
       :options => {
         :submit_for_settlement => true
-      }
+      },
     )
 
     config = Braintree::Configuration.instantiate
@@ -6874,8 +6640,8 @@ describe Braintree::Transaction do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009"
       },
-      :service_fee_amount => '1.00',
-      :options => { :hold_in_escrow => true }
+      :service_fee_amount => "1.00",
+      :options => {:hold_in_escrow => true},
     )
 
     config = Braintree::Configuration.instantiate
@@ -6889,7 +6655,7 @@ describe Braintree::Transaction do
       it "can create a transaction with venmo_sdk_payment_method_code" do
         result = Braintree::Transaction.sale(
           :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa)
+          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa),
         )
         result.success?.should == true
         result.transaction.credit_card_details.venmo_sdk?.should == false
@@ -6898,7 +6664,7 @@ describe Braintree::Transaction do
       it "errors when an invalid payment method code is passed" do
         result = Braintree::Transaction.sale(
           :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode
+          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode,
         )
         result.success?.should == false
         result.message.should include("Invalid VenmoSDK payment method code")
@@ -6916,7 +6682,7 @@ describe Braintree::Transaction do
           },
           :options => {
             :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.venmo_sdk?.should == false
@@ -6931,7 +6697,7 @@ describe Braintree::Transaction do
           },
           :options => {
             :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
-          }
+          },
         )
         result.success?.should == true
         result.transaction.credit_card_details.venmo_sdk?.should == false
@@ -6943,7 +6709,7 @@ describe Braintree::Transaction do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(
         :amount => "10.00",
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
       )
       result.success?.should == true
       result.transaction.paypal_details.payer_email.should == "payer@example.com"
@@ -6958,7 +6724,7 @@ describe Braintree::Transaction do
         :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
         :options => {
           :store_in_vault => true
-        }
+        },
       )
       result.success?.should == true
       result.transaction.paypal_details.token.should_not be_nil
@@ -6971,7 +6737,7 @@ describe Braintree::Transaction do
       customer = Braintree::Customer.create!
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       result.should be_success
@@ -6981,7 +6747,7 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.sale(
         :amount => "100",
         :customer_id => customer.id,
-        :payment_method_token => payment_method_token
+        :payment_method_token => payment_method_token,
       )
 
       result.should be_success
@@ -6996,7 +6762,7 @@ describe Braintree::Transaction do
         nonce = nonce_for_paypal_account(:token => "TOKEN")
         result = Braintree::Transaction.sale(
           :amount => "10.00",
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
         result.should_not be_success
         result.errors.for(:transaction).for(:paypal_account).first.code.should == Braintree::ErrorCodes::PayPalAccount::IncompletePayPalAccount
@@ -7011,7 +6777,7 @@ describe Braintree::Transaction do
         :public_key => "oauth_app_partner_user_public_key",
         :private_key => "oauth_app_partner_user_private_key",
         :environment => Braintree::Configuration.environment,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
       @customer = @partner_merchant_gateway.customer.create(
         :first_name => "Joe",
@@ -7020,12 +6786,12 @@ describe Braintree::Transaction do
         :email => "joe@example.com",
         :phone => "312.555.1234",
         :fax => "614.555.5678",
-        :website => "www.example.com"
+        :website => "www.example.com",
       ).customer
       @address = @partner_merchant_gateway.address.create(
         :customer_id => @customer.id,
         :first_name => "Testy",
-        :last_name => "McTesterson"
+        :last_name => "McTesterson",
       ).address
       @credit_card = @partner_merchant_gateway.credit_card.create(
         :customer_id => @customer.id,
@@ -7036,13 +6802,13 @@ describe Braintree::Transaction do
           :first_name => "Adam",
           :last_name => "Davis",
           :postal_code => "95131"
-        }
+        },
       ).credit_card
 
       oauth_gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
       access_token = Braintree::OAuthTestHelper.create_token(oauth_gateway, {
         :merchant_public_id => "integration_merchant_id",
@@ -7051,7 +6817,7 @@ describe Braintree::Transaction do
 
       @granting_gateway = Braintree::Gateway.new(
         :access_token => access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
     end
@@ -7061,7 +6827,7 @@ describe Braintree::Transaction do
 
       result = Braintree::Transaction.sale(
         :payment_method_nonce => grant_result.payment_method_nonce.nonce,
-        :amount => Braintree::Test::TransactionAmounts::Authorize
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
       )
       result.transaction.facilitated_details.merchant_id.should == "integration_merchant_id"
       result.transaction.facilitated_details.merchant_name.should == "14ladders"
@@ -7077,7 +6843,7 @@ describe Braintree::Transaction do
 
       result = Braintree::Transaction.sale(
         :payment_method_nonce => grant_result.payment_method_nonce.nonce,
-        :amount => Braintree::Test::TransactionAmounts::Authorize
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
       )
 
       result.transaction.billing_details.postal_code == "95131"
@@ -7089,7 +6855,7 @@ describe Braintree::Transaction do
         :shared_customer_id => @customer.id,
         :shared_shipping_address_id => @address.id,
         :shared_billing_address_id => @address.id,
-        :amount => Braintree::Test::TransactionAmounts::Authorize
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
       )
       result.success?.should == true
       result.transaction.shipping_details.first_name.should == @address.first_name
@@ -7099,7 +6865,7 @@ describe Braintree::Transaction do
     it "facilitated details are returned on transaction created via a shared_payment_method_token" do
       result = @granting_gateway.transaction.sale(
         :shared_payment_method_token => @credit_card.token,
-        :amount => Braintree::Test::TransactionAmounts::Authorize
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
       )
       result.transaction.facilitated_details.merchant_id.should == "integration_merchant_id"
       result.transaction.facilitated_details.merchant_name.should == "14ladders"
@@ -7111,12 +6877,12 @@ describe Braintree::Transaction do
 
     it "facilitated details are returned on transaction created via a shared_payment_method_nonce" do
       shared_nonce = @partner_merchant_gateway.payment_method_nonce.create(
-        @credit_card.token
+        @credit_card.token,
       ).payment_method_nonce.nonce
 
       result = @granting_gateway.transaction.sale(
         :shared_payment_method_nonce => shared_nonce,
-        :amount => Braintree::Test::TransactionAmounts::Authorize
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
       )
       result.transaction.facilitated_details.merchant_id.should == "integration_merchant_id"
       result.transaction.facilitated_details.merchant_name.should == "14ladders"
@@ -7129,7 +6895,7 @@ describe Braintree::Transaction do
 
   context "paypal here" do
     it "gets the details of an auth/capture transaction" do
-      result = Braintree::Transaction.find('paypal_here_auth_capture_id')
+      result = Braintree::Transaction.find("paypal_here_auth_capture_id")
       result.payment_instrument_type.should eq(Braintree::PaymentInstrumentType::PayPalHere)
       result.paypal_here_details.should_not be_nil
 
@@ -7146,7 +6912,7 @@ describe Braintree::Transaction do
     end
 
     it "gets the details of a sale transaction" do
-      result = Braintree::Transaction.find('paypal_here_sale_id')
+      result = Braintree::Transaction.find("paypal_here_sale_id")
       result.paypal_here_details.should_not be_nil
 
       details = result.paypal_here_details
@@ -7154,7 +6920,7 @@ describe Braintree::Transaction do
     end
 
     it "gets the details of a refunded sale transaction" do
-      result = Braintree::Transaction.find('paypal_here_refund_id')
+      result = Braintree::Transaction.find("paypal_here_refund_id")
       result.paypal_here_details.should_not be_nil
 
       details = result.paypal_here_details
@@ -7179,7 +6945,7 @@ describe Braintree::Transaction do
       customer = Braintree::Customer.create!
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       payment_method_token = result.payment_method.token
 
@@ -7194,4 +6960,299 @@ describe Braintree::Transaction do
       transaction.processed_with_network_token?.should == false
     end
   end
+
+  describe "retried flag presence in response" do
+    it "creates a retried transaction" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :payment_method_token => "network_tokenized_credit_card",
+      )
+      transaction = result.transaction
+      transaction.retried.should == true
+    end
+
+    it "creates a non-retried transaction" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_token => "network_tokenized_credit_card",
+      )
+      transaction = result.transaction
+      transaction.retried.should == nil
+    end
+
+    it "creates a transaction that is ineligible for retries" do
+      result = Braintree::Transaction.sale(
+        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+      )
+      transaction = result.transaction
+      transaction.retried.should == nil
+    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
+
+  describe "Manual Key Entry" do
+    context "with correct encrypted payment reader card details" do
+      it "returns a success response" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :payment_reader_card_details => {
+              :encrypted_card_data => "8F34DFB312DC79C24FD5320622F3E11682D79E6B0C0FD881",
+              :key_serial_number => "FFFFFF02000572A00005",
+            },
+          },
+        )
+
+        expect(result).to be_success
+      end
+    end
+
+    context "with invalid encrypted payment reader card details" do
+      it "returns a failure response" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :payment_reader_card_details => {
+              :encrypted_card_data => "invalid",
+              :key_serial_number => "invalid",
+            },
+          },
+        )
+
+        expect(result).not_to be_success
+        expect(result.errors.for(:transaction).first.code)
+          .to eq(Braintree::ErrorCodes::Transaction::PaymentInstrumentNotSupportedByMerchantAccount)
+      end
+    end
+  end
+
+  describe "Adjust Authorization" do
+    let(:first_data_master_transaction_params) do
+      {
+        :merchant_account_id => SpecHelper::FakeFirstDataMerchantAccountId,
+        :amount => "75.50",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        }
+      }
+    end
+    let(:first_data_visa_transaction_params) do
+      {
+        :merchant_account_id => SpecHelper::FakeFirstDataMerchantAccountId,
+        :amount => "75.50",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      }
+    end
+    context "successful authorization" do
+      it "returns success response" do
+        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params)
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "85.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(true)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("85.50"))
+      end
+    end
+
+    context "unsuccessful authorization" do
+      it "returns failure, when processor does not support multi auth adjustment" do
+        initial_transaction = Braintree::Transaction.sale(
+          :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
+          :amount => "75.50",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "06/2009"
+          },
+        )
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "85.50"
+        )
+
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::ProcessorDoesNotSupportAuthAdjustment)
+      end
+
+      it "returns failure response, when adjusted amount submitted is zero" do
+        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params)
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "0.0"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:authorization_adjustment).on(:amount).first.code).to eq(Braintree::ErrorCodes::Transaction::AdjustmentAmountMustBeGreaterThanZero)
+      end
+
+      it "returns failure response, when adjusted amount submitted same as authorized amount" do
+        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params)
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "75.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:authorization_adjustment).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::NoNetAmountToPerformAuthAdjustment)
+      end
+
+      it "returns failure, when transaction status is not authorized" do
+        additional_params = {:options => {:submit_for_settlement => true}}
+        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params.merge(additional_params))
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "85.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionMustBeInStateAuthorized)
+      end
+
+      it "returns failure, when transaction authorization type final or undefined" do
+        additional_params = {:transaction_source => "recurring_first"}
+        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params.merge(additional_params))
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "85.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionIsNotEligibleForAdjustment)
+      end
+
+      it "returns failure, when processor does not support incremental auth" do
+        initial_transaction = Braintree::Transaction.sale(first_data_visa_transaction_params)
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "85.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::ProcessorDoesNotSupportIncrementalAuth)
+      end
+
+      it "returns failure, when processor does not support auth reversal" do
+        initial_transaction = Braintree::Transaction.sale(first_data_visa_transaction_params)
+        expect(initial_transaction.success?).to eq(true)
+
+        adjustment_transaction = Braintree::Transaction.adjust_authorization(
+          initial_transaction.transaction.id, "65.50"
+        )
+
+        expect(adjustment_transaction.success?).to eq(false)
+        expect(adjustment_transaction.transaction.amount.should).to eq(BigDecimal("75.50"))
+        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::ProcessorDoesNotSupportPartialAuthReversal)
+      end
+    end
+  end
 end