braintree 2.104.0 → 4.9.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -13,14 +13,15 @@ describe Braintree::PaymentMethod do
       context "plaid verified nonce" do
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
             :customer_id => customer.id,
             :options => {
               :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-            }
+            },
           )
 
           result.should be_success
@@ -49,7 +50,8 @@ describe Braintree::PaymentMethod do
           Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
           Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
         ].each do |method|
-          it "succeeds and verifies via #{method}" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "succeeds and verifies via #{method}" do
             customer = Braintree::Customer.create.customer
             result = Braintree::PaymentMethod.create(
               :payment_method_nonce => nonce,
@@ -57,7 +59,7 @@ describe Braintree::PaymentMethod do
               :options => {
                 :us_bank_account_verification_method => method,
                 :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              }
+              },
             )
 
             result.should be_success
@@ -101,7 +103,7 @@ describe Braintree::PaymentMethod do
             :customer_id => customer.id,
             :options => {
               :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-            }
+            },
           )
 
           result.should be_success
@@ -134,7 +136,7 @@ describe Braintree::PaymentMethod do
               :options => {
                 :us_bank_account_verification_method => method,
                 :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              }
+              },
             )
 
             result.should be_success
@@ -165,7 +167,7 @@ describe Braintree::PaymentMethod do
         customer = Braintree::Customer.create.customer
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => generate_invalid_us_bank_account_nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
         result.should_not be_success
@@ -183,14 +185,15 @@ describe Braintree::PaymentMethod do
 
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
             :customer_id => customer.id,
             :options => {
               :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-            }
+            },
           )
 
           result.should be_success
@@ -219,14 +222,15 @@ describe Braintree::PaymentMethod do
       context "non plaid verified nonce" do
         let(:nonce) { generate_non_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
             :customer_id => customer.id,
             :options => {
               :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-            }
+            },
           )
 
           result.should be_success
@@ -256,7 +260,7 @@ describe Braintree::PaymentMethod do
         customer = Braintree::Customer.create.customer
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => generate_invalid_us_bank_account_nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
         result.should_not be_success
@@ -352,7 +356,7 @@ describe Braintree::PaymentMethod do
             :customer_id => customer.id,
             :options => {
               :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-            }
+            },
           ).payment_method
         end
 

data/spec/integration/braintree/paypal_account_spec.rb

@@ -9,11 +9,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       result.should be_success
 
@@ -35,7 +35,7 @@ describe Braintree::PayPalAccount do
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
         :customer_id => customer.id,
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result.should be_success
 
@@ -56,7 +56,7 @@ describe Braintree::PayPalAccount do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :token => "CREDIT_CARD_TOKEN"
+        :token => "CREDIT_CARD_TOKEN",
       )
 
       expect do
@@ -70,11 +70,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       result.should be_success
 
@@ -82,12 +82,12 @@ describe Braintree::PayPalAccount do
 
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => token,
-        :plan_id => SpecHelper::TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id],
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => token,
-        :plan_id => SpecHelper::TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id],
       ).subscription
 
       paypal_account = Braintree::PayPalAccount.find(token)
@@ -105,7 +105,7 @@ describe Braintree::PayPalAccount do
         :options => {
             :make_default => true,
             :fail_on_duplicate_payment_method => true,
-        }
+        },
       )
 
       result.should be_success
@@ -116,7 +116,7 @@ describe Braintree::PayPalAccount do
     it "throws an error if customer id is not specified" do
       result = Braintree::PayPalAccount.create(
         :billing_agreement_id => "some_billing_agreement_id",
-        :email => "some@example.com"
+        :email => "some@example.com",
       )
 
       result.success?.should == false
@@ -127,7 +127,7 @@ describe Braintree::PayPalAccount do
       customer = Braintree::Customer.create!
       result = Braintree::PayPalAccount.create(
         :customer_id => customer.id,
-        :email => "some@example.com"
+        :email => "some@example.com",
       )
 
       result.success?.should == false
