stripe 3.0.3 → 3.1.0

data/lib/stripe/util.rb

@@ -89,6 +89,20 @@ module Stripe
       end
     end
 
+    def self.log_info(message, data = {})
+      if Stripe.log_level == Stripe::LEVEL_DEBUG ||Stripe.log_level == Stripe::LEVEL_INFO
+        log_internal(message, data, color: :cyan,
+          level: Stripe::LEVEL_INFO, out: $stdout)
+      end
+    end
+
+    def self.log_debug(message, data = {})
+      if Stripe.log_level == Stripe::LEVEL_DEBUG
+        log_internal(message, data, color: :blue,
+          level: Stripe::LEVEL_DEBUG, out: $stdout)
+      end
+    end
+
     def self.file_readable(file)
       # This is nominally equivalent to File.readable?, but that can
       # report incorrect results on some more oddball filesystems
@@ -220,8 +234,59 @@ module Stripe
       key
     end
 
+    # Normalizes header keys so that they're all lower case and each
+    # hyphen-delimited section starts with a single capitalized letter. For
+    # example, `request-id` becomes `Request-Id`. This is useful for extracting
+    # certain key values when the user could have set them with a variety of
+    # diffent naming schemes.
+    def self.normalize_headers(headers)
+      headers.inject({}) do |new_headers, (k, v)|
+        if k.is_a?(Symbol)
+          k = titlecase_parts(k.to_s.gsub("_", "-"))
+        elsif k.is_a?(String)
+          k = titlecase_parts(k)
+        end
+
+        new_headers[k] = v
+        new_headers
+      end
+    end
+
+    # Generates a Dashboard link to inspect a request ID based off of a request
+    # ID value and an API key, which is used to attempt to extract whether the
+    # environment is livemode or testmode.
+    def self.request_id_dashboard_url(request_id, api_key)
+      env = !api_key.nil? && api_key.start_with?("sk_live") ? "live" : "test"
+      "https://dashboard.stripe.com/#{env}/logs/#{request_id}"
+    end
+
+    # Constant time string comparison to prevent timing attacks
+    # Code borrowed from ActiveSupport
+    def self.secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      l = a.unpack "C#{a.bytesize}"
+
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res == 0
+    end
+
     private
 
+    COLOR_CODES = {
+      :black   => 0, :light_black    => 60,
+      :red     => 1, :light_red      => 61,
+      :green   => 2, :light_green    => 62,
+      :yellow  => 3, :light_yellow   => 63,
+      :blue    => 4, :light_blue     => 64,
+      :magenta => 5, :light_magenta  => 65,
+      :cyan    => 6, :light_cyan     => 66,
+      :white   => 7, :light_white    => 67,
+      :default => 9
+    }
+    private_constant :COLOR_CODES
+
     # We use a pretty janky version of form encoding (Rack's) that supports
     # more complex data structures like maps and arrays through the use of
     # specialized syntax. To encode an array of maps like:
@@ -258,17 +323,71 @@ module Stripe
         end
       end
     end
+    private_class_method :check_array_of_maps_start_keys!
 
-    # Constant time string comparison to prevent timing attacks
-    # Code borrowed from ActiveSupport
-    def self.secure_compare(a, b)
-      return false unless a.bytesize == b.bytesize
+    # Uses an ANSI escape code to colorize text if it's going to be sent to a
+    # TTY.
+    def self.colorize(val, color, isatty)
+      return val unless isatty
 
-      l = a.unpack "C#{a.bytesize}"
+      mode = 0 # default
+      foreground = 30 + COLOR_CODES.fetch(color)
+      background = 40 + COLOR_CODES.fetch(:default)
 
