braintree 2.74.0 → 4.12.0

data/spec/spec_helper.rb

@@ -3,8 +3,9 @@ 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"
   $LOAD_PATH << braintree_lib
@@ -27,10 +28,6 @@ unless defined?(SPEC_HELPER_LOADED)
     end
   end
 
-  def now_in_eastern
-    (Time.now.utc - 5*60*60).strftime("%Y-%m-%d")
-  end
-
   module SpecHelper
 
     DefaultMerchantAccountId = "sandbox_credit_card"
@@ -39,13 +36,18 @@ unless defined?(SPEC_HELPER_LOADED)
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
     FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
     FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
-    UsBankMerhantAccountId = "us_bank_merchant_account"
-    IdealMerchantAccountId = "ideal_merchant_account"
+    UsBankMerchantAccountId = "us_bank_merchant_account"
+    AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
+    AdyenMerchantAccountId = "adyen_ma"
+    HiperBRLMerchantAccountId = "hiper_brl"
+    CardProcessorBRLMerchantAccountId = "card_processor_brl"
+    FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
+    AibSwedenMaMerchantAccountId = "aib_swe_ma"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",
       :id => "integration_trial_plan",
-      :price => BigDecimal.new("43.21"),
+      :price => BigDecimal("43.21"),
       :trial_period => true,
       :trial_duration => 2,
       :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