@@ -141,14 +141,14 @@ describe Braintree::PayPalAccount do
       create_result = Braintree::PayPalAccount.create(
         :customer_id => customer.id,
         :billing_agreement_id => "first_billing_agreement_id",
-        :email => "first@example.com"
+        :email => "first@example.com",
       )
       create_result.success?.should == true
 
       update_result = Braintree::PayPalAccount.update(
         create_result.paypal_account.token,
         :billing_agreement_id => "second_billing_agreement_id",
-        :email => "second@example.com"
+        :email => "second@example.com",
       )
 
       update_result.success?.should == true
@@ -163,17 +163,17 @@ describe Braintree::PayPalAccount do
       original_token = random_payment_method_token
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => original_token
+        :token => original_token,
       )
       original_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       updated_token = "UPDATED_TOKEN-" + rand(36**3).to_s(36)
       updated_result = Braintree::PayPalAccount.update(
         original_token,
-        :token => updated_token
+        :token => updated_token,
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
@@ -190,19 +190,19 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
-        :options => {:make_default => true}
+        :options => {:make_default => true},
       )
       result.should be_success
 
       nonce = nonce_for_paypal_account(:consent_code => "consent-code")
       original_token = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       ).payment_method.token
 
       updated_result = Braintree::PayPalAccount.update(
         original_token,
-        :options => {:make_default => true}
+        :options => {:make_default => true},
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(original_token)
@@ -216,25 +216,25 @@ describe Braintree::PayPalAccount do
 
       first_nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => first_token
+        :token => first_token,
       )
       first_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => first_nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       second_nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => second_token
+        :token => second_token,
       )
       second_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => second_nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       updated_result = Braintree::PayPalAccount.update(
         first_token,
-        :token => second_token
+        :token => second_token,
       )
 
       updated_result.should_not be_success
@@ -249,11 +249,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => token
+        :token => token,
       )
       Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       result = Braintree::PayPalAccount.delete(token)
@@ -267,7 +267,7 @@ describe Braintree::PayPalAccount do
   context "self.sale" do
     it "creates a transaction using a paypal account and returns a result object" do
       customer = Braintree::Customer.create!(
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
       )
 
       result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
@@ -283,7 +283,7 @@ describe Braintree::PayPalAccount do
   context "self.sale!" do
     it "creates a transaction using a paypal account and returns a transaction" do
       customer = Braintree::Customer.create!(
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
       )
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")

data/spec/integration/braintree/plan_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Plan do
 
@@ -48,6 +49,87 @@ describe Braintree::Plan do
     end
   end
 
+  describe "self.create" do
+    let(:attributes) do
+      {
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false
+      }
+
+      it "is successful with given params" do
+        result = Braintree::Plan.create(attributes)
+        expect(result.success?).to be_truthy
+        expect(result.plan.billing_day_of_month).to eq 12
+        expect(result.plan.description).to eq "description on create"
+        expect(result.plan.name).to eq "my new plan name"
+        expect(result.plan.price).to eq "9.99"
+        expect(result.plan.billing_frequency).to eq 1
+      end
+    end
+  end
+
+  describe "self.find" do
+    it "finds a plan" do
+      plan = Braintree::Plan.create(
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false,
+      ).plan
+
+      found_plan = Braintree::Plan.find(plan.id)
+      expect(found_plan.name).to eq plan.name
+    end
+
+    it "raises Braintree::NotFoundError if it cannot find" do
+      expect {
+        Braintree::Plan.find("noSuchPlan")
+      }.to raise_error(Braintree::NotFoundError, 'plan with id "noSuchPlan" not found')
+    end
+  end
+
+  describe "self.update!" do
+    before(:each) do
+      @plan = Braintree::Plan.create(
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false,
+      ).plan
+    end
+
+    it "returns the updated plan if valid" do
+      new_id = rand(36**9).to_s(36)
+      plan = Braintree::Plan.update!(@plan.id,
+                                     :name => "updated name",
+                                     :price => 99.88,
+                                    )
+
+      expect(plan.name).to eq "updated name"
+      expect(plan.price).to eq BigDecimal("99.88")
+    end
+
+    it "raises a ValidationsFailed if invalid" do
+      expect do
+        Braintree::Plan.update!(@plan.id, :number_of_billing_cycles => "number of billing cycles")
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
   def create_plan_for_tests(attributes)
     config = Braintree::Configuration.gateway.config
     config.http.post("#{config.base_merchant_path}/plans/create_plan_for_tests", :plan => attributes)

