sharpetronics/stripe-ruby
1
0
Fork 0
mirror of https://github.com/stripe/stripe-ruby.git synced 2025-06-02 00:00:35 -04:00
Code Issues Projects Releases Wiki Activity

Merge pull request #496 from stripe/brandur-webmock

Browse Source 
Use Webmock instead of Mocha for HTTP stubbing
This commit is contained in:
Brandur 2017-02-14 12:16:32 -08:00 committed by GitHub
commit 15f77a6e47
39 changed files with 765 additions and 1233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
test/stripe/account_test.rb
View File

@ -8,10 +8,8 @@ module Stripe
:details_submitted => false,
:email => "test+bindings@stripe.com",
})
@mock.expects(:get).
once.
with('https://api.stripe.com/v1/account', nil, nil).
returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/account").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve
assert_equal "test+bindings@stripe.com", a.email
assert !a.charges_enabled
@ -24,10 +22,8 @@ module Stripe
:details_submitted => false,
:email => "test+bindings@stripe.com",
})
@mock.expects(:get).
once.
with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/accounts/acct_foo").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve('acct_foo')
assert_equal "test+bindings@stripe.com", a.email
assert !a.charges_enabled
@ -54,15 +50,11 @@ module Stripe
should "be rejectable" do
account_data = {:id => 'acct_foo'}
@mock.expects(:get).
once.
with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
returns(make_response(account_data))
stub_request(:get, "#{Stripe.api_base}/v1/accounts/acct_foo").
to_return(body: JSON.generate(account_data))
@mock.expects(:post).
once.
with("https://api.stripe.com/v1/accounts/acct_foo/reject", nil, 'reason=fraud').
returns(make_response(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')
@ -77,15 +69,11 @@ module Stripe
}
}
}
@mock.expects(:get).
once.
with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/accounts/acct_foo").
to_return(body: JSON.generate(resp))
@mock.expects(:post).
once.
with('https://api.stripe.com/v1/accounts/acct_foo', nil, 'legal_entity[address][line1]=2+Three+Four&legal_entity[first_name]=Bob').
returns(make_response(resp))
stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_foo").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve('acct_foo')
a.legal_entity.first_name = 'Bob'
@ -98,10 +86,8 @@ module Stripe
:id => 'acct_foo',
:business_name => 'ACME Corp',
}
@mock.expects(:post).
once.
with('https://api.stripe.com/v1/accounts/acct_foo', nil, 'business_name=ACME+Corp').
returns(make_response(resp))
stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_foo").
to_return(body: JSON.generate(resp))
a = Stripe::Account.update('acct_foo', :business_name => "ACME Corp")
assert_equal('ACME Corp', a.business_name)
@ -127,13 +113,13 @@ module Stripe
should "be able to deauthorize an account" do
resp = {:id => 'acct_1234', :email => "test+bindings@stripe.com", :charge_enabled => false, :details_submitted => false}
@mock.expects(:get).once.returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/account").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.connect_base}/oauth/deauthorize" && api_key.nil? && CGI.parse(params) == { 'client_id' => [ 'ca_1234' ], 'stripe_user_id' => [ a.id ]}
end.returns(make_response({ 'stripe_user_id' => a.id }))
stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize").
with(body: { 'client_id' => 'ca_1234', 'stripe_user_id' => a.id}).
to_return(body: JSON.generate({ 'stripe_user_id' => a.id }))
a.deauthorize('ca_1234', 'sk_test_1234')
end
@ -155,13 +141,13 @@ module Stripe
:data => [],
}
}
@mock.expects(:get).once.returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/account").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve
@mock.expects(:post).
once.
with('https://api.stripe.com/v1/accounts/acct_1234/external_accounts', nil, 'external_account=btok_1234').
returns(make_response(resp))
stub_request(:post, "#{Stripe.api_base}/v1/accounts/acct_1234/external_accounts").
with(body: { :external_account => 'btok_1234' }).
to_return(body: JSON.generate(resp))
a.external_accounts.create({:external_account => 'btok_1234'})
end
@ -177,7 +163,8 @@ module Stripe
}],
}
}
@mock.expects(:get).once.returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/account").
to_return(body: JSON.generate(resp))
a = Stripe::Account.retrieve
assert_equal(BankAccount, a.external_accounts.data[0].class)
end

6
test/stripe/api_operations_test.rb
View File

@ -13,9 +13,9 @@ module Stripe
context ".update" do
should "post the correct parameters to the resource URL" do
@mock.expects(:post).once.
with("#{Stripe.api_base}/v1/updateableresources/id", nil, 'foo=bar').
returns(make_response({foo: 'bar'}))
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

393
test/stripe/api_resource_test.rb
View File

