braintree 2.90.0 → 2.91.0

data/spec/integration/braintree/http_spec.rb

@@ -18,7 +18,7 @@ describe Braintree::Http do
     it "raises an AuthorizationError if authorization fails" do
       expect do
         config = Braintree::Configuration.instantiate
-        config.http.get("#{config.base_merchant_path}/downloads")
+        config.http.get("#{config.base_merchant_path}/home")
       end.to raise_error(Braintree::AuthorizationError)
     end
   end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -293,6 +293,25 @@ describe Braintree::Transaction, "search" do
         collection.maximum_size.should == 0
       end
 
+      it "searches for an Elo card" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::AdyenMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Elo,
+            :cvv => "737",
+            :expiration_date => "10/2020"
+          }
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.credit_card_card_type.is Braintree::CreditCard::CardType::Elo
+        end
+
+        collection.maximum_size.should == 1
+      end
+
       it "searches by payment instrument type CreditCardDetail" do
         transaction = Braintree::Transaction.sale!(
           :amount => Braintree::Test::TransactionAmounts::Authorize,

data/spec/integration/braintree/transaction_spec.rb

@@ -248,6 +248,31 @@ describe Braintree::Transaction do
       end
     end
 
+    context "elo" do
+      it "returns a successful result if successful" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::AdyenMerchantAccountId,
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Elo,
+            :cvv => "737",
+            :expiration_date => "10/2020"
+          }
+        )
+        result.success?.should == true
+        result.transaction.id.should =~ /^\w{6,}$/
+        result.transaction.type.should == "sale"
+        result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
+        result.transaction.processor_authorization_code.should_not be_nil
+        result.transaction.voice_referral_number.should be_nil
+        result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Elo[0, 6]
+        result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Elo[-4..-1]
+        result.transaction.credit_card_details.expiration_date.should == "10/2020"
+        result.transaction.credit_card_details.customer_location.should == "US"
+      end
+    end
+
     it "returns a successful result if successful" do
       result = Braintree::Transaction.create(
         :type => "sale",
@@ -3617,6 +3642,182 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).on(:ships_from_postal_code)[0].code.should == Braintree::ErrorCodes::Transaction::ShipsFromPostalCodeInvalidCharacters
       end
     end
+
+    context "network_transaction_id" do
+      it "receives network_transaction_id for visa transaction" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+        )
+        result.success?.should == true
+        result.transaction.network_transaction_id.should_not be_nil
+      end
+    end
+
+    context "external vault" do
+      it "returns a validation error if used with an unsupported instrument type" do
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :customer_id => customer.id
+        )
+        payment_method_token = result.payment_method.token
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :customer_id => customer.id,
+          :payment_method_token => payment_method_token,
+          :external_vault => {
+            :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+          },
+          :amount => "10.00",
+        )
+        result.success?.should == false
+        result.errors.for(:transaction)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentInstrumentWithExternalVaultIsInvalid
+      end
+
+      it "reject invalid status" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "05/2009"
+          },
+          :external_vault => {
+            :status => "not_valid",
+          },
+          :amount => "10.00",
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:external_vault).on(:status)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::StatusIsInvalid
+      end
+
+      context "Visa" do
+        it "accepts status" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == true
+          result.transaction.network_transaction_id.should_not be_nil
+        end
+
+        it "accepts previous_network_transaction_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_network_transaction_id => "123456789012345",
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == true
+          result.transaction.network_transaction_id.should_not be_nil
+        end
+
+        it "rejects non-vaulted status with previous_network_transaction_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+              :previous_network_transaction_id => "123456789012345",
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).for(:external_vault).on(:status)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::StatusWithPreviousNetworkTransactionIdIsInvalid
+        end
+
+        it "rejects invalid previous_network_transaction_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_network_transaction_id => "not_and_valid_id",
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).for(:external_vault).on(:previous_network_transaction_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::PreviousNetworkTransactionIdIsInvalid
+        end
+      end
+
+      context "Non-Visa" do
+        it "accepts status" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == true
+          result.transaction.network_transaction_id.should be_nil
+        end
+
+        it "accepts blank previous_network_transaction_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_network_transaction_id => "",
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == true
+          result.transaction.network_transaction_id.should be_nil
+        end
+
+        it "rejects previous_network_transaction_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Discover,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_network_transaction_id => "123456789012345",
+            },
+            :amount => "10.00",
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).for(:external_vault).on(:previous_network_transaction_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::CardTypeIsInvalid
+        end
+      end
+
+    end
   end
 
   describe "self.create!" do
@@ -4808,8 +5009,8 @@ describe Braintree::Transaction do
     it "returns an error with an invalid payment instrument type" do
       authorized_transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover
+        :merchant_account_id => SpecHelper::FakeVenmoAccountMerchantAccountId,
+        :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount
       )
 
       result = Braintree::Transaction.submit_for_partial_settlement(authorized_transaction.id, 100)

