braintree 2.101.0 → 3.0.1

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

@@ -56,93 +56,84 @@ def nonce_for_paypal_account(paypal_account_details)
 end
 
 def generate_non_plaid_us_bank_account_nonce(account_number="1000000000")
-  definition = <<-GRAPHQL
-mutation TokenizeUsBankAccount($input: TokenizeUsBankAccountInput!) {
-  tokenizeUsBankAccount(input: $input) {
-    paymentMethod {
-      id
+  query = %{
+    mutation TokenizeUsBankAccount($input: TokenizeUsBankAccountInput!) {
+      tokenizeUsBankAccount(input: $input) {
+        paymentMethod {
+          id
+        }
+      }
     }
   }
-}
-      GRAPHQL
+
   variables = {
-    input: {
-      usBankAccount: {
-        achMandate: "cl mandate text",
-        routingNumber: "021000021",
-        accountNumber: account_number,
-        accountType: "CHECKING",
-        individualOwner: {
-          firstName: "John",
-          lastName: "Doe",
+    :input => {
+      :usBankAccount => {
+        :accountNumber => account_number,
+        :routingNumber => "021000021",
+        :accountType => "CHECKING",
+        :individualOwner => {
+          :firstName => "John",
+          :lastName => "Doe",
         },
-        billingAddress: {
-          streetAddress: "123 Ave",
-          city: "San Francisco",
-          state: "CA",
-          zipCode: "94112"
-        }
+        :billingAddress => {
+          :streetAddress => "123 Ave",
+          :state => "CA",
+          :city => "San Francisco",
+          :zipCode => "94112"
+        },
+        :achMandate => "cl mandate text"
       }
     }
   }
-  response = Braintree::GraphQLClient.new(Braintree::Configuration.instantiate).query(definition, variables)
 
-  response[:data][:tokenizeUsBankAccount][:paymentMethod][:id]
+  graphql_request = {
+    :query => query,
+    :variables => variables
+  }
+
+  json = _send_graphql_request(graphql_request)
+  json["data"]["tokenizeUsBankAccount"]["paymentMethod"]["id"]
 end
 
 def generate_valid_plaid_us_bank_account_nonce
-  raw_client_token = Braintree::ClientToken.generate
-  client_token = decode_client_token(raw_client_token)
-
-  url = client_token["graphQL"]["url"]
-  date = client_token["graphQL"]["date"]
-  token = client_token["authorizationFingerprint"]
-
-  definition = <<-GRAPHQL
-mutation TokenizeUsBankLogin($input: TokenizeUsBankLoginInput!) {
-  tokenizeUsBankLogin(input: $input) {
-    paymentMethod {
-      id
+  query = %{
+    mutation TokenizeUsBankLogin($input: TokenizeUsBankLoginInput!) {
+      tokenizeUsBankLogin(input: $input) {
+        paymentMethod {
+          id
+        }
+      }
     }
   }
-}
-      GRAPHQL
+
   variables = {
-    input: {
-      usBankLogin: {
-        achMandate: "cl mandate text",
-        publicToken: "good",
-        accountId: "plaid_account_id",
-        accountType: "CHECKING",
-        businessOwner: {
-          businessName: "PayPal, Inc."
+    :input => {
+      :usBankLogin => {
+        :publicToken => "good",
+        :accountId => "plaid_account_id",
+        :accountType => "CHECKING",
+        :businessOwner => {
+          :businessName => "PayPal, Inc.",
         },
-        billingAddress: {
-          streetAddress: "123 Ave",
-          city: "San Francisco",
-          state: "CA",
-          zipCode: "94112"
-        }
+        :billingAddress => {
+          :streetAddress => "123 Ave",
+          :state => "CA",
+          :city => "San Francisco",
+          :zipCode => "94112"
+        },
+        :achMandate => "cl mandate text"
       }
     }
   }
-  payload = {
-    query: definition,
-    variables: variables
+
+  graphql_request = {
+    :query => query,
+    :variables => variables
   }
-  uri = URI::parse(url)
-  connection = Net::HTTP.new(uri.host, uri.port)
-  connection.use_ssl = false
-  response = connection.start do |http|
-    request = Net::HTTP::Post.new(uri.path)
-    request["Content-Type"] = "application/json"
-    request["Braintree-Version"] = date
-    request["Authorization"] = "Bearer #{token}"
-    request.body = payload.to_json
-    http.request(request)
-  end
 
-  JSON.parse(response.body)[:data][:tokenizeUsBankLogin][:paymentMethod][:id]
+  json = _send_graphql_request(graphql_request)
+  json["data"]["tokenizeUsBankLogin"]["paymentMethod"]["id"]
 end
 
 def sample(arr)
@@ -156,6 +147,48 @@ def generate_invalid_us_bank_account_nonce
   nonce += "_xxx"
 end
 
+def _cosmos_post(token, url, payload)
+  uri = URI::parse(url)
+  connection = Net::HTTP.new(uri.host, uri.port)
+  if uri.scheme == "https"
+    connection.use_ssl = true
+    connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  end
+  resp = connection.start do |http|
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request["Braintree-Version"] = "2016-10-07"
+    request["Authorization"] = "Bearer #{token}"
+    request.body = payload.to_json
+    http.request(request)
+  end
+
+  JSON.parse(resp.body)
+end
+
+def _send_graphql_request(graphql_request)
+  raw_client_token = Braintree::ClientToken.generate
+  client_token = decode_client_token(raw_client_token)
+  uri = URI::parse("#{client_token["braintree_api"]["url"]}/graphql")
+  connection = Net::HTTP.new(uri.host, uri.port)
+
+  if uri.scheme == "https"
+    connection.use_ssl = true
+    connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  end
+
+  resp = connection.start do |http|
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request["Braintree-Version"] = "2016-10-07"
+    request["Authorization"] = "Bearer #{client_token["braintree_api"]["access_token"]}"
+    request.body = graphql_request.to_json
+    http.request(request)
+  end
+
+  JSON.parse(resp.body)
+end
+
 class ClientApiHttp
   attr_reader :config, :options
 

data/spec/integration/braintree/credit_card_spec.rb

@@ -15,7 +15,7 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
-        :cvv => "100"
+        :cvv => "100",
       )
       result.success?.should == true
       credit_card = result.credit_card
@@ -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"
@@ -227,6 +226,49 @@ describe Braintree::CreditCard do
       result.success?.should == true
     end
 
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :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).not_to 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 "accepts three_d_secure pass thru params in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :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}
+      )
+      result.success?.should == true
+
+    end
+
     it "returns 3DS info on cc verification" do
       customer = Braintree::Customer.create!
       result = Braintree::CreditCard.create(
@@ -730,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!
@@ -844,6 +797,62 @@ describe Braintree::CreditCard do
       updated_credit_card.cardholder_name.should == "New Holder"
     end
 
+    it "validates presence of three_d_secure_version in 3ds pass thru params" 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"
+      )
+      result = Braintree::CreditCard.update(credit_card.token,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :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).not_to 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 "accepts three_d_secure pass thru params in the request" 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"
+      )
+      result = Braintree::CreditCard.update(credit_card.token,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :cavv => 'some_cavv',
+          :three_d_secure_version=> "2.1.0",
+          :xid => 'some_xid',
+          :authentication_response => 'Y',
+          :directory_response => 'Y',
+          :cavv_algorithm => '2',
+          :ds_transaction_id => 'some_ds_transaction_id',
+        },
+        :options => {:verify_card => true}
+      )
+
+      result.success?.should == true
+
+    end
+
     context "billing address" do
       it "creates a new billing address by default" do
         customer = Braintree::Customer.create!
@@ -954,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
 
@@ -1123,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
@@ -1490,266 +1373,35 @@ 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
+  describe "nonce" do
+    it "returns the credit card nonce" 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."
+      credit_card.nonce.should_not be_nil
     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
+  describe "card on file network tokenization" do
+    it "should find a network tokenized credit card" do
+      credit_card = Braintree::CreditCard.find("network_tokenized_credit_card")
+      credit_card.is_network_tokenized?.should == true
     end
 
-    it "raises a ValidationsFailed if invalid" do
+    it "should find a non-network tokenized credit card" 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!
-      credit_card = Braintree::CreditCard.create!(
-        :cardholder_name => "Original Holder",
+      credit_card = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-
-      credit_card.nonce.should_not be_nil
+        :expiration_date => "05/2009"
+      ).credit_card
+      credit_card_vaulted = Braintree::CreditCard.find(credit_card.token)
+      credit_card_vaulted.is_network_tokenized?.should == false
     end
   end
 end