mustwin-stripe-ruby-mock 1.8.4.10

data/spec/_dummy/webhooks/dummy.event.json

@@ -0,0 +1,6 @@
+{
+  "val": "success",
+  "data": {
+    "object": {}
+  }
+}

data/spec/fixtures/stripe_webhooks/account.updated.json

@@ -0,0 +1,7 @@
+{
+  "id": "evt_123",
+  "type": "account.updated",
+  "data": {
+    "object": {}
+  }
+}

data/spec/fixtures/stripe_webhooks/custom.account.updated.json

@@ -0,0 +1,5 @@
+{
+  "data": {
+    "object": {}
+  }
+}

data/spec/instance_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require_stripe_examples
+
+describe StripeMock::Instance do
+
+  it_behaves_like_stripe do
+    def test_data_source(type); StripeMock.instance.send(type); end
+  end
+
+  before { StripeMock.start }
+  after { StripeMock.stop }
+
+  it "handles both string and symbol hash keys" do
+    string_params = {
+      "id" => "str_abcde",
+      :name => "String Plan"
+    }
+    res, api_key = StripeMock.instance.mock_request('post', '/v1/plans', 'api_key', string_params)
+    expect(res[:id]).to eq('str_abcde')
+    expect(res[:name]).to eq('String Plan')
+  end
+
+  it "exits gracefully on an unrecognized handler url" do
+    dummy_params = {
+      "id" => "str_12345",
+      "name" => "PLAN"
+    }
+
+    expect { res, api_key = StripeMock.instance.mock_request('post', '/v1/unrecongnized_method', 'api_key', dummy_params) }.to_not raise_error
+  end
+
+  it "can toggle debug" do
+    StripeMock.toggle_debug(true)
+    expect(StripeMock.instance.debug).to eq(true)
+    StripeMock.toggle_debug(false)
+    expect(StripeMock.instance.debug).to eq(false)
+  end
+
+  it "should toggle off debug when mock session ends" do
+    StripeMock.toggle_debug(true)
+
+    StripeMock.stop
+    expect(StripeMock.instance).to be_nil
+
+    StripeMock.start
+    expect(StripeMock.instance.debug).to eq(false)
+  end
+
+end

data/spec/readme_spec.rb

@@ -0,0 +1,72 @@
+
+describe 'README examples' do
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  it "creates a stripe customer" do
+
+    # This doesn't touch stripe's servers nor the internet!
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: 'void_card_token'
+    })
+    expect(customer.email).to eq('johnny@appleseed.com')
+  end
+
+
+  it "mocks a declined card error" do
+    # Prepares an error for the next create charge request
+    StripeMock.prepare_card_error(:card_declined)
+
+    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('card_declined')
+    }
+  end
+
+  it "has built-in card errors" do
+    StripeMock.prepare_card_error(:incorrect_number)
+    StripeMock.prepare_card_error(:invalid_number)
+    StripeMock.prepare_card_error(:invalid_expiry_month)
+    StripeMock.prepare_card_error(:invalid_expiry_year)
+    StripeMock.prepare_card_error(:invalid_cvc)
+    StripeMock.prepare_card_error(:expired_card)
+    StripeMock.prepare_card_error(:incorrect_cvc)
+    StripeMock.prepare_card_error(:card_declined)
+    StripeMock.prepare_card_error(:missing)
+    StripeMock.prepare_card_error(:processing_error)
+  end
+
+  it "mocks a stripe webhook" do
+    event = StripeMock.mock_webhook_event('customer.created')
+
+    customer_object = event.data.object
+    expect(customer_object.id).to_not be_nil
+    expect(customer_object.active_card).to_not be_nil
+    # etc.
+  end
+
+  it "can override default webhook values" do
+    event = StripeMock.mock_webhook_event('customer.created', {
+      :id => 'cus_my_custom_value',
+      :email => 'joe@example.com'
+    })
+    # Alternatively:
+    # event.data.object.id = 'cus_my_custom_value'
+    # event.data.object.email = 'joe@example.com'
+    expect(event.data.object.id).to eq('cus_my_custom_value')
+    expect(event.data.object.email).to eq('joe@example.com')
+  end
+
+  it "generates a stripe card token" do
+    card_token = StripeMock.generate_card_token(last4: "9191", exp_year: 1984)
+
+    cus = Stripe::Customer.create(card: card_token)
+    card = cus.cards.data.first
+    expect(card.last4).to eq("9191")
+    expect(card.exp_year).to eq(1984)
+  end
+
+end

