pin_up 1.3.4 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,8 +1,46 @@
1
1
  require 'spec_helper'
2
2
 
3
3
  describe 'Customer', :vcr, class: Pin::Customer do
4
+ let(:card_1) {
5
+ { number: '5520000000000000',
6
+ expiry_month: '12',
7
+ expiry_year: '2025',
8
+ cvc: '123',
9
+ name: 'Roland Robot',
10
+ address_line1: '123 Fake Street',
11
+ address_city: 'Melbourne',
12
+ address_postcode: '1234',
13
+ address_state: 'Vic',
14
+ address_country: 'Australia' }
15
+ }
16
+
17
+ let(:card_2) {
18
+ { number: '4200000000000000',
19
+ expiry_month: '12',
20
+ expiry_year: '2020',
21
+ cvc: '111',
22
+ name: 'Roland TestRobot',
23
+ address_line1: '123 Fake Road',
24
+ address_line2: '',
25
+ address_city: 'Melbourne',
26
+ address_postcode: '1223',
27
+ address_state: 'Vic',
28
+ address_country: 'AU' }
29
+ }
30
+
31
+ let(:customer_token) {
32
+ Pin::Customer.create('email@example.com', card_1)['token']
33
+ }
34
+
4
35
  before(:each) do
5
36
  Pin::Base.new(ENV['PIN_SECRET'], :test)
37
+ Pin::Charges.create(email: 'email@example.com',
38
+ description: 'Charge description',
39
+ amount: '500',
40
+ currency: 'AUD',
41
+ number: '5520000000000000',
42
+ ip_address: '203.192.1.172',
43
+ customer_token: customer_token)
6
44
  end
7
45
 
8
46
  it 'should list customers' do
@@ -25,65 +63,56 @@ describe 'Customer', :vcr, class: Pin::Customer do
25
63
  end
26
64
 
27
65
  it 'should not list customers on a page given a page if there are no customers' do
28
- request = Pin::Customer.all(25, true)
66
+ request = Pin::Customer.all(900, true)
29
67
  expect(request[:response]).to eq []
30
68
  end
31
69
 
32
70
  it 'should show a customer given a token' do
33
- expect(Pin::Customer.find('cus_6XnfOD5bvQ1qkaf3LqmhfQ')['token']).to eq 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
71
+ expect(Pin::Customer.find(customer_token)['token']).to eq(customer_token)
34
72
  end
35
73
 
36
74
  it 'should list charges to a customer given a token' do
37
- expect(Pin::Customer.charges('cus_6XnfOD5bvQ1qkaf3LqmhfQ')[0]['token']).to match(/^[a-z]{2}[_]/)
75
+ Pin::Customer.charges(customer_token)
76
+ expect(Pin::Customer.charges(customer_token)[0]['token']).to match(/^[a-z]{2}[_]/)
38
77
  end
39
78
 
40
79
  it 'should show pagination on a page given a token and a page' do
41
- expect(Pin::Customer.charges('cus_6XnfOD5bvQ1qkaf3LqmhfQ', 5, true)[:pagination]['current']).to eq 5
80
+ expect(Pin::Customer.charges(customer_token, 5, true)[:pagination]['current']).to eq 5
42
81
  end
43
82
 
44
83
  it 'should list charges to a customer on a page given a token and a page' do
45
- expect(Pin::Customer.charges('cus_6XnfOD5bvQ1qkaf3LqmhfQ', 1, true)[:response][0]['token']).to match(/^[a-z]{2}[_]/)
84
+ expect(Pin::Customer.charges(customer_token, 1, true)[:response][0]['token']).to match(/^[a-z]{2}[_]/)
46
85
  end
47
86
 
48
87
  it 'should create a customer given an email and card details' do
49
- expect(Pin::Customer.create('email@example.com', number: '5520000000000000', expiry_month: '12', expiry_year: '2016', cvc: '123', name: 'Roland Robot', address_line1: '123 fake street', address_city: 'Melbourne', address_postcode: '1234', address_state: 'Vic', address_country: 'Australia')['token']).to match(/^[a-z]{3}[_]/)
88
+ expect(Pin::Customer.create('email@example.com', card_1)['token']).to match(/^[a-z]{3}[_]/)
50
89
  end
