braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/customer_spec.rb

@@ -1,14 +1,16 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Customer do
   describe "self.all" do
-    it "gets more than a page of customers" do
+    #Disabling test until we have a more stable CI
+    xit "gets more than a page of customers" do
       customers = Braintree::Customer.all
-      customers.maximum_size.should > 100
+      expect(customers.maximum_size).to be > 100
 
-      customer_ids = customers.map {|c| c.id }.uniq.compact
-      customer_ids.size.should == customers.maximum_size
+      customer_ids = customers.map { |c| c.id }.uniq.compact
+      expect(customer_ids.size).to eq(customers.maximum_size)
     end
   end
 
@@ -16,13 +18,13 @@ describe Braintree::Customer do
     it "deletes the customer with the given id" do
      create_result = Braintree::Customer.create(
         :first_name => "Joe",
-        :last_name => "Cool"
+        :last_name => "Cool",
       )
-      create_result.success?.should == true
+      expect(create_result.success?).to eq(true)
       customer = create_result.customer
 
       delete_result = Braintree::Customer.delete(customer.id)
-      delete_result.success?.should == true
+      expect(delete_result.success?).to eq(true)
       expect do
         Braintree::Customer.find(customer.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -37,62 +39,175 @@ describe Braintree::Customer do
         :company => "Microsoft",
         :email => "bill@microsoft.com",
         :phone => "312.555.1234",
+        :international_phone => {:country_code => "1", :national_number => "3121234567"},
         :fax => "614.555.5678",
-        :website => "www.microsoft.com"
+        :website => "www.microsoft.com",
+        :tax_identifiers => [{:country_code => "US", :identifier => "987654321"}],
       )
-      result.success?.should == true
-      result.customer.id.should =~ /^\d{6}$/
-      result.customer.first_name.should == "Bill"
-      result.customer.last_name.should == "Gates"
-      result.customer.company.should == "Microsoft"
-      result.customer.email.should == "bill@microsoft.com"
-      result.customer.phone.should == "312.555.1234"
-      result.customer.fax.should == "614.555.5678"
-      result.customer.website.should == "www.microsoft.com"
-      result.customer.created_at.between?(Time.now - 10, Time.now).should == true
-      result.customer.updated_at.between?(Time.now - 10, Time.now).should == true
+      expect(result.success?).to eq(true)
+      expect(result.customer.id).to match(/^\d{6,}$/)
+      expect(result.customer.first_name).to eq("Bill")
+      expect(result.customer.last_name).to eq("Gates")
+      expect(result.customer.company).to eq("Microsoft")
+      expect(result.customer.email).to eq("bill@microsoft.com")
+      expect(result.customer.phone).to eq("312.555.1234")
+      expect(result.customer.international_phone[:country_code]).to eq("1")
+      expect(result.customer.international_phone[:national_number]).to eq("3121234567")
+      expect(result.customer.fax).to eq("614.555.5678")
+      expect(result.customer.website).to eq("www.microsoft.com")
+      expect(result.customer.created_at.between?(Time.now - 10, Time.now)).to eq(true)
+      expect(result.customer.updated_at.between?(Time.now - 10, Time.now)).to eq(true)
+    end
+
+    it "returns a successful result if successful using an access token" do
+      oauth_gateway = Braintree::Gateway.new(
+        :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
+        :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
+        :logger => Logger.new("/dev/null"),
+      )
+      access_token = Braintree::OAuthTestHelper.create_token(oauth_gateway, {
+        :merchant_public_id => "integration_merchant_id",
+        :scope => "read_write"
+      }).credentials.access_token
+
+      gateway = Braintree::Gateway.new(
+        :access_token => access_token,
+        :logger => Logger.new("/dev/null"),
+      )
+
+      result = gateway.customer.create(
+        :first_name => "Joe",
+        :last_name => "Brown",
+        :company => "ExampleCo",
+        :email => "joe@example.com",
+        :phone => "312.555.1234",
+        :fax => "614.555.5678",
+        :website => "www.example.com",
+      )
+      expect(result.success?).to eq(true)
+      expect(result.customer.id).to match(/^\d{6,}$/)
+      expect(result.customer.first_name).to eq("Joe")
+      expect(result.customer.last_name).to eq("Brown")
+    end
+
+    it "supports creation with device_data" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :device_data => "device_data",
+        },
+      )
+
+      expect(result).to be_success
+    end
+
+    it "supports creation including risk data with customer_browser and customer_ip" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100"
+        },
+        :risk_data => {
+          :customer_browser => "IE5",
+          :customer_ip => "192.168.0.1"
+        },
+      )
+
+      expect(result).to be_success
+    end
+
+    it "includes risk data when skip_advanced_fraud_checking is false" do
+      with_fraud_protection_enterprise_merchant do
+        result = Braintree::Customer.create(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "05/2010",
+            :cvv => "100",
+            :options => {
+              :skip_advanced_fraud_checking => false,
+              :verify_card => true,
+            },
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.customer.credit_cards.first.verification
+        expect(verification.risk_data).not_to be_nil
+      end
+    end
+
+    it "does not include risk data when skip_advanced_fraud_checking is true" do
+      with_fraud_protection_enterprise_merchant do
+        result = Braintree::Customer.create(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "05/2010",
+            :cvv => "100",
+            :options => {
+              :skip_advanced_fraud_checking => true,
+              :verify_card => true,
+            },
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.customer.credit_cards.first.verification
+        expect(verification.risk_data).to be_nil
+      end
+    end
+
+    it "supports creation with tax_identifiers" do
+      result = Braintree::Customer.create(
+        :tax_identifiers => [
+          {:country_code => "US", :identifier => "987654321"},
+          {:country_code => "CL", :identifier => "123456789"}
+        ],
+      )
+
+      expect(result).to be_success
     end
 
     it "can create without any attributes" do
       result = Braintree::Customer.create
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
 
     it "supports utf-8" do
       first_name = "Jos\303\251"
       last_name = "Mu\303\261oz"
       result = Braintree::Customer.create(:first_name => first_name, :last_name => last_name)
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       if RUBY_VERSION =~ /^1.8/
-        result.customer.first_name.should == first_name
-        result.customer.last_name.should == last_name
+        expect(result.customer.first_name).to eq(first_name)
+        expect(result.customer.last_name).to eq(last_name)
 
         found_customer = Braintree::Customer.find(result.customer.id)
-        found_customer.first_name.should == first_name
-        found_customer.last_name.should == last_name
-      elsif RUBY_VERSION =~ /^1.9/
-        result.customer.first_name.should == "José"
-        result.customer.first_name.bytes.map {|b| b.to_s(8)}.should == ["112", "157", "163", "303", "251"]
-        result.customer.last_name.should == "Muñoz"
-        result.customer.last_name.bytes.map {|b| b.to_s(8)}.should == ["115", "165", "303", "261", "157", "172"]
+        expect(found_customer.first_name).to eq(first_name)
+        expect(found_customer.last_name).to eq(last_name)
+      else
+        expect(result.customer.first_name).to eq("José")
+        expect(result.customer.first_name.bytes.map { |b| b.to_s(8) }).to eq(["112", "157", "163", "303", "251"])
+        expect(result.customer.last_name).to eq("Muñoz")
+        expect(result.customer.last_name.bytes.map { |b| b.to_s(8) }).to eq(["115", "165", "303", "261", "157", "172"])
 
         found_customer = Braintree::Customer.find(result.customer.id)
-        found_customer.first_name.should == "José"
-        found_customer.first_name.bytes.map {|b| b.to_s(8)}.should == ["112", "157", "163", "303", "251"]
-        found_customer.last_name.should == "Muñoz"
-        found_customer.last_name.bytes.map {|b| b.to_s(8)}.should == ["115", "165", "303", "261", "157", "172"]
-      else
-        raise "unknown ruby version: #{RUBY_VERSION.inspect}"
+        expect(found_customer.first_name).to eq("José")
+        expect(found_customer.first_name.bytes.map { |b| b.to_s(8) }).to eq(["112", "157", "163", "303", "251"])
+        expect(found_customer.last_name).to eq("Muñoz")
+        expect(found_customer.last_name.bytes.map { |b| b.to_s(8) }).to eq(["115", "165", "303", "261", "157", "172"])
       end
     end
 
     it "returns an error response if invalid" do
       result = Braintree::Customer.create(
-        :email => "@invalid.com"
+        :email => "@invalid.com",
       )
-      result.success?.should == false
-      result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).on(:email)[0].message).to eq("Email is an invalid format.")
     end
 
     it "can create a customer and a payment method at the same time" do
