action_controller_tweaks 0.3.1 → 0.3.2

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.
Files changed (21) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +1 -0
  3. data/.rubocop.yml +856 -0
  4. data/.travis.yml +11 -5
  5. data/Appraisals +20 -20
  6. data/CHANGELOG.md +73 -14
  7. data/Gemfile +1 -1
  8. data/README.md +7 -8
  9. data/Rakefile +4 -1
  10. data/action_controller_tweaks.gemspec +11 -9
  11. data/gemfiles/rails_5_0.gemfile +10 -0
  12. data/lib/action_controller_tweaks.rb +4 -4
  13. data/lib/action_controller_tweaks/caching.rb +8 -4
  14. data/lib/action_controller_tweaks/session.rb +71 -42
  15. data/lib/action_controller_tweaks/version.rb +1 -1
  16. data/spec/action_controller_tweaks_spec.rb +232 -173
  17. data/spec/fixtures/application.rb +8 -5
  18. data/spec/fixtures/controllers.rb +7 -5
  19. data/spec/spec_helper.rb +14 -14
  20. metadata +34 -19
  21. data/gemfiles/rails_3_2.gemfile +0 -10
data/lib/action_controller_tweaks/version.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  module ActionControllerTweaks
2
- VERSION = '0.3.1'
2
+ VERSION = "0.3.2"
3
3
 
4
4
  def self.version
5
5
  Gem::Version.new(VERSION)
data/spec/action_controller_tweaks_spec.rb CHANGED
@@ -1,29 +1,48 @@
1
- require 'spec_helper'
1
+ require "spec_helper"
2
+
3
+ describe NotController do
4
+ describe "::Session" do
5
+ context "when included by a class without `before_action` or `before_filter`" do
6
+ it "raises error" do
7
+ expect do
8
+ described_class.class_eval do
9
+ include ActionControllerTweaks::Session
10
+ end
11
+ end.to raise_error(NotImplementedError)
12
+ end
13
+ end
14
+ end
15
+ end
2
16
 
3
17
  describe PostsController, type: :controller do
4
- describe 'included modules' do
18
+ describe "included modules" do
5
19
  specify do
6
20
  expect(described_class.ancestors).to include(ActionControllerTweaks)
7
21
  end
8
22
  end
9
23
 
10
- describe '::Caching' do
11
- describe '#set_no_cache' do
24
+ describe "::Caching" do
25
+ describe "#set_no_cache" do
12
26
  before do
13
- get :index, no_cache: true
27
+ if Rails::VERSION::MAJOR >= 5
28
+ get :index, params: { no_cache: true }
29
+ else
30
+ get :index, no_cache: true
31
+ end
14
32
  end
15
33
 
16
- it 'includes the pre defined headeres' do
17
- expect(controller.headers.deep_include?(ActionControllerTweaks::Caching::HEADERS)).to be true
34
+ it "includes the pre defined headeres" do
35
+ expect(controller.headers.
36
+ deep_include?(ActionControllerTweaks::Caching::HEADERS)).to be true
18
37
  end
19
38
  end
20
39
  end
21
40
 
22
- describe '::Session' do
41
+ describe "::Session" do
23
42
  let(:session_key) { :key }
24
- let(:session_value) { 'value' }
43
+ let(:session_value) { "value" }
25
44
 
26
- describe '#set_session' do
45
+ describe "#set_session" do
27
46
  let(:expire_in) { 60 * 60 } # 1 hour
28
47
  let(:expire_at) { Time.new(2014, 1, 1).in_time_zone }
29
48
  let(:time_now) { Time.new(2013, 1, 1).in_time_zone }
@@ -31,32 +50,33 @@ describe PostsController, type: :controller do
31
50
  let(:expires_in) { expire_in }
32
51
  let(:expires_at) { expire_at }
33
52
 
34
- context 'when calling it without option' do
53
+ context "when calling it without option" do
35
54
  let :set_session do
36
55
  controller.send(:set_session, session_key, session_value)
37
56
  end
38
57
 
39
- context 'with normal key' do
58
+ context "with normal key" do
40
59
  before do
