epopia-stripe-ruby-mock 2.5.8

data/spec/shared_stripe_examples/subscription_items_examples.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+shared_examples 'Subscription Items API' do
+  let(:stripe_helper) { StripeMock.create_test_helper }
+  let(:plan) { stripe_helper.create_plan }
+  let(:plan2) { stripe_helper.create_plan(amount: 100, id: 'one_more_1_plan') }
+  let(:customer) { Stripe::Customer.create(source: stripe_helper.generate_card_token) }
+  let(:subscription) { Stripe::Subscription.create(customer: customer.id, items: [{ plan: plan.id }]) }
+
+  context 'creates an item' do
+    it 'when required params only' do
+      item = Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id)
+
+      expect(item.id).to match(/^test_si/)
+      expect(item.plan.id).to eq(plan.id)
+      expect(item.subscription).to eq(subscription.id)
+    end
+    it 'when no subscription params' do
+      expect { Stripe::SubscriptionItem.create(plan: plan.id) }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription')
+        expect(e.message).to eq('Missing required param: subscription.')
+      }
+    end
+    it 'when no plan params' do
+      expect { Stripe::SubscriptionItem.create(subscription: subscription.id) }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('plan')
+        expect(e.message).to eq('Missing required param: plan.')
+      }
+    end
+  end
+
+  context 'updates an item' do
+    let(:item) { Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id, quantity: 2 ) }
+
+    it 'updates plan' do
+      updated_item = Stripe::SubscriptionItem.update(item.id, plan: plan2.id)
+
+      expect(updated_item.plan.id).to eq(plan2.id)
+    end
+    it 'updates quantity' do
+      updated_item = Stripe::SubscriptionItem.update(item.id, quantity: 23)
+
+      expect(updated_item.quantity).to eq(23)
+    end
+    it 'when no existing item' do
+      expect { Stripe::SubscriptionItem.update('some_id') }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription_item')
+        expect(e.message).to eq('No such subscription_item: some_id')
+      }
+    end
+  end
+
+  context 'retrieves a list of items' do
+    before do
+      Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id, quantity: 2 )
+      Stripe::SubscriptionItem.create(plan: plan2.id, subscription: subscription.id, quantity: 20)
+    end
+
+    it 'retrieves all subscription items' do
+      all = Stripe::SubscriptionItem.list(subscription: subscription.id)
+
+      expect(all.count).to eq(2)
+    end
+    it 'when no subscription param' do
+      expect { Stripe::SubscriptionItem.list }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription')
+        expect(e.message).to eq('Missing required param: subscription.')
+      }
+    end
+  end
+end

data/spec/shared_stripe_examples/tax_rate_examples.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+shared_examples 'TaxRate API' do
+  context 'with created tax rate' do
+    let!(:rate) { Stripe::TaxRate.create }
+
+    it 'returns list of tax rates' do
+      rates = Stripe::TaxRate.list
+      expect(rates.count).to eq(1)
+    end
+
+    it 'retrieves tax rate' do
+      ret_rate = Stripe::TaxRate.retrieve(rate.id)
+      expect(ret_rate.id).not_to be_nil
+      expect(ret_rate.object).to eq('tax_rate')
+      expect(ret_rate.display_name).to eq('VAT')
+      expect(ret_rate.percentage).to eq(21.0)
+      expect(ret_rate.jurisdiction).to eq('EU')
+      expect(ret_rate.inclusive).to eq(false)
+    end
+
+    it 'updates tax rate' do
+      ret_rate = Stripe::TaxRate.update(rate.id, percentage: 30.5)
+      expect(ret_rate.id).not_to be_nil
+      expect(ret_rate.object).to eq('tax_rate')
+      expect(ret_rate.display_name).to eq('VAT')
+      expect(ret_rate.percentage).to eq(30.5)
+      expect(ret_rate.jurisdiction).to eq('EU')
+      expect(ret_rate.inclusive).to eq(false)
+    end
+  end
+
+  it 'creates tax rate' do
+    rate = Stripe::TaxRate.create
+    expect(rate.id).not_to be_nil
+    expect(rate.object).to eq('tax_rate')
+    expect(rate.display_name).to eq('VAT')
+    expect(rate.percentage).to eq(21.0)
+    expect(rate.jurisdiction).to eq('EU')
+    expect(rate.inclusive).to eq(false)
+  end
+end