-      res = 0
-      b.each_byte { |byte| res |= byte ^ l.shift }
-      res == 0
+      "\033[#{mode};#{foreground};#{background}m#{val}\033[0m"
+    end
+    private_class_method :colorize
+
+    # TODO: Make these named required arguments when we drop support for Ruby
+    # 2.0.
+    def self.log_internal(message, data = {}, color: nil, level: nil, out: nil)
+      data_str = data.select { |k,v| !v.nil? }.
+        map { |(k,v)|
+          "%s=%s" % [
+            colorize(k, color, out.isatty),
+            wrap_logfmt_value(v)
+          ]
+        }.join(" ")
+
+      if out.isatty
+        out.puts "%s %s %s" %
+          [colorize(level[0, 4].upcase, color, out.isatty), message, data_str]
+      else
+        out.puts "message=%s level=%s %s" %
+          [wrap_logfmt_value(message), level, data_str]
+      end
+    end
+    private_class_method :log_internal
+
+    def self.titlecase_parts(s)
+      s.split("-").
+        select { |p| p != "" }.
+        map { |p| p[0].upcase + p[1..-1].downcase }.
+        join("-")
+    end
+    private_class_method :titlecase_parts
+
+    # Wraps a value in double quotes if it looks sufficiently complex so that
+    # it can be read by logfmt parsers.
+    def self.wrap_logfmt_value(val)
+      # If value is any kind of number, just allow it to be formatted directly
+      # to a string (this will handle integers or floats).
+      return val if val.is_a?(Numeric)
+
+      # Hopefully val is a string, but protect in case it's not.
+      val = val.to_s
+
+      if %r{[^\w\-/]} =~ val
+        # If the string contains any special characters, escape any double
+        # quotes it has, remove newlines, and wrap the whole thing in quotes.
+        %{"%s"} % val.gsub('"', '\"').gsub("\n", "")
+      else
+        # Otherwise use the basic value if it looks like a standard set of
+        # characters (and allow a few special characters like hyphens, and
+        # slashes)
+        val
+      end
     end
+    private_class_method :wrap_logfmt_value
   end
 end

data/lib/stripe/version.rb

@@ -1,3 +1,3 @@
 module Stripe
-  VERSION = '3.0.3'
+  VERSION = '3.1.0'
 end

data/test/api_stub_helpers.rb

