epopia-stripe-ruby-mock 2.5.8

data/spec/shared_stripe_examples/invoice_item_examples.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+shared_examples 'Invoice Item API' do
+
+  context "creating a new invoice item" do
+    it "creates a stripe invoice item" do
+      invoice_item = Stripe::InvoiceItem.create({
+        amount: 1099,
+        customer: 1234,
+        currency: 'USD',
+        description: "invoice item desc"
+      }, 'abcde')
+
+      expect(invoice_item.id).to match(/^test_ii/)
+      expect(invoice_item.amount).to eq(1099)
+      expect(invoice_item.description).to eq('invoice item desc')
+    end
+
+    it "stores a created stripe invoice item in memory" do
+      invoice_item = Stripe::InvoiceItem.create
+      data = test_data_source(:invoice_items)
+      expect(data[invoice_item.id]).to_not be_nil
+      expect(data[invoice_item.id][:id]).to eq(invoice_item.id)
+    end
+  end
+
+  context "retrieving an invoice item" do
+    it "retrieves a stripe invoice item" do
+      original = Stripe::InvoiceItem.create
+      invoice_item = Stripe::InvoiceItem.retrieve(original.id)
+      expect(invoice_item.id).to eq(original.id)
+    end
+  end
+
+  context "retrieving a list of invoice items" do
+    before do
+      Stripe::InvoiceItem.create({ amount: 1075 })
+      Stripe::InvoiceItem.create({ amount: 1540 })
+    end
+
+    it "retrieves all invoice items" do
+      all = Stripe::InvoiceItem.all
+      expect(all.count).to eq(2)
+      expect(all.map &:amount).to include(1075, 1540)
+    end
+  end
+
+  it "updates a stripe invoice_item" do
+    original = Stripe::InvoiceItem.create(id: 'test_invoice_item_update')
+    amount = original.amount
+
+    original.description = 'new desc'
+    original.save
+
+    expect(original.amount).to eq(amount)
+    expect(original.description).to eq('new desc')
+
+    invoice_item = Stripe::InvoiceItem.retrieve("test_invoice_item_update")
+    expect(invoice_item.amount).to eq(original.amount)
+    expect(invoice_item.description).to eq('new desc')
+  end
+
+  it "deletes a invoice_item" do
+    invoice_item = Stripe::InvoiceItem.create(id: 'test_invoice_item_sub')
+    invoice_item = invoice_item.delete
+    expect(invoice_item.deleted).to eq true
+  end
+
+end

data/spec/shared_stripe_examples/payment_intent_examples.rb

@@ -0,0 +1,131 @@
+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')
+  end
+
+  it "creates a requires_payment_method stripe payment_intent when amount matches 3178" 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
+
+  it "creates a requires_capture stripe payment_intent when amount matches 3169" do
+    payment_intent = Stripe::PaymentIntent.create(amount: 3169, currency: "usd")
+
+    expect(payment_intent.id).to match(/^test_pi/)
+    expect(payment_intent.amount).to eq(3169)
+    expect(payment_intent.currency).to eq('usd')
+    expect(payment_intent.metadata.to_hash).to eq({})
+    expect(payment_intent.status).to eq('requires_capture')
+  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.all.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::PaymentIntent.all(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 "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")
+  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).not_to be_nil
+  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

