stripe-ruby-mock 2.5.8 → 3.0.0

data/spec/shared_stripe_examples/dispute_examples.rb

@@ -71,14 +71,14 @@ shared_examples 'Dispute API' do
   describe "listing disputes" do
 
     it "retrieves all disputes" do
-      disputes = Stripe::Dispute.all
+      disputes = Stripe::Dispute.list
 
       expect(disputes.count).to eq(10)
       expect(disputes.map &:id).to include('dp_05RsQX2eZvKYlo2C0FRTGSSA','dp_15RsQX2eZvKYlo2C0ERTYUIA', 'dp_25RsQX2eZvKYlo2C0ZXCVBNM', 'dp_35RsQX2eZvKYlo2C0QAZXSWE', 'dp_45RsQX2eZvKYlo2C0EDCVFRT', 'dp_55RsQX2eZvKYlo2C0OIKLJUY', 'dp_65RsQX2eZvKYlo2C0ASDFGHJ', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ', 'dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_95RsQX2eZvKYlo2C0EDFRYUI')
     end
 
     it "retrieves disputes with a limit(3)" do
-      disputes = Stripe::Dispute.all(limit: 3)
+      disputes = Stripe::Dispute.list(limit: 3)
 
       expect(disputes.count).to eq(3)
       expected = ['dp_95RsQX2eZvKYlo2C0EDFRYUI','dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ']

data/spec/shared_stripe_examples/error_mock_examples.rb

@@ -6,13 +6,14 @@ def expect_card_error(code, param)
     expect(e.http_status).to eq(402)
     expect(e.code).to eq(code)
     expect(e.param).to eq(param)
+    expect(e.http_body).to eq(e.json_body.to_json)
   }
 end
 
 shared_examples 'Stripe Error Mocking' do
 
   it "mocks a manually given stripe card error" do
-    error = Stripe::CardError.new('Test Msg', 'param_name', 'bad_code', http_status: 444, http_body: 'body', json_body: 'json body')
+    error = Stripe::CardError.new('Test Msg', 'param_name', code: 'bad_code', http_status: 444, http_body: 'body', json_body: {})
     StripeMock.prepare_error(error)
 
     expect { Stripe::Customer.create() }.to raise_error {|e|
@@ -23,14 +24,14 @@ shared_examples 'Stripe Error Mocking' do
 
       expect(e.http_status).to eq(444)
       expect(e.http_body).to eq('body')
-      expect(e.json_body).to eq('json body')
+      expect(e.json_body).to eq({})
     }
   end
 
 
   it "mocks a manually gives stripe invalid request error" do
 
-    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: 'json ibody')
+    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: {})
     StripeMock.prepare_error(error)
 
     expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error {|e|
@@ -40,22 +41,22 @@ shared_examples 'Stripe Error Mocking' do
 
       expect(e.http_status).to eq(987)
       expect(e.http_body).to eq('ibody')
-      expect(e.json_body).to eq('json ibody')
+      expect(e.json_body).to eq({})
     }
   end
 
 
   it "mocks a manually gives stripe invalid auth error" do
-    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: 'json abody')
+    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: {})
     StripeMock.prepare_error(error)
 
