braintree 4.20.0 → 4.22.0

data/spec/integration/braintree/merchant_spec.rb

@@ -11,7 +11,7 @@ describe Braintree::MerchantGateway do
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
+        :country_code_alpha3 => "GBR",
         :payment_methods => ["credit_card", "paypal"],
       )
 
@@ -21,10 +21,10 @@ describe Braintree::MerchantGateway do
       expect(merchant.id).not_to be_nil
       expect(merchant.email).to eq("name@email.com")
       expect(merchant.company_name).to eq("name@email.com")
-      expect(merchant.country_code_alpha3).to eq("USA")
-      expect(merchant.country_code_alpha2).to eq("US")
-      expect(merchant.country_code_numeric).to eq("840")
-      expect(merchant.country_name).to eq("United States of America")
+      expect(merchant.country_code_alpha3).to eq("GBR")
+      expect(merchant.country_code_alpha2).to eq("GB")
+      expect(merchant.country_code_numeric).to eq("826")
+      expect(merchant.country_name).to eq("United Kingdom")
 
       credentials = result.credentials
       expect(credentials.access_token).not_to be_nil
@@ -42,7 +42,7 @@ describe Braintree::MerchantGateway do
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
+        :country_code_alpha3 => "GBR",
         :payment_methods => ["fake_money"],
       )
 
@@ -70,7 +70,7 @@ describe Braintree::MerchantGateway do
         )
         result = gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["credit_card", "paypal"],
         )
 
@@ -81,47 +81,12 @@ describe Braintree::MerchantGateway do
     context "multiple currencies" do
       before(:each) do
         @gateway = Braintree::Gateway.new(
-          :client_id => "client_id$development$signup_client_id",
-          :client_secret => "client_secret$development$signup_client_secret",
+          :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"),
         )
       end
 
-      it "creates a US multi currency merchant for paypal and credit_card" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"],
-          :currencies => ["GBP", "USD"],
-        )
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("USA")
-        expect(merchant.country_code_alpha2).to eq("US")
-        expect(merchant.country_code_numeric).to eq("840")
-        expect(merchant.country_name).to eq("United States of America")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(2)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("USD")
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        expect(merchant_account.default).to eq(false)
-        expect(merchant_account.currency_iso_code).to eq("GBP")
-      end
-
       it "creates an EU multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
@@ -161,7 +126,7 @@ describe Braintree::MerchantGateway do
       it "creates a paypal-only merchant that accepts multiple currencies" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["GBP", "USD"],
           :paypal_account => {
@@ -176,10 +141,10 @@ describe Braintree::MerchantGateway do
         expect(merchant.id).not_to be_nil
         expect(merchant.email).to eq("name@email.com")
         expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("USA")
-        expect(merchant.country_code_alpha2).to eq("US")
-        expect(merchant.country_code_numeric).to eq("840")
-        expect(merchant.country_name).to eq("United States of America")
+        expect(merchant.country_code_alpha3).to eq("GBR")
+        expect(merchant.country_code_alpha2).to eq("GB")
+        expect(merchant.country_code_numeric).to eq("826")
+        expect(merchant.country_name).to eq("United Kingdom")
 
         credentials = result.credentials
         expect(credentials.access_token).not_to be_nil
@@ -191,90 +156,18 @@ describe Braintree::MerchantGateway do
         expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.default).to eq(false)
         expect(merchant_account.currency_iso_code).to eq("USD")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        expect(merchant_account.default).to eq(false)
-        expect(merchant_account.currency_iso_code).to eq("GBP")
-      end
-
-      it "allows creation of non-US merchant if onboarding application is internal" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "JPN",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          },
-        )
-
-        expect(result).to be_success
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("JPN")
-        expect(merchant.country_code_alpha2).to eq("JP")
-        expect(merchant.country_code_numeric).to eq("392")
-        expect(merchant.country_name).to eq("Japan")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(1)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
         expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("JPY")
