braintree 2.104.1 → 3.0.1

data/lib/braintree/transaction_search.rb

@@ -28,7 +28,6 @@ module Braintree
       :paypal_authorization_id,
       :paypal_payer_email,
       :processor_authorization_code,
-      :europe_bank_account_iban,
       :settlement_batch_id,
       :shipping_company,
       :shipping_country_name,

data/lib/braintree/util.rb

@@ -53,6 +53,8 @@ module Braintree
         raise AuthorizationError, message
       when 404
         raise NotFoundError
+      when 408
+        raise RequestTimeoutError
       when 426
         raise UpgradeRequiredError, "Please upgrade your client library."
       when 429
@@ -60,7 +62,9 @@ module Braintree
       when 500
         raise ServerError
       when 503
-        raise DownForMaintenanceError
+        raise ServiceUnavailableError
+      when 504
+        raise GatewayTimeoutError
       else
         raise UnexpectedError, "Unexpected HTTP_RESPONSE #{status_code.to_i}"
       end
@@ -87,7 +91,7 @@ module Braintree
           when "INTERNAL"
             raise ServerError
           when "SERVICE_AVAILABILITY"
-            raise DownForMaintenanceError
+            raise ServiceUnavailableError
           else
             raise UnexpectedError, "Unexpected Response: #{error[:message]}"
           end
@@ -126,6 +130,17 @@ module Braintree
       !invalid_keys.any?
     end
 
+    def self.replace_key(hash, target_key, replacement_key)
+      hash.inject({}) do |new_hash, (key, value)|
+        if value.is_a?(Hash)
+          value = replace_key(value, target_key, replacement_key)
+        end
+
+        key = replacement_key if key == target_key
+        new_hash.merge(key => value)
+      end
+    end
+
     def self._flatten_valid_keys(valid_keys, namespace = nil)
       valid_keys.inject([]) do |result, key|
         if key.is_a?(Hash)

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
-    Major = 2
-    Minor = 104
+    Major = 3
+    Minor = 0
     Tiny = 1
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/lib/braintree/webhook_notification.rb

@@ -36,18 +36,10 @@ module Braintree
 
       AccountUpdaterDailyReport = "account_updater_daily_report"
 
-      # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
-      # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.
-      IdealPaymentComplete = "ideal_payment_complete"
-      IdealPaymentFailed = "ideal_payment_failed"
-
       OAuthAccessRevoked = "oauth_access_revoked"
       ConnectedMerchantStatusTransitioned = "connected_merchant_status_transitioned"
       ConnectedMerchantPayPalStatusChanged = "connected_merchant_paypal_status_changed"
 
-      # NEXT_MAJOR_VERSION remove GrantedPaymentInstrumentUpdate. Kind is not sent by Braintree Gateway.
-      # Kind will either be GrantorUpdatedGrantedPaymentMethod or RecipientUpdatedGrantedPaymentMethod.
-      GrantedPaymentInstrumentUpdate = "granted_payment_instrument_update"
       GrantorUpdatedGrantedPaymentMethod = "grantor_updated_granted_payment_method"
       RecipientUpdatedGrantedPaymentMethod = "recipient_updated_granted_payment_method"
       GrantedPaymentInstrumentRevoked = "granted_payment_instrument_revoked"
@@ -63,7 +55,6 @@ module Braintree
     attr_reader :dispute
     attr_reader :granted_payment_instrument_update
     attr_reader :revoked_payment_method_metadata
-    attr_reader :ideal_payment
     attr_reader :kind
     attr_reader :local_payment_completed
     attr_reader :oauth_access_revocation
@@ -93,7 +84,6 @@ module Braintree
       @disbursement = Disbursement._new(gateway, @subject[:disbursement]) if @subject.has_key?(:disbursement)
       @dispute = Dispute._new(@subject[:dispute]) if @subject.has_key?(:dispute)
       @account_updater_daily_report = AccountUpdaterDailyReport._new(@subject[:account_updater_daily_report]) if @subject.has_key?(:account_updater_daily_report)
-      @ideal_payment = Braintree::IdealPayment._new(gateway, @subject[:ideal_payment]) if @subject.has_key?(:ideal_payment)
       @connected_merchant_status_transitioned = ConnectedMerchantStatusTransitioned._new(@subject[:connected_merchant_status_transitioned]) if @subject.has_key?(:connected_merchant_status_transitioned)
       @connected_merchant_paypal_status_changed = ConnectedMerchantPayPalStatusChanged._new(@subject[:connected_merchant_paypal_status_changed]) if @subject.has_key?(:connected_merchant_paypal_status_changed)
       @granted_payment_instrument_update = GrantedPaymentInstrumentUpdate._new(@subject[:granted_payment_instrument_update]) if @subject.has_key?(:granted_payment_instrument_update)

