stripe 3.3.2 → 3.4.1

data/lib/stripe/version.rb

@@ -1,3 +1,3 @@
 module Stripe
-  VERSION = '3.3.2'
+  VERSION = "3.4.1".freeze
 end

data/lib/stripe/webhook.rb

@@ -19,18 +19,18 @@ module Stripe
     end
 
     module Signature
-      EXPECTED_SCHEME = 'v1'
+      EXPECTED_SCHEME = "v1".freeze
 
       def self.compute_signature(payload, secret)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), secret, payload)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), secret, payload)
       end
       private_class_method :compute_signature
 
       # Extracts the timestamp and the signature(s) with the desired scheme
       # from the header
       def self.get_timestamp_and_signatures(header, scheme)
-        list_items = header.split(/,\s*/).map { |i| i.split('=', 2) }
-        timestamp = Integer(list_items.select { |i| i[0] == 't' }[0][1])
+        list_items = header.split(/,\s*/).map { |i| i.split("=", 2) }
+        timestamp = Integer(list_items.select { |i| i[0] == "t" }[0][1])
         signatures = list_items.select { |i| i[0] == scheme }.map { |i| i[1] }
         [timestamp, signatures]
       end
@@ -49,30 +49,34 @@ module Stripe
       def self.verify_header(payload, header, secret, tolerance: nil)
         begin
           timestamp, signatures = get_timestamp_and_signatures(header, EXPECTED_SCHEME)
-        rescue
+        rescue StandardError
           raise SignatureVerificationError.new(
             "Unable to extract timestamp and signatures from header",
-            header, http_body: payload)
+            header, http_body: payload
+          )
         end
 
         if signatures.empty?
           raise SignatureVerificationError.new(
             "No signatures found with expected scheme #{EXPECTED_SCHEME}",
-            header, http_body: payload)
+            header, http_body: payload
+          )
         end
 
         signed_payload = "#{timestamp}.#{payload}"
         expected_sig = compute_signature(signed_payload, secret)
-        unless signatures.any? {|s| Util.secure_compare(expected_sig, s)}
+        unless signatures.any? { |s| Util.secure_compare(expected_sig, s) }
           raise SignatureVerificationError.new(
             "No signatures found matching the expected signature for payload",
-            header, http_body: payload)
+            header, http_body: payload
+          )
         end
 
         if tolerance && timestamp < Time.now.to_f - tolerance
           raise SignatureVerificationError.new(
             "Timestamp outside the tolerance zone (#{Time.at(timestamp)})",
-            header, http_body: payload)
+            header, http_body: payload
+          )
         end
 
         true

data/stripe.gemspec

@@ -1,22 +1,22 @@
-$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
 
-require 'stripe/version'
+require "stripe/version"
 
-spec = Gem::Specification.new do |s|
-  s.name = 'stripe'
+Gem::Specification.new do |s|
+  s.name = "stripe"
   s.version = Stripe::VERSION
-  s.required_ruby_version = '>= 2.0.0'
-  s.summary = 'Ruby bindings for the Stripe API'
-  s.description = 'Stripe is the easiest way to accept payments online.  See https://stripe.com for details.'
-  s.author = 'Stripe'
-  s.email = 'support@stripe.com'
-  s.homepage = 'https://stripe.com/docs/api/ruby'
-  s.license = 'MIT'
+  s.required_ruby_version = ">= 2.0.0"
+  s.summary = "Ruby bindings for the Stripe API"
+  s.description = "Stripe is the easiest way to accept payments online.  See https://stripe.com for details."
+  s.author = "Stripe"
+  s.email = "support@stripe.com"
+  s.homepage = "https://stripe.com/docs/api/ruby"
+  s.license = "MIT"
 
-  s.add_dependency('faraday', '~> 0.9')
+  s.add_dependency("faraday", "~> 0.10")
 
   s.files = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- test/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ['lib']
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
 end

data/test/stripe/account_test.rb

@@ -1,62 +1,62 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class AccountTest < Test::Unit::TestCase
     should "be listable" do
       accounts = Stripe::Account.list
       assert_requested :get, "#{Stripe.api_base}/v1/accounts"
