braintree 2.99.0 → 2.104.0

data/spec/integration/braintree/dispute_search_spec.rb

@@ -74,7 +74,7 @@ describe Braintree::Dispute, "search" do
         ]
       end
 
-      expect(collection.disputes.count).to eq(2)
+      expect(collection.disputes.count).to be >= 2
       dispute = collection.disputes.first
     end
 

data/spec/integration/braintree/dispute_spec.rb

@@ -186,6 +186,7 @@ describe Braintree::Dispute do
       dispute.amount_disputed.should == 31.0
       dispute.amount_won.should == 0.0
       dispute.id.should == "open_dispute"
+      dispute.graphql_id.should_not be_nil
       dispute.status.should == Braintree::Dispute::Status::Open
       dispute.transaction.amount.should == 31.0
       dispute.transaction.id.should == "open_disputed_transaction"

data/spec/integration/braintree/document_upload_spec.rb

@@ -46,6 +46,18 @@ describe Braintree::DocumentUploadGateway do
       end
     end
 
+    it "returns file is empty error with empty file" do
+      filename = "#{File.dirname(__FILE__)}/../../fixtures/files/empty_file.png"
+      begin
+        File.open(filename, "w+") {}
+        file = File.new(filename, "r")
+        response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+        response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsEmpty
+      ensure
+        File.delete(filename)
+      end
+    end
+
     it "returns file too long error with file over 50 pages" do
       filename = "#{File.dirname(__FILE__)}/../../fixtures/files/too_long.pdf"
       file = File.new(filename, "r")

data/spec/integration/braintree/merchant_spec.rb

@@ -305,7 +305,7 @@ describe Braintree::MerchantGateway do
       it "succeeds" do
         result = Braintree::Merchant.provision_raw_apple_pay
         result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
       end
 
       it "is repeatable" do
@@ -313,7 +313,7 @@ describe Braintree::MerchantGateway do
         result.should be_success
         result = Braintree::Merchant.provision_raw_apple_pay
         result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
       end
     end
 

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -84,10 +84,14 @@ describe Braintree::PaymentMethodNonce do
     end
 
     it "return paypal details if details exist" do
-      result = Braintree::PaymentMethodNonce.find("fake-google-pay-paypal-nonce")
-
+      result = Braintree::PaymentMethodNonce.find("fake-paypal-one-time-nonce")
       nonce = result.payment_method_nonce
 
+      nonce.details.fetch(:cobranded_card_label).should_not be_nil
+      nonce.details.fetch(:shipping_option_id).should_not be_nil
+      nonce.details.fetch(:billing_address).fetch(:recipient_name).should_not be_nil
+      nonce.details.fetch(:shipping_address).fetch(:recipient_name).should_not be_nil
+
       nonce.details.fetch(:payer_info).fetch(:first_name).should_not be_nil
       nonce.details.fetch(:payer_info).fetch(:last_name).should_not be_nil
       nonce.details.fetch(:payer_info).fetch(:email).should_not be_nil
@@ -235,5 +239,82 @@ describe Braintree::PaymentMethodNonce do
         Braintree::PaymentMethodNonce.find("not_a_nonce")
       end.to raise_error(Braintree::NotFoundError)
     end
