braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/advanced_search_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::AdvancedSearch do
       :credit_card => {
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2010"
-      }
+      },
     ).credit_cards[0]
   end
 
@@ -16,21 +16,21 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
@@ -39,14 +39,14 @@ describe Braintree::AdvancedSearch do
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
         :price => "11",
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
         :price => "11",
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -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
@@ -63,21 +63,21 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
@@ -85,21 +85,21 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
@@ -107,21 +107,21 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
 
@@ -131,13 +131,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "12"
+          :price => "12",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "12"
+          :price => "12",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -147,21 +147,21 @@ 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
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "13"
+          :price => "13",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "13"
+          :price => "13",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -171,21 +171,21 @@ 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
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "14"
+          :price => "14",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "14"
+          :price => "14",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -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
@@ -204,13 +204,13 @@ describe Braintree::AdvancedSearch do
           subscription1 = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
             :plan_id => SpecHelper::TriallessPlan[:id],
-            :price => "15"
+            :price => "15",
           ).subscription
 
           subscription2 = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
             :plan_id => SpecHelper::TriallessPlan[:id],
-            :price => "15"
+            :price => "15",
           ).subscription
 
           Braintree::Subscription.cancel(subscription2.id)
@@ -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
 
@@ -229,13 +229,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "16"
+          :price => "16",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "16"
+          :price => "16",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -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
@@ -263,22 +263,22 @@ describe Braintree::AdvancedSearch do
   context "multiple_value_or_text_field" do
     describe "in" do
       it "works for the in operator" do
-        subscription1 = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
-        subscription2 = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
-        subscription3 = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::AddOnDiscountPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
         plan_ids = [SpecHelper::TriallessPlan[:id], SpecHelper::TrialPlan[:id]]
@@ -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
 
@@ -307,13 +307,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "18"
+          :price => "18",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "18"
+          :price => "18",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -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
 
@@ -331,13 +331,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "19"
+          :price => "19",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "19"
+          :price => "19",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -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
 
@@ -355,13 +355,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "20"
+          :price => "20",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "20"
+          :price => "20",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -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
 
@@ -379,13 +379,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "21"
+          :price => "21",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "21"
+          :price => "21",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -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
 
@@ -403,13 +403,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "22"
+          :price => "22",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "22"
+          :price => "22",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -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
@@ -428,105 +428,105 @@ describe Braintree::AdvancedSearch do
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.01"
+        :price => "5.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "4.99"
+        :price => "4.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.01"
+        :price => "5.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "999.99"
+        :price => "999.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "1000.00"
+        :price => "1000.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "1000.01"
+        :price => "1000.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "4.99"
+        :price => "4.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_502 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.02"
+        :price => "5.02",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
         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

@@ -5,31 +5,31 @@ describe Braintree::ApplePayGateway 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"],
     )
 
     @gateway = Braintree::Gateway.new(
       :access_token => result.credentials.access_token,
-      :logger => Logger.new("/dev/null")
+      :logger => Logger.new("/dev/null"),
     )
   end
 
   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/braintree_gateway_spec.rb

@@ -12,7 +12,8 @@ describe Braintree::Gateway do
   end
 
   describe "query" do
-    it "makes valid GraphQL queries when given a definition" do
+    # we are temporarily skipping this test until we have a more stable CI env
+    xit "makes valid GraphQL queries when given a definition" do
       definition = <<-GRAPHQL
       mutation ExampleServerSideSingleUseToken($input: TokenizeCreditCardInput!) {
         tokenizeCreditCard(input: $input) {