51
90
 
52
91
  it 'should update a customer given a token and details to update' do
53
- options = { email: 'email@example.com', card: { number: '5520000000000000', address_line1: '12345 Fake Street', expiry_month: '05', expiry_year: Time.now.year+1, cvc: '123', name: 'Daniel Nitsikopoulos', address_city: 'Melbourne', address_postcode: '1234', address_state: 'VIC', address_country: 'Australia' } }
54
- expect(Pin::Customer.update('cus_6XnfOD5bvQ1qkaf3LqmhfQ', options)['card']['address_line1']).to eq '12345 Fake Street'
92
+ expect(Pin::Customer.update(customer_token, card_1)['card']['address_line1']).to eq '123 Fake Street'
55
93
  end
56
94
 
57
95
  it 'should create a customer given a card token customer email' do
58
- options = { number: '5520000000000000', expiry_month: '12', expiry_year: '2018', cvc: '123', name: 'Roland TestRobot', address_line1: '123 Fake Road', address_line2: '', address_city: 'Melbourne', address_postcode: '1223', address_state: 'Vic', address_country: 'AU' }
59
- @card = Pin::Card.create(options)
96
+ @card = Pin::Card.create(card_1)
60
97
  expect(Pin::Customer.create('nitza98@hotmail.com', @card['token'])['token']).to match(/^[a-z]{3}[_]/)
61
98
  end
62
99
 
63
100
  it 'should list all cards belonging to this customer' do
64
- token = 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
65
- expect(Pin::Customer.cards(token).first['token']).to match(/(card)[_]([\w-]{22})/)
101
+ expect(Pin::Customer.cards(customer_token).first['token']).to match(/(card)[_]([\w-]{22})/)
66
102
  end
67
103
 
68
104
  it 'should create a card given customer token and card hash' do
69
- customer_token = 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
70
- card = { publishable_api_key: ENV['PUBLISHABLE_SECRET'], number: '5520000000000000', expiry_month: '12', expiry_year: '2018', cvc: '123', name: 'Roland TestRobot', address_line1: '123 Fake Road', address_line2: '', address_city: 'Melbourne', address_postcode: '1223', address_state: 'Vic', address_country: 'AU' }
71
- expect(Pin::Customer.create_card(customer_token, card)['token']).to match(/(card)[_]([\w-]{22})/)
105
+ expect(Pin::Customer.create_card(customer_token, card_1)['token']).to match(/(card)[_]([\w-]{22})/)
72
106
  end
73
107
 
74
108
  it 'should create a card then add it to a customer' do
75
- options = { number: '5520000000000000', expiry_month: '12', expiry_year: '2018', cvc: '123', name: 'Roland Robot', address_line1: '123 Fake Road', address_line2: '', address_city: 'Melbourne', address_postcode: '1223', address_state: 'Vic', address_country: 'AU' }
76
- card_token = Pin::Card.create(options)['token']
77
- customer_token = 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
78
- expect(Pin::Customer.create_card(customer_token, card_token)['token']).to match(/(card)[_]([\w-]{22})/)
109
+ added_card = Pin::Customer.create_card(customer_token, card_2)
110
+ expect(added_card['token']).to match(/(card)[_]([\w-]{22})/)
79
111
  end
80
112
 
81
113
  it 'should delete a card given a token' do
82
- options = { number: '5520000000000000', expiry_month: '12', expiry_year: '2018', cvc: '123', name: 'Roland Robot', address_line1: '123 Fake Road', address_line2: '', address_city: 'Melbourne', address_postcode: '1223', address_state: 'Vic', address_country: 'AU' }
83
- card_token = Pin::Card.create(options)['token']
84
- customer_token = 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
114
+ card_token = Pin::Card.create(card_2)['token']
85
115
  Pin::Customer.create_card(customer_token, card_token)
