braintree 2.98.0 → 4.23.0

data/spec/spec_helper.rb

@@ -3,8 +3,8 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   require "bundler/setup"
-  require "rspec"
   require "libxml"
+  require "rspec"
   require "pry"
 
   braintree_lib = "#{project_root}/lib"
@@ -28,22 +28,22 @@ unless defined?(SPEC_HELPER_LOADED)
     end
   end
 
-  def now_in_eastern
-    (Time.now.utc - 5*60*60).strftime("%Y-%m-%d")
-  end
-
   module SpecHelper
 
+    AdyenMerchantAccountId = "adyen_ma"
+    AibSwedenMaMerchantAccountId = "aib_swe_ma"
+    AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
+    CardProcessorBRLMerchantAccountId = "card_processor_brl"
     DefaultMerchantAccountId = "sandbox_credit_card"
+    FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
+    FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
+    FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
+    HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
     NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
+    PinlessDebitMerchantAccountId = "pinless_debit"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
-    FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
-    FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"
-    AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
-    AdyenMerchantAccountId = "adyen_ma"
-    HiperBRLMerchantAccountId = "hiper_brl"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",
@@ -92,13 +92,13 @@ unless defined?(SPEC_HELPER_LOADED)
                                                       :environment => Braintree::Configuration.environment,
                                                       :merchant_id => "test_merchant_id",
                                                       :public_key => "test_public_key",
-                                                      :private_key => "test_private_key"
+                                                      :private_key => "test_private_key",
                                                       )
 
     def self.make_past_due(subscription, number_of_days_past_due = 1)
       config = Braintree::Configuration.instantiate
       config.http.put(
-        "#{config.base_merchant_path}/subscriptions/#{subscription.id}/make_past_due?days_past_due=#{number_of_days_past_due}"
+        "#{config.base_merchant_path}/subscriptions/#{subscription.id}/make_past_due?days_past_due=#{number_of_days_past_due}",
       )
     end
 
@@ -110,14 +110,14 @@ unless defined?(SPEC_HELPER_LOADED)
     def self.create_3ds_verification(merchant_account_id, params)
       config = Braintree::Configuration.instantiate
       response = config.http.post("#{config.base_merchant_path}/three_d_secure/create_verification/#{merchant_account_id}", :three_d_secure_verification => params)
-      response[:three_d_secure_verification][:three_d_secure_token]
+      response[:three_d_secure_verification][:three_d_secure_authentication_id]
     end
 
     def self.create_merchant(params={})
       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"),
       )
 
       gateway.merchant.create({
@@ -188,16 +188,11 @@ unless defined?(SPEC_HELPER_LOADED)
       end
 
       def matches?(xml_string)
-        @libxml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string, Braintree::Xml::Libxml)
-        @rexml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string, Braintree::Xml::Rexml)
+        @libxml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string)
         if @libxml_parse != @expected_hash
           @results = @libxml_parse
           @failed_parser = "libxml"
           false
-        elsif @rexml_parse != @expected_hash
-          @results = @rexml_parse
-          @failed_parser = "rexml"
-          false
         else
           true
         end

data/spec/unit/braintree/address_spec.rb

@@ -3,32 +3,32 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Braintree::Address do
   describe "==" do
     it "returns true if given an address with the same id and customer_id" do
-      first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => 'a1')
+      first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false if given an address with a different id and the same customer_id" do
       first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "not a1")
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false if given an address with a different customer_id and the same id" do
       first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "not c1", :id => "a1")
 
-      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 an address" do
       address = Braintree::Address._new(:gateway, :id => "a1")
-      address.should_not == "not an address"
+      expect(address).not_to eq("not an address")
     end
   end
 
@@ -80,7 +80,7 @@ describe Braintree::Address do
     end
 
     it "does not raise an error if address_id does not respond to strip" 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::Address.find("customer_id", 8675309)
       end.to_not raise_error
@@ -94,12 +94,4 @@ describe Braintree::Address do
       end.to raise_error(NoMethodError, /protected method .new/)
     end
   end