41
60
  set_session
42
61
  end
43
62
 
44
- it 'set the session' do
63
+ it "set the session" do
45
64
  expect(session[session_key]).to eq session_value
46
65
  end
47
66
  end
48
67
 
49
- context 'with a reserved key' do
68
+ context "with a reserved key" do
50
69
  let(:session_key) { ActionControllerTweaks::Session::RESERVED_SESSION_KEYS.first }
51
70
 
52
- it 'raise error' do
53
- expect { set_session }.to raise_error(ActionControllerTweaks::Session::Errors::ReservedSessionKeyConflict)
71
+ it "raise error" do
72
+ expect { set_session }.
73
+ to raise_error(ActionControllerTweaks::Session::Errors::ReservedSessionKeyConflict)
54
74
  end
55
75
  end
56
76
  end
57
77
 
58
- context 'for old option keys' do
59
- context 'when calling it with option expire_in' do
78
+ context "for old option keys" do
79
+ context "when calling it with option expire_in" do
60
80
  let!(:time_before_expire) { time_now + (expire_in / 2) }
61
81
  let!(:time_after_expire) { time_now + (expire_in * 2) }
62
82
 
@@ -69,294 +89,308 @@ describe PostsController, type: :controller do
69
89
  Timecop.return
70
90
  end
71
91
 
72
- it 'set the session' do
92
+ it "set the session" do
73
93
  expect(session[session_key]).to eq session_value
74
94
  end
75
95
 
76
- context 'before expire time' do
96
+ context "before expire time" do
77
97
  before do
78
98
  Timecop.travel(time_before_expire)
79
99
  # Runs before_filter
80
100
  get :index
81
101
  end
82
102
 
83
- it 'keeps the session key' do
103
+ it "keeps the session key" do
84
104
  expect(session[session_key]).to eq session_value
85
105
  end
86
106
  end
87
- context 'after expire time' do
107
+ context "after expire time" do
88
108
  before do
89
109
  Timecop.travel(time_after_expire)
90
110
  # Runs before_filter
91
111
  get :index
92
112
  end
93
113
 
94
- it 'keeps the session key' do
114
+ it "keeps the session key" do
95
115
  expect(session.key?(session_key)).to be false
96
116
  end
97
117
  end
98
118
  end
99
119
 
100
- context 'when calling it with no option' do
120
+ context "when calling it with no option" do
101
121
  before do
102
122
  controller.send(:set_session, session_key, session_value)
103
123
  end
104
124
 
105
- it 'set the session' do
125
+ it "set the session" do
106
126
  expect(session[session_key]).to eq session_value
107
127
  end
108
128
 
109
- it 'does NOT add the session key to `session_keys_to_expire`' do
110
- expect(session['session_keys_to_expire'].keys).to_not include(session_key)
129
+ it "does NOT add the session key to `session_keys_to_expire`" do
130
+ expect(session["session_keys_to_expire"].keys).to_not include(session_key)
111
131
  end
112
132
  end
113
133
 
114
- context 'when calling it with option expire_at' do
134
+ context "when calling it with option expire_at" do
115
135
  let!(:time_before_expire) { expire_at - 1 }
116
136
  let!(:time_after_expire) { expire_at + 1 }
117
137
 
118
138
  before do
119
139
  Timecop.freeze(time_now)
120
- controller.send(:set_session, session_key, session_value, expire_at: expire_at)
140
+ controller.send(:set_session,
141
+ session_key, session_value, expire_at: expire_at)
121
142
  end
122
143
 
123
144
  after do
124
145
  Timecop.return
125
146
  end
126
147
 
127
- it 'set the session' do
148
+ it "set the session" do
128
149
  expect(session[session_key]).to eq session_value
129
150
  end
130
151
 
131
- context 'before expire time' do
152
+ context "before expire time" do
132
153
  before do
133
154
  Timecop.travel(time_before_expire)
134
155
  # Runs before_filter
135
156
  get :index
136
157
  end
137
158
 