@ -24,30 +24,30 @@ module Stripe
end
should "creating a new APIResource should not fetch over the network" do
@mock.expects(:get).never
Stripe::Customer.new("someid")
assert_not_requested :get, %r{#{Stripe.api_base}/.*}
end
should "creating a new APIResource from a hash should not fetch over the network" do
@mock.expects(:get).never
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
@mock.expects(:get).never
@mock.expects(:post).never
c = Stripe::Customer.new("test_customer");
c.card = {:id => "somecard", :object => "card"}
assert_not_requested :get, %r{#{Stripe.api_base}/.*}
assert_not_requested :post, %r{#{Stripe.api_base}/.*}
end
should "accessing id should not issue a fetch" do
@mock.expects(:get).never
c = Stripe::Customer.new("test_customer")
c.id
assert_not_requested :get, %r{#{Stripe.api_base}/.*}
end
should "not specifying api credentials should raise an exception" do
@ -75,18 +75,18 @@ module Stripe
should "specifying invalid api credentials should raise an exception" do
Stripe.api_key = "invalid"
response = make_response(make_invalid_api_key_error, 401)
assert_raises Stripe::AuthenticationError do
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
stub_request(:get, "#{Stripe.api_base}/v1/customers/failing_customer").
to_return(body: JSON.generate(make_invalid_api_key_error), status: 401)
Stripe::Customer.retrieve("failing_customer")
end
end
should "AuthenticationErrors should have an http status, http body, and JSON body" do
Stripe.api_key = "invalid"
response = make_response(make_invalid_api_key_error, 401)
begin
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
stub_request(:get, "#{Stripe.api_base}/v1/customers/failing_customer").
to_return(body: JSON.generate(make_invalid_api_key_error), status: 401)
Stripe::Customer.retrieve("failing_customer")
rescue Stripe::AuthenticationError => e
assert_equal(401, e.http_status)
@ -97,30 +97,29 @@ module Stripe
end
should "send expand on fetch properly" do
@mock.expects(:get).once.
with("#{Stripe.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
returns(make_response(make_charge))
stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
with(query: { "expand" => ["customer"] }).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => [:customer]})
end
should "preserve expand across refreshes" do
@mock.expects(:get).twice.
with("#{Stripe.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
returns(make_response(make_charge))
stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
with(query: { "expand" => ["customer"] }).
to_return(body: JSON.generate(make_charge))
ch = Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => [:customer]})
ch.refresh
end
should "send expand when fetching through ListObject" do
@mock.expects(:get).once.
with("#{Stripe.api_base}/v1/customers/c_test_customer", nil, nil).
returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
to_return(body: JSON.generate(make_customer))
@mock.expects(:get).once.
with("#{Stripe.api_base}/v1/customers/c_test_customer/sources/cc_test_card?expand[]=customer", nil, nil).
returns(make_response(make_card))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer/sources/cc_test_card").
with(query: { "expand" => ["customer"] }).
to_return(body: JSON.generate(make_customer))
customer = Stripe::Customer.retrieve('c_test_customer')
customer.sources.retrieve({:id => 'cc_test_card', :expand => [:customer]})
@ -128,26 +127,27 @@ module Stripe
should "send stripe account as header when set" do
stripe_account = "acct_0000"
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:stripe_account] == stripe_account
end.returns(make_response(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Stripe-Account" => stripe_account}).
to_return(body: JSON.generate(make_customer))
Stripe::Charge.create({:card => {:number => '4242424242424242'}},
{:stripe_account => stripe_account, :api_key => 'sk_test_local'})
end
should "not send stripe account as header when not set" do
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:stripe_account].nil?
end.returns(make_response(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with { |req|
req.headers["Stripe-Account"].nil?
}.to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({:card => {:number => '4242424242424242'}},
'sk_test_local')
end
should "handle error response with empty body" do
response = make_response('', 500)
@mock.expects(:post).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: '', status: 500)
e = assert_raises Stripe::APIError do
Stripe::Charge.create
@ -157,14 +157,14 @@ module Stripe
end
should "handle error response with non-object error value" do
response = make_response('{"error": "foo"}', 500)
@mock.expects(:post).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate({ error: "foo" }), status: 500)
e = assert_raises Stripe::APIError do
Stripe::Charge.create
end
assert_equal 'Invalid response object from API: "{\"error\": \"foo\"}" (HTTP response code was 500)', e.message
assert_equal 'Invalid response object from API: "{\"error\":\"foo\"}" (HTTP response code was 500)', e.message
end
should "have default open and read timeouts" do
@ -172,30 +172,12 @@ module Stripe
assert_equal Stripe.read_timeout, 80
end
should "allow configurable open and read timeouts" do
original_timeouts = Stripe.open_timeout, Stripe.read_timeout
begin
Stripe.open_timeout = 999
Stripe.read_timeout = 998
Stripe.expects(:execute_request).with do |opts|
opts[:open_timeout] == 999 && opts[:timeout] == 998
end.returns(make_response(make_charge))
Stripe::Charge.create({:card => {:number => '4242424242424242'}},
'sk_test_local')
ensure
Stripe.open_timeout, Stripe.read_timeout = original_timeouts
end
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
Stripe.expects(:execute_request).with do |opts|
opts[:headers]['Authorization'] == 'Bearer sk_test_local'
end.returns(make_response(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Authorization" => "Bearer sk_test_local"}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({:card => {:number => '4242424242424242'}},
'sk_test_local')
@ -212,23 +194,21 @@ module Stripe
end
should "use the per-object credential when creating" do
Stripe.expects(:execute_request).with do |opts|
opts[:headers]['Authorization'] == 'Bearer local'
end.returns(make_response(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Authorization" => "Bearer local"}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({:card => {:number => '4242424242424242'}},
'local')
end
should "use the per-object credential when retrieving and making other calls" do
Stripe.expects(:execute_request).with do |opts|
opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge" &&
opts[:headers]['Authorization'] == 'Bearer local'
end.returns(make_response(make_charge))
Stripe.expects(:execute_request).with do |opts|
opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge/refunds" &&
opts[:headers]['Authorization'] == 'Bearer local'
end.returns(make_response(make_refund))
stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_test_charge").
with(headers: {"Authorization" => "Bearer local"}).
to_return(body: JSON.generate(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges/ch_test_charge/refunds").
with(headers: {"Authorization" => "Bearer local"}).
to_return(body: JSON.generate(make_refund))
ch = Stripe::Charge.retrieve('ch_test_charge', 'local')
ch.refunds.create
@ -238,9 +218,9 @@ module Stripe
context "with valid credentials" do
should "send along the idempotency-key header" do
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:idempotency_key] == 'bar'
end.returns(make_response(make_charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Idempotency-Key" => "bar"}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({:card => {:number => '4242424242424242'}}, {
:idempotency_key => 'bar',
@ -249,26 +229,31 @@ module Stripe
end
should "urlencode values in GET params" do
response = make_response(make_charge_array)
@mock.expects(:get).with("#{Stripe.api_base}/v1/charges?customer=test+customer", nil, nil).returns(response)
stub_request(:get, "#{Stripe.api_base}/v1/charges").
with(query: { customer: "test customer" }).
to_return(body: JSON.generate(make_charge_array))
charges = Stripe::Charge.list(:customer => 'test customer').data
assert charges.kind_of? Array
end
should "construct URL properly with base query parameters" do
response = make_response(make_invoice_customer_array)
@mock.expects(:get).with("#{Stripe.api_base}/v1/invoices?customer=test_customer", nil, nil).returns(response)
response = JSON.generate(make_invoice_customer_array)
stub_request(:get, "#{Stripe.api_base}/v1/invoices").
with(query: { customer: "test_customer" }).
to_return(body: response)
invoices = Stripe::Invoice.list(:customer => 'test_customer')
@mock.expects(:get).with("#{Stripe.api_base}/v1/invoices?customer=test_customer&paid=true", nil, nil).returns(response)
stub_request(:get, "#{Stripe.api_base}/v1/invoices").
with(query: { customer: "test_customer", paid: "true" }).
to_return(body: response)
invoices.list(:paid => true)
end
should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
response = make_response(make_missing_id_error, 400)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 400)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::InvalidRequestError => e
assert_equal(400, e.http_status)
assert_equal(true, !!e.http_body)
@ -277,10 +262,10 @@ module Stripe
end
should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
response = make_response(make_missing_id_error, 401)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 401)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::AuthenticationError => e
assert_equal(401, e.http_status)
assert_equal(true, !!e.http_body)
@ -289,10 +274,10 @@ module Stripe
end
should "a 402 should give a CardError with http status, body, and JSON body" do
response = make_response(make_missing_id_error, 402)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 402)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::CardError => e
assert_equal(402, e.http_status)
assert_equal(true, !!e.http_body)
@ -301,10 +286,10 @@ module Stripe
end
should "a 403 should give a PermissionError with http status, body, and JSON body" do
response = make_response(make_missing_id_error, 403)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 403))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 403)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::PermissionError => e
assert_equal(403, e.http_status)
assert_equal(true, !!e.http_body)
@ -313,10 +298,10 @@ module Stripe
end
should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
response = make_response(make_missing_id_error, 404)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 404)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::InvalidRequestError => e
assert_equal(404, e.http_status)
assert_equal(true, !!e.http_body)
@ -325,10 +310,10 @@ module Stripe
end
should "a 429 should give a RateLimitError with http status, body, and JSON body" do
response = make_response(make_rate_limit_error, 429)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 429))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_missing_id_error), status: 429)
begin
Stripe::Customer.retrieve("foo")
Stripe::Charge.create
rescue Stripe::RateLimitError => e
assert_equal(429, e.http_status)
assert_equal(true, !!e.http_body)
@ -337,25 +322,20 @@ module Stripe
end
should "setting a nil value for a param should exclude that param from the request" do
@mock.expects(:get).with do |url, api_key, params|
uri = URI(url)
query = CGI.parse(uri.query)
(url =~ %r{^#{Stripe.api_base}/v1/charges?} &&
query.keys.sort == ['offset', 'sad'])
end.returns(make_response({ :count => 1, :data => [make_charge] }))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
with(query: { offset: 5, sad: false }).
to_return(body: JSON.generate({ :count => 1, :data => [make_charge] }))
Stripe::Charge.list(:count => nil, :offset => 5, :sad => false)
@mock.expects(:post).with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/charges" &&
api_key.nil? &&
CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['usd'] }
end.returns(make_response({ :count => 1, :data => [make_charge] }))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(body: { 'amount' => '50', 'currency' => 'usd' }).
to_return(body: JSON.generate({ :count => 1, :data => [make_charge] }))
Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
end
should "requesting with a unicode ID should result in a request" do
response = make_response(make_missing_id_error, 404)
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 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
@ -366,28 +346,29 @@ module Stripe
end
should "making a GET request with parameters should have a query string and no body" do
params = { :limit => 1 }
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/charges?limit=1", nil, nil).
returns(make_response({ :data => [make_charge] }))
Stripe::Charge.list(params)
stub_request(:get, "#{Stripe.api_base}/v1/charges").
with(query: { limit: 1 }).
to_return(body: JSON.generate({ :data => [make_charge] }))
Stripe::Charge.list({ :limit => 1 })
end
should "making a POST request with parameters should have a body and no query string" do
params = { :amount => 100, :currency => 'usd', :card => 'sc_token' }
@mock.expects(:post).once.with do |url, get, post|
get.nil? && CGI.parse(post) == {'amount' => ['100'], 'currency' => ['usd'], 'card' => ['sc_token']}
end.returns(make_response(make_charge))
Stripe::Charge.create(params)
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(body: {'amount' => '100', 'currency' => 'usd', 'card' => 'sc_token'}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({ :amount => 100, :currency => 'usd', :card => 'sc_token' })
end
should "loading an object should issue a GET request" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new("test_customer")
c.refresh
end
should "using array accessors should be the same as the method interface" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new("test_customer")
c.refresh
assert_equal c.created, c[:created]
@ -397,22 +378,26 @@ module Stripe
end
should "accessing a property other than id or parent on an unfetched object should fetch it" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
with(query: { customer: "test_customer" }).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new("test_customer")
c.charges
end
should "updating an object should issue a POST request with only the changed properties" do
@mock.expects(:post).with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
end.once.returns(make_response(make_customer))
stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
with(body: { 'description' => 'another_mn' }).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.construct_from(make_customer)
c.description = "another_mn"
c.save
end
should "updating should merge in returned properties" do
@mock.expects(:post).once.returns(make_response(make_customer))
stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
with(body: { 'description' => 'another_mn' }).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new("c_test_customer")
c.description = "another_mn"
c.save
@ -420,9 +405,9 @@ module Stripe
end
should "updating should send along the idempotency-key header" do
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:idempotency_key] == 'bar'
end.returns(make_response(make_customer))
stub_request(:post, "#{Stripe.api_base}/v1/customers").
with(headers: {"Idempotency-Key" => "bar"}).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new
c.save({}, { :idempotency_key => 'bar' })
assert_equal false, c.livemode
@ -436,18 +421,17 @@ module Stripe
end
should "updating should use the supplied api_key" do
Stripe.expects(:execute_request).with do |opts|
opts[:headers]['Authorization'] == 'Bearer sk_test_local'
end.returns(make_response(make_customer))
stub_request(:post, "#{Stripe.api_base}/v1/customers").
with(headers: {"Authorization" => "Bearer sk_test_local"}).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new
c.save({}, { :api_key => 'sk_test_local' })
assert_equal false, c.livemode
end
should "deleting should send no props and result in an object that has no props other deleted" do
@mock.expects(:get).never
@mock.expects(:post).never
@mock.expects(:delete).with("#{Stripe.api_base}/v1/customers/c_test_customer", nil, nil).once.returns(make_response({ "id" => "test_customer", "deleted" => true }))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/c_test_customer").
to_return(body: JSON.generate({ "id" => "test_customer", "deleted" => true }))
c = Stripe::Customer.construct_from(make_customer)
c.delete
assert_equal true, c.deleted
@ -458,13 +442,15 @@ module Stripe
end
should "loading an object with properties that have specific types should instantiate those classes" do
@mock.expects(:get).once.returns(make_response(make_charge))
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
c = Stripe::Charge.retrieve("test_charge")
assert c.card.kind_of?(Stripe::StripeObject) && c.card.object == 'card'
end
should "loading all of an APIResource should return an array of recursively instantiated objects" do
@mock.expects(:get).once.returns(make_response(make_charge_array))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_charge_array))
c = Stripe::Charge.list.data
assert c.kind_of? Array
assert c[0].kind_of? Stripe::Charge
@ -472,28 +458,21 @@ module Stripe
end
should "passing in a stripe_account header should pass it through on call" do
Stripe.expects(:execute_request).with do |opts|
opts[:method] == :get &&
opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
opts[:headers][:stripe_account] == 'acct_abc'
end.once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
with(headers: {"Stripe-Account" => "acct_abc"}).
to_return(body: JSON.generate(make_customer))
Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
end
should "passing in a stripe_account header should pass it through on save" do
Stripe.expects(:execute_request).with do |opts|
opts[:method] == :get &&
opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
opts[:headers][:stripe_account] == 'acct_abc'
end.once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
with(headers: {"Stripe-Account" => "acct_abc"}).
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
Stripe.expects(:execute_request).with do |opts|
opts[:method] == :post &&
opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
opts[:headers][:stripe_account] == 'acct_abc' &&
opts[:payload] == 'description=FOO'
end.once.returns(make_response(make_customer))
stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer").
with(headers: {"Stripe-Account" => "acct_abc"}).
to_return(body: JSON.generate(make_customer))
c.description = 'FOO'
c.save
end
@ -501,8 +480,8 @@ module Stripe
context "error checking" do
should "404s should raise an InvalidRequestError" do
response = make_response(make_missing_id_error, 404)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_missing_id_error), status: 404)
rescued = false
begin
@ -519,8 +498,8 @@ module Stripe
end
should "5XXs should raise an APIError" do
response = make_response(make_api_error, 500)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_api_error), status: 500)
rescued = false
begin
@ -535,8 +514,8 @@ module Stripe
end
should "402s should raise a CardError" do
response = make_response(make_invalid_exp_year_error, 402)
@mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 402))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_invalid_exp_year_error), status: 402)
rescued = false
begin
@ -564,7 +543,9 @@ module Stripe
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[first_name]=Bob').returns(make_response({"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.save
@ -572,27 +553,31 @@ module Stripe
should 'save nothing if nothing changes' do
acct = Stripe::Account.construct_from({
:id => 'myid',
:id => 'acct_id',
:metadata => {
:key => 'value'
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
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 => 'charge_id',
:id => 'ch_id',
:customer => {
:object => 'customer',
:id => 'customer_id'
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/charges/charge_id", nil, '').returns(make_response({"id" => "charge_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.save
@ -610,14 +595,9 @@ module Stripe
}
})
@mock.expects(:post).once.with(
"#{Stripe.api_base}/v1/accounts/myid",
nil,
any_of(
'legal_entity[address][line1]=Test2&legal_entity[address][city]=',
'legal_entity[address][city]=&legal_entity[address][line1]=Test2'
)
).returns(make_response({"id" => "myid"}))
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.save
@ -629,7 +609,9 @@ module Stripe
:legal_entity => {}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][0][first_name]=Bob').returns(make_response({"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.save
@ -643,7 +625,12 @@ module Stripe
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][0][first_name]=Bob').returns(make_response({"id" => "myid"}))
# 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" }))
acct.legal_entity.additional_owners << {:first_name => 'Bob'}
acct.save
@ -657,7 +644,12 @@ module Stripe
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][1][first_name]=Janet').returns(make_response({"id" => "myid"}))
# 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" }))
acct.legal_entity.additional_owners[1].first_name = 'Janet'
acct.save
@ -672,7 +664,9 @@ module Stripe
:currencies_supported => ['usd', 'cad']
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
with(body: {}).
to_return(body: JSON.generate({ "id" => "myid" }))
acct.save
end
@ -685,7 +679,9 @@ module Stripe
}
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
stub_request(:post, "#{Stripe.api_base}/v1/accounts/myid").
with(body: {}).
to_return(body: JSON.generate({ "id" => "myid" }))
acct.save
end
@ -696,8 +692,9 @@ module Stripe
:display_name => nil,
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe').
returns(make_response({"id" => "charge_id"}))
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.save
@ -709,8 +706,9 @@ module Stripe
:display_name => nil,
})
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe&metadata[key]=value').
returns(make_response({"id" => "charge_id"}))
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' })
end
@ -723,8 +721,8 @@ module Stripe
should 'retry failed network requests if specified and raise if error persists' do
Stripe.expects(:sleep_time).at_least_once.returns(0)
@mock.expects(:post).times(3).with('https://api.stripe.com/v1/charges', nil, 'amount=50&currency=usd').
raises(Errno::ECONNREFUSED.new)
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_raise(Errno::ECONNREFUSED.new)
err = assert_raises Stripe::APIConnectionError do
Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
@ -734,11 +732,17 @@ module Stripe
should 'retry failed network requests if specified and return successful response' do
Stripe.expects(:sleep_time).at_least_once.returns(0)
response = make_response({"id" => "myid"})
@mock.expects(:post).times(2).with('https://api.stripe.com/v1/charges', nil, 'amount=50&currency=usd').
raises(Errno::ECONNREFUSED.new).
then.
returns(response)
i = 0
stub_request(:post, "#{Stripe.api_base}/v1/charges").
to_return { |_|
if i < 2
i += 1
raise Errno::ECONNREFUSED.new
else
{ body: JSON.generate({"id" => "myid"}) }
end
}
result = Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
assert_equal "myid", result.id
@ -746,29 +750,30 @@ module Stripe
should 'not add an idempotency key to GET requests' do
SecureRandom.expects(:uuid).times(0)
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:idempotency_key].nil?
end.returns(make_response({"id" => "myid"}))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
with { |req|
req.headers['Idempotency-Key'].nil?
}.to_return(body: JSON.generate(make_charge_array))
Stripe::Charge.list
end
should 'ensure there is always an idempotency_key on POST requests' do
SecureRandom.expects(:uuid).at_least_once.returns("random_key")
Stripe.expects(:execute_request).with do |opts|
opts[:headers]['Idempotency-Key'] == "random_key"
end.returns(make_response({"id" => "myid"}))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Idempotency-Key" => "random_key"}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
end
should 'ensure there is always an idempotency_key on DELETE requests' do
SecureRandom.expects(:uuid).at_least_once.returns("random_key")
Stripe.expects(:execute_request).with do |opts|
opts[:headers]['Idempotency-Key'] == "random_key"
end.returns(make_response({"id" => "myid"}))
c = Stripe::Customer.construct_from(make_customer)
stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{c.id}").
with(headers: {"Idempotency-Key" => "random_key"}).
to_return(body: JSON.generate(make_charge))
c.delete
end
@ -779,9 +784,9 @@ module Stripe
# (`Idempotency-Key`), but rest-client does allow this symbol
# formatting and will properly override the system generated one as
# expected.
Stripe.expects(:execute_request).with do |opts|
opts[:headers][:idempotency_key] == "provided_key"
end.returns(make_response({"id" => "myid"}))
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(headers: {"Idempotency-Key" => "provided_key"}).
to_return(body: JSON.generate(make_charge))
Stripe::Charge.create({:amount => 50, :currency => 'usd', :card => { :number => nil }}, {:idempotency_key => 'provided_key'})
end

17
test/stripe/apple_pay_domain_test.rb
View File

@ -3,26 +3,25 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ApplePayDomainTest < Test::Unit::TestCase
should "create should return a new Apple Pay domain" do
@mock.expects(:post).once
.with('https://api.stripe.com/v1/apple_pay/domains', nil, '')
.returns(make_response(make_apple_pay_domain))
stub_request(:post, "#{Stripe.api_base}/v1/apple_pay/domains").
to_return(body: JSON.generate(make_apple_pay_domain))
d = Stripe::ApplePayDomain.create
assert_equal "apwc_test_domain", d.id
end
should "domains should be deletable" do
@mock.expects(:get).once
.with('https://api.stripe.com/v1/apple_pay/domains/apwc_test_domain', nil, nil)
.returns(make_response(make_apple_pay_domain))
@mock.expects(:delete).once.returns(make_response(make_apple_pay_domain(:deleted => true)))
stub_request(:get, "#{Stripe.api_base}/v1/apple_pay/domains/apwc_test_domain").
to_return(body: JSON.generate(make_apple_pay_domain))
stub_request(:delete, "#{Stripe.api_base}/v1/apple_pay/domains/apwc_test_domain").
to_return(body: JSON.generate(make_apple_pay_domain(:deleted => true)))
domain = Stripe::ApplePayDomain.retrieve('apwc_test_domain')
domain.delete
assert domain.deleted
end
should "domains should be listable" do
@mock.expects(:get).once.with('https://api.stripe.com/v1/apple_pay/domains', nil, nil)
.returns(make_response(make_apple_pay_domain_array))
stub_request(:get, "#{Stripe.api_base}/v1/apple_pay/domains").
to_return(body: JSON.generate(make_apple_pay_domain_array))
domains = Stripe::ApplePayDomain.list
assert domains.data.kind_of?(Array)
assert_equal 3, domains.data.length

29
test/stripe/application_fee_refund_test.rb
View File

