braintree 4.13.0 → 4.15.0

data/spec/integration/braintree/address_spec.rb

@@ -18,21 +18,21 @@ describe Braintree::Address do
         :postal_code => "60622",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.customer_id.should == customer.id
-      result.address.first_name.should == "Ben"
-      result.address.last_name.should == "Moore"
-      result.address.company.should == "Moore Co."
-      result.address.street_address.should == "1811 E Main St"
-      result.address.extended_address.should == "Suite 200"
-      result.address.locality.should == "Chicago"
-      result.address.region.should == "Illinois"
-      result.address.phone_number.should == "5551231234"
-      result.address.postal_code.should == "60622"
-      result.address.country_name.should == "United States of America"
-      result.address.country_code_alpha2.should == "US"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.customer_id).to eq(customer.id)
+      expect(result.address.first_name).to eq("Ben")
+      expect(result.address.last_name).to eq("Moore")
+      expect(result.address.company).to eq("Moore Co.")
+      expect(result.address.street_address).to eq("1811 E Main St")
+      expect(result.address.extended_address).to eq("Suite 200")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.phone_number).to eq("5551231234")
+      expect(result.address.postal_code).to eq("60622")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -43,11 +43,11 @@ describe Braintree::Address do
         :country_code_alpha3 => "ASM",
         :country_code_numeric => "16",
       )
-      result.success?.should == true
-      result.address.country_name.should == "American Samoa"
-      result.address.country_code_alpha2.should == "AS"
-      result.address.country_code_alpha3.should == "ASM"
-      result.address.country_code_numeric.should == "016"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("American Samoa")
+      expect(result.address.country_code_alpha2).to eq("AS")
+      expect(result.address.country_code_alpha3).to eq("ASM")
+      expect(result.address.country_code_numeric).to eq("016")
     end
 
     it "accepts utf-8 country names" do
@@ -56,8 +56,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_name => "Åland",
       )
-      result.success?.should == true
-      result.address.country_name.should == "Åland"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Åland")
     end
 
     it "returns an error response given inconsistent country codes" do
@@ -67,8 +67,8 @@ describe Braintree::Address do
         :country_code_alpha2 => "AS",
         :country_code_alpha3 => "USA",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:base).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error response given an invalid country_code_alpha2" do
@@ -77,8 +77,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_alpha2 => "zz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_alpha3" do
@@ -87,8 +87,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_alpha3 => "zzz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_numeric" do
@@ -97,8 +97,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_numeric => "zz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns an error response if invalid" do
@@ -107,8 +107,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_name => "United States of Invalid",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
 
     it "allows -, _, A-Z, a-z, and 0-9 in customer_id without raising an ArgumentError" do
@@ -137,14 +137,14 @@ describe Braintree::Address do
         :postal_code => "60623",
         :country_name => "United States of America",
       )
-      address.customer_id.should == customer.id
-      address.street_address.should == "1812 E Main St"
-      address.extended_address.should == "Suite 201"
-      address.locality.should == "Bartlett"
-      address.region.should == "IL"
-      address.phone_number.should == "5551231234"
-      address.postal_code.should == "60623"
-      address.country_name.should == "United States of America"
+      expect(address.customer_id).to eq(customer.id)
+      expect(address.street_address).to eq("1812 E Main St")
+      expect(address.extended_address).to eq("Suite 201")
+      expect(address.locality).to eq("Bartlett")
+      expect(address.region).to eq("IL")
+      expect(address.phone_number).to eq("5551231234")
+      expect(address.postal_code).to eq("60623")
+      expect(address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed if invalid" do
@@ -162,7 +162,7 @@ describe Braintree::Address do
     it "deletes the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer.id, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer.id, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -171,7 +171,7 @@ describe Braintree::Address do
     it "deletes the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -182,13 +182,13 @@ describe Braintree::Address do
     it "finds the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer, address.id).should == address
+      expect(Braintree::Address.find(customer, address.id)).to eq(address)
     end
 
     it "finds the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer.id, address.id).should == address
+      expect(Braintree::Address.find(customer.id, address.id)).to eq(address)
     end
 
     it "raises a NotFoundError if it cannot be found because of customer id" do
@@ -242,16 +242,16 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.street_address.should == "123 E New St"
-      result.address.extended_address.should == "New Suite 3"
-      result.address.locality.should == "Chicago"
-      result.address.region.should == "Illinois"
-      result.address.postal_code.should == "60621"
-      result.address.country_name.should == "United States of America"
-      result.address.country_code_alpha2.should == "US"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.street_address).to eq("123 E New St")
+      expect(result.address.extended_address).to eq("New Suite 3")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.postal_code).to eq("60621")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -266,11 +266,11 @@ describe Braintree::Address do
         :country_name => "Azerbaijan",
       )
 