data/spec/shared_stripe_examples/payment_method_examples.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+shared_examples 'PaymentMethod API' do
+  let(:billing_details) do
+    {
+      address: {
+        city: 'North New Portland',
+        country: 'US',
+        line1: '2631 Bloomfield Way',
+        line2: 'Apartment 5B',
+        postal_code: '05555',
+        state: 'ME'
+      },
+      email: 'john@example.com',
+      name: 'John Doe',
+      phone: '555-555-5555'
+    }
+  end
+  let(:card_details) do
+    {
+      number: 4242_4242_4242_4242,
+      exp_month: 9,
+      exp_year: (Time.now.year + 5),
+      cvc: 999
+    }
+  end
+
+  # post /v1/payment_methods
+  describe 'Create a PaymentMethod', live: true do
+    let(:payment_method) do
+      Stripe::PaymentMethod.create(
+        type: type,
+        billing_details: billing_details,
+        card: card_details,
+        metadata: {
+          order_id: '123456789'
+        }
+      )
+    end
+    let(:type) { 'card' }
+
+    it 'creates a payment method with a valid id', live: false do
+      expect(payment_method.id).to match(/^test_pm/)
+    end
+
+    it 'creates a payment method with a billing address' do
+      expect(payment_method.billing_details.address.city).to eq('North New Portland')
+      expect(payment_method.billing_details.address.country).to eq('US')
+      expect(payment_method.billing_details.address.line1).to eq('2631 Bloomfield Way')
+      expect(payment_method.billing_details.address.line2).to eq('Apartment 5B')
+      expect(payment_method.billing_details.address.postal_code).to eq('05555')
+      expect(payment_method.billing_details.address.state).to eq('ME')
+      expect(payment_method.billing_details.email).to eq('john@example.com')
+      expect(payment_method.billing_details.name).to  eq('John Doe')
+      expect(payment_method.billing_details.phone).to eq('555-555-5555')
+    end
+
+    it 'creates a payment method with metadata' do
+      expect(payment_method.metadata.order_id).to eq('123456789')
+    end
+
+    context 'when type is invalid' do
+      let(:type) { 'bank_account' }
+
+      it 'raises invalid requestion exception' do
+        expect { payment_method }.to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+
+  # get /v1/payment_methods/:id
+  describe 'Retrieve a PaymentMethod', live: true do
+    it 'retrieves a given payment method' do
+      customer = Stripe::Customer.create
+      original = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+      Stripe::PaymentMethod.attach(original.id, customer: customer.id)
+
+      payment_method = Stripe::PaymentMethod.retrieve(original.id)
+
+      expect(payment_method.id).to eq(original.id)
+      expect(payment_method.type).to eq(original.type)
+      expect(payment_method.customer).to eq(customer.id)
+    end
+  end
+
+  # get /v1/payment_methods
+  describe "List a Customer's PaymentMethods", live: true do
+    let(:customer)  { Stripe::Customer.create }
+    let(:customer2) { Stripe::Customer.create }
+    before do
+      3.times do
+        payment_method = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+        Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+      end
+    end
+
+    it 'lists all payment methods' do
+      expect(Stripe::PaymentMethod.list(customer: customer.id, type: 'card').count).to eq(3)
+    end
+
+    context 'when passing a limit' do
+      it 'only lists the limited number of payment methods' do
+        expect(Stripe::PaymentMethod.list(customer: customer.id, type: 'card', limit: 2).count).to eq(2)
+      end
+    end
+
+    context 'when listing the payment methods of another customer' do
+      it 'does not list any payment methods' do
+        expect(Stripe::PaymentMethod.list(customer: customer2.id, type: 'card').count).to eq(0)
+      end
+    end
+  end
+
+  # post /v1/payment_methods/:id/attach
+  describe 'Attach a PaymentMethod to a Customer', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) { Stripe::PaymentMethod.create(type: 'card', card: card_details) }
+
+    it 'attaches a payment method to a customer' do
+      expect { Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id) }
+        .to change { Stripe::PaymentMethod.retrieve(payment_method.id).customer }
+        .from(nil).to(customer.id)
+    end
+
+    context "when the customer doesn't exist" do
+      it 'raises invalid requestion exception' do
+        expect { Stripe::PaymentMethod.attach(payment_method.id, customer: 'cus_invalid') }
+          .to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+
+  # post /v1/payment_methods/:id/detach
+  describe 'Detach a PaymentMethod from a Customer', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) do
+      payment_method = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+      Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+    end
+
+    it 'detaches a PaymentMethod from a customer' do
+      expect { Stripe::PaymentMethod.detach(payment_method.id) }
+        .to change { Stripe::PaymentMethod.retrieve(payment_method.id).customer }
+        .from(customer.id).to(nil)
+    end
+  end
+
+  # post /v1/payment_methods/:id
+  describe 'Update a PaymentMethod', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) do
+      Stripe::PaymentMethod.create(type: 'card', card: card_details)
+    end
+
+    it 'updates the card for the payment method' do
+      Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+
+      original_card_exp_month = payment_method.card.exp_month
+      new_card_exp_month = 12
+
+      expect do
+        Stripe::PaymentMethod.update(payment_method.id, card: { exp_month: new_card_exp_month })
+      end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).card.exp_month }
+        .from(original_card_exp_month).to(new_card_exp_month)
+    end
+
+    context 'without a customer' do
+      it 'raises invalid requestion exception' do
+        expect do
+          Stripe::PaymentMethod.update(payment_method.id, card: { exp_month: 12 })
+        end.to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+end

