braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/merchant_spec.rb

@@ -6,50 +6,50 @@ describe Braintree::MerchantGateway do
       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"),
       )
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
-        :payment_methods => ["credit_card", "paypal"]
+        :country_code_alpha3 => "GBR",
+        :payment_methods => ["credit_card", "paypal"],
       )
 
-      result.should be_success
+      expect(result).to be_success
 
       merchant = result.merchant
-      merchant.id.should_not be_nil
-      merchant.email.should == "name@email.com"
-      merchant.company_name.should == "name@email.com"
-      merchant.country_code_alpha3.should == "USA"
-      merchant.country_code_alpha2.should == "US"
-      merchant.country_code_numeric.should == "840"
-      merchant.country_name.should == "United States of America"
+      expect(merchant.id).not_to be_nil
+      expect(merchant.email).to eq("name@email.com")
+      expect(merchant.company_name).to eq("name@email.com")
+      expect(merchant.country_code_alpha3).to eq("GBR")
+      expect(merchant.country_code_alpha2).to eq("GB")
+      expect(merchant.country_code_numeric).to eq("826")
+      expect(merchant.country_name).to eq("United Kingdom")
 
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
 
     it "gives an error when using invalid payment_methods" do
       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"),
       )
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
-        :payment_methods => ["fake_money"]
+        :country_code_alpha3 => "GBR",
+        :payment_methods => ["fake_money"],
       )
 
-      result.should_not be_success
+      expect(result).not_to be_success
       errors = result.errors.for(:merchant).on(:payment_methods)
 
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid)
     end
 
     context "credentials" do
@@ -70,223 +70,116 @@ describe Braintree::MerchantGateway do
         )
         result = gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"]
+          :country_code_alpha3 => "GBR",
+          :payment_methods => ["credit_card", "paypal"],
         )
 
-        result.should be_success
+        expect(result).to be_success
       end
     end
 
     context "multiple currencies" do
       before(:each) do
         @gateway = Braintree::Gateway.new(
-          :client_id => "client_id$development$signup_client_id",
-          :client_secret => "client_secret$development$signup_client_secret",
-          :logger => Logger.new("/dev/null")
+          :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"),
         )
       end
 
-      it "creates a US multi currency merchant for paypal and credit_card" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"],
-          :currencies => ["GBP", "USD"]
-        )
-
-        merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "USA"
-        merchant.country_code_alpha2.should == "US"
-        merchant.country_code_numeric.should == "840"
-        merchant.country_name.should == "United States of America"
-
-        credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
-
-        merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "GBP"
-      end
-
       it "creates an EU multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "GBR",
           :payment_methods => ["credit_card", "paypal"],
-          :currencies => ["GBP", "USD"]
+          :currencies => ["GBP", "USD"],
         )
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "GBR"
-        merchant.country_code_alpha2.should == "GB"
-        merchant.country_code_numeric.should == "826"
-        merchant.country_name.should == "United Kingdom"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("GBR")
+        expect(merchant.country_code_alpha2).to eq("GB")
+        expect(merchant.country_code_numeric).to eq("826")
+        expect(merchant.country_name).to eq("United Kingdom")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
+        expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "GBP"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("GBP")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(false)
+        expect(merchant_account.currency_iso_code).to eq("USD")
       end
 
 
       it "creates a paypal-only merchant that accepts multiple currencies" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["GBP", "USD"],
           :paypal_account => {
             :client_id => "paypal_client_id",
             :client_secret => "paypal_client_secret",
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "USA"
-        merchant.country_code_alpha2.should == "US"
-        merchant.country_code_numeric.should == "840"
-        merchant.country_name.should == "United States of America"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("GBR")
+        expect(merchant.country_code_alpha2).to eq("GB")
+        expect(merchant.country_code_numeric).to eq("826")
+        expect(merchant.country_name).to eq("United Kingdom")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
+        expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(false)
+        expect(merchant_account.currency_iso_code).to eq("USD")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "GBP"
-      end
-
-      it "allows creation of non-US merchant if onboarding application is internal" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "JPN",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          }
-        )
-
-        result.should be_success
-
-        merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "JPN"
-        merchant.country_code_alpha2.should == "JP"
-        merchant.country_code_numeric.should == "392"
-        merchant.country_name.should == "Japan"
-
-        credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
-
-        merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "JPY"
-      end
-
-      it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "YEM",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          }
-        )
-
-        result.should be_success
-
-        merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "YEM"
-        merchant.country_code_alpha2.should == "YE"
-        merchant.country_code_numeric.should == "887"
-        merchant.country_name.should == "Yemen"
-
-        credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
-
-        merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("GBP")
       end
 
       it "returns error if invalid currency is passed" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["FAKE", "GBP"],
           :paypal_account => {
             :client_id => "paypal_client_id",
             :client_secret => "paypal_client_secret",
-          }
+          },
         )
 
