braintree 4.10.0 → 4.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d00fc1e35be1af3de05492fc2300a27ff643adec2d6c600088240c54f3ce59cf
-  data.tar.gz: 5c8d2d3aa4e16d587dd83cda3aa5d5f0cda4d17414557564a0754857f4ca706b
+  metadata.gz: bfe8849002c4dbacd2476b61311adc19f0939a2c42bb61ccf2ca797d59248054
+  data.tar.gz: 7f97e328fdd729365a0117bc8297edac4e12e8e383e8c7b10b06f74862bd8e34
 SHA512:
-  metadata.gz: b289dbe733557dd65754f36c2e8e592160619d3ea0222e3d645cbea2711752933f9b403140eb3b666531b0cb2372a58fc45f5286e37de111d2fb041d87f41d2a
-  data.tar.gz: 4cdc5ed40d74adfd3d6b6cb3ad622670200f6c60bc9a5314c457e8bfb886265284ff8d62645ffa88d82f7bec6b10816e3919959e527238640e3f932b2b57b821
+  metadata.gz: 20e3ed69efa6b094974b3461165a3197958df6e62be5f9952d676d14c7411bdae5c2169b2f0e86eab743a94475f436baf3b907ff1dab4a45e984eafa741e3356
+  data.tar.gz: b7e5bcbe3a4c57e6aa2a60016e93b0adff02b9dd51601370d94f08d56307e319b19381274e032eb8bd80fffa4ecf5a8c601c3da9e17e38526a8860d981a7d471

data/lib/braintree/credit_card_verification_gateway.rb

@@ -46,11 +46,24 @@ module Braintree
 
     def self._create_signature
       [
-         {:options => [:amount, :merchant_account_id, :account_type]},
-         {:credit_card => [
-           :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year,
-           :number, {:billing_address => AddressGateway._shared_signature}
-         ]}
+        {:credit_card => [
+          :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year,
+          :number, {:billing_address => AddressGateway._shared_signature}
+        ]},
+        :intended_transaction_source,
+        {:options => [:amount, :merchant_account_id, :account_type]},
+        :payment_method_nonce,
+        :three_d_secure_authentication_id,
+        {:three_d_secure_pass_thru => [
+            :eci_flag,
+            :cavv,
+            :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
+        ]},
       ]
     end
   end

data/lib/braintree/error_codes.rb

@@ -83,6 +83,7 @@ module Braintree
       ExpirationYearIsInvalid = "81713"
       InvalidParamsForCreditCardUpdate = "91745"
       InvalidVenmoSDKPaymentMethodCode = "91727"
+      NetworkTokenizationAttributeCryptogramIsRequired = "81762"
       NumberIsInvalid = "81715"
       NumberIsProhibited = "81750"
       NumberIsRequired = "81714"

data/lib/braintree/sepa_direct_debit_account.rb

@@ -12,12 +12,14 @@ module Braintree
     attr_reader :last_4
     attr_reader :mandate_type
     attr_reader :merchant_or_partner_customer_id
+    attr_reader :subscriptions
     attr_reader :token
     attr_reader :updated_at
     attr_reader :view_mandate_url
 
     def initialize(gateway, attributes) # :nodoc:
       @gateway = gateway
+      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
       set_instance_variables_from_hash(attributes)
     end
 

data/lib/braintree/transaction/credit_card_details.rb

@@ -67,6 +67,10 @@ module Braintree
       def venmo_sdk?
         @venmo_sdk
       end
+
+      def is_network_tokenized?
+        @is_network_tokenized
+      end
     end
   end
 end

data/lib/braintree/transaction.rb

@@ -127,8 +127,11 @@ module Braintree
     attr_reader :installments
     attr_reader :local_payment_details
     attr_reader :merchant_account_id
+    attr_reader :merchant_advice_code
+    attr_reader :merchant_advice_code_text
     attr_reader :network_response_code                  # Response code from the card network
     attr_reader :network_response_text                  # Response text from the card network
+    attr_reader :network_token_details
     attr_reader :network_transaction_id
     attr_reader :order_id
     attr_reader :partial_settlement_transaction_ids
