braintree 2.32.1 → 2.33.0

data/lib/braintree.rb

@@ -42,6 +42,7 @@ require "braintree/digest"
 require "braintree/discount"
 require "braintree/discount_gateway"
 require "braintree/dispute"
+require "braintree/dispute/transaction_details"
 require "braintree/error_codes"
 require "braintree/error_result"
 require "braintree/errors"

data/lib/braintree/descriptor.rb

@@ -2,7 +2,7 @@ module Braintree
   class Descriptor # :nodoc:
     include BaseModule
 
-    attr_reader :name, :phone
+    attr_reader :name, :phone, :url
 
     def initialize(attributes)
       set_instance_variables_from_hash attributes unless attributes.nil?

data/lib/braintree/dispute.rb

@@ -8,6 +8,8 @@ module Braintree
     attr_reader :status
     attr_reader :reason
     attr_reader :currency_iso_code
+    attr_reader :id
+    attr_reader :transaction_details
 
     module Status
       Open = "open"
@@ -40,6 +42,7 @@ module Braintree
       @received_date = Date.parse(received_date)
       @reply_by_date = Date.parse(reply_by_date) unless reply_by_date.nil?
       @amount = Util.to_big_decimal(amount)
+      @transaction_details = TransactionDetails.new(@transaction)
     end
   end
 end

data/lib/braintree/dispute/transaction_details.rb

@@ -0,0 +1,14 @@
+module Braintree
+  class Dispute
+    class TransactionDetails # :nodoc:
+      include BaseModule
+
+      attr_reader :amount, :id
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @amount = Util.to_big_decimal(amount)
+      end
+    end
+  end
+end

data/lib/braintree/error_codes.rb

@@ -107,6 +107,7 @@ module Braintree
       DynamicDescriptorsDisabled = "92203"
       InternationalNameFormatIsInvalid = "92204"
       InternationalPhoneFormatIsInvalid = "92205"
+      UrlFormatIsInvalid = "92206"
     end
 
     module PayPalAccount

data/lib/braintree/payment_method.rb

@@ -10,6 +10,10 @@ module Braintree
       Configuration.gateway.payment_method.find(token)
     end
 
+    def self.update(token, attributes)
+      Configuration.gateway.payment_method.update(token, attributes)
+    end
+
     def self.delete(token)
       Configuration.gateway.payment_method.delete(token)
     end

data/lib/braintree/payment_method_gateway.rb

@@ -45,14 +45,54 @@ module Braintree
       raise NotFoundError, "payment method with token #{token.inspect} not found"
     end
 
+    def update(token, attributes)
+      Util.verify_keys(PaymentMethodGateway._update_signature, attributes)
+      _do_update(:put, "/payment_methods/any/#{token}", :payment_method => attributes)
+    end
+
+    def _do_update(http_verb, url, params) # :nodoc:
+      response = @config.http.send http_verb, url, params
+      if response[:credit_card]
+        SuccessfulResult.new(:payment_method => CreditCard._new(@gateway, response[:credit_card]))
+      elsif response[:paypal_account]
+        SuccessfulResult.new(:payment_method => PayPalAccount._new(@gateway, response[:paypal_account]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :payment_method or :api_error_response"
+      end
+    end
+
     def self._create_signature # :nodoc:
-      options = [:make_default]
-      [
-        :customer_id,
-        :payment_method_nonce,
-        :token,
-        {:options => options}
+      _signature(:create)
+    end
+
+    def self._update_signature # :nodoc:
+      _signature(:update)
+    end
+
+    def self._signature(type) # :nodoc:
+      billing_address_params = AddressGateway._shared_signature
+      options = [:make_default, :verification_merchant_account_id, :verify_card, :venmo_sdk_session]
+      signature = [
+        :billing_address_id, :cardholder_name, :cvv, :device_session_id, :expiration_date,
+        :expiration_month, :expiration_year, :number, :token, :venmo_sdk_payment_method_code,
+        :device_data, :fraud_merchant_id, :payment_method_nonce,
+        {:options => options},
+        {:billing_address => billing_address_params}
       ]
+
+      case type
+      when :create
+        options << :fail_on_duplicate_payment_method
+        signature << :customer_id
+      when :update
+        billing_address_params << {:options => [:update_existing]}
+      else
+        raise ArgumentError
+      end
+
+      return signature
     end
   end
 end

data/lib/braintree/paypal_account.rb

@@ -2,11 +2,12 @@ module Braintree
   class PayPalAccount
     include BaseModule
 
-    attr_reader :email, :token, :image_url, :created_at, :updated_at
+    attr_reader :email, :token, :image_url, :created_at, :updated_at, :subscriptions
 
     def initialize(gateway, attributes) # :nodoc:
       @gateway = gateway
       set_instance_variables_from_hash(attributes)
+      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
     end
 
     class << self

data/lib/braintree/subscription_gateway.rb

@@ -67,7 +67,7 @@ module Braintree
         :trial_duration_unit,
         :trial_period,
         {:options => [:do_not_inherit_add_ons_or_discounts, :start_immediately]},
-        {:descriptor => [:name, :phone]}
+        {:descriptor => [:name, :phone, :url]}
       ] + _add_on_discount_signature
     end
 
@@ -86,7 +86,7 @@ module Braintree
           :replace_all_add_ons_and_discounts,
           :revert_subscription_on_proration_failure
         ]},
