braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/us_bank_account_verification_spec.rb

@@ -0,0 +1,240 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::UsBankAccountVerification do
+  let(:nonce) { generate_non_plaid_us_bank_account_nonce }
+  let(:customer) do
+    params = {
+      :first_name => "Tom",
+      :last_name => "Smith",
+      :email => "tom.smith@example.com",
+    }
+
+    Braintree::Customer.create(params).customer
+  end
+
+  describe "self.confirm_micro_transfer_amounts" do
+    before do
+      Braintree::Configuration.merchant_id = "integration2_merchant_id"
+      Braintree::Configuration.public_key = "integration2_public_key"
+      Braintree::Configuration.private_key = "integration2_private_key"
+    end
+
+    after(:all) do
+      Braintree::Configuration.merchant_id = "integration_merchant_id"
+      Braintree::Configuration.public_key = "integration_public_key"
+      Braintree::Configuration.private_key = "integration_private_key"
+    end
+
+    context "with a micro transfer verification" do
+      it "successfully confirms settled amounts" do
+        nonce = generate_non_plaid_us_bank_account_nonce("1000000000")
+
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
+
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [17, 29])
+
+        expect(response).to be_success
+        expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+
+        us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account[:token])
+
+        expect(us_bank_account.verified).to be_truthy
+      end
+
+      it "successfully confirms not-yet-settled amounts" do
+        nonce = generate_non_plaid_us_bank_account_nonce("1000000001")
+
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
+
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [17, 29])
+
+        expect(response).to be_success
+        expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
+      end
+
+      it "attempts to confirm" do
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
+
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
+
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch)
+      end
+
+      it "exceeds the confirmation attempt threshold" do
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+
+        response = nil
+        4.times do
+          response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
+
+          expect(response).not_to be_success
+          expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch)
+        end
+
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts)
+
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts)
+      end
+
+      it "returns an error for invalid deposit amounts" do
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, ["abc"])
+
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::InvalidDepositAmounts)
+      end
+    end
+
+    context "non-micro transfer" do
+      it "rejects for incorrect verification type" do
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+          },
+        )
+
+        expect(result).to be_success
+
+        verification = result.payment_method.verifications.first
+        response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
+
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::MustBeMicroTransfersVerification)
+      end
+    end
+  end
+
+  describe "self.find" do
+    it "finds the verification with the given id" do
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        },
+      )
+
+      expect(result).to be_success
+
+      created_verification = result.payment_method.verifications.first
+      found_verification = Braintree::UsBankAccountVerification.find(created_verification.id)
+
+      expect(found_verification).to eq(created_verification)
+    end
+
+    it "raises a NotFoundError exception if verification cannot be found" do
+      expect do
+        Braintree::UsBankAccountVerification.find("invalid-id")
+      end.to raise_error(Braintree::NotFoundError, 'verification with id "invalid-id" not found')
+    end
+  end
+
+  describe "self.search" do
+    let(:payment_method) do
+      Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        },
+      ).payment_method
+    end
+
+    let(:created_verification) do
+      payment_method.verifications.first
+    end
+
+    it "searches and finds verification using verification fields" do
+      found_verifications = Braintree::UsBankAccountVerification.search do |search|
+        search.created_at >= (Time.now() - 120)
+        search.ids.in created_verification.id
+        search.status.in created_verification.status
+        search.verification_method.in created_verification.verification_method
+      end
+
+      expect(found_verifications).to include(created_verification)
+    end
+
+    it "searches and finds verifications using customer fields" do
+      found_verifications = Braintree::UsBankAccountVerification.search do |search|
+        search.customer_email.is customer.email
+        search.customer_id.is customer.id
+        search.payment_method_token.is payment_method.token
+      end
+
+      expect(found_verifications.count).to eq(1)
+    end
+  end
+end

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::VisaCheckoutCard do
+  it "can create from payment method nonce" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id,
+    )
+    expect(result).to be_success
+
+    visa_checkout_card = result.payment_method
+    expect(visa_checkout_card).to be_a(Braintree::VisaCheckoutCard)
+    expect(visa_checkout_card.call_id).to eq("abc123")
+    expect(visa_checkout_card.billing_address).not_to be_nil
+    expect(visa_checkout_card.bin).not_to be_nil
+    expect(visa_checkout_card.card_type).not_to be_nil
+    expect(visa_checkout_card.cardholder_name).not_to be_nil
+    expect(visa_checkout_card.commercial).not_to be_nil
+    expect(visa_checkout_card.country_of_issuance).not_to be_nil
+    expect(visa_checkout_card.created_at).not_to be_nil
+    expect(visa_checkout_card.customer_id).not_to be_nil
+    expect(visa_checkout_card.customer_location).not_to be_nil
+    expect(visa_checkout_card.debit).not_to be_nil
+    expect(visa_checkout_card.default?).not_to be_nil
+    expect(visa_checkout_card.durbin_regulated).not_to be_nil
+    expect(visa_checkout_card.expiration_date).not_to be_nil
+    expect(visa_checkout_card.expiration_month).not_to be_nil
+    expect(visa_checkout_card.expiration_year).not_to be_nil
+    expect(visa_checkout_card.expired?).not_to be_nil
+    expect(visa_checkout_card.healthcare).not_to be_nil
+    expect(visa_checkout_card.image_url).not_to be_nil
+    expect(visa_checkout_card.issuing_bank).not_to be_nil
+    expect(visa_checkout_card.last_4).not_to be_nil
+    expect(visa_checkout_card.payroll).not_to be_nil
+    expect(visa_checkout_card.prepaid).not_to be_nil
+    expect(visa_checkout_card.product_id).not_to be_nil
+    expect(visa_checkout_card.subscriptions).not_to be_nil
+    expect(visa_checkout_card.token).not_to be_nil
+    expect(visa_checkout_card.unique_number_identifier).not_to be_nil
+    expect(visa_checkout_card.updated_at).not_to be_nil
+
+    customer = Braintree::Customer.find(customer.id)
+    expect(customer.visa_checkout_cards.size).to eq(1)
+    expect(customer.visa_checkout_cards.first).to eq(visa_checkout_card)
+  end
+
+  it "can create with verification" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id,
+      :options => {:verify_card => true},
+    )
+    expect(result).to be_success
+    expect(result.payment_method.verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
+  end
+
+  it "can search for transactions" do
+    transaction_create_result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :amount => "47.00",
+    )
+    expect(transaction_create_result).to be_success
+    transaction_id = transaction_create_result.transaction.id
+
+    search_results = Braintree::Transaction.search do |search|
+      search.id.is transaction_id
+      search.payment_instrument_type.is Braintree::PaymentInstrumentType::VisaCheckoutCard
+    end
+    expect(search_results.first.id).to eq(transaction_id)
+  end
+
+  it "can create transaction from nonce and vault" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id,
+      :amount => "47.00",
+      :options => {:store_in_vault => true},
+    )
+    expect(result).to be_success
+
+    visa_checkout_card_details = result.transaction.visa_checkout_card_details
+    expect(visa_checkout_card_details.call_id).to eq("abc123")
+    expect(visa_checkout_card_details.bin).not_to be_nil
+    expect(visa_checkout_card_details.card_type).not_to be_nil
+    expect(visa_checkout_card_details.cardholder_name).not_to be_nil
+    expect(visa_checkout_card_details.commercial).not_to be_nil
+    expect(visa_checkout_card_details.country_of_issuance).not_to be_nil
+    expect(visa_checkout_card_details.customer_location).not_to be_nil
+    expect(visa_checkout_card_details.debit).not_to be_nil
+    expect(visa_checkout_card_details.durbin_regulated).not_to be_nil
+    expect(visa_checkout_card_details.expiration_date).not_to be_nil
+    expect(visa_checkout_card_details.expiration_month).not_to be_nil
+    expect(visa_checkout_card_details.expiration_year).not_to be_nil
+    expect(visa_checkout_card_details.healthcare).not_to be_nil
+    expect(visa_checkout_card_details.image_url).not_to be_nil
+    expect(visa_checkout_card_details.issuing_bank).not_to be_nil
+    expect(visa_checkout_card_details.last_4).not_to be_nil
+    expect(visa_checkout_card_details.payroll).not_to be_nil
+    expect(visa_checkout_card_details.prepaid).not_to be_nil
+    expect(visa_checkout_card_details.product_id).not_to be_nil
+    expect(visa_checkout_card_details.token).not_to be_nil
+  end
+end