@@ -103,14 +218,34 @@ describe Braintree::Customer do
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
           :expiration_date => "05/2010",
           :cvv => "100"
-        }
+        },
       )
-      result.success?.should == true
-      result.customer.first_name.should == "Mike"
-      result.customer.last_name.should == "Jones"
-      result.customer.credit_cards[0].bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      result.customer.credit_cards[0].last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-      result.customer.credit_cards[0].expiration_date.should == "05/2010"
+
+      expect(result.success?).to eq(true)
+      expect(result.customer.first_name).to eq("Mike")
+      expect(result.customer.last_name).to eq("Jones")
+      expect(result.customer.credit_cards[0].bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(result.customer.credit_cards[0].last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+      expect(result.customer.credit_cards[0].expiration_date).to eq("05/2010")
+      expect(result.customer.credit_cards[0].unique_number_identifier).to match(/\A\w{32}\z/)
+    end
+
+    it "can create a customer and a paypal account at the same time" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :paypal_account => {
+          :email => "other@example.com",
+          :billing_agreement_id => "B-123456",
+          :options => {:make_default => true}
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.customer.first_name).to eq("Mike")
+      expect(result.customer.last_name).to eq("Jones")
+      expect(result.customer.paypal_accounts[0].billing_agreement_id).to eq("B-123456")
+      expect(result.customer.paypal_accounts[0].email).to eq("other@example.com")
     end
 
     it "verifies the card if credit_card[options][verify_card]=true" do
@@ -121,10 +256,44 @@ describe Braintree::Customer do
           :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::MasterCard,
           :expiration_date => "05/2010",
           :options => {:verify_card => true}
-        }
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+    end
+
+    it "allows a verification_amount" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2019",
+          :options => {:verify_card => true, :verification_amount => "2.00"}
+        },
       )
-      result.success?.should == false
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      expect(result.success?).to eq(true)
+    end
+
+    it "fails on create if credit_card[options][fail_on_duplicate_payment_method]=true and there is a duplicated payment method" do
+      customer = Braintree::Customer.create!
+      Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2015",
+      )
+
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2015",
+          :options => {:fail_on_duplicate_payment_method => true}
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Duplicate card exists in the vault.")
     end
 
     it "allows the user to specify the merchant account for verification" do
@@ -138,12 +307,98 @@ describe Braintree::Customer do
             :verify_card => true,
             :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
           }
-        }
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+    end
+
+    it "can create a customer and a payment method at the same time after validating verification_currency_iso_code" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "USD"
+          }
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.customer.first_name).to eq("Mike")
+      expect(result.customer.last_name).to eq("Jones")
+      expect(result.customer.credit_cards[0].bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(result.customer.credit_cards[0].last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+      expect(result.customer.credit_cards[0].expiration_date).to eq("05/2010")
+      expect(result.customer.credit_cards[0].unique_number_identifier).to match(/\A\w{32}\z/)
+      result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+    end
+
+    it "errors when verification_currency_iso_code is not supported by merchant account" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "GBP"
+          }
+        },
+      )
+      expect(result).to_not be_success
+      expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
+    it "validates verification_currency_iso_code of the given verification_merchant_account_id and creates customer" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "USD"
+          }
+        },
+      )
+      expect(result.success?).to eq(true)
+      result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+      expect(result.customer.first_name).to eq("Mike")
+      expect(result.customer.last_name).to eq("Jones")
+      expect(result.customer.credit_cards[0].bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(result.customer.credit_cards[0].last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+      expect(result.customer.credit_cards[0].expiration_date).to eq("05/2010")
+      expect(result.customer.credit_cards[0].unique_number_identifier).to match(/\A\w{32}\z/)
+    end
+
+    it "validates verification_currency_iso_code of the given verification_merchant_account_id and returns error" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "GBP"
+          }
+        },
       )
-      result.success?.should == false
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      expect(result).to_not be_success
+      expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
     end
 
+
     it "can create a customer, payment method, and billing address at the same time" do
       result = Braintree::Customer.create(
         :first_name => "Mike",
@@ -159,22 +414,22 @@ describe Braintree::Customer do
             :postal_code => "60622",
             :country_name => "United States of America"
           }
-        }
-      )
-      result.success?.should == true
-      result.customer.first_name.should == "Mike"
-      result.customer.last_name.should == "Jones"
-      result.customer.credit_cards[0].bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      result.customer.credit_cards[0].last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-      result.customer.credit_cards[0].expiration_date.should == "05/2010"
-      result.customer.credit_cards[0].billing_address.id.should == result.customer.addresses[0].id
-      result.customer.addresses[0].id.should =~ /\w+/
-      result.customer.addresses[0].street_address.should == "1 E Main St"
-      result.customer.addresses[0].extended_address.should == "Suite 3"
-      result.customer.addresses[0].locality.should == "Chicago"
-      result.customer.addresses[0].region.should == "Illinois"
-      result.customer.addresses[0].postal_code.should == "60622"
-      result.customer.addresses[0].country_name.should == "United States of America"
+        },
+      )
+      expect(result.success?).to eq(true)
+      expect(result.customer.first_name).to eq("Mike")
+      expect(result.customer.last_name).to eq("Jones")
+      expect(result.customer.credit_cards[0].bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(result.customer.credit_cards[0].last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+      expect(result.customer.credit_cards[0].expiration_date).to eq("05/2010")
+      expect(result.customer.credit_cards[0].billing_address.id).to eq(result.customer.addresses[0].id)
+      expect(result.customer.addresses[0].id).to match(/\w+/)
+      expect(result.customer.addresses[0].street_address).to eq("1 E Main St")
+      expect(result.customer.addresses[0].extended_address).to eq("Suite 3")
+      expect(result.customer.addresses[0].locality).to eq("Chicago")
+      expect(result.customer.addresses[0].region).to eq("Illinois")
+      expect(result.customer.addresses[0].postal_code).to eq("60622")
+      expect(result.customer.addresses[0].country_name).to eq("United States of America")
     end
 
     it "can use any country code" do
@@ -190,13 +445,13 @@ describe Braintree::Customer do
             :country_code_alpha3 => "COM",
             :country_code_numeric => "174"
           }
-        }
+        },
       )