+
+    context "authentication insights" do
+      let(:indian_payment_token) { "india_visa_credit" }
+      let(:european_payment_token) { "european_visa_credit" }
+      let(:indian_merchant_token) { "india_three_d_secure_merchant_account" }
+      let(:european_merchant_token) { "european_three_d_secure_merchant_account" }
+
+      describe "self.create" do
+        it "raises an exception if hash includes an invalid key" do
+          expect do
+            Braintree::PaymentMethodNonce.create("european_visa_credit", :invalid_key => "foo")
+          end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+        end
+      end
+
+      context "regulation environments" do
+        it "can get unregulated" do
+          expect(
+            request_authentication_insights(european_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "unregulated"
+        end
+
+        it "can get psd2" do
+          expect(
+            request_authentication_insights(european_merchant_token, european_payment_token)[:regulation_environment]
+          ).to eq "psd2"
+        end
+
+        it "can get rbi" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "rbi"
+        end
+      end
+
+      context "sca_indicator" do
+        it "can get unavailable" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:sca_indicator]
+          ).to eq "unavailable"
+        end
+
+        it "can get sca_required" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2001})[:sca_indicator]
+          ).to eq "sca_required"
+        end
+
+        it "can get sca_optional" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2000, recurring_customer_consent: true, recurring_max_amount: 2000})[:sca_indicator]
+
+          ).to eq "sca_optional"
+        end
+      end
+
+      def request_authentication_insights(merchant_token, payment_method_token, options = {})
+        authentication_insight_options = {
+          amount: options[:amount],
+          recurring_customer_consent: options[:recurring_customer_consent],
+          recurring_max_amount: options[:recurring_max_amount],
+        }
+        nonce_request = {
+          merchant_account_id: merchant_token,
+          authentication_insight: true,
+          authentication_insight_options: authentication_insight_options,
+        }
+
+        result = Braintree::PaymentMethodNonce.create(
+          payment_method_token,
+          payment_method_nonce: nonce_request
+        )
+        result.should be_success
+
+        return result.payment_method_nonce.authentication_insight
+      end
+    end
   end
 end

data/spec/integration/braintree/payment_method_spec.rb

@@ -121,6 +121,7 @@ describe Braintree::PaymentMethod do
       android_pay_card.expiration_year.to_i.should > 0
       android_pay_card.default.should == true
       android_pay_card.image_url.should =~ /android_pay/
+      android_pay_card.is_network_tokenized?.should == false
       android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
       android_pay_card.source_card_last_4.should == "1111"
       android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -148,6 +149,7 @@ describe Braintree::PaymentMethod do
       android_pay_card.expiration_year.to_i.should > 0
       android_pay_card.default.should == true
       android_pay_card.image_url.should =~ /android_pay/
+      android_pay_card.is_network_tokenized?.should == true
       android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
       android_pay_card.source_card_last_4.should == "4444"
       android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -298,6 +300,50 @@ describe Braintree::PaymentMethod do
       result.credit_card_verification.amount.should == BigDecimal("100.00")
     end
 
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :cavv => 'some_cavv',
+          :xid => 'some_xid',
+          :three_d_secure_version => 'xx',
+          :authentication_response => 'Y',
+          :directory_response => 'Y',
+          :cavv_algorithm => '2',
+          :ds_transaction_id => 'some_ds_transaction_id',
+        },
+        :options => {:verify_card => true}
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+      expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :cavv => 'some_cavv',
+          :xid => 'some_xid',
+          :three_d_secure_version => '1.0.2',
+          :authentication_response => 'Y',
+          :directory_response => 'Y',
+          :cavv_algorithm => '2',
+          :ds_transaction_id => 'some_ds_transaction_id',
+        },
+        :options => {:verify_card => true}
+      )
+
+      expect(result).to be_success
+    end
+
     it "returns 3DS info on cc verification" do
       customer = Braintree::Customer.create.customer
       result = Braintree::PaymentMethod.create(
@@ -727,24 +773,6 @@ describe Braintree::PaymentMethod do
         found_paypal_account.payer_id.should_not be_nil
       end
 
-      it "creates a billing agreement payment method from a refresh token without upgrading" do
-        customer = Braintree::Customer.create.customer
-        result = Braintree::PaymentMethod.create(
-          :customer_id => customer.id,
-          :paypal_refresh_token => "some_future_payment_token",
-          :paypal_vault_without_upgrade => true,
-        )
-
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.billing_agreement_id.should be_nil
-        token = result.payment_method.token
-
-        found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
-        found_paypal_account.billing_agreement_id.should be_nil
-      end
-
       it "does not create a payment method from an unvalidated onetime paypal account nonce" do
         customer = Braintree::Customer.create.customer
         nonce = nonce_for_paypal_account(:access_token => "PAYPAL_ACCESS_TOKEN")
@@ -1017,6 +1045,7 @@ describe Braintree::PaymentMethod do
         android_pay_card.expiration_year.to_i.should > 0
         android_pay_card.default.should == true
         android_pay_card.image_url.should =~ /android_pay/
+        android_pay_card.is_network_tokenized?.should == false
         android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
         android_pay_card.source_card_last_4.should == "1111"
         android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -1044,6 +1073,7 @@ describe Braintree::PaymentMethod do
         android_pay_card.expiration_year.to_i.should > 0
         android_pay_card.default.should == true
         android_pay_card.image_url.should =~ /android_pay/
+        android_pay_card.is_network_tokenized?.should == true
         android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
         android_pay_card.source_card_last_4.should == "4444"
         android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -1183,6 +1213,71 @@ describe Braintree::PaymentMethod do
 
   describe "self.update" do
     context "credit cards" do
+      it "throws validation error when passing invalid  pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => 'xx',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true},
+        )
+        expect(update_result).to_not be_success
+        error = update_result.errors.for(:verification).first
+        expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+        expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+      end
+
+      it "updates the credit card with three_d_secure pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => '1.0.2',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true},
+        )
+        update_result.success?.should == true
+        update_result.payment_method.should == credit_card
+        updated_credit_card = update_result.payment_method
+        updated_credit_card.cardholder_name.should == "New Holder"
+        updated_credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+        updated_credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+        updated_credit_card.expiration_date.should == "06/2013"
+      end
+
       it "updates the credit card" do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(

data/spec/integration/braintree/paypal_account_spec.rb

@@ -131,7 +131,7 @@ describe Braintree::PayPalAccount do
       )
 
       result.success?.should == false
