action_controller_tweaks 0.3.1 → 0.3.2

Sign up to get free protection for your applications and to get access to all the features.
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