-      result.success?.should == true
-      result.customer.addresses[0].country_name.should == "Comoros"
-      result.customer.addresses[0].country_code_alpha2.should == "KM"
-      result.customer.addresses[0].country_code_alpha3.should == "COM"
-      result.customer.addresses[0].country_code_numeric.should == "174"
+      expect(result.success?).to eq(true)
+      expect(result.customer.addresses[0].country_name).to eq("Comoros")
+      expect(result.customer.addresses[0].country_code_alpha2).to eq("KM")
+      expect(result.customer.addresses[0].country_code_alpha3).to eq("COM")
+      expect(result.customer.addresses[0].country_code_numeric).to eq("174")
     end
 
     it "stores custom fields when valid" do
@@ -205,10 +460,20 @@ describe Braintree::Customer do
         :last_name => "Gates",
         :custom_fields => {
           :store_me => "custom value"
-        }
+        },
       )
-      result.success?.should == true
-      result.customer.custom_fields[:store_me].should == "custom value"
+      expect(result.success?).to eq(true)
+      expect(result.customer.custom_fields[:store_me]).to eq("custom value")
+    end
+
+    it "returns empty hash for custom fields when blank" do
+      result = Braintree::Customer.create(
+        :first_name => "Bill",
+        :last_name => "Gates",
+        :custom_fields => {:store_me => ""},
+      )
+      expect(result.success?).to eq(true)
+      expect(result.customer.custom_fields).to eq({})
     end
 
     it "returns nested errors if credit card and/or billing address are invalid" do
@@ -219,12 +484,12 @@ describe Braintree::Customer do
           :billing_address => {
             :country_name => "invalid"
           }
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
-      result.errors.for(:customer).for(:credit_card).on(:number)[0].message.should == "Credit card number is invalid."
-      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).on(:email)[0].message).to eq("Email is an invalid format.")
+      expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Credit card number is invalid.")
+      expect(result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
 
     it "returns errors if country codes are inconsistent" do
@@ -239,10 +504,10 @@ describe Braintree::Customer do
             :country_code_alpha2 => "US",
             :country_code_alpha3 => "COM",
           }
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:base).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:base).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error if country code alpha2 is invalid" do
@@ -255,10 +520,10 @@ describe Braintree::Customer do
           :billing_address => {
             :country_code_alpha2 => "zz",
           }
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha2).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha2).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
     end
 
     it "returns an error if country code alpha3 is invalid" do
@@ -271,10 +536,10 @@ describe Braintree::Customer do
           :billing_address => {
             :country_code_alpha3 => "zzz",
           }
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha3).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha3).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
     end
 
     it "returns an error if country code numeric is invalid" do
@@ -287,10 +552,10 @@ describe Braintree::Customer do
           :billing_address => {
             :country_code_numeric => "zzz",
           }
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_numeric).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_numeric).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns errors if custom_fields are not registered" do
@@ -299,10 +564,138 @@ describe Braintree::Customer do
         :last_name => "Kennedy",
         :custom_fields => {
           :spouse_name => "Jacqueline"
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).on(:custom_fields)[0].message.should == "Custom field is invalid: spouse_name."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).on(:custom_fields)[0].message).to eq("Custom field is invalid: spouse_name.")
+    end
+
+    context "client API" do
+      it "can create a customer with a payment method nonce" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => "4111111111111111",
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+          :share => true,
+        )
+
+        result = Braintree::Customer.create(
+          :credit_card => {
+            :payment_method_nonce => nonce
+          },
+        )
+
+        expect(result.success?).to eq(true)
+        expect(result.customer.credit_cards.first.bin).to eq("411111")
+        expect(result.customer.credit_cards.first.last_4).to eq("1111")
+      end
+    end
+
+    it "can create a customer with an apple pay payment method" do
+      result = Braintree::Customer.create(:payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa)
+
+      expect(result.success?).to eq(true)
+      expect(result.customer.payment_methods).not_to be_empty
+      expect(result.customer.payment_methods.first.token).not_to be_nil
+    end
+
+    it "can create a customer with an unknown payment method" do
+      result = Braintree::Customer.create(:payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable)
+
+      expect(result.success?).to eq(true)
+    end
+
+    context "verification_account_type" do
+      it "verifies card with account_type debit" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+              :verification_account_type => "debit",
+            }
+          },
+        )
+
+        expect(result).to be_success
+      end
+
+      it "verifies card with account_type credit" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "credit",
+            }
+          },
+        )
+
+        expect(result).to be_success
+      end
+
+      it "errors with invalid account_type" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "ach",
+            }
+          },
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeIsInvalid
+      end
+
+      it "errors when account_type not supported by merchant" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_account_type => "credit",
+            }
+          },
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeNotSupported
+      end
     end
   end
 
@@ -310,16 +703,16 @@ describe Braintree::Customer do
     it "returns the customer if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Jim",
-        :last_name => "Smith"
+        :last_name => "Smith",
       )
-      customer.id.should =~ /\d+/
-      customer.first_name.should == "Jim"
-      customer.last_name.should == "Smith"
+      expect(customer.id).to match(/\d+/)
+      expect(customer.first_name).to eq("Jim")
+      expect(customer.last_name).to eq("Smith")
     end
 
     it "can create without any attributes" do
       customer = Braintree::Customer.create!
-      customer.id.should =~ /\d+/
+      expect(customer.id).to match(/\d+/)
     end
 
     it "raises an exception if not successful" do
