mirror of
https://github.com/stripe/stripe-ruby.git
synced 2025-10-05 00:02:50 -04:00
44766516d9
* Convert library to use built-in `Net::HTTP`
Moves the library off of Faraday and over onto the standard library's
built-in `Net::HTTP` module. The upside of the transition is that we
break away from a few dependencies that have caused us a fair bit of
trouble in the past, the downside is that we need more of our own code
to do things (although surprisingly, not that much more).
The biggest new pieces are:
* `ConnectionManager`: A per-thread class that manages a connection to
each Stripe infrastructure URL (like `api.stripe.com`,
`connect.stripe.com`, etc.) so that we can reuse them between
requests. It's also responsible for setting up and configuring new
`Net::HTTP` connections, which is a little more heavyweight
code-wise compared to other libraries. All of this could have lived in
`StripeClient`, but I extracted it because that class has gotten so
big.
* `MultipartEncoder`: A class that does multipart form encoding for file
uploads. Unfortunately, Ruby doesn't bundle anything like this. I
built this by referencing the Go implementation because the original
RFC is not very detailed or well-written. I also made sure that it was
behaving similarly to our other custom implementations like
stripe-node, and that it can really upload a file outside the test
suite.
There's some risk here in that it's easy to miss something across one of
these big transitions. I've tried to test out various error cases
through tests, but also by leaving scripts running as I terminate my
network connection and bring it back. That said, we'd certainly release
on a major version bump because some of the interface (like setting
`Stripe.default_client`) changes.
* Drop support for old versions of Ruby
Drops support for Ruby 2.1 (EOL March 31, 2017) and 2.2 (EOL March 31,
2018). They're removed from `.travis.yml` and the gemspec and RuboCop
configuration have also been updated to the new lower bound.
Most of the diff here are minor updates to styling as required by
RuboCop:
* String literals are frozen by default, so the `.freeze` we had
everywhere is now considered redundant.
* We can now use Ruby 1.9 style hash syntax with string keys like `{
"foo": "bar" }`.
* Converted a few heredocs over to use squiggly (leading whitespace
removed) syntax.
As discussed in Slack, I didn't drop support for Ruby 2.3 (EOL March 31,
2019) as we still have quite a few users on it. As far as I know
dropping it doesn't get us access to any major syntax improvements or
anything, so it's probably not a big deal.
* Make `CardError`'s `code` parameter named instead of positional (#816)
Makes the `code` parameter on `CardError` named instead of positional.
This makes it more consistent with the rest of the constructor's
parameters and makes instantiating `CardError` from `StripeClient`
cleaner.
This is a minor breaking change so we're aiming to release it for the
next major version of stripe-ruby.
* Bump Rubocop to latest version (#818)
* Ruby minimum version increase followup (#819)
* Remove old deprecated methods (#820)
* Remove all alias for list methods (#823)
* Remove UsageRecord.create method (#826)
* Remove IssuerFraudRecord (#827)
* Add ErrorObject to StripeError exceptions (#811)
* Tweak retry logic to be a little more like stripe-node (#828)
Tweaks the retry logic to be a little more like stripe-node's. In
particular, we also retry under these conditions:
* If we receive a 500 on a non-`POST` request.
* If we receive a 503.
I made it slightly different from stripe-node which checks for a 500
with `>= 500`. I don't really like that -- if we want to retry specific
status codes we should be explicit about it.
We're actively re-examining ways on how to make it easier for clients to
figure out when to retry right now, but I figure V5 is a good time to
tweak this because the modifications change the method signature of
`should_retry?` slightly, and it's technically a public method.
* Fix inverted sign for 500 retries (#830)
I messed up in #828 by (1) accidentally flipping the comparison against
`:post` when checking whether to retry on 500, and (2) forgetting to
write new tests for the condition, which is how (1) got through.
This patch fixes both those problems.
* Remove a few more very old deprecated methods (#831)
I noticed that we had a couple of other deprecated methods on `Stripe`
and `StripeObject` that have been around for a long time. May as well
get rid of them too -- luckily they were using `Gem::Deprecate` so
they've been producing annoying deprecated warnings for quite a while
now.
* Remove extraneous slash at the end of the line
* Reset connections when connection-changing configuration changes (#829)
Adds a few basic features around connection and connection manager
management:
* `clear` on connection manager, which calls `finish` on each active
connection and then disposes of it.
* A centralized cross-thread tracking system for connection managers in
`StripeClient` and `clear_all_connection_managers` which clears all
known connection managers across all threads in a thread-safe way.
The addition of these allow us to modify the implementation of some of
our configuration on `Stripe` so that it can reset all currently open
connections when its value changes.
This fixes a currently problem with the library whereby certain
configuration must be set before the first request or it remains fixed
on any open connections. For example, if `Stripe.proxy` is set after a
request is made from the library, it has no effect because the proxy
must have been set when the connection was originally being initialized.
The impetus for getting this out is that I noticed that we will need
this internally in a few places when we're upgrading to stripe-ruby V5.
Those spots used to be able to hack around the unavailability of this
feature by just accessing the Faraday connection directly and resetting
state on it, but in V5 `StripeClient#conn` is gone, and that's no longer
possible.
* Minor cleanup in `StripeClient` (#832)
I ended up having to relax the maximum method line length in a few
previous PRs, so I wanted to try one more cleanup pass in
`execute_request` to see if I could get it back at all.
The answer was "not by much" (without reducing clarity), but I found a
few places that could be tweaked. Unfortunately, ~50 lines is probably
the "right" length for this method in that you _could_ extract it
further, but you'd end up passing huge amounts of state all over the
place in method parameters, and it really wouldn't look that good.
* Do better bookkeeping when tracking state in `Thread.current` (#833)
This is largely just another cleanup patch, but does a couple main
things:
* Hoists the `last_response` value into thread state. This is a very
minor nicety, but effectively makes `StripeClient` fully thread-safe,
which seems like a minor nicety. Two calls to `#request` to the same
`StripeObject` can now be executed on two different threads and their
results won't interfere with each other.
* Moves state off one-off `Thread.current` keys and into a single one
for the whole client which stores a new simple type of record called
`ThreadContext`. Again, this doesn't change much, but adds some minor
type safety and lets us document each field we expect to have in a
thread's context.
* Add Invoice.list_upcoming_line_items method (#834)
498 lines
18 KiB
Ruby
498 lines
18 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require ::File.expand_path("../test_helper", __dir__)
|
|
|
|
module Stripe
|
|
class StripeObjectTest < Test::Unit::TestCase
|
|
should "implement #==" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, foo: "bar")
|
|
obj2 = Stripe::StripeObject.construct_from(id: 1, foo: "bar")
|
|
obj3 = Stripe::StripeObject.construct_from(id: 1, foo: "rab")
|
|
|
|
assert obj1 == obj2
|
|
refute obj1 == obj3
|
|
end
|
|
|
|
should "implement #deleted?" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
refute obj.deleted?
|
|
|
|
obj = Stripe::StripeObject.construct_from(deleted: false)
|
|
refute obj.deleted?
|
|
|
|
obj = Stripe::StripeObject.construct_from(deleted: true)
|
|
assert obj.deleted?
|
|
end
|
|
|
|
should "implement #respond_to" do
|
|
obj = Stripe::StripeObject.construct_from(id: 1, foo: "bar")
|
|
assert obj.respond_to?(:id)
|
|
assert obj.respond_to?(:foo)
|
|
assert !obj.respond_to?(:baz)
|
|
end
|
|
|
|
should "marshal be insensitive to strings vs. symbols when constructin" do
|
|
obj = Stripe::StripeObject.construct_from(:id => 1, "name" => "Stripe")
|
|
assert_equal 1, obj[:id]
|
|
assert_equal "Stripe", obj[:name]
|
|
end
|
|
|
|
context "#deep_copy" do
|
|
should "produce a deep copy" do
|
|
opts = {
|
|
api_base: Stripe.api_base,
|
|
api_key: "apikey",
|
|
}
|
|
values = {
|
|
id: 1,
|
|
name: "Stripe",
|
|
arr: [
|
|
StripeObject.construct_from({ id: "index0" }, opts),
|
|
"index1",
|
|
2,
|
|
],
|
|
map: {
|
|
"0": StripeObject.construct_from({ id: "index0" }, opts),
|
|
"1": "index1",
|
|
"2": 2,
|
|
},
|
|
}
|
|
|
|
# it's not good to test methods with `#send` like this, but I've done
|
|
# it in the interest of trying to keep `.deep_copy` as internal as
|
|
# possible
|
|
copy_values = Stripe::StripeObject.send(:deep_copy, values)
|
|
|
|
# we can't compare the hashes directly because they have embedded
|
|
# objects which are different from each other
|
|
assert_equal values[:id], copy_values[:id]
|
|
assert_equal values[:name], copy_values[:name]
|
|
|
|
assert_equal values[:arr].length, copy_values[:arr].length
|
|
|
|
# internal values of the copied StripeObject should be the same
|
|
# (including opts), but the object itself should be new (hence the
|
|
# refutation of equality on #object_id)
|
|
assert_equal values[:arr][0][:id], copy_values[:arr][0][:id]
|
|
refute_equal values[:arr][0].object_id, copy_values[:arr][0].object_id
|
|
assert_equal values[:arr][0].instance_variable_get(:@opts),
|
|
copy_values[:arr][0].instance_variable_get(:@opts)
|
|
|
|
# scalars however, can be compared
|
|
assert_equal values[:arr][1], copy_values[:arr][1]
|
|
assert_equal values[:arr][2], copy_values[:arr][2]
|
|
|
|
# and a similar story with the hash
|
|
assert_equal values[:map].keys, copy_values[:map].keys
|
|
assert_equal values[:map][:"0"][:id], copy_values[:map][:"0"][:id]
|
|
refute_equal values[:map][:"0"].object_id, copy_values[:map][:"0"].object_id
|
|
assert_equal values[:map][:"0"].instance_variable_get(:@opts),
|
|
copy_values[:map][:"0"].instance_variable_get(:@opts)
|
|
assert_equal values[:map][:"1"], copy_values[:map][:"1"]
|
|
assert_equal values[:map][:"2"], copy_values[:map][:"2"]
|
|
end
|
|
|
|
should "not copy a client" do
|
|
opts = {
|
|
api_key: "apikey",
|
|
client: StripeClient.active_client,
|
|
}
|
|
values = { id: 1, name: "Stripe" }
|
|
|
|
obj = Stripe::StripeObject.construct_from(values, opts)
|
|
copy_obj = Stripe::StripeObject.send(:deep_copy, obj)
|
|
|
|
assert_equal values, copy_obj.instance_variable_get(:@values)
|
|
assert_equal opts.reject { |k, _v| k == :client },
|
|
copy_obj.instance_variable_get(:@opts)
|
|
end
|
|
|
|
should "return an instance of the same class" do
|
|
class TestObject < Stripe::StripeObject; end
|
|
|
|
obj = TestObject.construct_from(id: 1)
|
|
copy_obj = obj.class.send(:deep_copy, obj)
|
|
|
|
assert_equal obj.class, copy_obj.class
|
|
end
|
|
end
|
|
|
|
context "#eql?" do
|
|
should "produce true for two equivalent Stripe objects" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
assert obj1.eql?(obj2)
|
|
end
|
|
|
|
should "produce false for non-equivalent Stripe objects" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = Stripe::StripeObject.construct_from(id: 2, name: "Stripe")
|
|
refute obj1.eql?(obj2)
|
|
end
|
|
|
|
should "produce false for different types" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = 7
|
|
refute obj1.eql?(obj2)
|
|
end
|
|
end
|
|
|
|
context "#hash" do
|
|
should "produce the same hash for two equivalent Stripe objects" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
assert_equal obj1.hash, obj2.hash
|
|
end
|
|
|
|
should "produce different hashes for non-equivalent Stripe objects" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = Stripe::StripeObject.construct_from(id: 2, name: "Stripe")
|
|
refute_equal obj1.hash, obj2.hash
|
|
end
|
|
|
|
should "produce different hashes for different types" do
|
|
obj1 = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj2 = 7
|
|
refute_equal obj1.hash, obj2.hash
|
|
end
|
|
end
|
|
|
|
context "#to_hash" do
|
|
should "skip calling to_hash on nil" do
|
|
begin
|
|
module NilWithToHash
|
|
def to_hash
|
|
raise "Can't call to_hash on nil"
|
|
end
|
|
end
|
|
::NilClass.include NilWithToHash
|
|
|
|
hash_with_nil = { id: 3, foo: nil }
|
|
obj = StripeObject.construct_from(hash_with_nil)
|
|
expected_hash = { id: 3, foo: nil }
|
|
assert_equal expected_hash, obj.to_hash
|
|
ensure
|
|
::NilClass.send(:undef_method, :to_hash)
|
|
end
|
|
end
|
|
|
|
should "recursively call to_hash on its values" do
|
|
# deep nested hash (when contained in an array) or StripeObject
|
|
nested_hash = { id: 7, foo: "bar" }
|
|
nested = Stripe::StripeObject.construct_from(nested_hash)
|
|
|
|
obj = Stripe::StripeObject.construct_from(id: 1,
|
|
# simple hash that contains a StripeObject to help us test deep
|
|
# recursion
|
|
nested: { object: "list", data: [nested] },
|
|
list: [nested])
|
|
|
|
expected_hash = {
|
|
id: 1,
|
|
nested: { object: "list", data: [nested_hash] },
|
|
list: [nested_hash],
|
|
}
|
|
assert_equal expected_hash, obj.to_hash
|
|
end
|
|
end
|
|
|
|
should "assign question mark accessors for booleans" do
|
|
obj = Stripe::StripeObject.construct_from(id: 1, bool: true, not_bool: "bar")
|
|
assert obj.respond_to?(:bool?)
|
|
assert obj.bool?
|
|
refute obj.respond_to?(:not_bool?)
|
|
end
|
|
|
|
should "assign question mark accessors for booleans added after initialization" do
|
|
obj = Stripe::StripeObject.new
|
|
obj.bool = true
|
|
assert obj.respond_to?(:bool?)
|
|
assert obj.bool?
|
|
end
|
|
|
|
should "mass assign values with #update_attributes" do
|
|
obj = Stripe::StripeObject.construct_from(id: 1, name: "Stripe")
|
|
obj.update_attributes(name: "STRIPE")
|
|
assert_equal "STRIPE", obj.name
|
|
|
|
# unfortunately, we even assign unknown properties to duplicate the
|
|
# behavior that we currently have via magic accessors with
|
|
# method_missing
|
|
obj.update_attributes(unknown: "foo")
|
|
assert_equal "foo", obj.unknown
|
|
end
|
|
|
|
should "#update_attributes with a hash" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
obj.update_attributes(metadata: { foo: "bar" })
|
|
assert_equal Stripe::StripeObject, obj.metadata.class
|
|
end
|
|
|
|
should "create accessors when #update_attributes is called" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
assert_equal false, obj.send(:metaclass).method_defined?(:foo)
|
|
obj.update_attributes(foo: "bar")
|
|
assert_equal true, obj.send(:metaclass).method_defined?(:foo)
|
|
end
|
|
|
|
should "pass opts down to children when initializing" do
|
|
opts = { custom: "opts" }
|
|
|
|
# customer comes with a `sources` list that makes a convenient object to
|
|
# perform tests on
|
|
obj = Stripe::StripeObject.construct_from({
|
|
sources: [
|
|
{},
|
|
],
|
|
}, opts)
|
|
|
|
source = obj.sources.first
|
|
# Pulling `@opts` as an instance variable here is not ideal, but it's
|
|
# important enough argument that the test here is worth it. we should
|
|
# consider exposing it publicly on a future pull (and possibly renaming
|
|
# it to something more useful).
|
|
assert_equal opts, source.instance_variable_get(:@opts)
|
|
end
|
|
|
|
should "#serialize_params on an empty object" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
assert_equal({}, obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on a new object with a subobject" do
|
|
obj = Stripe::StripeObject.new
|
|
obj.metadata = { foo: "bar" }
|
|
assert_equal({ metadata: { foo: "bar" } },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on a basic object" do
|
|
obj = Stripe::StripeObject.construct_from(foo: nil)
|
|
obj.update_attributes(foo: "bar")
|
|
assert_equal({ foo: "bar" }, obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on a more complex object" do
|
|
obj = Stripe::StripeObject.construct_from(foo: Stripe::StripeObject.construct_from(bar: nil,
|
|
baz: nil))
|
|
obj.foo.bar = "newbar"
|
|
assert_equal({ foo: { bar: "newbar" } },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on an array" do
|
|
obj = Stripe::StripeObject.construct_from(foo: nil)
|
|
obj.foo = ["new-value"]
|
|
assert_equal({ foo: ["new-value"] },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on an array that shortens" do
|
|
obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
|
|
obj.foo = ["new-value"]
|
|
assert_equal({ foo: ["new-value"] },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on an array that lengthens" do
|
|
obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
|
|
obj.foo = ["new-value"] * 4
|
|
assert_equal({ foo: ["new-value"] * 4 },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on an array of hashes" do
|
|
obj = Stripe::StripeObject.construct_from(foo: nil)
|
|
obj.foo = [
|
|
Stripe::StripeObject.construct_from(bar: nil),
|
|
]
|
|
obj.foo[0].bar = "baz"
|
|
assert_equal({ foo: [{ bar: "baz" }] },
|
|
obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params doesn't include unchanged values" do
|
|
obj = Stripe::StripeObject.construct_from(foo: nil)
|
|
assert_equal({}, obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params on an array that is unchanged" do
|
|
obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
|
|
obj.foo = %w[0-index 1-index 2-index]
|
|
assert_equal({}, obj.serialize_params)
|
|
end
|
|
|
|
should "#serialize_params with a StripeObject" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
|
|
# using an #update_attributes will end up converting a Hash into a
|
|
# StripeObject
|
|
obj.metadata =
|
|
Stripe::StripeObject.construct_from(foo: "bar")
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ foo: "bar" }, serialized[:metadata])
|
|
end
|
|
|
|
should "#serialize_params with StripeObject that's been replaced" do
|
|
obj = Stripe::StripeObject.construct_from(source: Stripe::StripeObject.construct_from(bar: "foo"))
|
|
|
|
# Here we replace the object wholesale.
|
|
obj.source =
|
|
Stripe::StripeObject.construct_from(baz: "foo")
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ baz: "foo" }, serialized[:source])
|
|
end
|
|
|
|
should "#serialize_params with StripeObject that's been replaced which is `metadata`" do
|
|
class WithAdditiveObjectParam < Stripe::StripeObject
|
|
additive_object_param :metadata
|
|
end
|
|
|
|
obj = WithAdditiveObjectParam.construct_from(metadata: Stripe::StripeObject.construct_from(bar: "foo"))
|
|
|
|
# Here we replace the object wholesale. Because it's `metadata`, the
|
|
# client must be able to blank out the values that were in the old
|
|
# object, but which are no longer present in the new one.
|
|
obj.metadata =
|
|
Stripe::StripeObject.construct_from(baz: "foo")
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ bar: "", baz: "foo" }, serialized[:metadata])
|
|
end
|
|
|
|
should "#serialize_params with an array of StripeObjects" do
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
obj.metadata = [
|
|
Stripe::StripeObject.construct_from(foo: "bar"),
|
|
]
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal([{ foo: "bar" }], serialized[:metadata])
|
|
end
|
|
|
|
should "#serialize_params and embed an API resource that's been set and has an ID" do
|
|
customer = Customer.construct_from(id: "cus_123")
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
|
|
# the key here is that the property is set explicitly (and therefore
|
|
# marked as unsaved), which is why it gets included below
|
|
obj.customer = customer
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ customer: customer }, serialized)
|
|
end
|
|
|
|
should "#serialize_params and not include API resources that have not been set" do
|
|
customer = Customer.construct_from(id: "cus_123")
|
|
obj = Stripe::StripeObject.construct_from(customer: customer)
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({}, serialized)
|
|
end
|
|
|
|
should "#serialize_params serializes API resources flagged with save_with_parent" do
|
|
c = Customer.construct_from({})
|
|
c.save_with_parent = true
|
|
|
|
obj = Stripe::StripeObject.construct_from(customer: c)
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ customer: {} }, serialized)
|
|
end
|
|
|
|
should "#serialize_params should raise an error on other embedded API resources" do
|
|
# This customer doesn't have an ID and therefore the library doesn't know
|
|
# what to do with it and throws an ArgumentError because it's probably
|
|
# not what the user expected to happen.
|
|
customer = Customer.construct_from({})
|
|
|
|
obj = Stripe::StripeObject.construct_from({})
|
|
obj.customer = customer
|
|
|
|
e = assert_raises(ArgumentError) do
|
|
obj.serialize_params
|
|
end
|
|
assert_equal "Cannot save property `customer` containing " \
|
|
"an API resource. It doesn't appear to be persisted and is " \
|
|
"not marked as `save_with_parent`.", e.message
|
|
end
|
|
|
|
should "#serialize_params takes a force option" do
|
|
obj = Stripe::StripeObject.construct_from(id: "id",
|
|
metadata: Stripe::StripeObject.construct_from(foo: "bar"))
|
|
|
|
serialized = obj.serialize_params(force: true)
|
|
assert_equal({ id: "id", metadata: { foo: "bar" } }, serialized)
|
|
end
|
|
|
|
should "#dirty! forces an object and its subobjects to be saved" do
|
|
obj = Stripe::StripeObject.construct_from(id: "id",
|
|
metadata: Stripe::StripeObject.construct_from(foo: "bar"))
|
|
|
|
# note that `force` and `dirty!` are for different things, but are
|
|
# functionally equivalent
|
|
obj.dirty!
|
|
|
|
serialized = obj.serialize_params
|
|
assert_equal({ id: "id", metadata: { foo: "bar" } }, serialized)
|
|
end
|
|
|
|
should "#to_s will call to_s for all embedded stripe objects" do
|
|
obj = Stripe::StripeObject.construct_from(id: "id",
|
|
# embedded list object
|
|
refunds: Stripe::ListObject.construct_from(data: [
|
|
# embedded object in list
|
|
Stripe::StripeObject.construct_from(id: "id",
|
|
# embedded object in an object in a list object
|
|
metadata: Stripe::StripeObject.construct_from(foo: "bar")),
|
|
]),
|
|
# embedded stripe object
|
|
metadata: Stripe::StripeObject.construct_from(foo: "bar"))
|
|
expected = JSON.pretty_generate(id: "id",
|
|
refunds: {
|
|
data: [
|
|
{ id: "id", metadata: { foo: "bar" } },
|
|
],
|
|
},
|
|
metadata: { foo: "bar" })
|
|
|
|
assert_equal(expected, obj.to_s)
|
|
end
|
|
|
|
should "error on setting a property to an empty string" do
|
|
obj = Stripe::StripeObject.construct_from(foo: "bar")
|
|
e = assert_raises ArgumentError do
|
|
obj.foo = ""
|
|
end
|
|
assert_match(/\(object\).foo = nil/, e.message)
|
|
end
|
|
|
|
should "marshal and unmarshal using custom encoder and decoder" do
|
|
obj = Stripe::StripeObject.construct_from(
|
|
{ id: 1, name: "Stripe" },
|
|
api_key: "apikey",
|
|
client: StripeClient.active_client
|
|
)
|
|
m = Marshal.load(Marshal.dump(obj))
|
|
assert_equal 1, m.id
|
|
assert_equal "Stripe", m.name
|
|
expected_hash = { api_key: "apikey" }
|
|
assert_equal expected_hash, m.instance_variable_get("@opts")
|
|
end
|
|
|
|
context "#method" do
|
|
should "act as a getter if no arguments are provided" do
|
|
obj = Stripe::StripeObject.construct_from(id: 1, method: "foo")
|
|
assert_equal "foo", obj.method
|
|
end
|
|
|
|
should "call Object#method if an argument is provided" do
|
|
obj = Stripe::StripeObject.construct_from(id: 1, method: "foo")
|
|
assert obj.method(:id).is_a?(Method)
|
|
end
|
|
end
|
|
end
|
|
end
|