braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/us_bank_account_verification_search_spec.rb

@@ -7,7 +7,7 @@ describe Braintree::UsBankAccountVerification, "search" do
       search.account_holder_name.is "thisnameisnotreal"
     end
 
-    collection.maximum_size.should == 0
+    expect(collection.maximum_size).to eq(0)
   end
 
   let(:nonce) { generate_non_plaid_us_bank_account_nonce }
@@ -21,7 +21,7 @@ describe Braintree::UsBankAccountVerification, "search" do
       :customer_id => customer.id,
       :options => {
         :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-      }
+      },
     ).payment_method
     verification = payment_method.verifications.first
 
@@ -40,14 +40,14 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.id.is verification.id
         search.send(criterion).is value
       end
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.send(criterion).is "invalid_attribute"
       end
-      collection.should be_empty
+      expect(collection).to be_empty
     end
 
     collection = Braintree::UsBankAccountVerification.search do |search|
@@ -57,8 +57,8 @@ describe Braintree::UsBankAccountVerification, "search" do
       end
     end
 
-    collection.maximum_size.should == 1
-    collection.first.id.should == verification.id
+    expect(collection.maximum_size).to eq(1)
+    expect(collection.first.id).to eq(verification.id)
   end
 
   describe "multiple value fields" do
@@ -70,7 +70,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       ).payment_method
       verification1 = payment_method1.verifications.first
 
@@ -79,7 +79,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       ).payment_method
       verification2 = payment_method2.verifications.first
 
@@ -87,7 +87,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.ids.in verification1.id, verification2.id
       end
 
-      collection.maximum_size.should == 2
+      expect(collection.maximum_size).to eq(2)
     end
   end
 
@@ -100,7 +100,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       ).payment_method
       verification = payment_method.verifications.first
 
@@ -110,46 +110,46 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.id.is verification.id
         search.created_at.between(
           created_at - 60,
-          created_at + 60
+          created_at + 60,
         )
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at >= created_at - 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at <= created_at + 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at.between(
           created_at - 300,
-          created_at - 100
+          created_at - 100,
         )
       end
 
-      collection.maximum_size.should == 0
+      expect(collection.maximum_size).to eq(0)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at.is created_at
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
     end
   end
 
@@ -162,7 +162,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       ).payment_method
       verification = payment_method.verifications.first
 
@@ -171,8 +171,8 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.account_number.ends_with "0000"
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
     end
   end
 end

data/spec/integration/braintree/us_bank_account_verification_spec.rb

@@ -36,23 +36,23 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        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])
 
-        response.should be_success
-        response.us_bank_account_verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
+        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])
 
-        us_bank_account.verified.should be_truthy
+        expect(us_bank_account.verified).to be_truthy
       end
 
       it "successfully confirms not-yet-settled amounts" do
@@ -64,19 +64,19 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        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])
 
-        response.should be_success
-        response.us_bank_account_verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        expect(response).to be_success
+        expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
       end
 
       it "attempts to confirm" do
@@ -86,19 +86,19 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        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])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch
+        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
@@ -108,10 +108,10 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
 
@@ -119,17 +119,17 @@ describe Braintree::UsBankAccountVerification do
         4.times do
           response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
 
-          response.should_not be_success
-          response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch
+          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])
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts
+        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])
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts
+        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
@@ -139,16 +139,16 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, ["abc"])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::InvalidDepositAmounts
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::InvalidDepositAmounts)
       end
     end
 
@@ -160,16 +160,16 @@ describe Braintree::UsBankAccountVerification do
           :options => {
             :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
             :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::MustBeMicroTransfersVerification
+        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
@@ -182,15 +182,15 @@ describe Braintree::UsBankAccountVerification do
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
           :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
-        }
+        },
       )
 
-      result.should be_success
+      expect(result).to be_success
 
       created_verification = result.payment_method.verifications.first
       found_verification = Braintree::UsBankAccountVerification.find(created_verification.id)
 
-      found_verification.should == created_verification
+      expect(found_verification).to eq(created_verification)
     end
 
     it "raises a NotFoundError exception if verification cannot be found" do
@@ -208,7 +208,7 @@ describe Braintree::UsBankAccountVerification do
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
           :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
-        }
+        },
       ).payment_method
     end
 
@@ -224,7 +224,7 @@ describe Braintree::UsBankAccountVerification do
         search.verification_method.in created_verification.verification_method
       end
 
-      found_verifications.should include(created_verification)
+      expect(found_verifications).to include(created_verification)
     end
 
     it "searches and finds verifications using customer fields" do
@@ -234,7 +234,7 @@ describe Braintree::UsBankAccountVerification do
         search.payment_method_token.is payment_method.token
       end
 
-      found_verifications.count.should eq(1)
+      expect(found_verifications.count).to eq(1)
     end
   end
 end

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -7,44 +7,44 @@ describe Braintree::VisaCheckoutCard do
 
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id
+      :customer_id => customer.id,
     )
-    result.should be_success
+    expect(result).to be_success
 
     visa_checkout_card = result.payment_method