@@ -335,17 +728,17 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::Customer.credit(customer.id, :amount => "100.00")
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new("100.00")
-      result.transaction.type.should == "credit"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("credit")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(result.transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(result.transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -355,16 +748,16 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction = Braintree::Customer.credit!(customer.id, :amount => "100.00")
-      transaction.amount.should == BigDecimal.new("100.00")
-      transaction.type.should == "credit"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("credit")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -374,17 +767,17 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::Customer.sale(customer.id, :amount => "100.00")
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(result.transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(result.transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -394,16 +787,16 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction = Braintree::Customer.sale!(customer.id, :amount => "100.00")
-      transaction.amount.should == BigDecimal.new("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -413,67 +806,11 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
-      transaction = customer.sale!(:amount => "100.00")
+      transaction = Braintree::Customer.sale!(customer.id, :amount => "100.00")
       collection = Braintree::Customer.transactions(customer.id)
-      collection.first.should == transaction
-    end
-  end
-
-
-  describe "sale" do
-    it "creates a sale transaction using the customer, returning a result object" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      result = customer.sale(
-        :amount => "100.00"
-      )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "sale!" do
-    it "returns the created sale tranaction if valid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      transaction = customer.sale!(:amount => "100.00")
-      transaction.amount.should == BigDecimal.new("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "transactions" do
-    it "finds transactions for the customer" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      transaction = customer.sale!(:amount => "100.00")
-      collection = customer.transactions
-      collection.first.should == transaction
+      expect(collection.first).to eq(transaction)
     end
   end
 
@@ -483,19 +820,19 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = customer.credit(
-        :amount => "100.00"
+        :amount => "100.00",
       )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new("100.00")
-      result.transaction.type.should == "credit"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("credit")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(result.transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(result.transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -505,77 +842,16 @@ describe Braintree::Customer do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction = customer.credit!(:amount => "100.00")
-      transaction.amount.should == BigDecimal.new("100.00")
-      transaction.type.should == "credit"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "create_from_transparent_redirect" do
-    it "returns a successful result if successful" do
-      params = {
-        :customer => {
-          :first_name => "John",
-          :last_name => "Doe",
-          :company => "Doe Co",
-          :email => "john@doe.com",
-          :phone => "312.555.2323",
-          :fax => "614.555.5656",
-          :website => "www.johndoe.com"
-        }
-      }
-
-      tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Customer.create_customer_url)
-      result = Braintree::Customer.create_from_transparent_redirect(query_string_response)
-
-      result.success?.should == true
-      customer = result.customer
-      customer.first_name.should == "John"
-      customer.last_name.should == "Doe"
-      customer.company.should == "Doe Co"
-      customer.email.should == "john@doe.com"
-      customer.phone.should == "312.555.2323"
-      customer.fax.should == "614.555.5656"
-      customer.website.should == "www.johndoe.com"
-    end
-
-    it "can pass any attribute through tr_data" do
-      customer_id = "customer_#{rand(1_000_000)}"
-      tr_data_params = {
-        :customer => {
-          :id => customer_id,
-          :first_name => "John",
-          :last_name => "Doe",
-          :company => "Doe Co",
-          :email => "john@doe.com",
-          :phone => "312.555.2323",
-          :fax => "614.555.5656",
-          :website => "www.johndoe.com"
-        }
-      }
-
-      tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Customer.create_customer_url)
-      result = Braintree::Customer.create_from_transparent_redirect(query_string_response)
-
-      result.success?.should == true
-      customer = result.customer
-      customer.id.should == customer_id
-      customer.first_name.should == "John"
-      customer.last_name.should == "Doe"
-      customer.company.should == "Doe Co"
-      customer.email.should == "john@doe.com"
-      customer.phone.should == "312.555.2323"
-      customer.fax.should == "614.555.5656"
-      customer.website.should == "www.johndoe.com"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("credit")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -583,12 +859,12 @@ describe Braintree::Customer do
     it "deletes the customer" do
      result = Braintree::Customer.create(
         :first_name => "Joe",
-        :last_name => "Cool"
+        :last_name => "Cool",
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       customer = result.customer
-      customer.delete.success?.should == true
+      expect(customer.delete.success?).to eq(true)
       expect do
         Braintree::Customer.find(customer.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -600,14 +876,15 @@ describe Braintree::Customer do
     it "finds the customer with the given id" do
       result = Braintree::Customer.create(
         :first_name => "Joe",
-        :last_name => "Cool"
+        :last_name => "Cool",
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       customer = Braintree::Customer.find(result.customer.id)
-      customer.id.should == result.customer.id
-      customer.first_name.should == "Joe"
-      customer.last_name.should == "Cool"
+      expect(customer.id).to eq(result.customer.id)
+      expect(customer.graphql_id).not_to be_nil
+      expect(customer.first_name).to eq("Joe")
+      expect(customer.last_name).to eq("Cool")
     end
 
     it "returns associated subscriptions" do
@@ -615,26 +892,215 @@ describe Braintree::Customer do
       credit_card = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       ).credit_card
 
       subscription = Braintree::Subscription.create(
         :payment_method_token => credit_card.token,
         :plan_id => "integration_trialless_plan",
-        :price => "1.00"
+        :price => "1.00",
       ).subscription
 
       found_customer = Braintree::Customer.find(customer.id)
-      found_customer.credit_cards.first.subscriptions.first.id.should == subscription.id
-      found_customer.credit_cards.first.subscriptions.first.plan_id.should == "integration_trialless_plan"
-      found_customer.credit_cards.first.subscriptions.first.payment_method_token.should == credit_card.token
-      found_customer.credit_cards.first.subscriptions.first.price.should == BigDecimal.new("1.00")
+      expect(found_customer.credit_cards.first.subscriptions.first.id).to eq(subscription.id)
+      expect(found_customer.credit_cards.first.subscriptions.first.plan_id).to eq("integration_trialless_plan")
+      expect(found_customer.credit_cards.first.subscriptions.first.payment_method_token).to eq(credit_card.token)
+      expect(found_customer.credit_cards.first.subscriptions.first.price).to eq(BigDecimal("1.00"))
+    end
+
+    context "when given an association filter id" do
+      it "filters out all filterable associations" do
+        customer = Braintree::Customer.create(
+          :custom_fields => {
+            :store_me => "custom value"
+          },
+        ).customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :street_address => "1 E Main St",
+            :locality => "Chicago",
+            :region => "Illinois",
+            :postal_code => "60622",
+            :country_name => "United States of America"
+          },
+        ).credit_card
+
+        Braintree::Subscription.create(
+          :payment_method_token => credit_card.token,
+          :plan_id => "integration_trialless_plan",
+          :price => "1.00",
+        )
+
+        found_customer = Braintree::Customer.find(customer.id, {
+          :association_filter_id => "customernoassociations"
+        })
+        expect(found_customer.credit_cards.length).to eq(0)
+        expect(found_customer.payment_methods.length).to eq(0)
+        expect(found_customer.addresses.length).to eq(0)
+        expect(found_customer.custom_fields).to eq({})
+      end
+
+      it "filters out nested filterable associations" do
+        customer = Braintree::Customer.create(
+          :custom_fields => {
+            :store_me => "custom value"
+          },
+        ).customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :street_address => "1 E Main St",
+            :locality => "Chicago",
+            :region => "Illinois",
+            :postal_code => "60622",
+            :country_name => "United States of America"
+          },
+        ).credit_card
+
+        Braintree::Subscription.create(
+          :payment_method_token => credit_card.token,
+          :plan_id => "integration_trialless_plan",
+          :price => "1.00",
+        )
+
+        found_customer = Braintree::Customer.find(customer.id, {
+         :association_filter_id =>  "customertoplevelassociations"
+        })
+
+        expect(found_customer.credit_cards.length).to eq(1)
+        expect(found_customer.credit_cards.first.subscriptions.length).to eq(0)
+        expect(found_customer.payment_methods.length).to eq(1)
+        expect(found_customer.payment_methods.first.subscriptions.length).to eq(0)
+        expect(found_customer.addresses.length).to eq(1)
+        expect(found_customer.custom_fields.length).to eq(1)
+      end
+    end
+
+    it "returns associated ApplePayCards" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx,
+      )
+      expect(result.success?).to eq(true)
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      expect(found_customer.apple_pay_cards).not_to be_nil
+      apple_pay_card = found_customer.apple_pay_cards.first
+      expect(apple_pay_card).to be_a Braintree::ApplePayCard
+      expect(apple_pay_card.commercial).not_to be_nil
+      expect(apple_pay_card.country_of_issuance).not_to be_nil
+      expect(apple_pay_card.debit).not_to be_nil
+      expect(apple_pay_card.durbin_regulated).not_to be_nil
+      expect(apple_pay_card.expiration_year).not_to be_nil
+      expect(apple_pay_card.healthcare).not_to be_nil
+      expect(apple_pay_card.issuing_bank).not_to be_nil
+      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
+      expect(apple_pay_card.payroll).not_to be_nil
+      expect(apple_pay_card.prepaid).not_to be_nil
+      expect(apple_pay_card.prepaid_reloadable).not_to be_nil
+      expect(apple_pay_card.product_id).not_to be_nil
+      expect(apple_pay_card.token).not_to be_nil
+    end
+
+    it "returns associated google pay proxy cards" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
+      )
+      expect(result.success?).to eq(true)
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      expect(found_customer.google_pay_cards.size).to eq(1)
+      expect(found_customer.payment_methods.size).to eq(1)
+      google_pay_card = found_customer.google_pay_cards.first
+      expect(google_pay_card).to be_a Braintree::GooglePayCard
+      expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.country_of_issuance).not_to be_nil
+      expect(google_pay_card.debit).not_to be_nil
+      expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.expiration_year).not_to be_nil
+      expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.is_network_tokenized?).to eq(false)
+      expect(google_pay_card.issuing_bank).not_to be_nil
+      expect(google_pay_card.payroll).not_to be_nil
+      expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.prepaid_reloadable).not_to be_nil
+      expect(google_pay_card.product_id).not_to be_nil
+      expect(google_pay_card.token).not_to be_nil
+    end
+
+    it "returns associated google pay network tokens" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
+      )
+      expect(result.success?).to eq(true)
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      expect(found_customer.google_pay_cards.size).to eq(1)
+      expect(found_customer.payment_methods.size).to eq(1)
+      google_pay_card = found_customer.google_pay_cards.first
+      expect(google_pay_card).to be_a Braintree::GooglePayCard
+      expect(google_pay_card.token).not_to be_nil
+      expect(google_pay_card.expiration_year).not_to be_nil
+      expect(google_pay_card.is_network_tokenized?).to eq(true)
+      expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.country_of_issuance).not_to be_nil
+      expect(google_pay_card.debit).not_to be_nil
+      expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.issuing_bank).not_to be_nil
+      expect(google_pay_card.payroll).not_to be_nil
+      expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.prepaid_reloadable).not_to be_nil
+      expect(google_pay_card.product_id).not_to be_nil
+    end
+
+    it "returns associated venmo accounts" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
+      )
+      expect(result.success?).to eq(true)
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      expect(found_customer.venmo_accounts.size).to eq(1)
+      expect(found_customer.payment_methods.size).to eq(1)
+      venmo_account = found_customer.venmo_accounts.first
+      expect(venmo_account).to be_a Braintree::VenmoAccount
+      expect(venmo_account.token).not_to be_nil
+      expect(venmo_account.username).not_to be_nil
+    end
+
+    xit "returns associated us bank accounts" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+        :credit_card => {
+          :options => {
+            :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          }
+        },
+      )
+      expect(result).to be_success
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      expect(found_customer.us_bank_accounts.size).to eq(1)
+      expect(found_customer.payment_methods.size).to eq(1)
+
+      us_bank_account = found_customer.us_bank_accounts.first
+      expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+      expect(us_bank_account.routing_number).to eq("021000021")
+      expect(us_bank_account.last_4).to eq("0000")
+      expect(us_bank_account.account_type).to eq("checking")
+      expect(us_bank_account.account_holder_name).to eq("John Doe")
+      expect(us_bank_account.bank_name).to match(/CHASE/)
     end
 
     it "works for a blank customer" do
       created_customer = Braintree::Customer.create!
       found_customer = Braintree::Customer.find(created_customer.id)
