braintree 2.10.0 → 4.26.0

data/spec/unit/braintree/customer_session_gateway_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::CustomerSessionGateway do
+  let(:gateway) { double(:gateway) }
+  let(:graphql_client) { double(:graphql_client) }
+  let(:customer_session_gateway) { Braintree::CustomerSessionGateway.new(gateway, graphql_client) }
+
+  describe "#create_customer_session" do
+    let(:input) do
+      {
+       :merchant_account_id => "merchant-account-id",
+      }
+    end
+
+    let(:response) do
+        {
+          data: {
+            createCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+    end
+
+
+    it "executes the createCustomerSession mutation" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::CREATE_CUSTOMER_SESSION,
+      {
+        "input" => create_input.to_graphql_variables
+      }).and_return(response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.session_id).to eq("session-id")
+    end
+
+    it "returns an error result if there are validation errors" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      errors = {:errors =>
+        [ {:attribute => "", :code => "123", :message => "error"} ]
+      }
+      expect(graphql_client).to receive(:query).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(errors)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::ErrorResult)
+      expect(result.errors.first.message).to eq("error")
+    end
+
+    it "raises an UnexpectedError if there is a problem parsing the response" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      badResonse =  {:data => {}}
+      expect(graphql_client).to receive(:query).and_return(badResonse)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(badResonse).and_return(nil)
+      expect { customer_session_gateway.create_customer_session(create_input) }.to raise_error(Braintree::UnexpectedError)
+    end
+  end
+
+
+  describe "#update_customer_session" do
+      let(:input) do
+        {
+          :merchant_account_id => "merchant-account-id", :session_id => "session-id"
+        }
+      end
+      let(:response) do
+        {
+          data: {
+            updateCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+      end
+
+      it "executes the updateCustomerSession mutation" do
+        update_input = Braintree::UpdateCustomerSessionInput.new(input)
+        expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::UPDATE_CUSTOMER_SESSION,
+        {
+          "input" => update_input.to_graphql_variables
+        }).and_return(response)
+        expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+        result = customer_session_gateway.update_customer_session(update_input)
+        expect(result).to be_a(Braintree::SuccessfulResult)
+        expect(result.session_id).to eq("session-id")
+      end
+  end
+
+  describe "#get_customer_recommendations" do
+    let(:customer_recommendations_input) { double(:customer_recommendations_input, to_graphql_variables: {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}) }
+    let(:response) do
+      {
+        data: {
+          customerRecommendations: {
+              isInPayPalNetwork: true,
+              recommendations: {
+                paymentOptions: [
+                  {paymentOption: "PAYPAL", recommendedPriority: 1}
+                ]
+              }
+          }
+        }
+      }
+    end
+
+    it "fetches customer recommendations" do
+      expected_variables = {"input" => {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}}
+      expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::GET_CUSTOMER_RECOMMENDATIONS, expected_variables).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+
+      result = customer_session_gateway.get_customer_recommendations(customer_recommendations_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.customer_recommendations.is_in_paypal_network).to eq(true)
+      expect(result.customer_recommendations.recommendations.payment_options[0].payment_option).to eq("PAYPAL")
+      expect(result.customer_recommendations.recommendations.payment_options[0].recommended_priority).to eq(1)
+    end
+  end
+
+end

data/spec/unit/braintree/customer_spec.rb

@@ -3,8 +3,8 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Braintree::Customer do
   describe "inspect" do
     it "includes the id first" do
-      output = Braintree::Customer._new(:gateway, {:first_name => 'Dan', :id => '1234'}).inspect
-      output.should include("#<Braintree::Customer id: \"1234\",")
+      output = Braintree::Customer._new(:gateway, {:first_name => "Dan", :id => "1234"}).inspect
+      expect(output).to include("#<Braintree::Customer id: \"1234\",")
     end
 
     it "includes all customer attributes" do
@@ -16,20 +16,26 @@ describe Braintree::Customer do
         :first_name => "Patrick",
         :last_name => "Smith",
         :phone => "802-483-5932",
+        :international_phone => {:country_code => "1", :national_number => "3121234567"},
         :website => "patrick.smith.com",
         :created_at => Time.now,
-        :updated_at => Time.now
+        :updated_at => Time.now,
       )
       output = customer.inspect