-      assert accounts.data.kind_of?(Array)
-      assert accounts.data[0].kind_of?(Stripe::Account)
+      assert accounts.data.is_a?(Array)
+      assert accounts.data[0].is_a?(Stripe::Account)
     end
 
     should "be retrievable using singular endpoint" do
       account = Stripe::Account.retrieve
       assert_requested :get, "#{Stripe.api_base}/v1/account"
-      assert account.kind_of?(Stripe::Account)
+      assert account.is_a?(Stripe::Account)
     end
 
     should "be retrievable using plural endpoint" do
       account = Stripe::Account.retrieve("acct_123")
       assert_requested :get, "#{Stripe.api_base}/v1/accounts/acct_123"
-      assert account.kind_of?(Stripe::Account)
+      assert account.is_a?(Stripe::Account)
     end
 
     should "be rejectable" do
-      account_data = {:id => 'acct_foo'}
-      stub_request(:get, "#{Stripe.api_base}/v1/accounts/acct_foo").
-        to_return(body: JSON.generate(account_data))
+      account_data = { id: "acct_foo" }
+      stub_request(:get, "#{Stripe.api_base}/v1/accounts/acct_foo")
+        .to_return(body: JSON.generate(account_data))
 
-      stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_foo/reject").
-        to_return(body: JSON.generate(account_data))
+      stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_foo/reject")
+        .to_return(body: JSON.generate(account_data))
 
-      account = Stripe::Account.retrieve('acct_foo')
-      account.reject(:reason => 'fraud')
+      account = Stripe::Account.retrieve("acct_foo")
+      account.reject(reason: "fraud")
     end
 
     should "be creatable" do
-      account = Stripe::Account.create(:metadata => {}, :type => 'standard')
+      account = Stripe::Account.create(metadata: {}, type: "standard")
       assert_requested :post, "#{Stripe.api_base}/v1/accounts"
-      assert account.kind_of?(Stripe::Account)
+      assert account.is_a?(Stripe::Account)
     end
 
     should "be saveable" do
       account = Stripe::Account.retrieve("acct_123")
-      account.metadata['key'] = 'value'
+      account.metadata["key"] = "value"
       account.save
       assert_requested :post, "#{Stripe.api_base}/v1/accounts/#{account.id}"
     end
 
     should "be updateable" do
-      account = Stripe::Account.update("acct_123", metadata: {foo: 'bar'})
+      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)
+      assert account.is_a?(Stripe::Account)
     end
 
     should "be deletable" do
       account = Stripe::Account.retrieve("acct_123")
       account = account.delete
       assert_requested :delete, "#{Stripe.api_base}/v1/accounts/#{account.id}"
-      assert account.kind_of?(Stripe::Account)
+      assert account.is_a?(Stripe::Account)
     end
 
     context "#bank_account=" do
@@ -66,8 +66,8 @@ module Stripe
         begin
           account = Stripe::Account.retrieve("acct_123")
           account.bank_account = "tok_123"
-          message = "NOTE: Stripe::Account#bank_account= is " +
-            "deprecated; use #external_account= instead"
+          message = "NOTE: Stripe::Account#bank_account= is " \
+                    "deprecated; use #external_account= instead"
           assert_match Regexp.new(message), $stderr.string
         ensure
           $stderr = old_stderr
@@ -81,93 +81,85 @@ module Stripe
 
         # Unfortunately, the OpenAPI spec doesn't yet cover anything under the
         # Connect endpoints, so for just stub this out with Webmock.
-        stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize").
-          with(body: { 'client_id' => 'ca_1234', 'stripe_user_id' => account.id}).
-          to_return(body: JSON.generate({ 'stripe_user_id' => account.id }))
-        account.deauthorize('ca_1234', 'sk_test_1234')
+        stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize")
+          .with(body: { "client_id" => "ca_1234", "stripe_user_id" => account.id })
+          .to_return(body: JSON.generate("stripe_user_id" => account.id))
+        account.deauthorize("ca_1234", "sk_test_1234")
       end
     end
 
     context "#legal_entity=" do