@@ -1,125 +0,0 @@
-require "json"
-
-# Provides a set of helpers for a test suite that help to mock out the Stripe
-# API.
-module APIStubHelpers
-  protected
-
-  # Uses Webmock to stub out the Stripe API for testing purposes. The stub will
-  # by default respond on any routes that are defined in the bundled OpenAPI
-  # spec with generated response data.
-  #
-  # An `override_app` can be specified to get finer grain control over how a
-  # stubbed endpoint responds. It can be used to modify generated responses,
-  # mock expectations, or even to override the default stub completely.
-  def stub_api
-    stub_request(:any, /^#{Stripe.api_base}/).to_rack(new_api_stub)
-  end
-
-  def stub_connect
-    stub_request(:any, /^#{Stripe.connect_base}/).to_return(:body => "{}")
-  end
-
-  private
-
-  # APIStubMiddleware intercepts a response generated by Committee's stubbing
-  # middleware, and tries to replace it with a better version from a set of
-  # sample fixtures data generated from Stripe's core API service.
-  class APIStubMiddleware
-    API_FIXTURES = APIFixtures.new
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      # We use a vendor specific prefix (`x-resourceId`) embedded in the schema
-      # of any resource in our spec to identify it (e.g. "charge"). This allows
-      # us to cross-reference that response with some data that we might find
-      # in our fixtures file so that we can respond with a higher fidelity
-      # response.
-      schema = env["committee.response_schema"]
-      resource_id = schema.data["x-resourceId"] || ""
-
-      if data = API_FIXTURES[resource_id.to_sym]
-        # standard top-level API resource
-        data = fixturize_lists_recursively(schema, data)
-        env["committee.response"] = data
-      elsif schema.properties["object"].enum == ["list"]
-        # top level list (like from a list endpoint)
-        data = fixturize_list(schema, env["committee.response"])
-        env["committee.response"] = data
-      else
-        raise "no fixture for: #{resource_id}"
-      end
-      @app.call(env)
-    end
-
-    private
-
-    # If schema looks like a Stripe list object, then we look up the resource
-    # that the list is supposed to include and inject it into `data` as a
-    # fixture. Also calls into that other schema recursively so that sublists
-    # within it will also be assigned a fixture.
-    def fixturize_list(schema, data)
-      object_schema = schema.properties["object"]
-      if object_schema && object_schema.enum == ["list"]
-        subschema = schema.properties["data"].items
-        resource_id = subschema.data["x-resourceId"] || ""
-        if subdata = API_FIXTURES[resource_id.to_sym]
-          subdata = fixturize_lists_recursively(subschema, subdata)
-
-          data = data ? data.dup : {}
-          data[:data] = [subdata]
-        end
-      end
-      data
-    end
-
-    # Examines each of the given schema's properties and calls #fixturize_list
-    # on them so that any sublists will be populated with sample fixture data.
-    def fixturize_lists_recursively(schema, data)
-      data = data.dup
-      schema.properties.each do |key, subschema|
-        data[key.to_sym] = fixturize_list(subschema, data[key.to_sym])
-      end
-      data
-    end
-  end
-
-  # A descendant of the standard `Sinatra::Base` that we can use to enrich
-  # certain types of responses.
-  class APIStubApp < Sinatra::Base
-    not_found do
-      "endpoint not found in API stub: #{request.request_method} #{request.path_info}"
-    end
-  end
-
-  # Finds the latest OpenAPI specification in ROOT/openapi/ and parses it for
-  # use with Committee.
-  def self.initialize_spec
-    spec_data = ::JSON.parse(File.read("#{PROJECT_ROOT}/openapi/spec2.json"))
-
-    driver = Committee::Drivers::OpenAPI2.new
-    driver.parse(spec_data)
-  end
-
-  # Creates a new Rack app with Committee middleware it.
-  def new_api_stub
-    Rack::Builder.new {
-      use Committee::Middleware::RequestValidation, schema: @@spec,
-        params_response: true, strict: true
-      use Committee::Middleware::Stub, schema: @@spec,
-        call: true
-      use APIStubMiddleware
-      run APIStubApp.new
-    }
-  end
-
-  # Parse and initialize the OpenAPI spec only once for the entire test suite.
-  @@spec = initialize_spec
-
-  # The default override app. Doesn't respond on any route so generated
-  # responses will always take precedence.
-  @@default_override_app = Sinatra.new
-end

data/test/stripe/account_test.rb

@@ -2,8 +2,6 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class AccountTest < Test::Unit::TestCase
-    FIXTURE = API_FIXTURES.fetch(:account)
-
     should "be listable" do
       accounts = Stripe::Account.list
       assert_requested :get, "#{Stripe.api_base}/v1/accounts"
@@ -18,8 +16,8 @@ module Stripe
     end
 
     should "be retrievable using plural endpoint" do
-      account = Stripe::Account.retrieve(FIXTURE[:id])
-      assert_requested :get, "#{Stripe.api_base}/v1/accounts/#{FIXTURE[:id]}"
+      account = Stripe::Account.retrieve("acct_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/accounts/acct_123"
       assert account.kind_of?(Stripe::Account)
     end
 
@@ -42,22 +40,22 @@ module Stripe
     end
 
     should "be saveable" do
-      account = Stripe::Account.retrieve(FIXTURE[:id])
+      account = Stripe::Account.retrieve("acct_123")
       account.metadata['key'] = 'value'
       account.save
-      assert_requested :post, "#{Stripe.api_base}/v1/accounts/#{FIXTURE[:id]}"
+      assert_requested :post, "#{Stripe.api_base}/v1/accounts/#{account.id}"
     end
 
     should "be updateable" do
-      account = Stripe::Account.update(FIXTURE[:id], metadata: {foo: 'bar'})
-      assert_requested :post, "#{Stripe.api_base}/v1/accounts/#{FIXTURE[:id]}"
+      account = Stripe::Account.update("acct_123", metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/accounts/acct_123"
       assert account.kind_of?(Stripe::Account)
     end
 
     should "be deletable" do
-      account = Stripe::Account.retrieve(FIXTURE[:id])
+      account = Stripe::Account.retrieve("acct_123")
       account = account.delete
-      assert_requested :delete, "#{Stripe.api_base}/v1/accounts/#{FIXTURE[:id]}"
+      assert_requested :delete, "#{Stripe.api_base}/v1/accounts/#{account.id}"
       assert account.kind_of?(Stripe::Account)
     end
 
@@ -66,7 +64,7 @@ module Stripe
         old_stderr = $stderr
         $stderr = StringIO.new
         begin
-          account = Stripe::Account.retrieve(FIXTURE[:id])
+          account = Stripe::Account.retrieve("acct_123")
           account.bank_account = "tok_123"
           message = "NOTE: Stripe::Account#bank_account= is " +
             "deprecated; use #external_account= instead"
@@ -79,7 +77,7 @@ module Stripe
 
     context "#deauthorize" do
       should "deauthorize an account" do
-        account = Stripe::Account.retrieve(FIXTURE[:id])
+        account = Stripe::Account.retrieve("acct_123")
 
         # Unfortunately, the OpenAPI spec doesn't yet cover anything under the
         # Connect endpoints, so for just stub this out with Webmock.
@@ -92,7 +90,7 @@ module Stripe
 
     context "#legal_entity=" do
       should 'disallow direct overrides' do
-        account = Stripe::Account.retrieve(FIXTURE[:id])
+        account = Stripe::Account.retrieve("acct_123")
 
         assert_raise NoMethodError do
           account.legal_entity = {:first_name => 'Blah'}

data/test/stripe/alipay_account_test.rb

@@ -2,17 +2,15 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class AlipayAccountTest < Test::Unit::TestCase
-    FIXTURE = API_FIXTURES.fetch(:alipay_account)
-
     should "raise on #retrieve" do
       assert_raises NotImplementedError do
-        Stripe::AlipayAccount.retrieve FIXTURE[:id]
+        Stripe::AlipayAccount.retrieve("aliacc_123")
       end
     end
 
     should "raise on #update" do
       assert_raises NotImplementedError do
-        Stripe::AlipayAccount.update FIXTURE[:id], {}
+        Stripe::AlipayAccount.update("aliacc_123", {})
       end
     end
   end

data/test/stripe/api_resource_test.rb

@@ -38,14 +38,14 @@ module Stripe
     end
 
     should "setting an attribute should not cause a network request" do
-      c = Stripe::Customer.new("test_customer");
+      c = Stripe::Customer.new("cus_123");
       c.card = {:id => "somecard", :object => "card"}
       assert_not_requested :get, %r{#{Stripe.api_base}/.*}
       assert_not_requested :post, %r{#{Stripe.api_base}/.*}
     end
 
     should "accessing id should not issue a fetch" do
-      c = Stripe::Customer.new("test_customer")
+      c = Stripe::Customer.new("cus_123")
       c.id
       assert_not_requested :get, %r{#{Stripe.api_base}/.*}
     end
@@ -53,7 +53,7 @@ module Stripe
     should "not specifying api credentials should raise an exception" do
       Stripe.api_key = nil
       assert_raises Stripe::AuthenticationError do
-        Stripe::Customer.new("test_customer").refresh
+        Stripe::Customer.new("cus_123").refresh
       end
     end
 
@@ -69,36 +69,36 @@ module Stripe
     should "specifying api credentials containing whitespace should raise an exception" do
       Stripe.api_key = "key "
       assert_raises Stripe::AuthenticationError do
-        Stripe::Customer.new("test_customer").refresh
+        Stripe::Customer.new("cus_123").refresh
       end
     end
 
     should "send expand on fetch properly" do
-      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
+      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
         with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+        to_return(body: JSON.generate(charge_fixture))
 
-      Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => [:customer]})
+      Stripe::Charge.retrieve({:id => 'ch_123', :expand => [:customer]})
     end
 
     should "preserve expand across refreshes" do
-      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
+      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
         with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+        to_return(body: JSON.generate(charge_fixture))
 
-      ch = Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => :customer})
+      ch = Stripe::Charge.retrieve({:id => 'ch_123', :expand => :customer})
       ch.refresh
     end
 
     should "send expand when fetching through ListObject" do
-      stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
-        to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
+      stub_request(:get, "#{Stripe.api_base}/v1/customers/cus_123").
+        to_return(body: JSON.generate(customer_fixture))
 
-      stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer/sources/cc_test_card").
+      stub_request(:get, "#{Stripe.api_base}/v1/customers/cus_123/sources/cc_test_card").
         with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
+        to_return(body: JSON.generate(customer_fixture))
 
-      customer = Stripe::Customer.retrieve('c_test_customer')
+      customer = Stripe::Customer.retrieve('cus_123')
       customer.sources.retrieve({:id => 'cc_test_card', :expand => :customer})
     end
 
@@ -107,7 +107,7 @@ module Stripe
         should "use the per-object credential when creating" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges").
             with(headers: {"Authorization" => "Bearer sk_test_local"}).
-            to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+            to_return(body: JSON.generate(charge_fixture))
 
           Stripe::Charge.create({:source => 'tok_visa'},
             'sk_test_local')
@@ -125,22 +125,22 @@ module Stripe
 
         should "use the per-object credential when creating" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges").
-            with(headers: {"Authorization" => "Bearer local"}).
-            to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+            with(headers: {"Authorization" => "Bearer sk_test_local"}).
+            to_return(body: JSON.generate(charge_fixture))
 
           Stripe::Charge.create({:source => 'tok_visa'},
-            'local')
+            'sk_test_local')
         end
 
         should "use the per-object credential when retrieving and making other calls" do
-          stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
-            with(headers: {"Authorization" => "Bearer local"}).
-            to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
-          stub_request(:post, "#{Stripe.api_base}/v1/charges/ch_test_charge/refunds").
-            with(headers: {"Authorization" => "Bearer local"}).
-            to_return(body: JSON.generate(API_FIXTURES.fetch(:refund)))
-
-          ch = Stripe::Charge.retrieve('ch_test_charge', 'local')
+          stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
+            with(headers: {"Authorization" => "Bearer sk_test_local"}).
+            to_return(body: JSON.generate(charge_fixture))
+          stub_request(:post, "#{Stripe.api_base}/v1/charges/ch_123/refunds").
+            with(headers: {"Authorization" => "Bearer sk_test_local"}).
+            to_return(body: "{}")
+
+          ch = Stripe::Charge.retrieve('ch_123', 'sk_test_local')
           ch.refunds.create
         end
       end
@@ -151,45 +151,45 @@ module Stripe
         stub_request(:get, "#{Stripe.api_base}/v1/charges").
           with(query: { customer: "test customer" }).
           to_return(body: JSON.generate({
-            data: [API_FIXTURES.fetch(:charge)]
+            data: [charge_fixture]
           }))
         charges = Stripe::Charge.list(:customer => 'test customer').data
         assert charges.kind_of? Array
       end
 
       should "construct URL properly with base query parameters" do
-        stub_request(:get, "#{Stripe.api_base}/v1/invoices").
-          with(query: { customer: "test_customer" }).
+        stub_request(:get, "#{Stripe.api_base}/v1/charges").
+          with(query: { customer: "cus_123" }).
           to_return(body: JSON.generate({
-            data: [API_FIXTURES.fetch(:invoice)],
-            url: "/v1/invoices"
+            data: [charge_fixture],
+            url: "/v1/charges"
           }))
-        invoices = Stripe::Invoice.list(:customer => 'test_customer')
+        charges = Stripe::Invoice.list(:customer => 'cus_123')
 
-        stub_request(:get, "#{Stripe.api_base}/v1/invoices").
-          with(query: { customer: "test_customer", paid: "true" }).
+        stub_request(:get, "#{Stripe.api_base}/v1/charges").
+          with(query: { customer: "cus_123", created: "123" }).
           to_return(body: JSON.generate({
-            data: [API_FIXTURES.fetch(:invoice)],
-            url: "/v1/invoices"
+            data: [charge_fixture],
+            url: "/v1/charges"
           }))
-        invoices.list(:paid => true)
+        charges.list(:created => 123)
       end
 
       should "setting a nil value for a param should exclude that param from the request" do
         stub_request(:get, "#{Stripe.api_base}/v1/charges").
           with(query: { offset: 5, sad: false }).
-          to_return(body: JSON.generate({ :count => 1, :data => [API_FIXTURES.fetch(:charge)] }))
+          to_return(body: JSON.generate({ :count => 1, :data => [charge_fixture] }))
         Stripe::Charge.list(:count => nil, :offset => 5, :sad => false)
 
         stub_request(:post, "#{Stripe.api_base}/v1/charges").
           with(body: { 'amount' => '50', 'currency' => 'usd' }).
-          to_return(body: JSON.generate({ :count => 1, :data => [API_FIXTURES.fetch(:charge)] }))
+          to_return(body: JSON.generate({ :count => 1, :data => [charge_fixture] }))
         Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
       end
 
       should "not trigger a warning if a known opt, such as idempotency_key, is in opts" do
         stub_request(:post, "#{Stripe.api_base}/v1/charges").
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+          to_return(body: JSON.generate(charge_fixture))
         old_stderr = $stderr
         $stderr = StringIO.new
         begin
@@ -202,7 +202,7 @@ module Stripe
 
       should "trigger a warning if a known opt, such as idempotency_key, is in params" do
         stub_request(:post, "#{Stripe.api_base}/v1/charges").
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+          to_return(body: JSON.generate(charge_fixture))
         old_stderr = $stderr
         $stderr = StringIO.new
         begin
@@ -228,28 +228,28 @@ module Stripe
       should "making a GET request with parameters should have a query string and no body" do
         stub_request(:get, "#{Stripe.api_base}/v1/charges").
           with(query: { limit: 1 }).
-          to_return(body: JSON.generate({ :data => [API_FIXTURES.fetch(:charge)] }))
+          to_return(body: JSON.generate({ :data => [charge_fixture] }))
         Stripe::Charge.list({ :limit => 1 })
       end
 
       should "making a POST request with parameters should have a body and no query string" do
         stub_request(:post, "#{Stripe.api_base}/v1/charges").
           with(body: {'amount' => '100', 'currency' => 'usd', 'card' => 'sc_token'}).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:charge)))