@ -3,30 +3,24 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ApplicationFeeRefundTest < Test::Unit::TestCase
should "refunds should be listable" do
@mock.expects(:get).once.returns(make_response(make_application_fee))
stub_request(:get, "#{Stripe.api_base}/v1/application_fees/test_application_fee").
to_return(body: JSON.generate(make_application_fee))
application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
assert application_fee.refunds.first.kind_of?(Stripe::ApplicationFeeRefund)
end
should "refunds should be refreshable" do
@mock.expects(:get).twice.returns(make_response(make_application_fee), make_response(make_application_fee_refund(:id => 'refreshed_refund')))
application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
refund = application_fee.refunds.first
refund.refresh
assert_equal 'refreshed_refund', refund.id
end
should "refunds should be updateable" do
@mock.expects(:get).once.returns(make_response(make_application_fee))
@mock.expects(:post).once.returns(make_response(make_application_fee_refund(:metadata => {'key' => 'value'})))
stub_request(:get, "#{Stripe.api_base}/v1/application_fees/test_application_fee").
to_return(body: JSON.generate(make_application_fee))
application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
refund = application_fee.refunds.first
stub_request(:post, "#{Stripe.api_base}/v1/application_fees/#{refund.fee}/refunds/#{refund.id}").
to_return(body: JSON.generate(make_application_fee_refund(:metadata => {'key' => 'value'})))
assert_equal nil, refund.metadata['key']
refund.metadata['key'] = 'valu'
@ -36,10 +30,13 @@ module Stripe
end
should "create should return a new refund" do
@mock.expects(:get).once.returns(make_response(make_application_fee))
@mock.expects(:post).once.returns(make_response(make_application_fee_refund(:id => 'test_new_refund')))
stub_request(:get, "#{Stripe.api_base}/v1/application_fees/test_application_fee").
to_return(body: JSON.generate(make_application_fee))
application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
stub_request(:post, "#{Stripe.api_base}/v1/application_fees/#{application_fee.id}/refunds").
to_return(body: JSON.generate(make_application_fee_refund(:id => 'test_new_refund')))
refund = application_fee.refunds.create(:amount => 20)
assert_equal 'test_new_refund', refund.id
end

8
test/stripe/application_fee_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ApplicationFeeTest < Test::Unit::TestCase
should "application fees should be listable" do
@mock.expects(:get).once.returns(make_response(make_application_fee_array))
stub_request(:get, "#{Stripe.api_base}/v1/application_fees").
to_return(body: JSON.generate(make_application_fee_array))
fees = Stripe::ApplicationFee.list
assert fees.data.kind_of? Array
fees.each do |fee|
@ -14,9 +15,8 @@ module Stripe
should "application fees should be refundable" do
fee = Stripe::ApplicationFee.construct_from(make_application_fee)
@mock.expects(:post).once.
with("#{Stripe.api_base}/v1/application_fees/#{fee.id}/refunds", nil, '').
returns(make_response(make_application_fee_refund))
stub_request(:post, "#{Stripe.api_base}/v1/application_fees/#{fee.id}/refunds").
to_return(body: JSON.generate(make_application_fee_refund))
refund = fee.refunds.create
assert refund.is_a?(Stripe::ApplicationFeeRefund)

3
test/stripe/balance_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class BalanceTest < Test::Unit::TestCase
should "balance should be retrievable" do
@mock.expects(:get).once.returns(make_response(make_balance))
stub_request(:get, "#{Stripe.api_base}/v1/balance").
to_return(body: JSON.generate(make_balance))
balance = Stripe::Balance.retrieve
assert_equal('balance', balance['object'])
end

7
test/stripe/bank_account_test.rb
View File

@ -9,10 +9,9 @@ module Stripe
:customer => 'cus_bar'
})
@mock.expects(:post).
once.
with('https://api.stripe.com/v1/customers/cus_bar/sources/ba_foo/verify', nil, 'amounts[]=1&amounts[]=2').
returns(make_response(:status => 'verified'))
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{bank.customer}/sources/#{bank.id}/verify").
with(body: { 'amounts' => ['1', '2'] }).
to_return(body: JSON.generate(:status => 'verified'))
bank.verify(:amounts => [1,2])
end

32
test/stripe/bitcoin_receiver_test.rb
View File

@ -3,19 +3,22 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class BitcoinReceiverTest < Test::Unit::TestCase
should "retrieve should retrieve bitcoin receiver" do
@mock.expects(:get).once.returns(make_response(make_bitcoin_receiver))
stub_request(:get, "#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver").
to_return(body: JSON.generate(make_bitcoin_receiver))
receiver = Stripe::BitcoinReceiver.retrieve('btcrcv_test_receiver')
assert_equal 'btcrcv_test_receiver', receiver.id
end
should "create should create a bitcoin receiver" do
@mock.expects(:post).once.returns(make_response(make_bitcoin_receiver))
stub_request(:post, "#{Stripe.api_base}/v1/bitcoin/receivers").
to_return(body: JSON.generate(make_bitcoin_receiver))
receiver = Stripe::BitcoinReceiver.create
assert_equal "btcrcv_test_receiver", receiver.id
end
should "all should list bitcoin receivers" do
@mock.expects(:get).once.returns(make_response(make_bitcoin_receiver_array))
stub_request(:get, "#{Stripe.api_base}/v1/bitcoin/receivers").
to_return(body: JSON.generate(make_bitcoin_receiver_array))
receivers = Stripe::BitcoinReceiver.list
assert_equal 3, receivers.data.length
assert receivers.data.kind_of? Array
@ -27,33 +30,32 @@ module Stripe
end
end
should "maintain bitcoin transaction sublist" do
@mock.expects(:get).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, nil).once.returns(make_response(make_bitcoin_receiver))
receiver = Stripe::BitcoinReceiver.retrieve('btcrcv_test_receiver')
@mock.expects(:get).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver/transactions", nil, nil).once.returns(make_response(make_bitcoin_transaction_array))
transactions = receiver.transactions.list
assert_equal(3, transactions.data.length)
end
should "update should update a bitcoin receiver" do
@mock.expects(:get).once.returns(make_response(make_bitcoin_receiver))
@mock.expects(:post).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, "description=details").once.returns(make_response(make_bitcoin_receiver))
receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver)
stub_request(:get, "#{Stripe.api_base}/v1/bitcoin/receivers/#{receiver.id}").
to_return(body: JSON.generate(make_bitcoin_receiver))
receiver.refresh
stub_request(:post, "#{Stripe.api_base}/v1/bitcoin/receivers/#{receiver.id}").
with(body: { description: "details" }).
to_return(body: JSON.generate(make_bitcoin_receiver))
receiver.description = "details"
receiver.save
end
should "delete a bitcoin receiver with no customer through top-level API" do
@mock.expects(:delete).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, nil).once.returns(make_response({:deleted => true, :id => "btcrcv_test_receiver"}))
receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver)
stub_request(:delete, "#{Stripe.api_base}/v1/bitcoin/receivers/#{receiver.id}").
to_return(body: JSON.generate({:deleted => true, :id => "btcrcv_test_receiver"}))
receiver.delete
assert(receiver.deleted)
end
should "delete a bitcoin receiver with a customer through customer's subresource API" do
@mock.expects(:delete).with("#{Stripe.api_base}/v1/customers/customer_foo/sources/btcrcv_test_receiver", nil, nil).once.returns(make_response({:deleted => true, :id => "btcrcv_test_receiver"}))
receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver(:customer => 'customer_foo'))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/customer_foo/sources/#{receiver.id}").
to_return(body: JSON.generate({:deleted => true, :id => "btcrcv_test_receiver"}))
receiver.delete
assert(receiver.deleted)
end

14
test/stripe/bitcoin_transaction_test.rb
View File

@ -5,21 +5,17 @@ module Stripe
TEST_ID = "btctxn_test_transaction".freeze
should "retrieve should retrieve bitcoin receiver" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/bitcoin/transactions/#{TEST_ID}", nil, nil).
once.
returns(make_response(make_bitcoin_transaction))
stub_request(:get, "#{Stripe.api_base}/v1/bitcoin/transactions/#{TEST_ID}").
to_return(body: JSON.generate(make_bitcoin_transaction))
receiver = Stripe::BitcoinTransaction.retrieve(TEST_ID)
assert_equal TEST_ID, receiver.id
end
should "all should list bitcoin transactions" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/bitcoin/transactions", nil, nil).
once.
returns(make_response(make_bitcoin_transaction_array))
stub_request(:get, "#{Stripe.api_base}/v1/bitcoin/transactions").
to_return(body: JSON.generate(make_bitcoin_transaction_array))
transactions = Stripe::BitcoinTransaction.list
assert_equal 3, transactions.data.length
assert transactions.data.kind_of? Array
transactions.each do |transaction|
assert transaction.kind_of?(Stripe::BitcoinTransaction)

64
test/stripe/charge_refund_test.rb
View File

@ -3,64 +3,58 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ChargeRefundTest < Test::Unit::TestCase
should "refunds should be listable" do
@mock.expects(:get).once.returns(make_response(make_charge))
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
charge = Stripe::Charge.retrieve('test_charge')
assert charge.refunds.first.kind_of?(Stripe::Refund)
end
should "refunds should be refreshable" do
@mock.expects(:get).twice.returns(make_response(make_charge), make_response(make_refund(:id => 'refreshed_refund')))
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
charge = Stripe::Charge.retrieve('test_charge')
refund = charge.refunds.first
refund.refresh
assert_equal 'refreshed_refund', refund.id
stub_request(:get, "#{Stripe.api_base}/v1/refunds/#{refund.id}").
to_return(body: JSON.generate(make_refund))
refund.refresh
end
should "refunds should be updateable" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
once.returns(make_response(make_charge))
@mock.expects(:post).
with("#{Stripe.api_base}/v1/refunds/ref_test_refund", nil, 'metadata[key]=value').
once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
charge = Stripe::Charge.retrieve('test_charge')
refund = charge.refunds.first
assert_equal nil, refund.metadata['key']
stub_request(:post, "#{Stripe.api_base}/v1/refunds/#{refund.id}").
with(body: { metadata: { key: "value" } }).
to_return(body: JSON.generate(make_refund))
refund.metadata['key'] = 'value'
refund.save
assert_equal 'value', refund.metadata['key']
end
should "create should return a new refund" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
once.returns(make_response(make_charge(:id => 'test_charge')))
@mock.expects(:post).
with("#{Stripe.api_base}/v1/charges/test_charge/refunds", nil, 'amount=20').
once.returns(make_response(make_refund(:id => 'test_new_refund')))
should "create a new refund" do
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
charge = Stripe::Charge.retrieve('test_charge')
refund = charge.refunds.create(:amount => 20)
assert_equal 'test_new_refund', refund.id
stub_request(:post, "#{Stripe.api_base}/v1/charges/#{charge.id}/refunds").
with(body: { amount: "20" }).
to_return(body: JSON.generate(make_refund))
_ = charge.refunds.create(:amount => 20)
end
should "should refund a charge with given amount" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
twice.returns(make_response(make_charge(:id => 'test_charge')))
@mock.expects(:post).
with("#{Stripe.api_base}/v1/charges/test_charge/refunds", nil, 'amount=20').
once.returns(make_response(make_refund(:amount => 20)))
should "create a new refund with the old helper" do
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
charge = Stripe::Charge.retrieve('test_charge')
stub_request(:get, "#{Stripe.api_base}/v1/charges/#{charge.id}").
to_return(body: JSON.generate(charge))
stub_request(:post, "#{Stripe.api_base}/v1/charges/#{charge.id}/refunds").
with(body: { amount: "20" }).
to_return(body: JSON.generate(make_refund))
charge.refund(:amount => 20)
end
end