138
- it 'keeps the session key' do
159
+ it "keeps the session key" do
139
160
  expect(session[session_key]).to eq session_value
140
161
  end
141
162
  end
142
- context 'after expire time' do
163
+ context "after expire time" do
143
164
  before do
144
165
  Timecop.travel(time_after_expire)
145
166
  # Runs before_filter
146
167
  get :index
147
168
  end
148
169
 
149
- it 'keeps the session key' do
170
+ it "keeps the session key" do
150
171
  expect(session.key?(session_key)).to be false
151
172
  end
152
173
  end
153
174
  end
154
175
  end
155
- context 'for new option keys' do
156
- context 'when calling it with option expires_in' do
176
+ context "for new option keys" do
177
+ context "when calling it with option expires_in" do
157
178
  let!(:time_before_expire) { time_now + (expires_in / 2) }
158
179
  let!(:time_after_expire) { time_now + (expires_in * 2) }
159
180
 
160
181
  before do
161
182
  Timecop.freeze(time_now)
162
- controller.send(:set_session, session_key, session_value, expires_in: expires_in)
183
+ controller.send(:set_session,
184
+ session_key, session_value, expires_in: expires_in)
163
185
  end
164
186
 
165
187
  after do
166
188
  Timecop.return
167
189
  end
168
190
 
169
- it 'set the session' do
191
+ it "set the session" do
170
192
  expect(session[session_key]).to eq session_value
171
193
  end
172
194
 
173
- context 'before expire time' do
195
+ context "before expire time" do
174
196
  before do
175
197
  Timecop.travel(time_before_expire)
176
198
  # Runs before_filter
177
199
  get :index
178
200
  end
179
201
 
180
- it 'keeps the session key' do
202
+ it "keeps the session key" do
181
203
  expect(session[session_key]).to eq session_value
182
204
  end
183
205
  end
184
- context 'after expire time' do
206
+ context "after expire time" do
185
207
  before do
186
208
  Timecop.travel(time_after_expire)
187
209
  # Runs before_filter
188
210
  get :index
189
211
  end
190
212
 
191
- it 'keeps the session key' do
213
+ it "keeps the session key" do
192
214
  expect(session.key?(session_key)).to be false
193
215
  end
194
216
  end
195
217
  end
196
218
 
197
- context 'when calling it with option expires_at' do
219
+ context "when calling it with option expires_at" do
198
220
  let!(:time_before_expire) { expires_at - 1 }
199
221
  let!(:time_after_expire) { expires_at + 1 }
200
222
 
201
223
  before do
202
224
  Timecop.freeze(time_now)
203
- controller.send(:set_session, session_key, session_value, expire_at: expires_at)
225
+ controller.send(:set_session,
226
+ session_key, session_value, expire_at: expires_at)
204
227
  end
205
228
 
206
229
  after do
207
230
  Timecop.return
208
231
  end
209
232
 
210
- it 'set the session' do
233
+ it "set the session" do
211
234
  expect(session[session_key]).to eq session_value
212
235
  end
213
236
 
214
- context 'before expire time' do
237
+ context "before expire time" do
215
238
  before do
216
239
  Timecop.travel(time_before_expire)
217
240
  # Runs before_filter
218
241
  get :index
219
242
  end
220
243
 
221
- it 'keeps the session key' do
244
+ it "keeps the session key" do
222
245
  expect(session[session_key]).to eq session_value
223
246
  end
224
247
  end
225
- context 'after expire time' do
248
+ context "after expire time" do
226
249
  before do
227
250
  Timecop.travel(time_after_expire)
228
251
  # Runs before_filter
229
252
  get :index
230
253
  end
231
254
 
232
- it 'keeps the session key' do
255
+ it "keeps the session key" do
233
256
  expect(session.key?(session_key)).to be false
234
257
  end
235
258
  end
236
259
  end
237
260
  end
238
261
 
239
-
240
- context 'when option value with different types is passed into options' do
262
+ context "when option value with different types is passed into options" do
241
263
  let(:method_call) do
242
264
  controller.send(:set_session, session_key, session_value, options)
243
265
  end
