resque-igo 1.1

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 (50) hide show
  1. data/HISTORY.md +225 -0
  2. data/LICENSE +20 -0
  3. data/README.markdown +855 -0
  4. data/Rakefile +70 -0
  5. data/bin/resque +57 -0
  6. data/bin/resque-web +23 -0
  7. data/lib/resque.rb +380 -0
  8. data/lib/resque/errors.rb +10 -0
  9. data/lib/resque/failure.rb +66 -0
  10. data/lib/resque/failure/base.rb +61 -0
  11. data/lib/resque/failure/hoptoad.rb +132 -0
  12. data/lib/resque/failure/multiple.rb +50 -0
  13. data/lib/resque/failure/redis.rb +40 -0
  14. data/lib/resque/helpers.rb +71 -0
  15. data/lib/resque/job.rb +209 -0
  16. data/lib/resque/plugin.rb +51 -0
  17. data/lib/resque/server.rb +247 -0
  18. data/lib/resque/server/public/idle.png +0 -0
  19. data/lib/resque/server/public/jquery-1.3.2.min.js +19 -0
  20. data/lib/resque/server/public/jquery.relatize_date.js +95 -0
  21. data/lib/resque/server/public/poll.png +0 -0
  22. data/lib/resque/server/public/ranger.js +67 -0
  23. data/lib/resque/server/public/reset.css +48 -0
  24. data/lib/resque/server/public/style.css +86 -0
  25. data/lib/resque/server/public/working.png +0 -0
  26. data/lib/resque/server/test_helper.rb +19 -0
  27. data/lib/resque/server/views/error.erb +1 -0
  28. data/lib/resque/server/views/failed.erb +53 -0
  29. data/lib/resque/server/views/key_sets.erb +20 -0
  30. data/lib/resque/server/views/key_string.erb +11 -0
  31. data/lib/resque/server/views/layout.erb +42 -0
  32. data/lib/resque/server/views/next_more.erb +10 -0
  33. data/lib/resque/server/views/overview.erb +4 -0
  34. data/lib/resque/server/views/queues.erb +65 -0
  35. data/lib/resque/server/views/stats.erb +73 -0
  36. data/lib/resque/server/views/workers.erb +109 -0
  37. data/lib/resque/server/views/working.erb +68 -0
  38. data/lib/resque/stat.rb +54 -0
  39. data/lib/resque/tasks.rb +39 -0
  40. data/lib/resque/version.rb +3 -0
  41. data/lib/resque/worker.rb +478 -0
  42. data/tasks/resque.rake +2 -0
  43. data/test/job_hooks_test.rb +323 -0
  44. data/test/job_plugins_test.rb +230 -0
  45. data/test/plugin_test.rb +116 -0
  46. data/test/resque-web_test.rb +54 -0
  47. data/test/resque_test.rb +351 -0
  48. data/test/test_helper.rb +166 -0
  49. data/test/worker_test.rb +302 -0
  50. metadata +180 -0