147
test/stripe/charge_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ChargeTest < Test::Unit::TestCase
should "charges should be listable" do
@mock.expects(:get).once.returns(make_response(make_charge_array))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_charge_array))
c = Stripe::Charge.list
assert c.data.kind_of? Array
c.each do |charge|
@ -11,136 +12,62 @@ module Stripe
end
end
should "charges should be refundable" do
c = Stripe::Charge.construct_from(make_charge)
@mock.expects(:get).never
@mock.expects(:post).once.returns(make_response(make_refund(:charge => c)))
r = c.refunds.create
assert r.is_a?(Stripe::Refund)
end
should "charges should be refundable for old API versions" do
# "refunds" was a plain array in old API versions but is not a Stripe
# list (see the implementation of `make_charge` for a current example)
data = make_charge.merge!(:refunds => [])
c = Stripe::Charge.construct_from(data)
@mock.expects(:get).never
@mock.expects(:post).once.
with("#{Stripe.api_base}/v1/charges/#{c.id}/refund", nil, '').
returns(make_response(data.merge(:refunded => true)))
c = c.refund
assert c.is_a?(Stripe::Charge)
assert c.refunded
end
should "charges should not be deletable" do
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
c = Stripe::Charge.retrieve("test_charge")
assert_raises NoMethodError do
@mock.expects(:get).once.returns(make_response(make_charge))
c = Stripe::Charge.retrieve("test_charge")
c.delete
end
end
should "charges should be updateable" do
@mock.expects(:post).once.
with('https://api.stripe.com/v1/charges/test_charge', nil, 'metadata[foo]=bar').
returns(make_response(make_charge(metadata: {'foo' => 'bar'})))
c = Stripe::Charge.update("test_charge", metadata: {foo: 'bar'})
assert_equal('bar', c.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/charges/test_charge").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_charge))
_ = Stripe::Charge.update("test_charge", metadata: {foo: 'bar'})
end
should "charges should be saveable" do
@mock.expects(:get).once.returns(make_response(make_charge))
@mock.expects(:post).once.returns(make_response(make_charge))
c = Stripe::Charge.new("test_charge")
c.refresh
c.mnemonic = "New charge description"
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
c = Stripe::Charge.retrieve("test_charge")
stub_request(:post, "#{Stripe.api_base}/v1/charges/#{c.id}").
with(body: { mnemonic: "updated" }).
to_return(body: JSON.generate(make_charge))
c.mnemonic = "updated"
c.save
end
should "charges should be able to be marked as fraudulent" do
@mock.expects(:get).once.returns(make_response(make_charge))
@mock.expects(:post).once.returns(make_response(make_charge))
c = Stripe::Charge.new("test_charge")
c.refresh
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
c = Stripe::Charge.retrieve("test_charge")
stub_request(:post, "#{Stripe.api_base}/v1/charges/#{c.id}").
with(body: { :fraud_details => { :user_report => 'fraudulent' } }).
to_return(body: JSON.generate(make_charge))
c.mark_as_fraudulent
end
should "charges should be able to be marked as safe" do
@mock.expects(:get).once.returns(make_response(make_charge))
@mock.expects(:post).once.returns(make_response(make_charge))
c = Stripe::Charge.new("test_charge")
c.refresh
stub_request(:get, "#{Stripe.api_base}/v1/charges/test_charge").
to_return(body: JSON.generate(make_charge))
c = Stripe::Charge.retrieve("test_charge")
stub_request(:post, "#{Stripe.api_base}/v1/charges/#{c.id}").
with(body: { :fraud_details => { :user_report => 'safe' } }).
to_return(body: JSON.generate(make_charge))
c.mark_as_safe
end
should "charges should have Card objects associated with their Card property" do
@mock.expects(:get).once.returns(make_response(make_charge))
c = Stripe::Charge.retrieve("test_charge")
assert c.card.kind_of?(Stripe::StripeObject) && c.card.object == 'card'
end
should "charges should have Outcome objects associated with their outcome property" do
@mock.expects(:get).once.returns(make_response(make_charge))
c = Stripe::Charge.retrieve("test_charge")
assert c.outcome.kind_of?(Stripe::StripeObject) && c.outcome.type == 'authorized'
end
should "execute should return a new, fully executed charge when passed correct `card` parameters" do
@mock.expects(:post).with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
'currency' => ['usd'], 'amount' => ['100'],
'card[exp_year]' => ['2012'],
'card[number]' => ['4242424242424242'],
'card[exp_month]' => ['11']
}
end.once.returns(make_response(make_charge))
c = Stripe::Charge.create({
:amount => 100,
:card => {
:number => "4242424242424242",
:exp_month => 11,
:exp_year => 2012,
},
:currency => "usd"
})
assert c.paid
end
should "execute should return a new, fully executed charge when passed correct `source` parameters" do
@mock.expects(:post).with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
'currency' => ['usd'], 'amount' => ['100'],
'source' => ['btcrcv_test_receiver']
}
end.once.returns(make_response(make_charge))
c = Stripe::Charge.create({
:amount => 100,
:source => 'btcrcv_test_receiver',
:currency => "usd"
})
assert c.paid
end
should "properly handle an array or dictionaries" do
@mock.expects(:post).with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
'currency' => ['usd'], 'amount' => ['100'],
'source' => ['btcrcv_test_receiver'],
'level3[][red]' => ['firstred', 'another'],
'level3[][one]' => ['fish'],
}
end.once.returns(make_response(make_charge))
c = Stripe::Charge.create({
:amount => 100,
:source => 'btcrcv_test_receiver',
:currency => "usd",
:level3 => [{:red => 'firstred'}, {:red => 'another', :one => 'fish'}]
})
assert c.paid
should "create a new charge" do
stub_request(:post, "#{Stripe.api_base}/v1/charges").
with(body: { amount: "20" }).
to_return(body: JSON.generate(make_charge))
_ = Charge.create(:amount => 20)
end
end
end

30
test/stripe/country_spec_test.rb
View File

@ -3,41 +3,19 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class CountrySpecTest < Test::Unit::TestCase
should "be listable" do
@mock.expects(:get).once.
returns(make_response(country_spec_array))
stub_request(:get, "#{Stripe.api_base}/v1/country_specs").
to_return(body: JSON.generate(make_country_spec_array))
c = Stripe::CountrySpec.list
assert_equal('/v1/country_specs', c.resource_url)
assert_equal('list', c.object)
assert(c.data.kind_of?(Array))
assert_equal('US', c.data[0].id)
assert(c.data[0].kind_of?(Stripe::CountrySpec))
end
should "be retrievable" do
resp = make_country_spec
@mock.expects(:get).once.
with('https://api.stripe.com/v1/country_specs/US', nil, nil).
returns(make_response(resp))
stub_request(:get, "#{Stripe.api_base}/v1/country_specs/US").
to_return(body: JSON.generate(make_country_spec))
s = Stripe::CountrySpec.retrieve('US')
assert_equal('/v1/country_specs/US', s.resource_url)
assert_equal('country_spec', s.object)
assert(s.kind_of?(Stripe::CountrySpec))
s.supported_bank_account_currencies.map{ |k,v| assert v.kind_of?(Array) }
assert_equal(['US'], s.supported_bank_account_currencies['usd'])
assert(s.supported_payment_currencies.include?('usd'))
assert s.supported_payment_currencies.kind_of?(Array)
assert s.supported_payment_methods.kind_of?(Array)
['individual', 'company'].map{ |type|
item = s.verification_fields[type]
assert item.minimum.include?('external_account')
assert item.additional.include?('legal_entity.verification.document')
assert item.additional.kind_of?(Array)
assert item.minimum.kind_of?(Array)
}
end
end
end

26
test/stripe/coupon_test.rb
View File

@ -3,26 +3,28 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class CouponTest < Test::Unit::TestCase
should "create should return a new coupon" do
@mock.expects(:post).once.returns(make_response(make_coupon))
c = Stripe::Coupon.create
assert_equal "co_test_coupon", c.id
stub_request(:post, "#{Stripe.api_base}/v1/coupons").
to_return(body: JSON.generate(make_coupon))
_ = Stripe::Coupon.create
end
should "coupons should be saveable" do
@mock.expects(:get).once.returns(make_response(make_coupon))
@mock.expects(:post).once.returns(make_response(make_coupon))
c = Stripe::Coupon.new("test_coupon")
c.refresh
stub_request(:get, "#{Stripe.api_base}/v1/coupons/test_coupon").
to_return(body: JSON.generate(make_coupon))
c = Stripe::Coupon.retrieve("test_coupon")
stub_request(:post, "#{Stripe.api_base}/v1/coupons/#{c.id}").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_customer))
c.metadata['foo'] = 'bar'
c.save
end
should "coupons should be updateable" do
@mock.expects(:post).once.
with("https://api.stripe.com/v1/coupons/test_coupon", nil, "metadata[foo]=bar").
returns(make_response(make_coupon(metadata: {foo: 'bar'})))
c = Stripe::Coupon.update("test_coupon", metadata: {foo: 'bar'})
assert_equal('bar', c.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/coupons/test_coupon").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_customer))
_ = Stripe::Coupon.update("test_coupon", metadata: {foo: 'bar'})
end
end
end

50
test/stripe/customer_card_test.rb
View File

@ -2,56 +2,56 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class CustomerCardTest < Test::Unit::TestCase
CUSTOMER_CARD_URL = '/v1/customers/test_customer/sources/test_card'
def customer
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
Stripe::Customer.retrieve('test_customer')
end
should "customer cards should be listable" do
c = customer
@mock.expects(:get).once.returns(make_response(make_customer_card_array(customer.id)))
stub_request(:get, "#{Stripe.api_base}/v1/customers/#{c.id}/sources").
with(query: { object: "card" }).
to_return(body: JSON.generate(make_customer_card_array(customer.id)))
cards = c.sources.list(:object => "card").data
assert cards.kind_of? Array
assert cards[0].kind_of? Stripe::Card
end
should "customer cards should have the correct resource url" do
c = customer
@mock.expects(:get).once.returns(make_response(make_card(
:id => 'test_card',
:customer => 'test_customer'
)))
card = c.sources.retrieve('card')
assert_equal CUSTOMER_CARD_URL, card.resource_url
end
should "customer cards should be deletable" do
c = customer
@mock.expects(:get).once.returns(make_response(make_card))
@mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
stub_request(:get, "#{Stripe.api_base}/v1/customers/#{c.id}/sources/card").
to_return(body: JSON.generate(make_card))
card = c.sources.retrieve('card')
card.delete
assert card.deleted
stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{card.customer}/sources/#{card.id}").
to_return(body: JSON.generate(make_card(:deleted => true)))
_ = card.delete
end
should "customer cards should be updateable" do
c = customer
@mock.expects(:get).once.returns(make_response(make_card(:exp_year => "2000")))
@mock.expects(:post).once.returns(make_response(make_card(:exp_year => "2100")))
stub_request(:get, "#{Stripe.api_base}/v1/customers/#{c.id}/sources/card").
to_return(body: JSON.generate(make_card))
card = c.sources.retrieve('card')
assert_equal "2000", card.exp_year
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{card.customer}/sources/#{card.id}").
with(body: { exp_year: "2100" }).
to_return(body: JSON.generate(make_card))
card.exp_year = "2100"
card.save
assert_equal "2100", card.exp_year
end
should "create should return a new customer card" do
c = customer
@mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
card = c.sources.create(:source => "tok_41YJ05ijAaWaFS")
assert_equal "test_card", card.id
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{c.id}/sources").
with(body: { source: "tok_41YJ05ijAaWaFS" }).
to_return(body: JSON.generate(make_card))
_ = c.sources.create(:source => "tok_41YJ05ijAaWaFS")
end
should "raise if accessing Stripe::Card.retrieve directly" do

83
test/stripe/customer_test.rb
View File

@ -3,94 +3,97 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class CustomerTest < Test::Unit::TestCase
should "customers should be listable" do
@mock.expects(:get).once.returns(make_response(make_customer_array))
stub_request(:get, "#{Stripe.api_base}/v1/customers").
to_return(body: JSON.generate(make_customer_array))
c = Stripe::Customer.list.data
assert c.kind_of? Array
assert c[0].kind_of? Stripe::Customer
end
should "customers should be deletable" do
@mock.expects(:delete).once.returns(make_response(make_customer({:deleted => true})))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.new("test_customer")
c.delete
assert c.deleted
end
should "customers should be saveable" do
@mock.expects(:get).once.returns(make_response(make_customer({:mnemonic => "foo"})))
@mock.expects(:post).once.returns(make_response(make_customer({:mnemonic => "bar"})))
c = Stripe::Customer.new("test_customer").refresh
assert_equal "foo", c.mnemonic
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.retrieve("test_customer")
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{c.id}").
with(body: { mnemonic: "bar" }).
to_return(body: JSON.generate(make_customer))
c.mnemonic = "bar"
c.save
assert_equal "bar", c.mnemonic
end
should "customers should be updateable" do
@mock.expects(:post).once.
with("https://api.stripe.com/v1/customers/test_customer", nil, "metadata[foo]=bar").
returns(make_response(make_customer(metadata: {foo: 'bar'})))
c = Stripe::Customer.update("test_customer", metadata: {foo: 'bar'})
assert_equal('bar', c.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/customers/test_customer").
with(body: { mnemonic: "bar" }).
to_return(body: JSON.generate(make_customer))
_ = Stripe::Customer.update("test_customer", mnemonic: "bar")
end
should "create should return a new customer" do
@mock.expects(:post).once.returns(make_response(make_customer))
c = Stripe::Customer.create
assert_equal "c_test_customer", c.id
stub_request(:post, "#{Stripe.api_base}/v1/customers").
to_return(body: JSON.generate(make_customer))
_ = Stripe::Customer.create
end
should "create_upcoming_invoice should create a new invoice" do
@mock.expects(:post).once.returns(make_response(make_invoice))
i = Stripe::Customer.new("test_customer").create_upcoming_invoice
assert_equal "c_test_customer", i.customer
stub_request(:post, "#{Stripe.api_base}/v1/invoices").
with(body: { customer: "test_customer" }).
to_return(body: JSON.generate(make_customer))
_ = Stripe::Customer.new("test_customer").create_upcoming_invoice
end
should "be able to update a customer's subscription" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.retrieve("test_customer")
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/customers/c_test_customer/subscription" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
end.returns(make_response(make_subscription(:plan => 'silver')))
s = c.update_subscription({:plan => 'silver'})
assert_equal 'subscription', s.object
assert_equal 'silver', s.plan.identifier
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{c.id}/subscription").
with(body: { plan: "silver" }).
to_return(body: JSON.generate(make_subscription))
_ = c.update_subscription({:plan => 'silver'})
end
should "be able to cancel a customer's subscription" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.retrieve("test_customer")
# Not an accurate response, but whatever
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription?at_period_end=true", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{c.id}/subscription").
with(query: { at_period_end: "true" }).
to_return(body: JSON.generate(make_subscription))
c.cancel_subscription({:at_period_end => 'true'})
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{c.id}/subscription").
to_return(body: JSON.generate(make_subscription))
c.cancel_subscription
end
should "be able to create a subscription for a customer" do
c = Stripe::Customer.new("test_customer")
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/customers/test_customer/subscriptions" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
end.returns(make_response(make_subscription(:plan => 'silver')))
s = c.create_subscription({:plan => 'silver'})
assert_equal 'subscription', s.object
assert_equal 'silver', s.plan.identifier
stub_request(:post, "#{Stripe.api_base}/v1/customers/#{c.id}/subscriptions").
with(body: { plan: "silver" }).
to_return(body: JSON.generate(make_subscription))
_ = c.create_subscription({:plan => 'silver'})
end
should "be able to delete a customer's discount" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/test_customer").
to_return(body: JSON.generate(make_customer))
c = Stripe::Customer.retrieve("test_customer")
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/discount", nil, nil).returns(make_response(make_delete_discount_response))
stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{c.id}/discount").
to_return(body: JSON.generate(make_delete_discount_response))
c.delete_discount
assert_equal nil, c.discount
end
should "can have a token source set" do

39
test/stripe/dispute_test.rb
View File

@ -3,13 +3,15 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class DisputeTest < Test::Unit::TestCase
should "disputes should be retrievable" do
@mock.expects(:get).once.returns(make_response(make_dispute))
stub_request(:get, "#{Stripe.api_base}/v1/disputes/dp_test_dispute").
to_return(body: JSON.generate(make_dispute))
d = Stripe::Dispute.retrieve('dp_test_dispute')
assert d.kind_of?(Stripe::Dispute)
end
should "disputes should be listable" do
@mock.expects(:get).once.returns(make_response(make_dispute_array))
stub_request(:get, "#{Stripe.api_base}/v1/disputes").
to_return(body: JSON.generate(make_dispute_array))
d = Stripe::Dispute.list
assert d.data.kind_of? Array
d.each do |dispute|
@ -18,34 +20,27 @@ module Stripe
end
should "disputes should be closeable" do
@mock.expects(:get).never
@mock.expects(:post).with(
"#{Stripe.api_base}/v1/disputes/test_dispute/close",
nil,
''
).once.returns(make_response({:id => 'dp_test_dispute', :status => 'lost'}))
d = Stripe::Dispute.new('test_dispute')
stub_request(:post, "#{Stripe.api_base}/v1/disputes/dp_test_dispute/close").
to_return(body: JSON.generate(make_dispute))
d = Stripe::Dispute.new('dp_test_dispute')
d.close
end
should "disputes should be updateable" do
@mock.expects(:post).once.
with("https://api.stripe.com/v1/disputes/test_dispute", nil, "metadata[foo]=bar").
returns(make_response(make_dispute(metadata: {foo: 'bar'})))
d = Stripe::Dispute.update("test_dispute", metadata: {foo: 'bar'})
assert_equal('bar', d.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/disputes/dp_test_dispute").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_dispute))
_ = Stripe::Dispute.update("dp_test_dispute", metadata: {foo: 'bar'})
end
should "disputes should be saveable" do
@mock.expects(:get).once.returns(make_response(make_dispute))
@mock.expects(:post).with(
"#{Stripe.api_base}/v1/disputes/dp_test_dispute",
nil,
'evidence[customer_name]=customer'
).once.returns(make_response(make_dispute))
stub_request(:get, "#{Stripe.api_base}/v1/disputes/dp_test_dispute").
to_return(body: JSON.generate(make_dispute))
d = Stripe::Dispute.retrieve('dp_test_dispute')
d = Stripe::Dispute.new('test_dispute')
d.refresh
stub_request(:post, "#{Stripe.api_base}/v1/disputes/dp_test_dispute").
with(body: { evidence: { customer_name: "customer" } }).
to_return(body: JSON.generate(make_dispute))
d.evidence['customer_name'] = 'customer'
d.save
end

27
test/stripe/file_upload_test.rb
View File

@ -3,33 +3,26 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class FileUploadTest < Test::Unit::TestCase
should "create should return a new file" do
params = {
stub_request(:post, "#{Stripe.uploads_base}/v1/files").
to_return(body: JSON.generate(make_file))
f = Stripe::FileUpload.create({
:purpose => "dispute_evidence",
:file => File.new(__FILE__),
}
@mock.expects(:post).once.
with("#{Stripe.uploads_base}/v1/files", nil, params).
returns(make_response(make_file))
f = Stripe::FileUpload.create(params)
})
assert_equal "fil_test_file", f.id
end
should "files should be retrievable" do
@mock.expects(:get).once.
with("#{Stripe.uploads_base}/v1/files/fil_test_file", nil, nil).
returns(make_response(make_file))
stub_request(:get, "#{Stripe.uploads_base}/v1/files/fil_test_file").
to_return(body: JSON.generate(make_file))
c = Stripe::FileUpload.new("fil_test_file")
c.refresh
assert_equal 1403047735, c.created
_ = Stripe::FileUpload.retrieve("fil_test_file")
end
should "files should be listable" do
@mock.expects(:get).once.
with("#{Stripe.uploads_base}/v1/files", nil, nil).
returns(make_response(make_file_array))
stub_request(:get, "#{Stripe.uploads_base}/v1/files").
to_return(body: JSON.generate(make_file_array))
c = Stripe::FileUpload.list.data
assert c.kind_of? Array

15
test/stripe/invoice_item_test.rb
View File

@ -3,17 +3,16 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class InvoiceItemTest < Test::Unit::TestCase
should "retrieve should retrieve invoice items" do
@mock.expects(:get).once.returns(make_response(make_invoice_item))
ii = Stripe::InvoiceItem.retrieve('in_test_invoice_item')
assert_equal 'ii_test_invoice_item', ii.id
stub_request(:get, "#{Stripe.api_base}/v1/invoiceitems/ii_test_invoice_item").
to_return(body: JSON.generate(make_invoice_item))
_ = Stripe::InvoiceItem.retrieve('ii_test_invoice_item')
end
should "invoice items should be updateable" do
@mock.expects(:post).once.
with('https://api.stripe.com/v1/invoiceitems/test_invoice_item', nil, 'metadata[foo]=bar').
returns(make_response(make_charge(metadata: {'foo' => 'bar'})))
ii = Stripe::InvoiceItem.update("test_invoice_item", metadata: {foo: 'bar'})
assert_equal('bar', ii.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/invoiceitems/ii_test_invoice_item").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_invoice_item))
_ = Stripe::InvoiceItem.update("ii_test_invoice_item", metadata: {foo: 'bar'})
end
end
end

58
test/stripe/invoice_test.rb
View File

@ -3,64 +3,46 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class InvoiceTest < Test::Unit::TestCase
should "retrieve should retrieve invoices" do
@mock.expects(:get).once.returns(make_response(make_invoice))
stub_request(:get, "#{Stripe.api_base}/v1/invoices/in_test_invoice").
to_return(body: JSON.generate(make_invoice))
i = Stripe::Invoice.retrieve('in_test_invoice')
assert_equal 'in_test_invoice', i.id
end
should "create should create a new invoice" do
@mock.expects(:post).once.returns(make_response(make_invoice))
i = Stripe::Invoice.create
assert_equal "in_test_invoice", i.id
stub_request(:post, "#{Stripe.api_base}/v1/invoices").
to_return(body: JSON.generate(make_invoice))
_ = Stripe::Invoice.create
end
should "pay should pay an invoice" do
@mock.expects(:get).once.returns(make_response(make_invoice))
stub_request(:get, "#{Stripe.api_base}/v1/invoices/in_test_invoice").
to_return(body: JSON.generate(make_invoice))
i = Stripe::Invoice.retrieve('in_test_invoice')
@mock.expects(:post).once.with('https://api.stripe.com/v1/invoices/in_test_invoice/pay', nil, '').returns(make_response(make_paid_invoice))
stub_request(:post, "#{Stripe.api_base}/v1/invoices/#{i.id}/pay").
to_return(body: JSON.generate(make_invoice))
i.pay
assert_equal nil, i.next_payment_attempt
end
should "invoices should be updateable" do
@mock.expects(:post).once.
with("https://api.stripe.com/v1/invoices/test_invoice", nil, "metadata[foo]=bar").
returns(make_response(make_invoice(metadata: {foo: 'bar'})))
i = Stripe::Invoice.update("test_invoice", metadata: {foo: 'bar'})
assert_equal('bar', i.metadata['foo'])
end
should "pay with extra opts should pay an invoice" do
@mock.expects(:get).once.returns(make_response(make_invoice))
i = Stripe::Invoice.retrieve('in_test_invoice', {:api_key => 'foobar'})
Stripe.expects(:execute_request).with do |opts|
opts[:url] == "#{Stripe.api_base}/v1/invoices/in_test_invoice/pay" &&
opts[:method] == :post &&
opts[:headers]['Authorization'] == 'Bearer foobar'
end.returns(make_response(make_paid_invoice))
i.pay
assert_equal nil, i.next_payment_attempt
stub_request(:post, "#{Stripe.api_base}/v1/invoices/test_invoice").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_invoice))
_ = Stripe::Invoice.update("test_invoice", metadata: {foo: 'bar'})
end
should "be able to retrieve upcoming invoices" do
base = "#{Stripe.api_base}/v1/invoices/upcoming?"
cus_sub = "customer=c_test_customer&subscription=s_test_subscription&"
item0 = "subscription_items[][plan]=gold&subscription_items[][quantity]=1&"
item1 = "subscription_items[][plan]=silver&subscription_items[][quantity]=2"
@mock.expects(:get).once.with(base + cus_sub + item0 + item1, nil, nil).
returns(make_response(make_invoice(:customer => 'c_test_customer', :subscription => 's_test_subscription')))
i = Stripe::Invoice.upcoming(
stub_request(:get, "#{Stripe.api_base}/v1/invoices/upcoming").
with(query: {
:customer => 'c_test_customer',
:subscription => 's_test_subscription',
}).
to_return(body: JSON.generate(make_invoice))
_ = Stripe::Invoice.upcoming(
:customer => 'c_test_customer',
:subscription => 's_test_subscription',
:subscription_items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}]
)
assert_equal 'c_test_customer', i.customer
assert_equal 's_test_subscription', i.subscription
end
end
end