@@ -299,6 +302,7 @@ module Braintree
       @apple_pay_details = ApplePayDetails.new(@apple_pay)
       @billing_details = AddressDetails.new(@billing)
       @credit_card_details = CreditCardDetails.new(@credit_card)
+      @network_token_details = CreditCardDetails.new(@network_token)
       @custom_fields = attributes[:custom_fields].is_a?(Hash) ? attributes[:custom_fields] : {}
       @customer_details = CustomerDetails.new(@customer)
       @descriptor = Descriptor.new(@descriptor)

data/lib/braintree/transaction_gateway.rb

@@ -195,7 +195,7 @@ module Braintree
         :sca_exemption, :currency_iso_code, :exchange_rate_quote_id,
         {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
         {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
-        {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, {:payment_reader_card_details => [:encrypted_card_data, :key_serial_number]}]},
+        {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, {:payment_reader_card_details => [:encrypted_card_data, :key_serial_number]}, {:network_tokenization_attributes => [:cryptogram, :ecommerce_indicator, :token_requestor_id]}]},
         {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
         {
           :billing => AddressGateway._shared_signature

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 4
-    Minor = 10
+    Minor = 12
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/spec/integration/braintree/credit_card_spec.rb

@@ -576,66 +576,6 @@ describe Braintree::CreditCard do
       end
     end
 
-    context "venmo_sdk" do
-      describe "venmo_sdk_payment_method_code" do
-        it "can pass a venmo sdk payment method code" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode,
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-          result.credit_card.bin.should == "400934"
-          result.credit_card.last_4.should == "1881"
-        end
-
-        it "success? returns false when given an invalid venmo sdk payment method code" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode,
-          )
-
-          result.success?.should == false
-          result.message.should == "Invalid VenmoSDK payment method code"
-          result.errors.first.code.should == "91727"
-        end
-      end
-
-      describe "venmo_sdk_session" do
-        it "venmo_sdk? returns true when given a valid session" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009",
-            :cvv => "100",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-            },
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-        end
-
-        it "venmo_sdk? returns false when given an invalid session" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009",
-            :cvv => "100",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
-            },
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-        end
-      end
-    end
-
     context "client API" do
       it "adds credit card to an existing customer using a payment method nonce" do
         nonce = nonce_for_new_payment_method(

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::CreditCardVerification, "search" do
 
@@ -11,7 +12,7 @@ describe Braintree::CreditCardVerification, "search" do
         },
         :options => {
           :amount => "10.00"
-        }
+        },
       }
 
       result = Braintree::CreditCardVerification.create(verification_params)
@@ -259,4 +260,126 @@ describe Braintree::CreditCardVerification, "search" do
       end
     end
   end
+
+  describe "intended transaction source" do
+    it "creates a new verification with intended transaction source installment" do
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "05/2029",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00"
+        },
+        :intended_transaction_source => "installment"
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      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
+  end
+
+  context "three_d_secure" do
+    it "can create a verification with a three_d_secure_authentication_id" do
+      three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+        SpecHelper::ThreeDSecureMerchantAccountId,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_month => "12",
+        :expiration_year => "2029",
+      )
+
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "12/2029",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+        },
+        :three_d_secure_authentication_id => three_d_secure_authentication_id,
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      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 "can create a verification with a payment_method_nonce" do
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+        },
+      )
+      nonce.should_not be_nil
+
+      verification_params = {
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+        },
+        :payment_method_nonce => nonce,
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      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 "can create a verification with a verification_three_d_secure_pass_thru" do
+      verification_params = {
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/12",
+        },
+        :options => {
+          :amount => "10.00",
+        },
+        :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_id",
+        },
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      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
+  end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -566,37 +566,6 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:custom_fields)[0].message.should == "Custom field is invalid: spouse_name."
     end
 
