braintree 2.10.0 → 4.26.0

data/spec/ssl/certificate.crt

@@ -0,0 +1,17 @@
+-----BEGIN CERTIFICATE-----
+MIICsDCCAhmgAwIBAgIJALYNz+IiqwdkMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMDkxMjAyMjI1NTE3WhcNMTAxMjAyMjI1NTE3WjBF
+MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQCrUO6cm5QqdJLLcMIygeIzyBUYl7iWiHqPy6fmxzj3SsFbTAY8tXT8C2jh3cWi
+0qNGXuxwSK6pClFwkPmW5znjCPbq9Ifa6mAU4+NoCzjTCAWxY3K1p6eW2s1gA82J
+BJF9/X4umdx9NbkOeoZWselJa7K0hztjOSBZXjXNfMYOiQIDAQABo4GnMIGkMB0G
+A1UdDgQWBBRhqocfWHXEx0mT/IEFR1I5fqCHAjB1BgNVHSMEbjBsgBRhqocfWHXE
+x0mT/IEFR1I5fqCHAqFJpEcwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUt
+U3RhdGUxITAfBgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZIIJALYNz+Ii
+qwdkMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAqeNLmBTdAGcdiTqS
+XfmLqbykyq1Qogg+J6s7uNhnP42tuvmHXrE0tC9cn8stbgYzTF4661f/AS97jOOn
+cL7c2kXzTzX+fiAd+dMHOckTBoTzRT95/YlphddJNvcdl2q/e2aWMg2VEnIqShJP
+jyWXlHrUWbOazZzroZwY9WviUdo=
+-----END CERTIFICATE-----

data/spec/ssl/geotrust_global.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
+YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
+EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
+R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
+9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
+fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
+iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
+1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
+bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
+MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
+ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
+uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
+Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
+tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
+PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
+hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
+5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
+-----END CERTIFICATE-----

data/spec/ssl/privateKey.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQCrUO6cm5QqdJLLcMIygeIzyBUYl7iWiHqPy6fmxzj3SsFbTAY8
+tXT8C2jh3cWi0qNGXuxwSK6pClFwkPmW5znjCPbq9Ifa6mAU4+NoCzjTCAWxY3K1
+p6eW2s1gA82JBJF9/X4umdx9NbkOeoZWselJa7K0hztjOSBZXjXNfMYOiQIDAQAB
+AoGBAI0I/rdc+XiOKb9kH+u2s8NPZ9asKSF8T/ILhjleL46eM1p21veppxpMRlcT
+3T2zTQmE4f96RpgRT4RtRZyu1R6zaSuVlmnKeD8BwEFgYaJUNBHyJuiG2f59gD5f
+S09NOXqvHQVMxUKYm9GZ3IG9TVQkpZlytXg8Y1SIHI9Cz8jRAkEA2CTGVWLuke/Z
+T+40+TSAbxOpXt7zyq1CO/jp7NsAy3MLIv3GHgxVzcK8tsAEyvPvRSnmMFdciZCx
+5yTfFMHt1QJBAMroCmhLJWcwpjH5mO4kD/1eZNre1j5ZgGTt9fiIxo8Gns6kDLWX
+7iLZ5sAdqle9KUm4BZKvnBtwFkBAwf9Pk+UCQBbdhRHBXoWXvwCCrZ3zXObjSJad
+tWKqg4g+o9iHroTXTcVM3WmOWoFi6X3XwGoL9jL15MEWbNastPVD5EmY3mUCQBj4
+Pzegb8ToHrutrJ05wOH8OMsaeyEHIJ7LDeb85fp55Rcm5w192edeC2B/BhRwCeGx
+jLYFeF+EBqj3jygdIeUCQGExaHBVu0nTHY9CnvJOjc2hs/I3TPwgXzm8rBisGm5W
+g0eJhfZ1uJ+oHaKhoTRgB6OOUVnpugx83vYvYiKj+1M=
+-----END RSA PRIVATE KEY-----

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
 
@@ -66,6 +66,25 @@ describe Braintree::Address do
         Braintree::Address.find("spaces not allowed", "address_id")
       end.to raise_error(ArgumentError, "customer_id contains invalid characters")
     end
+
+    it "raises an error if address_id is blank" do
+      expect do
+        Braintree::Address.find("customer_id", "")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises an error if address_id is blank" do
+      expect do
+        Braintree::Address.find("customer_id", nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not raise an error if address_id does not respond to strip" do
+      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
+    end
   end
 
   describe "self.new" do
@@ -75,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

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ApplePayCard do
+  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",
+      :prepaid_reloadable => "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
+      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
+      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
+      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
+      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

@@ -0,0 +1,37 @@
+
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Braintree
+  describe ClientToken do
+    describe "self.generate" do
+      it "delegates to ClientTokenGateway#generate" do
+        options = {:foo => :bar}
+        client_token_gateway = double(: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 {
+          Braintree::ClientToken.generate(
+            :public_key => "bad_key",
+            :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 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,
+            )
+          end.to raise_error(ArgumentError, /#{option_name}/)
+        end
+      end
+    end
+  end
+end