data/spec/server_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require_stripe_examples
+
+describe 'StripeMock Server' do
+
+  it_behaves_like_stripe do
+    def test_data_source(type); StripeMock.client.get_server_data(type); end
+  end
+
+  before(:all) do
+    StripeMock.spawn_server
+  end
+
+  after(:all) do
+    StripeMock.kill_server
+  end
+
+
+  before do
+    @client = StripeMock.start_client
+  end
+
+  after { StripeMock.stop_client(:clear_server_data => true) }
+
+
+  it "uses an RPC client for mock requests" do
+    charge = Stripe::Charge.create(
+      amount: 987,
+      currency: 'USD',
+      card: 'card_token_abcde',
+      description: 'card charge'
+    )
+    expect(charge.amount).to eq(987)
+    expect(charge.currency).to eq('USD')
+    expect(charge.description).to eq('card charge')
+  end
+
+
+  it "should not clear server data in between client sessions by default" do
+    customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+    expect(customer.email).to eq('johnny@appleseed.com')
+
+    server_customer_data = StripeMock.client.get_server_data(:customers)[customer.id]
+    expect(server_customer_data).to_not be_nil
+    expect(server_customer_data[:email]).to eq('johnny@appleseed.com')
+
+    StripeMock.stop_client
+    StripeMock.start_client
+
+    server_customer_data = StripeMock.client.get_server_data(:customers)[customer.id]
+    expect(server_customer_data).to_not be_nil
+    expect(server_customer_data[:email]).to eq('johnny@appleseed.com')
+  end
+
+
+  it "returns a response with symbolized hash keys" do
+    Stripe::Plan.create(id: 'x')
+    response, api_key = StripeMock.redirect_to_mock_server('get', '/v1/plans/x', 'xxx')
+    response.keys.each {|k| expect(k).to be_a(Symbol) }
+  end
+
+
+  it "can toggle debug" do
+    StripeMock.toggle_debug(true)
+    expect(@client.server_debug?).to eq(true)
+    StripeMock.toggle_debug(false)
+    expect(@client.server_debug?).to eq(false)
+  end
+
+
+  it "should toggle off debug when mock session ends" do
+    StripeMock.toggle_debug(true)
+
+    StripeMock.stop_client
+    expect(StripeMock.client).to be_nil
+
+    StripeMock.start_client
+    expect(StripeMock.client.server_debug?).to eq(false)
+  end
+
+
+  it "can set the default server pid path" do
+    expect(StripeMock.default_server_pid_path).to eq('./stripe-mock-server.pid')
+
+    orig = StripeMock.default_server_pid_path
+    StripeMock.default_server_pid_path = 'abc'
+    expect(StripeMock.default_server_pid_path).to eq('abc')
+
+    # Set back to original for #kill_server to work properly
+    StripeMock.default_server_pid_path = orig
+  end
+
+
+  it "doesn't create multiple clients" do
+    result = StripeMock.start_client
+    expect(result.__id__).to eq(@client.__id__)
+  end
+
+
+  it "raises an error when client is stopped" do
+    expect(@client).to be_a StripeMock::Client
+    expect(@client.state).to eq('ready')
+
+    StripeMock.stop_client
+    expect(@client.state).to eq('closed')
+    expect { @client.clear_server_data }.to raise_error StripeMock::ClosedClientConnectionError
+  end
+
+
+  it "raises an error when client connection is closed" do
+    expect(@client).to be_a StripeMock::Client
+    expect(@client.state).to eq('ready')
+
+    @client.close!
+    expect(@client.state).to eq('closed')
+    expect(StripeMock.stop_client).to eq(false)
+  end
+
+
+  it "throws an error when server is not running" do
+    StripeMock.stop_client
+    begin
+      StripeMock.start_client(1515)
+      # We should never get here
+      expect(false).to eq(true)
+    rescue StripeMock::ServerTimeoutError => e
+      expect(e.associated_error).to be_a(Errno::ECONNREFUSED)
+    end
+  end
+
+end