-      found_customer.id.should == created_customer.id
+      expect(found_customer.id).to eq(created_customer.id)
     end
 
     it "raises an ArgumentError if customer_id is not a string" do
@@ -657,30 +1123,214 @@ describe Braintree::Customer do
   end
 
   describe "self.update" do
+      it "updates the credit card with three_d_secure pass thru params" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+          :last_name => "Cool",
+        )
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "Mr. Joe",
+          :last_name => "Super Cool",
+          :custom_fields => {
+            :store_me => "a value"
+          },
+          :credit_card => {
+            :number => 4111111111111111,
+            :expiration_date => "05/2060",
+            :three_d_secure_pass_thru => {
+              :eci_flag => "05",
+              :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.success?).to eq(true)
+        expect(result.customer.id).to eq(customer.id)
+        expect(result.customer.first_name).to eq("Mr. Joe")
+        expect(result.customer.last_name).to eq("Super Cool")
+        expect(result.customer.custom_fields[:store_me]).to eq("a value")
+      end
+
+      it "validates the presence of three_d_secure_version while passing three_d_secure_pass_thru in update" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+          :last_name => "Cool",
+        )
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "Mr. Joe",
+          :last_name => "Super Cool",
+          :custom_fields => {
+            :store_me => "a value"
+          },
+          :credit_card => {
+            :number => 4111111111111111,
+            :expiration_date => "05/2060",
+            :three_d_secure_pass_thru => {
+              :eci_flag => "05",
+              :cavv => "some_cavv",
+              :xid => "some_xid",
+              :authentication_response => "Y",
+              :directory_response => "Y",
+              :cavv_algorithm => "2",
+              :ds_transaction_id => "some_ds_transaction_id",
+            },
+            options: {:verify_card => true}
+          },
+        )
+        expect(result).to_not be_success
+        error = result.errors.for(:verification).first
+        expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsRequired)
+        expect(error.message).to eq("ThreeDSecureVersion is required.")
+      end
+
     it "updates the customer with the given id if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
-        :last_name => "Cool"
+        :last_name => "Cool",
       )
       result = Braintree::Customer.update(
         customer.id,
         :first_name => "Mr. Joe",
         :last_name => "Super Cool",
+        :international_phone => {:country_code => "1", :national_number => "3121234567"},
         :custom_fields => {
           :store_me => "a value"
-        }
+        },
+      )
+      expect(result.success?).to eq(true)
+      expect(result.customer.id).to eq(customer.id)
+      expect(result.customer.first_name).to eq("Mr. Joe")
+      expect(result.customer.last_name).to eq("Super Cool")
+      expect(result.customer.international_phone[:country_code]).to eq("1")
+      expect(result.customer.international_phone[:national_number]).to eq("3121234567")
+      expect(result.customer.custom_fields[:store_me]).to eq("a value")
+    end
+
+    it "does not update customer with duplicate payment method if fail_on_payment_method option set" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+        },
+      )
+      result = Braintree::Customer.update(
+        customer.id,
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+          :options=> {
+            :fail_on_duplicate_payment_method => true
+          }
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Duplicate card exists in the vault.")
+    end
+
+    it "does not update customer with duplicate payment method if fail_on_payment_method_for_customer option set" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+        },
       )
