braintree 2.101.0 → 2.102.0

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

@@ -56,93 +56,83 @@ 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
-    }
-  }
-}
-      GRAPHQL
-  variables = {
-    input: {
-      usBankAccount: {
-        achMandate: "cl mandate text",
-        routingNumber: "021000021",
-        accountNumber: account_number,
-        accountType: "CHECKING",
-        individualOwner: {
-          firstName: "John",
-          lastName: "Doe",
-        },
-        billingAddress: {
-          streetAddress: "123 Ave",
-          city: "San Francisco",
-          state: "CA",
-          zipCode: "94112"
-        }
-      }
+  raw_client_token = Braintree::ClientToken.generate
+  client_token = decode_client_token(raw_client_token)
+
+  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"
     }
   }
-  response = Braintree::GraphQLClient.new(Braintree::Configuration.instantiate).query(definition, variables)
 
-  response[:data][:tokenizeUsBankAccount][:paymentMethod][:id]
+  json = _cosmos_post(token, url, payload)
+  json["data"]["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
-    }
-  }
-}
-      GRAPHQL
-  variables = {
-    input: {
-      usBankLogin: {
-        achMandate: "cl mandate text",
-        publicToken: "good",
-        accountId: "plaid_account_id",
-        accountType: "CHECKING",
-        businessOwner: {
-          businessName: "PayPal, Inc."
-        },
-        billingAddress: {
-          streetAddress: "123 Ave",
-          city: "San Francisco",
-          state: "CA",
-          zipCode: "94112"
-        }
-      }
+  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"
     }
   }
+
+  json = _cosmos_post(token, url, payload)
+  json["data"]["id"]
+end
+
+def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
+  raw_client_token = Braintree::ClientToken.generate(:merchant_account_id => "ideal_merchant_account")
+  client_token = decode_client_token(raw_client_token)
+  client = ClientApiHttp.new(
+    Braintree::Configuration.instantiate,
+    :authorization_fingerprint => client_token["authorizationFingerprint"],
+  )
+  config = JSON.parse(client.get_configuration.body)
+
+  token = client_token["braintree_api"]["access_token"]
+  url = client_token["braintree_api"]["url"] + "/ideal-payments"
   payload = {
-    query: definition,
-    variables: variables
+    :issuer => "RABONL2U",
+    :order_id => SpecHelper::DefaultOrderId,
+    :amount => amount,
+    :currency => "EUR",
+    :redirect_url => "https://braintree-api.com",
+    :route_id => config["ideal"]["routeId"]
   }
-  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 = _cosmos_post(token, url, payload)
+  json["data"]["id"]
 end
 
 def sample(arr)
@@ -156,6 +146,23 @@ 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)
+  connection.use_ssl = true
+  connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  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
+
 class ClientApiHttp
   attr_reader :config, :options
 

data/spec/integration/braintree/credit_card_spec.rb

@@ -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(
@@ -844,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!

data/spec/integration/braintree/customer_spec.rb

@@ -1115,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",
@@ -1312,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,

data/spec/integration/braintree/document_upload_spec.rb

@@ -46,6 +46,18 @@ describe Braintree::DocumentUploadGateway do
       end
     end
 
+    it "returns file is empty error with empty file" do
+      filename = "#{File.dirname(__FILE__)}/../../fixtures/files/empty_file.png"
+      begin
+        File.open(filename, "w+") {}
+        file = File.new(filename, "r")
+        response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+        response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsEmpty
+      ensure
+        File.delete(filename)
+      end
+    end
+
     it "returns file too long error with file over 50 pages" do
       filename = "#{File.dirname(__FILE__)}/../../fixtures/files/too_long.pdf"
       file = File.new(filename, "r")

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -239,5 +239,82 @@ describe Braintree::PaymentMethodNonce do
         Braintree::PaymentMethodNonce.find("not_a_nonce")
       end.to raise_error(Braintree::NotFoundError)
     end
+
+    context "authentication insights" do
+      let(:indian_payment_token) { "india_visa_credit" }
+      let(:european_payment_token) { "european_visa_credit" }
+      let(:indian_merchant_token) { "india_three_d_secure_merchant_account" }
+      let(:european_merchant_token) { "european_three_d_secure_merchant_account" }
+
+      describe "self.create" do
+        it "raises an exception if hash includes an invalid key" do
+          expect do
+            Braintree::PaymentMethodNonce.create("european_visa_credit", :invalid_key => "foo")
+          end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+        end
+      end
+
+      context "regulation environments" do
+        it "can get unregulated" do
+          expect(
+            request_authentication_insights(european_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "unregulated"
+        end
+
+        it "can get psd2" do
+          expect(
+            request_authentication_insights(european_merchant_token, european_payment_token)[:regulation_environment]
+          ).to eq "psd2"
+        end
+
+        it "can get rbi" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "rbi"
+        end
+      end
+
+      context "sca_indicator" do
+        it "can get unavailable" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:sca_indicator]
+          ).to eq "unavailable"
+        end
+
+        it "can get sca_required" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2001})[:sca_indicator]
+          ).to eq "sca_required"
+        end
+
+        it "can get sca_optional" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2000, recurring_customer_consent: true, recurring_max_amount: 2000})[:sca_indicator]
+
+          ).to eq "sca_optional"
+        end
+      end
+
+      def request_authentication_insights(merchant_token, payment_method_token, options = {})
+        authentication_insight_options = {
+          amount: options[:amount],
+          recurring_customer_consent: options[:recurring_customer_consent],
+          recurring_max_amount: options[:recurring_max_amount],
+        }
+        nonce_request = {
+          merchant_account_id: merchant_token,
+          authentication_insight: true,
+          authentication_insight_options: authentication_insight_options,
+        }
+
+        result = Braintree::PaymentMethodNonce.create(
+          payment_method_token,
+          payment_method_nonce: nonce_request
+        )
+        result.should be_success
+
+        return result.payment_method_nonce.authentication_insight
+      end
+    end
   end
 end