244
266
 
245
- context 'for old option keys' do
246
- context 'for expire_in' do
267
+ context "for old option keys" do
268
+ context "for expire_in" do
247
269
  let(:options) { {expire_in: expire_in.to_s} }
248
270
 
249
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
271
+ specify do
272
+ expect { method_call }.
273
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
274
+ end
250
275
  end
251
- context 'for expire_at' do
252
- context 'with a Hash' do
276
+ context "for expire_at" do
277
+ context "with a Hash" do
253
278
  # String#to_time would be nil if format invalid
254
279
  let(:options) { {expire_at: {}} }
255
280
 
256
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
281
+ specify do
282
+ expect { method_call }.
283
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
284
+ end
257
285
  end
258
- context 'with a blank String' do
286
+ context "with a blank String" do
259
287
  # String#to_time would be nil if format invalid
260
- let(:options) { {expire_at: ''} }
288
+ let(:options) { {expire_at: ""} }
261
289
 
262
- specify { expect{ method_call }.to_not raise_error }
290
+ specify { expect { method_call }.to_not raise_error }
263
291
  end
264
- context 'with a time String' do
292
+ context "with a time String" do
265
293
  let(:options) { {expire_at: expire_at.to_s} }
266
294
 
267
- specify { expect{ method_call }.to_not raise_error }
295
+ specify { expect { method_call }.to_not raise_error }
268
296
  end
269
- context 'with a Time' do
297
+ context "with a Time" do
270
298
  let(:options) { {expire_at: expire_at.to_time} }
271
299
 
272
- specify { expect{ method_call }.to_not raise_error }
300
+ specify { expect { method_call }.to_not raise_error }
273
301
  end
274
- context 'with a Date' do
302
+ context "with a Date" do
275
303
  let(:options) { {expire_at: expire_at.to_date} }
276
304
 
277
- specify { expect{ method_call }.to_not raise_error }
305
+ specify { expect { method_call }.to_not raise_error }
278
306
  end
279
- context 'with a DateTime' do
307
+ context "with a DateTime" do
280
308
  let(:options) { {expire_at: expire_at.in_time_zone} }
281
309
 
282
- specify { expect{ method_call }.to_not raise_error }
310
+ specify { expect { method_call }.to_not raise_error }
283
311
  end
284
312
  end
285
313
  end
286
- context 'for new option keys' do
287
- context 'for expires_in' do
314
+ context "for new option keys" do
315
+ context "for expires_in" do
288
316
  let(:options) { {expires_in: expires_in.to_s} }
289
317
 
290
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
318
+ specify do
319
+ expect { method_call }.
320
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
321
+ end
291
322
  end
292
- context 'for expires_at' do
293
- context 'with a Hash' do
323
+ context "for expires_at" do
324
+ context "with a Hash" do
294
325
  # String#to_time would be nil if format invalid
295
326
  let(:options) { {expires_at: {}} }
296
327
 
297
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
328
+ specify do
329
+ expect { method_call }.
330
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
331
+ end
298
332
  end
299
- context 'with a blank String' do
333
+ context "with a blank String" do
300
334
  # String#to_time would be nil if format invalid
301
- let(:options) { {expires_at: ''} }
335
+ let(:options) { {expires_at: ""} }
302
336
 
303
- specify { expect{ method_call }.to_not raise_error }
337
+ specify { expect { method_call }.to_not raise_error }
304
338
  end
305
- context 'with a time String' do
339
+ context "with a time String" do
306
340
  let(:options) { {expires_at: expire_at.to_s} }
307
341
 
308
- specify { expect{ method_call }.to_not raise_error }
342
+ specify { expect { method_call }.to_not raise_error }
309
343
  end
310
- context 'with a Time' do
344
+ context "with a Time" do
311
345
  let(:options) { {expires_at: expire_at.to_time} }
312
346
 
313
- specify { expect{ method_call }.to_not raise_error }
347
+ specify { expect { method_call }.to_not raise_error }
314
348
  end
315
- context 'with a Date' do
349
+ context "with a Date" do
316
350
  let(:options) { {expires_at: expire_at.to_date} }