-      should 'disallow direct overrides' do
+      should "disallow direct overrides" do
         account = Stripe::Account.retrieve("acct_123")
 
         assert_raise NoMethodError do
-          account.legal_entity = {:first_name => 'Blah'}
+          account.legal_entity = { first_name: "Blah" }
         end
 
-        account.legal_entity.first_name = 'Blah'
+        account.legal_entity.first_name = "Blah"
       end
     end
 
     context "#serialize_params" do
       should "serialize an a new additional_owners" do
         obj = Stripe::Util.convert_to_stripe_object({
-          :object => "account",
-          :legal_entity => Stripe::StripeObject.construct_from({
+          object: "account",
+          legal_entity: Stripe::StripeObject.construct_from({
           }),
         }, {})
         obj.legal_entity.additional_owners = [
-          { :first_name => "Joe" },
-          { :first_name => "Jane" },
+          { first_name: "Joe" },
+          { first_name: "Jane" },
         ]
 
         expected = {
-          :legal_entity => {
-            :additional_owners => {
-              "0" => { :first_name => "Joe" },
-              "1" => { :first_name => "Jane" },
-            }
-          }
+          legal_entity: {
+            additional_owners: {
+              "0" => { first_name: "Joe" },
+              "1" => { first_name: "Jane" },
+            },
+          },
         }
         assert_equal(expected, obj.serialize_params)
       end
 
       should "serialize on an partially changed additional_owners" do
         obj = Stripe::Util.convert_to_stripe_object({
-          :object => "account",
-          :legal_entity => {
-            :additional_owners => [
-              Stripe::StripeObject.construct_from({
-                :first_name => "Joe"
-              }),
-              Stripe::StripeObject.construct_from({
-                :first_name => "Jane"
-              }),
-            ]
-          }
+          object: "account",
+          legal_entity: {
+            additional_owners: [
+              Stripe::StripeObject.construct_from(first_name: "Joe"),
+              Stripe::StripeObject.construct_from(first_name: "Jane"),
+            ],
+          },
         }, {})
         obj.legal_entity.additional_owners[1].first_name = "Stripe"
 
         expected = {
-          :legal_entity => {
-            :additional_owners => {
-              "1" => { :first_name => "Stripe" }
-            }
-          }
+          legal_entity: {
+            additional_owners: {
+              "1" => { first_name: "Stripe" },
+            },
+          },
         }
         assert_equal(expected, obj.serialize_params)
       end
 
       should "serialize on an unchanged additional_owners" do
         obj = Stripe::Util.convert_to_stripe_object({
-          :object => "account",
-          :legal_entity => {
-            :additional_owners => [
-              Stripe::StripeObject.construct_from({
-                :first_name => "Joe"
-              }),
-              Stripe::StripeObject.construct_from({
-                :first_name => "Jane"
-              }),
-            ]
-          }
+          object: "account",
+          legal_entity: {
+            additional_owners: [
+              Stripe::StripeObject.construct_from(first_name: "Joe"),
+              Stripe::StripeObject.construct_from(first_name: "Jane"),
+            ],
+          },
         }, {})
 
         expected = {
-          :legal_entity => {
-            :additional_owners => {}
-          }
+          legal_entity: {
+            additional_owners: {},
+          },
         }
         assert_equal(expected, obj.serialize_params)
       end
@@ -176,24 +168,20 @@ module Stripe
       # meaning for the server, which interprets it as an array unset.
       should "serialize on an unset additional_owners" do
         obj = Stripe::Util.convert_to_stripe_object({
-          :object => "account",
-          :legal_entity => {
-            :additional_owners => [
-              Stripe::StripeObject.construct_from({
-                :first_name => "Joe"
-              }),
-              Stripe::StripeObject.construct_from({
-                :first_name => "Jane"
-              }),
-            ]
-          }
+          object: "account",
+          legal_entity: {
+            additional_owners: [
+              Stripe::StripeObject.construct_from(first_name: "Joe"),
+              Stripe::StripeObject.construct_from(first_name: "Jane"),
+            ],
+          },
         }, {})
         obj.legal_entity.additional_owners = nil
 
         expected = {
-          :legal_entity => {
-            :additional_owners => ""
-          }
+          legal_entity: {
+            additional_owners: "",
+          },
         }
         assert_equal(expected, obj.serialize_params)
       end

data/test/stripe/alipay_account_test.rb

@@ -1,7 +1,25 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class AlipayAccountTest < Test::Unit::TestCase
+    context "#resource_url" do
+      should "return a resource URL" do
+        alipay_account = Stripe::AlipayAccount.construct_from(
+          id: "aliacc_123",
+          customer: "cus_123"
+        )
+        assert_equal "/v1/customers/cus_123/sources/aliacc_123",
+                     alipay_account.resource_url
+      end
+
+      should "raise without a customer" do
+        alipay_account = Stripe::AlipayAccount.construct_from(id: "aliacc_123")
+        assert_raises NotImplementedError do
+          alipay_account.resource_url
+        end
+      end
+    end
+
     should "raise on #retrieve" do
       assert_raises NotImplementedError do
         Stripe::AlipayAccount.retrieve("aliacc_123")

data/test/stripe/api_operations_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class ApiOperationsTest < Test::Unit::TestCase
@@ -13,16 +13,16 @@ module Stripe
 
     context ".update" do
       should "post the correct parameters to the resource URL" do
-        stub_request(:post, "#{Stripe.api_base}/v1/updateableresources/id").
-          with(body: { foo: "bar" }).
-          to_return(body: JSON.generate({ foo: "bar" }))
-        resource = UpdateableResource::update("id", { foo: "bar" })
-        assert_equal('bar', resource.foo)
+        stub_request(:post, "#{Stripe.api_base}/v1/updateableresources/id")
+          .with(body: { foo: "bar" })
+          .to_return(body: JSON.generate(foo: "bar"))
+        resource = UpdateableResource.update("id", foo: "bar")
+        assert_equal("bar", resource.foo)
       end
 
       should "error on protected fields" do
         e = assert_raises do
-          UpdateableResource::update("id", { protected: "bar" })
+          UpdateableResource.update("id", protected: "bar")
         end
         assert_equal "Cannot update protected field: protected", e.message
       end

data/test/stripe/api_resource_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class ApiResourceTest < Test::Unit::TestCase
@@ -17,7 +17,7 @@ module Stripe
       should "set a flag if given an object source" do
         r = NestedTestAPIResource.new("test_resource")
         r.external_account = {
-          :object => 'card'
+          object: "card",
         }
         assert_equal true, r.external_account.save_with_parent
       end
@@ -29,17 +29,15 @@ module Stripe
     end
 
     should "creating a new APIResource from a hash should not fetch over the network" do
-      Stripe::Customer.construct_from({
-        :id => "somecustomer",
-        :card => {:id => "somecard", :object => "card"},
-        :object => "customer"
-      })
+      Stripe::Customer.construct_from(id: "somecustomer",
+                                      card: { id: "somecard", object: "card" },
+                                      object: "customer")
       assert_not_requested :get, %r{#{Stripe.api_base}/.*}
     end
 
     should "setting an attribute should not cause a network request" do
-      c = Stripe::Customer.new("cus_123");
-      c.card = {:id => "somecard", :object => "card"}
+      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
@@ -62,7 +60,7 @@ module Stripe
         Stripe::Customer.list({}, nil)
       end
       assert_raises TypeError do
-        Stripe::Customer.list({}, { :api_key => nil })
+        Stripe::Customer.list({}, api_key: nil)
       end
     end
 
@@ -74,43 +72,43 @@ module Stripe
     end
 
     should "send expand on fetch properly" do
-      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123").
-        with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(charge_fixture))
+      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123")
+        .with(query: { "expand" => ["customer"] })
+        .to_return(body: JSON.generate(charge_fixture))
 
-      Stripe::Charge.retrieve({:id => 'ch_123', :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_123").
-        with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(charge_fixture))
+      stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123")
+        .with(query: { "expand" => ["customer"] })
+        .to_return(body: JSON.generate(charge_fixture))
 
-      ch = Stripe::Charge.retrieve({:id => 'ch_123', :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/cus_123").
-        to_return(body: JSON.generate(customer_fixture))
+      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/cus_123/sources/cc_test_card").
-        with(query: { "expand" => ["customer"] }).
-        to_return(body: JSON.generate(customer_fixture))
+      stub_request(:get, "#{Stripe.api_base}/v1/customers/cus_123/sources/cc_test_card")
+        .with(query: { "expand" => ["customer"] })
+        .to_return(body: JSON.generate(customer_fixture))
 
-      customer = Stripe::Customer.retrieve('cus_123')
-      customer.sources.retrieve({:id => 'cc_test_card', :expand => :customer})
+      customer = Stripe::Customer.retrieve("cus_123")
+      customer.sources.retrieve(id: "cc_test_card", expand: :customer)
     end
 
     context "when specifying per-object credentials" do
       context "with no global API key set" do
         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(charge_fixture))
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .with(headers: { "Authorization" => "Bearer sk_test_local" })
+            .to_return(body: JSON.generate(charge_fixture))
 
-          Stripe::Charge.create({:source => 'tok_visa'},
-            'sk_test_local')
+          Stripe::Charge.create({ source: "tok_visa" },
+                                "sk_test_local")
         end
       end
 
@@ -124,23 +122,23 @@ module Stripe
         end
 
         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(charge_fixture))
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .with(headers: { "Authorization" => "Bearer sk_test_local" })
+            .to_return(body: JSON.generate(charge_fixture))
 
-          Stripe::Charge.create({:source => 'tok_visa'},
-            'sk_test_local')
+          Stripe::Charge.create({ source: "tok_visa" },
+                                "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_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')
+          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
@@ -148,52 +146,46 @@ module Stripe
 
     context "with valid credentials" do
       should "urlencode values in GET params" do
-        stub_request(:get, "#{Stripe.api_base}/v1/charges").
-          with(query: { customer: "test customer" }).
-          to_return(body: JSON.generate({
-            data: [charge_fixture]
-          }))
-        charges = Stripe::Charge.list(:customer => 'test customer').data
-        assert charges.kind_of? Array
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with(query: { customer: "test customer" })
+          .to_return(body: JSON.generate(data: [charge_fixture]))
+        charges = Stripe::Charge.list(customer: "test customer").data
+        assert charges.is_a? Array
       end
 
       should "construct URL properly with base query parameters" do
-        stub_request(:get, "#{Stripe.api_base}/v1/charges").
-          with(query: { customer: "cus_123" }).
-          to_return(body: JSON.generate({
-            data: [charge_fixture],
-            url: "/v1/charges"
-          }))
-        charges = Stripe::Invoice.list(:customer => 'cus_123')
-
-        stub_request(:get, "#{Stripe.api_base}/v1/charges").
-          with(query: { customer: "cus_123", created: "123" }).
-          to_return(body: JSON.generate({
-            data: [charge_fixture],
-            url: "/v1/charges"
-          }))
-        charges.list(:created => 123)
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with(query: { customer: "cus_123" })
+          .to_return(body: JSON.generate(data: [charge_fixture],
+                                         url: "/v1/charges"))
+        charges = Stripe::Invoice.list(customer: "cus_123")
+
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with(query: { customer: "cus_123", created: "123" })
+          .to_return(body: JSON.generate(data: [charge_fixture],
+                                         url: "/v1/charges"))
+        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 => [charge_fixture] }))
-        Stripe::Charge.list(:count => nil, :offset => 5, :sad => false)
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with(query: { offset: 5, sad: false })
+          .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 => [charge_fixture] }))
-        Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .with(body: { "amount" => "50", "currency" => "usd" })
+          .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(charge_fixture))
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(charge_fixture))
         old_stderr = $stderr
         $stderr = StringIO.new
         begin