-        {:descriptor => [:name, :phone]}
+        {:descriptor => [:name, :phone, :url]}
       ] + _add_on_discount_signature
     end
 

data/lib/braintree/transaction_gateway.rb

@@ -129,7 +129,7 @@ module Braintree
         },
         {:options => [:hold_in_escrow, :store_in_vault, :store_in_vault_on_success, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault, :venmo_sdk_session]},
         {:custom_fields => :_any_key_},
-        {:descriptor => [:name, :phone]},
+        {:descriptor => [:name, :phone, :url]},
         {:paypal_account => [:email, :token, :paypal_data]},
         {:industry => [:industry_type, {:data => [:folio_number, :check_in_date, :check_out_date]}]}
       ]

data/lib/braintree/version.rb

@@ -1,8 +1,8 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 32
-    Tiny = 1
+    Minor = 33
+    Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"
   end

data/lib/braintree/webhook_notification.rb

@@ -7,6 +7,11 @@ module Braintree
     module Kind
       Disbursement = "disbursement"
       DisbursementException = "disbursement_exception"
+
+      DisputeOpened = "dispute_opened"
+      DisputeLost = "dispute_lost"
+      DisputeWon = "dispute_won"
+
       SubscriptionCanceled = "subscription_canceled"
       SubscriptionChargedSuccessfully = "subscription_charged_successfully"
       SubscriptionChargedUnsuccessfully = "subscription_charged_unsuccessfully"
@@ -23,7 +28,7 @@ module Braintree
       PartnerMerchantDeclined = "partner_merchant_declined"
     end
 
-    attr_reader :subscription, :kind, :timestamp, :transaction, :partner_merchant, :disbursement
+    attr_reader :subscription, :kind, :timestamp, :transaction, :partner_merchant, :disbursement, :dispute
 
     def self.parse(signature, payload)
       Configuration.gateway.webhook_notification.parse(signature, payload)
@@ -42,6 +47,7 @@ module Braintree
       @subscription = Subscription._new(gateway, @subject[:subscription]) if @subject.has_key?(:subscription)
       @transaction = Transaction._new(gateway, @subject[:transaction]) if @subject.has_key?(:transaction)
       @disbursement = Disbursement._new(gateway, @subject[:disbursement]) if @subject.has_key?(:disbursement)
+      @dispute = Dispute._new(@subject[:dispute]) if @subject.has_key?(:dispute)
     end
 
     def merchant_account

data/lib/braintree/webhook_testing_gateway.rb

@@ -26,6 +26,12 @@ module Braintree
 
     def _subject_sample_xml(kind, id)
       case kind
+      when Braintree::WebhookNotification::Kind::DisputeOpened
+        _dispute_opened_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::DisputeLost
+        _dispute_lost_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::DisputeWon
+        _dispute_won_sample_xml(id)
       when Braintree::WebhookNotification::Kind::PartnerMerchantConnected
         _partner_merchant_connected_sample_xml(id)
       when Braintree::WebhookNotification::Kind::PartnerMerchantDisconnected
@@ -149,6 +155,63 @@ module Braintree
       XML
     end
 