-    describe "venmo_sdk" do
-      it "can create a customer with a venmo sdk payment method code" do
-        result = Braintree::Customer.create(
-          :first_name => "Steve",
-          :last_name => "Hamlin",
-          :credit_card => {
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode
-          },
-        )
-        result.success?.should == true
-        result.customer.credit_cards.first.bin.should == "400934"
-        result.customer.credit_cards.first.last_4.should == "1881"
-      end
-
-      it "can create a customer with a venmo sdk session" do
-        result = Braintree::Customer.create(
-          :first_name => "Steve",
-          :last_name => "Hamlin",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::MasterCard,
-            :expiration_date => "05/2010",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-            }
-          },
-        )
-        result.success?.should == true
-        result.customer.credit_cards.first.venmo_sdk?.should == false
-      end
-    end
-
     context "client API" do
       it "can create a customer with a payment method nonce" do
         nonce = nonce_for_new_payment_method(
@@ -1097,7 +1066,7 @@ describe Braintree::Customer do
       venmo_account.username.should_not be_nil
     end
 
-    it "returns associated us bank accounts" do
+    xit "returns associated us bank accounts" do
       result = Braintree::Customer.create(
         :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
         :credit_card => {

data/spec/integration/braintree/dispute_search_spec.rb

@@ -78,20 +78,6 @@ describe Braintree::Dispute, "search" do
       dispute = collection.disputes.first
     end
 
-    it "correctly returns chargeback protected disputes" do
-      collection = Braintree::Dispute.search do |search|
-        search.case_number.is "CASE-CHARGEBACK-PROTECTED"
-      end
-
-      expect(collection.disputes.count).to eq(1)
-      dispute = collection.disputes.first
-
-      # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
-      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
-      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
-      expect(dispute.reason).to eq(Braintree::Dispute::Reason::Fraud)
-    end
-
     it "correctly returns disputes by chargeback protection level flag" do
       collection = Braintree::Dispute.search do |search|
         search.chargeback_protection_level.in [
@@ -104,7 +90,6 @@ describe Braintree::Dispute, "search" do
       collection.disputes.each do |dispute|
         expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
         expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
-        expect(dispute.reason).to eq(Braintree::Dispute::Reason::Fraud)
       end
     end
 

data/spec/integration/braintree/dispute_spec.rb

@@ -151,6 +151,33 @@ describe Braintree::Dispute do
       result.evidence.sent_to_processor_at.should == nil
       result.evidence.sequence_number.should == 7
     end
+
+    it "creates text evidence for the dispute with CARRIER_NAME shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "UPS", category: "CARRIER_NAME", sequence_number: 0})
+
+      result.success?.should == true
+      result.evidence.category.should == "CARRIER_NAME"
+      result.evidence.comment.should == "UPS"
+      result.evidence.sequence_number.should == 0
+    end
+
+    it "creates text evidence for the dispute with TRACKING_NUMBER shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "3", category: "TRACKING_NUMBER", sequence_number: 0})
+
+      result.success?.should == true
+      result.evidence.category.should == "TRACKING_NUMBER"
+      result.evidence.comment.should == "3"
+      result.evidence.sequence_number.should == 0
+    end
+
+    it "creates text evidence for the dispute with TRACKING_URL shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "https://example.com/tracking-number/abc12345", category: "TRACKING_URL", sequence_number: 1})
+
+      result.success?.should == true
+      result.evidence.category.should == "TRACKING_URL"
+      result.evidence.comment.should == "https://example.com/tracking-number/abc12345"
+      result.evidence.sequence_number.should == 1
+    end
   end
 
   describe "self.finalize" do

data/spec/integration/braintree/http_spec.rb

@@ -97,7 +97,7 @@ describe Braintree::Http do
     end
 
     describe "ssl_version" do
-      it "causes failed requests to sandbox with incompatible SSL version" do
+      xit "causes failed requests to sandbox with incompatible SSL version" do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :sandbox

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -50,6 +50,26 @@ describe Braintree::SepaDirectDebitAccount do
         }.to raise_error(Braintree::NotFoundError)
       end
     end
+
+    context "subscriptions" do
+      it "returns subscriptions associated with a SEPA direct debit account" do
+        customer = Braintree::Customer.create!
+
+        subscription1 = Braintree::Subscription.create(
+          :payment_method_token => token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+        ).subscription
+
+        subscription2 = Braintree::Subscription.create(
+          :payment_method_token => token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+        ).subscription
+
+        sepa_debit_account = Braintree::SepaDirectDebitAccount.find(token)
+        subscription_ids = sepa_debit_account.subscriptions.map { |h| h[:id] }.sort
+        expect(subscription_ids).to eq([subscription1.id, subscription2.id].sort)
+      end
+    end
   end
 
   describe "self.delete" do

data/spec/integration/braintree/transaction_spec.rb

@@ -1002,10 +1002,12 @@ describe Braintree::Transaction do
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::TokenIssuance
       end
 
-      it "exposes the excessive_retry gateway rejection reason" do
+      xit "exposes the excessive_retry gateway rejection reason" do
         with_duplicate_checking_merchant do
           result = nil
-          16.times do
+          counter = 0
+          excessive_retry = false
+          until excessive_retry || counter == 20
             result = Braintree::Transaction.sale(
               :amount => Braintree::Test::TransactionAmounts::Decline,
               :credit_card => {
@@ -1014,9 +1016,10 @@ describe Braintree::Transaction do
                 :expiration_year => "2011"
               },
               )
+            excessive_retry = result.transaction.status == "gateway_rejected"
+            counter +=1
           end
-          result.success?.should == false
-          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry
+          expect(result.transaction.gateway_rejection_reason). to eq(Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry)
         end
       end
     end
@@ -1504,6 +1507,32 @@ describe Braintree::Transaction do
         result.transaction.recurring.should == true
       end
 
+      it "successfully creates a transaction with installment_first" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :transaction_source => "installment_first",
+        )
+        result.success?.should == true
+      end
+
+      it "successfully creates a transaction with installment" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :transaction_source => "installment",
+        )
+        result.success?.should == true
+      end
+
       it "marks a transactions as merchant" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -1728,35 +1757,6 @@ describe Braintree::Transaction do
       end
     end
 
-    describe "venmo_sdk" do
-      it "can create a card with a venmo sdk payment method code" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode,
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.bin.should == "400934"
-        result.transaction.credit_card_details.last_4.should == "1881"
-      end
-
-      it "can create a transaction with venmo sdk session" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-    end
-
     context "client API" do
       it "can create a transaction with a shared card nonce" do
         nonce = nonce_for_new_payment_method(
@@ -5226,6 +5226,49 @@ describe Braintree::Transaction do
       end
     end
 
+
+    context "3rd party Card on File Network Token" do
+      it "Works with all params" do
+        params = {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+            :network_tokenization_attributes => {
+              :cryptogram => "/wAAAAAAAcb8AlGUF/1JQEkAAAA=",
+              :ecommerce_indicator => "05",
+              :token_requestor_id => "45310020105"
+            },
+          }
+        }
+        result = Braintree::Transaction.sale(params)
+        expect(result.success?).to eq true
+        expect(result.transaction.status).to eq Braintree::Transaction::Status::Authorized
+        expect(result.transaction.processed_with_network_token?).to eq true
+
+        network_token_details = result.transaction.network_token_details
+        expect(network_token_details.is_network_tokenized?).to eq true
+      end
+
+      it "returns errors if validations on cryptogram fails" do
+        params = {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+            :network_tokenization_attributes => {
+              :ecommerce_indicator => "05",
+              :token_requestor_id => "45310020105"
+            },
+          }
+        }
+        result = Braintree::Transaction.sale(params)
+
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:transaction).for(:credit_card).map { |e| e.code }.sort).to eq [Braintree::ErrorCodes::CreditCard::NetworkTokenizationAttributeCryptogramIsRequired]
+      end
+    end
+
     xit "Amex Pay with Points" do
       context "transaction creation" do
         it "succeeds when submit_for_settlement is true" do