data/spec/integration/braintree/samsung_pay_card_spec.rb

@@ -8,7 +8,7 @@ describe Braintree::SamsungPayCard do
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :cardholder_name => 'Jenny Block',
+      :cardholder_name => "Jenny Block",
       :billing_address => {
           :first_name => "New First Name",
           :last_name => "New Last Name",
@@ -19,7 +19,7 @@ describe Braintree::SamsungPayCard do
           :region => "New State",
           :postal_code => "56789",
           :country_name => "United States of America"
-      }
+      },
     )
     result.should be_success
 
@@ -65,7 +65,7 @@ describe Braintree::SamsungPayCard do
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :cardholder_name => 'Jenny Block',
+      :cardholder_name => "Jenny Block",
       :billing_address => {
           :first_name => "New First Name",
           :last_name => "New Last Name",
@@ -76,11 +76,11 @@ describe Braintree::SamsungPayCard do
           :region => "New State",
           :postal_code => "56789",
           :country_name => "United States of America"
-      }
+      },
     )
 
     result.should be_success
-    result.payment_method.cardholder_name.should == 'Jenny Block'
+    result.payment_method.cardholder_name.should == "Jenny Block"
 
     address = result.payment_method.billing_address
     address.first_name.should == "New First Name"
@@ -96,7 +96,7 @@ describe Braintree::SamsungPayCard do
   it "can search for transactions" do
     transaction_create_result = Braintree::Transaction.sale(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
-      :amount => '47.00',
+      :amount => "47.00",
     )
     transaction_create_result.should be_success
     transaction_id = transaction_create_result.transaction.id
@@ -114,8 +114,8 @@ describe Braintree::SamsungPayCard do
     result = Braintree::Transaction.sale(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :amount => '47.00',
-      :options => { :store_in_vault => true },
+      :amount => "47.00",
+      :options => {:store_in_vault => true},
     )
     result.should be_success
 
@@ -138,7 +138,7 @@ describe Braintree::SamsungPayCard do
     samsung_pay_card_details.prepaid.should_not be_nil
     samsung_pay_card_details.product_id.should_not be_nil
     samsung_pay_card_details.source_card_last_4.should_not be_nil
-    samsung_pay_card_details.source_card_last_4.should == '3333'
+    samsung_pay_card_details.source_card_last_4.should == "3333"
     samsung_pay_card_details.token.should_not be_nil
   end
 end

data/spec/integration/braintree/settlement_batch_summary_spec.rb

@@ -12,7 +12,7 @@ describe Braintree::SettlementBatchSummary do
     it "returns an error response if the date cannot be parsed" do
       result = Braintree::SettlementBatchSummary.generate("NOT A DATE :(")
       result.should_not be_success
-      result.errors.for(:settlement_batch_summary).on(:settlement_date).map {|e| e.code}.should include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
+      result.errors.for(:settlement_batch_summary).on(:settlement_date).map { |e| e.code }.should include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
     end
 
     it "returns transactions settled on a given day" do
@@ -23,14 +23,14 @@ describe Braintree::SettlementBatchSummary do
           :expiration_date => "05/2012",
           :cardholder_name => "Sergio Ramos"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
       result = Braintree::SettlementBatchSummary.generate(settlement_date)
 
       result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
       amex_records.first[:count].to_i.should >= 1
       amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i
     end
@@ -46,14 +46,14 @@ describe Braintree::SettlementBatchSummary do
         :custom_fields => {
           :store_me => "1"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
-      result = Braintree::SettlementBatchSummary.generate(settlement_date, 'store_me')
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
+      result = Braintree::SettlementBatchSummary.generate(settlement_date, "store_me")
 
       result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:store_me] == "1" }
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:store_me] == "1" }
       amex_records.should_not be_empty
       amex_records.first[:count].to_i.should >= 1
       amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i