+    def _dispute_opened_sample_xml(id)
+
+      <<-XML
+        <dispute>
+          <amount>250.00</amount>
+          <currency-iso-code>USD</currency-iso-code>
+          <received-date type="date">2014-03-01</received-date>
+          <reply-by-date type="date">2014-03-21</reply-by-date>
+          <status>open</status>
+          <reason>fraud</reason>
+          <id>#{id}</id>
+          <transaction>
+            <id>#{id}</id>
+            <amount>250.00</amount>
+          </transaction>
+        </dispute>
+      XML
+    end
+
+    def _dispute_lost_sample_xml(id)
+
+      <<-XML
+        <dispute>
+          <amount>250.00</amount>
+          <currency-iso-code>USD</currency-iso-code>
+          <received-date type="date">2014-03-01</received-date>
+          <reply-by-date type="date">2014-03-21</reply-by-date>
+          <status>lost</status>
+          <reason>fraud</reason>
+          <id>#{id}</id>
+          <transaction>
+            <id>#{id}</id>
+            <amount>250.00</amount>
+          </transaction>
+        </dispute>
+      XML
+    end
+
+    def _dispute_won_sample_xml(id)
+
+      <<-XML
+        <dispute>
+          <amount>250.00</amount>
+          <currency-iso-code>USD</currency-iso-code>
+          <received-date type="date">2014-03-01</received-date>
+          <reply-by-date type="date">2014-03-21</reply-by-date>
+          <status>won</status>
+          <reason>fraud</reason>
+          <id>#{id}</id>
+          <transaction>
+            <id>#{id}</id>
+            <amount>250.00</amount>
+          </transaction>
+        </dispute>
+      XML
+    end
+
     def _disbursement_exception_sample_xml(id)
 
       <<-XML

data/spec/httpsd.pid

@@ -0,0 +1 @@
+2708

data/spec/integration/braintree/client_api/client_token_spec.rb

@@ -38,7 +38,7 @@ describe Braintree::ClientToken do
         config = Braintree::Configuration.instantiate
         client_token_string = Braintree::ClientToken.generate
         client_token = decode_client_token(client_token_string)
-        client_token["version"].should == "2"
+        client_token["version"].should == 2
       end
     end
 

data/spec/integration/braintree/payment_method_spec.rb

@@ -116,6 +116,220 @@ describe Braintree::PaymentMethod do
       payment_method.token.should ==  second_token
     end
 
+    it "respects verify_card and verification_merchant_account_id when included outside of the nonce" do
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => "4000111111111115",
+          :expiration_month => "11",
+          :expiration_year => "2099",
+        }
+      )
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verify_card => true,
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
+        }
+      )
+
+      result.should_not be_success
+      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      result.credit_card_verification.processor_response_code.should == "2000"
+      result.credit_card_verification.processor_response_text.should == "Do Not Honor"
+      result.credit_card_verification.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+    end
+
+    it "respects fail_on_duplicate_payment_method when included outside of the nonce" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2012"
+      )
+      result.should be_success
+
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        }
+      )
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :fail_on_duplicate_payment_method => true
+        }
+      )
+
+      result.should_not be_success
+      result.errors.first.code.should == "81724"
+    end
+
+    it "allows passing the billing address outside of the nonce" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => "4111111111111111",
+        :expirationMonth => "12",
+        :expirationYear => "2020",
+        :options => {:validate => false}
+      )
+      response.code.should == "202"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :billing_address => {
+          :street_address => "123 Abc Way"
+        }
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+      found_credit_card.billing_address.street_address.should == "123 Abc Way"
+    end
+
+    it "allows passing a billing address id outside of the nonce" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => "4111111111111111",
+        :expirationMonth => "12",
+        :expirationYear => "2020",
+        :options => {:validate => false}
+      )
+      response.code.should == "202"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+
+      address = Braintree::Address.create!(:customer_id => customer.id, :first_name => "Bobby", :last_name => "Tables")
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :billing_address_id => address.id
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+      found_credit_card.billing_address.first_name.should == "Bobby"
+      found_credit_card.billing_address.last_name.should == "Tables"
+    end
+
+    it "overrides the billing address in the nonce" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => "4111111111111111",
+        :expirationMonth => "12",
+        :expirationYear => "2020",
+        :options => {:validate => false},
+        :billing_address => {
+          :street_address => "456 Xyz Way"
+        }
+      )
+      response.code.should == "202"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :billing_address => {
+          :street_address => "123 Abc Way"
+        }
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+      found_credit_card.billing_address.street_address.should == "123 Abc Way"
+    end
+
+    it "does not override the billing address for a vaulted credit card" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => 4111111111111111,
+        :expirationMonth => 12,
+        :expirationYear => 2020,
+        :billing_address => {
+          :street_address => "456 Xyz Way"
+        }
+      )
+      response.code.should == "201"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :billing_address => {
+          :street_address => "123 Abc Way"
+        }
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+      found_credit_card.billing_address.street_address.should == "456 Xyz Way"
+    end
+
     context "paypal" do
       it "creates a payment method from an unvalidated future paypal account nonce" do
         nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