+          to_return(body: JSON.generate(charge_fixture))
         Stripe::Charge.create({ :amount => 100, :currency => 'usd', :card => 'sc_token' })
       end
 
       should "loading an object should issue a GET request" do
-        stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.new("test_customer")
+        stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
+          to_return(body: JSON.generate(charge_fixture))
+        c = Stripe::Charge.new("ch_123")
         c.refresh
       end
 
       should "using array accessors should be the same as the method interface" do
-        stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.new("test_customer")
+        stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
+          to_return(body: JSON.generate(charge_fixture))
+        c = Stripe::Charge.new("cus_123")
         c.refresh
         assert_equal c.created, c[:created]
         assert_equal c.created, c['created']
@@ -259,26 +259,26 @@ module Stripe
 
       should "accessing a property other than id or parent on an unfetched object should fetch it" do
         stub_request(:get, "#{Stripe.api_base}/v1/charges").
-          with(query: { customer: "test_customer" }).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.new("test_customer")
+          with(query: { customer: "cus_123" }).
+          to_return(body: JSON.generate(customer_fixture))
+        c = Stripe::Customer.new("cus_123")
         c.charges
       end
 
       should "updating an object should issue a POST request with only the changed properties" do
-        stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/cus_123").
           with(body: { 'description' => 'another_mn' }).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.construct_from(API_FIXTURES.fetch(:customer))
