braintree 4.26.0 → 4.28.0

data/spec/integration/braintree/merchant_account_spec.rb

@@ -142,90 +142,6 @@ describe Braintree::MerchantAccount do
     end
   end
 
-  describe "create" do
-    it "accepts the deprecated parameters" do
-      result = Braintree::MerchantAccount.create(DEPRECATED_APPLICATION_PARAMS)
-
-      expect(result).to be_success
-      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
-      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
-    end
-
-    it "creates a merchant account with the new parameters and doesn't require an id" do
-      result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)
-
-      expect(result).to be_success
-      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
-      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
-    end
-
-    it "allows an id to be passed" do
-      random_number = rand(10000)
-      sub_merchant_account_id = "sub_merchant_account_id#{random_number}"
-      result = Braintree::MerchantAccount.create(
-        VALID_APPLICATION_PARAMS.merge(
-          :id => sub_merchant_account_id,
-        ),
-      )
-
-      expect(result).to be_success
-      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
-      expect(result.merchant_account.id).to eq(sub_merchant_account_id)
-      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
-    end
-
-    it "handles unsuccessful results" do
-      result = Braintree::MerchantAccount.create({})
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).on(:master_merchant_account_id).first.code).to eq(Braintree::ErrorCodes::MerchantAccount::MasterMerchantAccountIdIsRequired)
-    end
-
-    it "requires all fields" do
-      result = Braintree::MerchantAccount.create(
-        :master_merchant_account_id => "sandbox_master_merchant_account",
-      )
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).on(:tos_accepted).first.code).to eq(Braintree::ErrorCodes::MerchantAccount::TosAcceptedIsRequired)
-    end
-
-    context "funding destination" do
-      it "accepts a bank" do
-        params = VALID_APPLICATION_PARAMS.dup
-        params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::Bank
-        result = Braintree::MerchantAccount.create(params)
-
-        expect(result).to be_success
-      end
-
-      it "accepts an email" do
-        params = VALID_APPLICATION_PARAMS.dup
-        params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::Email
-        params[:funding][:email] = "joebloggs@compuserve.com"
-        result = Braintree::MerchantAccount.create(params)
-
-        expect(result).to be_success
-      end
-
-      it "accepts a mobile_phone" do
-        params = VALID_APPLICATION_PARAMS.dup
-        params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::MobilePhone
-        params[:funding][:mobile_phone] = "3125882300"
-        result = Braintree::MerchantAccount.create(params)
-
-        expect(result).to be_success
-      end
-    end
-  end
-
-  describe "create!" do
-    it "creates a merchant account with the new parameters and doesn't require an id" do
-      merchant_account = Braintree::MerchantAccount.create!(VALID_APPLICATION_PARAMS)
-
-      expect(merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
-      expect(merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
-    end
-  end
-
   describe "create_for_currency" do
     it "creates a new merchant account for currency" do
       result = SpecHelper::create_merchant
@@ -330,18 +246,6 @@ describe Braintree::MerchantAccount do
   end
 
   describe "find" do
-    it "finds the merchant account with the given token" do
-      result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)
-      expect(result).to be_success
-      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
-
-      id = result.merchant_account.id
-      merchant_account = Braintree::MerchantAccount.find(id)
-
-      expect(merchant_account.individual_details.first_name).to eq(VALID_APPLICATION_PARAMS[:individual][:first_name])
-      expect(merchant_account.individual_details.last_name).to eq(VALID_APPLICATION_PARAMS[:individual][:last_name])
-    end
-
     it "retrieves the currency iso code for an existing master merchant account" do
       merchant_account = Braintree::MerchantAccount.find("sandbox_master_merchant_account")
 
@@ -354,250 +258,4 @@ describe Braintree::MerchantAccount do
       end.to raise_error(Braintree::NotFoundError, "Merchant account with id non-existant not found")
     end
   end
-
-  describe "update" do
-    it "updates the Merchant Account info" do
-      params = VALID_APPLICATION_PARAMS.clone
-      params.delete(:tos_accepted)
-      params.delete(:master_merchant_account_id)
-      params[:individual][:first_name] = "John"
-      params[:individual][:last_name] = "Doe"
-      params[:individual][:email] = "john.doe@example.com"
-      params[:individual][:date_of_birth] = "1970-01-01"
-      params[:individual][:phone] = "3125551234"
-      params[:individual][:address][:street_address] = "123 Fake St"
-      params[:individual][:address][:locality] = "Chicago"
-      params[:individual][:address][:region] = "IL"
-      params[:individual][:address][:postal_code] = "60622"
-      params[:business][:dba_name] = "James's Bloggs"
-      params[:business][:legal_name] = "James's Bloggs Inc"
-      params[:business][:tax_id] = "423456789"
-      params[:business][:address][:street_address] = "999 Fake St"
-      params[:business][:address][:locality] = "Miami"
-      params[:business][:address][:region] = "FL"
-      params[:business][:address][:postal_code] = "99999"
-      params[:funding][:account_number] = "43759348798"
-      params[:funding][:routing_number] = "071000013"
-      params[:funding][:email] = "check@this.com"
-      params[:funding][:mobile_phone] = "1234567890"
-      params[:funding][:destination] = Braintree::MerchantAccount::FundingDestination::MobilePhone
-      result = Braintree::MerchantAccount.update("sandbox_sub_merchant_account", params)
-      expect(result).to be_success
-      expect(result.merchant_account.status).to eq("active")
-      expect(result.merchant_account.id).to eq("sandbox_sub_merchant_account")
-      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
-      expect(result.merchant_account.individual_details.first_name).to eq("John")
-      expect(result.merchant_account.individual_details.last_name).to eq("Doe")
-      expect(result.merchant_account.individual_details.email).to eq("john.doe@example.com")
-      expect(result.merchant_account.individual_details.date_of_birth).to eq("1970-01-01")
-      expect(result.merchant_account.individual_details.phone).to eq("3125551234")
-      expect(result.merchant_account.individual_details.address_details.street_address).to eq("123 Fake St")
-      expect(result.merchant_account.individual_details.address_details.locality).to eq("Chicago")
-      expect(result.merchant_account.individual_details.address_details.region).to eq("IL")
-      expect(result.merchant_account.individual_details.address_details.postal_code).to eq("60622")
-      expect(result.merchant_account.business_details.dba_name).to eq("James's Bloggs")
-      expect(result.merchant_account.business_details.legal_name).to eq("James's Bloggs Inc")
-      expect(result.merchant_account.business_details.tax_id).to eq("423456789")
-      expect(result.merchant_account.business_details.address_details.street_address).to eq("999 Fake St")
-      expect(result.merchant_account.business_details.address_details.locality).to eq("Miami")
-      expect(result.merchant_account.business_details.address_details.region).to eq("FL")
-      expect(result.merchant_account.business_details.address_details.postal_code).to eq("99999")
-      expect(result.merchant_account.funding_details.account_number_last_4).to eq("8798")
-      expect(result.merchant_account.funding_details.routing_number).to eq("071000013")
-      expect(result.merchant_account.funding_details.email).to eq("check@this.com")
-      expect(result.merchant_account.funding_details.mobile_phone).to eq("1234567890")
-      expect(result.merchant_account.funding_details.destination).to eq(Braintree::MerchantAccount::FundingDestination::MobilePhone)
-      expect(result.merchant_account.funding_details.descriptor).to eq("Joes Bloggs MI")
-    end
-
-    it "does not require all fields" do
-      result = Braintree::MerchantAccount.update("sandbox_sub_merchant_account", {:individual => {:first_name => "Jose"}})
-      expect(result).to be_success
-    end
-
-    it "handles validation errors for blank fields" do
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :individual => {
-            :first_name => "",
-            :last_name => "",
-            :email => "",
-            :phone => "",
-            :address => {
-              :street_address => "",
-              :postal_code => "",
-              :locality => "",
-              :region => "",
-            },
-            :date_of_birth => "",
-            :ssn => "",
-          },
-          :business => {
-            :legal_name => "",
-            :dba_name => "",
-            :tax_id => ""
-          },
-          :funding => {
-            :destination => "",
-            :routing_number => "",
-            :account_number => ""
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:date_of_birth).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::DateOfBirthIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:locality).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::LocalityIsRequired])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsRequired])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsRequired])
-      expect(result.errors.for(:merchant_account).on(:base)).to be_empty
-    end
-
-    it "handles validation errors for invalid fields" do
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :individual => {
-            :first_name => "<>",
-            :last_name => "<>",
-            :email => "bad",
-            :phone => "999",
-            :address => {
-              :street_address => "nope",
-              :postal_code => "1",
-              :region => "QQ",
-            },
-            :date_of_birth => "hah",
-            :ssn => "12345",
-          },
-          :business => {
-            :legal_name => "``{}",
-            :dba_name => "{}``",
-            :tax_id => "bad",
-            :address => {
-              :street_address => "nope",
-              :postal_code => "1",
-              :region => "QQ",
-            },
-          },
-          :funding => {
-            :destination => "MY WALLET",
-            :routing_number => "LEATHER",
-            :account_number => "BACK POCKET",
-            :email => "BILLFOLD",
-            :mobile_phone => "TRIFOLD"
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::PhoneIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:individual).on(:ssn).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::SsnIsInvalid])
-
-      expect(result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:business).on(:dba_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::DbaNameIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::StreetAddressIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::PostalCodeIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::RegionIsInvalid])
-
-      expect(result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsInvalid])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsInvalid])
-
-      expect(result.errors.for(:merchant_account).on(:base)).to be_empty
-    end
-
-    it "handles validation errors for business fields" do
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :business => {
-            :legal_name => "",
-            :tax_id => "111223333",
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsRequiredWithTaxId])
-      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdMustBeBlank])
-
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :business => {
-            :legal_name => "legal_name",
-            :tax_id => "",
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsRequiredWithLegalName])
-    end
-
-    it "handles validation errors for funding fields" do
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :funding => {
-            :destination => Braintree::MerchantAccount::FundingDestination::Bank,
-            :routing_number => "",
-            :account_number => ""
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsRequired])
-      expect(result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsRequired])
-
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :funding => {
-            :destination => Braintree::MerchantAccount::FundingDestination::Email,
-            :email => ""
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsRequired])
-
-      result = Braintree::MerchantAccount.update(
-        "sandbox_sub_merchant_account", {
-          :funding => {
-            :destination => Braintree::MerchantAccount::FundingDestination::MobilePhone,
-            :mobile_phone => ""
-          },
-        }
-      )
-
-      expect(result).not_to be_success
-      expect(result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsRequired])
-    end
-  end
-
-  describe "update!" do
-    it "updates the Merchant Account info" do
-      params = VALID_APPLICATION_PARAMS.clone
-      params.delete(:tos_accepted)
-      params.delete(:master_merchant_account_id)
-      params[:individual][:first_name] = "John"
-      params[:individual][:last_name] = "Doe"
-      merchant_account = Braintree::MerchantAccount.update!("sandbox_sub_merchant_account", params)
-      expect(merchant_account.individual_details.first_name).to eq("John")
-      expect(merchant_account.individual_details.last_name).to eq("Doe")
-    end
-  end
 end

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -148,6 +148,16 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.details.bin).to eq("401288")
     end
 