data/lib/braintree/webhook_testing_gateway.rb

@@ -78,17 +78,6 @@ module Braintree
         _auth_status_transitioned_sample_xml(id)
       when Braintree::WebhookNotification::Kind::ConnectedMerchantPayPalStatusChanged
         _auth_paypal_status_changed_sample_xml(id)
-        # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
-        # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.
-      when Braintree::WebhookNotification::Kind::IdealPaymentComplete
-        _ideal_payment_complete_sample_xml(id)
-        # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
-        # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.
-      when Braintree::WebhookNotification::Kind::IdealPaymentFailed
-        _ideal_payment_failed_sample_xml(id)
-      # NEXT_MAJOR_VERSION remove GrantedPaymentInstrumentUpdate
-      when Braintree::WebhookNotification::Kind::GrantedPaymentInstrumentUpdate
-        _granted_payment_instrument_update_sample_xml(id)
       when Braintree::WebhookNotification::Kind::GrantorUpdatedGrantedPaymentMethod
         _granted_payment_instrument_update_sample_xml(id)
       when Braintree::WebhookNotification::Kind::RecipientUpdatedGrantedPaymentMethod
@@ -867,38 +856,6 @@ module Braintree
       XML
     end
 
-    def _ideal_payment_complete_sample_xml(id)
-      <<-XML
-        <ideal-payment>
-          <id>#{id}</id>
-          <status>COMPLETE</status>
-          <issuer>ABCISSUER</issuer>
-          <order-id>ORDERABC</order-id>
-          <currency>EUR</currency>
-          <amount>10.00</amount>
-          <created-at>2016-11-29T23:27:34.547Z</created-at>
-          <approval-url>https://example.com</approval-url>
-          <ideal-transaction-id>1234567890</ideal-transaction-id>
-        </ideal-payment>
-      XML
-    end
-
-    def _ideal_payment_failed_sample_xml(id)
-      <<-XML
-        <ideal-payment>
-          <id>#{id}</id>
-          <status>FAILED</status>
-          <issuer>ABCISSUER</issuer>
-          <order-id>ORDERABC</order-id>
-          <currency>EUR</currency>
-          <amount>10.00</amount>
-          <created-at>2016-11-29T23:27:34.547Z</created-at>
-          <approval-url>https://example.com</approval-url>
-          <ideal-transaction-id>1234567890</ideal-transaction-id>
-        </ideal-payment>
-      XML
-    end
-
     def _granted_payment_instrument_update_sample_xml(id)
       <<-XML
         <granted-payment-instrument-update>

data/lib/braintree/xml/libxml.rb

@@ -1,3 +1,4 @@
+require 'libxml'
 # Portions of this code were copied and modified from Ruby on Rails, released
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree

data/lib/braintree/xml/parser.rb

@@ -11,23 +11,14 @@ module Braintree
         "boolean"  => Proc.new { |boolean| %w(1 true).include?(boolean.strip) },
       }
 
-      def self.hash_from_xml(xml, parser = _determine_parser)
-        standardized_hash_structure = parser.parse(xml)
-        with_underscores_in_keys = _unrename_keys(standardized_hash_structure)
-        typecasted_xml = _typecast_xml_value(with_underscores_in_keys)
-        Util.symbolize_keys(typecasted_xml)
+      def self.hash_from_xml(xml)
+        standardized_hash_structure = ::Braintree::Xml::Libxml.parse(xml)
+        transformed_xml = _transform_xml(standardized_hash_structure)
+        Util.symbolize_keys(transformed_xml)
       end
 
-      def self._determine_parser
-        # LibXML causes a segfault in Ruby 2.0.0. We need to fall back to Rexml to prevent this segfault.
-        if !RUBY_VERSION.start_with?("2.0") && defined?(::LibXML::XML) && ::LibXML::XML.respond_to?(:default_keep_blanks=)
-          ::Braintree::Xml::Libxml
-        else
-          ::Braintree::Xml::Rexml
-        end
-      end
-
-      def self._typecast_xml_value(value)
+      # Transform into standard Ruby types and convert all keys to snake_case instead of dash-case
+      def self._transform_xml(value)
         case value.class.to_s
           when 'Hash'
             if value['type'] == 'array'