-      result.success?.should == true
-      result.address.country_name.should == "Azerbaijan"
-      result.address.country_code_alpha2.should == "AZ"
-      result.address.country_code_alpha3.should == "AZE"
-      result.address.country_code_numeric.should == "031"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Azerbaijan")
+      expect(result.address.country_code_alpha2).to eq("AZ")
+      expect(result.address.country_code_alpha3).to eq("AZE")
+      expect(result.address.country_code_numeric).to eq("031")
     end
 
     it "returns an error response if invalid" do
@@ -285,8 +285,8 @@ describe Braintree::Address do
         :street_address => "123 E New St",
         :country_name => "United States of Invalid",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
   end
 
@@ -320,13 +320,13 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      updated_address.should == address
-      updated_address.street_address.should == "123 E New St"
-      updated_address.extended_address.should == "New Suite 3"
-      updated_address.locality.should == "Chicago"
-      updated_address.region.should == "Illinois"
-      updated_address.postal_code.should == "60621"
-      updated_address.country_name.should == "United States of America"
+      expect(updated_address).to eq(address)
+      expect(updated_address.street_address).to eq("123 E New St")
+      expect(updated_address.extended_address).to eq("New Suite 3")
+      expect(updated_address.locality).to eq("Chicago")
+      expect(updated_address.region).to eq("Illinois")
+      expect(updated_address.postal_code).to eq("60621")
+      expect(updated_address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed invalid" do
@@ -352,7 +352,7 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
       result = Braintree::Address.delete(customer.id, address.id)
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)

data/spec/integration/braintree/advanced_search_spec.rb

@@ -29,8 +29,8 @@ describe Braintree::AdvancedSearch do
         search.id.is "subscription1_#{id}"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "is_not" do
@@ -54,8 +54,8 @@ describe Braintree::AdvancedSearch do
         search.price.is "11"
       end
 
-      collection.should_not include(subscription1)
-      collection.should include(subscription2)
+      expect(collection).not_to include(subscription1)
+      expect(collection).to include(subscription2)
     end
 
     it "starts_with" do
@@ -76,8 +76,8 @@ describe Braintree::AdvancedSearch do
         search.id.starts_with "subscription1_"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "ends_with" do
@@ -98,8 +98,8 @@ describe Braintree::AdvancedSearch do
         search.id.ends_with "1_#{id}"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "contains" do
@@ -120,8 +120,8 @@ describe Braintree::AdvancedSearch do
         search.id.contains "scription1_"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
   end
 
@@ -147,8 +147,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "12"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       it "returns only matching results" do
@@ -171,8 +171,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "13"
         end
 
-        collection.should include(subscription1)
-        collection.should_not include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).not_to include(subscription2)
       end
 
       it "returns only matching results given an argument list" do
@@ -195,8 +195,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "14"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       describe "is" do
@@ -220,8 +220,8 @@ describe Braintree::AdvancedSearch do
             search.price.is "15"
           end
 
-          collection.should include(subscription1)
-          collection.should_not include(subscription2)
+          expect(collection).to include(subscription1)
+          expect(collection).not_to include(subscription2)
         end
       end
 