+    it "returns bin_data with business set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-business-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.business).to eq(Braintree::CreditCard::Business::Yes)
+    end
+
     it "returns bin_data with commercial set to Yes" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-commercial-nonce")
 
@@ -158,6 +168,26 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::Yes)
     end
 
+    it "returns bin_data with consumer set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-consumer-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.consumer).to eq(Braintree::CreditCard::Consumer::Yes)
+    end
+
+    it "returns bin_data with corporate set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-corporate-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.corporate).to eq(Braintree::CreditCard::Corporate::Yes)
+    end
+
     it "returns bin_data with country_of_issuance set to CAN" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-country-of-issuance-cad-nonce")
 
@@ -240,6 +270,16 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
     end
 
+    it "returns bin_data with purchase set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-purchase-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.purchase).to eq(Braintree::CreditCard::Purchase::Yes)
+    end
+
     it "returns bin_data with unknown indicators" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-unknown-indicators-nonce")
 
@@ -247,7 +287,10 @@ describe Braintree::PaymentMethodNonce do
 
       expect(result).to be_success
       expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.business).to eq(Braintree::CreditCard::Business::Unknown)
       expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::Unknown)
+      expect(nonce.bin_data.consumer).to eq(Braintree::CreditCard::Consumer::Unknown)
+      expect(nonce.bin_data.corporate).to eq(Braintree::CreditCard::Corporate::Unknown)
       expect(nonce.bin_data.country_of_issuance).to eq(Braintree::CreditCard::CountryOfIssuance::Unknown)
       expect(nonce.bin_data.debit).to eq(Braintree::CreditCard::Debit::Unknown)
       expect(nonce.bin_data.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Unknown)