-          Stripe::Charge.create({ :amount => 100, :currency => 'usd', :card => 'sc_token' }, { :idempotency_key => '12345' })
+          Stripe::Charge.create({ amount: 100, currency: "usd", card: "sc_token" }, idempotency_key: "12345")
           assert $stderr.string.empty?
         ensure
           $stderr = old_stderr
@@ -201,21 +193,21 @@ module Stripe
       end
 
       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(charge_fixture))
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(charge_fixture))
         old_stderr = $stderr
         $stderr = StringIO.new
         begin
-          Stripe::Charge.create({ :amount => 100, :currency => 'usd', :card => 'sc_token', :idempotency_key => '12345' })
-          assert_match Regexp.new('WARNING:'), $stderr.string
+          Stripe::Charge.create(amount: 100, currency: "usd", card: "sc_token", idempotency_key: "12345")
+          assert_match Regexp.new("WARNING:"), $stderr.string
         ensure
           $stderr = old_stderr
         end
       end
 
       should "requesting with a unicode ID should result in a request" do
-        stub_request(:get, "#{Stripe.api_base}/v1/customers/%E2%98%83").
-          to_return(body: JSON.generate(make_missing_id_error), status: 404)
+        stub_request(:get, "#{Stripe.api_base}/v1/customers/%E2%98%83")
+          .to_return(body: JSON.generate(make_missing_id_error), status: 404)
         c = Stripe::Customer.new("☃")
         assert_raises(Stripe::InvalidRequestError) { c.refresh }
       end