-      output.should include(%q(company: "Company"))
-      output.should include(%q(email: "e@mail.com"))
-      output.should include(%q(fax: "483-438-5821"))
-      output.should include(%q(first_name: "Patrick"))
-      output.should include(%q(last_name: "Smith"))
-      output.should include(%q(phone: "802-483-5932"))
-      output.should include(%q(website: "patrick.smith.com"))
-      output.should include(%Q(created_at: #{customer.created_at.inspect}))
-      output.should include(%Q(updated_at: #{customer.updated_at.inspect}))
+      expect(output).to include(%q(company: "Company"))
+      expect(output).to include(%q(email: "e@mail.com"))
+      expect(output).to include(%q(fax: "483-438-5821"))
+      expect(output).to include(%q(first_name: "Patrick"))
+      expect(output).to include(%q(last_name: "Smith"))
+      expect(output).to include(%q(phone: "802-483-5932"))
+      expect(output).to include(%q(international_phone: {:country_code=>"1", :national_number=>"3121234567"}))
+      expect(output).to include(%q(website: "patrick.smith.com"))
+      expect(output).to include(%q(addresses: []))
+      expect(output).to include(%q(credit_cards: []))
+      expect(output).to include(%q(paypal_accounts: []))
+      expect(output).to include(%q(tax_identifiers: []))
+      expect(output).to include(%Q(created_at: #{customer.created_at.inspect}))
+      expect(output).to include(%Q(updated_at: #{customer.updated_at.inspect}))
     end
   end
 
@@ -41,6 +47,27 @@ describe Braintree::Customer do
     end
   end
 
+  describe "self.find" do
+    it "raises an exception if the id is blank" do
+      expect do
+        Braintree::Customer.find("  ")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises an exception if the id is nil" do
+      expect do
+        Braintree::Customer.find(nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not raise an exception if the id is a fixnum" do
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+      expect do
+        Braintree::Customer.find(8675309)
+      end.to_not raise_error
+    end
+  end
+
   describe "self.update" do
     it "raises an exception if hash includes an invalid key" do
       expect do
@@ -51,15 +78,19 @@ describe Braintree::Customer do
 
   describe "self.create_signature" do
     it "should be what we expect" do
-      Braintree::CustomerGateway._create_signature.should == [
+      expect(Braintree::CustomerGateway._create_signature).to match([
         :company,
         :email,
         :fax,
         :first_name,
         :id,
+        {:international_phone=>[:country_code, :national_number]},
         :last_name,
         :phone,
         :website,
+        :device_data,
+        :payment_method_nonce,
+        {:risk_data => [:customer_browser, :customer_ip]},
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,
@@ -69,7 +100,12 @@ describe Braintree::Customer do
           :expiration_year,
           :number,
           :token,
-          {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
+          :device_data,
+          :payment_method_nonce,
+          {:external_vault=>[:network_transaction_id]},
+          {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+            :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -78,29 +114,80 @@ describe Braintree::Customer do
             :country_name,
             :extended_address,
             :first_name,
+            {:international_phone=>[:country_code, :national_number]},
             :last_name,
             :locality,
+            :phone_number,
             :postal_code,
             :region,
             :street_address
-          ]}
+          ]},
+          {:three_d_secure_pass_thru => [
+            :eci_flag,
+            :cavv,
+            :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
+          ]},
+        ]},
+        {:paypal_account => [
+          :email,
+          :token,
+          :billing_agreement_id,
+          {:options => [:make_default]},
         ]},
+        {:tax_identifiers => [
+          :country_code,
+          :identifier
+        ]},
+        {:options =>
+          [:paypal => [
+            :payee_email,
+            :order_id,
+            :custom_field,
+            :description,
+            :amount,
+            {:shipping => [
+              :company,
+              :country_code_alpha2,
+              :country_code_alpha3,
+              :country_code_numeric,
+              :country_name,
+              :extended_address,
+              :first_name,
+              {:international_phone=>[:country_code, :national_number]},
+              :last_name,
+              :locality,
+              :phone_number,
+              :postal_code,
+              :region,
+              :street_address,
+            ]}
+          ]]
+        },
         {:custom_fields => :_any_key_}
-      ]
+      ])
     end
   end
 
   describe "self.update_signature" do
     it "should be what we expect" do
-      Braintree::CustomerGateway._update_signature.should == [
+      expect(Braintree::CustomerGateway._update_signature).to match([
         :company,
         :email,
         :fax,
         :first_name,
         :id,
+        {:international_phone=>[:country_code, :national_number]},
         :last_name,
         :phone,
         :website,
+        :device_data,
+        :payment_method_nonce,
+        :default_payment_method_token,
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,
@@ -110,12 +197,23 @@ describe Braintree::Customer do
           :expiration_year,
           :number,
           :token,
-          {:options => [
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
+          :device_data,
+          :payment_method_nonce,
+          {:external_vault=>[:network_transaction_id]},
+          {:options => match_array([
             :make_default,
+            :skip_advanced_fraud_checking,
             :verification_merchant_account_id,
             :verify_card,
+            :verification_amount,
+            :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+            :fail_on_duplicate_payment_method,
+            :fail_on_duplicate_payment_method_for_customer,
+            :verification_account_type,
+            :verification_currency_iso_code,
             :update_existing_token
-          ]},
+          ])},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -124,24 +222,57 @@ describe Braintree::Customer do
             :country_name,
             :extended_address,
             :first_name,
+            {:international_phone=>[:country_code, :national_number]},
             :last_name,
             :locality,
+            :phone_number,
             :postal_code,
             :region,
             :street_address,
             {:options => [:update_existing]}
-          ]}
+          ]},
+          {:three_d_secure_pass_thru => [
+            :eci_flag,
+            :cavv,
+            :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
+          ]},
         ]},
+        {:tax_identifiers => [
+          :country_code,
+          :identifier
+        ]},
+        {:options =>
+          [:paypal => [
+            :payee_email,
+            :order_id,
+            :custom_field,
+            :description,
+            :amount,
+            {:shipping => [
+              :company,
+              :country_code_alpha2,
+              :country_code_alpha3,
+              :country_code_numeric,
+              :country_name,
+              :extended_address,
+              :first_name,
+              {:international_phone=>[:country_code, :national_number]},
+              :last_name,
+              :locality,
+              :phone_number,
+              :postal_code,
+              :region,
+              :street_address,
+            ]}
+          ]]
+        },
         {:custom_fields => :_any_key_}
-      ]
-    end
-  end
-
-  describe "self.create_from_transparent_redirect" do
-    it "raises an exception if the query string is forged" do
-      expect do
-        Braintree::Customer.create_from_transparent_redirect("http_status=200&forged=query_string")
-      end.to raise_error(Braintree::ForgedQueryString)
+      ])
     end
   end
 