-      result.errors.first.code.should == "82902"
+      result.errors.map(&:code).should include("82902")
     end
   end
 

data/spec/integration/braintree/transaction_spec.rb

@@ -140,6 +140,31 @@ describe Braintree::Transaction do
           result.transaction.risk_data.should respond_to(:fraud_service_provider)
         end
       end
+
+      it "handles validation errors for invalid risk data attributes" do
+        with_advanced_fraud_integration_merchant do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :risk_data => {
+              :customer_browser => "#{"1" * 300}",
+              :customer_device_id => "customer_device_id_0#{"1" * 300}",
+              :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
+          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
+        end
+      end
     end
 
     describe "card type indicators" do
@@ -419,6 +444,7 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
       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
     end
 
     it "returns a successful network response code if successful" do
@@ -498,7 +524,7 @@ describe Braintree::Transaction do
       result.success?.should == true
     end
 
-    it "accepts additional security parameters: risk data with customer_browser and customer_ip" do
+    it "accepts additional security parameters: risk data" do
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -508,7 +534,10 @@ describe Braintree::Transaction do
         },
         :risk_data => {
           :customer_browser => "IE6",
-          :customer_ip => "192.168.0.1"
+          :customer_device_id => "customer_device_id_012",
+          :customer_ip => "192.168.0.1",
+          :customer_location_zip => "91244",
+          :customer_tenure => "20",
         }
       )
 
@@ -687,6 +716,68 @@ describe Braintree::Transaction do
       codes.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
+    it "returns an error if provided product sku is invalid" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :product_sku => "product$ku!",
+      )
+
+      result.success?.should == false
+      result.errors.for(:transaction).on(:product_sku).map { |e| e.code }.should include(Braintree::ErrorCodes::Transaction::ProductSkuIsInvalid)
+    end
+
+    it "returns an error if provided shipping phone number is invalid" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :shipping => {
+          :phone_number => "123-234-3456=098765"
+        }
+      )
+
+      result.success?.should == false
+      result.errors.for(:transaction).for(:shipping).on(:phone_number).map { |e| e.code }.should include(Braintree::ErrorCodes::Transaction::ShippingPhoneNumberIsInvalid)
+    end
+
+    it "returns an error if provided shipping method is invalid" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :shipping => {
+          :shipping_method => "urgent"
+        }
+      )
+
+      result.success?.should == false
+      result.errors.for(:transaction).for(:shipping).on(:shipping_method).map { |e| e.code }.should include(Braintree::ErrorCodes::Transaction::ShippingMethodIsInvalid)
+    end
+
+    it "returns an error if provided billing phone number is invalid" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :phone_number => "123-234-3456=098765"
+        }
+      )
+
+      result.success?.should == false
+      result.errors.for(:transaction).for(:billing).on(:phone_number).map { |e| e.code }.should include(Braintree::ErrorCodes::Transaction::BillingPhoneNumberIsInvalid)
+    end
+
     context "gateway rejection reason" do
       it "exposes the cvv gateway rejection reason" do
         old_merchant = Braintree::Configuration.merchant_id