317
351
 
318
- specify { expect{ method_call }.to_not raise_error }
352
+ specify { expect { method_call }.to_not raise_error }
319
353
  end
320
- context 'with a DateTime' do
354
+ context "with a DateTime" do
321
355
  let(:options) { {expires_at: expire_at.in_time_zone} }
322
356
 
323
- specify { expect{ method_call }.to_not raise_error }
357
+ specify { expect { method_call }.to_not raise_error }
324
358
  end
325
359
  end
326
360
  end
327
361
  end
328
362
 
329
- context 'when someone screw up the special session key' do
363
+ context "when someone screw up the special session key" do
330
364
  before do
331
365
  session[session_key] = session_value
332
366
  end
333
367
 
334
- context 'when someone set non time string in expire_at_str' do
368
+ context "when someone set non time string in expire_at_str" do
335
369
  before do
336
- session['session_keys_to_expire'] = {session_key => ''}
370
+ session["session_keys_to_expire"] = {session_key => ""}
337
371
 
338
372
  # Runs before_filter
339
373
  get :index
340
374
  end
341
375
 
342
- it 'destroys the session key' do
376
+ it "destroys the session key" do
343
377
  expect(session.key?(session_key)).to be false
344
378
  end
345
379
  end
346
380
 
347
- context 'when someone set non-hash to session_keys_to_expire' do
381
+ context "when someone set non-hash to session_keys_to_expire" do
348
382
  before do
349
- session['session_keys_to_expire'] = []
383
+ session["session_keys_to_expire"] = []
350
384
  end
351
385
 
352
- it 'does not destroy the session key' do
386
+ it "does not destroy the session key" do
353
387
  expect(session.key?(session_key)).to be true
354
388
  end
355
389
  end
356
390
  end
357
391
  end
358
392
 
359
- describe '#set_session_with_expiry' do
393
+ describe "#set_session_with_expiry" do
360
394
  let(:expire_in) { 60 * 60 } # 1 hour
361
395
  let(:expire_at) { Time.new(2014, 1, 1).in_time_zone }
362
396
  let(:time_now) { Time.new(2013, 1, 1).in_time_zone }
@@ -368,298 +402,323 @@ describe PostsController, type: :controller do
368
402
  controller.send(:set_session_with_expiry, session_key, session_value, options)
369
403
  end
370
404
 
371
- context 'when call with no options' do
405
+ context "when call with no options" do
372
406
  let!(:options) { {} }
373
407
 
374
- specify { expect{method_call}.to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys) }
408
+ specify do
409
+ expect { method_call }.
410
+ to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys)
411
+ end
375
412
  end
376
- context 'when call with invalid option keys' do
413
+ context "when call with invalid option keys" do
377
414
  let!(:options) { {key: :value} }
378
415
 
379
- specify { expect{method_call}.to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys) }
416
+ specify do
417
+ expect { method_call }.
418
+ to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys)
419
+ end
380
420
  end
381
- context 'when call with valid option keys' do
382
- context 'like expire_in' do
421
+ context "when call with valid option keys" do
422
+ context "like expire_in" do
383
423
  let!(:options) { {expire_in: 1.day} }
384
424
 
385
- specify { expect{method_call}.to_not raise_error }
425
+ specify { expect { method_call }.to_not raise_error }
386
426
  end
387
- context 'like expire_at' do
427
+ context "like expire_at" do
388
428
  let!(:options) { {expire_at: 1.day.from_now} }
389
429
 
390
- specify { expect{method_call}.to_not raise_error }
430
+ specify { expect { method_call }.to_not raise_error }
391
431
  end
392
- context 'like expires_in' do
432
+ context "like expires_in" do
393
433
  let!(:options) { {expires_in: 1.day} }
394
434
 
395
- specify { expect{method_call}.to_not raise_error }
435
+ specify { expect { method_call }.to_not raise_error }
396
436
  end
397
- context 'like expires_at' do
437
+ context "like expires_at" do
398
438
  let!(:options) { {expires_at: 1.day.from_now} }