49
test/stripe/list_object_test.rb
View File

@ -36,8 +36,9 @@ module Stripe
:has_more => true,
:url => "/things",
})
@mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { starting_after: "1" }).
to_return(body: JSON.generate({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
assert_equal expected, list.auto_paging_each.to_a
end
@ -55,8 +56,9 @@ module Stripe
:has_more => true,
:url => "/things",
})
@mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { starting_after: "1" }).
to_return(body: JSON.generate({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
actual = []
list.auto_paging_each do |obj|
@ -83,8 +85,9 @@ module Stripe
:has_more => true,
:url => "/things",
})
@mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { starting_after: "1" }).
to_return(body: JSON.generate({ :data => [{ :id => 2 }], :has_more => false }))
next_list = list.next_page
refute next_list.empty?
end
@ -96,15 +99,9 @@ module Stripe
:url => "/things",
})
list.filters = { :expand => ['data.source'], :limit => 3 }
@mock.expects(:get).with do |url, _, _|
u = URI.parse(url)
params = CGI.parse(u.query)
u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
"expand[]" => ["data.source"],
"limit" => ["3"],
"starting_after" => ["1"],
}
end.returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { "expand[]" => "data.source", "limit" => "3", "starting_after" => "1" }).
to_return(body: JSON.generate({ :data => [{ :id => 2 }], :has_more => false }))
next_list = list.next_page
assert_equal({ :expand => ['data.source'], :limit => 3 }, next_list.filters)
end
@ -128,8 +125,9 @@ module Stripe
:data => [{ :id => 2 }],
:url => "/things",
})
@mock.expects(:get).once.with("#{Stripe.api_base}/things?ending_before=2", nil, nil).
returns(make_response({ :data => [{ :id => 1 }] }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { ending_before: "2" }).
to_return(body: JSON.generate({ :data => [{ :id => 1 }] }))
next_list = list.previous_page
refute next_list.empty?
end
@ -140,17 +138,9 @@ module Stripe
:url => "/things",
})
list.filters = { :expand => ['data.source'], :limit => 3 }
@mock.expects(:get).with do |url, _, _|
# apparently URI.parse in 1.8.7 doesn't support query parameters ...
url, query = url.split("?")
u = URI.parse(url)
params = CGI.parse(query)
u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
"ending_before" => ["2"],
"expand[]" => ["data.source"],
"limit" => ["3"],
}
end.returns(make_response({ :data => [{ :id => 1 }] }))
stub_request(:get, "#{Stripe.api_base}/things").
with(query: { "expand[]" => "data.source", "limit" => "3", "ending_before" => "2" }).
to_return(body: JSON.generate({ :data => [{ :id => 1 }] }))
next_list = list.previous_page
assert_equal({ :expand => ['data.source'], :limit => 3 }, next_list.filters)
end
@ -162,7 +152,8 @@ module Stripe
# note that the name #all is deprecated, as is using it fetch the next page
# in a list
should "be able to retrieve full lists given a listobject" do
@mock.expects(:get).twice.returns(make_response(make_charge_array))
stub_request(:get, "#{Stripe.api_base}/v1/charges").
to_return(body: JSON.generate(make_charge_array))
c = Stripe::Charge.all
assert c.kind_of?(Stripe::ListObject)
assert_equal('/v1/charges', c.resource_url)

129
test/stripe/metadata_test.rb
View File

@ -1,129 +0,0 @@
require File.expand_path('../../test_helper', __FILE__)
module Stripe
class MetadataTest < Test::Unit::TestCase
setup do
@metadata_supported = {
:charge => {
:new => Stripe::Charge.method(:new),
:test => method(:make_charge),
:url => "/v1/charges/#{make_charge()[:id]}"
},
:customer => {
:new => Stripe::Customer.method(:new),
:test => method(:make_customer),
:url => "/v1/customers/#{make_customer()[:id]}"
},
:recipient => {
:new => Stripe::Recipient.method(:new),
:test => method(:make_recipient),
:url => "/v1/recipients/#{make_recipient()[:id]}"
},
:transfer => {
:new => Stripe::Transfer.method(:new),
:test => method(:make_transfer),
:url => "/v1/transfers/#{make_transfer()[:id]}"
},
:product => {
:new => Stripe::Product.method(:new),
:test => method(:make_product),
:url => "/v1/products/#{make_product()[:id]}"
},
:order => {
:new => Stripe::Order.method(:new),
:test => method(:make_order),
:url => "/v1/orders/#{make_order()[:id]}"
},
:sku => {
:new => Stripe::SKU.method(:new),
:test => method(:make_sku),
:url => "/v1/skus/#{make_sku()[:id]}"
},
}
@base_url = 'https://api.stripe.com'
end
should "not touch metadata" do
update_actions = lambda {|obj| obj.description = 'test'}
check_metadata({:metadata => {'initial' => 'true'}},
'description=test',
update_actions)
end
should "update metadata as a whole" do
update_actions = lambda {|obj| obj.metadata = {'uuid' => '6735'}}
check_metadata({:metadata => {}},
'metadata[uuid]=6735',
update_actions)
if is_greater_than_ruby_1_9?
check_metadata({:metadata => {:initial => 'true'}},
'metadata[initial]=&metadata[uuid]=6735',
update_actions)
end
end
should "update metadata keys individually" do
update_actions = lambda {|obj| obj.metadata['txn_id'] = '134a13'}
check_metadata({:metadata => {'initial' => 'true'}},
'metadata[txn_id]=134a13',
update_actions)
end
should "clear metadata as a whole" do
update_actions = lambda {|obj| obj.metadata = nil}
check_metadata({:metadata => {'initial' => 'true'}},
'metadata=',
update_actions)
end
should "clear metadata keys individually" do
update_actions = lambda {|obj| obj.metadata['initial'] = nil}
check_metadata({:metadata => {'initial' => 'true'}},
'metadata[initial]=',
update_actions)
end
should "handle combinations of whole and partial metadata updates" do
if is_greater_than_ruby_1_9?
update_actions = lambda do |obj|
obj.metadata = {'type' => 'summer'}
obj.metadata['uuid'] = '6735'
end
params = {:metadata => {'type' => 'summer', 'uuid' => '6735'}}
curl_args = Stripe::Util.encode_parameters(params)
check_metadata({:metadata => {'type' => 'christmas'}},
curl_args,
update_actions)
end
end
def check_metadata (initial_params, curl_args, metadata_update)
@metadata_supported.each do |name, methods|
neu = methods[:new]
test = methods[:test]
url = @base_url + methods[:url]
initial_test_obj = test.call(initial_params)
@mock.expects(:get).once.returns(make_response(initial_test_obj))
final_test_obj = test.call()
@mock.expects(:post).once.
returns(make_response(final_test_obj)).
with(url, nil, curl_args)
obj = neu.call("test")
obj.refresh()
metadata_update.call(obj)
obj.save
end
end
def is_greater_than_ruby_1_9?
version = RUBY_VERSION.dup # clone preserves frozen state
Gem::Version.new(version) >= Gem::Version.new('1.9')
end
end
end