-        result.should_not be_success
+        expect(result).not_to be_success
         errors = result.errors.for(:merchant).on(:currencies)
 
-        errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrenciesAreInvalid
+        expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrenciesAreInvalid)
       end
     end
   end
@@ -304,30 +197,16 @@ describe Braintree::MerchantGateway do
 
       it "succeeds" do
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover"]
+        expect(result).to be_success
+        expect(result.supported_networks).to eq(["visa", "mastercard", "amex", "discover", "maestro", "elo"])
       end
 
       it "is repeatable" do
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
-        result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover"]
-      end
-    end
-
-    context "merchant has no processor connection supporting apple pay" do
-      before do
-        Braintree::Configuration.merchant_id = "forward_payment_method_merchant_id"
-        Braintree::Configuration.public_key = "forward_payment_method_public_key"
-        Braintree::Configuration.private_key = "forward_payment_method_private_key"
-      end
-
-      it "returns a validation error" do
+        expect(result).to be_success
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should_not be_success
-        result.errors.for(:apple_pay).first.code.should == Braintree::ErrorCodes::ApplePay::ApplePayCardsAreNotAccepted
+        expect(result).to be_success
+        expect(result.supported_networks).to eq(["visa", "mastercard", "amex", "discover", "maestro", "elo"])
       end
     end
 

data/spec/integration/braintree/oauth_spec.rb

@@ -5,7 +5,7 @@ describe "OAuth" do
     @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"),
     )
   end
 
@@ -18,38 +18,38 @@ describe "OAuth" do
 
       result = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
-      result.should be_success
+      expect(result).to be_success
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
 
     it "returns validation errors for bad params" do
       result = @gateway.oauth.create_token_from_code(
         :code => "bad_code",
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
-      result.should_not be_success
-      errors = result.errors.for(:credentials).on(:code)[0].code.should == Braintree::ErrorCodes::OAuth::InvalidGrant
-      result.message.should =~ /Invalid grant: code not found/
+      expect(result).not_to be_success
+      expect(result.errors.for(:credentials).on(:code)[0].code).to eq(Braintree::ErrorCodes::OAuth::InvalidGrant)
+      expect(result.message).to match(/Invalid grant: code not found/)
     end
 
     it "raises with a helpful error if client_id and client_secret are not set" do
       gateway = Braintree::Gateway.new(
         :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       expect do
         gateway.oauth.create_token_from_code(
           :code => "some code",
-          :scope => "read_write"
+          :scope => "read_write",
         )
       end.to raise_error(Braintree::ConfigurationError, /client_id and client_secret are required/);
     end
@@ -63,20 +63,20 @@ describe "OAuth" do
       })
       refresh_token = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       ).credentials.refresh_token
 
       result = @gateway.oauth.create_token_from_refresh_token(
         :refresh_token => refresh_token,
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
-      result.should be_success
+      expect(result).to be_success
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
   end
 
@@ -88,15 +88,15 @@ describe "OAuth" do
       })
       access_token = @gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       ).credentials.access_token
 
       result = @gateway.oauth.revoke_access_token(access_token)
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       expect do
@@ -146,53 +146,53 @@ describe "OAuth" do
           :currency => "USD",
           :website => "http://example.com"
         },
-        :payment_methods => ["credit_card", "paypal"]
+        :payment_methods => ["credit_card", "paypal"],
       )
 
       uri = URI.parse(url)
-      uri.host.should == Braintree::Configuration.instantiate.server
-      uri.path.should == "/oauth/connect"
+      expect(uri.host).to eq(Braintree::Configuration.instantiate.server)
+      expect(uri.path).to eq("/oauth/connect")
 
       query = CGI.parse(uri.query)