data/spec/shared_stripe_examples/card_token_examples.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+shared_examples 'Card Token Mocking' do
+
+  it "generates and reads a card token for create customer" do
+    card_token = StripeMock.generate_card_token(last4: "9191", exp_month: 99, exp_year: 3005)
+
+    cus = Stripe::Customer.create(card: card_token)
+    card = cus.cards.data.first
+    expect(card.last4).to eq("9191")
+    expect(card.exp_month).to eq(99)
+    expect(card.exp_year).to eq(3005)
+  end
+
+  it "generated and reads a card token for update customer" do
+    card_token = StripeMock.generate_card_token(last4: "1133", exp_month: 11, exp_year: 2099)
+
+    cus = Stripe::Customer.create()
+    cus.card = card_token
+    cus.save
+
+    card = cus.cards.data.first
+    expect(card.last4).to eq("1133")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(2099)
+  end
+
+end

data/spec/shared_stripe_examples/charge_examples.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+shared_examples 'Charge API' do
+
+  it "creates a stripe charge item with a card token" do
+    charge = Stripe::Charge.create(
+      amount: 999,
+      currency: 'USD',
+      card: 'card_token_abcde',
+      description: 'card charge'
+    )
+
+    expect(charge.id).to match(/^test_ch/)
+    expect(charge.amount).to eq(999)
+    expect(charge.description).to eq('card charge')
+    expect(charge.captured).to eq(true)
+  end
+
+
+  it "stores a created stripe charge in memory" do
+    charge = Stripe::Charge.create({
+      amount: 333,
+      currency: 'USD',
+      card: 'card_token_333'
+    })
+    charge2 = Stripe::Charge.create({
+      amount: 777,
+      currency: 'USD',
+      card: 'card_token_777'
+    })
+    data = test_data_source(:charges)
+    expect(data[charge.id]).to_not be_nil
+    expect(data[charge.id][:amount]).to eq(333)
+
+    expect(data[charge2.id]).to_not be_nil
+    expect(data[charge2.id][:amount]).to eq(777)
+  end
+
+
+  it "retrieves a stripe charge" do
+    original = Stripe::Charge.create({
+      amount: 777,
+      currency: 'USD',
+      card: 'card_token_abc'
+    })
+    charge = Stripe::Charge.retrieve(original.id)
+
+    expect(charge.id).to eq(original.id)
+    expect(charge.amount).to eq(original.amount)
+  end
+
+  it "cannot retrieve a charge that doesn't exist" do
+    expect { Stripe::Charge.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('charge')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+
+  context "With strict mode toggled off" do
+
+    before { StripeMock.toggle_strict(false) }
+
+    it "retrieves a stripe charge with an id that doesn't exist" do
+      charge = Stripe::Charge.retrieve('test_charge_x')
+      expect(charge.id).to eq('test_charge_x')
+      expect(charge.amount).to_not be_nil
+      expect(charge.card).to_not be_nil
+    end
+  end
+
+
+  describe 'captured status value' do
+    it "reports captured by default" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        card: 'card_token_abc'
+      })
+
+      expect(charge.captured).to be_true
+    end
+
+    it "reports captured if capture requested" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        card: 'card_token_abc',
+        capture: true
+      })
+
+      expect(charge.captured).to be_true
+    end
+
+    it "reports not captured if capture: false requested" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        card: 'card_token_abc',
+        capture: false
+      })
+
+      expect(charge.captured).to be_false
+    end
+  end
+
+  describe "two-step charge (auth, then capture)" do
+    it "changes captured status upon #capture" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        card: 'card_token_abc',
+        capture: false
+      })
+
+      returned_charge = charge.capture
+      expect(charge.captured).to be_true
+      expect(returned_charge.id).to eq(charge.id)
+      expect(returned_charge.captured).to be_true
+    end
+  end
+end