data/spec/shared_stripe_examples/payout_examples.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+shared_examples 'Payout API' do
+
+  it "creates a stripe payout" do
+    payout = Stripe::Payout.create(amount:  "100", currency: "usd")
+
+    expect(payout.id).to match(/^test_po/)
+    expect(payout.amount).to eq('100')
+    expect(payout.currency).to eq('usd')
+    expect(payout.metadata.to_hash).to eq({})
+  end
+
+  describe "listing payouts" do
+    before do
+      3.times do
+        Stripe::Payout.create(amount: "100", currency: "usd")
+      end
+    end
+
+    it "without params retrieves all tripe payouts" do
+      expect(Stripe::Payout.all.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::Payout.all(limit: 2).count).to eq(2)
+    end
+  end
+
+  it "retrieves a stripe payout" do
+    original = Stripe::Payout.create(amount:  "100", currency: "usd")
+    payout = Stripe::Payout.retrieve(original.id)
+
+    expect(payout.id).to eq(original.id)
+    expect(payout.amount).to eq(original.amount)
+    expect(payout.currency).to eq(original.currency)
+    expect(payout.metadata.to_hash).to eq(original.metadata.to_hash)
+  end
+
+  it "cannot retrieve a payout that doesn't exist" do
+    expect { Stripe::Payout.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('payout')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it 'when amount is not integer', live: true do
+    expect { Stripe::Payout.create(amount: '400.2',
+                                       currency: 'usd',
+                                       description: 'Payout for test@example.com') }.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::Payout.create(amount: '-400',
+                                     currency: 'usd',
+                                     description: 'Payout for test@example.com') }.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