@@ -146,6 +360,44 @@ describe Braintree::PaymentMethod do
         result.errors.first.code.should == "82902"
       end
 
+      it "ignores passed billing address params" do
+        nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :billing_address => {
+            :street_address => "123 Abc Way"
+          }
+        )
+
+        result.should be_success
+        result.payment_method.should be_a(Braintree::PayPalAccount)
+        result.payment_method.image_url.should_not be_nil
+        token = result.payment_method.token
+
+        found_paypal_account = Braintree::PayPalAccount.find(token)
+        found_paypal_account.should_not be_nil
+      end
+
+      it "ignores passed billing address id" do
+        nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :billing_address_id => "address_id"
+        )
+
+        result.should be_success
+        result.payment_method.should be_a(Braintree::PayPalAccount)
+        result.payment_method.image_url.should_not be_nil
+        token = result.payment_method.token
+
+        found_paypal_account = Braintree::PayPalAccount.find(token)
+        found_paypal_account.should_not be_nil
+      end
+
       it "returns appropriate validation errors" do
         customer = Braintree::Customer.create.customer
         nonce = nonce_for_paypal_account(:token => "PAYPAL_TOKEN")
@@ -159,6 +411,27 @@ describe Braintree::PaymentMethod do
         errors.should include("82901")
         errors.should include("82902")
       end
+
+      it "doesn't return an error if credit card options are present for a paypal nonce" do
+        customer = Braintree::Customer.create!
+        original_token = "paypal-account-#{Time.now.to_i}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "consent-code",
+          :token => original_token
+        )
+
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :fail_on_duplicate_payment_method => true,
+            :verification_merchant_account_id => "not_a_real_merchant_account_id"
+          }
+        )
+
+        result.should be_success
+      end
     end
 
     context "SEPA" do
@@ -312,4 +585,317 @@ describe Braintree::PaymentMethod do
       end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{token}\" not found")
     end
   end