data/spec/shared_stripe_examples/customer_examples.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+shared_examples 'Customer API' do
+
+  it "creates a stripe customer with a default card" do
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: 'some_card_token',
+      description: "a description"
+    })
+    expect(customer.id).to match(/^test_cus/)
+    expect(customer.email).to eq('johnny@appleseed.com')
+    expect(customer.description).to eq('a description')
+
+    expect(customer.cards.count).to eq(1)
+    expect(customer.cards.data.length).to eq(1)
+    expect(customer.default_card).to_not be_nil
+    expect(customer.default_card).to eq customer.cards.data.first.id
+
+    expect { customer.card }.to raise_error
+  end
+
+  it "creates a stripe customer without a card" do
+    customer = Stripe::Customer.create({
+      email: 'cardless@appleseed.com',
+      description: "no card"
+    })
+    expect(customer.id).to match(/^test_cus/)
+    expect(customer.email).to eq('cardless@appleseed.com')
+    expect(customer.description).to eq('no card')
+
+    expect(customer.cards.count).to eq(0)
+    expect(customer.cards.data.length).to eq(0)
+    expect(customer.default_card).to be_nil
+  end
+
+  it "stores a created stripe customer in memory" do
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: 'some_card_token'
+    })
+    customer2 = Stripe::Customer.create({
+      email: 'bob@bobbers.com',
+      card: 'another_card_token'
+    })
+    data = test_data_source(:customers)
+    expect(data[customer.id]).to_not be_nil
+    expect(data[customer.id][:email]).to eq('johnny@appleseed.com')
+
+    expect(data[customer2.id]).to_not be_nil
+    expect(data[customer2.id][:email]).to eq('bob@bobbers.com')
+  end
+
+  it "retrieves a stripe customer" do
+    original = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: 'some_card_token'
+    })
+    customer = Stripe::Customer.retrieve(original.id)
+
+    expect(customer.id).to eq(original.id)
+    expect(customer.email).to eq(original.email)
+    expect(customer.default_card).to eq(original.default_card)
+    expect(customer.subscription).to be_nil
+  end
+
+  it "cannot retrieve a customer that doesn't exist" do
+    expect { Stripe::Customer.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('customer')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "retrieves all customers" do
+    Stripe::Customer.create({ email: 'one@one.com' })
+    Stripe::Customer.create({ email: 'two@two.com' })
+
+    all = Stripe::Customer.all
+    expect(all.length).to eq(2)
+    all.map(&:email).should include('one@one.com', 'two@two.com')
+  end
+
+  it "updates a stripe customer" do
+    original = Stripe::Customer.create(id: 'test_customer_update')
+    email = original.email
+
+    original.description = 'new desc'
+    original.save
+
+    expect(original.email).to eq(email)
+    expect(original.description).to eq('new desc')
+
+    customer = Stripe::Customer.retrieve("test_customer_update")
+    expect(customer.email).to eq(original.email)
+    expect(customer.description).to eq('new desc')
+  end
+
+  it "updates a stripe customer's card" do
+    original = Stripe::Customer.create(id: 'test_customer_update', card: 'token')
+    card = original.cards.data.first
+    expect(original.default_card).to eq(card.id)
+    expect(original.cards.count).to eq(1)
+
+    original.card = 'new_token'
+    original.save
+
+    new_card = original.cards.data.first
+    expect(original.cards.count).to eq(1)
+    expect(original.default_card).to eq(new_card.id)
+
+    expect(new_card.id).to_not eq(card.id)
+  end
+
+  it "updates a stripe customer's subscription" do
+    plan = Stripe::Plan.create(id: 'silver')
+    customer = Stripe::Customer.create(id: 'test_customer_sub', card: 'tk')
+    sub = customer.update_subscription({ :plan => 'silver' })
+
+    expect(sub.object).to eq('subscription')
+    expect(sub.plan.id).to eq('silver')
+    expect(sub.plan.to_hash).to eq(plan.to_hash)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.subscription).to_not be_nil
+    expect(customer.subscription.id).to eq(sub.id)
+    expect(customer.subscription.plan.id).to eq('silver')
+    expect(customer.subscription.customer).to eq(customer.id)
+  end
+
+  it "throws an error when subscribing a customer with no card" do
+    plan = Stripe::Plan.create(id: 'enterprise', amount: 499)
+    customer = Stripe::Customer.create(id: 'cardless')
+
+    expect { customer.update_subscription({ :plan => 'enterprise' }) }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.http_status).to eq(400)
+      expect(e.message).to_not be_nil
+    }
+  end
+
+  it "subscribes a customer with no card to a free plan" do
+    plan = Stripe::Plan.create(id: 'free_tier', amount: 0)
+    customer = Stripe::Customer.create(id: 'cardless')
+    sub = customer.update_subscription({ :plan => 'free_tier' })
+
+    expect(sub.object).to eq('subscription')
+    expect(sub.plan.id).to eq('free_tier')
+    expect(sub.plan.to_hash).to eq(plan.to_hash)
+
+    customer = Stripe::Customer.retrieve('cardless')
+    expect(customer.subscription).to_not be_nil
+    expect(customer.subscription.id).to eq(sub.id)
+    expect(customer.subscription.plan.id).to eq('free_tier')
+    expect(customer.subscription.customer).to eq(customer.id)
+  end
+
+  it "subscribes a customer with no card to a plan with a free trial" do
+    plan = Stripe::Plan.create(id: 'trial', amount: 999, trial_period_days: 14)
+    customer = Stripe::Customer.create(id: 'cardless')
+    sub = customer.update_subscription({ :plan => 'trial' })
+
+    expect(sub.object).to eq('subscription')
+    expect(sub.plan.id).to eq('trial')
+    expect(sub.plan.to_hash).to eq(plan.to_hash)
+
+    customer = Stripe::Customer.retrieve('cardless')
+    expect(customer.subscription).to_not be_nil
+    expect(customer.subscription.id).to eq(sub.id)
+    expect(customer.subscription.plan.id).to eq('trial')
+    expect(customer.subscription.customer).to eq(customer.id)
+  end
+
+  it "cancels a stripe customer's subscription" do
+    plan = Stripe::Plan.create(id: 'the truth')
+    customer = Stripe::Customer.create(id: 'test_customer_sub', card: 'tk')
+    sub = customer.update_subscription({ :plan => 'the truth' })
+
+    result = customer.cancel_subscription
+    expect(result.deleted).to eq(true)
+    expect(result.id).to eq(sub.id)
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.subscription).to be_nil
+  end
+
+  it "cannot update to a plan that does not exist" do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    expect {
+      customer.update_subscription(plan: 'imagination')
+    }.to raise_error Stripe::InvalidRequestError
+  end
+
+  it "cannot cancel a plan that does not exist" do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    expect {
+      customer.cancel_subscription(plan: 'imagination')
+    }.to raise_error Stripe::InvalidRequestError
+  end
+
+  it "deletes a customer" do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    customer = customer.delete
+    expect(customer.deleted).to be_true
+  end
+
+  context "With strict mode toggled off" do
+
+    before { StripeMock.toggle_strict(false) }
+
+    it "retrieves a stripe customer with an id that doesn't exist" do
+      customer = Stripe::Customer.retrieve('test_customer_x')
+      expect(customer.id).to eq('test_customer_x')
+      expect(customer.email).to_not be_nil
+      expect(customer.description).to_not be_nil
+    end
+  end
+
+end