3
test/stripe/order_return_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class OrderReturnTest < Test::Unit::TestCase
should "returns should be listable" do
@mock.expects(:get).once.returns(make_response(make_order_return_array))
stub_request(:get, "#{Stripe.api_base}/v1/order_returns").
to_return(body: JSON.generate(make_order_return_array))
returns = Stripe::OrderReturn.list
assert returns.data.kind_of?(Array)
returns.each do |ret|

62
test/stripe/order_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class OrderTest < Test::Unit::TestCase
should "orders should be listable" do
@mock.expects(:get).once.returns(make_response(make_order_array))
stub_request(:get, "#{Stripe.api_base}/v1/orders").
to_return(body: JSON.generate(make_order_array))
orders = Stripe::Order.list
assert orders.data.kind_of?(Array)
orders.each do |order|
@ -12,61 +13,54 @@ module Stripe
end
should "orders should not be deletable" do
stub_request(:get, "#{Stripe.api_base}/v1/orders/or_test_order").
to_return(body: JSON.generate(make_order))
p = Stripe::Order.retrieve("or_test_order")
assert_raises NoMethodError do
@mock.expects(:get).once.returns(make_response(make_order))
p = Stripe::Order.retrieve("test_order")
p.delete
end
end
should "orders should be saveable" do
@mock.expects(:get).once.returns(make_response(make_order))
@mock.expects(:post).once.returns(make_response(make_order))
p = Stripe::Order.new("test_order")
p.refresh
stub_request(:get, "#{Stripe.api_base}/v1/orders/or_test_order").
to_return(body: JSON.generate(make_order))
p = Stripe::Order.retrieve("or_test_order")
stub_request(:post, "#{Stripe.api_base}/v1/orders/#{p.id}").
with(body: { status: "fulfilled" }).
to_return(body: JSON.generate(make_order))
p.status = "fulfilled"
p.save
end
should "orders should be updateable" do
@mock.expects(:post).once.
with('https://api.stripe.com/v1/orders/test_order', nil, 'status=fulfilled').
returns(make_response(make_order(status: 'fulfilled')))
ii = Stripe::Order.update("test_order", status: 'fulfilled')
assert_equal('fulfilled', ii.status)
end
should "orders should allow metadata updates" do
@mock.expects(:get).once.returns(make_response(make_order))
@mock.expects(:post).once.returns(make_response(make_order))
p = Stripe::Order.new("test_order")
p.refresh
p.metadata['key'] = 'value'
p.save
stub_request(:post, "#{Stripe.api_base}/v1/orders/or_test_order").
with(body: { status: "fulfilled" }).
to_return(body: JSON.generate(make_order))
_ = Stripe::Order.update("or_test_order", status: 'fulfilled')
end
should "pay should pay an order" do
@mock.expects(:get).once.
returns(make_response(make_order(:id => 'or_test_order')))
stub_request(:get, "#{Stripe.api_base}/v1/orders/or_test_order").
to_return(body: JSON.generate(make_order))
order = Stripe::Order.retrieve('or_test_order')
@mock.expects(:post).once.
with('https://api.stripe.com/v1/orders/or_test_order/pay', nil, 'token=test_token').
returns(make_response(make_paid_order))
stub_request(:post, "#{Stripe.api_base}/v1/orders/#{order.id}/pay").
with(body: { token: "test_token" }).
to_return(body: JSON.generate(make_order))
order.pay(:token => 'test_token')
assert_equal "paid", order.status
end
should "return an order" do
@mock.expects(:get).once.
returns(make_response(make_order(:id => 'or_test_order')))
stub_request(:get, "#{Stripe.api_base}/v1/orders/or_test_order").
to_return(body: JSON.generate(make_order))
order = Stripe::Order.retrieve('or_test_order')
@mock.expects(:post).once.
with('https://api.stripe.com/v1/orders/or_test_order/returns', nil, 'items[][parent]=sku_foo').
returns(make_response(make_order_return({:order => order.id})))
order_return = order.return_order(:items => [{:parent => 'sku_foo'}])
assert_equal order.id, order_return.order
stub_request(:post, "#{Stripe.api_base}/v1/orders/#{order.id}/returns").
with(body: { items: [{ parent: "sku_foo" }] }).
to_return(body: JSON.generate(make_order))
_ = order.return_order(:items => [{:parent => 'sku_foo'}])
end
end
end

23
test/stripe/plan_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class PlanTest < Test::Unit::TestCase
should "plans should be listable" do
@mock.expects(:get).once.returns(make_response(make_plan_array))
stub_request(:get, "#{Stripe.api_base}/v1/plans").
to_return(body: JSON.generate(make_plan_array))
plans = Stripe::Plan.list
assert plans.data.kind_of?(Array)
plans.each do |plan|
@ -12,20 +13,22 @@ module Stripe
end
should "plans should be saveable" do
@mock.expects(:get).once.returns(make_response(make_plan))
@mock.expects(:post).once.returns(make_response(make_plan))
p = Stripe::Plan.new("test_plan")
p.refresh
stub_request(:get, "#{Stripe.api_base}/v1/plans/test_plan").
to_return(body: JSON.generate(make_plan))
p = Stripe::Plan.retrieve("test_plan")
stub_request(:post, "#{Stripe.api_base}/v1/plans/#{p.id}").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_plan))
p.metadata['foo'] = 'bar'
p.save
end
should "plans should be updateable" do
@mock.expects(:post).once.
with('https://api.stripe.com/v1/plans/test_plan', nil, 'metadata[foo]=bar').
returns(make_response(make_plan(metadata: {foo: 'bar'})))
p = Stripe::Plan.update("test_plan", metadata: {foo: 'bar'})
assert_equal('bar', p.metadata['foo'])
stub_request(:post, "#{Stripe.api_base}/v1/plans/test_plan").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_plan))
_ = Stripe::Plan.update("test_plan", metadata: {foo: 'bar'})
end
end
end

42
test/stripe/product_test.rb
View File

@ -3,7 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ProductTest < Test::Unit::TestCase
should "products should be listable" do
@mock.expects(:get).once.returns(make_response(make_product_array))
stub_request(:get, "#{Stripe.api_base}/v1/products").
to_return(body: JSON.generate(make_product_array))
products = Stripe::Product.list
assert products.data.kind_of?(Array)
products.each do |product|
@ -12,40 +13,33 @@ module Stripe
end
should "products should be deletable" do
@mock.expects(:get).once.returns(make_response(make_product))
@mock.expects(:delete).once.
returns(make_response(make_product(:deleted => true)))
stub_request(:get, "#{Stripe.api_base}/v1/products/test_product").
to_return(body: JSON.generate(make_product))
p = Stripe::Product.retrieve("test_product")
stub_request(:delete, "#{Stripe.api_base}/v1/products/#{p.id}").
to_return(body: JSON.generate(make_product))
p.delete
assert p.deleted
end
should "products should be saveable" do
@mock.expects(:get).once.returns(make_response(make_product))
@mock.expects(:post).once.returns(make_response(make_product))
stub_request(:get, "#{Stripe.api_base}/v1/products/test_product").
to_return(body: JSON.generate(make_product))
p = Stripe::Product.new("test_product")
p.refresh
p.description = "New product description"
stub_request(:post, "#{Stripe.api_base}/v1/products/#{p.id}").
with(body: { :description => "update" }).
to_return(body: JSON.generate(make_product))
p.description = "update"
p.save
end
should "products should be updateable" do
@mock.expects(:post).once.
with('https://api.stripe.com/v1/products/test_product', nil, 'description=update').
returns(make_response(make_product(description: 'update')))
p = Stripe::Product.update("test_product", description: 'update')
assert_equal('update', p.description)
stub_request(:post, "#{Stripe.api_base}/v1/products/test_product").
with(body: { :description => "update" }).
to_return(body: JSON.generate(make_product))
_ = Stripe::Product.update("test_product", description: "update")
end
should "products should allow metadata updates" do
@mock.expects(:get).once.returns(make_response(make_product))
@mock.expects(:post).once.returns(make_response(make_product))
p = Stripe::Product.new("test_product")
p.refresh
p.metadata['key'] = 'value'
p.save
end
end
end

49
test/stripe/recipient_card_test.rb
View File

@ -2,56 +2,55 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class RecipientCardTest < Test::Unit::TestCase
RECIPIENT_CARD_URL = '/v1/recipients/test_recipient/cards/test_card'
def recipient
@mock.expects(:get).once.returns(make_response(make_recipient))
stub_request(:get, "#{Stripe.api_base}/v1/recipients/test_recipient").
to_return(body: JSON.generate(make_recipient))
Stripe::Recipient.retrieve('test_recipient')
end
should "recipient cards should be listable" do
c = recipient
@mock.expects(:get).once.returns(make_response(make_recipient_card_array(recipient.id)))
stub_request(:get, "#{Stripe.api_base}/v1/recipients/#{c.id}/cards").
to_return(body: JSON.generate(make_recipient_card_array(recipient.id)))
cards = c.cards.list.data
assert cards.kind_of? Array
assert cards[0].kind_of? Stripe::Card
end
should "recipient cards should have the correct resource url" do
c = recipient
@mock.expects(:get).once.returns(make_response(make_card(
:id => 'test_card',
:recipient => 'test_recipient'
)))
card = c.cards.retrieve('card')
assert_equal RECIPIENT_CARD_URL, card.resource_url
end
should "recipient cards should be deletable" do
c = recipient
@mock.expects(:get).once.returns(make_response(make_card))
@mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
stub_request(:get, "#{Stripe.api_base}/v1/recipients/#{c.id}/cards/card").
to_return(body: JSON.generate(make_card(:recipient => 'test_recipient')))
card = c.cards.retrieve('card')
card.delete
assert card.deleted
stub_request(:delete, "#{Stripe.api_base}/v1/recipients/#{card.recipient}/cards/#{card.id}").
to_return(body: JSON.generate(make_card(:deleted => true)))
_ = card.delete
end
should "recipient cards should be updateable" do
c = recipient
@mock.expects(:get).once.returns(make_response(make_card(:exp_year => "2000")))
@mock.expects(:post).once.returns(make_response(make_card(:exp_year => "2100")))
stub_request(:get, "#{Stripe.api_base}/v1/recipients/#{c.id}/cards/card").
to_return(body: JSON.generate(make_card(:recipient => 'test_recipient')))
card = c.cards.retrieve('card')
assert_equal "2000", card.exp_year
stub_request(:post, "#{Stripe.api_base}/v1/recipients/#{card.recipient}/cards/#{card.id}").
with(body: { exp_year: "2100" }).
to_return(body: JSON.generate(make_card))
card.exp_year = "2100"
card.save
assert_equal "2100", card.exp_year
end
should "create should return a new recipient card" do
c = recipient
@mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
card = c.cards.create(:card => "tok_41YJ05ijAaWaFS")
assert_equal "test_card", card.id
stub_request(:post, "#{Stripe.api_base}/v1/recipients/#{c.id}/cards").
with(body: { card: "tok_41YJ05ijAaWaFS" }).
to_return(body: JSON.generate(make_card))
_ = c.cards.create(:card => "tok_41YJ05ijAaWaFS")
end
end
end

16
test/stripe/recipient_test.rb
View File

@ -2,19 +2,17 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class RecipientTest < Test::Unit::TestCase
should "recipient should be retrievable" do
@mock.expects(:get).once.returns(make_response(make_recipient))
r = Stripe::Recipient.retrieve('test_recipient')
assert_equal 'rp_test_recipient', r.id
stub_request(:get, "#{Stripe.api_base}/v1/recipients/test_recipient").
to_return(body: JSON.generate(make_recipient))
_ = Stripe::Recipient.retrieve('test_recipient')
end
should "recipient should be updateable" do
@mock.expects(:post).once.
with("https://api.stripe.com/v1/recipients/test_recipient", nil, "metadata[foo]=bar").
returns(make_response(make_recipient(metadata: {foo: 'bar'})))
r = Stripe::Recipient.update('test_recipient', metadata: {foo: 'bar'})
assert_equal 'bar', r.metadata['foo']
stub_request(:post, "#{Stripe.api_base}/v1/recipients/test_recipient").
with(body: { metadata: { key: "value" } }).
to_return(body: JSON.generate(make_refund))
_ = Stripe::Recipient.update('test_recipient', metadata: { key: 'value' })
end
end
end

56
test/stripe/refund_test.rb
View File