-      result.success?.should == true
-      result.customer.id.should == customer.id
-      result.customer.first_name.should == "Mr. Joe"
-      result.customer.last_name.should == "Super Cool"
-      result.customer.custom_fields[:store_me].should == "a value"
+      result = Braintree::Customer.update(
+        customer.id,
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+          :options=> {
+            :fail_on_duplicate_payment_method_for_customer => true
+          }
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Duplicate card exists in the vault for the customer.")
+    end
+
+    it "updates the default payment method" do
+      customer = Braintree::Customer.create!(
+        :first_name => "Joe",
+        :last_name => "Brown",
+      )
+
+      token1 = random_payment_method_token
+
+      Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :token => token1,
+      )
+
+      payment_method1 = Braintree::PaymentMethod.find(token1)
+      expect(payment_method1).to be_default
+
+      token2 = random_payment_method_token
+
+      Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableMasterCard,
+        :token => token2,
+      )
+
+      Braintree::Customer.update(customer.id,
+        :default_payment_method_token => token2,
+      )
+
+      payment_method2 = Braintree::PaymentMethod.find(token2)
+      expect(payment_method2).to be_default
+    end
+
+    it "updates the default payment method in the options" do
+      customer = Braintree::Customer.create!(
+        :first_name => "Joe",
+        :last_name => "Brown",
+      )
+
+      token1 = random_payment_method_token
+
+      Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :token => token1,
+      )
+
+      payment_method1 = Braintree::PaymentMethod.find(token1)
+      expect(payment_method1).to be_default
+
+      token2 = random_payment_method_token
+
+      Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableMasterCard,
+        :token => token2,
+      )
+
+      Braintree::Customer.update(customer.id,
+        :credit_card => {
+          :options => {
+            :update_existing_token => token2,
+            :make_default => true
+          }
+        },
+      )
+
+      payment_method2 = Braintree::PaymentMethod.find(token2)
+      expect(payment_method2).to be_default
     end
 
     it "can use any country code" do
       customer = Braintree::Customer.create!(
         :first_name => "Alex",
-        :last_name => "Matterson"
+        :last_name => "Matterson",
       )
       result = Braintree::Customer.update(
         customer.id,
@@ -695,13 +1345,13 @@ describe Braintree::Customer do
             :country_code_alpha3 => "FJI",
             :country_code_numeric => "242"
           }
-        }
+        },
       )
-      result.success?.should == true
-      result.customer.addresses[0].country_name.should == "Fiji"
-      result.customer.addresses[0].country_code_alpha2.should == "FJ"
-      result.customer.addresses[0].country_code_alpha3.should == "FJI"
-      result.customer.addresses[0].country_code_numeric.should == "242"
+      expect(result.success?).to eq(true)
+      expect(result.customer.addresses[0].country_name).to eq("Fiji")
+      expect(result.customer.addresses[0].country_code_alpha2).to eq("FJ")
+      expect(result.customer.addresses[0].country_code_alpha3).to eq("FJI")
+      expect(result.customer.addresses[0].country_code_numeric).to eq("242")
     end
 
     it "can update the customer, credit card, and billing address in one request" do
@@ -714,7 +1364,7 @@ describe Braintree::Customer do
             :first_name => "Joe",
             :postal_code => "60622"
           }
-        }
+        },
       )
 
       result = Braintree::Customer.update(
@@ -722,26 +1372,175 @@ describe Braintree::Customer do
         :first_name => "New Joe",
         :credit_card => {
           :cardholder_name => "New Joe Cardholder",
-          :options => { :update_existing_token => customer.credit_cards.first.token },
+          :options => {:update_existing_token => customer.credit_cards.first.token},
           :billing_address => {
             :last_name => "Cool",
             :postal_code => "60666",
-            :options => { :update_existing => true }
+            :options => {:update_existing => true}
           }
-        }
+        },
       )
-      result.success?.should == true
-      result.customer.id.should == customer.id
-      result.customer.first_name.should == "New Joe"
+      expect(result.success?).to eq(true)
+      expect(result.customer.id).to eq(customer.id)
+      expect(result.customer.first_name).to eq("New Joe")
 
-      result.customer.credit_cards.size.should == 1
+      expect(result.customer.credit_cards.size).to eq(1)
       credit_card = result.customer.credit_cards.first
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa.slice(0, 6)
-      credit_card.cardholder_name.should == "New Joe Cardholder"
+      expect(credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::Visa.slice(0, 6))
+      expect(credit_card.cardholder_name).to eq("New Joe Cardholder")
 
-      credit_card.billing_address.first_name.should == "Joe"
-      credit_card.billing_address.last_name.should == "Cool"
-      credit_card.billing_address.postal_code.should == "60666"
+      expect(credit_card.billing_address.first_name).to eq("Joe")
+      expect(credit_card.billing_address.last_name).to eq("Cool")
+      expect(credit_card.billing_address.postal_code).to eq("60666")
+    end
+
+    it "can update the customer and verify_card with a specific verification_amount" do
+      customer = Braintree::Customer.create!(
+        :first_name => "Joe",
+      )
+
+      result = Braintree::Customer.update(
+        customer.id,
+        :first_name => "New Joe",
+        :credit_card => {
+          :cardholder_name => "New Joe Cardholder",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/2009",
+          :options => {:verify_card => true, :verification_amount => "2.00"}
+        },
+      )
+      expect(result.success?).to eq(true)
+    end
+
+    it "includes risk data when skip_advanced_fraud_checking is false" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        updated_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {
+              :skip_advanced_fraud_checking => false,
+              :verify_card => true,
+            },
+          },
+        )
+
+        expect(updated_result).to be_success
+        verification = updated_result.customer.credit_cards.first.verification
+        expect(verification.risk_data).not_to be_nil
+      end
+    end
+
+    it "does not include risk data when skip_advanced_fraud_checking is true" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        updated_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {
+              :skip_advanced_fraud_checking => true,
+              :verify_card => true,
+            },
+          },
+        )
+
+        expect(updated_result).to be_success
+        verification = updated_result.customer.credit_cards.first.verification
+        expect(verification.risk_data).to be_nil
+      end
+    end
+
+    it "can update a tax_identifier" do
+      customer = Braintree::Customer.create!(
+        :tax_identifiers => [
+          {:country_code => "US", :identifier => "987654321"},
+          {:country_code => "CL", :identifier => "123456789"}
+        ],
+      )
+
+      result = Braintree::Customer.update(
+        customer.id,
+        :tax_identifiers => [{:country_code => "US", :identifier => "567891234"}],
+      )
+      expect(result.success?).to eq(true)
+    end
+
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+        :credit_card => {
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :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
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+        :credit_card => {
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "2.2.1",
+            :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
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+        :credit_card => {
+          :options => {:verify_card => true}
+        },
+      )
+      expect(result.success?).to eq(true)
+
+      three_d_secure_info = result.customer.payment_methods.first.verification.three_d_secure_info
+      expect(three_d_secure_info.enrolled).to eq("Y")
+      expect(three_d_secure_info).to be_liability_shifted
+      expect(three_d_secure_info).to be_liability_shift_possible
+      expect(three_d_secure_info.status).to eq("authenticate_successful")
+      expect(three_d_secure_info.cavv).to eq("cavv_value")
+      expect(three_d_secure_info.xid).to eq("xid_value")
+      expect(three_d_secure_info.eci_flag).to eq("05")
+      expect(three_d_secure_info.three_d_secure_version).to eq("1.0.2")
+      expect(three_d_secure_info.ds_transaction_id).to eq(nil)
     end
 
     it "can update the nested billing address with billing_address_id" do
@@ -750,7 +1549,7 @@ describe Braintree::Customer do
       address = Braintree::Address.create!(
         :customer_id => customer.id,
         :first_name => "John",
-        :last_name => "Doe"
+        :last_name => "Doe",
       )
 
       customer = Braintree::Customer.update(
@@ -759,23 +1558,144 @@ describe Braintree::Customer do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "12/2009",
           :billing_address_id => address.id
-        }
+        },
       ).customer
 
       billing_address = customer.credit_cards.first.billing_address