@@ -226,58 +218,58 @@ module Stripe
       end
 
       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 => [charge_fixture] }))
-        Stripe::Charge.list({ :limit => 1 })
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with(query: { limit: 1 })
+          .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(charge_fixture))
-        Stripe::Charge.create({ :amount => 100, :currency => 'usd', :card => 'sc_token' })
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .with(body: { "amount" => "100", "currency" => "usd", "card" => "sc_token" })
+          .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/charges/ch_123").
-          to_return(body: JSON.generate(charge_fixture))
+        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/charges/ch_123").
-          to_return(body: JSON.generate(charge_fixture))
+        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']
-        c['created'] = 12345
-        assert_equal c.created, 12345
+        assert_equal c.created, c["created"]
+        c["created"] = 12_345
+        assert_equal c.created, 12_345
       end
 
       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: "cus_123" }).
-          to_return(body: JSON.generate(customer_fixture))
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .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/cus_123").
-          with(body: { 'description' => 'another_mn' }).
-          to_return(body: JSON.generate(customer_fixture))
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/cus_123")
+          .with(body: { "description" => "another_mn" })
+          .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/cus_123").
-          with(body: { 'description' => 'another_mn' }).
-          to_return(body: JSON.generate(customer_fixture))
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/cus_123")
+          .with(body: { "description" => "another_mn" })
+          .to_return(body: JSON.generate(customer_fixture))
         c = Stripe::Customer.new("cus_123")
         c.description = "another_mn"
         c.save