@@ -6668,61 +6711,6 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
-  context "venmo sdk" do
-    describe "venmo_sdk_payment_method_code" do
-      it "can create a transaction with venmo_sdk_payment_method_code" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa),
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-
-      it "errors when an invalid payment method code is passed" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode,
-        )
-        result.success?.should == false
-        result.message.should include("Invalid VenmoSDK payment method code")
-        result.errors.map(&:code).should include("91727")
-      end
-    end
-
-    describe "venmo_sdk_session" do
-      it "can create a transaction and vault a card when a venmo_sdk_session is present" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-
-      it "venmo_sdk boolean is false when an invalid session is passed" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-    end
-  end
-
   context "paypal" do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(
@@ -7273,4 +7261,19 @@ describe Braintree::Transaction do
       end
     end
   end
+
+  context "Merchant Advice Code" do
+    it "exposes MAC and MAC text" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => DateTime.now.strftime("%m/%Y")
+        },
+      )
+      expect(result.transaction.merchant_advice_code).to eq("01")
+      expect(result.transaction.merchant_advice_code_text).to eq("New account information available")
+    end
+  end
 end

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::CreditCardVerificationGateway do
+  describe "Credit Card Verification Gateway" do
+    let(:gateway) do
+      config = Braintree::Configuration.new(
+        :merchant_id => "merchant_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
+      )
+      Braintree::Gateway.new(config)
+    end
+
+    it "creates a credit card verification gateway" do
+      result = Braintree::CreditCardVerificationGateway.new(gateway)
+
+      result.inspect.should include("merchant_id")
+      result.inspect.should include("public_key")
+      result.inspect.should include("private_key")
+    end
+
+    it "creates a credit card verification gateway signature" do
+      result = Braintree::CreditCardVerificationGateway._create_signature
+      result.inspect.should include("credit_card")
+      result.inspect.should include("credit_card")
+      result.inspect.should include("cardholder_name")
+      result.inspect.should include("cvv")
+      result.inspect.should include("expiration_date")
+      result.inspect.should include("expiration_month")
+      result.inspect.should include("expiration_year")
+      result.inspect.should include("number")
+      result.inspect.should include("billing_address")
+      result.inspect.should include("intended_transaction_source")
+      result.inspect.should include("options")
+      result.inspect.should include("amount")
+      result.inspect.should include("merchant_account_id")
+      result.inspect.should include("account_type")
+      result.inspect.should include("payment_method_nonce")
+      result.inspect.should include("three_d_secure_authentication_id")
+      result.inspect.should include("three_d_secure_pass_thru")
+      result.inspect.should include("eci_flag")
+      result.inspect.should include("cavv")
+      result.inspect.should include("xid")
+      result.inspect.should include("three_d_secure_version")
+      result.inspect.should include("authentication_response")
+      result.inspect.should include("directory_response")
+      result.inspect.should include("cavv_algorithm")
+      result.inspect.should include("ds_transaction_id")
+    end
+  end
+end