-      billing_address.id.should == address.id
-      billing_address.first_name.should == "John"
-      billing_address.last_name.should == "Doe"
+      expect(billing_address.id).to eq(address.id)
+      expect(billing_address.first_name).to eq("John")
+      expect(billing_address.last_name).to eq("Doe")
     end
 
     it "returns an error response if invalid" do
       customer = Braintree::Customer.create!(:email => "valid@email.com")
       result = Braintree::Customer.update(
         customer.id,
-        :email => "@invalid.com"
+        :email => "@invalid.com",
       )
-      result.success?.should == false
-      result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).on(:email)[0].message).to eq("Email is an invalid format.")
+    end
+
+    context "verification_currency_iso_code" do
+      it "can update the customer after validating verification_currency_iso_code" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {:verify_card => true, :verification_currency_iso_code => "USD"}
+          },
+        )
+        expect(result.success?).to eq(true)
+        result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+      end
+
+      it "can update the customer after validating verification_currency_iso_code against the given verification_merchant_account_id" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId, :verification_currency_iso_code => "USD"}
+          },
+        )
+        expect(result.success?).to eq(true)
+        result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+        result.customer.credit_cards[0].verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+      end
+
+      it "throws error due to verification_currency_iso_code not matching against the currency configured in default merchant account" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {:verify_card => true, :verification_currency_iso_code => "GBP"}
+          },
+        )
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+
+      end
+
+      it "throws error due to verification_currency_iso_code not matching against the currency configured in the given verification merchant account" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId, :verification_currency_iso_code => "GBP"}
+          },
+        )
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+
+      end
+    end
+
+    context "verification_account_type" do
+      it "updates the credit card with account_type credit" do
+        customer = Braintree::Customer.create!
+        update_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Holder",
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "credit",
+            },
+          },
+        )
+        expect(update_result).to be_success
+      end
+
+      it "updates the credit card with account_type debit" do
+        customer = Braintree::Customer.create!
+        update_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Holder",
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+              :verification_account_type => "debit",
+            },
+          },
+        )
+        expect(update_result).to be_success
+      end
     end
   end
 
@@ -783,16 +1703,16 @@ describe Braintree::Customer do
     it "returns the updated customer if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
-        :last_name => "Cool"
+        :last_name => "Cool",
       )
       updated_customer = Braintree::Customer.update!(
         customer.id,
         :first_name => "Mr. Joe",
-        :last_name => "Super Cool"
+        :last_name => "Super Cool",
       )
-      updated_customer.first_name.should == "Mr. Joe"
-      updated_customer.last_name.should == "Super Cool"
-      updated_customer.updated_at.between?(Time.now - 60, Time.now).should == true
+      expect(updated_customer.first_name).to eq("Mr. Joe")
+      expect(updated_customer.last_name).to eq("Super Cool")
+      expect(updated_customer.updated_at.between?(Time.now - 60, Time.now)).to eq(true)
     end
 
     it "raises an error if unsuccessful" do
@@ -803,210 +1723,209 @@ describe Braintree::Customer do
     end
   end
 
-  describe "update" do
-    it "updates the customer" do
+  describe "default_payment_method" do
+    it "should return the default credit card for a given customer" do
       customer = Braintree::Customer.create!(
-        :first_name => "Joe",
-        :last_name => "Cool"
-      )
-      update_result = customer.update(
-        :first_name => "Mr. Joe",
-        :last_name => "Super Cool"
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/2015",
+          :options => {
+            :make_default => false
+          }
+        },
       )
-      update_result.success?.should == true
-      update_result.customer.should == customer
-      updated_customer = update_result.customer
-      updated_customer.first_name.should == "Mr. Joe"
-      updated_customer.last_name.should == "Super Cool"
-    end
 
-    it "returns an error response if invalid" do
-      customer = Braintree::Customer.create!(
-        :email => "valid@email.com"
-      )
-      result = customer.update(
-        :email => "@invalid.com"
+      default_payment_method = Braintree::CreditCard.create!(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "11/2015",
+        :options => {
+          :make_default => true
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
+
+      customer = Braintree::Customer.find(customer.id)
+
+      expect(customer.default_payment_method).to eq(default_payment_method)
     end
   end
 
-  describe "update!" do
-    it "returns the customer and updates the customer if successful" do
-      customer = Braintree::Customer.create!(
-        :first_name => "Joe",
-        :last_name => "Cool"
-      )
-      customer.update!(
-        :first_name => "Mr. Joe",
-        :last_name => "Super Cool"
-      ).should == customer
-      customer.first_name.should == "Mr. Joe"
-      customer.last_name.should == "Super Cool"
-      customer.updated_at.between?(Time.now - 60, Time.now).should == true
+  describe "paypal" do
+    context "future" do
+      it "creates a customer with a future paypal account" do
+        result = Braintree::Customer.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
+        )
+
+        expect(result).to be_success
+      end
+
+      it "updates a customer with a future paypal account" do
+        customer = Braintree::Customer.create!(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
+            }
+          },
+        )
+
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          },
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce,
+        )
+
+        expect(result).to be_success
+        expect(result.customer.default_payment_method.token).to eq(paypal_account_token)
+      end
     end
 