-      query["merchant_id"].should == ["integration_merchant_id"]
-      query["client_id"].should == ["client_id$#{Braintree::Configuration.environment}$integration_client_id"]
-      query["redirect_uri"].should == ["http://bar.example.com"]
-      query["scope"].should == ["read_write"]
-      query["state"].should == ["baz_state"]
-      query["landing_page"].should == ["signup"]
-      query["login_only"].should == ["false"]
-
-      query["user[country]"].should == ["USA"]
-      query["business[name]"].should == ["14 Ladders"]
-
-      query["user[email]"].should == ["foo@example.com"]
-      query["user[first_name]"].should == ["Bob"]
-      query["user[last_name]"].should == ["Jones"]
-      query["user[phone]"].should == ["555-555-5555"]
-      query["user[dob_year]"].should == ["1970"]
-      query["user[dob_month]"].should == ["01"]
-      query["user[dob_day]"].should == ["01"]
-      query["user[street_address]"].should == ["222 W Merchandise Mart"]
-      query["user[locality]"].should == ["Chicago"]
-      query["user[region]"].should == ["IL"]
-      query["user[postal_code]"].should == ["60606"]
-
-      query["business[name]"].should == ["14 Ladders"]
-      query["business[registered_as]"].should == ["14.0 Ladders"]
-      query["business[industry]"].should == ["Ladders"]
-      query["business[description]"].should == ["We sell the best ladders"]
-      query["business[street_address]"].should == ["111 N Canal"]
-      query["business[locality]"].should == ["Chicago"]
-      query["business[region]"].should == ["IL"]
-      query["business[postal_code]"].should == ["60606"]
-      query["business[country]"].should == ["USA"]
-      query["business[annual_volume_amount]"].should == ["1000000"]
-      query["business[average_transaction_amount]"].should == ["100"]
-      query["business[maximum_transaction_amount]"].should == ["10000"]
-      query["business[ship_physical_goods]"].should == ["true"]
-      query["business[fulfillment_completed_in]"].should == ["7"]
-      query["business[currency]"].should == ["USD"]
-      query["business[website]"].should == ["http://example.com"]
+      expect(query["merchant_id"]).to eq(["integration_merchant_id"])
+      expect(query["client_id"]).to eq(["client_id$#{Braintree::Configuration.environment}$integration_client_id"])
+      expect(query["redirect_uri"]).to eq(["http://bar.example.com"])
+      expect(query["scope"]).to eq(["read_write"])
+      expect(query["state"]).to eq(["baz_state"])
+      expect(query["landing_page"]).to eq(["signup"])
+      expect(query["login_only"]).to eq(["false"])
+
+      expect(query["user[country]"]).to eq(["USA"])
+      expect(query["business[name]"]).to eq(["14 Ladders"])
+
+      expect(query["user[email]"]).to eq(["foo@example.com"])
+      expect(query["user[first_name]"]).to eq(["Bob"])
+      expect(query["user[last_name]"]).to eq(["Jones"])
+      expect(query["user[phone]"]).to eq(["555-555-5555"])
+      expect(query["user[dob_year]"]).to eq(["1970"])
+      expect(query["user[dob_month]"]).to eq(["01"])
+      expect(query["user[dob_day]"]).to eq(["01"])
+      expect(query["user[street_address]"]).to eq(["222 W Merchandise Mart"])
+      expect(query["user[locality]"]).to eq(["Chicago"])
+      expect(query["user[region]"]).to eq(["IL"])
+      expect(query["user[postal_code]"]).to eq(["60606"])
+
+      expect(query["business[name]"]).to eq(["14 Ladders"])
+      expect(query["business[registered_as]"]).to eq(["14.0 Ladders"])
+      expect(query["business[industry]"]).to eq(["Ladders"])
+      expect(query["business[description]"]).to eq(["We sell the best ladders"])
+      expect(query["business[street_address]"]).to eq(["111 N Canal"])
+      expect(query["business[locality]"]).to eq(["Chicago"])
+      expect(query["business[region]"]).to eq(["IL"])
+      expect(query["business[postal_code]"]).to eq(["60606"])
+      expect(query["business[country]"]).to eq(["USA"])
+      expect(query["business[annual_volume_amount]"]).to eq(["1000000"])
+      expect(query["business[average_transaction_amount]"]).to eq(["100"])
+      expect(query["business[maximum_transaction_amount]"]).to eq(["10000"])
+      expect(query["business[ship_physical_goods]"]).to eq(["true"])
+      expect(query["business[fulfillment_completed_in]"]).to eq(["7"])
+      expect(query["business[currency]"]).to eq(["USD"])
+      expect(query["business[website]"]).to eq(["http://example.com"])
     end
 
     it "builds the query string with multiple payment_methods" do
@@ -201,17 +201,17 @@ describe "OAuth" do
         :redirect_uri => "http://bar.example.com",
         :scope => "read_write",
         :state => "baz_state",
-        :payment_methods => ["credit_card", "paypal"]
+        :payment_methods => ["credit_card", "paypal"],
       )
 
       uri = URI.parse(url)
-      uri.host.should == Braintree::Configuration.instantiate.server
-      uri.path.should == "/oauth/connect"
+      expect(uri.host).to eq(Braintree::Configuration.instantiate.server)
+      expect(uri.path).to eq("/oauth/connect")
 
       query = CGI.parse(CGI.unescape(uri.query))
-      query["payment_methods[]"].length.should == 2
-      query["payment_methods[]"].should include("paypal")
-      query["payment_methods[]"].should include("credit_card")
+      expect(query["payment_methods[]"].length).to eq(2)
+      expect(query["payment_methods[]"]).to include("paypal")
+      expect(query["payment_methods[]"]).to include("credit_card")
     end
 
     it "doesn't mutate the options" do
@@ -219,7 +219,7 @@ describe "OAuth" do
 
       @gateway.oauth.connect_url(params)
 
-      params.should == {:payment_methods => ["credit_card"]}
+      expect(params).to eq({:payment_methods => ["credit_card"]})
     end
   end
 end