braintree 2.74.0 → 4.12.0

data/spec/integration/braintree/oauth_spec.rb

@@ -5,7 +5,7 @@ describe "OAuth" do
     @gateway = Braintree::Gateway.new(
       :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
       :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-      :logger => Logger.new("/dev/null")
+      :logger => Logger.new("/dev/null"),
     )
   end
 
@@ -18,7 +18,7 @@ describe "OAuth" do
 
       result = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
       result.should be_success
@@ -32,7 +32,7 @@ describe "OAuth" do
     it "returns validation errors for bad params" do
       result = @gateway.oauth.create_token_from_code(
         :code => "bad_code",
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
       result.should_not be_success
@@ -43,13 +43,13 @@ describe "OAuth" do
     it "raises with a helpful error if client_id and client_secret are not set" do
       gateway = Braintree::Gateway.new(
         :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       expect do
         gateway.oauth.create_token_from_code(
           :code => "some code",
-          :scope => "read_write"
+          :scope => "read_write",
         )
       end.to raise_error(Braintree::ConfigurationError, /client_id and client_secret are required/);
     end
@@ -63,12 +63,12 @@ describe "OAuth" do
       })
       refresh_token = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       ).credentials.refresh_token
 
       result = @gateway.oauth.create_token_from_refresh_token(
         :refresh_token => refresh_token,
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
       result.should be_success
@@ -88,7 +88,7 @@ describe "OAuth" do
       })
       access_token = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       ).credentials.access_token
 
       result = @gateway.oauth.revoke_access_token(access_token)
@@ -96,7 +96,7 @@ describe "OAuth" do
 
       gateway = Braintree::Gateway.new(
         :access_token => access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       expect do
@@ -113,6 +113,7 @@ describe "OAuth" do
         :scope => "read_write",
         :state => "baz_state",
         :landing_page => "signup",
+        :login_only => false,
         :user => {
           :country => "USA",
           :email => "foo@example.com",
@@ -145,7 +146,7 @@ describe "OAuth" do
           :currency => "USD",
           :website => "http://example.com"
         },
-        :payment_methods => ["credit_card", "paypal"]
+        :payment_methods => ["credit_card", "paypal"],
       )
 
       uri = URI.parse(url)
@@ -159,6 +160,7 @@ describe "OAuth" do
       query["scope"].should == ["read_write"]
       query["state"].should == ["baz_state"]
       query["landing_page"].should == ["signup"]
+      query["login_only"].should == ["false"]
 
       query["user[country]"].should == ["USA"]
       query["business[name]"].should == ["14 Ladders"]
@@ -191,9 +193,6 @@ describe "OAuth" do
       query["business[fulfillment_completed_in]"].should == ["7"]
       query["business[currency]"].should == ["USD"]
       query["business[website]"].should == ["http://example.com"]
-
-      query["signature"][0].length.should == 64
-      query["algorithm"].should == ["SHA256"]
     end
 
     it "builds the query string with multiple payment_methods" do
@@ -202,7 +201,7 @@ describe "OAuth" do
         :redirect_uri => "http://bar.example.com",
         :scope => "read_write",
         :state => "baz_state",
-        :payment_methods => ["credit_card", "paypal"]
+        :payment_methods => ["credit_card", "paypal"],
       )
 
       uri = URI.parse(url)
@@ -214,19 +213,13 @@ describe "OAuth" do
       query["payment_methods[]"].should include("paypal")
       query["payment_methods[]"].should include("credit_card")
     end
-  end
 
-  describe "_compute_signature" do
-    it "computes the correct signature" do
-      @gateway = Braintree::Gateway.new(
-        :client_id => "client_id$development$integration_client_id",
-        :client_secret => "client_secret$development$integration_client_secret",
-        :logger => Logger.new("/dev/null")
-      )
-      url = "http://localhost:3000/oauth/connect?business%5Bname%5D=We+Like+Spaces&client_id=client_id%24development%24integration_client_id"
-      signature = @gateway.oauth._compute_signature(url)
+    it "doesn't mutate the options" do
+      params = {:payment_methods => ["credit_card"]}
+
+      @gateway.oauth.connect_url(params)
 
-      signature.should == "a36bcf10dd982e2e47e0d6a2cb930aea47ade73f954b7d59c58dae6167894d41"
+      params.should == {:payment_methods => ["credit_card"]}
     end
   end
 end

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+require "date"
 
 describe Braintree::PaymentMethodNonce do
   let(:config) { Braintree::Configuration.instantiate }
@@ -12,12 +13,12 @@ describe Braintree::PaymentMethodNonce do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
 
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       result.should be_success
@@ -32,6 +33,7 @@ describe Braintree::PaymentMethodNonce do
       result.payment_method_nonce.should_not be_nil
       result.payment_method_nonce.nonce.should_not be_nil
       result.payment_method_nonce.details.should_not be_nil
+      result.payment_method_nonce.default?.should be_truthy
     end
 
     it "correctly raises and exception for a non existent token" do