@@ -150,21 +281,21 @@ describe Braintree::Customer do
       first = Braintree::Customer._new(:gateway, :id => 123)
       second = Braintree::Customer._new(:gateway, :id => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false when given a customer with a different id" do
       first = Braintree::Customer._new(:gateway, :id => 123)
       second = Braintree::Customer._new(:gateway, :id => 124)
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false when not given a customer" do
       customer = Braintree::Customer._new(:gateway, :id => 123)
-      customer.should_not == "not a customer"
+      expect(customer).not_to eq("not a customer")
     end
   end
 
@@ -173,13 +304,38 @@ describe Braintree::Customer do
       customer = Braintree::Customer._new(
         :gateway,
         :credit_cards => [
-          {:token => "pm1"},
-          {:token => "pm2"}
-        ]
+          {:token => "credit_card_1"},
+          {:token => "credit_card_2"}
+        ],
+        :paypal_accounts => [
+          {:token => "paypal_1"},
+          {:token => "paypal_2"}
+        ],
+        :sepa_debit_accounts => [
+          {:token => "sepa_debit_1"},
+          {:token => "sepa_debit_2"}
+        ],
       )
-      customer.credit_cards.size.should == 2
-      customer.credit_cards[0].token.should == "pm1"
-      customer.credit_cards[1].token.should == "pm2"
+
+      expect(customer.credit_cards.size).to eq(2)
+      expect(customer.credit_cards[0].token).to eq("credit_card_1")
+      expect(customer.credit_cards[1].token).to eq("credit_card_2")
+
+      expect(customer.paypal_accounts.size).to eq(2)
+      expect(customer.paypal_accounts[0].token).to eq("paypal_1")
+      expect(customer.paypal_accounts[1].token).to eq("paypal_2")
+
+      expect(customer.sepa_direct_debit_accounts.size).to eq(2)
+      expect(customer.sepa_direct_debit_accounts[0].token).to eq("sepa_debit_1")
+      expect(customer.sepa_direct_debit_accounts[1].token).to eq("sepa_debit_2")
+
+      expect(customer.payment_methods.count).to eq(6)
+      expect(customer.payment_methods.map(&:token)).to include("credit_card_1")
+      expect(customer.payment_methods.map(&:token)).to include("credit_card_2")
+      expect(customer.payment_methods.map(&:token)).to include("paypal_1")
+      expect(customer.payment_methods.map(&:token)).to include("paypal_2")
+      expect(customer.payment_methods.map(&:token)).to include("sepa_debit_1")
+      expect(customer.payment_methods.map(&:token)).to include("sepa_debit_2")
     end
   end
 

data/spec/unit/braintree/digest_spec.rb

@@ -3,21 +3,34 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Braintree::Digest do
   describe "self.hexdigest" do
     it "returns the sha1 hmac of the input string (test case 6 from RFC 2202)" do
-      original_key = Braintree::Configuration.private_key
       private_key = "\xaa" * 80
       data = "Test Using Larger Than Block-Size Key - Hash Key First"
-      Braintree::Digest.hexdigest(private_key, data).should == "aa4ae5e15272d00e95705637ce8a3b55ed402112"
+      expect(Braintree::Digest.hexdigest(private_key, data)).to eq("aa4ae5e15272d00e95705637ce8a3b55ed402112")
     end
 
     it "returns the sha1 hmac of the input string (test case 7 from RFC 2202)" do
       private_key = "\xaa" * 80
       data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