data/spec/unit/braintree/sepa_debit_account_spec.rb

@@ -15,18 +15,19 @@ describe Braintree::SepaDirectDebitAccount do
     let(:params) do
       {
         bank_reference_token: "a-reference-token",
-        mandate_type: "ONE_OFF",
-        last_4: "4321",
-        merchant_or_partner_customer_id: "a-mp-customer-id",
-        customer_id: "a-customer-id",
+        created_at: Time.now,
         customer_global_id: "a-customer-global-id",
+        customer_id: "a-customer-id",
         default: true,
-        token: "a-token",
         global_id: "a-global-id",
         image_url: "a-image-url",
-        view_mandate_url: "a-view-mandate-url",
-        created_at: Time.now,
+        last_4: "4321",
+        mandate_type: "ONE_OFF",
+        merchant_or_partner_customer_id: "a-mp-customer-id",
+        subscriptions: [{price: "10.00"}],
+        token: "a-token",
         updated_at: Time.now,
+        view_mandate_url: "a-view-mandate-url",
       }
     end
 

data/spec/unit/braintree/transaction/credit_card_details_spec.rb

@@ -46,4 +46,20 @@ describe Braintree::Transaction::CreditCardDetails do
       details.masked_number.should == "510510******5100"
     end
   end
+
+  describe "is_network_tokenized" do
+    it "returns true if is_network_tokenized is true" do
+      details = Braintree::Transaction::CreditCardDetails.new(
+        :is_network_tokenized => true,
+      )
+      details.is_network_tokenized?.should == true
+    end
+
+    it "returns false if is_network_tokenized is false" do
+      details = Braintree::Transaction::CreditCardDetails.new(
+        :is_network_tokenized => false,
+      )
+      details.is_network_tokenized?.should == false
+    end
+  end
 end

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::TransactionGateway do
+  describe "Transaction Gateway" do
+    let(:gateway) do
+      config = Braintree::Configuration.new(
+        :merchant_id => "merchant_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
+      )
+      Braintree::Gateway.new(config)
+    end
+
+    it "creates a transactionGateway gateway" do
+      result = Braintree::TransactionGateway.new(gateway)
+
+      result.inspect.should include("merchant_id")
+      result.inspect.should include("public_key")
+      result.inspect.should include("private_key")
+    end
+
+    describe "self.create" do
+      it "raises an exception if attributes contain an invalid key" do
+        expect do
+          transaction = Braintree::TransactionGateway.new(gateway)
+          transaction.create(:invalid_key => "val")
+        end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+      end
+    end
+
+    it "creates a transaction gateway signature" do
+      expect(Braintree::TransactionGateway._create_signature).to match([
+        :amount, :billing_address_id, :channel, :customer_id, :device_data, :discount_amount,
+        :merchant_account_id, :order_id, :payment_method_nonce, :payment_method_token,
+        :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
+        :shared_customer_id, :shared_payment_method_nonce, :shared_payment_method_token,
+        :shared_shipping_address_id, :shipping_address_id, :shipping_amount,
+        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,
+        :three_d_secure_token, :transaction_source, :type, :venmo_sdk_payment_method_code,
+        :sca_exemption, :currency_iso_code, :exchange_rate_quote_id,
+        {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
+        {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
+        {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, {:payment_reader_card_details => [:encrypted_card_data, :key_serial_number]}, {:network_tokenization_attributes => [:cryptogram, :ecommerce_indicator, :token_requestor_id]}]},
+        {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
+        {
+          :billing => Braintree::AddressGateway._shared_signature
+        },
+        {
+          :shipping => Braintree::AddressGateway._shared_signature + [:shipping_method],
+        },
+        {
+          :three_d_secure_pass_thru => [
+            :eci_flag,
+            :cavv,
+            :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
+          ]
+        },
+        {:options => [
+          :hold_in_escrow,
+          :store_in_vault,
+          :store_in_vault_on_success,
+          :submit_for_settlement,
+          :add_billing_address_to_payment_method,
+          :store_shipping_address_in_vault,
+          :venmo_sdk_session,
+          :payee_id,
+          :payee_email,
+          :skip_advanced_fraud_checking,
+          :skip_avs,
+          :skip_cvv,
+          {:paypal => [:custom_field, :payee_id, :payee_email, :description, {:supplementary_data => :_any_key_}]},
+          {:three_d_secure => [:required]},
+          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]},
+          {:venmo => [:profile_id]},
+          {:credit_card => [:account_type]},
+        ]
+        },
+        {:external_vault => [
+          :status,
+          :previous_network_transaction_id,
+        ]},
+        {:custom_fields => :_any_key_},
+        {:descriptor => [:name, :phone, :url]},
+        {:paypal_account => [:email, :token, :paypal_data, :payee_id, :payee_email, :payer_id, :payment_id]},
+        {:industry => [
+          :industry_type,
+          {:data => [
+            :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
+            :passenger_first_name, :passenger_last_name, :passenger_middle_initial, :passenger_title, :issued_date, :travel_agency_name, :travel_agency_code, :ticket_number,
+            :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket, :no_show, :advanced_deposit, :fire_safe, :property_phone,
+            {:legs => [
+              :conjunction_ticket, :exchange_ticket, :coupon_number, :service_class, :carrier_code, :fare_basis_code, :flight_number, :departure_date, :departure_airport_code, :departure_time,
+              :arrival_airport_code, :arrival_time, :stopover_permitted, :fare_amount, :fee_amount, :tax_amount, :endorsement_or_restrictions,
+            ]},
+            {:additional_charges => [
+              :kind, :amount,
+            ]},
+          ]},
+        ]},
+        {:apple_pay_card => [:number, :cardholder_name, :cryptogram, :expiration_month, :expiration_year, :eci_indicator]},
+        {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]},
+        {:installments => [:count]},
+      ])
+    end
+  end
+end

