stripe-ruby-mock 1.8.1.1 → 1.8.3.0

data/README.md

@@ -1,6 +1,6 @@
 # stripe-ruby-mock
 
-* Homepage: https://github.com/mindeavor/stripe-ruby-mock#readme
+* Homepage: https://github.com/mindeavor/stripe-ruby-mock
 * Issues: https://github.com/mindeavor/stripe-ruby-mock/issues
 
 ## Install
@@ -9,8 +9,8 @@
 
 ## Features
 
-* Easily test against stripe errors
 * No stripe server access required
+* Easily test against stripe errors
 
 ## Description
 
@@ -23,29 +23,67 @@ without the need to actually hit stripe's servers.
 
 You can use stripe-ruby-mock with any ruby testing library. Here's a quick dummy example with RSpec:
 
-    require 'stripe'
-    require 'stripe_mock'
-
-    describe MyApp do
-      before { StripeMock.start }
-      after { StripeMock.stop }
-
-      it "should create 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
-    end
+```ruby
+require 'stripe'
+require 'stripe_mock'
+
+describe MyApp 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
+end
+```
+
+## Mocking Errors
+
+Tired of manually inputting fake credit card numbers to test against errors? Consider it a thing of the past!
+
+```ruby
+it "mocks a declined card error" do
+  # Prepares an error for the next stripe request
+  StripeMock.prepare_card_error(:card_declined)
+
+  begin
+    # Note: The next request of ANY type will raise your prepared error
+    Stripe::Charge.create()
+  rescue Stripe::CardError => error
+    expect(error.http_status).to eq(402)
+    expect(error.code).to eq('card_declined')
+  end
+end
+```
+
+You can also set your own custom Stripe error using `prepare_error`:
+
+```ruby
+it "raises a custom error" do
+  custom_error = Stripe::AuthenticationError.new('Did not provide favourite colour', 400)
+  StripeMock.prepare_error(custom_error)
+
+  begin
+    # Note: The next request of ANY type will raise your prepared error
+    Stripe::Invoice.create()
+  rescue Stripe::AuthenticationError => error
+    expect(error.http_status).to eq(400)
+    expect(error.message).to eq('Did not provide favourite colour')
+  end
+end
+```
 
 ## TODO
 
 * Cover all stripe urls/methods
-* Mock stripe error responses
-* Create hash for storing/retrieving stripe objects in-memory
+* Create hash for storing/retrieving all stripe objects in-memory
+  * Currently implemented for: **Customers** and **Charges**
 
 ## Copyright
 

data/lib/stripe_mock.rb

@@ -1,29 +1,12 @@
+require 'ostruct'
+
 require 'stripe_mock/version'
 require 'stripe_mock/data'
-require 'stripe_mock/methods'
-
-module StripeMock
-
-  @@init = false
-  @@enabled = false
-
-  def self.start
-    if @@init == false
-      @@request_method = Stripe.method(:request)
-      @@init = true
-    end
-    alias_stripe_method :request, Methods.method(:mock_request)
-    @@enabled = true
-  end
-
-  def self.stop
-    return unless @@enabled == true
-    alias_stripe_method :request, @@request_method
-    @@enabled = false
-  end
 
-  def self.alias_stripe_method(new_name, method_object)
-    Stripe.define_singleton_method(new_name) {|*args| method_object.call(*args) }
-  end
+require 'stripe_mock/api/instance'
+require 'stripe_mock/api/errors'
 
-end
+require 'stripe_mock/request_handlers/charges.rb'
+require 'stripe_mock/request_handlers/customers.rb'
+require 'stripe_mock/request_handlers/invoice_items.rb'
+require 'stripe_mock/instance'

data/lib/stripe_mock/api/errors.rb

@@ -0,0 +1,30 @@
+module StripeMock
+
+  def self.prepare_error(stripe_error)
+    instance.pending_error = stripe_error
+  end
+
+  def self.prepare_card_error(code)
+    return if instance.nil?
+    args = card_error_args[code]
+    instance.pending_error = Stripe::CardError.new(*args)
+  end
+
+  private
+
+  def self.card_error_args
+    @__map = {
+      incorrect_number: ["The card number is incorrect", 'number', 'incorrect_number', 402],
+      invalid_number: ["The card number is not a valid credit card number", 'number', 'invalid_number', 402],
+      invalid_expiry_month: ["The card's expiration month is invalid", 'exp_month', 'invalid_expiry_month', 402],
+      invalid_expiry_year: ["The card's expiration year is invalid", 'exp_year', 'invalid_expiry_year', 402],
+      invalid_cvc: ["The card's security code is invalid", 'cvc', 'invalid_cvc', 402],
+      expired_card: ["The card has expired", 'exp_month', 'expired_card', 402],
+      incorrect_cvc: ["The card's security code is incorrect", 'cvc', 'incorrect_cvc', 402],
+      card_declined: ["The card was declined", nil, 'card_declined', 402],
+      missing: ["There is no card on a customer that is being charged.", nil, 'missing', 402],
+      processing_error: ["An error occurred while processing the card", nil, 'processing_error', 402],
+    }
+  end
+
+end