-    visa_checkout_card.should be_a(Braintree::VisaCheckoutCard)
-    visa_checkout_card.call_id.should == "abc123"
-    visa_checkout_card.billing_address.should_not be_nil
-    visa_checkout_card.bin.should_not be_nil
-    visa_checkout_card.card_type.should_not be_nil
-    visa_checkout_card.cardholder_name.should_not be_nil
-    visa_checkout_card.commercial.should_not be_nil
-    visa_checkout_card.country_of_issuance.should_not be_nil
-    visa_checkout_card.created_at.should_not be_nil
-    visa_checkout_card.customer_id.should_not be_nil
-    visa_checkout_card.customer_location.should_not be_nil
-    visa_checkout_card.debit.should_not be_nil
-    visa_checkout_card.default?.should_not be_nil
-    visa_checkout_card.durbin_regulated.should_not be_nil
-    visa_checkout_card.expiration_date.should_not be_nil
-    visa_checkout_card.expiration_month.should_not be_nil
-    visa_checkout_card.expiration_year.should_not be_nil
-    visa_checkout_card.expired?.should_not be_nil
-    visa_checkout_card.healthcare.should_not be_nil
-    visa_checkout_card.image_url.should_not be_nil
-    visa_checkout_card.issuing_bank.should_not be_nil
-    visa_checkout_card.last_4.should_not be_nil
-    visa_checkout_card.payroll.should_not be_nil
-    visa_checkout_card.prepaid.should_not be_nil
-    visa_checkout_card.product_id.should_not be_nil
-    visa_checkout_card.subscriptions.should_not be_nil
-    visa_checkout_card.token.should_not be_nil
-    visa_checkout_card.unique_number_identifier.should_not be_nil
-    visa_checkout_card.updated_at.should_not be_nil
+    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)
-    customer.visa_checkout_cards.size.should == 1
-    customer.visa_checkout_cards.first.should == visa_checkout_card
+    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
@@ -53,25 +53,25 @@ describe Braintree::VisaCheckoutCard do
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
       :customer_id => customer.id,
-      :options => { :verify_card => true }
+      :options => {:verify_card => true},
     )
-    result.should be_success
-    result.payment_method.verification.status.should == Braintree::CreditCardVerification::Status::Verified
+    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',
+      :amount => "47.00",
     )
-    transaction_create_result.should be_success
+    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
-    search_results.first.id.should == transaction_id
+    expect(search_results.first.id).to eq(transaction_id)
   end
 
   it "can create transaction from nonce and vault" do
@@ -80,31 +80,31 @@ describe Braintree::VisaCheckoutCard do
     result = Braintree::Transaction.sale(
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
       :customer_id => customer.id,
-      :amount => '47.00',
-      :options => { :store_in_vault => true },
+      :amount => "47.00",
+      :options => {:store_in_vault => true},
     )
-    result.should be_success
+    expect(result).to be_success
 
     visa_checkout_card_details = result.transaction.visa_checkout_card_details
-    visa_checkout_card_details.call_id.should == "abc123"
-    visa_checkout_card_details.bin.should_not be_nil
-    visa_checkout_card_details.card_type.should_not be_nil
-    visa_checkout_card_details.cardholder_name.should_not be_nil
-    visa_checkout_card_details.commercial.should_not be_nil
-    visa_checkout_card_details.country_of_issuance.should_not be_nil
-    visa_checkout_card_details.customer_location.should_not be_nil
-    visa_checkout_card_details.debit.should_not be_nil
-    visa_checkout_card_details.durbin_regulated.should_not be_nil
-    visa_checkout_card_details.expiration_date.should_not be_nil
-    visa_checkout_card_details.expiration_month.should_not be_nil
-    visa_checkout_card_details.expiration_year.should_not be_nil
-    visa_checkout_card_details.healthcare.should_not be_nil
-    visa_checkout_card_details.image_url.should_not be_nil
-    visa_checkout_card_details.issuing_bank.should_not be_nil
-    visa_checkout_card_details.last_4.should_not be_nil
-    visa_checkout_card_details.payroll.should_not be_nil
-    visa_checkout_card_details.prepaid.should_not be_nil
-    visa_checkout_card_details.product_id.should_not be_nil
-    visa_checkout_card_details.token.should_not be_nil
+    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

@@ -2,10 +2,9 @@ require "securerandom"
 
 unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
   INTEGRATION_SPEC_HELPER_LOADED = true
-  SSL_TEST_PORT = ENV['SSL_TEST_PORT'] || 8444
+  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"))
@@ -13,11 +12,9 @@ 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 => SSL_TEST_PORT
+    TCPSocket.new("127.0.0.1",SSL_TEST_PORT)
 
-    yield
-
-    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
@@ -45,12 +42,24 @@ unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
     end
   end
 
-  def with_advanced_fraud_integration_merchant(&block)
+  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
@@ -58,4 +67,10 @@ unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
   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

@@ -10,7 +10,7 @@ module Braintree
     def self.create_token(gateway, params)
       code = create_grant(gateway, params)
       gateway.oauth.create_token_from_code(
-        :code => code
+        :code => code,
       )
     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 => (ENV['SSL_TEST_PORT'] || 8444),
+  :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