data/spec/unit/braintree/transaction_spec.rb

@@ -147,6 +147,48 @@ describe Braintree::Transaction do
       transaction.credit_card_details.issuing_bank.should == "Mr Tumnus"
     end
 
+    it "sets up network token attributes in network_token_details" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_token => {
+          :token => "mzg2",
+          :bin => "411111",
+          :last_4 => "1111",
+          :card_type => "Visa",
+          :expiration_month => "08",
+          :expiration_year => "2009",
+          :customer_location => "US",
+          :prepaid => "Yes",
+          :healthcare => "Yes",
+          :durbin_regulated => "Yes",
+          :debit => "Yes",
+          :commercial => "No",
+          :payroll => "Unknown",
+          :product_id => "Unknown",
+          :country_of_issuance => "Narnia",
+          :issuing_bank => "Mr Tumnus",
+          :is_network_tokenized => true
+        },
+      )
+      transaction.network_token_details.token.should == "mzg2"
+      transaction.network_token_details.bin.should == "411111"
+      transaction.network_token_details.last_4.should == "1111"
+      transaction.network_token_details.card_type.should == "Visa"
+      transaction.network_token_details.expiration_month.should == "08"
+      transaction.network_token_details.expiration_year.should == "2009"
+      transaction.network_token_details.customer_location.should == "US"
+      transaction.network_token_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+      transaction.network_token_details.healthcare.should == Braintree::CreditCard::Healthcare::Yes
+      transaction.network_token_details.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
+      transaction.network_token_details.debit.should == Braintree::CreditCard::Debit::Yes
+      transaction.network_token_details.commercial.should == Braintree::CreditCard::Commercial::No
+      transaction.network_token_details.payroll.should == Braintree::CreditCard::Payroll::Unknown
+      transaction.network_token_details.product_id.should == Braintree::CreditCard::ProductId::Unknown
+      transaction.network_token_details.country_of_issuance.should == "Narnia"
+      transaction.network_token_details.issuing_bank.should == "Mr Tumnus"
+      transaction.network_token_details.is_network_tokenized?.should == true
+    end
+
     it "sets up three_d_secure_info" do
       transaction = Braintree::Transaction._new(
         :gateway,
@@ -256,6 +298,16 @@ describe Braintree::Transaction do
       expect(transaction.network_response_text).to eq("Successful approval/completion or V.I.P. PIN verification is successful")
     end
 
+    it "accepts merchant_advice_code and merchant_advice_text" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :merchant_advice_code => "01",
+        :merchant_advice_code_text => "New account information available",
+      )
+      expect(transaction.merchant_advice_code).to eq("01")
+      expect(transaction.merchant_advice_code_text).to eq("New account information available")
+    end
+
     it "accepts sepa_direct_debit_return_code" do
       transaction = Braintree::Transaction._new(
         :gateway,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 4.10.0
+  version: 4.12.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-11 00:00:00.000000000 Z
+date: 2023-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -277,6 +277,7 @@ files:
 - spec/unit/braintree/configuration_spec.rb
 - spec/unit/braintree/credentials_parser_spec.rb
 - spec/unit/braintree/credit_card_spec.rb
+- spec/unit/braintree/credit_card_verification_gateway_spec.rb
 - spec/unit/braintree/credit_card_verification_search_spec.rb
 - spec/unit/braintree/credit_card_verification_spec.rb
 - spec/unit/braintree/customer_spec.rb
@@ -322,6 +323,7 @@ files:
 - spec/unit/braintree/transaction/installment_spec.rb
 - spec/unit/braintree/transaction/paypal_details_spec.rb
 - spec/unit/braintree/transaction/sepa_direct_debit_account_details_spec.rb
+- spec/unit/braintree/transaction_gateway_spec.rb
 - spec/unit/braintree/transaction_search_spec.rb
 - spec/unit/braintree/transaction_spec.rb
 - spec/unit/braintree/unknown_payment_method_spec.rb
@@ -362,7 +364,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.13
 signing_key: 
 specification_version: 4
 summary: Braintree Ruby Server SDK