@@ -245,8 +245,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "16"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       it "returns expired subscriptions" do
@@ -254,8 +254,8 @@ describe Braintree::AdvancedSearch do
           search.status.in [Braintree::Subscription::Status::Expired]
         end
 
-        collection.maximum_size.should > 0
-        collection.all? { |subscription| subscription.status.should == Braintree::Subscription::Status::Expired }
+        expect(collection.maximum_size).to be > 0
+        collection.all? { |subscription| expect(subscription.status).to eq(Braintree::Subscription::Status::Expired) }
       end
     end
   end
@@ -287,7 +287,7 @@ describe Braintree::AdvancedSearch do
           search.price.is "17"
         end
 
-        collection.maximum_size.should > 0
+        expect(collection.maximum_size).to be > 0
         collection.all? { |subscription| plan_ids.include?(subscription.plan_id) }
       end
     end
@@ -298,7 +298,7 @@ describe Braintree::AdvancedSearch do
           search.plan_id.is "not_a_real_plan_id"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
     end
 
@@ -321,8 +321,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "18"
         end
 
-        collection.should include(trialless_subscription)
-        collection.should_not include(trial_subscription)
+        expect(collection).to include(trialless_subscription)
+        expect(collection).not_to include(trial_subscription)
       end
     end
 
@@ -345,8 +345,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "19"
         end
 
-        collection.should_not include(trialless_subscription)
-        collection.should include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
       end
     end
 
@@ -369,8 +369,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "20"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
 
@@ -393,8 +393,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "21"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
 
@@ -417,8 +417,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "22"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
   end
@@ -441,8 +441,8 @@ describe Braintree::AdvancedSearch do
         search.price.is "5.00"
       end
 
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_501)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_501)
     end
 
     it "<=" do
@@ -468,9 +468,9 @@ describe Braintree::AdvancedSearch do
         search.price <= "5.00"
       end
 
-      collection.should include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_501)
+      expect(collection).to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_501)
     end
 
     it ">=" do
@@ -496,9 +496,9 @@ describe Braintree::AdvancedSearch do
         search.price >= "1000.00"
       end
 
-      collection.should_not include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should include(subscription_501)
+      expect(collection).not_to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).to include(subscription_501)
     end
 
     it "between" do
@@ -524,9 +524,9 @@ describe Braintree::AdvancedSearch do
         search.price.between "4.99", "5.01"
       end
 
-      collection.should include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_502)
+      expect(collection).to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_502)
     end
   end
 end

data/spec/integration/braintree/apple_pay_spec.rb

@@ -23,13 +23,13 @@ describe Braintree::ApplePayGateway do
   describe "register_domain" do
     it "registers an apple pay domain" do
       result = @gateway.apple_pay.register_domain("www.example.com")
-      result.should be_success
+      expect(result).to be_success
     end
 
     it "gets a validation error when attempting to register no domains" do
       result = @gateway.apple_pay.register_domain("")
-      result.should_not be_success
-      result.errors.for(:apple_pay)[0].message.should eq("Domain name is required.")
+      expect(result).not_to be_success
+      expect(result.errors.for(:apple_pay)[0].message).to eq("Domain name is required.")
     end
   end
 
@@ -37,27 +37,27 @@ describe Braintree::ApplePayGateway do
     it "unregisters an apple pay domain" do
       domain = "example.org"
       result = @gateway.apple_pay.unregister_domain(domain)
-      result.should be_success
+      expect(result).to be_success
     end
 
     it "unregisters an apple pay domain with scheme in url" do
       domain = "http://example.org"
       result = @gateway.apple_pay.unregister_domain(domain)
-      result.should be_success
+      expect(result).to be_success
     end
 
     it "escapes the unregistered domain query parameter" do
       domain = "ex&mple.org"
       result = @gateway.apple_pay.unregister_domain(domain)