86
116
  expect(Pin::Customer.delete_card(customer_token, card_token).code).to eq 204
87
117
  end
88
-
89
118
  end
@@ -1,29 +1,48 @@
1
1
  require 'spec_helper'
2
2
 
3
3
  describe 'Errors', :vcr, class: Pin::PinError do
4
- before(:each) do
5
- Pin::Base.new(ENV['PIN_SECRET'], :test)
6
- end
4
+ let(:card_1) {
5
+ { number: '5520000000000000',
6
+ expiry_month: '12',
7
+ expiry_year: '2025',
8
+ cvc: '123',
9
+ name: 'Roland Robot',
10
+ address_line1: '123 Fake Street',
11
+ address_city: 'Melbourne',
12
+ address_postcode: '1234',
13
+ address_state: 'Vic',
14
+ address_country: 'Australia' }
15
+ }
7
16
 
8
- it 'should raise a 404 error when looking for a customer that doesn\'t exist' do
9
- expect { Pin::Customer.find('foo') }.to raise_error do |error|
10
- expect(error).to be_a Pin::ResourceNotFound
11
- expect(error.message).to eq 'The requested resource could not be found.'
12
- expect(error.response).to be_a Hash
13
- end
14
- end
17
+ let(:card_2) {
18
+ { number: '4200000000000000',
19
+ expiry_month: '12',
20
+ expiry_year: '2020',
21
+ cvc: '111',
22
+ name: 'Roland TestRobot',
23
+ address_line1: '123 Fake Road',
24
+ address_line2: '',
25
+ address_city: 'Melbourne',
26
+ address_postcode: '1223',
27
+ address_state: 'Vic',
28
+ address_country: 'AU' }
29
+ }
15
30
 
16
- it 'should raise a 422 error when trying to update missing a param' do
17
- options = { email: 'email@example.com', card: { address_line1: '12345 Fake Street', expiry_month: '05', expiry_year: Time.now.year+1, cvc: '123', address_city: 'Melbourne', address_postcode: '1234', address_state: 'VIC', address_country: 'Australia' } }
18
- expect { Pin::Customer.update('cus_6XnfOD5bvQ1qkaf3LqmhfQ', options) }.to raise_error do |error|
19
- expect(error).to be_a Pin::InvalidResource
20
- expect(error.message).to eq "card_number_invalid: Card number can't be blank card_name_invalid: Card name can't be blank "
21
- expect(error.response).to be_a Hash
22
- end
23
- end
31
+ let(:card_2_token) {
32
+ Pin::Card.create(card_2)['token']
33
+ }
24
34
 
