stripe 5.2.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec1d1414aafc87b63dca172263ecd4666467cda2ab39eaac1abdbd13e7cd90b
-  data.tar.gz: 3adde22d80c8f867e34d2735dd0aea142f0b69e6cd2a84e13fe7c6a53655ee85
+  metadata.gz: b717ef70627c0f7467317a2e2f08e8d553b04411b6324df41f4cc5eac6bd6800
+  data.tar.gz: 26a05a4ceeb4412c95c2ad12776785c72bd291841c5843eba2ec03a6dc21a722
 SHA512:
-  metadata.gz: e4086cfa6bc5281bf1e31e88a2435156d6928716d7022e319afe5845157571731ad260c3728c6bf021d593f11727fa6fdba06c26667d7d5774b6a29cfadf9829
-  data.tar.gz: 4b6477d988e90607c8ad8c1d8a4a11e3f0afb3494948403d2b6b9e23cde4a6be0dcb9779100306c28449e6d7d24876043edcc2239ab00cdb1dc7fd88942b57de
+  metadata.gz: ef1b962195d8a8510a1d360d8fbd18a246c65363877b43a451bccd1340c1ea18008581c04c4a0e62eb6eed9f2f8afebfccf9c4f5d059b08a2ccd921cae5b5cd0
+  data.tar.gz: 98fb62f907a16aadb4cab5564053ce85e96931193a8e1eeccb8ef10ebcfa726ddf086e51aef09db0825c685129867d5a91716addcc2252ae771869ca4d83bc8a

data/.rubocop.yml

@@ -4,6 +4,12 @@ AllCops:
   DisplayCopNames: true
   TargetRubyVersion: 2.3
 