@ -3,62 +3,36 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class RefundTest < Test::Unit::TestCase
should "refunds should be listable" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/refunds", nil, nil).
once.returns(make_response(make_refund_array))
stub_request(:get, "#{Stripe.api_base}/v1/refunds").
to_return(body: JSON.generate(make_refund_array))
refunds = Stripe::Refund.list
assert refunds.first.kind_of?(Stripe::Refund)
end
should "refunds should be refreshable" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/refunds/test_refund", nil, nil).
twice.returns(make_response(make_refund(:id => 'test_refund')),
make_response(make_refund(:id => 'refreshed_refund')))
refund = Stripe::Refund.retrieve('test_refund')
refund.refresh
assert_equal 'refreshed_refund', refund.id
end
should "refunds should be saveable" do
@mock.expects(:get).
with("#{Stripe.api_base}/v1/refunds/get_refund", nil, nil).
once.returns(make_response(make_refund(:id => 'save_refund')))
@mock.expects(:post).
with("#{Stripe.api_base}/v1/refunds/save_refund", nil, 'metadata[key]=value').
once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
stub_request(:get, "#{Stripe.api_base}/v1/refunds/get_refund").
to_return(body: JSON.generate(make_refund))
refund = Stripe::Refund.retrieve('get_refund')
assert_equal nil, refund.metadata['key']
stub_request(:post, "#{Stripe.api_base}/v1/refunds/#{refund.id}").
with(body: { metadata: { key: "value" } }).
to_return(body: JSON.generate(make_refund))
refund.metadata['key'] = 'value'
refund.save
assert_equal 'value', refund.metadata['key']
end
should "refunds should be updateable" do
@mock.expects(:post).
with("#{Stripe.api_base}/v1/refunds/update_refund", nil, 'metadata[key]=value').
once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
refund = Stripe::Refund.update('update_refund', metadata: {key: 'value'})
assert_equal 'value', refund.metadata['key']
stub_request(:post, "#{Stripe.api_base}/v1/refunds/update_refund").
with(body: { metadata: { key: "value" } }).
to_return(body: JSON.generate(make_refund))
_ = Stripe::Refund.update('update_refund', metadata: { key: 'value' })
end
should "create should return a new refund" do
@mock.expects(:post).
with("#{Stripe.api_base}/v1/refunds", nil, 'charge=test_charge').
once.returns(make_response(make_refund(:id => 'test_new_refund')))
refund = Stripe::Refund.create(:charge => 'test_charge')
assert_equal 'test_new_refund', refund.id
stub_request(:post, "#{Stripe.api_base}/v1/refunds").
with(body: { charge: "test_charge" }).
to_return(body: JSON.generate(make_refund))
_ = Stripe::Refund.create(:charge => 'test_charge')
end
end
end

39
test/stripe/reversal_test.rb
View File

@ -3,45 +3,34 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ReversalTest < Test::Unit::TestCase
should "reversals should be listable" do
@mock.expects(:get).once.returns(make_response(make_transfer))
stub_request(:get, "#{Stripe.api_base}/v1/transfers/test_transfer").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.retrieve('test_transfer')
assert transfer.reversals.first.kind_of?(Stripe::Reversal)
end
should "reversals should be refreshable" do
@mock.expects(:get).twice.returns(make_response(make_transfer), make_response(make_reversal(:id => 'refreshed_reversal')))
transfer = Stripe::Transfer.retrieve('test_transfer')
reversal = transfer.reversals.first
reversal.refresh
assert_equal 'refreshed_reversal', reversal.id
end
should "reversals should be updateable" do
@mock.expects(:get).once.returns(make_response(make_transfer))
@mock.expects(:post).once.returns(make_response(make_reversal(:metadata => {'key' => 'value'})))
stub_request(:get, "#{Stripe.api_base}/v1/transfers/test_transfer").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.retrieve('test_transfer')
reversal = transfer.reversals.first
assert_equal nil, reversal.metadata['key']
stub_request(:post, "#{Stripe.api_base}/v1/transfers/#{transfer.id}/reversals/#{reversal.id}").
with(body: { metadata: { key: "value" } }).
to_return(body: JSON.generate(make_reversal))
reversal.metadata['key'] = 'value'
reversal.save
assert_equal 'value', reversal.metadata['key']
end
should "create should return a new reversal" do
@mock.expects(:get).once.returns(make_response(make_transfer))
@mock.expects(:post).once.returns(make_response(make_reversal(:id => 'test_new_reversal')))
stub_request(:get, "#{Stripe.api_base}/v1/transfers/test_transfer").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.retrieve('test_transfer')
reversals = transfer.reversals.create(:amount => 20)
assert_equal 'test_new_reversal', reversals.id
stub_request(:post, "#{Stripe.api_base}/v1/transfers/#{transfer.id}/reversals").
with(body: { amount: "20" }).
to_return(body: JSON.generate(make_reversal))
_ = transfer.reversals.create(:amount => 20)
end
end
end

22
test/stripe/sku_test.rb
View File

@ -3,8 +3,8 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class SKUTest < Test::Unit::TestCase
should "SKUs should be listable" do
@mock.expects(:get).once.
returns(make_response(make_sku_array("test_product")))
stub_request(:get, "#{Stripe.api_base}/v1/skus").
to_return(body: JSON.generate(make_sku_array("test_product")))
skus = Stripe::SKU.list
assert skus.data.kind_of? Array
skus.each do |sku|
@ -13,20 +13,20 @@ module Stripe
end
should "SKUs should be updateable" do
@mock.expects(:post).once.
with("#{Stripe.api_base}/v1/skus/test_sku", nil, 'metadata[foo]=bar').
returns(make_response(make_sku(:metadata => {foo: 'bar'})))
s = Stripe::SKU.update("test_sku", metadata: {foo: 'bar'})
assert_equal 'bar', s.metadata['foo']
stub_request(:post, "#{Stripe.api_base}/v1/skus/test_sku").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_sku))
_ = Stripe::SKU.update("test_sku", metadata: {foo: 'bar'})
end
should "SKUs should be deletable" do
@mock.expects(:get).once.returns(make_response(make_sku))
@mock.expects(:delete).once.returns(make_response(make_sku(:deleted => true)))
stub_request(:get, "#{Stripe.api_base}/v1/skus/test_sku").
to_return(body: JSON.generate(make_sku))
s = Stripe::SKU.retrieve("test_sku")
stub_request(:delete, "#{Stripe.api_base}/v1/skus/#{s.id}").
to_return(body: JSON.generate(make_sku(:deleted => true)))
s.delete
assert s.deleted
end
end

76
test/stripe/source_test.rb
View File

@ -3,54 +3,47 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class SourceTest < Test::Unit::TestCase
should 'be creatable' do
@mock.expects(:post).once.returns(make_response(make_source_card))
src = Stripe::Source.create(
stub_request(:post, "#{Stripe.api_base}/v1/sources").
with(body: { type: 'card', token: 'tok_test' }).
to_return(body: JSON.generate(make_source_card))
_ = Stripe::Source.create(
type: 'card',
token: 'tok_test',
)
assert_equal 'src_test_card', src.id
end
should 'be retrievable' do
@mock.expects(:get).once.returns(make_response(make_source_card))
src = Stripe::Source.retrieve('src_test_card')
assert_equal 'src_test_card', src.id
stub_request(:get, "#{Stripe.api_base}/v1/sources/source_test_card").
to_return(body: JSON.generate(make_source_card))
_ = Stripe::Source.retrieve('source_test_card')
end
should 'be updatable' do
@mock.expects(:post).once
.with(
"#{Stripe.api_base}/v1/sources/src_test_card",
nil,
'metadata[foo]=bar'
)
.returns(make_response(make_source_card(metadata: {foo: 'bar'})))
src = Stripe::Source.update('src_test_card', metadata: {foo: 'bar'})
assert_equal 'bar', src.metadata['foo']
stub_request(:post, "#{Stripe.api_base}/v1/sources/source_test_card").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_source_card))
_ = Stripe::Source.update('source_test_card', metadata: {foo: 'bar'})
end
should 'be saveable' do
@mock.expects(:get).once.returns(make_response(make_source_card))
src = Stripe::Source.retrieve('src_test_card')
stub_request(:get, "#{Stripe.api_base}/v1/sources/source_test_card").
to_return(body: JSON.generate(make_source_card))
source = Stripe::Source.retrieve('source_test_card')
@mock.expects(:post).once
.with(
"#{Stripe.api_base}/v1/sources/src_test_card",
nil,
'metadata[foo]=bar'
)
.returns(make_response(make_source_card(metadata: {foo: 'bar'})))
src.metadata['foo'] = 'bar'
src.save
assert_equal 'bar', src.metadata['foo']
stub_request(:post, "#{Stripe.api_base}/v1/sources/#{source.id}").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_source_card))
source.metadata['foo'] = 'bar'
source.save
end
should 'not be deletable' do
@mock.expects(:get).once.returns(make_response(make_source_card))
src = Stripe::Source.retrieve('src_test_card')
stub_request(:get, "#{Stripe.api_base}/v1/sources/source_test_card").
to_return(body: JSON.generate(make_source_card))
source = Stripe::Source.retrieve('source_test_card')
assert_raises NoMethodError do
src.delete
source.delete
end
end
@ -61,23 +54,14 @@ module Stripe
end
should 'be verifiable' do
@mock.expects(:get).once.returns(make_response(make_source_ach_debit))
src = Stripe::Source.retrieve('src_test_ach_debit')
stub_request(:get, "#{Stripe.api_base}/v1/sources/source_test_card").
to_return(body: JSON.generate(make_source_card))
source = Stripe::Source.retrieve('source_test_card')
@mock.expects(:post).once
.with(
'https://api.stripe.com/v1/sources/src_test_ach_debit/verify',
nil,
'values[]=32&values[]=45'
)
.returns(make_response(make_source_ach_debit(
verification: {
attempts_remaining: 0,
status: 'succeeded',
}
)))
src.verify(values: [32, 45])
assert_equal 'succeeded', src.verification.status
stub_request(:post, "#{Stripe.api_base}/v1/sources/#{source.id}/verify").
with(body: { amounts: ["1", "2"] }).
to_return(body: JSON.generate(make_source_card))
source.verify(:amounts => [1,2])
end
end
end

57
test/stripe/subscription_item_test.rb
View File

@ -3,17 +3,17 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class SubscriptionItemTest < Test::Unit::TestCase
should "subscription items should be retrievable" do
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item", nil, nil).
returns(make_response(make_subscription_item))
stub_request(:get, "#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item").
to_return(body: JSON.generate(make_subscription_item))
sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
assert sub_item.kind_of?(Stripe::SubscriptionItem)
end
should "subscription items should be listable" do
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items?subscription=s_test_subscription&limit=3", nil, nil).
returns(make_response(make_subscription_item_array))
stub_request(:get, "#{Stripe.api_base}/v1/subscription_items").
with(query: { subscription: "s_test_subscription", limit: "3" }).
to_return(body: JSON.generate(make_subscription_item_array))
sub_items = Stripe::SubscriptionItem.list(:subscription => 's_test_subscription', :limit => 3).data
assert sub_items.kind_of? Array
@ -21,56 +21,43 @@ module Stripe
end
should "subscription items should be deletable" do
@mock.expects(:get).once.returns(make_response(make_subscription_item))
stub_request(:get, "#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item").
to_return(body: JSON.generate(make_subscription_item))
sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}", nil, nil).
returns(make_response(make_subscription_item))
stub_request(:delete, "#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}").
to_return(body: JSON.generate(make_subscription_item))
sub_item.delete
end
should "subscription items should be updateable" do
sid = 'si_test_subscription_item'
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscription_items/#{sid}" &&
api_key.nil? &&
CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
stub_request(:post, "#{Stripe.api_base}/v1/subscription_items/#{sid}").
with(body: { plan: "silver", quantity: "3" }).
to_return(body: JSON.generate(make_subscription_item))
sub_item = Stripe::SubscriptionItem.update(sid, {:plan => 'silver', :quantity => 3})
assert_equal 'silver', sub_item.plan.id
assert_equal 3, sub_item.quantity
_ = Stripe::SubscriptionItem.update(sid, {:plan => 'silver', :quantity => 3})
end
should "subscription items should be saveable" do
@mock.expects(:get).once.returns(make_response(make_subscription_item))
stub_request(:get, "#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item").
to_return(body: JSON.generate(make_subscription_item))
sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}" &&
api_key.nil? &&
CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
stub_request(:post, "#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}").
with(body: { plan: "silver", quantity: "3" }).
to_return(body: JSON.generate(make_subscription_item))
sub_item.plan = 'silver'
sub_item.quantity = 3
sub_item.save
assert_equal 'silver', sub_item.plan.id
assert_equal 3, sub_item.quantity
end
should "create should return a new subscription item" do
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscription_items" && api_key.nil? &&
CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
stub_request(:post, "#{Stripe.api_base}/v1/subscription_items").
with(body: { plan: "silver", quantity: "3" }).
to_return(body: JSON.generate(make_subscription_item))
sub_item = Stripe::SubscriptionItem.create(:plan => 'silver', :quantity => 3)
assert_equal 'silver', sub_item.plan.id
assert_equal 3, sub_item.quantity
_ = Stripe::SubscriptionItem.create(:plan => 'silver', :quantity => 3)
end
end
end

163
test/stripe/subscription_test.rb
View File