@@ -804,16 +895,44 @@ describe Braintree::Transaction do
       end
 
       it "exposes the fraud gateway rejection reason" 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
+        with_advanced_fraud_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
+        end
+      end
+
+      it "exposes the risk_threshold gateway rejection reason (via test cc num)" do
+        with_advanced_fraud_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
+        end
+      end
+
+      it "exposes the risk_threshold gateway rejection reason (via test test nonce)" do
+        with_advanced_fraud_integration_merchant do
+          result = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => Braintree::Test::Nonce::GatewayRejectedRiskThresholds,
+          )
+          result.success?.should == false
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::RiskThreshold
+        end
       end
 
       it "exposes the token issuance gateway rejection reason" do
@@ -1645,6 +1764,7 @@ describe Braintree::Transaction do
         result.transaction.should_not be_nil
         apple_pay_details = result.transaction.apple_pay_details
         apple_pay_details.should_not be_nil
+        apple_pay_details.bin.should_not be_nil
         apple_pay_details.card_type.should == Braintree::ApplePayCard::CardType::Visa
         apple_pay_details.payment_instrument_name.should == "Visa 8886"
         apple_pay_details.source_description.should == "Visa 8886"
@@ -1695,6 +1815,7 @@ describe Braintree::Transaction do
         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"
@@ -1704,6 +1825,7 @@ describe Braintree::Transaction do
         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
@@ -1735,6 +1857,7 @@ describe Braintree::Transaction do
         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
 
@@ -1757,6 +1880,7 @@ describe Braintree::Transaction do
         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
@@ -2083,6 +2207,7 @@ describe Braintree::Transaction do
 
         result = Braintree::Transaction.create(
           :type => "sale",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
@@ -2119,7 +2244,8 @@ describe Braintree::Transaction do
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ThreeDSecure
       end
 
-      it "can create a transaction without a three_d_secure token" do
+
+      it "can create a transaction without a three_d_secure_authentication_id" do
         result = Braintree::Transaction.create(
           :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
           :type => "sale",
@@ -2132,41 +2258,174 @@ describe Braintree::Transaction do
         result.success?.should == true
       end
 
-      it "returns an error if sent a nil three_d_secure token" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
+      context "with three_d_secure_authentication_id" do
+        it "can create a transaction with a three_d_secure_authentication_id" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :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
+            :expiration_month => "12",
+            :expiration_year => "2022"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/22",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id
+          )
+
+          result.success?.should == true
+        end
+        it "returns an error if sent a nil three_d_secure_authentication_id" do
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :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
+        end
+        it "returns an error if merchant_account in the payment_method does not match with 3ds data" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :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
+        end
+        it "returns an error if 3ds lookup data does not match txn data" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :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
+        end
+        it "returns an error if three_d_secure_authentication_id is supplied with three_d_secure_pass_thru" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id,
+            :three_d_secure_pass_thru => {
+              :eci_flag => "02",
+              :cavv => "some_cavv",
+              :xid => "some_xid",
+              :three_d_secure_version => "1.0.2",
+              :authentication_response => "Y",
+              :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
+        end
       end
 
-      it "returns an error if 3ds lookup data does not match txn data" do
-        three_d_secure_token = SpecHelper.create_3ds_verification(
-          SpecHelper::ThreeDSecureMerchantAccountId,
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_month => "12",
-          :expiration_year => "2012"
-        )
+      context "with three_d_secure_token" do
+        it "can create a transaction with a three_d_secure token" do
+          three_d_secure_token = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
 
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::MasterCard,
-            :expiration_date => "12/12",
-          },
-          :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
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_token => three_d_secure_token
+          )
+
+          result.success?.should == true
+        end
+
+        it "returns an error if sent a nil three_d_secure token" do
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :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
+        end
+
+        it "returns an error if 3ds lookup data does not match txn data" do
+          three_d_secure_token = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :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
+        end
       end
 
       it "can create a transaction with a three_d_secure_pass_thru" do