@@ -41,6 +43,36 @@ describe Braintree::PaymentMethodNonce do
     end
   end
 
+  describe "self.create!" do
+    it "creates a payment method nonce from a vaulted credit card" do
+      customer = Braintree::Customer.create.customer
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_month => "11",
+          :expiration_year => "2099",
+        },
+      )
+
+      payment_method = Braintree::PaymentMethod.create!(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+      )
+
+      payment_method.should be_a(Braintree::CreditCard)
+      token = payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+
+      payment_method_nonce = Braintree::PaymentMethodNonce.create!(found_credit_card.token)
+      payment_method_nonce.should_not be_nil
+      payment_method_nonce.nonce.should_not be_nil
+      payment_method_nonce.details.should_not be_nil
+      payment_method_nonce.default?.should be_truthy
+    end
+  end
+
   describe "self.find" do
     it "finds and returns the nonce if one was found" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-nonce")
@@ -50,8 +82,24 @@ describe Braintree::PaymentMethodNonce do
       result.should be_success
       nonce.nonce.should == "fake-valid-nonce"
       nonce.type.should == "CreditCard"
-      nonce.details.fetch(:last_two).should == "81"
-      nonce.details.fetch(:card_type).should == "Visa"
+      nonce.details.bin.should == "401288"
+      nonce.details.card_type.should == "Visa"
+      nonce.details.expiration_month.should == "12"
+      nonce.details.expiration_year.should == Date.today.next_year.year.to_s
+      nonce.details.is_network_tokenized?.should be_nil
+      nonce.details.last_two.should == "81"
+      nonce.details.payer_info.should be_nil
+    end
+
+    it "return paypal details if details exist" do
+      result = Braintree::PaymentMethodNonce.find("fake-paypal-one-time-nonce")
+      nonce = result.payment_method_nonce
+      nonce.details.payer_info.billing_agreement_id.should be_nil
+      nonce.details.payer_info.country_code.should be_nil
+      nonce.details.payer_info.email.should_not be_nil
+      nonce.details.payer_info.first_name.should_not be_nil
+      nonce.details.payer_info.last_name.should_not be_nil
+      nonce.details.payer_info.payer_id.should_not be_nil
     end
 
     it "returns null 3ds_info if there isn't any" do
@@ -60,7 +108,7 @@ describe Braintree::PaymentMethodNonce do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
 
       result = Braintree::PaymentMethodNonce.find(nonce)
@@ -71,10 +119,196 @@ describe Braintree::PaymentMethodNonce do
       nonce.three_d_secure_info.should be_nil
     end
 
+    it "returns the bin" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-visa-nonce")
+
+      nonce = result.payment_method_nonce
+      result.should be_success
+      nonce.details.should_not be_nil
+      nonce.details.bin.should == "401288"
+    end
+
+    it "returns bin_data with commercial set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-commercial-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.commercial.should == Braintree::CreditCard::Commercial::Yes
+    end
+
+    it "returns bin_data with country_of_issuance set to CAN" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-country-of-issuance-cad-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.country_of_issuance.should == "CAN"
+    end
+
+    it "returns bin_data with debit set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-debit-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.debit.should == Braintree::CreditCard::Debit::Yes
+    end
+
+    it "returns bin_data with durbin_regulated set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-durbin-regulated-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
+    end
+
+    it "returns bin_data with healthcare set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-healthcare-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.healthcare.should == Braintree::CreditCard::Healthcare::Yes
+      nonce.bin_data.product_id.should == "J3"
+    end
+
+    it "returns bin_data with issuing_bank set to Network Only" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-issuing-bank-network-only-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.issuing_bank.should == "NETWORK ONLY"
+    end
+
+    it "returns bin_data with payroll set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-payroll-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.payroll.should == Braintree::CreditCard::Payroll::Yes
+      nonce.bin_data.product_id.should == "MSA"
+    end
+
+    it "returns bin_data with prepaid set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-prepaid-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+    end
+
+    it "returns bin_data with unknown indicators" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-unknown-indicators-nonce")
+
+      nonce = result.payment_method_nonce
+
+      result.should be_success
+      nonce.bin_data.should_not be_nil
+      nonce.bin_data.commercial.should == Braintree::CreditCard::Commercial::Unknown
+      nonce.bin_data.country_of_issuance.should == Braintree::CreditCard::CountryOfIssuance::Unknown
+      nonce.bin_data.debit.should == Braintree::CreditCard::Debit::Unknown
+      nonce.bin_data.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Unknown
+      nonce.bin_data.healthcare.should == Braintree::CreditCard::Healthcare::Unknown
+      nonce.bin_data.issuing_bank.should == Braintree::CreditCard::IssuingBank::Unknown
+      nonce.bin_data.payroll.should == Braintree::CreditCard::Payroll::Unknown
+      nonce.bin_data.prepaid.should == Braintree::CreditCard::Prepaid::Unknown
+      nonce.bin_data.product_id.should == Braintree::CreditCard::ProductId::Unknown
+    end
+
     it "correctly raises and exception for a non existent token" do
       expect 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