@@ -287,245 +279,221 @@ module Stripe
       should "updating should fail if api_key is overwritten with nil" do
         c = Stripe::Customer.new
         assert_raises TypeError do
-          c.save({}, { :api_key => nil })
+          c.save({}, api_key: nil)
         end
       end
 
       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(customer_fixture))
+        stub_request(:post, "#{Stripe.api_base}/v1/customers")
+          .with(headers: { "Authorization" => "Bearer sk_test_local" })
+          .to_return(body: JSON.generate(customer_fixture))
         c = Stripe::Customer.new
-        c.save({}, { :api_key => 'sk_test_local' })
+        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/cus_123").
-          to_return(body: JSON.generate({ "id" => "cus_123", "deleted" => true }))
+        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: [charge_fixture]
-          }))
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(data: [charge_fixture]))
         charges = Stripe::Charge.list.data
-        assert charges.kind_of? Array
-        assert charges[0].kind_of? Stripe::Charge
-        assert charges[0].source.kind_of?(Stripe::StripeObject)
+        assert charges.is_a? Array
+        assert charges[0].is_a? Stripe::Charge
+        assert charges[0].source.is_a?(Stripe::StripeObject)
       end
 
       should "passing in a stripe_account header should pass it through on call" do
-        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'})
+        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/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'
+        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
 