@@ -37,9 +28,9 @@ module Braintree
               else
                 case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
                 when "Array"
-                  entries.collect { |v| _typecast_xml_value(v) }
+                  entries.collect { |v| _transform_xml(v) }
                 when "Hash"
-                  [_typecast_xml_value(entries)]
+                  [_transform_xml(entries)]
                 else
                   raise "can't typecast #{entries.inspect}"
                 end
@@ -65,13 +56,13 @@ module Braintree
               nil
             else
               xml_value = value.inject({}) do |h,(k,v)|
-                h[k] = _typecast_xml_value(v)
+                h[k.to_s.tr("-", "_")] = _transform_xml(v) # convert dashes to underscores in keys
                 h
               end
               xml_value
             end
           when 'Array'
-            value.map! { |i| _typecast_xml_value(i) }
+            value.map! { |i| _transform_xml(i) }
             case value.length
               when 0 then nil
               when 1 then value.first
@@ -80,21 +71,7 @@ module Braintree
           when 'String'
             value
           else
-            raise "can't typecast #{value.class.name} - #{value.inspect}"
-        end
-      end
-
-      def self._unrename_keys(params)
-        case params.class.to_s
-          when "Hash"
-            params.inject({}) do |h,(k,v)|
-              h[k.to_s.tr("-", "_")] = _unrename_keys(v)
-              h
-            end
-          when "Array"
-            params.map { |v| _unrename_keys(v) }
-          else
-            params
+            raise "can't transform #{value.class.name} - #{value.inspect}"
         end
       end
     end

data/spec/integration/braintree/address_spec.rb

@@ -347,98 +347,11 @@ describe Braintree::Address do
     it "deletes the address" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      address.delete.success?.should == true
+      result = Braintree::Address.delete(customer.id, address.id)
+      result.success?.should == true
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
     end
   end
-
-  describe "update" do
-    it "returns a success response and updates the address if valid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :street_address => "1812 E Old St",
-        :extended_address => "Suite Old 201",
-        :locality => "Old Chicago",
-        :region => "IL",
-        :postal_code => "60620",
-        :country_name => "United States of America"
-      )
-      result = address.update(
-        :street_address => "123 E New St",
-        :extended_address => "New Suite 3",
-        :locality => "Chicago",
-        :region => "Illinois",
-        :postal_code => "60621",
-        :country_name => "United States of America"
-      )
-      result.success?.should == true
-      result.address.should == address
-      address.street_address.should == "123 E New St"
-      address.extended_address.should == "New Suite 3"
-      address.locality.should == "Chicago"
-      address.region.should == "Illinois"
-      address.postal_code.should == "60621"
-      address.country_name.should == "United States of America"
-    end
-
-    it "returns an error response if invalid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :country_name => "United States of America"
-      )
-      result = address.update(
-        :street_address => "123 E New St",
-        :country_name => "United States of Invalid"
-      )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
-    end
-  end
-
-  describe "update!" do
-    it "returns true and updates the address if valid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :street_address => "1812 E Old St",
-        :extended_address => "Suite Old 201",
-        :locality => "Old Chicago",
-        :region => "IL",
-        :postal_code => "60620",
-        :country_name => "United States of America"
-      )
-      address.update!(
-        :street_address => "123 E New St",
-        :extended_address => "New Suite 3",
-        :locality => "Chicago",
-        :region => "Illinois",
-        :postal_code => "60621",
-        :country_name => "United States of America"
-      ).should == address
-      address.street_address.should == "123 E New St"
-      address.extended_address.should == "New Suite 3"
-      address.locality.should == "Chicago"
-      address.region.should == "Illinois"
-      address.postal_code.should == "60621"
-      address.country_name.should == "United States of America"
-    end
-
-    it "raises a ValidationsFailed invalid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :country_name => "United States of America"
-      )
-      expect do
-        address.update!(
-          :street_address => "123 E New St",
-          :country_name => "United States of Invalid"
-        )
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
 end

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

@@ -136,32 +136,6 @@ def generate_valid_plaid_us_bank_account_nonce
   json["data"]["tokenizeUsBankLogin"]["paymentMethod"]["id"]
 end
 