data/spec/integration/spec_helper.rb

@@ -1,8 +1,10 @@
+require "securerandom"
+
 unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
   INTEGRATION_SPEC_HELPER_LOADED = true
+  SSL_TEST_PORT = ENV["SSL_TEST_PORT"] || 8444
 
   require File.dirname(__FILE__) + "/../spec_helper"
-  require File.dirname(__FILE__) + "/../hacks/tcp_socket"
 
   def start_ssl_server
     web_server_pid_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "httpsd.pid"))
@@ -10,11 +12,65 @@ unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
     FileUtils.rm(web_server_pid_file) if File.exist?(web_server_pid_file)
     command = File.expand_path(File.join(File.dirname(__FILE__), "..", "script", "httpsd.rb"))
     `#{command} #{web_server_pid_file}`
-    TCPSocket.wait_for_service :host => "127.0.0.1", :port => 8443
-
-    yield
+    TCPSocket.new("127.0.0.1",SSL_TEST_PORT)
 
-    10.times { unless File.exists?(web_server_pid_file); sleep 1; end }
+    10.times { unless File.exist?(web_server_pid_file); sleep 1; end }
+  ensure
     Process.kill "INT", File.read(web_server_pid_file).to_i
   end
+
+  def create_modification_for_tests(attributes)
+    config = Braintree::Configuration.instantiate
+    config.http.post("#{config.base_merchant_path}/modifications/create_modification_for_tests", :modification => attributes)
+  end
+
+  def with_other_merchant(merchant_id, public_key, private_key, &block)
+    old_merchant_id = Braintree::Configuration.merchant_id
+    old_public_key = Braintree::Configuration.public_key
+    old_private_key = Braintree::Configuration.private_key
+
+    Braintree::Configuration.merchant_id = merchant_id
+    Braintree::Configuration.public_key = public_key
+    Braintree::Configuration.private_key = private_key
+
+    begin
+      yield
+    ensure
+      Braintree::Configuration.merchant_id = old_merchant_id
+      Braintree::Configuration.public_key = old_public_key
+      Braintree::Configuration.private_key = old_private_key
+    end
+  end
+
+  def with_advanced_fraud_kount_integration_merchant(&block)
+    with_other_merchant("advanced_fraud_integration_merchant_id", "advanced_fraud_integration_public_key", "advanced_fraud_integration_private_key") do
+      block.call
+    end
+  end
+
+  def with_fraud_protection_enterprise_merchant(&block)
+    with_other_merchant("fraud_protection_enterprise_integration_merchant_id", "fraud_protection_enterprise_integration_public_key", "fraud_protection_enterprise_integration_private_key") do
+      block.call
+    end
+  end
+
+  def with_chargeback_protection_merchant(&block)
+    with_other_merchant("fraud_protection_effortless_chargeback_protection_merchant_id", "effortless_chargeback_protection_public_key", "effortless_chargeback_protection_private_key") do
+      block.call
+    end
+  end
+
+  def with_altpay_merchant(&block)
+    with_other_merchant("altpay_merchant", "altpay_merchant_public_key", "altpay_merchant_private_key", &block)
+  end
+
+  def random_payment_method_token
+    "payment-method-token-#{SecureRandom.hex(6)}"
+  end
+
+  def with_duplicate_checking_merchant(&block)
+    with_other_merchant("dup_checking_integration_merchant_id", "dup_checking_integration_public_key", "dup_checking_integration_private_key") do
+      block.call
+    end
+  end
 end