-      end
-
-      it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "YEM",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          },
-        )
-
-        expect(result).to be_success
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("YEM")
-        expect(merchant.country_code_alpha2).to eq("YE")
-        expect(merchant.country_code_numeric).to eq("887")
-        expect(merchant.country_name).to eq("Yemen")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(1)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("USD")
+        expect(merchant_account.currency_iso_code).to eq("GBP")
       end
 
       it "returns error if invalid currency is passed" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["FAKE", "GBP"],
           :paypal_account => {
@@ -317,20 +210,6 @@ describe Braintree::MerchantGateway do
       end
     end
 
-    context "merchant has no processor connection supporting apple pay" do
-      before do
-        Braintree::Configuration.merchant_id = "forward_payment_method_merchant_id"
-        Braintree::Configuration.public_key = "forward_payment_method_public_key"
-        Braintree::Configuration.private_key = "forward_payment_method_private_key"
-      end
-
-      it "returns a validation error" do
-        result = Braintree::Merchant.provision_raw_apple_pay
-        expect(result).not_to be_success
-        expect(result.errors.for(:apple_pay).first.code).to eq(Braintree::ErrorCodes::ApplePay::ApplePayCardsAreNotAccepted)
-      end
-    end
-
     def _save_config
       @original_config = {
         :merchant_id => Braintree::Configuration.merchant_id,

data/spec/integration/braintree/package_tracking_spec.rb

@@ -1,18 +1,17 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
+# NEXT_MAJOR_VERSION Remove paypal_tracking_id assertions, use paypal_tracker_id going forward
 describe Braintree::Transaction do
     describe "self.package_tracking" do
+      let(:customer) { Braintree::Customer.create! }
         it "returns validation error message from gateway api" do
-            # Create Transaction
           result = Braintree::Transaction.sale(
             :amount => "100",
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
             :options => {
               :submit_for_settlement => true
             },
-            :paypal_account => {
-              :payer_id => "fake-payer-id",
-              :payment_id => "fake-payment-id",
-            },
           )
 
           expect(result.success?).to eq(true)
@@ -27,17 +26,12 @@ describe Braintree::Transaction do
         end
 
         it "successfully calls gateway API and adds package tracking information" do
-
-          # Create Transaction
           result = Braintree::Transaction.sale(
             :amount => "100",
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
             :options => {
               :submit_for_settlement => true
             },
-            :paypal_account => {
-              :payer_id => "fake-payer-id",
-              :payment_id => "fake-payment-id",
-            },
           )
 
           expect(result.success?).to eq(true)
@@ -77,7 +71,8 @@ describe Braintree::Transaction do
           expect(firstPackageResult.transaction.packages[0].id).not_to be_nil
           expect(firstPackageResult.transaction.packages[0].carrier).to eq("UPS")
           expect(firstPackageResult.transaction.packages[0].tracking_number).to eq("tracking_number_1")
-
+          expect(firstPackageResult.transaction.packages[0].paypal_tracker_id).to be_nil
+          expect(firstPackageResult.transaction.packages[0].paypal_tracking_id).to be_nil
 
           # Create second package with 1 product
           secondPackageResult = Braintree::Transaction.package_tracking(
@@ -102,10 +97,34 @@ describe Braintree::Transaction do
           expect(secondPackageResult.transaction.packages[1].id).not_to be_nil
           expect(secondPackageResult.transaction.packages[1].carrier).to eq("FEDEX")
           expect(secondPackageResult.transaction.packages[1].tracking_number).to eq("tracking_number_2")
+          expect(secondPackageResult.transaction.packages[1].paypal_tracker_id).to be_nil
+          expect(secondPackageResult.transaction.packages[1].paypal_tracking_id).to be_nil
 
           # Find transaction gives both packages
-          findTransaction = Braintree::Transaction.find(result.transaction.id)
-          expect(findTransaction.packages.length).to eq(2)
+          transaction = Braintree::Transaction.find(result.transaction.id)
+          expect(transaction.packages.length).to eq(2)
+          expect(transaction.packages[0].id).not_to be_nil
+          expect(transaction.packages[0].carrier).to eq("UPS")
+          expect(transaction.packages[0].tracking_number).to eq("tracking_number_1")
+          #In test environment, since we do not have jobstream setup paypal tracker id is going to be nil, this is just to access we could access it
+          expect(transaction.packages[0].paypal_tracker_id).to be_nil
+          expect(transaction.packages[0].paypal_tracking_id).to be_nil
+
+          expect(transaction.packages[1].id).not_to be_nil
+          expect(transaction.packages[1].carrier).to eq("FEDEX")
+          expect(transaction.packages[1].tracking_number).to eq("tracking_number_2")
+          expect(transaction.packages[1].paypal_tracker_id).to be_nil
+          expect(transaction.packages[1].paypal_tracking_id).to be_nil
+        end
+
+        it "retrieves paypal_tracker_id successfully" do
+          transaction = Braintree::Transaction.find("package_tracking_tx")
+          expect(transaction.packages.length).to eq(2)
+          expect(transaction.packages[0].paypal_tracker_id).to eq("paypal_tracker_id_1")
+          expect(transaction.packages[0].paypal_tracking_id).to be_nil
+
+          expect(transaction.packages[1].paypal_tracker_id).to eq("paypal_tracker_id_2")
+          expect(transaction.packages[1].paypal_tracking_id).to be_nil
         end
     end
-end
+end

data/spec/integration/braintree/payment_method_spec.rb

@@ -453,7 +453,8 @@ describe Braintree::PaymentMethod do
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
         :billing_address => {
-          :street_address => "123 Abc Way"
+          :street_address => "123 Abc Way",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
         },
       )
 
@@ -464,6 +465,8 @@ describe Braintree::PaymentMethod do
       found_credit_card = Braintree::CreditCard.find(token)
       expect(found_credit_card).not_to be_nil
       expect(found_credit_card.billing_address.street_address).to eq("123 Abc Way")
+      expect(found_credit_card.billing_address.international_phone[:country_code]).to eq("1")
+      expect(found_credit_card.billing_address.international_phone[:national_number]).to eq("3121234567")
     end
 
     it "allows passing a billing address id outside of the nonce" do
@@ -1677,12 +1680,15 @@ describe Braintree::PaymentMethod do
           )
           update_result = Braintree::PaymentMethod.update(credit_card.token,
             :billing_address => {
+              :international_phone => {:country_code => "1", :national_number => "3121234567"},
               :region => "IL",
               :options => {:update_existing => true}
             },
           )
           expect(update_result.success?).to eq(true)
           updated_credit_card = update_result.payment_method
+          expect(updated_credit_card.billing_address.international_phone[:country_code]).to eq("1")
+          expect(updated_credit_card.billing_address.international_phone[:national_number]).to eq("3121234567")
           expect(updated_credit_card.billing_address.region).to eq("IL")
           expect(updated_credit_card.billing_address.street_address).to eq("123 Nigeria Ave")
           expect(updated_credit_card.billing_address.id).to eq(credit_card.billing_address.id)

data/spec/integration/braintree/paypal_account_spec.rb

@@ -25,6 +25,8 @@ describe Braintree::PayPalAccount do
       expect(paypal_account.created_at).not_to be_nil
       expect(paypal_account.updated_at).not_to be_nil
       expect(paypal_account.customer_id).to eq(customer.id)
+      expect(paypal_account.funding_source_description).to be_nil
+      expect(paypal_account.edit_paypal_vault_id).to be_nil
       expect(paypal_account.revoked_at).to be_nil
     end
 

data/spec/integration/braintree/transaction_spec.rb

@@ -718,6 +718,49 @@ describe Braintree::Transaction do
       end
     end
 
+    context "foreign_retailer" do
+      it "returns true when foreign_retailer param is true" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2025"
+          },
+          :foreign_retailer => true,
+        )
+        expect(result).to be_success
+        expect(result.transaction.foreign_retailer).to be_truthy
+      end
+
+      it "returns nil when foreign_retailer param is false" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2025"
+          },
+          :foreign_retailer => false,
+        )
+        expect(result).to be_success
+        expect(result.transaction.foreign_retailer).to be_nil
+      end
+
+      it "returns nil when foreign_retailer param is nil" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2025"
+          },
+        )
+        expect(result).to be_success
+        expect(result.transaction.foreign_retailer).to be_nil
+      end
+    end
+
     it "returns a successful result if successful" do
       result = Braintree::Transaction.create(
         :type => "sale",
@@ -1110,7 +1153,7 @@ describe Braintree::Transaction do
         )
         result = gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["credit_card", "paypal"],
         )
 
