braintree 2.98.0 → 4.23.0

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,23 +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(addresses: []))
-      output.should include(%q(credit_cards: []))
-      output.should include(%q(paypal_accounts: []))
-      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
 
@@ -58,7 +61,7 @@ describe Braintree::Customer do
     end
 
     it "does not raise an exception if the id is a fixnum" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::Customer.find(8675309)
       end.to_not raise_error
@@ -75,12 +78,13 @@ 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,
@@ -91,17 +95,17 @@ describe Braintree::Customer do
           :billing_address_id,
           :cardholder_name,
           :cvv,
-          :device_session_id,
           :expiration_date,
           :expiration_month,
           :expiration_year,
           :number,
           :token,
-          :venmo_sdk_payment_method_code,
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
-          :fraud_merchant_id,
           :payment_method_nonce,
-          {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+          {: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,
@@ -110,12 +114,24 @@ 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,
@@ -123,6 +139,10 @@ describe Braintree::Customer do
           :billing_agreement_id,
           {:options => [:make_default]},
         ]},
+        {:tax_identifiers => [
+          :country_code,
+          :identifier
+        ]},
         {:options =>
           [:paypal => [
             :payee_email,
@@ -138,8 +158,10 @@ 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,
@@ -147,18 +169,19 @@ describe Braintree::Customer do
           ]]
         },
         {: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,
@@ -169,26 +192,28 @@ describe Braintree::Customer do
           :billing_address_id,
           :cardholder_name,
           :cvv,
-          :device_session_id,
           :expiration_date,
           :expiration_month,
           :expiration_year,
           :number,
           :token,
-          :venmo_sdk_payment_method_code,
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
-          :fraud_merchant_id,
           :payment_method_nonce,
-          {:options => [
+          {: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,
+            :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,
@@ -197,13 +222,29 @@ 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 => [
@@ -220,8 +261,10 @@ 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,
@@ -229,15 +272,7 @@ describe Braintree::Customer do
           ]]
         },
         {: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
 
@@ -246,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
 
@@ -275,22 +310,32 @@ describe Braintree::Customer do
         :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 == "credit_card_1"
-      customer.credit_cards[1].token.should == "credit_card_2"
+      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")
 
-      customer.paypal_accounts.size.should == 2
-      customer.paypal_accounts[0].token.should == "paypal_1"
-      customer.paypal_accounts[1].token.should == "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")
 
-      customer.payment_methods.count.should == 4
-      customer.payment_methods.map(&:token).should include("credit_card_1")
-      customer.payment_methods.map(&:token).should include("credit_card_2")
-      customer.payment_methods.map(&:token).should include("paypal_1")
-      customer.payment_methods.map(&:token).should include("paypal_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,16 +3,15 @@ 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
@@ -22,15 +21,15 @@ describe Braintree::Digest do
 
   describe "self.secure_compare" do
     it "returns true if two strings are equal" do
-      Braintree::Digest.secure_compare("A_string", "A_string").should be(true)
+      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
-      Braintree::Digest.secure_compare("A_string", "A_strong").should be(false)
+      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
-      Braintree::Digest.secure_compare("A_string", "A_string_that_is_longer").should be(false)
+      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

@@ -28,18 +28,18 @@ describe Braintree::Disbursement do
         :exception_message => "invalid_account_number",
         :follow_up_action => "update",
         :retry => false,
-        :success => false
+        :success => false,
       )
 
-      disbursement.inspect.should include('id: "123456"')
-      disbursement.inspect.should include('amount: "100.0"')
-      disbursement.inspect.should include('exception_message: "invalid_account_number"')
-      disbursement.inspect.should include('disbursement_date: 2013-04-10')
-      disbursement.inspect.should include('follow_up_action: "update"')
-      disbursement.inspect.should include('merchant_account: #<Braintree::MerchantAccount: ')
-      disbursement.inspect.should include('transaction_ids: ["sub_merchant_transaction"]')
-      disbursement.inspect.should include('retry: false')
-      disbursement.inspect.should include('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
 
@@ -56,9 +56,9 @@ describe Braintree::Disbursement do
           :status => "active"
         },
         :success => false,
-        :disbursement_date => "2013-04-10"
+        :disbursement_date => "2013-04-10",
       )
-      disbursement.success?.should == false
+      expect(disbursement.success?).to eq(false)
 
       disbursement = Braintree::Disbursement._new(
         :gateway,
@@ -71,9 +71,9 @@ describe Braintree::Disbursement do
           :status => "active"
         },
         :success => true,
-        :disbursement_date => "2013-04-10"
+        :disbursement_date => "2013-04-10",
       )
-      disbursement.success?.should == true
+      expect(disbursement.success?).to eq(true)
     end
   end
 

data/spec/unit/braintree/dispute_search_spec.rb

@@ -5,14 +5,14 @@ describe Braintree::DisputeSearch do
     search = Braintree::DisputeSearch.new
     search.id.is "dispute1"
     search.id.is "dispute2"
-    search.to_hash.should == {:id => {:is => "dispute2"}}
+    expect(search.to_hash).to eq({:id => {:is => "dispute2"}})
   end
 
   it "overrides previous 'in' with new 'in' for the same field" do
     search = Braintree::DisputeSearch.new
     search.status.in Braintree::Dispute::Status::Open
     search.status.in Braintree::Dispute::Status::Won
-    search.to_hash.should == {:status => [Braintree::Dispute::Status::Won]}
+    expect(search.to_hash).to eq({:status => [Braintree::Dispute::Status::Won]})
   end
 
   [
@@ -41,9 +41,13 @@ describe Braintree::DisputeSearch do
   end
 
   [
+    # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
+    :chargeback_protection_level,
+    :protection_level,
     :kind,
     :reason,
     :status,
+    :pre_dispute_program,
   ].each do |field|
     it "raises if provided an unknown #{field} value" do
       search = Braintree::DisputeSearch.new