+  Exclude:
+    # brandur: Exclude ephmeral script-like files that I use to try and
+    # reproduce problems with the library. If you know of a better way of doing
+    # this (e.g. exclude files not tracked by Git), feel free to change it.
+    - "example_*"
+
 Layout/CaseIndentation:
   EnforcedStyle: end
 

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 5.6.0 - 2019-10-04
+* [#861](https://github.com/stripe/stripe-ruby/pull/861) Nicer error when specifying non-nil non-string opt value
+
+## 5.5.0 - 2019-10-03
+* [#859](https://github.com/stripe/stripe-ruby/pull/859) User-friendly messages and retries for `EOFError`, `Errno::ECONNRESET`, `Errno::ETIMEDOUT`, and `Errno::EHOSTUNREACH` network errors
+
+## 5.4.1 - 2019-10-01
+* [#858](https://github.com/stripe/stripe-ruby/pull/858) Drop Timecop dependency
+
+## 5.4.0 - 2019-10-01
+* [#857](https://github.com/stripe/stripe-ruby/pull/857) Move to monotonic time for duration calculations
+
+## 5.3.0 - 2019-10-01
+* [#853](https://github.com/stripe/stripe-ruby/pull/853) Support `Stripe-Should-Retry` header
+
 ## 5.2.0 - 2019-09-19
 * [#851](https://github.com/stripe/stripe-ruby/pull/851) Introduce system for garbage collecting connection managers
 

data/Gemfile

@@ -11,7 +11,6 @@ group :development do
   gem "rake"
   gem "shoulda-context"
   gem "test-unit"
-  gem "timecop"
   gem "webmock"
 
   # Rubocop changes pretty quickly: new cops get added and old cops change

data/VERSION

@@ -1 +1 @@
-5.2.0
+5.6.0

data/lib/stripe/api_operations/nested_resource.rb

@@ -6,7 +6,7 @@ module Stripe
     # that it's possible to do so from a static context (i.e. without a
     # pre-existing collection of subresources on the parent).
     #
-    # For examle, a transfer gains the static methods for reversals so that the
+    # For example, a transfer gains the static methods for reversals so that the
     # methods `.create_reversal`, `.retrieve_reversal`, `.update_reversal`,
     # etc. all become available.
     module NestedResource
@@ -14,9 +14,11 @@ module Stripe
                                         resource_plural: nil)
         resource_plural ||= "#{resource}s"
         path ||= resource_plural
+
         raise ArgumentError, "operations array required" if operations.nil?
 
         resource_url_method = :"#{resource}s_url"
+
         define_singleton_method(resource_url_method) do |id, nested_id = nil|
           url = "#{resource_url}/#{CGI.escape(id)}/#{CGI.escape(path)}"
           url += "/#{CGI.escape(nested_id)}" unless nested_id.nil?
@@ -27,39 +29,39 @@ module Stripe
           case operation
           when :create
             define_singleton_method(:"create_#{resource}") \
-                do |id, params = {}, opts = {}|
-              url = send(resource_url_method, id)
-              resp, opts = request(:post, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :retrieve
             define_singleton_method(:"retrieve_#{resource}") \
-                do |id, nested_id, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:get, url, {}, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:get, url, {}, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :update
             define_singleton_method(:"update_#{resource}") \
-                do |id, nested_id, params = {}, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:post, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :delete
             define_singleton_method(:"delete_#{resource}") \
-                do |id, nested_id, params = {}, opts = {}|
-              url = send(resource_url_method, id, nested_id)
-              resp, opts = request(:delete, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = request(:delete, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           when :list
             define_singleton_method(:"list_#{resource_plural}") \
-                do |id, params = {}, opts = {}|
-              url = send(resource_url_method, id)
-              resp, opts = request(:get, url, params, opts)
-              Util.convert_to_stripe_object(resp.data, opts)
-            end
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = request(:get, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
           else
             raise ArgumentError, "Unknown operation: #{operation.inspect}"
           end

data/lib/stripe/api_operations/request.rb

@@ -8,6 +8,8 @@ module Stripe
           warn_on_opts_in_params(params)
 
           opts = Util.normalize_opts(opts)
+          error_on_non_string_user_opts(opts)
+
           opts[:client] ||= StripeClient.active_client
 
           headers = opts.clone
@@ -31,10 +33,24 @@ module Stripe
           [resp, opts_to_persist]
         end
 
+        private def error_on_non_string_user_opts(opts)
+          Util::OPTS_USER_SPECIFIED.each do |opt|
+            next unless opts.key?(opt)
+
+            val = opts[opt]
+            next if val.nil?
+            next if val.is_a?(String)
+
+            raise ArgumentError,
+                  "request option '#{opt}' should be a string value " \
+                    "(was a #{val.class})"
+          end
+        end
+
         private def warn_on_opts_in_params(params)
           Util::OPTS_USER_SPECIFIED.each do |opt|
             if params.key?(opt)
-              warn("WARNING: #{opt} should be in opts instead of params.")
+              warn("WARNING: '#{opt}' should be in opts instead of params.")
             end
           end
         end

data/lib/stripe/connection_manager.rb

@@ -10,14 +10,15 @@ module Stripe
   # Note that this class in itself is *not* thread safe. We expect it to be
   # instantiated once per thread.
   class ConnectionManager
-    # Timestamp indicating when the connection manager last made a request.
-    # This is used by `StripeClient` to determine whether a connection manager
-    # should be garbage collected or not.
+    # Timestamp (in seconds procured from the system's monotonic clock)
+    # indicating when the connection manager last made a request. This is used
+    # by `StripeClient` to determine whether a connection manager should be
+    # garbage collected or not.
     attr_reader :last_used
 
     def initialize
       @active_connections = {}
-      @last_used = Time.now
+      @last_used = Util.monotonic_time
 
       # A connection manager may be accessed across threads as one thread makes
       # requests on it while another is trying to clear it (either because it's
@@ -78,7 +79,7 @@ module Stripe
       raise ArgumentError, "query should be a string" \
         if query && !query.is_a?(String)
 
-      @last_used = Time.now
+      @last_used = Util.monotonic_time
 
       connection = connection_for(uri)
 

data/lib/stripe/stripe_client.rb

@@ -9,7 +9,7 @@ module Stripe
     # synchronize global access to them.
     @thread_contexts_with_connection_managers = []
     @thread_contexts_with_connection_managers_mutex = Mutex.new
-    @last_connection_manager_gc = Time.now
+    @last_connection_manager_gc = Util.monotonic_time
 
     # Initializes a new `StripeClient`.
     #
@@ -81,17 +81,23 @@ module Stripe
     def self.should_retry?(error, method:, num_retries:)
       return false if num_retries >= Stripe.max_network_retries
 
-      # Retry on timeout-related problems (either on open or read).
-      return true if error.is_a?(Net::OpenTimeout)
-      return true if error.is_a?(Net::ReadTimeout)
+      case error
+      when Net::OpenTimeout, Net::ReadTimeout
+        # Retry on timeout-related problems (either on open or read).
+        true
+      when EOFError, Errno::ECONNREFUSED, Errno::ECONNRESET,
+            Errno::EHOSTUNREACH, Errno::ETIMEDOUT, SocketError
+        # Destination refused the connection, the connection was reset, or a
+        # variety of other connection failures. This could occur from a single
+        # saturated server, so retry in case it's intermittent.
+        true
+      when Stripe::StripeError
+        # The API may ask us not to retry (e.g. if doing so would be a no-op),
+        # or advise us to retry (e.g. in cases of lock timeouts). Defer to
+        # those instructions if given.
+        return false if error.http_headers["stripe-should-retry"] == "false"
+        return true if error.http_headers["stripe-should-retry"] == "true"
 
-      # Destination refused the connection, the connection was reset, or a
-      # variety of other connection failures. This could occur from a single
-      # saturated server, so retry in case it's intermittent.
-      return true if error.is_a?(Errno::ECONNREFUSED)
-      return true if error.is_a?(SocketError)
-
-      if error.is_a?(Stripe::StripeError)
         # 409 Conflict
         return true if error.http_status == 409
 
@@ -113,10 +119,10 @@ module Stripe
         return true if error.http_status == 500 && method != :post
 
         # 503 Service Unavailable
-        return true if error.http_status == 503
+        error.http_status == 503
+      else
+        false
       end
-
-      false
     end
 
     def self.sleep_time(num_retries)
@@ -290,7 +296,11 @@ module Stripe
     # The original error message is also appended onto the final exception for
     # full transparency.
     NETWORK_ERROR_MESSAGES_MAP = {
+      EOFError => ERROR_MESSAGE_CONNECTION,
       Errno::ECONNREFUSED => ERROR_MESSAGE_CONNECTION,
+      Errno::ECONNRESET => ERROR_MESSAGE_CONNECTION,
+      Errno::EHOSTUNREACH => ERROR_MESSAGE_CONNECTION,
+      Errno::ETIMEDOUT => ERROR_MESSAGE_TIMEOUT_CONNECT,
       SocketError => ERROR_MESSAGE_CONNECTION,
 
       Net::OpenTimeout => ERROR_MESSAGE_TIMEOUT_CONNECT,
@@ -362,11 +372,11 @@ module Stripe
     # For internal use only. Does not provide a stable API and may be broken
     # with future non-major changes.
     def self.maybe_gc_connection_managers
-      if @last_connection_manager_gc + CONNECTION_MANAGER_GC_PERIOD > Time.now
-        return nil
-      end
+      next_gc_time = @last_connection_manager_gc + CONNECTION_MANAGER_GC_PERIOD
+      return nil if next_gc_time > Util.monotonic_time
 
-      last_used_threshold = Time.now - CONNECTION_MANAGER_GC_LAST_USED_EXPIRY
+      last_used_threshold =
+        Util.monotonic_time - CONNECTION_MANAGER_GC_LAST_USED_EXPIRY
 
       pruned_thread_contexts = []
       @thread_contexts_with_connection_managers.each do |thread_context|
@@ -379,7 +389,7 @@ module Stripe
       end
 
       @thread_contexts_with_connection_managers -= pruned_thread_contexts
-      @last_connection_manager_gc = Time.now
+      @last_connection_manager_gc = Util.monotonic_time
 
       pruned_thread_contexts.count
     end
@@ -439,7 +449,7 @@ module Stripe
     private def execute_request_with_rescues(method, api_base, context)
       num_retries = 0
       begin
-        request_start = Time.now
+        request_start = Util.monotonic_time
         log_request(context, num_retries)
         resp = yield
         context = context.dup_from_response_headers(resp)
@@ -449,7 +459,8 @@ module Stripe
         log_response(context, request_start, resp.code.to_i, resp.body)
 
         if Stripe.enable_telemetry? && context.request_id
-          request_duration_ms = ((Time.now - request_start) * 1000).to_int
+          request_duration_ms =
+            ((Util.monotonic_time - request_start) * 1000).to_int
           @last_request_metrics =
             StripeRequestMetrics.new(context.request_id, request_duration_ms)
         end
@@ -720,7 +731,7 @@ module Stripe
       Util.log_info("Response from Stripe API",
                     account: context.account,
                     api_version: context.api_version,
-                    elapsed: Time.now - request_start,
+                    elapsed: Util.monotonic_time - request_start,
                     idempotency_key: context.idempotency_key,
                     method: context.method,
                     path: context.path,
@@ -742,7 +753,7 @@ module Stripe
 
     private def log_response_error(context, request_start, error)
       Util.log_error("Request error",
-                     elapsed: Time.now - request_start,
+                     elapsed: Util.monotonic_time - request_start,
                      error_message: error.message,
                      idempotency_key: context.idempotency_key,
                      method: context.method,

data/lib/stripe/util.rb

@@ -172,6 +172,18 @@ module Stripe
       result
     end
 
+    # `Time.now` can be unstable in cases like an administrator manually
+    # updating its value or a reconcilation via NTP. For this reason, prefer
+    # the use of the system's monotonic clock especially where comparing times
+    # to calculate an elapsed duration.
+    #
+    # Shortcut for getting monotonic time, mostly for purposes of line length
+    # and test stubbing. Returns time in seconds since the event used for
+    # monotonic reference purposes by the platform (e.g. system boot time).
+    def self.monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     def self.normalize_id(id)
       if id.is_a?(Hash) # overloaded id
         params_hash = id.dup

data/lib/stripe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stripe
-  VERSION = "5.2.0"
+  VERSION = "5.6.0"
 end

data/test/stripe/api_resource_test.rb

@@ -227,6 +227,23 @@ module Stripe
         end
       end
 
+      should "error if a user-specified opt is given a non-nil non-string value" do
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(charge_fixture))
+
+        # Works fine if not included or a string.
+        Stripe::Charge.create({ amount: 100, currency: "usd" }, {})
+        Stripe::Charge.create({ amount: 100, currency: "usd" }, idempotency_key: "12345")
+
+        # Errors on a non-string.
+        e = assert_raises(ArgumentError) do
+          Stripe::Charge.create({ amount: 100, currency: "usd" }, idempotency_key: :foo)
+        end
+        assert_equal "request option 'idempotency_key' should be a string value " \
+                       "(was a Symbol)",
+                     e.message
+      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)

data/test/stripe/connection_manager_test.rb

@@ -10,10 +10,9 @@ module Stripe
 
     context "#initialize" do
       should "set #last_used to current time" do
-        t = Time.new(2019)
-        Timecop.freeze(t) do
-          assert_equal t, Stripe::ConnectionManager.new.last_used
-        end
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
+        assert_equal t, Stripe::ConnectionManager.new.last_used
       end
     end
 
@@ -147,19 +146,17 @@ module Stripe
         stub_request(:post, "#{Stripe.api_base}/path")
           .to_return(body: JSON.generate(object: "account"))
 
-        t = Time.new(2019)
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
 
-        # Make sure the connection manager is initialized at a different time
-        # than the one we're going to measure at because `#last_used` is also
-        # set by the constructor.
-        manager = Timecop.freeze(t) do
-          Stripe::ConnectionManager.new
-        end
+        manager = Stripe::ConnectionManager.new
 
-        Timecop.freeze(t + 1) do
-          manager.execute_request(:post, "#{Stripe.api_base}/path")
-          assert_equal t + 1, manager.last_used
-        end
+        # `#last_used` is also set by the constructor, so make sure we get a
+        # new value for it.
+        Util.stubs(:monotonic_time).returns(t + 1.0)
+
+        manager.execute_request(:post, "#{Stripe.api_base}/path")
+        assert_equal t + 1.0, manager.last_used
       end
     end
   end

data/test/stripe/stripe_client_test.rb

@@ -27,47 +27,63 @@ module Stripe
         StripeClient.clear_all_connection_managers
 
         # Establish a base time.
-        t = Time.new(2019)
+        t = 0.0
 
         # And pretend that `StripeClient` was just initialized for the first
         # time. (Don't access instance variables like this, but it's tricky to
         # test properly otherwise.)
         StripeClient.instance_variable_set(:@last_connection_manager_gc, t)
 
-        Timecop.freeze(t) do
-          # Execute an initial request to ensure that a connection manager was
-          # created.
-          client = StripeClient.new
-          client.execute_request(:post, "/v1/path")
+        #
+        # t
+        #
+        Util.stubs(:monotonic_time).returns(t)
 
-          # The GC shouldn't run yet  (a `nil` return indicates that GC didn't run).
-          assert_equal nil, StripeClient.maybe_gc_connection_managers
-        end
+        # Execute an initial request to ensure that a connection manager was
+        # created.
+        client = StripeClient.new
+        client.execute_request(:post, "/v1/path")
+
+        # The GC shouldn't run yet  (a `nil` return indicates that GC didn't run).
+        assert_equal nil, StripeClient.maybe_gc_connection_managers
 
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_PERIOD - 1
+        #
         # Move time to just *before* garbage collection is eligible to run.
         # Nothing should happen.
-        Timecop.freeze(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD - 1) do
-          assert_equal nil, StripeClient.maybe_gc_connection_managers
-        end
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD - 1)
+
+        assert_equal nil, StripeClient.maybe_gc_connection_managers
 
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_PERIOD + 1
+        #
         # Move time to just *after* garbage collection is eligible to run.
         # Garbage collection will run, but because the connection manager is
         # not passed its expiry age, it will not be collected. Zero is returned
         # to indicate so.
-        Timecop.freeze(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD + 1) do
-          assert_equal 0, StripeClient.maybe_gc_connection_managers
-        end
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_PERIOD + 1)
+
+        assert_equal 0, StripeClient.maybe_gc_connection_managers
 
+        #
+        # t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1
+        #
         # Move us far enough into the future that we're passed the horizons for
         # both a GC run as well as well as the expiry age of a connection
         # manager. That means the GC will run and collect the connection
         # manager that we created above.
-        Timecop.freeze(t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1) do
-          assert_equal 1, StripeClient.maybe_gc_connection_managers
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1)
 
-          # And as an additional check, the connection manager of the current thread context should have been set to `nil` as it was GCed.
-          assert_nil StripeClient.current_thread_context.default_connection_manager
-        end
+        assert_equal 1, StripeClient.maybe_gc_connection_managers
+
+        # And as an additional check, the connection manager of the current
+        # thread context should have been set to `nil` as it was GCed.
+        assert_nil StripeClient.current_thread_context.default_connection_manager
       end
     end
 
@@ -156,6 +172,26 @@ module Stripe
                                           method: :post, num_retries: 0)
       end
 
+      should "retry on EOFError" do
+        assert StripeClient.should_retry?(EOFError.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::ECONNRESET" do
+        assert StripeClient.should_retry?(Errno::ECONNRESET.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::ETIMEDOUT" do
+        assert StripeClient.should_retry?(Errno::ETIMEDOUT.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Errno::EHOSTUNREACH" do
+        assert StripeClient.should_retry?(Errno::EHOSTUNREACH.new,
+                                          method: :post, num_retries: 0)
+      end
+
       should "retry on Net::OpenTimeout" do
         assert StripeClient.should_retry?(Net::OpenTimeout.new,
                                           method: :post, num_retries: 0)
@@ -171,6 +207,28 @@ module Stripe
                                           method: :post, num_retries: 0)
       end
 
+      should "retry when the `Stripe-Should-Retry` header is `true`" do
+        headers = StripeResponse::Headers.new(
+          "Stripe-Should-Retry" => ["true"]
+        )
+
+        # Note we send status 400 here, which would normally not be retried.
+        assert StripeClient.should_retry?(Stripe::StripeError.new(http_headers: headers,
+                                                                  http_status: 400),
+                                          method: :post, num_retries: 0)
+      end
+
+      should "not retry when the `Stripe-Should-Retry` header is `false`" do
+        headers = StripeResponse::Headers.new(
+          "Stripe-Should-Retry" => ["false"]
+        )
+
+        # Note we send status 409 here, which would normally be retried.
+        refute StripeClient.should_retry?(Stripe::StripeError.new(http_headers: headers,
+                                                                  http_status: 409),
+                                          method: :post, num_retries: 0)
+      end
+
       should "retry on a 409 Conflict" do
         assert StripeClient.should_retry?(Stripe::StripeError.new(http_status: 409),
                                           method: :post, num_retries: 0)
@@ -279,16 +337,11 @@ module Stripe
       context "logging" do
         setup do
           # Freeze time for the purposes of the `elapsed` parameter that we
-          # emit for responses. I didn't want to bring in a new dependency for
-          # this, but Mocha's `anything` parameter can't match inside of a hash
-          # and is therefore not useful for this purpose. If we switch over to
-          # rspec-mocks at some point, we can probably remove Timecop from the
-          # project.
-          Timecop.freeze(Time.local(1990))
-        end
-
-        teardown do
-          Timecop.return
+          # emit for responses. Mocha's `anything` parameter can't match inside
+          # of a hash and is therefore not useful for this purpose. If we
+          # switch over to rspec-mocks at some point, we can probably remove
+          # this.
+          Util.stubs(:monotonic_time).returns(0.0)
         end
 
         should "produce appropriate logging" do

data/test/test_helper.rb

@@ -8,7 +8,6 @@ require "test/unit"
 require "mocha/setup"
 require "stringio"
 require "shoulda/context"
-require "timecop"
 require "webmock/test_unit"
 
 PROJECT_ROOT = ::File.expand_path("../", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stripe
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-20 00:00:00.000000000 Z
+date: 2019-10-04 00:00:00.000000000 Z
 dependencies: []
 description: Stripe is the easiest way to accept payments online.  See https://stripe.com
   for details.
@@ -246,7 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for the Stripe API