data/spec/shared_stripe_examples/plan_examples.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+shared_examples 'Plan API' do
+
+  it "creates a stripe plan" do
+    plan = Stripe::Plan.create(
+      :id => 'pid_1',
+      :name => 'The Mock Plan',
+      :amount => 9900,
+      :currency => 'USD',
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      },
+      :metadata => {
+        :description => "desc text",
+        :info => "info text"
+      },
+      :trial_period_days => 30
+    )
+
+    expect(plan.id).to eq('pid_1')
+    expect(plan.name).to eq('The Mock Plan')
+    expect(plan.amount).to eq(9900)
+
+    expect(plan.currency).to eq('USD')
+    expect(plan.interval).to eq(1)
+
+    expect(plan.metadata.description).to eq('desc text')
+    expect(plan.metadata.info).to eq('info text')
+
+    expect(plan.trial_period_days).to eq(30)
+  end
+
+
+  it "creates a stripe plan without specifying ID" do
+    plan = Stripe::Plan.create(
+      :name => 'The Mock Plan',
+      :amount => 9900,
+      :currency => 'USD',
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
+    )
+
+    expect(plan.id).to match(/^test_plan/)
+  end
+
+  it "stores a created stripe plan in memory" do
+    plan = Stripe::Plan.create(
+      :id => 'pid_2',
+      :name => 'The Memory Plan',
+      :amount => 1100,
+      :currency => 'USD',
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
+    )
+    plan2 = Stripe::Plan.create(
+      :id => 'pid_3',
+      :name => 'The Bonk Plan',
+      :amount => 7777,
+      :currency => 'USD',
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
+    )
+    data = test_data_source(:plans)
+    expect(data[plan.id]).to_not be_nil
+    expect(data[plan.id][:amount]).to eq(1100)
+
+    expect(data[plan2.id]).to_not be_nil
+    expect(data[plan2.id][:amount]).to eq(7777)
+  end
+
+
+  it "retrieves a stripe plan" do
+    original = stripe_helper.create_plan(amount: 1331)
+    plan = Stripe::Plan.retrieve(original.id)
+
+    expect(plan.id).to eq(original.id)
+    expect(plan.amount).to eq(original.amount)
+  end
+
+
+  it "updates a stripe plan" do
+    stripe_helper.create_plan(id: 'super_member', amount: 111)
+
+    plan = Stripe::Plan.retrieve('super_member')
+    expect(plan.amount).to eq(111)
+
+    plan.amount = 789
+    plan.save
+    plan = Stripe::Plan.retrieve('super_member')
+    expect(plan.amount).to eq(789)
+  end
+
+
+  it "cannot retrieve a stripe plan that doesn't exist" do
+    expect { Stripe::Plan.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('plan')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "deletes a stripe plan" do
+    stripe_helper.create_plan(id: 'super_member', amount: 111)
+
+    plan = Stripe::Plan.retrieve('super_member')
+    expect(plan).to_not be_nil
+
+    plan.delete
+
+    expect { Stripe::Plan.retrieve('super_member') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('plan')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "retrieves all plans" do
+    stripe_helper.create_plan(id: 'Plan One', amount: 54321)
+    stripe_helper.create_plan(id: 'Plan Two', amount: 98765)
+
+    all = Stripe::Plan.all
+    expect(all.count).to eq(2)
+    expect(all.map &:id).to include('Plan One', 'Plan Two')
+    expect(all.map &:amount).to include(54321, 98765)
+  end
+
+  it 'retrieves plans with limit' do
+    101.times do | i|
+      stripe_helper.create_plan(id: "Plan #{i}", amount: 11)
+    end
+    all = Stripe::Plan.all(limit: 100)
+
+    expect(all.count).to eq(100)
+  end
+
+  it 'validates the amount' do
+    expect {
+      Stripe::Plan.create(
+        :id => 'pid_1',
+        :name => 'The Mock Plan',
+        :amount => 99.99,
+        :currency => 'USD',
+        :interval => 'month',
+        :product => {
+          :name => 'A product'
+        }
+      )
+    }.to raise_error(Stripe::InvalidRequestError, "Invalid integer: 99.99")
+  end
+
+  describe "Validation", :live => true do
+    let(:params) { stripe_helper.create_plan_params }
+    let(:subject) { Stripe::Plan.create(params) }
+
+    describe "Required Parameters" do
+      after do
+        params.delete(@name)
+        message =
+          if @name == :amount
+            "Plans require an `#{@name}` parameter to be set."
+          else
+            "Missing required param: #{@name}."
+          end
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
+      end
+
+      it("requires a product") { @name = :product }
+      it("requires an amount") { @name = :amount }
+      it("requires a currency") { @name = :currency }
+      it("requires an interval") { @name = :interval }
+    end
+
+    describe "Uniqueness" do
+
+      it "validates for uniqueness" do
+        stripe_helper.delete_plan(params[:id])
+
+        Stripe::Plan.create(params)
+        expect {
+          Stripe::Plan.create(params)
+        }.to raise_error(Stripe::InvalidRequestError, "Plan already exists.")
+      end
+    end
+  end
+
+end