+          to_return(body: JSON.generate(customer_fixture))
+        c = Stripe::Customer.construct_from(customer_fixture)
         c.description = "another_mn"
         c.save
       end
 
       should "updating should merge in returned properties" do
-        stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/cus_123").
           with(body: { 'description' => 'another_mn' }).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.new("c_test_customer")
+          to_return(body: JSON.generate(customer_fixture))
+        c = Stripe::Customer.new("cus_123")
         c.description = "another_mn"
         c.save
         assert_equal false, c.livemode
@@ -294,23 +294,23 @@ module Stripe
       should "updating should use the supplied api_key" do
         stub_request(:post, "#{Stripe.api_base}/v1/customers").
           with(headers: {"Authorization" => "Bearer sk_test_local"}).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
+          to_return(body: JSON.generate(customer_fixture))
         c = Stripe::Customer.new
         c.save({}, { :api_key => 'sk_test_local' })
         assert_equal false, c.livemode
       end
 
       should "deleting should send no props and result in an object that has no props other deleted" do
-        stub_request(:delete, "#{Stripe.api_base}/v1/customers/c_test_customer").
-          to_return(body: JSON.generate({ "id" => "test_customer", "deleted" => true }))
-        c = Stripe::Customer.construct_from(API_FIXTURES.fetch(:customer))
+        stub_request(:delete, "#{Stripe.api_base}/v1/customers/cus_123").
+          to_return(body: JSON.generate({ "id" => "cus_123", "deleted" => true }))
+        c = Stripe::Customer.construct_from(customer_fixture)
         c.delete
       end
 
       should "loading all of an APIResource should return an array of recursively instantiated objects" do
         stub_request(:get, "#{Stripe.api_base}/v1/charges").
           to_return(body: JSON.generate({
-            data: [API_FIXTURES.fetch(:charge)]
+            data: [charge_fixture]
           }))
         charges = Stripe::Charge.list.data
         assert charges.kind_of? Array