data/spec/oauth_test_helper.rb

@@ -0,0 +1,17 @@
+module Braintree
+  class OAuthTestHelper
+    def self.create_grant(gateway, params)
+      response = gateway.config.http.post("/oauth_testing/grants", {
+        :grant => params
+      })
+      response[:grant][:code]
+    end
+
+    def self.create_token(gateway, params)
+      code = create_grant(gateway, params)
+      gateway.oauth.create_token_from_code(
+        :code => code,
+      )
+    end
+  end
+end

data/spec/script/httpsd.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-require 'webrick'
-require 'webrick/https'
-require 'openssl'
+require "webrick"
+require "webrick/https"
+require "openssl"
 
 private_key_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "ssl", "privateKey.key"))
 cert_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "ssl", "certificate.crt"))
@@ -12,7 +12,7 @@ cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
 pid_file = ARGV[0]
 
 s = WEBrick::HTTPServer.new(
-  :Port => 8443,
+  :Port => (ENV["SSL_TEST_PORT"] || 8444),
   :Logger => WEBrick::Log::new(nil, WEBrick::Log::ERROR),
   :DocumentRoot => File.join(File.dirname(__FILE__)),
   :ServerType => WEBrick::Daemon,
@@ -21,7 +21,7 @@ s = WEBrick::HTTPServer.new(
   :SSLCertificate => cert,
   :SSLPrivateKey => pkey,
   :SSLCertName => [ [ "CN",WEBrick::Utils::getservername ] ],
-  :StartCallback => proc { File.open(pid_file, "w") { |f| f.write $$.to_s }}
+  :StartCallback => proc { File.open(pid_file, "w") { |f| f.write $$.to_s } },
 )
-trap("INT"){ s.shutdown }
+trap("INT") { s.shutdown }
 s.start

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--format progress
+--loadby mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -1,14 +1,16 @@
 unless defined?(SPEC_HELPER_LOADED)
   SPEC_HELPER_LOADED = true
-
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
-  gem "libxml-ruby", ENV["LIBXML_VERSION"] || "1.1.3"
+  require "bundler/setup"
   require "libxml"
-  gem "builder", ENV["BUILDER_VERSION"] || "2.1.2"
+  require "rspec"
+  require "pry"
+
   braintree_lib = "#{project_root}/lib"
   $LOAD_PATH << braintree_lib
   require "braintree"
+  require File.dirname(__FILE__) + "/oauth_test_helper"
 
   Braintree::Configuration.environment = :development
   Braintree::Configuration.merchant_id = "integration_merchant_id"
@@ -28,13 +30,25 @@ unless defined?(SPEC_HELPER_LOADED)
 
   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"
+    UsBankMerchantAccountId = "us_bank_merchant_account"
 
     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
@@ -43,14 +57,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
@@ -59,7 +73,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
     }
 