@@ -0,0 +1,116 @@
1
+ require File.dirname(__FILE__) + '/test_helper'
2
+
3
+ context "Resque::Plugin finding hooks" do
4
+ module SimplePlugin
5
+ extend self
6
+ def before_perform1; end
7
+ def before_perform; end
8
+ def before_perform2; end
9
+ def after_perform1; end
10
+ def after_perform; end
11
+ def after_perform2; end
12
+ def perform; end
13
+ def around_perform1; end
14
+ def around_perform; end
15
+ def around_perform2; end
16
+ def on_failure1; end
17
+ def on_failure; end
18
+ def on_failure2; end
19
+ end
20
+
21
+ test "before_perform hooks are found and sorted" do
22
+ assert_equal ["before_perform", "before_perform1", "before_perform2"], Resque::Plugin.before_hooks(SimplePlugin).map {|m| m.to_s}
23
+ end
24
+
25
+ test "after_perform hooks are found and sorted" do
26
+ assert_equal ["after_perform", "after_perform1", "after_perform2"], Resque::Plugin.after_hooks(SimplePlugin).map {|m| m.to_s}
27
+ end
28
+
29
+ test "around_perform hooks are found and sorted" do
30
+ assert_equal ["around_perform", "around_perform1", "around_perform2"], Resque::Plugin.around_hooks(SimplePlugin).map {|m| m.to_s}
31
+ end
32
+
33
+ test "on_failure hooks are found and sorted" do
34
+ assert_equal ["on_failure", "on_failure1", "on_failure2"], Resque::Plugin.failure_hooks(SimplePlugin).map {|m| m.to_s}
35
+ end
36
+ end
37
+
38
+ context "Resque::Plugin linting" do
39
+ module ::BadBefore
40
+ def self.before_perform; end
41
+ end
42
+ module ::BadAfter
43
+ def self.after_perform; end
44
+ end
45
+ module ::BadAround
46
+ def self.around_perform; end
47
+ end
48
+ module ::BadFailure
49
+ def self.on_failure; end
50
+ end
51
+
52
+ test "before_perform must be namespaced" do
53
+ begin
54
+ Resque::Plugin.lint(BadBefore)
55
+ assert false, "should have failed"
56
+ rescue Resque::Plugin::LintError => e
57
+ assert_equal "BadBefore.before_perform is not namespaced", e.message
58
+ end
59
+ end
60
+
61
+ test "after_perform must be namespaced" do
62
+ begin
63
+ Resque::Plugin.lint(BadAfter)
64
+ assert false, "should have failed"
65
+ rescue Resque::Plugin::LintError => e
66
+ assert_equal "BadAfter.after_perform is not namespaced", e.message
67
+ end
68
+ end
69
+
70
+ test "around_perform must be namespaced" do
71
+ begin
72
+ Resque::Plugin.lint(BadAround)
73
+ assert false, "should have failed"
74
+ rescue Resque::Plugin::LintError => e
75
+ assert_equal "BadAround.around_perform is not namespaced", e.message
76
+ end
77
+ end
78
+
79
+ test "on_failure must be namespaced" do
80
+ begin
81
+ Resque::Plugin.lint(BadFailure)
82
+ assert false, "should have failed"
83
+ rescue Resque::Plugin::LintError => e
84
+ assert_equal "BadFailure.on_failure is not namespaced", e.message
85
+ end
86
+ end
87
+
88
+ module GoodBefore
89
+ def self.before_perform1; end
90
+ end
91
+ module GoodAfter
92
+ def self.after_perform1; end
93
+ end
94
+ module GoodAround
95
+ def self.around_perform1; end
96
+ end
97
+ module GoodFailure
98
+ def self.on_failure1; end
99
+ end
100
+
101
+ test "before_perform1 is an ok name" do
102
+ Resque::Plugin.lint(GoodBefore)
103
+ end
104
+
105
+ test "after_perform1 is an ok name" do
106
+ Resque::Plugin.lint(GoodAfter)
107
+ end
108
+
109
+ test "around_perform1 is an ok name" do
110
+ Resque::Plugin.lint(GoodAround)
111
+ end
112
+
113
+ test "on_failure1 is an ok name" do
114
+ Resque::Plugin.lint(GoodFailure)
115
+ end
116
+ end
@@ -0,0 +1,54 @@
1
+ require File.dirname(__FILE__) + '/test_helper'
2
+ require 'resque/server/test_helper'
3
+
4
+ # Root path test
5
+ context "on GET to /" do
6
+ setup { get "/" }
7
+
8
+ test "redirect to overview" do
9
+ follow_redirect!
10
+ end
11
+ end
12
+
13
+ # Global overview
14
+ context "on GET to /overview" do
15
+ setup { get "/overview" }
16
+
17
+ test "should at least display 'queues'" do
18
+ assert last_response.body.include?('Queues')
19
+ end
20
+ end
21
+
22
+ # Working jobs
23
+ context "on GET to /working" do
24
+ setup { get "/working" }
25
+
26
+ should_respond_with_success
27
+ end
28
+
29
+ # Failed
30
+ context "on GET to /failed" do
31
+ setup { get "/failed" }
32
+
33
+ should_respond_with_success
34
+ end
35
+
36
+ # Stats
37
+ context "on GET to /stats/resque" do
38
+ setup { get "/stats/resque" }
39
+
40
+ should_respond_with_success
41
+ end
42
+
43
+ context "on GET to /stats/redis" do
44
+ setup { get "/stats/redis" }
45
+
46
+ should_respond_with_success
47
+ end
48
+
49
+ context "on GET to /stats/resque" do
50
+ setup { get "/stats/keys" }
51
+
52
+ should_respond_with_success
53
+ end
54
+
@@ -0,0 +1,351 @@
1
+ require File.dirname(__FILE__) + '/test_helper'
2
+
3
+ context "Resque" do
4
+ setup do
5
+ Resque.drop
6
+ Resque.bypass_queues = false
7
+ Resque.enable_delay(:delayed)
8
+ Resque.push(:people, { 'name' => 'chris' })
9
+ Resque.push(:people, { 'name' => 'bob' })
10
+ Resque.push(:people, { 'name' => 'mark' })
11
+ end
12
+
13
+ test "can set a namespace through a url-like string" do
14
+ assert Resque.mongo
15
+ assert_equal 'resque', Resque.mongo.name
16
+ Resque.mongo = 'localhost:27017/namespace'
17
+ assert_equal 'namespace', Resque.mongo.name
18
+ end
19
+
20
+ test "can put jobs on a queue" do
21
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
22
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
23
+ end
24
+
25
+ test "can grab jobs off a queue" do
26
+ Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
27
+
28
+ job = Resque.reserve(:jobs)
29
+
30
+ assert_kind_of Resque::Job, job
31
+ assert_equal SomeJob, job.payload_class
32
+ assert_equal 20, job.args[0]
33
+ assert_equal '/tmp', job.args[1]
34
+ end
35
+
36
+ test "can re-queue jobs" do
37
+ Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
38
+
39
+ job = Resque.reserve(:jobs)
40
+ job.recreate
41
+
42
+ assert_equal job, Resque.reserve(:jobs)
43
+ end
44
+
45
+ test "can put jobs on a queue by way of an ivar" do
46
+ assert_equal 0, Resque.size(:ivar)
47
+ assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
48
+ assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
49
+
50
+ job = Resque.reserve(:ivar)
51
+
52
+ assert_kind_of Resque::Job, job
53
+ assert_equal SomeIvarJob, job.payload_class
54
+ assert_equal 20, job.args[0]
55
+ assert_equal '/tmp', job.args[1]
56
+
57
+ assert Resque.reserve(:ivar)
58
+ assert_equal nil, Resque.reserve(:ivar)
59
+ end
60
+
61
+ test "can remove jobs from a queue by way of an ivar" do
62
+ assert_equal 0, Resque.size(:ivar)
63
+ assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
64
+ assert Resque.enqueue(SomeIvarJob, 30, '/tmp')
65
+ assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
66
+ assert Resque::Job.create(:ivar, 'blah-job', 20, '/tmp')
67
+ assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
68
+ assert_equal 5, Resque.size(:ivar)
69
+
70
+ assert Resque.dequeue(SomeIvarJob, 30, '/tmp')
71
+ assert_equal 4, Resque.size(:ivar)
72
+ assert Resque.dequeue(SomeIvarJob)
73
+ assert_equal 1, Resque.size(:ivar)
74
+ end
75
+
76
+ test "jobs have a nice #inspect" do
77
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
78
+ job = Resque.reserve(:jobs)
79
+ assert_equal '(Job{jobs} | SomeJob | [20, "/tmp"])', job.inspect
80
+ end
81
+
82
+ test "jobs can be destroyed" do
83
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
84
+ assert Resque::Job.create(:jobs, 'BadJob', 20, '/tmp')
85
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
86
+ assert Resque::Job.create(:jobs, 'BadJob', 30, '/tmp')
87
+ assert Resque::Job.create(:jobs, 'BadJob', 20, '/tmp')
88
+
89
+ assert_equal 5, Resque.size(:jobs)
90
+ assert_equal 2, Resque::Job.destroy(:jobs, 'SomeJob')
91
+ assert_equal 3, Resque.size(:jobs)
92
+ assert_equal 1, Resque::Job.destroy(:jobs, 'BadJob', 30, '/tmp')
93
+ assert_equal 2, Resque.size(:jobs)
94
+ end
95
+
96
+ test "jobs can test for equality" do
97
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
98
+ assert Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
99
+ assert_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
100
+
101
+ assert Resque::Job.create(:jobs, 'SomeMethodJob', 20, '/tmp')
102
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
103
+ assert_not_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
104
+
105
+ assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
106
+ assert Resque::Job.create(:jobs, 'SomeJob', 30, '/tmp')
107
+ assert_not_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
108
+ end
109
+
110
+ test "can put jobs on a queue by way of a method" do
111
+ assert_equal 0, Resque.size(:method)
112
+ assert Resque.enqueue(SomeMethodJob, 20, '/tmp')
113
+ assert Resque.enqueue(SomeMethodJob, 20, '/tmp')
114
+
115
+ job = Resque.reserve(:method)
116
+
117
+ assert_kind_of Resque::Job, job
118
+ assert_equal SomeMethodJob, job.payload_class
119
+ assert_equal 20, job.args[0]
120
+ assert_equal '/tmp', job.args[1]
121
+
122
+ assert Resque.reserve(:method)
123
+ assert_equal nil, Resque.reserve(:method)
124
+ end
125
+
126
+ test "needs to infer a queue with enqueue" do
127
+ assert_raises Resque::NoQueueError do
128
+ Resque.enqueue(SomeJob, 20, '/tmp')
129
+ end
130
+ end
131
+
132
+ test "can put items on a queue" do
133
+ assert Resque.push(:people, { 'name' => 'jon' })
134
+ end
135
+
136
+ def pop_no_id(queue)
137
+ item = Resque.pop(queue)
138
+ item.delete("_id")
139
+ item
140
+ end
141
+
142
+
143
+ test "can pull items off a queue" do
144
+ assert_equal({ 'name' => 'chris' }, pop_no_id(:people))
145
+ assert_equal({ 'name' => 'bob' }, pop_no_id(:people))
146
+ assert_equal({ 'name' => 'mark' }, pop_no_id(:people))
147
+ assert_equal nil, Resque.pop(:people)
148
+ end
149
+
150
+ test "knows how big a queue is" do
151
+ assert_equal 3, Resque.size(:people)
152
+
153
+ assert_equal({ 'name' => 'chris' }, pop_no_id(:people))
154
+ assert_equal 2, Resque.size(:people)
155
+
156
+ assert_equal({ 'name' => 'bob' }, pop_no_id(:people))
157
+ assert_equal({ 'name' => 'mark' }, pop_no_id(:people))
158
+ assert_equal 0, Resque.size(:people)
159
+ end
160
+
161
+ test "can peek at a queue" do
162
+ peek = Resque.peek(:people)
163
+ peek.delete "_id"
164
+ assert_equal({ 'name' => 'chris' }, peek)
165
+ assert_equal 3, Resque.size(:people)
166
+ end
167
+
168
+ test "can peek multiple items on a queue" do
169
+ assert_equal('bob', Resque.peek(:people, 1, 1)['name'])
170
+ peek = Resque.peek(:people, 1, 2).map { |hash| { 'name' => hash['name']}}
171
+ assert_equal([{ 'name' => 'bob' }, { 'name' => 'mark' }], peek)
172
+ peek = Resque.peek(:people, 0, 2).map { |hash| { 'name' => hash['name']} }
173
+ assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }], peek)
174
+ peek = Resque.peek(:people, 0, 3).map { |hash| { 'name' => hash['name']} }
175
+ assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }, { 'name' => 'mark' }], peek)
176
+ peek = Resque.peek(:people, 2, 1)
177
+ assert_equal('mark', peek['name'])
178
+ assert_equal nil, Resque.peek(:people, 3)
179
+ assert_equal [], Resque.peek(:people, 3, 2)
180
+ end
181
+
182
+ test "knows what queues it is managing" do
183
+ assert_equal %w( people ), Resque.queues
184
+ Resque.push(:cars, { 'make' => 'bmw' })
185
+ assert_equal %w( cars people ), Resque.queues.sort
186
+ end
187
+
188
+ test "queues are always a list" do
189
+ Resque.drop
190
+ assert_equal [], Resque.queues
191
+ end
192
+
193
+ test "can delete a queue" do
194
+ Resque.push(:cars, { 'make' => 'bmw' })
195
+ assert_equal %w( cars people ), Resque.queues.sort
196
+ Resque.remove_queue(:people)
197
+ assert_equal %w( cars ), Resque.queues
198
+ assert_equal nil, Resque.pop(:people)
199
+ end
200
+
201
+ test "keeps track of resque keys" do
202
+ assert Resque.keys.include? 'people'
203
+ end
204
+
205
+ test "badly wants a class name, too" do
206
+ assert_raises Resque::NoClassError do
207
+ Resque::Job.create(:jobs, nil)
208
+ end
209
+ end
210
+
211
+ test "keeps stats" do
212
+ Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
213
+ Resque::Job.create(:jobs, BadJob)
214
+ Resque::Job.create(:jobs, GoodJob)
215
+
216
+ Resque::Job.create(:others, GoodJob)
217
+ Resque::Job.create(:others, GoodJob)
218
+
219
+ stats = Resque.info
220
+ assert_equal 8, stats[:pending]
221
+
222
+ @worker = Resque::Worker.new(:jobs)
223
+ @worker.register_worker
224
+ 2.times { @worker.process }
225
+
226
+ job = @worker.reserve
227
+ @worker.working_on job
228
+
229
+ stats = Resque.info
230
+ assert_equal 1, stats[:working]
231
+ assert_equal 1, stats[:workers]
232
+
233
+ @worker.done_working
234
+
235
+ stats = Resque.info
236
+ assert_equal 3, stats[:queues]
237
+ assert_equal 3, stats[:processed]
238
+ assert_equal 1, stats[:failed]
239
+ # assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
240
+ end
241
+
242
+ test "decode bad json" do
243
+ assert_nil Resque.decode("{\"error\":\"Module not found \\u002\"}")
244
+ end
245
+
246
+ test "unique jobs are unique" do
247
+ #does uniqueness work?
248
+ Resque.enqueue(UniqueJob, {:_id => 'my_id', :arg1=> 'my args1'})
249
+ assert_equal(1, Resque.size(:unique))
250
+ assert_equal('my args1', Resque.peek(:unique)['args'][0]['arg1'])
251
+ assert_equal('my_id', Resque.peek(:unique)['args'][0]['_id'])
252
+ Resque.enqueue(UniqueJob, {:_id => 'my_id', :arg1=> 'my args2'})
253
+ assert_equal(1, Resque.size(:unique))
254
+ assert_equal('my args2', Resque.peek(:unique)['args'][0]['arg1'])
255
+
256
+ #if I enqueue unique jobs with the same key in 2 queues, do I get 2 jobs?
257
+ Resque.enqueue(UniqueJob, {:_id => 'my_id3', :arg1=> 'my arg3'})
258
+ assert_equal(2, Resque.size(:unique))
259
+ Resque.enqueue(OtherUnique, {:_id => 'my_id3', :arg1=> 'my args4'})
260
+ #following line fails because :unique and :unique2 are in the same collection
261
+ #\assert_equal(2, Resque.size(:unique))
262
+ assert_equal(1, Resque.size(:unique2))
263
+
264
+ #can I enqueue normal jobs in the unique queue?
265
+ Resque.enqueue(NonUnique, {:arg1=> 'my args'})
266
+ assert_equal(3, Resque.size(:unique))
267
+ Resque.enqueue(NonUnique, {:_id => 'my_id', :_id => 'my_id', :arg1=> 'my args2'})
268
+ assert_equal(4, Resque.size(:unique))
269
+
270
+ #how do unique jobs work without a given _id?
271
+ Resque.enqueue(UniqueJob, {:arg1=> 'my args3'})
272
+ assert_equal(5, Resque.size(:unique))
273
+ assert_equal('my args3', Resque.peek(:unique, 4)['args'][0]['arg1'])
274
+ Resque.enqueue(UniqueJob, {:arg1=> 'my args4'})
275
+ assert_equal(6, Resque.size(:unique))
276
+ assert_equal('my args4', Resque.peek(:unique, 5)['args'][0]['arg1'])
277
+ end
278
+
279
+ test "Can bypass queues for testing" do
280
+ Resque.enqueue(NonUnique, 'test')
281
+ assert_equal(1, Resque.size(:unique))
282
+ Resque.bypass_queues = true
283
+ Resque.enqueue(NonUnique, 'test')
284
+ assert_equal(1, Resque.size(:unique))
285
+ Resque.bypass_queues = false
286
+ Resque.enqueue(NonUnique, 'test')
287
+ assert_equal(2, Resque.size(:unique))
288
+ end
289
+
290
+ test "delayed jobs work" do
291
+ args = { :delay_until => Time.new-1}
292
+ Resque.enqueue(DelayedJob, args)
293
+ job = Resque::Job.reserve(:delayed)
294
+ assert_equal(1, job.args[0].keys.length)
295
+ assert_equal(args[:delay_until].to_i, job.args[0]["delay_until"].to_i)
296
+ args[:delay_until] = Time.new + 2
297
+ assert_equal(0, Resque.delayed_size(:delayed))
298
+ Resque.enqueue(DelayedJob, args)
299
+
300
+ assert_equal(1, Resque.delayed_size(:delayed))
301
+ assert_nil Resque.peek(:delayed)
302
+ assert_nil Resque::Job.reserve(:delayed)
303
+ sleep 1
304
+ assert_nil Resque::Job.reserve(:delayed)
305
+ sleep 1
306
+ assert_equal(DelayedJob, Resque::Job.reserve(:delayed).payload_class)
307
+ end
308
+
309
+ test "delayed unique jobs modify args in place" do
310
+ args = { :delay_until => Time.new + 3600, :_id => 'unique'}
311
+ Resque.enqueue(DelayedJob, args)
312
+ assert_nil(Resque.peek(:delayed))
313
+ args[:delay_until] = Time.new - 1
314
+ Resque.enqueue(DelayedJob, args)
315
+ assert_equal(2, Resque::Job.reserve(:delayed).args[0].keys.count)
316
+ end
317
+
318
+ test "delayed attribute is ignored when bypassing queues" do
319
+ Resque.bypass_queues = true
320
+ args = { :delay_until => Time.new+20}
321
+ foo = Resque.enqueue(DelayedJob, args)
322
+ assert(0, Resque.size(:delayed))
323
+ assert(args[:delay_until] > Time.new)
324
+ assert(foo =~ /^delayed job executing/)
325
+ Resque.bypass_queues = false
326
+ end
327
+
328
+ test "other queues are not affected" do
329
+ args = { :delay_until => Time.new+10}
330
+ assert OtherUnique.instance_variable_get :@delayed_jobs
331
+ Resque.enqueue(OtherUnique, args)
332
+ job = Resque::Job.reserve(:unique2)
333
+ assert_equal(1, job.args[0].keys.length)
334
+ end
335
+
336
+ test "can enqueue normal jobs in a delayed queue" do
337
+ args = { :delay_until => Time.new + 3600}
338
+ Resque.enqueue(DelayedJob, args)
339
+ Resque.enqueue(DelayedJob, args)
340
+ Resque.enqueue(DelayedJob, args)
341
+ assert_equal(3, Resque.size(:delayed))
342
+ assert_equal(3, Resque.delayed_size(:delayed))
343
+ assert_equal(0, Resque.ready_size(:delayed))
344
+ Resque.enqueue(NonDelayedJob, args)
345
+ Resque.enqueue(NonDelayedJob, args)
346
+ Resque.enqueue(DelayedJob, args)
347
+ assert_equal(6, Resque.size(:delayed))
348
+ assert_equal(2, Resque.ready_size(:delayed))
349
+ assert_equal(4, Resque.delayed_size(:delayed))
350
+ end
351
+ end