@@ -5219,6 +5262,7 @@ describe Braintree::Transaction do
           :locality => "Chicago",
           :region => "IL",
           :phone_number => "122-555-1237",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
           :postal_code => "60622",
           :country_name => "United States of America"
         },
@@ -5231,6 +5275,7 @@ describe Braintree::Transaction do
           :locality => "Bartlett",
           :region => "IL",
           :phone_number => "122-555-1236",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
           :postal_code => "60103",
           :country_name => "United States of America",
           :shipping_method => Braintree::Transaction::AddressDetails::ShippingMethod::Electronic
@@ -5277,6 +5322,9 @@ describe Braintree::Transaction do
       expect(transaction.billing_details.country_code_alpha2).to eq("US")
       expect(transaction.billing_details.country_code_alpha3).to eq("USA")
       expect(transaction.billing_details.country_code_numeric).to eq("840")
+      expect(transaction.billing_details.phone_number).to eq("122-555-1237")
+      expect(transaction.billing_details.international_phone[:country_code]).to eq("1")
+      expect(transaction.billing_details.international_phone[:national_number]).to eq("3121234567")
       expect(transaction.shipping_details.first_name).to eq("Andrew")
       expect(transaction.shipping_details.last_name).to eq("Mason")
       expect(transaction.shipping_details.company).to eq("Braintree")