-
-  describe "update" do
-    it "raises an exception if hash includes an invalid key" do
-      expect do
-        Braintree::Address._new(Braintree::Configuration.gateway, {}).update(:street_address => "456 E Main", :invalid_key2 => "foo")
-      end.to raise_error(ArgumentError, "invalid keys: invalid_key2")
-    end
-  end
 end

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -1,29 +1,132 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::ApplePayCard do
-  describe "bin" do
-    it "returns Apple pay card bin" do
-      Braintree::ApplePayCard._new(:gateway, bin: '411111').bin.should == '411111'
+  let(:attributes) do
+    {
+      :billing_address => {
+        company: "Braintree",
+        country_code_alpha2: "US",
+        country_code_alpha3: "USA",
+        country_code_numeric: "840",
+        country_name: "United States of America",
+        extended_address: "Apt 1",
+        first_name: "John",
+        last_name: "Miller",
+        locality: "Chicago",
+        phone_number: "17708675309",
+        postal_code: "12345",
+        region: "Illinois",
+        street_address: "123 Sesame Street",
+      },
+      :bin => "411111",
+      :card_type => "Apple Pay - MasterCard",
+      :cardholder_name => "John Miller",
+      :commercial => "No",
+      :country_of_issuance => "USA",
+      :created_at => Time.now,
+      :customer_id => "cid1",
+      :debit => "No",
+      :default => true,
+      :durbin_regulated => "Yes",
+      :expiration_month => "01",
+      :expiration_year => "2025",
+      :expired => false,
+      :healthcare => "No",
+      :image_url => nil,
+      :issuing_bank => "Big Bad Bank",
+      :last_4 => "9876",
+      :merchant_token_identifier => "merchant-token-123",
+      :payment_instrument_name => nil,
+      :payroll => "No",
+      :prepaid => "No",
+      :product_id => "MAC",
+      :source_card_last4 => "1234",
+      :source_description => "blah",
+      :subscriptions => [
+        {
+          balance: "50.00",
+          price: "10.00",
+          descriptor: [],
+          transactions: [],
+          add_ons: [],
+          discounts: [],
+        },
+      ],
+      :token => "123456789",
+      :updated_at => Time.now,
+    }
+  end
+
+  describe "initialize" do
+    it "converts billing address hash to Braintree::Address object" do
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.billing_address).to be_instance_of(Braintree::Address)
+    end
+
+    it "converts subscriptions hash to Braintree::Subscription object" do
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.subscriptions[0]).to be_instance_of(Braintree::Subscription)
+    end
+
+    it "handles nil billing address" do
+      attributes.delete(:billing_address)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.billing_address).to be_nil
+    end
+
+    it "handles nil subscriptions" do
+      attributes.delete(:subscriptions)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.subscriptions).to be_empty
+    end
+
+    it "handles mpan attributes" do
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.merchant_token_identifier).to_not be_nil
+      expect(card.source_card_last4).to_not be_nil
     end
   end
 
   describe "default?" do
     it "is true if the Apple pay card is the default payment method for the customer" do
-      Braintree::ApplePayCard._new(:gateway, :default => true).default?.should == true
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.default?).to be true
     end
 
     it "is false if the Apple pay card is not the default payment methodfor the customer" do
-      Braintree::ApplePayCard._new(:gateway, :default => false).default?.should == false
+      attributes.merge!(:default => false)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.default?).to be false
     end
   end
 
   describe "expired?" do
     it "is true if the Apple pay card is expired" do
-      Braintree::ApplePayCard._new(:gateway, :expired => true).expired?.should == true
+      attributes.merge!(:expired => true)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.expired?).to be true
     end
 
     it "is false if the Apple pay card is not expired" do
-      Braintree::ApplePayCard._new(:gateway, :expired => false).expired?.should == false
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.expired?).to be false
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::ApplePayCard.new
+      end.to raise_error(NoMethodError, /protected method .new/)
     end
   end
 end

data/spec/unit/braintree/base_module_spec.rb

@@ -8,11 +8,11 @@ describe Braintree::BaseModule do
         klass = Class.new { include Braintree::BaseModule }
         klass.return_object_or_raise(:obj) { result }
       rescue Braintree::ValidationsFailed => ex
+      expect(ex).not_to eq(nil)
+      expect(ex.error_result).to eq(result)
+      expect(ex.inspect).to include(result.inspect)
+      expect(ex.to_s).to include(result.inspect)
       end
-      ex.should_not == nil
-      ex.error_result.should == result
-      ex.inspect.should include(result.inspect)
-      ex.to_s.should include(result.inspect)
     end
   end
 end

data/spec/unit/braintree/client_token_spec.rb

@@ -7,27 +7,27 @@ module Braintree
       it "delegates to ClientTokenGateway#generate" do
         options = {:foo => :bar}
         client_token_gateway = double(:client_token_gateway)
-        client_token_gateway.should_receive(:generate).with(options).once
-        ClientTokenGateway.stub(:new).and_return(client_token_gateway)
+        expect(client_token_gateway).to receive(:generate).with(options).once
+        allow(ClientTokenGateway).to receive(:new).and_return(client_token_gateway)
         ClientToken.generate(options)
       end
 
       it "can't overwrite public_key, or created_at" do
         expect {
-          client_token = Braintree::ClientToken.generate(
+          Braintree::ClientToken.generate(
             :public_key => "bad_key",
-            :created_at => "bad_time"
+            :created_at => "bad_time",
           )
         }.to raise_error(ArgumentError, /created_at, public_key/)
       end
     end
 
     context "adding credit_card options with no customer ID" do
-      %w(verify_card fail_on_duplicate_payment_method make_default).each do |option_name|
+      %w(verify_card fail_on_duplicate_payment_method make_default fail_on_duplicate_payment_method_for_customer).each do |option_name|
         it "raises an ArgumentError if #{option_name} is present" do
           expect do
             Braintree::ClientToken.generate(
-              option_name.to_sym => true
+              option_name.to_sym => true,
             )
           end.to raise_error(ArgumentError, /#{option_name}/)
         end