braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/paypal_account_spec.rb

@@ -9,23 +9,25 @@ 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
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.should be_a(Braintree::PayPalAccount)
-      paypal_account.token.should == payment_method_token
-      paypal_account.email.should == "jane.doe@example.com"
-      paypal_account.image_url.should_not be_nil
-      paypal_account.created_at.should_not be_nil
-      paypal_account.updated_at.should_not be_nil
-      paypal_account.customer_id.should == customer.id
-      paypal_account.revoked_at.should be_nil
+      expect(paypal_account).to be_a(Braintree::PayPalAccount)
+      expect(paypal_account.token).to eq(payment_method_token)
+      expect(paypal_account.email).to eq("jane.doe@example.com")
+      expect(paypal_account.image_url).not_to be_nil
+      expect(paypal_account.created_at).not_to be_nil
+      expect(paypal_account.updated_at).not_to be_nil
+      expect(paypal_account.customer_id).to eq(customer.id)
+      expect(paypal_account.funding_source_description).to be_nil
+      expect(paypal_account.edit_paypal_vault_id).to be_nil
+      expect(paypal_account.revoked_at).to be_nil
     end
 
     it "returns a PayPalAccount with a billing agreement id" do
@@ -35,12 +37,12 @@ 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
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.billing_agreement_id.should_not be_nil
+      expect(paypal_account.billing_agreement_id).not_to be_nil
     end
 
     it "raises if the payment method token is not found" do
@@ -51,12 +53,12 @@ describe Braintree::PayPalAccount do
 
     it "does not return a different payment method type" do
       customer = Braintree::Customer.create!
-      result = Braintree::CreditCard.create(
+      Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :token => "CREDIT_CARD_TOKEN"
+        :token => "CREDIT_CARD_TOKEN",
       )
 
       expect do
@@ -70,28 +72,28 @@ 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
+      expect(result).to be_success
 
       token = result.payment_method.token
 
       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)
-      paypal_account.subscriptions.map(&:id).sort.should == [subscription1.id, subscription2.id].sort
+      expect(paypal_account.subscriptions.map(&:id).sort).to eq([subscription1.id, subscription2.id].sort)
     end
   end
 
@@ -105,33 +107,33 @@ describe Braintree::PayPalAccount do
         :options => {
             :make_default => true,
             :fail_on_duplicate_payment_method => true,
-        }
+        },
       )
 
-      result.should be_success
-      result.paypal_account.billing_agreement_id.should == "some_billing_agreement_id"
-      result.paypal_account.email.should == "some@example.com"
+      expect(result).to be_success
+      expect(result.paypal_account.billing_agreement_id).to eq("some_billing_agreement_id")
+      expect(result.paypal_account.email).to eq("some@example.com")
     end
 
     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
-      result.errors.first.code.should == "82905"
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.code).to eq("82905")
     end
 
     it "throws an error if billing agreement id is not specified" 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
-      result.errors.first.code.should == "82902"
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include("82902")
     end
   end
 
@@ -141,21 +143,21 @@ 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
+      expect(create_result.success?).to eq(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
+      expect(update_result.success?).to eq(true)
       paypal_account = update_result.paypal_account
 
-      paypal_account.billing_agreement_id.should == "second_billing_agreement_id"
-      paypal_account.email.should == "second@example.com"
+      expect(paypal_account.billing_agreement_id).to eq("second_billing_agreement_id")
+      expect(paypal_account.email).to eq("second@example.com")
     end
 
     it "updates a paypal account's token" do
@@ -163,21 +165,21 @@ 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(
+      Braintree::PayPalAccount.update(
         original_token,
-        :token => updated_token
+        :token => updated_token,
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
-      updated_paypal_account.email.should == original_result.payment_method.email
+      expect(updated_paypal_account.email).to eq(original_result.payment_method.email)
 
       expect do
         Braintree::PayPalAccount.find(original_token)
@@ -190,23 +192,23 @@ 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
+      expect(result).to 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(
+      Braintree::PayPalAccount.update(
         original_token,
-        :options => {:make_default => true}
+        :options => {:make_default => true},
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(original_token)
-      updated_paypal_account.should be_default
+      expect(updated_paypal_account).to be_default
     end
 
     it "returns an error if a token for account is used to attempt an update" do
@@ -216,29 +218,29 @@ 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(
+      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(
+      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
-      updated_result.errors.first.code.should == "92906"
+      expect(updated_result).not_to be_success
+      expect(updated_result.errors.first.code).to eq("92906")
     end
   end
 
@@ -249,14 +251,14 @@ 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)
+      Braintree::PayPalAccount.delete(token)
 
       expect do
         Braintree::PayPalAccount.find(token)
@@ -267,31 +269,31 @@ 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::PayPalBillingAgreement,
       )
 
       result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 
   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::PayPalBillingAgreement,
       )
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 end

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
 
@@ -25,26 +26,106 @@ describe Braintree::Plan do
 
       plans = Braintree::Plan.all
       plan = plans.select { |plan| plan.id == plan_token }.first
-      plan.should_not be_nil
-      plan.id.should == attributes[:id]
-      plan.billing_day_of_month.should == attributes[:billing_day_of_month]
-      plan.billing_frequency.should == attributes[:billing_frequency]
-      plan.currency_iso_code.should == attributes[:currency_iso_code]
-      plan.description.should == attributes[:description]
-      plan.name.should == attributes[:name]
-      plan.number_of_billing_cycles.should == attributes[:number_of_billing_cycles]
-      plan.price.should == Braintree::Util.to_big_decimal("1.00")
-      plan.trial_period.should == attributes[:trial_period]
-      plan.created_at.should_not be_nil
-      plan.updated_at.should_not be_nil
-      plan.add_ons.first.name.should == add_on_name
-      plan.discounts.first.name.should == discount_name
+      expect(plan).not_to be_nil
+      expect(plan.id).to eq(attributes[:id])
+      expect(plan.billing_day_of_month).to eq(attributes[:billing_day_of_month])
+      expect(plan.billing_frequency).to eq(attributes[:billing_frequency])
+      expect(plan.currency_iso_code).to eq(attributes[:currency_iso_code])
+      expect(plan.description).to eq(attributes[:description])
+      expect(plan.name).to eq(attributes[:name])
+      expect(plan.number_of_billing_cycles).to eq(attributes[:number_of_billing_cycles])
+      expect(plan.price).to eq(Braintree::Util.to_big_decimal("1.00"))
+      expect(plan.trial_period).to eq(attributes[:trial_period])
+      expect(plan.created_at).not_to be_nil
+      expect(plan.updated_at).not_to be_nil
+      expect(plan.add_ons.first.name).to eq(add_on_name)
+      expect(plan.discounts.first.name).to eq(discount_name)
     end
 
     it "returns an empty array if there are no plans" do
       gateway = Braintree::Gateway.new(SpecHelper::TestMerchantConfig)
       plans = gateway.plan.all
-      plans.should == []
+      expect(plans).to eq([])
+    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
+      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