399
439
 
400
- specify { expect{method_call}.to_not raise_error }
440
+ specify { expect { method_call }.to_not raise_error }
401
441
  end
402
442
  end
403
443
 
404
- context 'for old option keys' do
405
- context 'when calling it with option expire_in' do
444
+ context "for old option keys" do
445
+ context "when calling it with option expire_in" do
406
446
  let!(:time_before_expire) { time_now + (expire_in / 2) }
407
447
  let!(:time_after_expire) { time_now + (expire_in * 2) }
408
448
 
409
449
  before do
410
450
  Timecop.freeze(time_now)
411
- controller.send(:set_session_with_expiry, session_key, session_value, expire_in: expire_in)
451
+ controller.send(:set_session_with_expiry,
452
+ session_key, session_value, expire_in: expire_in)
412
453
  end
413
454
 
414
455
  after do
415
456
  Timecop.return
416
457
  end
417
458
 
418
- it 'set the session' do
459
+ it "set the session" do
419
460
  expect(session[session_key]).to eq session_value
420
461
  end
421
462
 
422
- context 'before expire time' do
463
+ context "before expire time" do
423
464
  before do
424
465
  Timecop.travel(time_before_expire)
425
466
  # Runs before_filter
426
467
  get :index
427
468
  end
428
469
 
429
- it 'keeps the session key' do
470
+ it "keeps the session key" do
430
471
  expect(session[session_key]).to eq session_value
431
472
  end
432
473
  end
433
- context 'after expire time' do
474
+ context "after expire time" do
434
475
  before do
435
476
  Timecop.travel(time_after_expire)
436
477
  # Runs before_filter
437
478
  get :index
438
479
  end
439
480
 
440
- it 'keeps the session key' do
481
+ it "keeps the session key" do
441
482
  expect(session.key?(session_key)).to be false
442
483
  end
443
484
  end
444
485
  end
445
486
 
446
- context 'when calling it with no option' do
487
+ context "when calling it with no option" do
447
488
  let(:method_call) do
448
489
  controller.send(:set_session_with_expiry, session_key, session_value)
449
490
  end
450
491
 
451
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys) }
492
+ specify do
493
+ expect { method_call }.
494
+ to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys)
495
+ end
452
496
  end
453
497
 
454
- context 'when calling it with option expire_at' do
498
+ context "when calling it with option expire_at" do
455
499
  let!(:time_before_expire) { expire_at - 1 }
456
500
  let!(:time_after_expire) { expire_at + 1 }
457
501
 
458
502
  before do
459
503
  Timecop.freeze(time_now)
460
- controller.send(:set_session_with_expiry, session_key, session_value, expire_at: expire_at)
504
+ controller.send(:set_session_with_expiry,
505
+ session_key, session_value, expire_at: expire_at)
461
506
  end
462
507
 
463
508
  after do
464
509
  Timecop.return
465
510
  end
466
511
 
467
- it 'set the session' do
512
+ it "set the session" do
468
513
  expect(session[session_key]).to eq session_value
469
514
  end
470
515
 
471
- context 'before expire time' do
516
+ context "before expire time" do
472
517
  before do
473
518
  Timecop.travel(time_before_expire)
474
519
  # Runs before_filter
475
520
  get :index
476
521
  end
477
522
 
478
- it 'keeps the session key' do
523
+ it "keeps the session key" do
479
524
  expect(session[session_key]).to eq session_value
480
525
  end
481
526
  end
482
- context 'after expire time' do
527
+ context "after expire time" do
483
528
  before do
484
529
  Timecop.travel(time_after_expire)
485
530
  # Runs before_filter
486
531
  get :index
487
532
  end
488
533
 
489
- it 'keeps the session key' do
534
+ it "keeps the session key" do
490
535
  expect(session.key?(session_key)).to be false
491
536
  end
492
537
  end
493
538
  end
494
539
  end
495
- context 'for new option keys' do
496
- context 'when calling it with option expires_in' do
540
+ context "for new option keys" do
541
+ context "when calling it with option expires_in" do
497
542
  let!(:time_before_expire) { time_now + (expires_in / 2) }