@@ -257,6 +300,7 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Unknown)
       expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Unknown)
       expect(nonce.bin_data.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
+      expect(nonce.bin_data.purchase).to eq(Braintree::CreditCard::Purchase::Unknown)
     end
 
     it "correctly raises and exception for a non existent token" do

data/spec/integration/braintree/payment_method_spec.rb

@@ -126,8 +126,8 @@ describe Braintree::PaymentMethod do
       expect(apple_pay_card.bin).not_to be_nil
       expect(apple_pay_card.token).to eq(token)
       expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
-      expect(apple_pay_card.payment_instrument_name).to eq("Visa 8886")
-      expect(apple_pay_card.source_description).to eq("Visa 8886")
+      expect(apple_pay_card.payment_instrument_name).to eq("Visa 2006")
+      expect(apple_pay_card.source_description).to eq("Visa 2006")
       expect(apple_pay_card.default).to eq(true)
       expect(apple_pay_card.image_url).to match(/apple_pay/)
       expect(apple_pay_card.expiration_month.to_i).to be > 0
@@ -671,6 +671,30 @@ describe Braintree::PaymentMethod do
       end
     end
 
+      it "includes ani response when account information inquiry is sent in options" do
+          customer = Braintree::Customer.create!
+          nonce = nonce_for_new_payment_method(
+            :credit_card => {
+              :cvv => "123",
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2029",
+            },
+          )
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verify_card => true,
+              :account_information_inquiry => "send_data",
+            },
+          )
+
+          expect(result).to be_success
+          verification = result.payment_method.verification
+          expect(verification.ani_first_name_response_code).not_to be_nil
+          expect(verification.ani_last_name_response_code).not_to be_nil
+      end
+
     context "account_type" do
       it "verifies card with account_type debit" do
         nonce = nonce_for_new_payment_method(
@@ -1228,7 +1252,7 @@ describe Braintree::PaymentMethod do
         expect(apple_pay_card.image_url).to match(/apple_pay/)
         expect(apple_pay_card.expiration_month.to_i).to be > 0
         expect(apple_pay_card.expiration_year.to_i).to be > 0
-        expect(apple_pay_card.source_description).to eq("Visa 8886")
+        expect(apple_pay_card.source_description).to eq("Visa 2006")
         expect(apple_pay_card.customer_id).to eq(customer.id)
         apple_pay_card.merchant_token_identifier == "DNITHE302308980427388297"
         apple_pay_card.source_card_last4 == "2006"
@@ -1588,6 +1612,29 @@ describe Braintree::PaymentMethod do
         end
       end
 
+      it "includes ani response after updating the options with account information inquiry" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2032",
+        )
+        update_result = Braintree::PaymentMethod.update(
+          credit_card.token,
+          :options => {
+            :verify_card => true,
+            :account_information_inquiry => "send_data",
+          },
+        )
+
+        expect(update_result).to be_success
+        verification = update_result.payment_method.verification
+        expect(verification.ani_first_name_response_code).not_to be_nil
+        expect(verification.ani_last_name_response_code).not_to be_nil
+      end
+
+
       context "verification_currency_iso_code" do
         it "validates verification_currency_iso_code and updates the credit card " do
           customer = Braintree::Customer.create!