@@ -54,14 +56,14 @@ unless defined?(SPEC_HELPER_LOADED)
     TriallessPlan = {
       :description => "Plan for integration tests -- without a trial",
       :id => "integration_trialless_plan",
-      :price => BigDecimal.new("12.34"),
+      :price => BigDecimal("12.34"),
       :trial_period => false
     }
 
     AddOnDiscountPlan = {
       :description => "Plan for integration tests -- with add-ons and discounts",
       :id => "integration_plan_with_add_ons_and_discounts",
-      :price => BigDecimal.new("9.99"),
+      :price => BigDecimal("9.99"),
       :trial_period => true,
       :trial_duration => 2,
       :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
@@ -70,7 +72,7 @@ unless defined?(SPEC_HELPER_LOADED)
     BillingDayOfMonthPlan = {
       :description => "Plan for integration tests -- with billing day of month",
       :id => "integration_plan_with_billing_day_of_month",
-      :price => BigDecimal.new("8.88"),
+      :price => BigDecimal("8.88"),
       :billing_day_of_month => 5
     }
 
@@ -89,13 +91,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
 
@@ -107,14 +109,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({
@@ -145,8 +147,9 @@ unless defined?(SPEC_HELPER_LOADED)
     def self.simulate_form_post_for_tr(tr_data_string, form_data_hash, url = Braintree::TransparentRedirect.url)
       response = nil
       config = Braintree::Configuration.instantiate
-      Net::HTTP.start(config.server, config.port) do |http|
-        http.use_ssl = config.ssl?
+      http = Net::HTTP.new(config.server, config.port)
+      http.use_ssl = config.ssl?
+      http.start do |http|
         request = Net::HTTP::Post.new("/" + url.split("/", 4)[3])
         request.add_field "Content-Type", "application/x-www-form-urlencoded"
         request.body = Braintree::Util.hash_to_query_string({:tr_data => tr_data_string}.merge(form_data_hash))
@@ -184,16 +187,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
@@ -217,6 +215,11 @@ end
 RSpec.configure do |config|
   config.include CustomMatchers
 
+  if ENV["JUNIT"] == "1"
+    config.add_formatter("RspecJunitFormatter", "tmp/build/braintree-ruby.#{rand}.junit.xml")
+    config.add_formatter("progress")
+  end
+
   config.expect_with :rspec do |expect|
     expect.syntax = [:should, :expect]
   end

data/spec/unit/braintree/address_spec.rb

@@ -3,7 +3,7 @@ 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
@@ -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,23 +1,123 @@
 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",
+      :payment_instrument_name => nil,
+      :payroll => "No",
+      :prepaid => "No",
+      :product_id => "MAC",
+      :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
+  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/client_token_spec.rb

@@ -16,7 +16,7 @@ module Braintree
         expect {
           client_token = Braintree::ClientToken.generate(
             :public_key => "bad_key",
-            :created_at => "bad_time"
+            :created_at => "bad_time",
           )
         }.to raise_error(ArgumentError, /created_at, public_key/)
       end
@@ -27,7 +27,7 @@ module Braintree
         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

data/spec/unit/braintree/configuration_spec.rb

@@ -1,3 +1,5 @@
+require "stringio"
+
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::Configuration do
@@ -20,26 +22,26 @@ describe Braintree::Configuration do
   describe "initialize" do
     it "accepts merchant credentials" do
       config = Braintree::Configuration.new(
-        :merchant_id => 'merchant_id',
-        :public_key => 'public_key',
-        :private_key => 'private_key'
+        :merchant_id => "merchant_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
       )
 
-      config.merchant_id.should == 'merchant_id'
-      config.public_key.should == 'public_key'
-      config.private_key.should == 'private_key'
+      config.merchant_id.should == "merchant_id"
+      config.public_key.should == "public_key"
+      config.private_key.should == "private_key"
     end
 
     it "accepts partner credentials" do
       config = Braintree::Configuration.new(
-        :partner_id => 'partner_id',
-        :public_key => 'public_key',
-        :private_key => 'private_key'
+        :partner_id => "partner_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
       )
 
-      config.merchant_id.should == 'partner_id'
-      config.public_key.should == 'public_key'
-      config.private_key.should == 'private_key'
+      config.merchant_id.should == "partner_id"
+      config.public_key.should == "public_key"
+      config.private_key.should == "private_key"
     end
 
     it "raises if combining client_id/secret with access_token" do
@@ -47,7 +49,7 @@ describe Braintree::Configuration do
         Braintree::Configuration.new(
           :client_id => "client_id$development$integration_client_id",
           :client_secret => "client_secret$development$integration_client_secret",
-          :access_token => "access_token$development$integration_merchant_id$fb27c79dd"
+          :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
         )
       end.to raise_error(Braintree::ConfigurationError, /mixed credential types/)
     end
@@ -60,28 +62,55 @@ describe Braintree::Configuration do
           :merchant_id => "merchant_id",
           :public_key => "public_key",
           :private_key => "private_key",
-          :environment => "development"
+          :environment => "development",
         )
       end.to raise_error(Braintree::ConfigurationError, /mixed credential types/)
     end
 
+    context "mixed environments" do
+      before do
+        @original_stderr = $stderr
+        $stderr = StringIO.new
+      end
+
+      after do
+        $stderr = @original_stderr
+      end
+
+      it "warns if both environment and access_token are provided and their environments differ" do
+        Braintree::Configuration.new(
+          :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
+          :environment => "sandbox",
+        )
+        $stderr.string.should == "Braintree::Gateway should not be initialized with mixed environments: environment parameter and access_token do not match, environment from access_token is used.\n"
+      end
+
+      it "does not warn if both environment and access_token are provided and their environments match" do
+        Braintree::Configuration.new(
+          :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
+          :environment => "development",
+        )
+        $stderr.string.should == ""
+      end
+    end
+
     it "accepts proxy params" do
       config = Braintree::Configuration.new(
-        :proxy_address => 'localhost',
+        :proxy_address => "localhost",
         :proxy_port => 8080,
-        :proxy_user => 'user',
-        :proxy_pass => 'test'
+        :proxy_user => "user",
+        :proxy_pass => "test",
       )
 
-      config.proxy_address.should == 'localhost'
+      config.proxy_address.should == "localhost"
       config.proxy_port.should == 8080
-      config.proxy_user.should == 'user'
-      config.proxy_pass.should == 'test'
+      config.proxy_user.should == "user"
+      config.proxy_pass.should == "test"
     end
 
     it "accepts ssl version" do
       config = Braintree::Configuration.new(
-        :ssl_version => :TLSv1_2
+        :ssl_version => :TLSv1_2,
       )
 
       config.ssl_version.should == :TLSv1_2
@@ -117,14 +146,14 @@ describe Braintree::Configuration do
       Braintree::Configuration.environment = :sandbox
       ca_file = Braintree::Configuration.instantiate.ca_file
       ca_file.should match(/api_braintreegateway_com\.ca\.crt$/)
-      File.exists?(ca_file).should == true
+      File.exist?(ca_file).should == true
     end
 
     it "production" do
       Braintree::Configuration.environment = :production
       ca_file = Braintree::Configuration.instantiate.ca_file
       ca_file.should match(/api_braintreegateway_com\.ca\.crt$/)
-      File.exists?(ca_file).should == true
+      File.exist?(ca_file).should == true
     end
   end
 
@@ -138,6 +167,19 @@ describe Braintree::Configuration do
       config = Braintree::Configuration.new :logger => nil
       config.logger.should_not == nil
     end
+
+    it "can set logger on gateway instance" do
+      gateway = Braintree::Configuration.gateway
+      old_logger = Braintree::Configuration.logger
+
+      new_logger = Logger.new("/dev/null")
+
+      gateway.config.logger = new_logger
+
+      expect(gateway.config.logger).to eq(new_logger)
+
+      gateway.config.logger = old_logger
+    end
   end
 
   describe "self.environment" do
@@ -154,6 +196,14 @@ describe Braintree::Configuration do
         Braintree::Configuration.environment
       end.to raise_error(Braintree::ConfigurationError, "Braintree::Configuration.environment needs to be set")
     end
+
+    it "converts environment to symbol" do
+      config = Braintree::Configuration.new({
+        :environment => "sandbox"
+      })
+
+      expect(config.environment).to eq(:sandbox)
+    end
   end
 
   describe "self.gateway" do
@@ -188,12 +238,12 @@ describe Braintree::Configuration do
 
     it "allows the environment to be set with a string value" do
       expect do
-        Braintree::Configuration.environment = 'sandbox'
+        Braintree::Configuration.environment = "sandbox"
       end.not_to raise_error
     end
 
     it "sets the environment as a symbol" do
-      Braintree::Configuration.environment = 'sandbox'
+      Braintree::Configuration.environment = "sandbox"
       expect(Braintree::Configuration.environment).to eq :sandbox
     end
   end
@@ -276,15 +326,15 @@ describe Braintree::Configuration do
 
     it "is 3000 or GATEWAY_PORT environment variable for development" do
       Braintree::Configuration.environment = :development
-      old_gateway_port = ENV['GATEWAY_PORT']
+      old_gateway_port = ENV["GATEWAY_PORT"]
       begin
-        ENV['GATEWAY_PORT'] = nil
+        ENV["GATEWAY_PORT"] = nil
         Braintree::Configuration.instantiate.port.should == 3000
 
-        ENV['GATEWAY_PORT'] = '1234'
-        Braintree::Configuration.instantiate.port.should == '1234'
+        ENV["GATEWAY_PORT"] = "1234"
+        Braintree::Configuration.instantiate.port.should == "1234"
       ensure
-        ENV['GATEWAY_PORT'] = old_gateway_port
+        ENV["GATEWAY_PORT"] = old_gateway_port
       end
     end
   end
@@ -306,10 +356,35 @@ describe Braintree::Configuration do
     end
   end
 
+  describe "graphql_server" do
+    it "is localhost or GRAPHQL_HOST environment variable for development" do
+      Braintree::Configuration.environment = :development
+      old_gateway_url = ENV["GRAPHQL_HOST"]
+      begin
+        ENV["GRAPHQL_HOST"] = nil
+        Braintree::Configuration.instantiate.graphql_server.should == "graphql.bt.local"
+
+        ENV["GRAPHQL_HOST"] = "gateway"
+        Braintree::Configuration.instantiate.graphql_server.should == "gateway"
+      ensure
+        ENV["GRAPHQL_HOST"] = old_gateway_url
+      end
+    end
+  end
+
   describe "server" do
-    it "is localhost for development" do
+    it "is localhost or GATEWAY_HOST environment variable for development" do
       Braintree::Configuration.environment = :development
-      Braintree::Configuration.instantiate.server.should == "localhost"
+      old_gateway_url = ENV["GATEWAY_HOST"]
+      begin
+        ENV["GATEWAY_HOST"] = nil
+        Braintree::Configuration.instantiate.server.should == "localhost"
+
+        ENV["GATEWAY_HOST"] = "gateway"
+        Braintree::Configuration.instantiate.server.should == "gateway"
+      ensure
+        ENV["GATEWAY_HOST"] = old_gateway_url
+      end
     end
 
     it "is api.braintreegateway.com for production" do
@@ -393,7 +468,7 @@ describe Braintree::Configuration do
     it "masks the private_key" do
       config = Braintree::Configuration.new(:private_key => "secret_key")
       config.inspect.should include('@private_key="[FILTERED]"')
-      config.inspect.should_not include('secret_key')
+      config.inspect.should_not include("secret_key")
     end
   end