data/lib/stripe_mock/api/instance.rb

@@ -0,0 +1,27 @@
+module StripeMock
+
+  @@first_start = true
+  @@instance = nil
+
+  def self.start
+    if @@first_start == true
+      @@original_request_method = Stripe.method(:request)
+      @@first_start = false
+    end
+    @@instance = Instance.new
+    alias_stripe_method :request, @@instance.method(:mock_request)
+  end
+
+  def self.stop
+    return if @@instance.nil?
+    alias_stripe_method :request, @@original_request_method
+    @@instance = nil
+  end
+
+  def self.alias_stripe_method(new_name, method_object)
+    Stripe.define_singleton_method(new_name) {|*args| method_object.call(*args) }
+  end
+
+  def self.instance; @@instance; end
+
+end

data/lib/stripe_mock/data.rb

@@ -3,6 +3,8 @@ module StripeMock
 
     def self.test_customer(params)
       {
+        :email => 'stripe_mock@example.com',
+        :description => 'an auto-generated stripe customer data mock',
         :subscription_history => [],
         :bills => [],
         :charges => [],
@@ -42,24 +44,43 @@ module StripeMock
 
     def self.test_charge(params={})
       {
-        :refunded => false,
-        :paid => true,
-        :amount => 100,
-        :card => {
-          :type => "Visa",
-          :last4 => "4242",
-          :exp_month => 11,
-          :country => "US",
-          :exp_year => 2012,
-          :id => "cc_test_card",
-          :object => "card"
+        id: "ch_1fD6uiR9FAA2zc",
+        object: "charge",
+        created: 1366194027,
+        livemode: false,
+        paid: true,
+        amount: 0,
+        currency: "usd",
+        refunded: false,
+        fee: 0,
+        fee_details: [
+        ],
+        card: {
+          object: "card",
+          last4: "4242",
+          type: "Visa",
+          exp_month: 12,
+          exp_year: 2013,
+          fingerprint: "3TQGpK9JoY1GgXPw",
+          country: "US",
+          name: "name",
+          address_line1: nil,
+          address_line2: nil,
+          address_city: nil,
+          address_state: nil,
+          address_zip: nil,
+          address_country: nil,
+          cvc_check: nil,
+          address_line1_check: nil,
+          address_zip_check: nil
         },
-        :id => "ch_test_charge",
-        :reason => "execute_charge",
-        :livemode => false,
-        :currency => "usd",
-        :object => "charge",
-        :created => 1304114826
+        captured: false,
+        failure_message: nil,
+        amount_refunded: 0,
+        customer: nil,
+        invoice: nil,
+        description: nil,
+        dispute: nil
       }.merge(params)
     end
 

data/lib/stripe_mock/instance.rb

@@ -0,0 +1,57 @@
+module StripeMock
+  class Instance
+
+    # Handlers are ordered by priority
+    @@handlers = []
+
+    def self.add_handler(route, name)
+      @@handlers << {
+        :route => %r{^#{route}$},
+        :name => name
+      }
+    end
+
+    include StripeMock::RequestHandlers::Charges
+    include StripeMock::RequestHandlers::Customers
+    include StripeMock::RequestHandlers::InvoiceItems
+
+
+    attr_reader :charges, :customers
+    attr_accessor :pending_error
+
+    def initialize
+      @customers = {}
+      @charges = {}
+      @id_counter = 0
+      @pending_error = nil
+    end
+
+    def mock_request(method, url, api_key, params={}, headers={})
+      return {} if method == :xtest
+
+      if @pending_error
+        raise @pending_error
+        @pending_error = nil
+      end
+
+      method_url = "#{method} #{url}"
+      handler = @@handlers.find {|h| method_url =~ h[:route] }
+
+      if handler
+        self.send  handler[:name],  handler[:route], method_url, params, headers
+      else
+        puts "WARNING: Unrecognized method + url: [#{method} #{url}]"
+        puts " params: #{params}"
+        {}
+      end
+    end
+
+    private
+
+    def new_id
+      # Stripe ids must be strings
+      (@id_counter += 1).to_s
+    end
+
+  end
+end

data/lib/stripe_mock/request_handlers/charges.rb

@@ -0,0 +1,22 @@
+module StripeMock
+  module RequestHandlers
+    module Charges
+
+      def Charges.included(klass)
+        klass.add_handler 'post /v1/charges',     :new_charge
+        klass.add_handler 'get /v1/charges/(.*)', :get_charge
+      end
+
+      def new_charge(route, method_url, params, headers)
+        id = new_id
+        charges[id] = Data.test_charge(params.merge :id => id)
+      end
+
+      def get_charge(route, method_url, params, headers)
+        route =~ method_url
+        charges[$1] ||= Data.test_charge(:id => $1)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/customers.rb

@@ -0,0 +1,34 @@
+module StripeMock
+  module RequestHandlers
+    module Customers
+
+      def Customers.included(klass)
+        klass.add_handler 'post /v1/customers',                   :new_customer
+        klass.add_handler 'post /v1/customers/(.*)/subscription', :new_subscription
+        klass.add_handler 'post /v1/customers/(.*)',              :update_customer
+        klass.add_handler 'get /v1/customers/(.*)',               :get_customer
+      end
+
+      def new_customer(route, method_url, params, headers)
+        id = new_id
+        customers[id] = Data.test_customer(params.merge :id => id)
+      end
+
+      def new_subscription(route, method_url, params, headers)
+        Data.test_subscription(params[:plan])
+      end
+
+      def update_customer(route, method_url, params, headers)
+        route =~ method_url
+        customers[$1] ||= Data.test_customer(:id => $1)
+        customers[$1].merge!(params)
+      end
+
+      def get_customer(route, method_url, params, headers)
+        route =~ method_url
+        customers[$1] ||= Data.test_customer(:id => $1)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/invoice_items.rb

@@ -0,0 +1,15 @@
+module StripeMock
+  module RequestHandlers
+    module InvoiceItems
+
+      def InvoiceItems.included(klass)
+        klass.add_handler 'post /v1/invoiceitems',  :new_invoice_item
+      end
+
+      def new_invoice_item(route, method_url, params, headers)
+        Data.test_invoice(params)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "1.8.1.1"
+  VERSION = "1.8.3.0"
 end

data/spec/readme_spec.rb

@@ -0,0 +1,45 @@
+
+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 stripe request
+    StripeMock.prepare_card_error(:card_declined)
+
+    begin
+      # Note: The next request of ANY type will raise your prepared error
+      Stripe::Charge.create()
+    rescue Stripe::CardError => error
+      expect(error.http_status).to eq(402)
+      expect(error.code).to eq('card_declined')
+    end
+  end
+
+
+  it "raises a custom error" do
+    custom_error = Stripe::AuthenticationError.new('Did not provide favourite colour', 400)
+    StripeMock.prepare_error(custom_error)
+
+    begin
+      # Note: The next request of ANY type will raise your prepared error
+      Stripe::Invoice.create()
+    rescue Stripe::AuthenticationError => error
+      expect(error.http_status).to eq(400)
+      expect(error.message).to eq('Did not provide favourite colour')
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
 gem 'rspec', '~> 2.4'
 require 'rspec'
 require 'stripe'
-require 'stripe_mock/version'
+require 'stripe_mock'

data/spec/stripe/charge_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'Charge API' do
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  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.amount).to eq(999)
+    expect(charge.description).to eq('card charge')
+  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 = StripeMock.instance.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 "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

data/spec/stripe/customer_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'Customer API' do
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  it "creates a stripe customer" do
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: 'some_card_token',
+      description: "a description"
+    })
+    expect(customer.email).to eq('johnny@appleseed.com')
+    expect(customer.description).to eq('a description')
+  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 = StripeMock.instance.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)
+  end
+
+  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
+
+  it "updates a stripe customer" do
+    original = Stripe::Customer.retrieve("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 subscription" do
+    customer = Stripe::Customer.retrieve("test_customer_sub")
+    sub = customer.update_subscription({ :plan => 'silver' })
+
+    expect(sub.object).to eq('subscription')
+    expect(sub.plan.id).to eq('silver')
+  end
+
+end

data/spec/stripe/error_mock_spec.rb

@@ -0,0 +1,122 @@
+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
+
+describe 'Stripe Error Mocking' do
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  it "mocks a manually gives 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::Invoice.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
+
+
+  # # # # # # # # # # # # # #
+  # Card Error Helper Methods
+  # # # # # # # # # # # # # #
+
+  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/stripe/invoice_item_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Invoice Item API' do
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  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/stripe_mock_spec.rb

@@ -0,0 +1,30 @@
+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
+
+end

data/stripe-ruby-mock.gemspec

@@ -10,14 +10,14 @@ Gem::Specification.new do |gem|
   gem.license       = "MIT"
   gem.authors       = ["Gilbert"]
   gem.email         = "gilbertbgarza@gmail.com"
-  gem.homepage      = "https://github.com/mindeavor/stripe-ruby-mock#readme"
+  gem.homepage      = "https://github.com/mindeavor/stripe-ruby-mock"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'stripe', '~> 1.8.1'
+  gem.add_dependency 'stripe', '~> 1.8.3'
 
   gem.add_development_dependency 'rspec', '~> 2.4'
   gem.add_development_dependency 'rubygems-tasks', '~> 0.2'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stripe-ruby-mock
 version: !ruby/object:Gem::Version
-  version: 1.8.1.1
+  version: 1.8.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-30 00:00:00.000000000 Z
+date: 2013-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stripe
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 1.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -72,13 +72,23 @@ files:
 - README.md
 - Rakefile
 - lib/stripe_mock.rb
+- lib/stripe_mock/api/errors.rb
+- lib/stripe_mock/api/instance.rb
 - lib/stripe_mock/data.rb
-- lib/stripe_mock/methods.rb
+- lib/stripe_mock/instance.rb
+- lib/stripe_mock/request_handlers/charges.rb
+- lib/stripe_mock/request_handlers/customers.rb
+- lib/stripe_mock/request_handlers/invoice_items.rb
 - lib/stripe_mock/version.rb
-- spec/mock_spec.rb
+- spec/readme_spec.rb
 - spec/spec_helper.rb
+- spec/stripe/charge_spec.rb
+- spec/stripe/customer_spec.rb
+- spec/stripe/error_mock_spec.rb
+- spec/stripe/invoice_item_spec.rb
+- spec/stripe_mock_spec.rb
 - stripe-ruby-mock.gemspec
-homepage: https://github.com/mindeavor/stripe-ruby-mock#readme
+homepage: https://github.com/mindeavor/stripe-ruby-mock
 licenses:
 - MIT
 post_install_message: 
@@ -104,5 +114,10 @@ signing_key:
 specification_version: 3
 summary: TDD with stripe
 test_files:
-- spec/mock_spec.rb
+- spec/readme_spec.rb
 - spec/spec_helper.rb
+- spec/stripe/charge_spec.rb
+- spec/stripe/customer_spec.rb
+- spec/stripe/error_mock_spec.rb
+- spec/stripe/invoice_item_spec.rb
+- spec/stripe_mock_spec.rb

data/lib/stripe_mock/methods.rb

@@ -1,25 +0,0 @@
-module StripeMock
-  module Methods
-
-    def self.mock_request(method, url, api_key, params={}, headers={})
-      return {} if method == :xtest
-
-      # Ordered from most specific to least specific
-      case "#{method} #{url}"
-      when 'post /v1/customers'
-        Data.test_customer(params)
-      when 'post /v1/invoiceitems'
-        Data.test_invoice(params)
-      when %r{post /v1/customers/(.*)/subscription}
-        Data.test_subscription(params[:plan])
-      when %r{get /v1/customers/(.*)}
-        Data.test_customer :id => $1
-      else
-        puts "WARNING: Unrecognized method + url: [#{method} #{url}]"
-        puts " params: #{params}"
-        {}
-      end
-    end
-
-  end
-end

data/spec/mock_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'stripe_mock'
-
-describe StripeMock do
-
-  before { StripeMock.start }
-  after  { StripeMock.stop }
-
-  it "should override stripe's request method" do
-    Stripe.request(:xtest, '/', 'abcde') # no error
-  end
-
-  it "should revert overriding stripe's request method" do
-    Stripe.request(:xtest, '/', 'abcde') # no error
-    StripeMock.stop
-    expect { Stripe.request(:x, '/', 'abcde') }.to raise_error
-  end
-
-  it "should create a stripe customer" do
-    customer = Stripe::Customer.create({
-      email: 'johnny@appleseed.com',
-      card: 'some_card_token',
-      description: "a description"
-    })
-    expect(customer.email).to eq('johnny@appleseed.com')
-    expect(customer.description).to eq('a description')
-  end
-
-  it "should retrieve a stripe customer" do
-    customer = Stripe::Customer.retrieve("test_customer")
-    expect(customer.id).to eq('test_customer')
-  end
-
-  it "should update a stripe customer's subscription" do
-    customer = Stripe::Customer.retrieve("test_customer")
-    sub = customer.update_subscription({ :plan => 'silver' })
-
-    expect(sub.object).to eq('subscription')
-    expect(sub.plan.identifier).to eq('silver')
-  end
-
-  it "should create a stripe invoice item" do
-    invoice = Stripe::InvoiceItem.create({
-      amount: 1099,
-      customer: 1234,
-      currency: 'USD',
-      description: "invoice desc"
-    }, 'abcde')
-
-    expect(invoice.amount).to eq(1099)
-    expect(invoice.description).to eq('invoice desc')
-  end
-
-end