braintree 2.99.0 → 2.104.0

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

@@ -56,59 +56,84 @@ def nonce_for_paypal_account(paypal_account_details)
 end
 
 def generate_non_plaid_us_bank_account_nonce(account_number="1000000000")
-  raw_client_token = Braintree::ClientToken.generate
-  client_token = decode_client_token(raw_client_token)
+  query = %{
+    mutation TokenizeUsBankAccount($input: TokenizeUsBankAccountInput!) {
+      tokenizeUsBankAccount(input: $input) {
+        paymentMethod {
+          id
+        }
+      }
+    }
+  }
 
-  url = client_token["braintree_api"]["url"] + "/tokens"
-  token = client_token["braintree_api"]["access_token"]
-  payload = {
-    :type => "us_bank_account",
-    :billing_address => {
-      :street_address => "123 Ave",
-      :region => "CA",
-      :locality => "San Francisco",
-      :postal_code => "94112"
-    },
-    :account_type => "checking",
-    :routing_number => "021000021",
-    :account_number => account_number,
-    :first_name => "John",
-    :last_name => "Doe",
-    :ownership_type => "personal",
-    :ach_mandate => {
-      :text => "cl mandate text"
+  variables = {
+    :input => {
+      :usBankAccount => {
+        :accountNumber => account_number,
+        :routingNumber => "021000021",
+        :accountType => "CHECKING",
+        :individualOwner => {
+          :firstName => "John",
+          :lastName => "Doe",
+        },
+        :billingAddress => {
+          :streetAddress => "123 Ave",
+          :state => "CA",
+          :city => "San Francisco",
+          :zipCode => "94112"
+        },
+        :achMandate => "cl mandate text"
+      }
     }
   }
 
-  json = _cosmos_post(token, url, payload)
-  json["data"]["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)
+  query = %{
+    mutation TokenizeUsBankLogin($input: TokenizeUsBankLoginInput!) {
+      tokenizeUsBankLogin(input: $input) {
+        paymentMethod {
+          id
+        }
+      }
+    }
+  }
 
-  url = client_token["braintree_api"]["url"] + "/tokens"
-  token = client_token["braintree_api"]["access_token"]
-  payload = {
-    :type => "plaid_public_token",
-    :public_token => "good",
-    :account_id => "plaid_account_id",
-    :ownership_type => "business",
-    :business_name => "PayPal, Inc.",
-    :billing_address => {
-      :street_address => "123 Ave",
-      :region => "CA",
-      :locality => "San Francisco",
-      :postal_code => "94112"
-    },
-    :ach_mandate => {
-      :text => "cl mandate text"
+  variables = {
+    :input => {
+      :usBankLogin => {
+        :publicToken => "good",
+        :accountId => "plaid_account_id",
+        :accountType => "CHECKING",
+        :businessOwner => {
+          :businessName => "PayPal, Inc.",
+        },
+        :billingAddress => {
+          :streetAddress => "123 Ave",
+          :state => "CA",
+          :city => "San Francisco",
+          :zipCode => "94112"
+        },
+        :achMandate => "cl mandate text"
+      }
     }
   }
 
-  json = _cosmos_post(token, url, payload)
-  json["data"]["id"]
+  graphql_request = {
+    :query => query,
+    :variables => variables
+  }
+
+  json = _send_graphql_request(graphql_request)
+  json["data"]["tokenizeUsBankLogin"]["paymentMethod"]["id"]
 end
 
 def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
@@ -120,8 +145,10 @@ def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmou
   )
   config = JSON.parse(client.get_configuration.body)
 
-  token = client_token["braintree_api"]["access_token"]
-  url = client_token["braintree_api"]["url"] + "/ideal-payments"
+  braintree_api = client_token["braintree_api"]
+  url = braintree_api["url"] + "/ideal-payments"
+
+  token = braintree_api["access_token"]
   payload = {
     :issuer => "RABONL2U",
     :order_id => SpecHelper::DefaultOrderId,
@@ -149,8 +176,10 @@ end
 def _cosmos_post(token, url, payload)
   uri = URI::parse(url)
   connection = Net::HTTP.new(uri.host, uri.port)
-  connection.use_ssl = true
-  connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  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"
@@ -163,6 +192,29 @@ def _cosmos_post(token, url, payload)
   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
@@ -227,6 +227,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(
@@ -246,6 +289,7 @@ describe Braintree::CreditCard do
       three_d_secure_info.eci_flag.should == "05"
       three_d_secure_info.three_d_secure_version.should == "1.0.2"
       three_d_secure_info.ds_transaction_id.should == nil
+      three_d_secure_info.three_d_secure_authentication_id.should_not be_nil
     end
 
     it "adds credit card with billing address to customer" do
@@ -336,6 +380,21 @@ describe Braintree::CreditCard do
       Braintree::CreditCard.find(card1.token).should_not be_default
     end
 
+    it "can set the network transaction identifier when creating a credit card" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :network_transaction_id => "MCC123456789",
+        },
+      )
+
+      expect(result.success?).to eq(true)
+    end
+
     context "card type indicators" do
       it "sets the prepaid field if the card is prepaid" do
         customer = Braintree::Customer.create!
@@ -828,6 +887,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!
@@ -1259,7 +1374,7 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "01/2015"
+          :expiration_date => "01/#{Time.now.year - 3}"
         )
       end
 
@@ -1736,4 +1851,22 @@ describe Braintree::CreditCard do
       credit_card.nonce.should_not be_nil
     end
   end
+
+  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 "should find a non-network tokenized credit card" do
+      customer = Braintree::Customer.create!
+      credit_card = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :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

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -22,6 +22,7 @@ describe Braintree::CreditCardVerification, "search" do
       result.credit_card_verification.processor_response_code.should == "1000"
       result.credit_card_verification.processor_response_text.should == "Approved"
       result.credit_card_verification.processor_response_type.should == Braintree::ProcessorResponseTypes::Approved
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
     end
 
     it "creates a new verification with network response code/text" do
@@ -161,6 +162,7 @@ describe Braintree::CreditCardVerification, "search" do
       found_verification = Braintree::CreditCardVerification.find(credit_card_verification.id)
 
       found_verification.should == credit_card_verification
+      found_verification.graphql_id.should_not be_nil
     end
 
     it "raises a NotFoundError exception if verification cannot be found" do

data/spec/integration/braintree/customer_spec.rb

@@ -889,6 +889,7 @@ describe Braintree::Customer do
 
       customer = Braintree::Customer.find(result.customer.id)
       customer.id.should == result.customer.id
+      customer.graphql_id.should_not be_nil
       customer.first_name.should == "Joe"
       customer.last_name.should == "Cool"
     end
@@ -1015,6 +1016,7 @@ describe Braintree::Customer do
       android_pay_card.should be_a Braintree::AndroidPayCard
       android_pay_card.token.should_not be_nil
       android_pay_card.expiration_year.should_not be_nil
+      android_pay_card.is_network_tokenized?.should == false
     end
 
     it "returns associated android pay network tokens" do
@@ -1030,6 +1032,7 @@ describe Braintree::Customer do
       android_pay_card.should be_a Braintree::AndroidPayCard
       android_pay_card.token.should_not be_nil
       android_pay_card.expiration_year.should_not be_nil
+      android_pay_card.is_network_tokenized?.should == true
     end
 
     it "returns associated amex express checkout cards" do
@@ -1112,6 +1115,74 @@ describe Braintree::Customer do
   end
 
   describe "self.update" do
+      it "updates the credit card with three_d_secure pass thru params" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+          :last_name => "Cool"
+        )
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "Mr. Joe",
+          :last_name => "Super Cool",
+          :custom_fields => {
+            :store_me => "a value"
+          },
+          :credit_card => {
+            :number => 4111111111111111,
+            :expiration_date => "05/2060",
+            :three_d_secure_pass_thru => {
+              :eci_flag => '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
+        result.customer.id.should == customer.id
+        result.customer.first_name.should == "Mr. Joe"
+        result.customer.last_name.should == "Super Cool"
+        result.customer.custom_fields[:store_me].should == "a value"
+      end
+
+      it "validates the presence of three_d_secure_version while passing three_d_secure_pass_thru in update" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe",
+          :last_name => "Cool"
+        )
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "Mr. Joe",
+          :last_name => "Super Cool",
+          :custom_fields => {
+            :store_me => "a value"
+          },
+          :credit_card => {
+            :number => 4111111111111111,
+            :expiration_date => "05/2060",
+            :three_d_secure_pass_thru => {
+              :eci_flag => '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).to_not be_success
+        error = result.errors.for(:verification).first
+        expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsRequired)
+        expect(error.message).to eq("ThreeDSecureVersion is required.")
+      end
+
     it "updates the customer with the given id if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
@@ -1309,6 +1380,51 @@ describe Braintree::Customer do
       result.success?.should == true
     end
 
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+        :credit_card => {
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => 'xx',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true}
+        }
+      )
+
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+      expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+        :credit_card => {
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => '2.2.1',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true}
+        }
+      )
+
+      expect(result).to be_success
+    end
+
     it "returns 3DS info on cc verification" do
       result = Braintree::Customer.create(
         :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,