+
+  describe "self.update" do
+    context "credit cards" do
+      it "updates the credit card" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        )
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013"
+        )
+        update_result.success?.should == true
+        update_result.payment_method.should == credit_card
+        updated_credit_card = update_result.payment_method
+        updated_credit_card.cardholder_name.should == "New Holder"
+        updated_credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+        updated_credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+        updated_credit_card.expiration_date.should == "06/2013"
+      end
+
+      context "billing address" do
+        it "creates a new billing address by default" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+            :billing_address => {
+              :street_address => "123 Nigeria Ave"
+            }
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+            :billing_address => {
+              :region => "IL"
+            }
+          )
+          update_result.success?.should == true
+          updated_credit_card = update_result.payment_method
+          updated_credit_card.billing_address.region.should == "IL"
+          updated_credit_card.billing_address.street_address.should == nil
+          updated_credit_card.billing_address.id.should_not == credit_card.billing_address.id
+        end
+
+        it "updates the billing address if option is specified" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+            :billing_address => {
+              :street_address => "123 Nigeria Ave"
+            }
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+            :billing_address => {
+              :region => "IL",
+              :options => {:update_existing => true}
+            }
+          )
+          update_result.success?.should == true
+          updated_credit_card = update_result.payment_method
+          updated_credit_card.billing_address.region.should == "IL"
+          updated_credit_card.billing_address.street_address.should == "123 Nigeria Ave"
+          updated_credit_card.billing_address.id.should == credit_card.billing_address.id
+        end
+
+        it "updates the country via codes" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+            :billing_address => {
+              :street_address => "123 Nigeria Ave"
+            }
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+            :billing_address => {
+              :country_name => "American Samoa",
+              :country_code_alpha2 => "AS",
+              :country_code_alpha3 => "ASM",
+              :country_code_numeric => "016",
+              :options => {:update_existing => true}
+            }
+          )
+          update_result.success?.should == true
+          updated_credit_card = update_result.payment_method
+          updated_credit_card.billing_address.country_name.should == "American Samoa"
+          updated_credit_card.billing_address.country_code_alpha2.should == "AS"
+          updated_credit_card.billing_address.country_code_alpha3.should == "ASM"
+          updated_credit_card.billing_address.country_code_numeric.should == "016"
+        end
+      end
+
+      it "can pass expiration_month and expiration_year" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        )
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_month => "07",
+          :expiration_year => "2011"
+        )
+        update_result.success?.should == true
+        update_result.payment_method.should == credit_card
+        update_result.payment_method.expiration_month.should == "07"
+        update_result.payment_method.expiration_year.should == "2011"
+        update_result.payment_method.expiration_date.should == "07/2011"
+      end
+
+      it "verifies the update if options[verify_card]=true" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        )
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::MasterCard,
+          :expiration_date => "06/2013",
+          :options => {:verify_card => true}
+        )
+        update_result.success?.should == false
+        update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+        update_result.credit_card_verification.gateway_rejection_reason.should be_nil
+      end
+
+      it "can update the billing address" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :first_name => "Old First Name",
+            :last_name => "Old Last Name",
+            :company => "Old Company",
+            :street_address => "123 Old St",
+            :extended_address => "Apt Old",
+            :locality => "Old City",
+            :region => "Old State",
+            :postal_code => "12345",
+            :country_name => "Canada"
+          }
+        )
+        result = Braintree::PaymentMethod.update(credit_card.token,
+          :options => {:verify_card => false},
+          :billing_address => {
+            :first_name => "New First Name",
+            :last_name => "New Last Name",
+            :company => "New Company",
+            :street_address => "123 New St",
+            :extended_address => "Apt New",
+            :locality => "New City",
+            :region => "New State",
+            :postal_code => "56789",
+            :country_name => "United States of America"
+          }
+        )
+        result.success?.should == true
+        address = result.payment_method.billing_address
+        address.first_name.should == "New First Name"
+        address.last_name.should == "New Last Name"
+        address.company.should == "New Company"
+        address.street_address.should == "123 New St"
+        address.extended_address.should == "Apt New"
+        address.locality.should == "New City"
+        address.region.should == "New State"
+        address.postal_code.should == "56789"
+        address.country_name.should == "United States of America"
+      end
+
+      it "returns an error response if invalid" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        )
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :number => "invalid",
+          :expiration_date => "05/2014"
+        )
+        update_result.success?.should == false
+        update_result.errors.for(:credit_card).on(:number)[0].message.should == "Credit card number must be 12-19 digits."
+      end
+
+      it "can update the default" do
+        customer = Braintree::Customer.create!
+        card1 = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        ).credit_card
+        card2 = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        ).credit_card
+
+        card1.should be_default
+        card2.should_not be_default
+
+        Braintree::PaymentMethod.update(card2.token, :options => {:make_default => true})
+
+        Braintree::CreditCard.find(card1.token).should_not be_default
+        Braintree::CreditCard.find(card2.token).should be_default
+      end
+    end
+
+    context "paypal accounts" do
+      it "updates a paypal account's token" do
+        customer = Braintree::Customer.create!
+        original_token = "paypal-account-#{Time.now.to_i}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "consent-code",
+          :token => original_token
+        )
+        original_result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        )
+
+        updated_token = "UPDATED_TOKEN-" + rand(36**3).to_s(36)
+        updated_result = Braintree::PaymentMethod.update(
+          original_token,
+          :token => updated_token
+        )
+
+        updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
+        updated_paypal_account.email.should == original_result.payment_method.email
+
+        expect do
+          Braintree::PayPalAccount.find(original_token)
+        end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{original_token}\" not found")
+      end
+
+      it "can make a paypal account the default payment method" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009",
+          :options => {:make_default => true}
+        )
+        result.should be_success
+
+        nonce = nonce_for_paypal_account(:consent_code => "consent-code")
+        original_token = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        ).payment_method.token
+
+        updated_result = Braintree::PaymentMethod.update(
+          original_token,
+          :options => {:make_default => true}
+        )
+
+        updated_paypal_account = Braintree::PayPalAccount.find(original_token)
+        updated_paypal_account.should be_default
+      end
+
+      it "returns an error if a token for account is used to attempt an update" do
+        customer = Braintree::Customer.create!
+        first_token = "paypal-account-#{rand(36**3).to_s(36)}"
+        second_token = "paypal-account-#{rand(36**3).to_s(36)}"
+
+        first_nonce = nonce_for_paypal_account(
+          :consent_code => "consent-code",
+          :token => first_token
+        )
+        first_result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => first_nonce,
+          :customer_id => customer.id
+        )
+
+        second_nonce = nonce_for_paypal_account(
+          :consent_code => "consent-code",
+          :token => second_token
+        )
+        second_result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => second_nonce,
+          :customer_id => customer.id
+        )
+
+        updated_result = Braintree::PaymentMethod.update(
+          first_token,
+          :token => second_token
+        )
+
+        updated_result.should_not be_success
+        updated_result.errors.first.code.should == "92906"
+      end
+    end
+  end
 end