@@ -5289,6 +5337,9 @@ describe Braintree::Transaction do
       expect(transaction.shipping_details.country_code_alpha2).to eq("US")
       expect(transaction.shipping_details.country_code_alpha3).to eq("USA")
       expect(transaction.shipping_details.country_code_numeric).to eq("840")
+      expect(transaction.shipping_details.phone_number).to eq("122-555-1236")
+      expect(transaction.shipping_details.international_phone[:country_code]).to eq("1")
+      expect(transaction.shipping_details.international_phone[:national_number]).to eq("3121234567")
     end
 
     it "allows merchant account to be specified" do
@@ -6579,6 +6630,39 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.submit_for_partial_settlement(transaction.id, Braintree::Test::TransactionAmounts::Authorize, industry_data_flight_params)
       expect(result.success?).to be_truthy
     end
+
+    it "final_capture indicates the current partial_capture as final" do
+      authorized_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        },
+      )
+
+      result1 = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)
+      expect(result1.success?).to eq(true)
+      partial_settlement_transaction1 = result1.transaction
+      expect(partial_settlement_transaction1.amount).to eq(100)
+      expect(partial_settlement_transaction1.type).to eq(Braintree::Transaction::Type::Sale)
+      expect(partial_settlement_transaction1.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
+      expect(partial_settlement_transaction1.authorized_transaction_id).to eq(authorized_transaction.id)
+      refreshed_authorized_transaction1 = Braintree::Transaction.find(authorized_transaction.id)
+      expect(refreshed_authorized_transaction1.status).to eq(Braintree::Transaction::Status::SettlementPending)
+
+      options = {:final_capture => true}
+      result2 = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100, options)
+      expect(result2.success?).to eq(true)
+      partial_settlement_transaction2 = result2.transaction
+      expect(partial_settlement_transaction2.amount).to eq(100)
+      expect(partial_settlement_transaction2.type).to eq(Braintree::Transaction::Type::Sale)
+      expect(partial_settlement_transaction2.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
+      expect(partial_settlement_transaction2.authorized_transaction_id).to eq(authorized_transaction.id)
+
+      refreshed_authorized_transaction2 = Braintree::Transaction.find(authorized_transaction.id)
+      expect(refreshed_authorized_transaction2.status).to eq(Braintree::Transaction::Status::SettlementPending)
+    end
   end
 
   describe "self.submit_for_partial_settlement!" do
@@ -7851,4 +7935,59 @@ describe Braintree::Transaction do
       expect(result.transaction.merchant_advice_code_text).to eq("New account information available")
     end
   end
+
+  context "Shipping Tax Amount" do
+    it "accepts shipping-tax-amount field" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :amount => "10.00",
+        :shipping_amount => "1.00",
+        :shipping_tax_amount => "1.00",
+        :discount_amount => "2.00",
+        :ships_from_postal_code => "12345",
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.shipping_amount).to eq("1.00")
+      expect(result.transaction.shipping_tax_amount).to eq("1.00")
+      expect(result.transaction.discount_amount).to eq("2.00")
+      expect(result.transaction.ships_from_postal_code).to eq("12345")
+    end
+
+    it "submit for settlement succeeds when shipping tax amount  is provided" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::FakeFirstDataMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2029"
+        },
+      )
+      expect(result.success?).to eq(true)
+
+      result = Braintree::Transaction.submit_for_settlement(
+        result.transaction.id,
+        nil,
+        :discount_amount => "2.00",
+        :shipping_amount => "1.23",
+        :shipping_tax_amount => "0.40",
+        :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",
+          },
+        ],
+      )
+      expect(result.success?).to eq(true)
+      expect(result.transaction.shipping_tax_amount).to eq("0.40")
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
+    end
+  end
 end