-def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
-  raw_client_token = Braintree::ClientToken.generate(:merchant_account_id => "ideal_merchant_account")
-  client_token = decode_client_token(raw_client_token)
-  client = ClientApiHttp.new(
-    Braintree::Configuration.instantiate,
-    :authorization_fingerprint => client_token["authorizationFingerprint"],
-  )
-  config = JSON.parse(client.get_configuration.body)
-
-  braintree_api = client_token["braintree_api"]
-  url = braintree_api["url"] + "/ideal-payments"
-
-  token = braintree_api["access_token"]
-  payload = {
-    :issuer => "RABONL2U",
-    :order_id => SpecHelper::DefaultOrderId,
-    :amount => amount,
-    :currency => "EUR",
-    :redirect_url => "https://braintree-api.com",
-    :route_id => config["ideal"]["routeId"]
-  }
-
-  json = _cosmos_post(token, url, payload)
-  json["data"]["id"]
-end
-
 def sample(arr)
   6.times.map { arr[rand(arr.length)] }.join
 end

data/spec/integration/braintree/credit_card_spec.rb

@@ -35,8 +35,7 @@ describe Braintree::CreditCard do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :device_session_id => "abc123",
-        :fraud_merchant_id => "7"
+        :device_data => "device_data",
       )
       result.success?.should == true
     end
@@ -110,7 +109,7 @@ describe Braintree::CreditCard do
         :options => {:verify_card => true}
       )
       result.success?.should == false
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::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.cvv_response_code.should == "I"
@@ -128,7 +127,7 @@ describe Braintree::CreditCard do
         :options => {:verify_card => true, :verification_amount => "100.00"}
       )
       result.success?.should == false
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::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.cvv_response_code.should == "I"
@@ -175,7 +174,7 @@ describe Braintree::CreditCard do
           :options => {:verify_card => true}
         )
         result.success?.should == false
-        result.credit_card_verification.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::CVV
+        result.credit_card_verification.gateway_rejection_reason.should == Braintree::CreditCardVerification::GatewayRejectionReason::CVV
       ensure
         Braintree::Configuration.merchant_id = old_merchant
         Braintree::Configuration.public_key = old_public_key
@@ -192,7 +191,7 @@ describe Braintree::CreditCard do
         :options => {:verify_card => true, :verification_amount => "1.01"}
       )
       result.success?.should == false
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::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.cvv_response_code.should == "I"
@@ -773,95 +772,6 @@ describe Braintree::CreditCard do
     end
   end
 
-  describe "self.create_from_transparent_redirect" do
-    it "returns a successful result if successful" do
-      result = Braintree::Customer.create
-      result.success?.should == true
-      customer = result.customer
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      credit_card = result.credit_card
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      credit_card.cardholder_name.should == "Card Holder"
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      credit_card.expiration_month.should == "05"
-      credit_card.expiration_year.should == "2012"
-      credit_card.expiration_date.should == "05/2012"
-      credit_card.customer_id.should == customer.id
-    end
-
-    it "create card as default" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
-      )
-      card1 = customer.credit_cards[0]
-
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012",
-          :options => {:make_default => true}
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      card2 = result.credit_card
-
-      Braintree::CreditCard.find(card1.token).should_not be_default
-      card2.should be_default
-    end
-
-    it "returns xml with nested errors if validation errors" do
-      customer = Braintree::Customer.create.customer
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => "eleventy",
-          :expiration_date => "y2k"
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == false
-      result.params[:customer_id] == customer.id
-      result.params[:credit_card]["cardholder_name"] == customer.id
-      result.params[:credit_card]["number"] == "eleventy"
-      result.params[:credit_card]["exipiration_date"] == "y2k"
-    end
-  end
-
   describe "self.update" do
     it "updates the credit card" do
       customer = Braintree::Customer.create!
@@ -1053,7 +963,7 @@ describe Braintree::CreditCard do
         :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.status.should == Braintree::CreditCardVerification::Status::ProcessorDeclined
       update_result.credit_card_verification.gateway_rejection_reason.should be_nil
     end
 
@@ -1222,132 +1132,6 @@ describe Braintree::CreditCard do
     end
   end
 