25
- it 'should raise a 422 error when trying to make a payment with an expired card' do
26
- options = { email: 'email@example.com', description: 'A new charge from testing Pin gem', amount: '400', currency: 'AUD', ip_address: '127.0.0.1', card: {
35
+ let(:customer_token) {
36
+ Pin::Customer.create('email@example.com', card_1)['token']
37
+ }
38
+
39
+ let(:charge_hash) {
40
+ { email: 'email@example.com',
41
+ description: 'A new charge from testing Pin gem',
42
+ amount: '400',
43
+ currency: 'AUD',
44
+ ip_address: '127.0.0.1',
45
+ card: {
27
46
  number: '5520000000000000',
28
47
  expiry_month: '05',
29
48
  expiry_year: '2012',
@@ -35,18 +54,18 @@ describe 'Errors', :vcr, class: Pin::PinError do
35
54
  address_state: 'WA',
36
55
  address_country: 'Australia'
37
56
  } }
38
- expect { Pin::Charges.create(options) }.to raise_error do |error|
39
- expect(error).to be_a Pin::InvalidResource
40
- expect(error.message).to eq 'card_expiry_month_invalid: Card expiry month is expired card_expiry_year_invalid: Card expiry year is expired '
41
- expect(error.response).to be_a Hash
42
- end
43
- end
57
+ }
44
58
 
45
- it 'should raise a 400 error when trying to make a payment and a valid card gets declined' do
46
- options = { email: 'email@example.com', description: 'A new charge from testing Pin gem', amount: '400', currency: 'AUD', ip_address: '127.0.0.1', card: {
59
+ let(:hash_of_details) {
60
+ { email: 'email@example.com',
61
+ description: 'A new charge from testing Pin gem',
62
+ amount: '400',
63
+ currency: 'AUD',
64
+ ip_address: '127.0.0.1',
65
+ card: {
47
66
  number: '5560000000000001',
48
- expiry_month: '05',
49
- expiry_year: '2018',
67
+ expiry_month: '12',
68
+ expiry_year: '2025',
50
69
  cvc: '123',
51
70
  name: 'Roland Robot',
52
71
  address_line1: '42 Sevenoaks St',
@@ -55,25 +74,76 @@ describe 'Errors', :vcr, class: Pin::PinError do
55
74
  address_state: 'WA',
56
75
  address_country: 'Australia'
57
76
  } }
58
- expect { Pin::Charges.create(options) }.to raise_error(Pin::ChargeError)
77
+ }
78
+
79
+ let(:charge) {
80
+ Pin::Charges.create(email: 'email@example.com',
81
+ description: 'Charge description',
82
+ amount: '500',
83
+ currency: 'AUD',
84
+ number: '5520000000000000',
85
+ ip_address: '203.192.1.172',
86
+ customer_token: customer_token)
87
+ }
88
+
89
+ let(:time) { Time.now.iso8601(4) }
90
+
91
+ let(:plan) {
92
+ { name: "Plan#{time}",
93
+ amount: '1000',
94
+ currency: 'AUD',
95
+ interval: 30,
96
+ interval_unit: 'day',
97
+ setup_amount: 0,
98
+ trial_amount: 0,
99
+ trial_interval: 7,
100
+ trial_interval_unit: 'day' }
101
+ }
102
+
103
+ let(:plan_token) {
104
+ Pin::Plan.create(plan)['token']
105
+ }
106
+
107
+ let(:subscription_1) {
108
+ { plan_token: plan_token,
109
+ customer_token: customer_token,
110
+ include_setup_fee: false }
111
+ }
112
+
113
+ let(:subscription_1_token) {
114
+ Pin::Subscription.create(subscription_1)['token']
115
+ }
116
+
117
+ before(:each) do
118
+ Pin::Base.new(ENV['PIN_SECRET'], :test)
59
119
  end
60
120
 
61
- it 'should raise a 422 error when trying to make a payment with an invalid card' do
62
- options = { email: 'email@example.com', description: 'A new charge from testing Pin gem', amount: '400', currency: 'AUD', ip_address: '127.0.0.1', card: {
63
- number: '5520000000000099',
64
- expiry_month: '05',
65
- expiry_year: '2019',
66
- cvc: '123',
67
- name: 'Roland Robot',
68
- address_line1: '42 Sevenoaks St',
69
- address_city: 'Lathlain',
70
- address_postcode: '6454',
71
- address_state: 'WA',
72
- address_country: 'Australia'
73
- } }
74
- expect { Pin::Charges.create(options) }.to raise_error do |error|
121
+ ###
122
+ # Customer Errors
123
+ ###
124
+ it 'should raise a 400 error when attempting to delete customer\'s primary card' do
125
+ cards = Pin::Customer.cards(customer_token)
126
+ primary_card_token = cards.select{|card| card['primary'] }.first['token']
127
+ expect { Pin::Customer.delete_card(customer_token, primary_card_token) }.to raise_error do |error|
75
128
  expect(error).to be_a Pin::InvalidResource
76
- expect(error.message).to eq 'card_number_invalid: Card number is not valid '
129
+ expect(error.message).to eq 'You cannot delete a customer\'s primary card token'
130
+ expect(error.response).to be_a Hash
131
+ end
132
+ end
133
+
134
+ it 'should raise a 404 error when looking for a customer that doesn\'t exist' do
135
+ expect { Pin::Customer.find('foo') }.to raise_error do |error|
136
+ expect(error).to be_a Pin::ResourceNotFound
137
+ expect(error.message).to eq 'The requested resource could not be found.'
138
+ expect(error.response).to be_a Hash
139
+ end
140
+ end
141
+
142
+ it 'should raise an Unauthorized error when token is invalid' do
143
+ Pin::Base.new('arbitrary_token', :test)
144
+ expect { Pin::Customer.charges('foo') }.to raise_error do |error|
145
+ expect(error).to be_a Pin::Unauthorized
146
+ expect(error.message).to eq 'Not authorised. (Check API Key)'
77
147
  expect(error.response).to be_a Hash
78
148
  end
79
149
  end
@@ -86,35 +156,198 @@ describe 'Errors', :vcr, class: Pin::PinError do
86
156
  end
87
157
  end
88
158
 
159
+ it 'should raise a 422 error when trying to update missing a param' do
160
+ hash_w_no_credit_card_or_name = hash_of_details.tap do |h|
161
+ h[:card][:number] = ''
162
+ h[:card][:name] = ''
163
+ end
164
+ expect { Pin::Customer.update(customer_token, hash_w_no_credit_card_or_name) }.to raise_error do |error|
165
+ expect(error).to be_a Pin::InvalidResource
166
+ expect(error.response['messages']).to be_a Array
167
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Card number can't be blank")
168
+ expect(error.response['messages'][1]).to match a_hash_including("message"=>"Card name can't be blank")
169
+ end
170
+ end
171
+
172
+ ###
173
+ # Charge Errors
174
+ ###
175
+ it 'should raise a 422 error when trying to make a payment with an expired card' do
176
+ hash_w_expired_credit_card = hash_of_details.tap do |h|
177
+ h[:card][:expiry_year] = '2001'
178
+ end
179
+ expect { Pin::Charges.create(hash_w_expired_credit_card) }.to raise_error do |error|
180
+ expect(error).to be_a Pin::InvalidResource
181
+ expect(error.response['messages']).to be_a Array
182
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Card expiry month is expired")
183
+ expect(error.response['messages'][1]).to match a_hash_including("message"=>"Card expiry year is expired")
184
+ end
185
+ end
186
+
187
+ it 'should raise a 400 error when trying to make a payment and a valid card gets declined' do
188
+ hash_w_card_declined = hash_of_details.tap do |h|
189
+ h[:card][:number] = '5560000000000001'
190
+ end
191
+ expect { Pin::Charges.create(hash_w_card_declined) }.to raise_error(Pin::ChargeError)
192
+ end
193
+
194
+ it 'should raise a 422 error when trying to make a payment with an invalid card' do
195
+ hash_w_invalid_card = hash_of_details.tap do |h|
196
+ h[:card][:number] = '5520000000000099'
197
+ end
198
+ expect { Pin::Charges.create(hash_w_invalid_card) }.to raise_error do |error|
199
+ expect(error).to be_a Pin::InvalidResource
200
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Card number is not valid")
201
+ end
202
+ end
203
+
204
+ ###
205
+ # Refund Errors
206
+ ###
89
207
  it 'should raise a 422 error if no 2nd argument is given' do
90
- customer = Pin::Customer.create('email@example.com', number: '5520000000000000', expiry_month: '12', expiry_year: Time.now.year+1, cvc: '123', name: 'Roland Robot', address_line1: '123 fake street', address_city: 'Melbourne', address_postcode: '1234', address_state: 'Vic', address_country: 'Australia')
91
- options = { email: 'email@example.com', description: 'A new charge from testing Pin gem', amount: '400', currency: 'AUD', ip_address: '127.0.0.1', customer_token: customer['token'] }
92
- @charge = Pin::Charges.create(options)
93
- expect { Pin::Refund.create(@charge['token']) }.to raise_error do |error|
208
+ expect { Pin::Refund.create(charge['token']) }.to raise_error do |error|
94
209
  expect(error).to be_a Pin::InvalidResource
95
210
  expect(error.message).to eq "amount_invalid: Amount can't be blank amount_invalid: Amount is not a number "
96
211
  expect(error.response).to be_a Hash
97
212
  end
98
213
  end
99
214
 
100
- it 'should raise a 400 error when attempting to delete customer\'s primary card' do
101
- customer_token = 'cus_6XnfOD5bvQ1qkaf3LqmhfQ'
102
- cards = Pin::Customer.cards(customer_token)
103
- primary_card_token = cards.select{|card| card['primary'] }.first['token']
104
- expect { Pin::Customer.delete_card(customer_token, primary_card_token) }.to raise_error do |error|
215
+ ###
216
+ # Plan Errors
217
+ ###
218
+ it 'should raise a 422 when creating a plan token and any field validation fails' do
219
+ plan_w_no_name = plan.tap { |h| h[:name] = '' }
220
+ expect { Pin::Plan.create(plan_w_no_name) }.to raise_error do |error|
105
221
  expect(error).to be_a Pin::InvalidResource
106
- expect(error.message).to eq 'You cannot delete a customer\'s primary card token'
222
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Name can't be blank")
223
+ end
224
+ end
225
+
226
+ it 'should raise a 404 error when trying to find a plan token that does not exist' do
227
+ expect { Pin::Plan.find('invalid_plan_token') }.to raise_error do |error|
228
+ expect(error).to be_a Pin::ResourceNotFound
229
+ expect(error.message).to eq 'The requested resource could not be found.'
107
230
  expect(error.response).to be_a Hash
108
231
  end
109
232
  end
110
233
 
111
- it 'should raise an Unauthorized error when token is invalid' do
112
- Pin::Base.new('arbitrary_token', :test)
113
- expect { Pin::Customer.charges('foo') }.to raise_error do |error|
114
- expect(error).to be_a Pin::Unauthorized
115
- expect(error.message).to eq 'Not authorised. (Check API Key)'
234
+ it 'should raise a 404 error when updating a plan token that does not exist' do
235
+ expect { Pin::Plan.update('invalid_plan_token', { name: 'new_plan_name' }) }.to raise_error do |error|
236
+ expect(error).to be_a Pin::ResourceNotFound
237
+ expect(error.message).to eq 'The requested resource could not be found.'
238
+ expect(error.response).to be_a Hash
239
+ end
240
+ end
241
+
242
+ it 'should raise a 422 when updating a plan token and any field validation fails' do
243
+ expect { Pin::Plan.update(plan_token, { currency: 'USD' }) }.to raise_error do |error|
244
+ expect(error).to be_a Pin::InvalidResource
245
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Name can't be blank")
246
+ expect(error.response).to be_a Hash
247
+ end
248
+ end
249
+
250
+ it 'should raise a 400 cannot delete plan which has active subscriptions' do
251
+ end
252
+
253
+ it 'should raise a 404 not found when deleting a plan token that does not exist' do
254
+ expect { Pin::Plan.delete('invalid_plan_token') }.to raise_error do |error|
255
+ expect(error).to be_a Pin::ResourceNotFound
256
+ expect(error.message).to eq 'The requested resource could not be found.'
257
+ expect(error.response).to be_a Hash
258
+ end
259
+ end
260
+
261
+ it 'should raise a 404 not found when creating a new subscription on an invalid plan token' do
262
+ expect { Pin::Plan.create_subscription('invalid_plan_token', customer_token) }.to raise_error do |error|
263
+ expect(error).to be_a Pin::ResourceNotFound
264
+ expect(error.message).to eq 'The requested resource could not be found.'
265
+ expect(error.response).to be_a Hash
266
+ end
267
+ end
268
+
269
+ it 'should raise a 404 not found when returning a list of subscriptions for a plan token that does not exist' do
270
+ expect { Pin::Plan.subscriptions('invalid_plan_token') }.to raise_error do |error|
271
+ expect(error).to be_a Pin::ResourceNotFound
272
+ expect(error.message).to eq 'The requested resource could not be found.'
273
+ expect(error.response).to be_a Hash
274
+ end
275
+ end
276
+
277
+ ###
278
+ # Subscription Errors
279
+ ###
280
+ it 'should raise a 400 when creating a subscription token & any field validation fails' do
281
+ subscription_w_no_plan_token = subscription_1.tap { |h| h[:plan_token] = '' }
282
+ expect { Pin::Subscription.create(subscription_w_no_plan_token) }.to raise_error do |error|
283
+ expect(error).to be_a Pin::InvalidResource
284
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Plan must exist")
285
+ end
286
+ end
287
+
288
+ it 'should raise a 404 error when trying to create a subscription with an invalid plan token' do
289
+ subscription_w_invalid_plan_token = subscription_1.tap { |h| h[:plan_token] = 'invalid_token' }
290
+ expect { Pin::Subscription.create(subscription_w_invalid_plan_token) }.to raise_error do |error|
291
+ expect(error).to be_a Pin::ResourceNotFound
292
+ expect(error.message).to eq 'The requested resource could not be found.'
293
+ expect(error.response).to be_a Hash
294
+ end
295
+ end
296
+
297
+ it 'should raise a 404 error when searching for an invalid subscription token' do
298
+ expect { Pin::Subscription.find('invalid_plan_token') }.to raise_error do |error|
299
+ expect(error).to be_a Pin::ResourceNotFound
300
+ expect(error.message).to eq 'The requested resource could not be found.'
301
+ expect(error.response).to be_a Hash
302
+ end
303
+ end
304
+
305
+ it 'should raise a 400 when updating a subscription & no card token is supplied' do
306
+ expect { Pin::Subscription.update(subscription_1_token, '') }.to raise_error do |error|
307
+ expect(error).to be_a Pin::InvalidResource
308
+ expect(error.response['messages'][0]).to match a_hash_including("message"=>"Card token must be present")
309
+ expect(error.response).to be_a Hash
310
+ end
311
+ end
312
+
313
+ it 'should raise a 400 error when update a subscription with an invalid card token' do
314
+ expect { Pin::Subscription.update(subscription_1_token, 'invalid_card_token') }.to raise_error do |error|
315
+ expect(error).to be_a Pin::InvalidResource
316
+ expect(error.message).to eq("Invalid card token")
116
317
  expect(error.response).to be_a Hash
117
318
  end
118
319
  end
119
320
 
321
+ it 'should raise a 404 when updating a subscription with invalid token' do
322
+ expect { Pin::Subscription.update('invalid_subscription_token', card_2_token) }.to raise_error do |error|
323
+ expect(error).to be_a Pin::ResourceNotFound
324
+ expect(error.message).to eq 'The requested resource could not be found.'
325
+ expect(error.response).to be_a Hash
326
+ end
327
+ end
328
+
329
+ it 'should raise a 404 not found when deleting an invalid subscription token' do
330
+ expect { Pin::Subscription.delete('invalid_subscription_token') }.to raise_error do |error|
331
+ expect(error).to be_a Pin::ResourceNotFound
332
+ expect(error.message).to eq 'The requested resource could not be found.'
333
+ expect(error.response).to be_a Hash
334
+ end
335
+ end
336
+
337
+ it 'should raise a 400 invalid state when deleting a cancelled subscription' do
338
+ deleted_subscription_token = Pin::Subscription.delete(subscription_1_token)['token']
339
+ expect { Pin::Subscription.delete(deleted_subscription_token) }.to raise_error do |error|
340
+ expect(error).to be_a Pin::InvalidResource
341
+ expect(error.message).to eq 'Cannot cancel subscription when state is trial_cancelling'
342
+ expect(error.response).to be_a Hash
343
+ end
344
+ end
345
+
346
+ it 'should raise a 404 when reactivating a subscription with invalid token' do
347
+ expect { Pin::Subscription.reactivate('invalid_subscription_token') }.to raise_error do |error|
348
+ expect(error).to be_a Pin::ResourceNotFound
349
+ expect(error.message).to eq 'The requested resource could not be found.'
350
+ expect(error.response).to be_a Hash
351
+ end
352
+ end
120
353
  end