mustwin-stripe-ruby-mock 1.8.4.10

data/spec/shared_stripe_examples/error_mock_examples.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+def expect_card_error(code, param)
+  expect { Stripe::Charge.create() }.to raise_error {|e|
+    expect(e).to be_a(Stripe::CardError)
+    expect(e.http_status).to eq(402)
+    expect(e.code).to eq(code)
+    expect(e.param).to eq(param)
+  }
+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', 444, 'body', 'json body')
+    StripeMock.prepare_error(error)
+
+    expect { Stripe::Customer.create() }.to raise_error {|e|
+      expect(e).to be_a(Stripe::CardError)
+      expect(e.code).to eq('bad_code')
+      expect(e.param).to eq('param_name')
+      expect(e.message).to eq('Test Msg')
+
+      expect(e.http_status).to eq(444)
+      expect(e.http_body).to eq('body')
+      expect(e.json_body).to eq('json body')
+    }
+  end
+
+
+  it "mocks a manually gives stripe invalid request error" do
+
+    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', 987, 'ibody', 'json ibody')
+    StripeMock.prepare_error(error)
+
+    expect { Stripe::Charge.create() }.to raise_error {|e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.param).to eq('param')
+      expect(e.message).to eq('Test Invalid')
+
+      expect(e.http_status).to eq(987)
+      expect(e.http_body).to eq('ibody')
+      expect(e.json_body).to eq('json ibody')
+    }
+  end
+
+
+  it "mocks a manually gives stripe invalid auth error" do
+    error = Stripe::AuthenticationError.new('Bad Auth', 499, 'abody', 'json abody')
+    StripeMock.prepare_error(error)
+
+    expect { Stripe::Plan.create() }.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')
+    }
+  end
+
+
+  it "raises a custom error for specific actions" do
+    custom_error = StandardError.new("Please knock first.")
+    StripeMock.prepare_error(custom_error, :new_customer)
+
+    expect { Stripe::Charge.create }.to_not raise_error
+    expect { Stripe::Customer.create }.to raise_error {|e|
+      expect(e).to be_a StandardError
+      expect(e.message).to eq("Please knock first.")
+    }
+  end
+
+  # # # # # # # # # # # # # #
+  # Card Error Helper Methods
+  # # # # # # # # # # # # # #
+
+  it "raises an error for an unrecognized card error code" do
+    expect { StripeMock.prepare_card_error(:non_existant_error_code) }.to raise_error {|e|
+      expect(e).to be_a(StripeMock::StripeMockError)
+    }
+  end
+
+  it "only raises a card error when a card charge is attempted" do
+    StripeMock.prepare_card_error(:card_declined)
+    expect { Stripe::Customer.create(id: 'x') }.to_not raise_error
+    expect { Stripe::Charge.create() }.to raise_error Stripe::CardError
+  end
+
+  it "mocks a card error with a given handler" do
+    StripeMock.prepare_card_error(:incorrect_cvc, :new_customer)
+    expect { Stripe::Charge.create() }.to_not raise_error
+
+    expect { Stripe::Customer.create() }.to raise_error {|e|
+      expect(e).to be_a(Stripe::CardError)
+      expect(e.http_status).to eq(402)
+      expect(e.code).to eq('incorrect_cvc')
+      expect(e.param).to eq('cvc')
+    }
+  end
+
+  it "mocks an incorrect number card error" do
+    StripeMock.prepare_card_error(:incorrect_number)
+    expect_card_error 'incorrect_number', 'number'
+  end
+
+  it "mocks an invalid number card error" do
+    StripeMock.prepare_card_error(:invalid_number)
+    expect_card_error 'invalid_number', 'number'
+  end
+
+  it "mocks an invalid expiration month card error" do
+    StripeMock.prepare_card_error(:invalid_expiry_month)
+    expect_card_error 'invalid_expiry_month', 'exp_month'
+  end
+
+  it "mocks an invalid expiration year card error" do
+    StripeMock.prepare_card_error(:invalid_expiry_year)
+    expect_card_error 'invalid_expiry_year', 'exp_year'
+  end
+
+  it "mocks an invalid cvc card error" do
+    StripeMock.prepare_card_error(:invalid_cvc)
+    expect_card_error 'invalid_cvc', 'cvc'
+  end
+
+  it "mocks an expired card error" do
+    StripeMock.prepare_card_error(:expired_card)
+    expect_card_error 'expired_card', 'exp_month'
+  end
+
+  it "mocks an incorrect cvc card error" do
+    StripeMock.prepare_card_error(:incorrect_cvc)
+    expect_card_error 'incorrect_cvc', 'cvc'
+  end
+
+  it "mocks a declined card error" do
+    StripeMock.prepare_card_error(:card_declined)
+    expect_card_error 'card_declined', nil
+  end
+
+  it "mocks a missing card error" do
+    StripeMock.prepare_card_error(:missing)
+    expect_card_error 'missing', nil
+  end
+
+  it "mocks a processing error card error" do
+    StripeMock.prepare_card_error(:processing_error)
+    expect_card_error 'processing_error', nil
+  end
+
+end