-      result.should be_success
+      expect(result).to be_success
     end
   end
 
   describe "registered_domains" do
     it "returns stubbed registered domains" do
       result = @gateway.apple_pay.registered_domains
-      result.should be_success
-      result.apple_pay_options.domains.should == ["www.example.com"]
+      expect(result).to be_success
+      expect(result.apple_pay_options.domains).to eq(["www.example.com"])
     end
   end
 end

data/spec/integration/braintree/client_api/client_token_spec.rb

@@ -17,7 +17,7 @@ describe Braintree::ClientToken do
 
       response = http.get_payment_methods
 
-      response.code.should == "200"
+      expect(response.code).to eq("200")
     end
 
     it "raises ArgumentError on invalid parameters (422)" do
@@ -31,14 +31,14 @@ describe Braintree::ClientToken do
         config = Braintree::Configuration.instantiate
         client_token_string = Braintree::ClientToken.generate(:version => 1)
         client_token = JSON.parse(client_token_string)
-        client_token["version"].should == 1
+        expect(client_token["version"]).to eq(1)
       end
 
       it "defaults to 2" do
         config = Braintree::Configuration.instantiate
         client_token_string = Braintree::ClientToken.generate
         client_token = decode_client_token(client_token_string)
-        client_token["version"].should == 2
+        expect(client_token["version"]).to eq(2)
       end
     end
 
@@ -68,7 +68,7 @@ describe Braintree::ClientToken do
         },
       )
 
-      response.code.should == "422"
+      expect(response.code).to eq("422")
     end
 
     it "can pass make_default" do
@@ -98,7 +98,7 @@ describe Braintree::ClientToken do
         },
       )
 
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       response = http.add_payment_method(
         :credit_card => {
@@ -108,10 +108,10 @@ describe Braintree::ClientToken do
         },
       )
 
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       customer = Braintree::Customer.find(customer_id)
-      customer.credit_cards.select { |c| c.bin == "400551" }[0].should be_default
+      expect(customer.credit_cards.select { |c| c.bin == "400551" }[0]).to be_default
     end
 
     it "can pass fail_on_duplicate_payment_method" do
@@ -138,7 +138,7 @@ describe Braintree::ClientToken do
         },
       )
 
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       second_raw_client_token = Braintree::ClientToken.generate(
         :customer_id => customer_id,
@@ -158,7 +158,7 @@ describe Braintree::ClientToken do
         },
       )
 
-      response.code.should == "422"
+      expect(response.code).to eq("422")
     end
 
     it "can pass merchant_account_id" do
@@ -169,7 +169,7 @@ describe Braintree::ClientToken do
       )
       client_token = decode_client_token(raw_client_token)
 
-      client_token["merchantAccountId"].should == merchant_account_id
+      expect(client_token["merchantAccountId"]).to eq(merchant_account_id)
     end
 
     context "paypal" do
@@ -178,11 +178,11 @@ describe Braintree::ClientToken do
           raw_client_token = Braintree::ClientToken.generate
           client_token = decode_client_token(raw_client_token)
 
-          client_token["paypal"]["displayName"].should == "merchant who has paypal and sepa enabled"
-          client_token["paypal"]["clientId"].should match(/.+/)
-          client_token["paypal"]["privacyUrl"].should match("http://www.example.com/privacy_policy")
-          client_token["paypal"]["userAgreementUrl"].should match("http://www.example.com/user_agreement")
-          client_token["paypal"]["baseUrl"].should_not be_nil
+          expect(client_token["paypal"]["displayName"]).to eq("merchant who has paypal and sepa enabled")
+          expect(client_token["paypal"]["clientId"]).to match(/.+/)
+          expect(client_token["paypal"]["privacyUrl"]).to match("http://www.example.com/privacy_policy")
+          expect(client_token["paypal"]["userAgreementUrl"]).to match("http://www.example.com/user_agreement")
+          expect(client_token["paypal"]["baseUrl"]).not_to be_nil
         end
       end
     end