@ -3,19 +3,23 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class SubscriptionTest < Test::Unit::TestCase
should "subscriptions should be retrievable by customer" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
to_return(body: JSON.generate(make_customer))
customer = Stripe::Customer.retrieve('c_test_customer')
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription(:id => 's_test_subscription')))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/s_test_subscription").
to_return(body: JSON.generate(make_subscription))
_ = customer.subscriptions.retrieve('s_test_subscription')
end
should "subscriptions should be listable by customer" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
to_return(body: JSON.generate(make_customer))
customer = Stripe::Customer.retrieve('c_test_customer')
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, nil).returns(make_response(make_customer_subscription_array('c_test_customer')))
subs = customer.subscriptions.all()
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions").
to_return(body: JSON.generate(make_customer_subscription_array('c_test_customer')))
subs = customer.subscriptions.list
assert subs.kind_of?(Stripe::ListObject)
assert subs.data.kind_of?(Array)
@ -23,24 +27,27 @@ module Stripe
end
should "subscriptions should be creatable by customer" do
@mock.expects(:get).once.returns(make_response(make_customer))
stub_request(:get, "#{Stripe.api_base}/v1/customers/c_test_customer").
to_return(body: JSON.generate(make_customer))
customer = Stripe::Customer.retrieve('c_test_customer')
@mock.expects(:post).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, 'plan=silver').returns(make_response(make_subscription(:id => 'test_new_subscription')))
subscription = customer.subscriptions.create(:plan => 'silver')
assert_equal 'test_new_subscription', subscription.id
stub_request(:post, "#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions").
with(body: { plan: "silver" }).
to_return(body: JSON.generate(make_subscription))
_ = customer.subscriptions.create(:plan => 'silver')
end
should "subscriptions should be retrievable" do
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions/s_test_subscription").
to_return(body: JSON.generate(make_subscription))
sub = Stripe::Subscription.retrieve('s_test_subscription')
assert sub.kind_of?(Stripe::Subscription)
end
should "subscriptions should be listable" do
@mock.expects(:get).once.returns(make_response(make_subscription_array))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions").
to_return(body: JSON.generate(make_subscription_array))
subs = Stripe::Subscription.list.data
assert subs.kind_of? Array
@ -48,7 +55,9 @@ module Stripe
end
should "subscriptions should be listable with filters" do
@mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions?customer=c_test_customer&limit=3&plan=gold", nil, nil).returns(make_response(make_subscription_array))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions").
with(query: { customer: "c_test_customer", limit: "3", plan: "gold" }).
to_return(body: JSON.generate(make_subscription_array))
subs = Stripe::Subscription.all(:customer => 'c_test_customer', :limit => 3, :plan => 'gold')
assert subs.kind_of?(Stripe::ListObject)
@ -57,138 +66,70 @@ module Stripe
end
should "subscriptions should be refreshable" do
@mock.expects(:get).twice.returns(make_response(make_subscription(:id => 'refreshed_subscription')))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions/s_test_subscription").
to_return(body: JSON.generate(make_subscription))
sub = Stripe::Subscription.retrieve('s_test_subscription')
sub.refresh
assert_equal 'refreshed_subscription', sub.id
end
should "subscriptions should be deletable" do
@mock.expects(:get).once.returns(make_response(make_subscription))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions/s_test_subscription").
to_return(body: JSON.generate(make_subscription))
sub = Stripe::Subscription.retrieve('s_test_subscription')
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}?at_period_end=true", nil, nil).returns(make_response(make_subscription))
stub_request(:delete, "#{Stripe.api_base}/v1/subscriptions/#{sub.id}").
with(query: { at_period_end: "true" }).
to_return(body: JSON.generate(make_subscription))
sub.delete :at_period_end => true
@mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}", nil, nil).returns(make_response(make_subscription))
stub_request(:delete, "#{Stripe.api_base}/v1/subscriptions/#{sub.id}").
to_return(body: JSON.generate(make_subscription))
sub.delete
end
should "subscriptions should be updateable" do
sid = 's_test_subscription'
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
end.returns(make_response(make_subscription(:status => 'active')))
sub = Stripe::Subscription.update(sid, :status => 'active')
assert_equal 'active', sub.status
stub_request(:post, "#{Stripe.api_base}/v1/subscriptions/#{sid}").
with(body: { status: "active" }).
to_return(body: JSON.generate(make_subscription))
_ = Stripe::Subscription.update(sid, :status => 'active')
end
should "subscription items should be updateable" do
sid = 's_test_subscription'
items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
api_key.nil? &&
CGI.parse(params) == {
'items[0][plan]' => ['gold'],
'items[0][quantity]' => ['1'],
'items[1][plan]' => ['silver'],
'items[1][quantity]' => ['2'],
}
end.returns(make_response(make_subscription(:items => items)))
sub = Stripe::Subscription.update(sid, :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
assert_equal 'gold', sub.items.data[0].plan.id
assert_equal 1, sub.items.data[0].quantity
assert_equal 'silver', sub.items.data[1].plan.id
assert_equal 2, sub.items.data[1].quantity
end
should "subscription items should be updateable with hash" do
sid = 's_test_subscription'
items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
api_key.nil? &&
CGI.parse(params) == {
'items[0][plan]' => ['gold'],
'items[0][quantity]' => ['1'],
'items[1][plan]' => ['silver'],
'items[1][quantity]' => ['2'],
}
end.returns(make_response(make_subscription(:items => items)))
sub = Stripe::Subscription.update(sid, :items => {'0' => {:plan => 'gold', :quantity =>1}, '1' => {:plan => 'silver', :quantity =>2}})
assert_equal 'gold', sub.items.data[0].plan.id
assert_equal 1, sub.items.data[0].quantity
assert_equal 'silver', sub.items.data[1].plan.id
assert_equal 2, sub.items.data[1].quantity
stub_request(:post, "#{Stripe.api_base}/v1/subscriptions/#{sid}").
with(body: { items: [{plan: "gold", quantity: "1"}, {plan: "silver", quantity: "2" }] }).
to_return(body: JSON.generate(make_subscription))
_ = Stripe::Subscription.update(sid, :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
end
should "subscriptions should be saveable" do
@mock.expects(:get).once.returns(make_response(make_subscription))
stub_request(:get, "#{Stripe.api_base}/v1/subscriptions/s_test_subscription").
to_return(body: JSON.generate(make_subscription))
sub = Stripe::Subscription.retrieve('s_test_subscription')
assert_equal 'trialing', sub.status
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions/#{sub.id}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
end.returns(make_response(make_subscription(:status => 'active')))
stub_request(:post, "#{Stripe.api_base}/v1/subscriptions/#{sub.id}").
with(body: { status: "active" }).
to_return(body: JSON.generate(make_subscription))
sub.status = 'active'
sub.save
assert_equal 'active', sub.status
end
should "create should return a new subscription" do
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions" && api_key.nil? && CGI.parse(params) == {'customer' => ['c_test_customer'], 'plan' => ['gold']}
end.returns(make_response(make_subscription(:plan => 'gold', :id => 'test_new_subscription')))
sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer')
assert_equal 'test_new_subscription', sub.id
assert_equal 'gold', sub.plan.identifier
end
should "create with items should return a new subscription" do
items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
@mock.expects(:post).once.with do |url, api_key, params|
url == "#{Stripe.api_base}/v1/subscriptions" &&
api_key.nil? &&
CGI.parse(params) == {
'customer' => ['c_test_customer'],
'items[0][plan]' => ['gold'],
'items[0][quantity]' => ['1'],
'items[1][plan]' => ['silver'],
'items[1][quantity]' => ['2'],
}
end.returns(make_response(make_subscription(:items => items, :id => 'test_new_subscription')))
sub = Stripe::Subscription.create(:customer => 'c_test_customer', :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
assert_equal 'test_new_subscription', sub.id
assert_equal 'gold', sub.items.data[0].plan.id
assert_equal 1, sub.items.data[0].quantity
assert_equal 'silver', sub.items.data[1].plan.id
assert_equal 2, sub.items.data[1].quantity
stub_request(:post, "#{Stripe.api_base}/v1/subscriptions").
with(body: { customer: "c_test_customer", plan: "gold" }).
to_return(body: JSON.generate(make_subscription))
_ = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer')
end
should "be able to delete a subscriptions's discount" do
@mock.expects(:post).once.returns(make_response(make_subscription))
stub_request(:post, "#{Stripe.api_base}/v1/subscriptions").
to_return(body: JSON.generate(make_subscription))
sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer', coupon: 'forever')
url = "#{Stripe.api_base}/v1/subscriptions/#{sub.id}/discount"
@mock.expects(:delete).once.with(url, nil, nil).returns(make_response(make_delete_discount_response))
stub_request(:delete, "#{Stripe.api_base}/v1/subscriptions/#{sub.id}/discount").
to_return(body: JSON.generate(make_delete_discount_response))
sub.delete_discount
assert_equal nil, sub.discount
end

10
test/stripe/three_d_secure_test.rb
View File

@ -3,20 +3,22 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class ThreeDSecureTest < Test::Unit::TestCase
should "retrieve an existing 3D Secure object" do
@mock.expects(:get).once.returns(make_response(make_three_d_secure))
stub_request(:get, "#{Stripe.api_base}/v1/3d_secure/tdsrc_test").
to_return(body: JSON.generate(make_three_d_secure))
tds = Stripe::ThreeDSecure.retrieve("tdsrc_test")
assert_equal "tdsrc_test", tds.id
end
should "create should return a new 3D Secure object" do
@mock.expects(:post).once.returns(make_response(make_three_d_secure))
tds = Stripe::ThreeDSecure.create(
stub_request(:post, "#{Stripe.api_base}/v1/3d_secure").
with(body: { card: "tok_test", amount: "1500", currency: "usd", return_url: "https://example.org/3d-secure-result" }).
to_return(body: JSON.generate(make_three_d_secure))
_ = Stripe::ThreeDSecure.create(
:card => "tok_test",
:amount => 1500,
:currency => "usd",
:return_url => "https://example.org/3d-secure-result"
)
assert_equal "tdsrc_test", tds.id
end
end
end

21
test/stripe/transfer_test.rb
View File

@ -3,30 +3,33 @@ require File.expand_path('../../test_helper', __FILE__)
module Stripe
class TransferTest < Test::Unit::TestCase
should "retrieve should retrieve transfer" do
@mock.expects(:get).once.returns(make_response(make_transfer))
stub_request(:get, "#{Stripe.api_base}/v1/transfers/tr_test_transfer").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.retrieve('tr_test_transfer')
assert_equal 'tr_test_transfer', transfer.id
end
should "create should create a transfer" do
@mock.expects(:post).once.returns(make_response(make_transfer))
stub_request(:post, "#{Stripe.api_base}/v1/transfers").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.create
assert_equal "tr_test_transfer", transfer.id
end
should "create should update a transfer" do
@mock.expects(:post).once.
with("#{Stripe.api_base}/v1/transfers/test_transfer", nil, "metadata[foo]=bar").
returns(make_response(make_transfer(metadata: {foo: 'bar'})))
transfer = Stripe::Transfer.update("test_transfer", metadata: {foo: 'bar'})
assert_equal "bar", transfer.metadata['foo']
stub_request(:post, "#{Stripe.api_base}/v1/transfers/test_transfer").
with(body: { metadata: { foo: "bar" } }).
to_return(body: JSON.generate(make_transfer))
Stripe::Transfer.update("test_transfer", metadata: {foo: 'bar'})
end
should "cancel should cancel a transfer" do
@mock.expects(:get).once.returns(make_response(make_transfer))
stub_request(:get, "#{Stripe.api_base}/v1/transfers/tr_test_transfer").
to_return(body: JSON.generate(make_transfer))
transfer = Stripe::Transfer.retrieve('tr_test_transfer')
@mock.expects(:post).once.with('https://api.stripe.com/v1/transfers/tr_test_transfer/cancel', nil, '').returns(make_response(make_canceled_transfer))
stub_request(:post, "#{Stripe.api_base}/v1/transfers/tr_test_transfer/cancel").
to_return(body: JSON.generate(make_canceled_transfer))
transfer.cancel
end
end

11
test/stripe_test.rb
View File

@ -35,16 +35,11 @@ class StripeTest < Test::Unit::TestCase
end
should "makes requests with the Stripe-Account header" do
response = make_account(
charges_enabled: false,
details_submitted: false,
email: "test+bindings@stripe.com"
)
Stripe.stripe_account = 'acct_1234'
Stripe.expects(:execute_request).with(
has_entry(:headers, has_entry('Stripe-Account', 'acct_1234')),
).returns(make_response(response))
stub_request(:post, "#{Stripe.api_base}/v1/account").
with(headers: {"Stripe-Account" => Stripe.stripe_account}).
to_return(body: JSON.generate(make_account))
Stripe.request(:post, '/v1/account', 'sk_live12334566')
end

30
test/test_data.rb
View File

@ -1,21 +1,5 @@
module Stripe
module TestData
def make_response(body, code=200)
# When an exception is raised, restclient clobbers method_missing. Hence we
# can't just use the stubs interface.
body = JSON.generate(body) if !(body.kind_of? String)
m = mock
m.instance_variable_set('@stripe_values', {
:body => body,
:code => code,
:headers => {},
})
def m.body; @stripe_values[:body]; end
def m.code; @stripe_values[:code]; end
def m.headers; @stripe_values[:headers]; end
m
end
def make_account(params={})
{
:charges_enabled => false,
@ -390,18 +374,6 @@ module Stripe
}.merge(params)
end
def make_paid_invoice
make_invoice.merge({
:attempt_count => 1,
:attempted => true,
:closed => true,
:paid => true,
:charge => 'ch_test_charge',
:ending_balance => 0,
:next_payment_attempt => nil,
})
end
def make_invoice_item(params={})
{
id: "ii_test_invoice_item",
@ -774,7 +746,7 @@ module Stripe
}
end
def country_spec_array
def make_country_spec_array
{
:object => "list",
:resource_url => "/v1/country_specs",

27
test/test_helper.rb
View File

@ -3,43 +3,18 @@ require 'test/unit'
require 'mocha/setup'
require 'stringio'
require 'shoulda/context'
require 'webmock/test_unit'
require File.expand_path('../test_data', __FILE__)
# monkeypatch request methods
module Stripe
@mock_rest_client = nil
def self.mock_rest_client=(mock_client)
@mock_rest_client = mock_client
end
class << self
remove_method :execute_request
end
def self.execute_request(opts)
get_params = (opts[:headers] || {})[:params]
post_params = opts[:payload]
case opts[:method]
when :get then @mock_rest_client.get opts[:url], get_params, post_params
when :post then @mock_rest_client.post opts[:url], get_params, post_params
when :delete then @mock_rest_client.delete opts[:url], get_params, post_params
end
end
end
class Test::Unit::TestCase
include Stripe::TestData
include Mocha
setup do
@mock = mock
Stripe.mock_rest_client = @mock
Stripe.api_key = "foo"
end
teardown do
Stripe.mock_rest_client = nil
Stripe.api_key = nil
end
end