@@ -71,14 +85,46 @@ unless defined?(SPEC_HELPER_LOADED)
     Discount11 = "discount_11"
     Discount15 = "discount_15"
 
+    DefaultOrderId = "ABC123"
+
+    TestMerchantConfig = Braintree::Configuration.new(
+                                                      :logger => Logger.new("/dev/null"),
+                                                      :environment => Braintree::Configuration.environment,
+                                                      :merchant_id => "test_merchant_id",
+                                                      :public_key => "test_public_key",
+                                                      :private_key => "test_private_key",
+                                                      )
+
     def self.make_past_due(subscription, number_of_days_past_due = 1)
-      Braintree::Configuration.instantiate.http.put(
-        "/subscriptions/#{subscription.id}/make_past_due?days_past_due=#{number_of_days_past_due}"
+      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}",
       )
     end
 
     def self.settle_transaction(transaction_id)
-      Braintree::Configuration.instantiate.http.put("/transactions/#{transaction_id}/settle")
+      config = Braintree::Configuration.instantiate
+      config.http.put("#{config.base_merchant_path}/transactions/#{transaction_id}/settle")
+    end
+
+    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_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"),
+      )
+
+      gateway.merchant.create({
+        :email => "name@email.com",
+        :country_code_alpha3 => "GBR",
+        :payment_methods => ["credit_card", "paypal"],
+      }.merge!(params))
     end
 
     def self.stub_time_dot_now(desired_time)
@@ -101,7 +147,10 @@ unless defined?(SPEC_HELPER_LOADED)
 
     def self.simulate_form_post_for_tr(tr_data_string, form_data_hash, url = Braintree::TransparentRedirect.url)
       response = nil
-      Net::HTTP.start("localhost", Braintree::Configuration.instantiate.port) do |http|
+      config = Braintree::Configuration.instantiate
+      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))
@@ -139,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
@@ -158,7 +202,7 @@ unless defined?(SPEC_HELPER_LOADED)
         "xml parsing failed for #{@failed_parser}, expected #{@expected_hash.inspect} but was #{@results.inspect}"
       end
 
-      def negative_failure_message
+      def failure_message_when_negated
         raise NotImplementedError
       end
     end
@@ -167,9 +211,21 @@ unless defined?(SPEC_HELPER_LOADED)
       ParseTo.new(hash)
     end
   end
+end
 
-  Spec::Runner.configure do |config|
-    config.include CustomMatchers
+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
-end
 
+  config.expect_with :rspec do |expect|
+    expect.syntax = [:should, :expect]
+  end
+
+  config.mock_with :rspec do |mock|
+    mock.syntax = [:should, :expect]
+  end
+end