-      Braintree::Digest.hexdigest(private_key, data).should == "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+      expect(Braintree::Digest.hexdigest(private_key, data)).to eq("e8e99d0f45237d786d6bbaa7965c7808bbff1a91")
     end
 
     it "doesn't blow up if message is nil" do
       expect { Braintree::Digest.hexdigest("key", nil) }.to_not raise_error
     end
   end
+
+  describe "self.secure_compare" do
+    it "returns true if two strings are equal" do
+      expect(Braintree::Digest.secure_compare("A_string", "A_string")).to be(true)
+    end
+
+    it "returns false if two strings are different and the same length" do
+      expect(Braintree::Digest.secure_compare("A_string", "A_strong")).to be(false)
+    end
+
+    it "returns false if one is a prefix of the other" do
+      expect(Braintree::Digest.secure_compare("A_string", "A_string_that_is_longer")).to be(false)
+    end
+  end
 end
 

data/spec/unit/braintree/disbursement_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Disbursement do
+  describe "new" do
+    it "is protected" do
+      expect do
+        Braintree::Disbursement.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "inspect" do
+    it "prints attributes of disbursement object" do
+      disbursement = Braintree::Disbursement._new(
+        :gateway,
+        :id => "123456",
+        :merchant_account => {
+          :id => "sandbox_sub_merchant_account",
+          :master_merchant_account => {
+            :id => "sandbox_master_merchant_account",
+            :status => "active"
+          },
+          :status => "active"
+        },
+        :transaction_ids => ["sub_merchant_transaction"],
+        :amount => "100.00",
+        :disbursement_date => "2013-04-10",
+        :exception_message => "invalid_account_number",
+        :follow_up_action => "update",
+        :retry => false,
+        :success => false,
+      )
+
+      expect(disbursement.inspect).to include('id: "123456"')
+      expect(disbursement.inspect).to include('amount: "100.0"')
+      expect(disbursement.inspect).to include('exception_message: "invalid_account_number"')
+      expect(disbursement.inspect).to include("disbursement_date: 2013-04-10")
+      expect(disbursement.inspect).to include('follow_up_action: "update"')
+      expect(disbursement.inspect).to include("merchant_account: #<Braintree::MerchantAccount: ")
+      expect(disbursement.inspect).to include('transaction_ids: ["sub_merchant_transaction"]')
+      expect(disbursement.inspect).to include("retry: false")
+      expect(disbursement.inspect).to include("success: false")
+    end
+  end
+
+  describe "success?" do
+    it "is an alias of success" do
+      disbursement = Braintree::Disbursement._new(
+        :gateway,
+        :merchant_account => {
+          :id => "sandbox_sub_merchant_account",
+          :master_merchant_account => {
+            :id => "sandbox_master_merchant_account",
+            :status => "active"
+          },
+          :status => "active"
+        },
+        :success => false,
+        :disbursement_date => "2013-04-10",
+      )
+      expect(disbursement.success?).to eq(false)
+
+      disbursement = Braintree::Disbursement._new(
+        :gateway,
+        :merchant_account => {
+          :id => "sandbox_sub_merchant_account",
+          :master_merchant_account => {
+            :id => "sandbox_master_merchant_account",
+            :status => "active"
+          },
+          :status => "active"
+        },
+        :success => true,
+        :disbursement_date => "2013-04-10",
+      )
+      expect(disbursement.success?).to eq(true)
+    end
+  end
+
+  describe "credit?" do
+    subject do
+      described_class._new(
+        :gateway,
+        merchant_account: {
+          id: "sandbox_master_merchant_account",
+          status: "active",
+        },
+        success: true,
+        amount: "100.00",
+        disbursement_type: type,
+        disbursement_date: "2013-04-10",
+      )
+    end
+
+    context "when the disbursement type is credit" do
+      let(:type) { described_class::Types::Credit }
+      it { is_expected.to be_credit }
+    end
+
+    context "when the disbursement type is not credit" do
+      let(:type) { described_class::Types::Debit }
+      it { is_expected.not_to be_credit }
+    end
+  end
+
+  describe "debit?" do
+    subject do
+      described_class._new(
+        :gateway,
+        merchant_account: {
+          id: "sandbox_master_merchant_account",
+          status: "active",
+        },
+        success: true,
+        amount: "100.00",
+        disbursement_type: type,
+        disbursement_date: "2013-04-10",
+      )
+    end
+
+    context "when the disbursement type is debit" do
+      let(:type) { described_class::Types::Debit }
+      it { is_expected.to be_debit }
+    end
+
+    context "when the disbursement type is not debit" do
+      let(:type) { described_class::Types::Credit }
+      it { is_expected.not_to be_debit }
+    end
+  end
+end