-      should 'add key to nested objects' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :size => 'l',
-            :score => 4,
-            :height => 10
-          }
-        })
+      should "add key to nested objects" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                size: "l",
+                                                score: 4,
+                                                height: 10,
+                                              })
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: { legal_entity: { first_name: "Bob" } }).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: { legal_entity: { first_name: "Bob" } })
+          .to_return(body: JSON.generate("id" => "myid"))
 
-        acct.legal_entity.first_name = 'Bob'
+        acct.legal_entity.first_name = "Bob"
         acct.save
       end
 
-      should 'save nothing if nothing changes' do
-        acct = Stripe::Account.construct_from({
-          :id => 'acct_id',
-          :metadata => {
-            :key => 'value'
-          }
-        })
+      should "save nothing if nothing changes" do
+        acct = Stripe::Account.construct_from(id: "acct_id",
+                                              metadata: {
+                                                key: "value",
+                                              })
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_id").
-          with(body: {}).
-          to_return(body: JSON.generate({ "id" => "acct_id" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_id")
+          .with(body: {})
+          .to_return(body: JSON.generate("id" => "acct_id"))
 
         acct.save
       end
 
-      should 'not save nested API resources' do
-        ch = Stripe::Charge.construct_from({
-          :id => 'ch_id',
-          :customer => {
-            :object => 'customer',
-            :id => 'customer_id'
-          }
-        })
+      should "not save nested API resources" do
+        ch = Stripe::Charge.construct_from(id: "ch_id",
+                                           customer: {
+                                             object: "customer",
+                                             id: "customer_id",
+                                           })
 
-        stub_request(:post, "#{Stripe.api_base}/v1/charges/ch_id").
-          with(body: {}).
-          to_return(body: JSON.generate({ "id" => "ch_id" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/charges/ch_id")
+          .with(body: {})
+          .to_return(body: JSON.generate("id" => "ch_id"))
 
-        ch.customer.description = 'Bob'
+        ch.customer.description = "Bob"
         ch.save
       end
 
-      should 'correctly handle replaced nested objects' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :last_name => 'Smith',
-            :address => {
-              :line1 => "test",
-              :city => "San Francisco"
-            }
-          }
-        })
+      should "correctly handle replaced nested objects" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                last_name: "Smith",
+                                                address: {
+                                                  line1: "test",
+                                                  city: "San Francisco",
+                                                },
+                                              })
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: { legal_entity: { address: { line1: "Test2", city: "" } } }).
-          to_return(body: JSON.generate({ "id" => "my_id" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: { legal_entity: { address: { line1: "Test2", city: "" } } })
+          .to_return(body: JSON.generate("id" => "my_id"))
 
-        acct.legal_entity.address = {:line1 => 'Test2'}
+        acct.legal_entity.address = { line1: "Test2" }
         acct.save
       end
 
-      should 'correctly handle array setting' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {}
-        })
+      should "correctly handle array setting" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {})
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: { legal_entity: { additional_owners: [{ first_name: "Bob" }] } }).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: { legal_entity: { additional_owners: [{ first_name: "Bob" }] } })
+          .to_return(body: JSON.generate("id" => "myid"))
 
-        acct.legal_entity.additional_owners = [{:first_name => 'Bob'}]
+        acct.legal_entity.additional_owners = [{ first_name: "Bob" }]
         acct.save
       end
 
-      should 'correctly handle array insertion' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => []
-          }
-        })
+      should "correctly handle array insertion" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                additional_owners: [],
+                                              })
 
         # Note that this isn't a perfect check because we're using webmock's
         # data decoding, which isn't aware of the Stripe array encoding that we
         # use here.
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: { legal_entity: { additional_owners: [{ first_name: "Bob" }] } }).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: { legal_entity: { additional_owners: [{ first_name: "Bob" }] } })
+          .to_return(body: JSON.generate("id" => "myid"))
 