data/spec/shared_stripe_examples/transfer_examples.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+shared_examples 'Transfer API' do
+
+  it "creates a stripe transfer" do
+    destination = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", id: "acct_12345")
+    transfer = Stripe::Transfer.create(amount: 100, currency: "usd", destination: destination.id)
+
+    expect(transfer.id).to match /^test_tr/
+    expect(transfer.amount).to eq(100)
+    expect(transfer.amount_reversed).to eq(0)
+    expect(transfer.balance_transaction).to eq('txn_2dyYXXP90MN26R')
+    expect(transfer.created).to eq(1304114826)
+    expect(transfer.currency).to eq('usd')
+    expect(transfer.description).to eq('Transfer description')
+    expect(transfer.destination).to eq('acct_12345')
+    expect(transfer.destination_payment).to eq("py_164xRvKbnvuxQXGuVFV2pZo1")
+    expect(transfer.livemode).to eq(false)
+    expect(transfer.metadata).to eq(Stripe::StripeObject.new)
+    expect(transfer.reversals).to eq(Stripe::ListObject.construct_from({
+      object: "list",
+      data: [],
+      total_count: 0,
+      has_more: false,
+      url: "/v1/transfers/#{transfer.id}/reversals"
+    }))
+    expect(transfer.reversed).to eq(false)
+    expect(transfer.source_transaction).to eq("ch_164xRv2eZvKYlo2Clu1sIJWB")
+    expect(transfer.source_type).to eq("card")
+    expect(transfer.transfer_group).to eq("group_ch_164xRv2eZvKYlo2Clu1sIJWB")
+  end
+
+  describe "listing transfers" do
+    let(:destination) { Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "MyCo") }
+
+    before do
+      3.times do
+        Stripe::Transfer.create(amount: "100", currency: "usd", destination: destination.id)
+      end
+    end
+
+    it "without params retrieves all tripe transfers" do
+      expect(Stripe::Transfer.all.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::Transfer.all(limit: 2).count).to eq(2)
+    end
+
+    it "filters the search to a specific destination" do
+      d2 = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "MyCo")
+      Stripe::Transfer.create(amount: "100", currency: "usd", destination: d2.id)
+
+      expect(Stripe::Transfer.all(destination: d2.id).count).to eq(1)
+    end
+
+    it "disallows unknown parameters" do
+      expect { Stripe::Transfer.all(recipient: "foo") }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq("recipient")
+        expect(e.message).to eq("Received unknown parameter: recipient")
+        expect(e.http_status).to eq(400)
+      }
+    end
+  end
+
+
+  it "retrieves a stripe transfer" do
+    original = Stripe::Transfer.create(amount: "100", currency: "usd")
+    transfer = Stripe::Transfer.retrieve(original.id)
+
+    expect(transfer.id).to eq(original.id)
+    expect(transfer.object).to eq(original.object)
+    expect(transfer.amount).to eq(original.amount)
+    expect(transfer.amount_reversed).to eq(original.amount_reversed)
+    expect(transfer.balance_transaction).to eq(original.balance_transaction)
+    expect(transfer.created).to eq(original.created)
+    expect(transfer.currency).to eq(original.currency)
+    expect(transfer.description).to eq(original.description)
+    expect(transfer.destination).to eq(original.destination)
+    expect(transfer.destination_payment).to eq(original.destination_payment)
+    expect(transfer.livemode).to eq(original.livemode)
+    expect(transfer.metadata).to eq(original.metadata)
+    expect(transfer.reversals).to eq(original.reversals)
+    expect(transfer.reversed).to eq(original.reversed)
+    expect(transfer.source_transaction).to eq(original.source_transaction)
+    expect(transfer.source_type).to eq(original.source_type)
+    expect(transfer.transfer_group).to eq(original.transfer_group)
+  end
+
+  it "cancels a stripe transfer" do
+    original = Stripe::Transfer.create(amount:  "100", currency: "usd")
+    res, api_key = Stripe::StripeClient.active_client.execute_request(:post, "/v1/transfers/#{original.id}/cancel", api_key: 'api_key')
+
+    expect(res.data[:status]).to eq("canceled")
+  end
+
+  it "cannot retrieve a transfer that doesn't exist" do
+    expect { Stripe::Transfer.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('transfer')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "when amount is not integer", live: true do
+    dest = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "Alex Smith")
+    expect { Stripe::Transfer.create(amount: '400.2',
+                                     currency: 'usd',
+                                     destination: dest.id,
+                                     description: 'Transfer 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
+    dest = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "Alex Smith")
+    expect { Stripe::Transfer.create(amount: '-400',
+                                     currency: 'usd',
+                                     destination: dest.id,
+                                     description: 'Transfer 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/validation_examples.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+shared_examples 'Server Validation', :live => true do
+
+  def credit_card_valid?(account_number)
+    digits = account_number.scan(/./).map(&:to_i)
+    check = digits.pop
+
+    sum = digits.reverse.each_slice(2).map do |x, y|
+      [(x * 2).divmod(10), y || 0]
+    end.flatten.inject(:+)
+
+    (10 - sum % 10) == check
+  end
+
+  it "runs a luhn check for charges" do
+    Stripe::Charge.new :with => "4242424242424241"
+  end
+end

data/spec/shared_stripe_examples/webhook_event_examples.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+shared_examples 'Webhook Events API' do
+
+  it "matches the list of webhooks with the folder of fixtures" do
+    events = StripeMock::Webhooks.event_list.to_set
+    file_names = Dir['./lib/stripe_mock/webhook_fixtures/*'].map {|f| File.basename(f, '.json')}.to_set
+    # The reason we take the difference instead of compare equal is so
+    # that a missing event name will show up in the test failure report.
+    expect(events - file_names).to eq(Set.new)
+    expect(file_names - events).to eq(Set.new)
+  end
+
+
+  it "first looks in spec/fixtures/stripe_webhooks/ for fixtures by default" do
+    event = StripeMock.mock_webhook_event('account.updated')
+    payload = StripeMock.mock_webhook_payload('account.updated')
+    expect(event).to be_a(Stripe::Event)
+    expect(event.id).to match /^test_evt_[0-9]+/
+    expect(event.type).to eq('account.updated')
+
+    expect(payload).to be_a(Hash)
+    expect(payload[:id]).to match /^test_evt_[0-9]+/
+    expect(payload[:type]).to eq('account.updated')
+  end
+
+  it "allows non-standard event names in the project fixture folder" do
+    expect {
+      event = StripeMock.mock_webhook_event('custom.account.updated')
+      StripeMock.mock_webhook_payload('custom.account.updated')
+    }.to_not raise_error
+  end
+
+  it "allows configuring the project fixture folder" do
+    original_path = StripeMock.webhook_fixture_path
+
+    StripeMock.webhook_fixture_path = './spec/_dummy/webhooks/'
+    expect(StripeMock.webhook_fixture_path).to eq('./spec/_dummy/webhooks/')
+
+    event = StripeMock.mock_webhook_event('dummy.event')
+    payload = StripeMock.mock_webhook_payload('dummy.event')
+    expect(event.val).to eq('success')
+    expect(payload[:val]).to eq('success')
+
+    StripeMock.webhook_fixture_path = original_path
+  end
+
+  it "generates an event and stores it in memory" do
+    event = StripeMock.mock_webhook_event('customer.created')
+    expect(event).to be_a(Stripe::Event)
+    expect(event.id).to_not be_nil
+
+    data = test_data_source(:events)
+    expect(data[event.id]).to_not be_nil
+    expect(data[event.id][:id]).to eq(event.id)
+    expect(data[event.id][:type]).to eq('customer.created')
+  end
+
+  it "generates an id for a new event" do
+    event_a = StripeMock.mock_webhook_event('customer.created')
+    event_b = StripeMock.mock_webhook_event('customer.created')
+    expect(event_a.id).to_not be_nil
+    expect(event_a.id).to_not eq(event_b.id)
+
+    data = test_data_source(:events)
+    expect(data[event_a.id]).to_not be_nil
+    expect(data[event_a.id][:id]).to eq(event_a.id)
+
+    expect(data[event_b.id]).to_not be_nil
+    expect(data[event_b.id][:id]).to eq(event_b.id)
+  end
+
+  it "handles stripe connect event when account is present" do
+  	acc_12314 = 'acc_12314'
+    event = StripeMock.mock_webhook_event('customer.created', account: acc_12314)
+    expect(event[:account]).to eq(acc_12314)
+  end
+
+  it "retrieves an eveng using the event resource" do
+    webhook_event = StripeMock.mock_webhook_event('plan.created')
+    expect(webhook_event.id).to_not be_nil
+
+    event = Stripe::Event.retrieve(webhook_event.id)
+    expect(event).to_not be_nil
+    expect(event.type).to eq 'plan.created'
+  end
+
+  it "takes a hash and deep merges into the data object" do
+    event = StripeMock.mock_webhook_event('customer.created', {
+      :account_balance => 12345
+    })
+    payload = StripeMock.mock_webhook_event('customer.created', {
+      :account_balance => 12345
+    })
+    expect(event.data.object.account_balance).to eq(12345)
+    expect(payload[:data][:object][:account_balance]).to eq(12345)
+  end
+
+  it "takes a hash and deep merges arrays in the data object" do
+    event = StripeMock.mock_webhook_event('invoice.created', {
+      :lines => {
+        :data => [
+          { :amount => 555,
+            :plan => { :id => 'wh_test' }
+          }
+        ]
+      }
+    })
+    expect(event.data.object.lines.data.first.amount).to eq(555)
+    expect(event.data.object.lines.data.first.plan.id).to eq('wh_test')
+    # Ensure data from invoice.created.json is still present
+    expect(event.data.object.lines.data.first.type).to eq('subscription')
+    expect(event.data.object.lines.data.first.plan.currency).to eq('usd')
+  end
+
+  it "can generate all events" do
+    StripeMock::Webhooks.event_list.each do |event_name|
+      expect { StripeMock.mock_webhook_event(event_name) }.to_not raise_error
+    end
+  end
+
+  it "raises an error for non-existant event types" do
+    expect {
+      event = StripeMock.mock_webhook_event('cow.bell')
+    }.to raise_error StripeMock::UnsupportedRequestError
+
+    expect {
+      StripeMock.mock_webhook_payload('cow.bell')
+    }.to raise_error StripeMock::UnsupportedRequestError
+  end
+
+  it 'has actual created attribute' do
+    time = Time.now.to_i
+
+    evnt = StripeMock.mock_webhook_event('customer.subscription.updated')
+
+    expect(evnt.created).to eq time
+  end
+
+  it 'when created param can be overrided' do
+    time = Time.now.to_i - 1000
+
+    evnt = StripeMock.mock_webhook_event('customer.subscription.updated', created: time)
+
+    expect(evnt.created).to eq time
+  end
+
+  describe "listing events" do
+
+    it "retrieves all events" do
+      customer_created_event = StripeMock.mock_webhook_event('customer.created')
+      expect(customer_created_event).to be_a(Stripe::Event)
+      expect(customer_created_event.id).to_not be_nil
+
+      plan_created_event = StripeMock.mock_webhook_event('plan.created')
+      expect(plan_created_event).to be_a(Stripe::Event)
+      expect(plan_created_event.id).to_not be_nil
+
+      coupon_created_event = StripeMock.mock_webhook_event('coupon.created')
+      expect(coupon_created_event).to be_a(Stripe::Event)
+      expect(coupon_created_event).to_not be_nil
+
+      invoice_created_event = StripeMock.mock_webhook_event('invoice.created')
+      expect(invoice_created_event).to be_a(Stripe::Event)
+      expect(invoice_created_event).to_not be_nil
+
+      invoice_item_created_event = StripeMock.mock_webhook_event('invoiceitem.created')
+      expect(invoice_item_created_event).to be_a(Stripe::Event)
+      expect(invoice_item_created_event).to_not be_nil
+
+      events = Stripe::Event.all
+
+      expect(events.count).to eq(5)
+      expect(events.map &:id).to include(customer_created_event.id, plan_created_event.id, coupon_created_event.id, invoice_created_event.id, invoice_item_created_event.id)
+      expect(events.map &:type).to include('customer.created', 'plan.created', 'coupon.created', 'invoice.created', 'invoiceitem.created')
+    end
+
+    it "retrieves events with a limit(3)" do
+      customer_created_event = StripeMock.mock_webhook_event('customer.created')
+      expect(customer_created_event).to be_a(Stripe::Event)
+      expect(customer_created_event.id).to_not be_nil
+
+      plan_created_event = StripeMock.mock_webhook_event('plan.created')
+      expect(plan_created_event).to be_a(Stripe::Event)
+      expect(plan_created_event.id).to_not be_nil
+
+      coupon_created_event = StripeMock.mock_webhook_event('coupon.created')
+      expect(coupon_created_event).to be_a(Stripe::Event)
+      expect(coupon_created_event).to_not be_nil
+
+      invoice_created_event = StripeMock.mock_webhook_event('invoice.created')
+      expect(invoice_created_event).to be_a(Stripe::Event)
+      expect(invoice_created_event).to_not be_nil
+
+      invoice_item_created_event = StripeMock.mock_webhook_event('invoiceitem.created')
+      expect(invoice_item_created_event).to be_a(Stripe::Event)
+      expect(invoice_item_created_event).to_not be_nil
+
+      events = Stripe::Event.all(limit: 3)
+
+      expect(events.count).to eq(3)
+      expect(events.map &:id).to include(invoice_item_created_event.id, invoice_created_event.id, coupon_created_event.id)
+      expect(events.map &:type).to include('invoiceitem.created', 'invoice.created', 'coupon.created')
+    end
+
+  end
+  
+  describe 'Subscription events' do 
+    it "Checks for billing items in customer.subscription.created" do 
+      subscription_created_event = StripeMock.mock_webhook_event('customer.subscription.created')
+      expect(subscription_created_event).to be_a(Stripe::Event)
+      expect(subscription_created_event.id).to_not be_nil
+      expect(subscription_created_event.data.object.items.data.class).to be Array
+      expect(subscription_created_event.data.object.items.data.length).to be 2
+      expect(subscription_created_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_created_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+
+    it "Checks for billing items in customer.subscription.deleted" do 
+      subscription_deleted_event = StripeMock.mock_webhook_event('customer.subscription.deleted')
+      expect(subscription_deleted_event).to be_a(Stripe::Event)
+      expect(subscription_deleted_event.id).to_not be_nil
+      expect(subscription_deleted_event.data.object.items.data.class).to be Array
+      expect(subscription_deleted_event.data.object.items.data.length).to be 2
+      expect(subscription_deleted_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_deleted_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+    
+    it "Checks for billing items in customer.subscription.updated" do 
+      subscription_updated_event = StripeMock.mock_webhook_event('customer.subscription.updated')
+      expect(subscription_updated_event).to be_a(Stripe::Event)
+      expect(subscription_updated_event.id).to_not be_nil
+      expect(subscription_updated_event.data.object.items.data.class).to be Array
+      expect(subscription_updated_event.data.object.items.data.length).to be 2
+      expect(subscription_updated_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_updated_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+    
+    it "Checks for billing items in customer.subscription.trial_will_end" do 
+      subscription_trial_will_end_event = StripeMock.mock_webhook_event('customer.subscription.trial_will_end')
+      expect(subscription_trial_will_end_event).to be_a(Stripe::Event)
+      expect(subscription_trial_will_end_event.id).to_not be_nil
+      expect(subscription_trial_will_end_event.data.object.items.data.class).to be Array
+      expect(subscription_trial_will_end_event.data.object.items.data.length).to be 2
+      expect(subscription_trial_will_end_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_trial_will_end_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+  end
+
+  describe 'Invoices events' do 
+    it "Checks for billing items in invoice.payment_succeeded" do
+      invoice_payment_succeeded = StripeMock.mock_webhook_event('invoice.payment_succeeded')
+      expect(invoice_payment_succeeded).to be_a(Stripe::Event)
+      expect(invoice_payment_succeeded.id).to_not be_nil
+      expect(invoice_payment_succeeded.data.object.lines.data.class).to be Array
+      expect(invoice_payment_succeeded.data.object.lines.data.length).to be 2
+      expect(invoice_payment_succeeded.data.object.lines.data.first).to respond_to(:plan)
+      expect(invoice_payment_succeeded.data.object.lines.data.first.id).to eq('sub_00000000000000')
+    end
+  end
+end