data/spec/spec_helper.rb

@@ -42,6 +42,7 @@ unless defined?(SPEC_HELPER_LOADED)
     UsBankMerchantAccountId = "us_bank_merchant_account"
     AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
     IdealMerchantAccountId = "ideal_merchant_account"
+    AdyenMerchantAccountId = "adyen_ma"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",

data/spec/unit/braintree/configuration_spec.rb

@@ -167,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
@@ -183,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
@@ -335,6 +356,22 @@ 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 or GATEWAY_HOST environment variable for development" do
       Braintree::Configuration.environment = :development

data/spec/unit/braintree/http_spec.rb

@@ -59,7 +59,9 @@ END
 END
       Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
     end
+  end
 
+  describe "self._http_do" do
     it "connects when proxy address is specified" do
       config = Braintree::Configuration.new(
         :proxy_address => "localhost",
@@ -116,6 +118,69 @@ END
     end
   end
 
+  describe "_compose_headers" do
+    before (:each) do
+      config = Braintree::Configuration.new
+      @http = Braintree::Http.new(config)
+    end
+
+    it "returns a hash of default headers" do
+      default_headers = @http._compose_headers
+      expect(default_headers["Accept"]).to eq("application/xml")
+      expect(default_headers["Accept-Encoding"]).to eq("gzip")
+      expect(default_headers["Content-Type"]).to eq("application/xml")
+      expect(default_headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(default_headers["X-ApiVersion"]).to eq("5")
+    end
+
+    it "overwrites defaults with override headers" do
+      override_headers = {
+        "Accept" => "application/pdf",
+        "Authorization" => "token"
+      }
+      headers = @http._compose_headers(override_headers)
+      expect(headers["Accept"]).to eq("application/pdf")
+      expect(headers["Accept-Encoding"]).to eq("gzip")
+      expect(headers["Authorization"]).to eq("token")
+      expect(headers["Content-Type"]).to eq("application/xml")
+      expect(headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(headers["X-ApiVersion"]).to eq("5")
+    end
+
+    it "extends default headers when new headers are specified" do
+      override_headers = {
+        "New-Header" => "New Value"
+      }
+      headers = @http._compose_headers(override_headers)
+      expect(headers["Accept"]).to eq("application/xml")
+      expect(headers["Accept-Encoding"]).to eq("gzip")
+      expect(headers["Content-Type"]).to eq("application/xml")
+      expect(headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(headers["X-ApiVersion"]).to eq("5")
+      expect(headers["New-Header"]).to eq("New Value")
+    end
+  end
+
+  describe "_setup_connection" do
+    it "creates a new Net::HTTP object using default server and port" do
+      config = Braintree::Configuration.new
+      http = Braintree::Http.new(config)
+
+      connection = http._setup_connection
+      expect(connection.address).to eq(nil)
+      expect(connection.port).to eq(80)
+    end
+
+    it "overrides the default server and port when replacements are specified" do
+      config = Braintree::Configuration.new
+      http = Braintree::Http.new(config)
+
+      connection = http._setup_connection("localhost", 3443)
+      expect(connection.address).to eq("localhost")
+      expect(connection.port).to eq(3443)
+    end
+  end
+
   describe "_build_query_string" do
     it "returns an empty string for empty query params" do
       Braintree::Http.new(:config)._build_query_string({}).should == ""

data/spec/unit/braintree/local_payment_completed_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentCompleted do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentCompleted.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+      params = {
+        payment_id: "a-payment-id",
+        payer_id: "a-payer-id",
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      local_payment_completed.payment_id.should eq("a-payment-id")
+      local_payment_completed.payer_id.should eq("a-payer-id")
+    end
+  end
+end

data/spec/unit/braintree/transaction_spec.rb

@@ -255,6 +255,14 @@ describe Braintree::Transaction do
       )
       transaction.risk_data.should be_nil
     end
+
+    it "accepts network_transaction_id" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_transaction_id => "123456789012345"
+      )
+      transaction.network_transaction_id.should == "123456789012345"
+    end
   end
 
   describe "inspect" do

data/spec/unit/braintree/util_spec.rb

@@ -119,6 +119,58 @@ describe Braintree::Util do
     end
   end
 
+  describe "self.keys_valid?" do
+    it "returns true for wildcard matches" do
+      response = Braintree::Util.keys_valid?(
+        [:allowed, {:custom_fields => :_any_key_}],
+        :allowed => "ok",
+        :custom_fields => {
+          :custom_allowed => "ok",
+          :custom_allowed2 => "also ok",
+        }
+      )
+      expect(response).to eq(true)
+    end
+    it "raises an exception if the hash contains an invalid key" do
+      response = Braintree::Util.keys_valid?([:allowed], :allowed => "ok", :disallowed => "bad")
+      expect(response).to eq(false)
+    end
+
+    it "raises an exception with all keys listed if the hash contains invalid keys" do
+      response = Braintree::Util.keys_valid?([:allowed], :allowed => "ok", :disallowed => "bad", "also_invalid" => true)
+      expect(response).to eq(false)
+    end
+
+    it "returns false for invalid key inside of array" do
+      response = Braintree::Util.keys_valid?(
+        [{:add_ons => [{:update => [:amount]}, {:add => [:amount]}]}],
+        :add_ons => {
+          :update => [{:foo => 10}],
+          :add => [{:bar => 5}]
+        }
+      )
+      expect(response).to eq(false)
+    end
+
+    it "returns false if a deeply nested hash contains an invalid key" do
+      response = Braintree::Util.keys_valid?(
+        [:allowed, {:nested => [:nested_allowed, :nested_allowed2, {:deeply_allowed => [:super_deep_allowed]}]}],
+        :allowed => "ok",
+        :top_level_invalid => "bad",
+        :nested => {
+          :nested_allowed => "ok",
+          :nested_allowed2 => "also ok",
+          :nested_invalid => "bad",
+          :deeply_allowed => {
+            :super_deep_allowed => "yep",
+            :real_deep_invalid => "nope"
+          }
+        }
+      )
+      expect(response).to eq(false)
+    end
+  end
+
   describe "self._flatten_hash_keys" do
     it "flattens hash keys" do
       Braintree::Util._flatten_hash_keys(:nested => {
@@ -199,6 +251,63 @@ describe Braintree::Util do
     end
   end
 
+  describe "self.raise_exception_for_graphql_error" do
+    errors = {
+      "AUTHENTICATION" => Braintree::AuthenticationError,
+      "AUTHORIZATION" => Braintree::AuthorizationError,
+      "NOT_FOUND" => Braintree::NotFoundError,
+      "UNSUPPORTED_CLIENT" => Braintree::UpgradeRequiredError,
+      "RESOURCE_LIMIT" => Braintree::TooManyRequestsError,
+      "INTERNAL" => Braintree::ServerError,
+      "SERVICE_AVAILABILITY" => Braintree::DownForMaintenanceError,
+    }
+
+    errors.each do |graphQLError, exception|
+      it "raises an #{exception} when GraphQL returns an #{graphQLError} error" do
+        response = {
+          errors: [{
+            extensions: {
+              errorClass: graphQLError
+            }
+          }]
+        }
+        expect do
+          Braintree::Util.raise_exception_for_graphql_error(response)
+        end.to raise_error(exception)
+      end
+    end
+
+    it "does not raise an exception when GraphQL returns a validation error" do
+      response = {
+        errors: [{
+          extensions: {
+            errorClass: "VALIDATION"
+          }
+        }]
+      }
+      expect do
+        Braintree::Util.raise_exception_for_graphql_error(response)
+      end.to_not raise_error()
+    end
+
+    it "raises any non-validation errorClass response" do
+      response = {
+        errors: [{
+          extensions: {
+            errorClass: "VALIDATION"
+          }
+        }, {
+          extensions: {
+            errorClass: "NOT_FOUND"
+          }
+        }]
+      }
+      expect do
+        Braintree::Util.raise_exception_for_graphql_error(response)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+
   describe "self.raise_exception_for_status_code" do
     it "raises an AuthenticationError if authentication fails" do
       expect do