data/spec/unit/braintree/configuration_spec.rb

@@ -399,7 +399,7 @@ describe Braintree::Configuration do
 
     it "is qa.braintreegateway.com for qa" do
       Braintree::Configuration.environment = :qa
-      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa.braintreepayments.com")
+      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa2.braintreepayments.com")
     end
 
     it "can by changed by configuring the production endpoint" do

data/spec/unit/braintree/credit_card_spec.rb

@@ -34,6 +34,7 @@ describe Braintree::CreditCard do
           :country_name,
           :extended_address,
           :first_name,
+          {:international_phone=>[:country_code, :national_number]},
           :last_name,
           :locality,
           :phone_number,
@@ -81,6 +82,7 @@ describe Braintree::CreditCard do
           :country_name,
           :extended_address,
           :first_name,
+          {:international_phone=>[:country_code, :national_number]},
           :last_name,
           :locality,
           :phone_number,

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -6,6 +6,8 @@ describe Braintree::CreditCardVerification do
       verification = Braintree::CreditCardVerification._new(
         :status => "verified",
         :amount => "12.45",
+        :ani_first_name_response_code => "I",
+        :ani_last_name_response_code => "I",
         :currency_iso_code => "USD",
         :avs_error_response_code => "I",
         :avs_postal_code_response_code => "I",
@@ -17,8 +19,7 @@ describe Braintree::CreditCardVerification do
         :network_response_code => "05",
         :network_response_text => "Do not Honor",
       )
-
-      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", amount: "12.45", currency_iso_code: "USD", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", network_response_code: "05", network_response_text: "Do not Honor", merchant_account_id: "some_id", gateway_rejection_reason: nil, id: nil, credit_card: nil, billing: nil, created_at: nil>))
+      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
     end
 
     it "has a status" do
@@ -37,6 +38,16 @@ describe Braintree::CreditCardVerification do
     end
   end
 
+  it "accepts ani name reponse codes" do
+    verification = Braintree::CreditCardVerification._new(
+      :ani_first_name_response_code => "M",
+      :ani_last_name_response_code => "M",
+    )
+
+    expect(verification.ani_first_name_response_code).to eq("M")
+    expect(verification.ani_last_name_response_code).to eq("M")
+  end
+
   it "accepts amount as either a String or BigDecimal" do
     expect(Braintree::CreditCardVerification._new(:amount => "12.34").amount).to eq(BigDecimal("12.34"))
     expect(Braintree::CreditCardVerification._new(:amount => BigDecimal("12.34")).amount).to eq(BigDecimal("12.34"))