-    expect { stripe_helper.create_plan() }.to raise_error {|e|
+    expect { stripe_helper.create_plan(id: "test_plan") }.to raise_error {|e|
       expect(e).to be_a(Stripe::AuthenticationError)
       expect(e.message).to eq('Bad Auth')
 
       expect(e.http_status).to eq(499)
       expect(e.http_body).to eq('abody')
-      expect(e.json_body).to eq('json abody')
+      expect(e.json_body).to eq({})
     }
   end
 

data/spec/shared_stripe_examples/external_account_examples.rb

@@ -63,7 +63,7 @@ shared_examples 'External Account API' do
     let!(:bank) { account.external_accounts.create(external_account: bank_token) }
 
     it "can retrieve all account's banks" do
-      retrieved = account.external_accounts.all
+      retrieved = account.external_accounts.list
       expect(retrieved.count).to eq(1)
     end
 
@@ -142,7 +142,7 @@ shared_examples 'External Account API' do
 
       account = Stripe::Account.retrieve('test_account')
 
-      list = account.external_accounts.all
+      list = account.external_accounts.list
 
       expect(list.object).to eq("list")
       expect(list.count).to eq(2)
@@ -159,7 +159,7 @@ shared_examples 'External Account API' do
       Stripe::Account.create(id: 'no_banks', type: 'custom', country: "US")
       account = Stripe::Account.retrieve('no_banks')
 
-      list = account.external_accounts.all
+      list = account.external_accounts.list
 
       expect(list.object).to eq("list")
       expect(list.count).to eq(0)

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -48,27 +48,28 @@ shared_examples 'Invoice API' do
     end
 
     it "stores invoices for a customer in memory" do
-      expect(@customer.invoices.map(&:id)).to eq([@invoice.id])
+      invoices = Stripe::Invoice.list(customer: @customer.id)
+      expect(invoices.map(&:id)).to eq([@invoice.id])
     end
 
     it "stores all invoices in memory" do
-      expect(Stripe::Invoice.all.map(&:id).sort).to eq([@invoice.id, @invoice2.id].sort)
+      expect(Stripe::Invoice.list.map(&:id)).to match_array([@invoice.id, @invoice2.id])
     end
 
     it "defaults count to 10 invoices" do
       11.times { Stripe::Invoice.create }
-      expect(Stripe::Invoice.all.count).to eq(10)
+      expect(Stripe::Invoice.list.count).to eq(10)
     end
 
     it "is marked as having more when more objects exist" do
       11.times { Stripe::Invoice.create }
 
-      expect(Stripe::Invoice.all.has_more).to eq(true)
+      expect(Stripe::Invoice.list.has_more).to eq(true)
     end
 
     context "when passing limit" do
       it "gets that many invoices" do
-        expect(Stripe::Invoice.all(limit: 1).count).to eq(1)
+        expect(Stripe::Invoice.list(limit: 1).count).to eq(1)
       end
     end
   end
@@ -109,8 +110,9 @@ shared_examples 'Invoice API' do
   context "retrieving upcoming invoice" do
     let(:customer)      { Stripe::Customer.create(source: stripe_helper.generate_card_token) }
     let(:coupon_amtoff) { stripe_helper.create_coupon(id: '100OFF', currency: 'usd', amount_off: 100_00, duration: 'repeating', duration_in_months: 6) }
-    let(:coupon_pctoff) { stripe_helper.create_coupon(id: '50%OFF', currency: 'usd', percent_off: 50, amount_off: nil, duration: 'repeating', duration_in_months: 6) }
-    let(:plan)          { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+    let(:coupon_pctoff) { stripe_helper.create_coupon(id: '50OFF', currency: 'usd', percent_off: 50, amount_off: nil, duration: 'repeating', duration_in_months: 6) }
+    let(:product)       { stripe_helper.create_product(id: "prod_123") }
+    let(:plan)          { stripe_helper.create_plan(id: '50m', product: product.id, amount: 50_00, interval: 'month', nickname: '50m', currency: 'usd') }
     let(:quantity)      { 3 }
     let(:subscription)  { Stripe::Subscription.create(plan: plan.id, customer: customer.id, quantity: quantity) }
 
@@ -198,8 +200,8 @@ shared_examples 'Invoice API' do
         expect(upcoming.discount).not_to be_nil
         expect(upcoming.discount.coupon.id).to eq '100OFF'
         expect(upcoming.discount.customer).to eq customer.id
-        expect(upcoming.discount.start).to be_within(5).of Time.now.to_i
-        expect(upcoming.discount.end).to be_within(5).of (Time.now.to_datetime >> 6).to_time.to_i
+        expect(upcoming.discount.start).to be_within(60).of Time.now.to_i
+        expect(upcoming.discount.end).to be_within(60).of (Time.now.to_datetime >> 6).to_time.to_i
         expect(upcoming.amount_due).to eq plan.amount * quantity - 100_00
         expect(upcoming.subtotal).to eq(upcoming.lines.data[0].amount)
         expect(upcoming.total).to eq upcoming.subtotal - 100_00
@@ -211,10 +213,10 @@ shared_examples 'Invoice API' do
 
         # Then
         expect(upcoming.discount).not_to be_nil
-        expect(upcoming.discount.coupon.id).to eq '50%OFF'
+        expect(upcoming.discount.coupon.id).to eq '50OFF'
         expect(upcoming.discount.customer).to eq customer.id
-        expect(upcoming.discount.start).to be_within(5).of Time.now.to_i
-        expect(upcoming.discount.end).to be_within(5).of (Time.now.to_datetime >> 6).to_time.to_i
+        expect(upcoming.discount.start).to be_within(60).of Time.now.to_i
+        expect(upcoming.discount.end).to be_within(60).of (Time.now.to_datetime >> 6).to_time.to_i
         expect(upcoming.amount_due).to eq (plan.amount * quantity) * 0.5
         expect(upcoming.subtotal).to eq(upcoming.lines.data[0].amount)
         expect(upcoming.total).to eq upcoming.subtotal * 0.5
@@ -223,7 +225,7 @@ shared_examples 'Invoice API' do
 
     describe 'proration' do
       shared_examples 'failing when proration date is outside of the subscription current period' do
-        it 'fails', live: true do
+        it 'fails', live: true, skip: 'Stripe does not raise error anymore' do
           expect { Stripe::Invoice.upcoming(
               customer: customer.id,
               subscription: subscription.id,
@@ -248,9 +250,9 @@ shared_examples 'Invoice API' do
 
       [false, true].each do |with_trial|
         describe "prorating a subscription with a new plan, with_trial: #{with_trial}" do
-          let(:new_monthly_plan) { stripe_helper.create_plan(id: '100m', amount: 100_00, interval: 'month', name: '100m', currency: 'usd') }
-          let(:new_yearly_plan) { stripe_helper.create_plan(id: '100y', amount: 100_00, interval: 'year', name: '100y', currency: 'usd') }
-          let(:plan) { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+          let(:new_monthly_plan) { stripe_helper.create_plan(id: '100m', product: product.id, amount: 100_00, interval: 'month', nickname: '100m', currency: 'usd') }
+          let(:new_yearly_plan) { stripe_helper.create_plan(id: '100y', product: product.id, amount: 100_00, interval: 'year', nickname: '100y', currency: 'usd') }
+          let(:plan) { stripe_helper.create_plan(id: '50m', product: product.id, amount: 50_00, interval: 'month', nickname: '50m', currency: 'usd') }
 
           it 'prorates while maintaining billing interval', live: true do
             # Given
@@ -271,19 +273,17 @@ shared_examples 'Invoice API' do
             # Then
             expect(upcoming).to be_a Stripe::Invoice
             expect(upcoming.customer).to eq(customer.id)
-            if with_trial
-              expect(upcoming.amount_due).to be_within(1).of 0
-            else
-              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
-            end
             expect(upcoming.starting_balance).to eq -credit_balance
-            expect(upcoming.ending_balance).to be_nil
             expect(upcoming.subscription).to eq(subscription.id)
 
             if with_trial
+              expect(upcoming.amount_due).to be_within(1).of 0
               expect(upcoming.lines.data.length).to eq(2)
+              expect(upcoming.ending_balance).to be_within(50).of -13540
             else
+              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
               expect(upcoming.lines.data.length).to eq(3)
+              expect(upcoming.ending_balance).to eq 0
             end
 
             expect(upcoming.lines.data[0].proration).to be_truthy
@@ -308,9 +308,10 @@ shared_examples 'Invoice API' do
             # Given
             proration_date = Time.now + 5 * 24 * 3600 # 5 days later
             new_quantity = 2
-            unused_amount = plan.amount * quantity * (subscription.current_period_end - proration_date.to_i) / (subscription.current_period_end - subscription.current_period_start)
+            unused_amount = (plan.amount.to_f * quantity * (subscription.current_period_end - proration_date.to_i) / (subscription.current_period_end - subscription.current_period_start)).round
             prorated_amount_due = new_yearly_plan.amount * new_quantity - unused_amount
             credit_balance = 1000
+            amount_due = prorated_amount_due - credit_balance
             customer.account_balance = -credit_balance
             customer.save
             query = { customer: customer.id, subscription: subscription.id, subscription_plan: new_yearly_plan.id, subscription_proration_date: proration_date.to_i, subscription_quantity: new_quantity }
@@ -323,17 +324,18 @@ shared_examples 'Invoice API' do
             expect(upcoming).to be_a Stripe::Invoice
             expect(upcoming.customer).to eq(customer.id)
             if with_trial
+              expect(upcoming.ending_balance).to be_within(50).of -13540
               expect(upcoming.amount_due).to eq 0
             else
-              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
+              expect(upcoming.ending_balance).to eq 0
+              expect(upcoming.amount_due).to eq amount_due
             end
             expect(upcoming.starting_balance).to eq -credit_balance
-            expect(upcoming.ending_balance).to be_nil
             expect(upcoming.subscription).to eq(subscription.id)
 
             expect(upcoming.lines.data[0].proration).to be_truthy
             expect(upcoming.lines.data[0].plan.id).to eq '50m'
-            expect(upcoming.lines.data[0].amount).to be_within(1).of -unused_amount
+            expect(upcoming.lines.data[0].amount).to eq -unused_amount
             expect(upcoming.lines.data[0].quantity).to eq quantity
 
             expect(upcoming.lines.data[1].proration).to be_falsey
@@ -351,7 +353,7 @@ shared_examples 'Invoice API' do
         it 'generates a preview without performing an actual proration', live: true do
           expect(preview.subtotal).to eq 150_00
           # this is a future invoice (generted at the end of the current subscription cycle), rather than a proration invoice
-          expect(preview.created).to be_within(1).of subscription.current_period_end
+          expect(preview.due_date).to be_nil
           expect(preview.period_start).to eq subscription.current_period_start
           expect(preview.period_end).to eq subscription.current_period_end
           expect(preview.lines.count).to eq 1
@@ -393,7 +395,7 @@ shared_examples 'Invoice API' do
     end
 
     it 'sets the start and end of billing periods correctly when plan has an interval_count' do
-      @oddplan = stripe_helper.create_plan(interval: "week", interval_count: 11)
+      @oddplan = stripe_helper.create_plan(product: product.id, interval: "week", interval_count: 11, id: "weekly_pl")
       @subscription = Stripe::Subscription.create(plan: @oddplan.id, customer: customer.id)
       @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -404,9 +406,9 @@ shared_examples 'Invoice API' do
     end
 
     it 'chooses the most recent of multiple subscriptions' do
-      @shortplan = stripe_helper.create_plan(id: 'a', interval: "week") # 1 week sub
-      @plainplan = stripe_helper.create_plan(id: 'b')                 # 1 month sub
-      @longplan  = stripe_helper.create_plan(id: 'c', interval: "year") # 1 year sub
+      @shortplan = stripe_helper.create_plan(id: 'a', product: product.id, interval: "week") # 1 week sub
+      @plainplan = stripe_helper.create_plan(id: 'b', product: product.id, interval: "month") # 1 month sub
+      @longplan  = stripe_helper.create_plan(id: 'c', product: product.id, interval: "year") # 1 year sub
 
       @plainsub = Stripe::Subscription.create(plan: @plainplan.id, customer: customer.id)
       @shortsub = Stripe::Subscription.create(plan: @shortplan.id, customer: customer.id)
@@ -428,7 +430,7 @@ shared_examples 'Invoice API' do
     context 'retrieving invoice line items' do
       it 'returns all line items for created invoice' do
         invoice = Stripe::Invoice.create(customer: customer.id)
-        line_items = invoice.lines.all
+        line_items = invoice.lines.list
 
         expect(invoice).to be_a Stripe::Invoice
         expect(line_items.count).to eq(1)
@@ -438,7 +440,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'returns all line items for upcoming invoice' do
-        plan = stripe_helper.create_plan()
+        plan = stripe_helper.create_plan(product: product.id, id: "silver_pl")
         subscription = Stripe::Subscription.create(plan: plan.id, customer: customer.id)
         upcoming = Stripe::Invoice.upcoming(customer: customer.id)
         line_items = upcoming.lines
@@ -454,7 +456,7 @@ shared_examples 'Invoice API' do
     context 'calculates month and year offsets correctly' do
 
       it 'for one month plan on the 1st' do
-        @plan = stripe_helper.create_plan()
+        @plan = stripe_helper.create_plan(product: product.id, id: "one_mo_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2014,1,1,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -465,7 +467,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one year plan on the 1st' do
-        @plan = stripe_helper.create_plan(interval: "year")
+        @plan = stripe_helper.create_plan(interval: "year", product: product.id, id: "year_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2012,1,1,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -476,7 +478,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one month plan on the 31st' do
-        @plan = stripe_helper.create_plan()
+        @plan = stripe_helper.create_plan(product: product.id, id: "one_mo_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2014,1,31,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -487,7 +489,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one year plan on feb. 29th' do
-        @plan = stripe_helper.create_plan(interval: "year")
+        @plan = stripe_helper.create_plan(product: product.id, interval: "year", id: "year_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2012,2,29,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -498,7 +500,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for two month plan on dec. 31st' do
-        @plan = stripe_helper.create_plan(interval_count: 2)
+        @plan = stripe_helper.create_plan(product: product.id, interval_count: 2, id: 'two_mo_plan')
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2013,12,31,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -509,7 +511,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for three month plan on nov. 30th' do
-        @plan = stripe_helper.create_plan(interval_count: 3)
+        @plan = stripe_helper.create_plan(product: product.id, interval_count: 3)
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2013,11,30,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 

data/spec/shared_stripe_examples/invoice_item_examples.rb

@@ -39,7 +39,7 @@ shared_examples 'Invoice Item API' do
     end
 
     it "retrieves all invoice items" do
-      all = Stripe::InvoiceItem.all
+      all = Stripe::InvoiceItem.list
       expect(all.count).to eq(2)
       expect(all.map &:amount).to include(1075, 1540)
     end

data/spec/shared_stripe_examples/payment_intent_examples.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+shared_examples 'PaymentIntent API' do
+
+  it "creates a succeeded stripe payment_intent" do
+    payment_intent = Stripe::PaymentIntent.create(amount:  100, currency: "usd")
+
+    expect(payment_intent.id).to match(/^test_pi/)
+    expect(payment_intent.amount).to eq(100)
+    expect(payment_intent.currency).to eq('usd')
+    expect(payment_intent.metadata.to_hash).to eq({})
+    expect(payment_intent.status).to eq('succeeded')
+  end
+
+  it "creates a requires_action stripe payment_intent when amount matches 3184" do
+    payment_intent = Stripe::PaymentIntent.create(amount:  3184, currency: "usd")
+
+    expect(payment_intent.id).to match(/^test_pi/)
+    expect(payment_intent.amount).to eq(3184)
+    expect(payment_intent.currency).to eq('usd')
+    expect(payment_intent.metadata.to_hash).to eq({})
+    expect(payment_intent.status).to eq('requires_action')
+    expect(payment_intent.next_action.type).to eq('use_stripe_sdk')
+  end
+
+  it "creates a requires_payment_method stripe payment_intent when amount matches 3184" do
+    payment_intent = Stripe::PaymentIntent.create(amount: 3178, currency: "usd")
+
+    expect(payment_intent.id).to match(/^test_pi/)
+    expect(payment_intent.amount).to eq(3178)
+    expect(payment_intent.currency).to eq('usd')
+    expect(payment_intent.metadata.to_hash).to eq({})
+    expect(payment_intent.status).to eq('requires_payment_method')
+    expect(payment_intent.last_payment_error.code).to eq('card_declined')
+    expect(payment_intent.last_payment_error.decline_code).to eq('insufficient_funds')
+    expect(payment_intent.last_payment_error.message).to eq('Not enough funds.')
+  end
+
+  describe "listing payment_intent" do
+    before do
+      3.times do
+        Stripe::PaymentIntent.create(amount: 100, currency: "usd")
+      end
+    end
+
+    it "without params retrieves all stripe payment_intent" do
+      expect(Stripe::PaymentIntent.list.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::PaymentIntent.list(limit: 2).count).to eq(2)
+    end
+  end
+
+  it "retrieves a stripe payment_intent" do
+    original = Stripe::PaymentIntent.create(amount:  100, currency: "usd")
+    payment_intent = Stripe::PaymentIntent.retrieve(original.id)
+
+    expect(payment_intent.id).to eq(original.id)
+    expect(payment_intent.amount).to eq(original.amount)
+    expect(payment_intent.currency).to eq(original.currency)
+    expect(payment_intent.metadata.to_hash).to eq(original.metadata.to_hash)
+  end
+
+  it "cannot retrieve a payment_intent that doesn't exist" do
+    expect { Stripe::PaymentIntent.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('payment_intent')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it 'creates and confirms a stripe payment_intent with confirm flag to true' do
+    payment_intent = Stripe::PaymentIntent.create(
+      amount: 100, currency: 'usd', confirm: true
+    )
+    expect(payment_intent.status).to eq('succeeded')
+    expect(payment_intent.charges.data.size).to eq(1)
+    expect(payment_intent.charges.data.first.object).to eq('charge')
+    balance_txn = payment_intent.charges.data.first.balance_transaction
+    expect(balance_txn).to match(/^test_txn/)
+    expect(Stripe::BalanceTransaction.retrieve(balance_txn).id).to eq(balance_txn)
+  end
+
+  it "confirms a stripe payment_intent" do
+    payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
+    confirmed_payment_intent = payment_intent.confirm()
+    expect(confirmed_payment_intent.status).to eq("succeeded")
+    expect(confirmed_payment_intent.charges.data.size).to eq(1)
+    expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
+  end
+
+  it "captures a stripe payment_intent" do
+    payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
+    confirmed_payment_intent = payment_intent.capture()
+    expect(confirmed_payment_intent.status).to eq("succeeded")
+    expect(confirmed_payment_intent.charges.data.size).to eq(1)
+    expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
+  end
+
+  it "cancels a stripe payment_intent" do
+    payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
+    confirmed_payment_intent = payment_intent.cancel()
+    expect(confirmed_payment_intent.status).to eq("canceled")
+  end
+
+  it "updates a stripe payment_intent" do
+    original = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
+    payment_intent = Stripe::PaymentIntent.retrieve(original.id)
+
+    payment_intent.amount = 200
+    payment_intent.save
+
+    updated = Stripe::PaymentIntent.retrieve(original.id)
+
+    expect(updated.amount).to eq(200)
+  end
+
+  it 'when amount is not integer', live: true do
+    expect { Stripe::PaymentIntent.create(amount: 400.2,
+                                         currency: 'usd') }.to raise_error { |e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('amount')
+      expect(e.http_status).to eq(400)
+    }
+  end
+
+  it 'when amount is negative', live: true do
+    expect { Stripe::PaymentIntent.create(amount: -400,
+                                     currency: 'usd') }.to raise_error { |e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('amount')
+      expect(e.message).to match(/^Invalid.*integer/)
+      expect(e.http_status).to eq(400)
+    }
+  end
+end