data/spec/integration/braintree/transaction_payment_facilitator_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Transaction do
+
+  describe "self.sale" do
+
+    it "should create a transaction with sub merchant and payment facilitator for a payfac merchant" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => SpecHelper::CardProcessorBRLPayFacMerchantAccountId,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123",
+        },
+        :descriptor => {
+          :name => "companynme12*product12",
+          :phone => "1232344444",
+          :url => "example.com",
+        },
+        :billing => {
+          :first_name => "Bob James",
+          :country_code_alpha2 => "CA",
+          :extended_address => "",
+          :locality => "Trois-Rivires",
+          :region => "QC",
+          :postal_code => "G8Y 156",
+          :street_address => "2346 Boul Lane",
+        },
+        :payment_facilitator => {
+          :payment_facilitator_id => "98765432109",
+          :sub_merchant => {
+            :reference_number => "123456789012345",
+            :tax_id => "99112233445577",
+            :legal_name => "Fooda",
+            :address => {
+              :street_address => "10880 Ibitinga",
+              :locality => "Araraquara",
+              :region => "SP",
+              :country_code_alpha2 => "BR",
+              :postal_code => "13525000",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "9876543210",
+              },
+            },
+          },
+        },
+        :options => {
+          :store_in_vault_on_success => true,
+        },
+      }
+
+      result = Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(true)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+
+    it "should fail on transaction with payment facilitator and non brazil merchant" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123",
+        },
+        :descriptor => {
+          :name => "companynme12*product12",
+          :phone => "1232344444",
+          :url => "example.com",
+        },
+        :billing => {
+          :first_name => "Bob James",
+          :country_code_alpha2 => "CA",
+          :extended_address => "",
+          :locality => "Trois-Rivires",
+          :region => "QC",
+          :postal_code => "G8Y 156",
+          :street_address => "2346 Boul Lane",
+        },
+        :payment_facilitator => {
+          :payment_facilitator_id => "98765432109",
+          :sub_merchant => {
+            :reference_number => "123456789012345",
+            :tax_id => "99112233445577",
+            :legal_name => "Fooda",
+            :address => {
+              :street_address => "10880 Ibitinga",
+              :locality => "Araraquara",
+              :region => "SP",
+              :country_code_alpha2 => "BR",
+              :postal_code => "13525000",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "9876543210",
+              },
+            },
+          },
+        },
+        :options => {
+          :store_in_vault_on_success => true,
+        },
+      }
+
+      ezp_gateway = Braintree::Gateway.new(
+        :environment => :development,
+        :merchant_id => "pp_credit_ezp_merchant",
+        :public_key => "pp_credit_ezp_merchant_public_key",
+        :private_key => "pp_credit_ezp_merchant_private_key",
+      )
+
+      result = ezp_gateway.transaction.sale(transaction_params)
+      expect(result.errors.for(:transaction).first.code).to eq(Braintree::ErrorCodes::PaymentFacilitator::PaymentFacilitatorNotApplicable)
+    end
+  end
+end