@@ -2630,6 +2889,36 @@ describe Braintree::Transaction do
           result.success?.should == false
           result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
         end
+
+        it "handles soft declined refund authorizations" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => "9000.00",
+            :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
+        end
+
+        it "handles hard declined refund authorizations" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => "9000.00",
+            :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
+        end
       end
 
       context "handling errors" do
@@ -4365,6 +4654,7 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.sale(
         :amount => "100.00",
         :order_id => "123",
+        :product_sku => "productsku01",
         :channel => "MyShoppingCartProvider",
         :credit_card => {
           :cardholder_name => "The Cardholder",
@@ -4389,6 +4679,7 @@ describe Braintree::Transaction do
           :extended_address => "Suite 403",
           :locality => "Chicago",
           :region => "IL",
+          :phone_number => "122-555-1237",
           :postal_code => "60622",
           :country_name => "United States of America"
         },
@@ -4400,8 +4691,10 @@ describe Braintree::Transaction do
           :extended_address => "Apt 2F",
           :locality => "Bartlett",
           :region => "IL",
+          :phone_number => "122-555-1236",
           :postal_code => "60103",
-          :country_name => "United States of America"
+          :country_name => "United States of America",
+          :shipping_method => Braintree::Transaction::AddressDetails::ShippingMethod::Electronic
         }
       )
       result.success?.should == true
@@ -5086,6 +5379,71 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount
       end
     end
+
+    it "succeeds when level 2 data is provided" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :amex_rewards => {
+            :request_id => "ABC123",
+            :points => "1000",
+            :currency_amount => "10.00",
+            :currency_iso_code => "USD"
+          }
+        }
+      )
+      result.success?.should == true
+
+      result = Braintree::Transaction.submit_for_settlement(result.transaction.id, nil, :tax_amount => "2.00", :tax_exempt => false, :purchase_order_number => "0Rd3r#")
+      result.success?.should == true
+      result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    end
+
+    it "succeeds when level 3 data is provided" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :amex_rewards => {
+            :request_id => "ABC123",
+            :points => "1000",
+            :currency_amount => "10.00",
+            :currency_iso_code => "USD"
+          }
+        }
+      )
+      result.success?.should == true
+
+      result = Braintree::Transaction.submit_for_settlement(
+        result.transaction.id,
+        nil,
+        :discount_amount => "2.00",
+        :shipping_amount => "1.23",
+        :ships_from_postal_code => "90210",
+        :line_items => [
+          {
+            :quantity => 1,
+            :unit_amount => 1,
+            :name => "New line item",
+            :kind => "debit",
+            :total_amount => "18.00",
+            :discount_amount => "12.00",
+            :tax_amount => "0",
+          },
+        ]
+      )
+      result.success?.should == true
+      result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    end
   end
 
   describe "self.submit_for_settlement!" do
@@ -5882,6 +6240,7 @@ describe Braintree::Transaction do
       created_transaction = result.transaction
       found_transaction = Braintree::Transaction.find(created_transaction.id)
       found_transaction.should == created_transaction
+      found_transaction.graphql_id.should_not be_nil
     end
 
     it "finds the vaulted transaction with the given id" do
@@ -6802,4 +7161,37 @@ describe Braintree::Transaction do
       details.refund_id.should_not be_nil
     end
   end
+
+  describe "card on file network tokenization" do
+    it "creates a transaction with a vaulted, tokenized credit card" do
+      result = Braintree::Transaction.sale(
+        :amount => "112.44",
+        :payment_method_token => "network_tokenized_credit_card",
+      )
+      result.success?.should == true
+      transaction = result.transaction
+
+      transaction.amount.should == BigDecimal("112.44")
+      transaction.processed_with_network_token?.should == true
+    end
+
+    it "creates a transaction with a vaulted, non-tokenized credit card" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :customer_id => customer.id
+      )
+      payment_method_token = result.payment_method.token
+
+      result = Braintree::Transaction.sale(
+        :amount => "112.44",
+        :payment_method_token => payment_method_token,
+      )
+      result.success?.should == true
+      transaction = result.transaction
+
+      transaction.amount.should == BigDecimal("112.44")
+      transaction.processed_with_network_token?.should == false
+    end
+  end
 end