498
543
  let!(:time_after_expire) { time_now + (expires_in * 2) }
499
544
 
500
545
  before do
501
546
  Timecop.freeze(time_now)
502
- controller.send(:set_session_with_expiry, session_key, session_value, expires_in: expires_in)
547
+ controller.send(:set_session_with_expiry,
548
+ session_key, session_value, expires_in: expires_in)
503
549
  end
504
550
 
505
551
  after do
506
552
  Timecop.return
507
553
  end
508
554
 
509
- it 'set the session' do
555
+ it "set the session" do
510
556
  expect(session[session_key]).to eq session_value
511
557
  end
512
558
 
513
- context 'before expire time' do
559
+ context "before expire time" do
514
560
  before do
515
561
  Timecop.travel(time_before_expire)
516
562
  # Runs before_filter
517
563
  get :index
518
564
  end
519
565
 
520
- it 'keeps the session key' do
566
+ it "keeps the session key" do
521
567
  expect(session[session_key]).to eq session_value
522
568
  end
523
569
  end
524
- context 'after expire time' do
570
+ context "after expire time" do
525
571
  before do
526
572
  Timecop.travel(time_after_expire)
527
573
  # Runs before_filter
528
574
  get :index
529
575
  end
530
576
 
531
- it 'keeps the session key' do
577
+ it "keeps the session key" do
532
578
  expect(session.key?(session_key)).to be false
533
579
  end
534
580
  end
535
581
  end
536
582
 
537
- context 'when calling it with option expires_at' do
583
+ context "when calling it with option expires_at" do
538
584
  let!(:time_before_expire) { expires_at - 1 }
539
585
  let!(:time_after_expire) { expires_at + 1 }
540
586
 
541
587
  before do
542
588
  Timecop.freeze(time_now)
543
- controller.send(:set_session_with_expiry, session_key, session_value, expire_at: expires_at)
589
+ controller.send(:set_session_with_expiry,
590
+ session_key, session_value, expire_at: expires_at)
544
591
  end
545
592
 
546
593
  after do
547
594
  Timecop.return
548
595
  end
549
596
 
550
- it 'set the session' do
597
+ it "set the session" do
551
598
  expect(session[session_key]).to eq session_value
552
599
  end
553
600
 
554
- context 'before expire time' do
601
+ context "before expire time" do
555
602
  before do
556
603
  Timecop.travel(time_before_expire)
557
604
  # Runs before_filter
558
605
  get :index
559
606
  end
560
607
 
561
- it 'keeps the session key' do
608
+ it "keeps the session key" do
562
609
  expect(session[session_key]).to eq session_value
563
610
  end
564
611
  end
565
- context 'after expire time' do
612
+ context "after expire time" do
566
613
  before do
567
614
  Timecop.travel(time_after_expire)
568
615
  # Runs before_filter
569
616
  get :index
570
617
  end
571
618
 
572
- it 'keeps the session key' do
619
+ it "keeps the session key" do
573
620
  expect(session.key?(session_key)).to be false
574
621
  end
575
622
  end
576
623
  end
577
624
  end
578
625
 
579
- context 'when option value with different types is passed into options' do
626
+ context "when option value with different types is passed into options" do
580
627
  let(:method_call) do
581
628
  controller.send(:set_session_with_expiry, session_key, session_value, options)
582
629
  end
583
630
 
584
- context 'for old option keys' do
585
- context 'for expire_in' do
631
+ context "for old option keys" do
632
+ context "for expire_in" do
586
633
  let(:options) { {expire_in: expire_in.to_s} }
587
634
 
588
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
635
+ specify do
636
+ expect { method_call }.
637
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
638
+ end
589
639
  end
590
- context 'for expire_at' do
591
- context 'with a Hash' do
640
+ context "for expire_at" do
641
+ context "with a Hash" do
592
642
  # String#to_time would be nil if format invalid
593
643
  let(:options) { {expire_at: {}} }
594
644
 