-        acct.legal_entity.additional_owners << {:first_name => 'Bob'}
+        acct.legal_entity.additional_owners << { first_name: "Bob" }
         acct.save
       end
 
-      should 'correctly handle array updates' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => [{:first_name => 'Bob'}, {:first_name => 'Jane'}]
-          }
-        })
+      should "correctly handle array updates" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                additional_owners: [{ first_name: "Bob" }, { first_name: "Jane" }],
+                                              })
 
         # Note that this isn't a perfect check because we're using webmock's
         # data decoding, which isn't aware of the Stripe array encoding that we
         # use here.
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: { legal_entity: { additional_owners: [{ first_name: "Janet" }] } }).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: { legal_entity: { additional_owners: [{ first_name: "Janet" }] } })
+          .to_return(body: JSON.generate("id" => "myid"))
 
-        acct.legal_entity.additional_owners[1].first_name = 'Janet'
+        acct.legal_entity.additional_owners[1].first_name = "Janet"
         acct.save
       end
 
-      should 'correctly handle array noops' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => [{:first_name => 'Bob'}]
-          },
-          :currencies_supported => ['usd', 'cad']
-        })
+      should "correctly handle array noops" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                additional_owners: [{ first_name: "Bob" }],
+                                              },
+                                              currencies_supported: %w[usd cad])
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: {}).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: {})
+          .to_return(body: JSON.generate("id" => "myid"))
 
         acct.save
       end
 
-      should 'correctly handle hash noops' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :address => {:line1 => '1 Two Three'}
-          }
-        })
+      should "correctly handle hash noops" do
+        acct = Stripe::Account.construct_from(id: "myid",
+                                              legal_entity: {
+                                                address: { line1: "1 Two Three" },
+                                              })
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
-          with(body: {}).
-          to_return(body: JSON.generate({ "id" => "myid" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid")
+          .with(body: {})
+          .to_return(body: JSON.generate("id" => "myid"))
 
         acct.save
       end
 
-      should 'should create a new resource when an object without an id is saved' do
-        account = Stripe::Account.construct_from({
-          :id => nil,
-          :display_name => nil,
-        })
+      should "should create a new resource when an object without an id is saved" do
+        account = Stripe::Account.construct_from(id: nil,
+                                                 display_name: nil)
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts").
-          with(body: { display_name: "stripe" }).
-          to_return(body: JSON.generate({ "id" => "acct_123" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts")
+          .with(body: { display_name: "stripe" })
+          .to_return(body: JSON.generate("id" => "acct_123"))
 
-        account.display_name = 'stripe'
+        account.display_name = "stripe"
         account.save
       end
 
-      should 'set attributes as part of save' do
-        account = Stripe::Account.construct_from({
-          :id => nil,
-          :display_name => nil,
-        })
+      should "set attributes as part of save" do
+        account = Stripe::Account.construct_from(id: nil,
+                                                 display_name: nil)
 
-        stub_request(:post, "#{Stripe.api_base}/v1/accounts").
-          with(body: { display_name: "stripe", metadata: { key: "value" } }).
-          to_return(body: JSON.generate({ "id" => "acct_123" }))
+        stub_request(:post, "#{Stripe.api_base}/v1/accounts")
+          .with(body: { display_name: "stripe", metadata: { key: "value" } })
+          .to_return(body: JSON.generate("id" => "acct_123"))
 
-        account.save(:display_name => 'stripe', :metadata => {:key => 'value' })
+        account.save(display_name: "stripe", metadata: { key: "value" })
       end
     end
 
     @@fixtures = {}
     setup do
       if @@fixtures.empty?
-        set_fixture(:charge) do
+        cache_fixture(:charge) do
           Charge.retrieve("ch_123")
         end
-        set_fixture(:customer) do
+        cache_fixture(:customer) do
           Customer.retrieve("cus_123")
         end
       end
@@ -541,13 +509,9 @@ module Stripe
       @@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)
+    def cache_fixture(key)
       return @@fixtures[key] if @@fixtures.key?(key)
 
       obj = yield