-    it "raises an error if unsuccessful" do
-      customer = Braintree::Customer.create!(
-        :email => "valid@email.com"
-      )
-      expect do
-        customer.update!(:email => "@invalid.com")
-      end.to raise_error(Braintree::ValidationsFailed)
+    context "limited use" do
+      it "creates a customer with payment_method_nonce and paypal options" do
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          },
+        )
+
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :options => {
+            :paypal => {
+              :payee_email => "payee@example.com",
+              :order_id => "merchant-order-id",
+              :custom_field => "custom merchant field",
+              :description => "merchant description",
+              :amount => "1.23",
+              :shipping => {
+                :first_name => "first",
+                :last_name => "last",
+                :locality => "Austin",
+                :postal_code => "78729",
+                :street_address => "7700 W Parmer Ln",
+                :country_name => "US",
+                :region => "TX",
+              },
+            },
+          },
+        )
+
+        expect(result).to be_success
+      end
+
+      it "updates a customer with payment_method_nonce and paypal options" do
+        customer = Braintree::Customer.create!(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
+            }
+          },
+        )
+
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          },
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce,
+          :options => {
+            :paypal => {
+              :payee_email => "payee@example.com",
+              :order_id => "merchant-order-id",
+              :custom_field => "custom merchant field",
+              :description => "merchant description",
+              :amount => "1.23",
+              :shipping => {
+                :first_name => "first",
+                :last_name => "last",
+                :locality => "Austin",
+                :postal_code => "78729",
+                :street_address => "7700 W Parmer Ln",
+                :country_name => "US",
+                :region => "TX",
+              },
+            },
+          },
+        )
+
+        expect(result).to be_success
+        expect(result.customer.default_payment_method.token).to eq(paypal_account_token)
+      end
     end
-  end
 
-  describe "update_from_transparent_redirect" do
-    it "returns a successful result if successful" do
-      result = Braintree::Customer.create(
-        :first_name => "Old First",
-        :last_name => "Old Last",
-        :company => "Old Company",
-        :email => "old@email.com",
-        :phone => "000.111.2222",
-        :fax => "000.222.3333",
-        :website => "old.website.com"
-      )
-      result.success?.should == true
-      original_customer = result.customer
-      params = {
-        :customer => {
-          :first_name => "New First",
-          :last_name => "New Last",
-          :company => "New Company",
-          :email => "new@email.com",
-          :phone => "888.111.2222",
-          :fax => "999.222.3333",
-          :website => "new.website.com"
-        }
-      }
-      tr_data_params = {
-        :customer_id => original_customer.id
-      }
-
-      tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::Customer.update_customer_url)
-      result = Braintree::Customer.update_from_transparent_redirect(query_string_response)
-
-      result.success?.should == true
-      customer = result.customer
-      customer.id.should == original_customer.id
-      customer.first_name.should == "New First"
-      customer.last_name.should == "New Last"
-      customer.company.should == "New Company"
-      customer.email.should == "new@email.com"
-      customer.phone.should == "888.111.2222"
-      customer.fax.should == "999.222.3333"
-      customer.website.should == "new.website.com"
-    end
-
-    it "returns a successful result when updating an existing credit card" do
-      result = Braintree::Customer.create(
-        :first_name => "Old First",
-        :last_name => "Old Last",
-        :company => "Old Company",
-        :email => "old@email.com",
-        :phone => "000.111.2222",
-        :fax => "000.222.3333",
-        :website => "old.website.com",
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/2009",
-          :billing_address => {
-            :first_name => "Joe",
-            :postal_code => "60622"
-          }
-        }
-      )
-      result.success?.should == true
-      original_customer = result.customer
-
-      tr_data_params = {
-        :customer_id => original_customer.id,
-        :customer => {
-          :first_name => "New First",
-          :last_name => "New Last",
-          :company => "New Company",
-          :email => "new@email.com",
-          :phone => "888.111.2222",
-          :fax => "999.222.3333",
-          :website => "new.website.com",
+    context "onetime" do
+      it "does not create a customer with a onetime paypal account" do
+        result = Braintree::Customer.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        )
+
+        expect(result).not_to be_success
+      end
+
+      it "does not update a customer with a onetime paypal account" do
+        credit_card_token = rand(36**3).to_s(36)
+        customer = Braintree::Customer.create!(
           :credit_card => {
-            :cardholder_name => "New Joe Cardholder",
-            :options => { :update_existing_token => original_customer.credit_cards.first.token },
-            :billing_address => {
-              :last_name => "Cool",
-              :postal_code => "60666",
-              :options => { :update_existing => true }
+            :token => credit_card_token,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
             }
-          }
-        }
-      }
+          },
+        )
 
-      tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Customer.update_customer_url)
-      result = Braintree::Customer.update_from_transparent_redirect(query_string_response)
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :access_token => "PAYPAL_ACCESS_TOKEN",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          },
+        )
 
-      result.success?.should == true
-      customer = result.customer
-      customer.id.should == original_customer.id
-      customer.first_name.should == "New First"
-      customer.last_name.should == "New Last"
-      customer.company.should == "New Company"
-      customer.email.should == "new@email.com"
-      customer.phone.should == "888.111.2222"
-      customer.fax.should == "999.222.3333"
-      customer.website.should == "new.website.com"
-
-      credit_card = customer.credit_cards.first
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa.slice(0, 6)
-      credit_card.cardholder_name.should == "New Joe Cardholder"
-
-      credit_card.billing_address.first_name.should == "Joe"
-      credit_card.billing_address.last_name.should == "Cool"
-      credit_card.billing_address.postal_code.should == "60666"
-    end
-
-    it "can pass any attribute through tr_data" do
-      original_customer = Braintree::Customer.create!(
-        :first_name => "Old First",
-        :last_name => "Old Last",
-        :company => "Old Company",
-        :email => "old@email.com",
-        :phone => "000.111.2222",
-        :fax => "000.222.3333",
-        :website => "old.website.com"
-      )
-      new_customer_id = "customer_#{rand(1_000_000)}"
-      tr_data_params = {
-        :customer_id => original_customer.id,
-        :customer => {
-          :id => new_customer_id,
-          :first_name => "New First",
-          :last_name => "New Last",
-          :company => "New Company",
-          :email => "new@email.com",
-          :phone => "888.111.2222",
-          :fax => "999.222.3333",
-          :website => "new.website.com"
-        }
-      }
-
-      tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Customer.update_customer_url)
-      result = Braintree::Customer.update_from_transparent_redirect(query_string_response)
-
-      result.success?.should == true
-      customer = result.customer
-      customer.id.should == new_customer_id
-      customer.first_name.should == "New First"
-      customer.last_name.should == "New Last"
-      customer.company.should == "New Company"
-      customer.email.should == "new@email.com"
-      customer.phone.should == "888.111.2222"
-      customer.fax.should == "999.222.3333"
-      customer.website.should == "new.website.com"
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce,
+        )
+
+        expect(result).not_to be_success
+        expect(customer.default_payment_method.token).to eq(credit_card_token)
+      end
     end
   end
+
+  it "returns prepaid_reloadable from VisaCheckoutCard" do
+    result = Braintree::Customer.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+    )
+    expect(result.success?).to eq(true)
+
+    found_customer = Braintree::Customer.find(result.customer.id)
+    expect(found_customer.visa_checkout_cards).not_to be_nil
+    visa_checkout_card = found_customer.visa_checkout_cards.first
+    expect(visa_checkout_card).to be_a Braintree::VisaCheckoutCard
+    expect(visa_checkout_card.prepaid_reloadable).not_to be_nil
+  end
 end