595
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
645
+ specify do
646
+ expect { method_call }.
647
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
648
+ end
596
649
  end
597
- context 'with a blank String' do
650
+ context "with a blank String" do
598
651
  # String#to_time would be nil if format invalid
599
- let(:options) { {expire_at: ''} }
652
+ let(:options) { {expire_at: ""} }
600
653
 
601
- specify { expect{ method_call }.to_not raise_error }
654
+ specify { expect { method_call }.to_not raise_error }
602
655
  end
603
- context 'with a time String' do
656
+ context "with a time String" do
604
657
  let(:options) { {expire_at: expire_at.to_s} }
605
658
 
606
- specify { expect{ method_call }.to_not raise_error }
659
+ specify { expect { method_call }.to_not raise_error }
607
660
  end
608
- context 'with a Time' do
661
+ context "with a Time" do
609
662
  let(:options) { {expire_at: expire_at.to_time} }
610
663
 
611
- specify { expect{ method_call }.to_not raise_error }
664
+ specify { expect { method_call }.to_not raise_error }
612
665
  end
613
- context 'with a Date' do
666
+ context "with a Date" do
614
667
  let(:options) { {expire_at: expire_at.to_date} }
615
668
 
616
- specify { expect{ method_call }.to_not raise_error }
669
+ specify { expect { method_call }.to_not raise_error }
617
670
  end
618
- context 'with a DateTime' do
671
+ context "with a DateTime" do
619
672
  let(:options) { {expire_at: expire_at.in_time_zone} }
620
673
 
621
- specify { expect{ method_call }.to_not raise_error }
674
+ specify { expect { method_call }.to_not raise_error }
622
675
  end
623
676
  end
624
677
  end
625
- context 'for new option keys' do
626
- context 'for expires_in' do
678
+ context "for new option keys" do
679
+ context "for expires_in" do
627
680
  let(:options) { {expires_in: expires_in.to_s} }
628
681
 
629
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
682
+ specify do
683
+ expect { method_call }.
684
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
685
+ end
630
686
  end
631
- context 'for expires_at' do
632
- context 'with a Hash' do
687
+ context "for expires_at" do
688
+ context "with a Hash" do
633
689
  # String#to_time would be nil if format invalid
634
690
  let(:options) { {expires_at: {}} }
635
691
 
636
- specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
692
+ specify do
693
+ expect { method_call }.
694
+ to raise_error(ActionControllerTweaks::Session::InvalidOptionValue)
695
+ end
637
696
  end
638
- context 'with a blank String' do
697
+ context "with a blank String" do
639
698
  # String#to_time would be nil if format invalid
640
- let(:options) { {expires_at: ''} }
699
+ let(:options) { {expires_at: ""} }
641
700
 
642
- specify { expect{ method_call }.to_not raise_error }
701
+ specify { expect { method_call }.to_not raise_error }
643
702
  end
644
- context 'with a time String' do
703
+ context "with a time String" do
645
704
  let(:options) { {expires_at: expire_at.to_s} }
646
705
 
647
- specify { expect{ method_call }.to_not raise_error }
706
+ specify { expect { method_call }.to_not raise_error }
648
707
  end
649
- context 'with a Time' do
708
+ context "with a Time" do
650
709
  let(:options) { {expires_at: expire_at.to_time} }
651
710
 
652
- specify { expect{ method_call }.to_not raise_error }
711
+ specify { expect { method_call }.to_not raise_error }
653
712
  end
654
- context 'with a Date' do
713
+ context "with a Date" do
655
714
  let(:options) { {expires_at: expire_at.to_date} }
656
715
 
657
- specify { expect{ method_call }.to_not raise_error }
716
+ specify { expect { method_call }.to_not raise_error }
658
717
  end
659
- context 'with a DateTime' do
718
+ context "with a DateTime" do
660
719
  let(:options) { {expires_at: expire_at.in_time_zone} }
661
720
 
662
- specify { expect{ method_call }.to_not raise_error }
721
+ specify { expect { method_call }.to_not raise_error }
663
722
  end
664
723
  end
665
724
  end