data/spec/shared_stripe_examples/invoice_item_examples.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+shared_examples 'Invoice Item API' 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.amount).to eq(1099)
+    expect(invoice_item.description).to eq('invoice item desc')
+  end
+
+end

data/spec/shared_stripe_examples/plan_examples.rb

@@ -0,0 +1,123 @@
+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,
+      :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.trial_period_days).to eq(30)
+  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
+    )
+    plan2 = Stripe::Plan.create(
+      :id => 'pid_3',
+      :name => 'The Bonk Plan',
+      :amount => 7777,
+      :currency => 'USD',
+      :interval => 1
+    )
+    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::Plan.create({
+      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::Plan.create(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::Plan.create(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::Plan.create({ id: 'Plan One', amount: 54321 })
+    Stripe::Plan.create({ id: 'Plan Two', amount: 98765 })
+
+    all = Stripe::Plan.all
+    expect(all.length).to eq(2)
+    all.map(&:id).should include('Plan One', 'Plan Two')
+    all.map(&:amount).should include(54321, 98765)
+  end
+
+
+  context "With strict mode toggled off" do
+
+    before { StripeMock.toggle_strict(false) }
+
+    it "can retrieve a stripe plan with an id that doesn't exist" do
+      plan = Stripe::Plan.retrieve('test_charge_x')
+
+      expect(plan.id).to eq('test_charge_x')
+      expect(plan.amount).to_not be_nil
+      expect(plan.name).to_not be_nil
+
+      expect(plan.currency).to_not be_nil
+      expect(plan.interval).to_not be_nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'set'
+
+gem 'rspec', '~> 2.4'
+require 'rspec'
+require 'stripe'
+require 'stripe_mock'
+require 'stripe_mock/server'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["./spec/support/**/*.rb"].each {|f| require f}

data/spec/stripe_mock_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe StripeMock do
+
+  it "overrides stripe's request method" do
+    StripeMock.start
+    Stripe.request(:xtest, '/', 'abcde') # no error
+    StripeMock.stop
+  end
+
+  it "reverts overriding stripe's request method" do
+    StripeMock.start
+    Stripe.request(:xtest, '/', 'abcde') # no error
+    StripeMock.stop
+    expect { Stripe.request(:x, '/', 'abcde') }.to raise_error
+  end
+
+  it "does not persist data between mock sessions" do
+    StripeMock.start
+    StripeMock.instance.customers[:x] = 9
+
+    StripeMock.stop
+    StripeMock.start
+
+    expect(StripeMock.instance.customers[:x]).to be_nil
+    expect(StripeMock.instance.customers.keys.length).to eq(0)
+    StripeMock.stop
+  end
+
+  it "throws an error when trying to prepare an error before starting" do
+    expect { StripeMock.prepare_error(StandardError.new) }.to raise_error {|e|
+      expect(e).to be_a(StripeMock::UnstartedStateError)
+    }
+
+    expect { StripeMock.prepare_card_error(:card_declined) }.to raise_error {|e|
+      expect(e).to be_a(StripeMock::UnstartedStateError)
+    }
+  end
+
+end

data/spec/support/stripe_examples.rb

@@ -0,0 +1,18 @@
+
+def require_stripe_examples
+  require 'shared_stripe_examples/card_token_examples'
+  require 'shared_stripe_examples/charge_examples'
+  require 'shared_stripe_examples/customer_examples'
+  require 'shared_stripe_examples/error_mock_examples'
+  require 'shared_stripe_examples/invoice_item_examples'
+  require 'shared_stripe_examples/plan_examples'
+end
+
+def it_behaves_like_stripe(&block)
+  it_behaves_like 'Card Token Mocking', &block
+  it_behaves_like 'Charge API', &block
+  it_behaves_like 'Customer API', &block
+  it_behaves_like 'Invoice Item API', &block
+  it_behaves_like 'Plan API', &block
+  it_behaves_like 'Stripe Error Mocking', &block
+end

data/spec/util_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe StripeMock::Util do
+
+  it "recursively merges a simple hash" do
+    dest = { x: { y: 50 }, a: 5, b: 3 }
+    source = { x: { y: 999 }, a: 77 }
+    result = StripeMock::Util.rmerge(dest, source)
+
+    expect(result).to eq({ x: { y: 999 }, a: 77, b: 3 })
+  end
+
+  it "recursively merges a nested hash" do
+    dest = { x: { y: 50, z: { m: 44, n: 4 } } }
+    source = { x: { y: 999, z: { n: 55 } } }
+    result = StripeMock::Util.rmerge(dest, source)
+
+    expect(result).to eq({ x: { y: 999, z: { m: 44, n: 55 } } })
+  end
+
+  it "merges array elements" do
+    dest = { x: [ {a: 1}, {b: 2}, {c: 3} ] }
+    source = { x: [ {a: 0}, {a: 0} ] }
+    result = StripeMock::Util.rmerge(dest, source)
+
+    expect(result).to eq({ x: [ {a: 0}, {a: 0, b: 2}, {c: 3} ] })
+  end
+
+  it "treats an array nil element as a skip op" do
+    dest = { x: [ {a: 1}, {b: 2}, {c: 3} ] }
+    source = { x: [ nil, nil, {c: 0} ] }
+    result = StripeMock::Util.rmerge(dest, source)
+
+    expect(result).to eq({ x: [ {a: 1}, {b: 2}, {c: 0} ] })
+  end
+
+  it "treats nil as a replacement otherwise" do
+    dest = { x: 99 }
+    source = { x: nil }
+    result = StripeMock::Util.rmerge(dest, source)
+
+    expect(result).to eq({ x: nil })
+  end
+
+end

data/spec/webhook_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'Webhook Generation' 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')
+    expect(event).to be_a(Stripe::Event)
+    expect(event.id).to eq('evt_123')
+    expect(event.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')
+    }.to_not raise_error
+  end
+
+  it "allows configuring the project fixture folder" do
+    StripeMock.webhook_fixture_path = './spec/_dummy/webhooks/'
+    expect(StripeMock.webhook_fixture_path).to eq('./spec/_dummy/webhooks/')
+
+    event = StripeMock.mock_webhook_event('dummy.event')
+    expect(event.val).to eq('success')
+  end
+
+  it "generates an event" do
+    event = StripeMock.mock_webhook_event('customer.created')
+    expect(event).to be_a(Stripe::Event)
+  end
+
+  it "takes a hash and deep merges into the data object" do
+    event = StripeMock.mock_webhook_event('customer.created', {
+      :account_balance => 12345
+    })
+    expect(event.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
+  end
+
+end