-  describe "self.update_from_transparent_redirect" do
-    it "updates the credit card" do
-      old_token = "token_#{rand(10**10)}"
-      new_token = "token_#{rand(10**10)}"
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012",
-          :token => old_token
-        }
-      )
-      credit_card = customer.credit_cards[0]
-      params = {
-        :credit_card => {
-          :cardholder_name => "New Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "05/2014"
-        }
-      }
-      tr_data_params = {
-        :payment_method_token => old_token,
-        :credit_card => {
-          :token => new_token
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.update_credit_card_url)
-      result = Braintree::CreditCard.update_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      credit_card = result.credit_card
-      credit_card.cardholder_name.should == "New Cardholder Name"
-      credit_card.masked_number.should == "555555******4444"
-      credit_card.expiration_date.should == "05/2014"
-      credit_card.token.should == new_token
-    end
-
-    it "updates the default credit card" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
-      )
-      card1 = customer.credit_cards[0]
-
-      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
-
-      params = {
-        :credit_card => {
-          :options => {:make_default => true}
-        }
-      }
-      tr_data_params = {
-        :payment_method_token => card2.token
-      }
-      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.update_credit_card_url)
-      result = Braintree::CreditCard.update_from_transparent_redirect(query_string_response)
-
-      Braintree::CreditCard.find(card1.token).should_not be_default
-      Braintree::CreditCard.find(card2.token).should be_default
-    end
-  end
-
-  describe "credit" do
-    it "creates a credit 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.credit_cards[0].credit(
-        :amount => "100.00"
-      )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("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"
-    end
-  end
-
-  describe "credit!" do
-    it "returns the created credit tranaction if valid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      transaction = customer.credit_cards[0].credit!(:amount => "100.00")
-      transaction.amount.should == BigDecimal("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
-
-    it "raises a ValidationsFailed if invalid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      expect do
-        customer.credit_cards[0].credit!(:amount => "invalid")
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.delete" do
     it "deletes the credit card" do
       customer = Braintree::Customer.create.customer
@@ -1589,255 +1373,6 @@ describe Braintree::CreditCard do
     end
   end
 
-  describe "sale" do
-    it "creates a sale transaction using the credit card, returning a result object" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      result = customer.credit_cards[0].sale(
-        :amount => "100.00"
-      )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("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.credit_cards[0].sale!(:amount => "100.00")
-      transaction.amount.should == BigDecimal("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
-
-    it "raises a ValidationsFailed if invalid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      expect do
-        customer.credit_cards[0].sale!(:amount => "invalid")
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  describe "update" 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 = credit_card.update(
-        :cardholder_name => "New Holder",
-        :cvv => "456",
-        :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
-      )
-      update_result.success?.should == true
-      update_result.credit_card.should == credit_card
-      updated_credit_card = update_result.credit_card
-      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"
-      updated_credit_card.cardholder_name.should == "New Holder"
-    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 = credit_card.update(
-        :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
-    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::CreditCard.create(
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2015",
-        :options => {:fail_on_duplicate_payment_method => true}
-      )
-
-      result.success?.should == false
-      result.errors.for(:credit_card).on(:number)[0].message.should == "Duplicate card exists in the vault."
-    end
-
-    it "allows user to specify merchant account for verification" 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 = credit_card.update(
-        :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
-        :expiration_date => "05/2009",
-        :options => {
-          :verify_card => true,
-          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
-        }
-      )
-      update_result.success?.should == false
-      update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      update_result.credit_card_verification.processor_response_code.should == "2000"
-      update_result.credit_card_verification.processor_response_text.should == "Do Not Honor"
-      update_result.credit_card_verification.cvv_response_code.should == "I"
-      update_result.credit_card_verification.avs_error_response_code.should == nil
-      update_result.credit_card_verification.avs_postal_code_response_code.should == "I"
-      update_result.credit_card_verification.avs_street_address_response_code.should == "I"
-    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 = credit_card.update(
-        :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.credit_card.billing_address
-      address.should == credit_card.billing_address # making sure credit card instance was updated
-      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 = credit_card.update(
-        :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
-  end
-
-  describe "update!" do
-    it "updates the credit card and returns true if valid" 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"
-      )
-      credit_card.update!(
-        :cardholder_name => "New Holder",
-        :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
-      ).should == credit_card
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-      credit_card.expiration_date.should == "06/2013"
-      credit_card.cardholder_name.should == "New Holder"
-      credit_card.updated_at.between?(Time.now - 60, Time.now).should == true
-    end
-
-    it "raises a ValidationsFailed 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"
-      )
-      expect do
-        credit_card.update!(
-          :cardholder_name => "New Holder",
-          :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "invalid/date"
-        )
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "nonce" do
     it "returns the credit card nonce" do
       customer = Braintree::Customer.create!