@@ -319,21 +319,21 @@ module Stripe
       end
 
       should "passing in a stripe_account header should pass it through on call" do
-        stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
-          with(headers: {"Stripe-Account" => "acct_abc"}).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
+        stub_request(:get, "#{Stripe.api_base}/v1/customers/cus_123").
+          with(headers: {"Stripe-Account" => "acct_123"}).
+          to_return(body: JSON.generate(customer_fixture))
+        Stripe::Customer.retrieve("cus_123", {:stripe_account => 'acct_123'})
       end
 
       should "passing in a stripe_account header should pass it through on save" do
-        stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
-          with(headers: {"Stripe-Account" => "acct_abc"}).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
-        c = Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
-
-        stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
-          with(headers: {"Stripe-Account" => "acct_abc"}).
-          to_return(body: JSON.generate(API_FIXTURES.fetch(:customer)))
+        stub_request(:get, "#{Stripe.api_base}/v1/customers/cus_123").
+          with(headers: {"Stripe-Account" => "acct_123"}).
+          to_return(body: JSON.generate(customer_fixture))
+        c = Stripe::Customer.retrieve("cus_123", {:stripe_account => 'acct_123'})
+
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/cus_123").
+          with(headers: {"Stripe-Account" => "acct_123"}).
+          to_return(body: JSON.generate(customer_fixture))
         c.description = 'FOO'
         c.save
       end
@@ -518,5 +518,41 @@ module Stripe
         account.save(:display_name => 'stripe', :metadata => {:key => 'value' })
       end
     end
+
+    @@fixtures = {}
+    setup do
+      if @@fixtures.empty?
+        set_fixture(:charge) do
+          Charge.retrieve("ch_123")
+        end
+        set_fixture(:customer) do
+          Customer.retrieve("cus_123")
+        end
+      end
+    end
+
+    private
+
+    def charge_fixture
+      @@fixtures[:charge]
+    end
+
+    def customer_fixture
+      @@fixtures[:customer]
+    end
+
+    def get_fixture(key)
+      @@fixtures.fetch(key)
+    end
+
+    # Expects to retrieve a fixture from stripe-mock (an API call should be
+    # included in the block to yield to) and does very simple memoization.
+    def set_fixture(key)
+      return @@fixtures[key] if @@fixtures.key?(key)
+
+      obj = yield
+      @@fixtures[key] = obj.instance_variable_get(:@values).freeze
+      @@fixtures[key]
+    end
   end
 end