win32-taskscheduler 0.2.2 → 0.3.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.
@@ -0,0 +1,33 @@
1
+ require 'ffi'
2
+
3
+ module Windows
4
+ module Helper
5
+ extend FFI::Library
6
+
7
+ ffi_lib :kernel32
8
+
9
+ attach_function :FormatMessage, :FormatMessageA,
10
+ [:ulong, :pointer, :ulong, :ulong, :pointer, :ulong, :pointer], :ulong
11
+
12
+ def win_error(function, err=FFI.errno)
13
+ flags = 0x00001000 | 0x00000200
14
+ buf = FFI::MemoryPointer.new(:char, 1024)
15
+
16
+ FormatMessage(flags, nil, err , 0x0409, buf, 1024, nil)
17
+
18
+ function + ': ' + buf.read_string.strip
19
+ end
20
+
21
+ def ole_error(function, err)
22
+ regex = /OLE error code:(.*?)\sin/
23
+ match = regex.match(err.to_s)
24
+
25
+ if match
26
+ error = match.captures.first.hex
27
+ win_error(function, error)
28
+ else
29
+ msg
30
+ end
31
+ end
32
+ end
33
+ end
@@ -1,538 +1,689 @@
1
- ##########################################################################
2
- # tc_taskscheduler.rb
3
- #
4
- # Test suite for the win32-taskscheduler package. You should run this
5
- # via the 'rake test' task.
6
- ##########################################################################
7
- require 'rubygems'
8
- gem 'test-unit'
9
-
10
- require 'test/unit'
11
- require 'win32/taskscheduler'
12
- require 'socket'
13
- include Win32
14
-
15
- class TC_TaskScheduler < Test::Unit::TestCase
16
- def self.startup
17
- @@host = Socket.gethostname
18
- end
19
-
20
- def setup
21
- @task = 'foo'
22
- @job_file = "C:\\WINDOWS\\Tasks\\test.job"
23
-
24
- @trigger = {
25
- 'start_year' => 2009,
26
- 'start_month' => 4,
27
- 'start_day' => 11,
28
- 'start_hour' => 7,
29
- 'start_minute' => 14,
30
- 'trigger_type' => TaskScheduler::DAILY,
31
- 'type' => { 'days_interval' => 1 }
32
- }
33
-
34
- @ts = TaskScheduler.new(@task, @trigger)
35
- @ts.save
36
- @ts.activate(@task)
37
- end
38
-
39
- def test_version
40
- assert_equal('0.2.2', TaskScheduler::VERSION)
41
- end
42
-
43
- def test_get_account_information
44
- assert_respond_to(@ts, :account_information)
45
- assert_equal(nil, @ts.account_information)
46
- end
47
-
48
- def test_get_account_information_expected_errors
49
- assert_raise(ArgumentError){ @ts.account_information('foo') }
50
- end
51
-
52
- def test_set_account_information
53
- assert_nothing_raised{ @ts.set_account_information('test', 'XXXX') }
54
- assert_equal('test', @ts.account_information)
55
- end
56
-
57
- def test_set_account_information_expected_errors
58
- assert_raise(ArgumentError){ @ts.set_account_information }
59
- assert_raise(ArgumentError){ @ts.set_account_information('x') }
60
- assert_raise(ArgumentError){ @ts.set_account_information('x', 'y', 'z') }
61
- assert_raise(TypeError){ @ts.set_account_information(1, 'XXX') }
62
- assert_raise(TypeError){ @ts.set_account_information('x', 1) }
63
- end
64
-
65
- def test_activate
66
- assert_nothing_raised{ @ts.activate('foo') }
67
- assert_nothing_raised{ @ts.activate('foo') } # Intentional duplicate
68
- end
69
-
70
- def test_activate_expected_errors
71
- assert_raise(ArgumentError){ @ts.activate }
72
- assert_raise(ArgumentError){ @ts.activate('foo', 'bar') }
73
- assert_raise(TypeError){ @ts.activate(1) }
74
- assert_raise(TaskScheduler::Error){ @ts.activate('bogus') }
75
- end
76
-
77
- def test_get_application_name
78
- assert_respond_to(@ts, :application_name)
79
- assert_nothing_raised{ @ts.application_name }
80
- assert_kind_of(String, @ts.application_name)
81
- end
82
-
83
- def test_get_application_name_expected_errors
84
- assert_raises(ArgumentError){ @ts.application_name('bogus') }
85
- end
86
-
87
- def test_set_application_name
88
- assert_respond_to(@ts, :application_name=)
89
- assert_nothing_raised{ @ts.application_name = "notepad.exe" }
90
- end
91
-
92
- def test_set_application_name_expected_errors
93
- assert_raise(ArgumentError){ @ts.send(:application_name=) }
94
- assert_raise(TypeError){ @ts.application_name = 1 }
95
- end
96
-
97
- def test_get_comment
98
- assert_respond_to(@ts, :comment)
99
- assert_nothing_raised{ @ts.comment }
100
- assert_kind_of(String, @ts.comment)
101
- end
102
-
103
- def test_get_comment_expected_errors
104
- assert_raise(ArgumentError){ @ts.comment('test') }
105
- end
106
-
107
- def test_set_comment
108
- assert_respond_to(@ts, :comment=)
109
- assert_nothing_raised{ @ts.comment = "test" }
110
- end
111
-
112
- def test_set_comment_expected_errors
113
- assert_raise(ArgumentError){ @ts.send(:comment=) }
114
- assert_raise(TypeError){ @ts.comment = 1 }
115
- end
116
-
117
- def test_get_creator
118
- assert_respond_to(@ts, :creator)
119
- assert_nothing_raised{ @ts.creator }
120
- assert_kind_of(String, @ts.creator)
121
- end
122
-
123
- def test_get_creator_expected_errors
124
- assert_raise(ArgumentError){ @ts.creator('foo') }
125
- end
126
-
127
- def test_set_creator
128
- assert_respond_to(@ts, :creator=)
129
- assert_nothing_raised{ @ts.creator = "Test Creator" }
130
- end
131
-
132
- def test_set_creator_expected_errors
133
- assert_raise(ArgumentError){ @ts.send(:creator=) }
134
- assert_raise(TypeError){ @ts.creator = 1 }
135
- end
136
-
137
- def test_delete
138
- assert_respond_to(@ts, :delete)
139
- assert_nothing_raised{ @ts.delete(@task) }
140
- end
141
-
142
- def test_delete_expected_errors
143
- assert_raise(ArgumentError){ @ts.delete }
144
- assert_raise(TaskScheduler::Error){ @ts.delete("foofoo") }
145
- end
146
-
147
- def test_delete_trigger
148
- assert_respond_to(@ts, :delete_trigger)
149
- assert_equal(0, @ts.delete_trigger(0))
150
- end
151
-
152
- # TODO: Figure out why the last two fail
153
- def test_delete_trigger_expected_errors
154
- assert_raise(ArgumentError){ @ts.delete }
155
- #assert_raise(TypeError){ @ts.delete('test') }
156
- #assert_raise(TaskScheduler::Error){ @ts.delete(-1) }
157
- end
158
-
159
- def test_enum
160
- assert_respond_to(@ts, :enum)
161
- assert_kind_of(Array, @ts.enum)
162
- assert_nothing_raised{ @ts.enum }
163
- end
164
-
165
- def test_enum_expected_errors
166
- assert_raise(ArgumentError){ @ts.enum(1) }
167
- assert_raise(NoMethodError){ @ts.enum = true }
168
- end
169
-
170
- def test_exists_basic
171
- assert_respond_to(@ts, :exists?)
172
- assert_boolean(@ts.exists?(@task))
173
- end
174
-
175
- def test_exists
176
- assert_true(@ts.exists?(@task))
177
- assert_false(@ts.exists?('bogusXYZ'))
178
- end
179
-
180
- def test_exists_expected_errors
181
- assert_raise(ArgumentError){ @ts.exists? }
182
- assert_raise(ArgumentError){ @ts.exists?('foo', 'bar') }
183
- end
184
-
185
- def test_exit_code
186
- assert_respond_to(@ts, :exit_code)
187
- assert_nothing_raised{ @ts.exit_code }
188
- assert_kind_of(Fixnum, @ts.exit_code)
189
- end
190
-
191
- def test_exit_code_expected_errors
192
- assert_raise(ArgumentError){ @ts.exit_code(true) }
193
- assert_raise(NoMethodError){ @ts.exit_code = 1 }
194
- end
195
-
196
- def test_get_flags
197
- assert_respond_to(@ts, :flags)
198
- assert_nothing_raised{ @ts.flags }
199
- assert_kind_of(Fixnum, @ts.flags)
200
- end
201
-
202
- def test_get_flags_expected_errors
203
- assert_raise(ArgumentError){ @ts.flags(1) }
204
- end
205
-
206
- def test_set_flags
207
- assert_respond_to(@ts, :flags=)
208
- assert_nothing_raised{ @ts.flags = TaskScheduler::DELETE_WHEN_DONE }
209
- end
210
-
211
- def test_set_flags_expected_errors
212
- assert_raise(ArgumentError){ @ts.send(:flags=) }
213
- assert_raise(TypeError){ @ts.flags = 'test' }
214
- end
215
-
216
- # TODO: Why does setting the host fail?
217
- def test_set_machine
218
- assert_respond_to(@ts, :host=)
219
- assert_respond_to(@ts, :machine=)
220
- #assert_nothing_raised{ @ts.machine = @@host }
221
- end
222
-
223
- def test_get_max_run_time
224
- assert_respond_to(@ts, :max_run_time)
225
- assert_nothing_raised{ @ts.max_run_time }
226
- assert_kind_of(Fixnum, @ts.max_run_time)
227
- end
228
-
229
- def test_get_max_run_time_expected_errors
230
- assert_raise(ArgumentError){ @ts.max_run_time(true) }
231
- end
232
-
233
- def test_set_max_run_time
234
- assert_respond_to(@ts, :max_run_time=)
235
- assert_nothing_raised{ @ts.max_run_time = 20000 }
236
- end
237
-
238
- def test_set_max_run_time_expected_errors
239
- assert_raise(ArgumentError){ @ts.send(:max_run_time=) }
240
- assert_raise(TypeError){ @ts.max_run_time = true }
241
- end
242
-
243
- def test_most_recent_run_time
244
- assert_respond_to(@ts, :most_recent_run_time)
245
- assert_nothing_raised{ @ts.most_recent_run_time }
246
- assert_nil(@ts.most_recent_run_time)
247
- end
248
-
249
- def test_most_recent_run_time_expected_errors
250
- assert_raise(ArgumentError){ @ts.most_recent_run_time(true) }
251
- assert_raise(NoMethodError){ @ts.most_recent_run_time = Time.now }
252
- end
253
-
254
- def test_new_work_item
255
- assert_respond_to(@ts, :new_work_item)
256
- assert_nothing_raised{ @ts.new_work_item('bar', @trigger) }
257
- end
258
-
259
- def test_new_work_item_expected_errors
260
- assert_raise(ArgumentError){ @ts.new_work_item('test', {:bogus => 1}) }
261
- end
262
-
263
- def test_new_task_alias
264
- assert_respond_to(@ts, :new_task)
265
- assert_equal(true, @ts.method(:new_task) == @ts.method(:new_work_item))
266
- end
267
-
268
- def test_new_work_item_expected_argument_errors
269
- assert_raise(ArgumentError){ @ts.new_work_item }
270
- assert_raise(ArgumentError){ @ts.new_work_item('bar') }
271
- assert_raise(TypeError){ @ts.new_work_item(1, 'bar') }
272
- assert_raise(TypeError){ @ts.new_work_item('bar', 1) }
273
- end
274
-
275
- def test_next_run_time
276
- assert_respond_to(@ts, :next_run_time)
277
- assert_nothing_raised{ @ts.next_run_time }
278
- assert_kind_of(Time, @ts.next_run_time)
279
- end
280
-
281
- def test_next_run_time_expected_errors
282
- assert_raise(ArgumentError){ @ts.next_run_time(true) }
283
- assert_raise(NoMethodError){ @ts.next_run_time = Time.now }
284
- end
285
-
286
- def test_get_parameters
287
- assert_respond_to(@ts, :parameters)
288
- assert_nothing_raised{ @ts.parameters }
289
- end
290
-
291
- def test_get_parameters_expected_errors
292
- assert_raise(ArgumentError){ @ts.parameters('test') }
293
- end
294
-
295
- def set_parameters
296
- assert_respond_to(@ts, :parameters=)
297
- assert_nothing_raised{ @ts.parameters = "somefile.txt" }
298
- end
299
-
300
- def set_parameters_expected_errors
301
- assert_raise(ArgumentError){ @ts.send(:parameters=) }
302
- assert_raise(TypeError){ @ts.parameters = 1 }
303
- end
304
-
305
- def test_get_priority
306
- assert_respond_to(@ts, :priority)
307
- assert_nothing_raised{ @ts.priority }
308
- assert_kind_of(String, @ts.priority)
309
- end
310
-
311
- def test_get_priority_expected_errors
312
- assert_raise(ArgumentError){ @ts.priority(true) }
313
- end
314
-
315
- def test_set_priority
316
- assert_respond_to(@ts, :priority=)
317
- assert_nothing_raised{ @ts.priority = TaskScheduler::NORMAL }
318
- end
319
-
320
- def test_set_priority_expected_errors
321
- assert_raise(ArgumentError){ @ts.send(:priority=) }
322
- assert_raise(TypeError){ @ts.priority = 'alpha' }
323
- end
324
-
325
- # TODO: Find a harmless way to test this.
326
- def test_run
327
- assert_respond_to(@ts, :run)
328
- end
329
-
330
- def test_run_expected_errors
331
- assert_raise(ArgumentError){ @ts.run(true) }
332
- assert_raise(NoMethodError){ @ts.run = true }
333
- end
334
-
335
- def test_save
336
- assert_respond_to(@ts, :save)
337
- assert_nothing_raised{ @ts.save }
338
- end
339
-
340
- def test_save_custom_file
341
- assert_nothing_raised{ @ts.save(@job_file) }
342
- assert_equal(true, File.exists?(@job_file))
343
- end
344
-
345
- def test_save_expected_errors
346
- assert_raise(TypeError){ @ts.save(true) }
347
- assert_raise(ArgumentError){ @ts.save(@job_file, true) }
348
- assert_raise(NoMethodError){ @ts.save = true }
349
- assert_raise(TaskScheduler::Error){ @ts.save; @ts.save }
350
- end
351
-
352
- def test_status
353
- assert_respond_to(@ts, :status)
354
- assert_nothing_raised{ @ts.status }
355
- assert_equal('not scheduled', @ts.status)
356
- end
357
-
358
- def test_status_expected_errors
359
- assert_raise(ArgumentError){ @ts.status(true) }
360
- assert_raise(NoMethodError){ @ts.status = true }
361
- end
362
-
363
- def test_terminate
364
- assert_respond_to(@ts, :terminate)
365
- end
366
-
367
- def test_terminate_expected_errors
368
- assert_raise(ArgumentError){ @ts.terminate(true) }
369
- assert_raise(NoMethodError){ @ts.terminate = true }
370
- assert_raise(TaskScheduler::Error){ @ts.terminate } # It's not running
371
- end
372
-
373
- def test_get_trigger
374
- assert_respond_to(@ts, :trigger)
375
- assert_nothing_raised{ @ts.trigger(0) }
376
- assert_kind_of(Hash, @ts.trigger(0))
377
- end
378
-
379
- def test_get_trigger_expected_errors
380
- assert_raises(ArgumentError){ @ts.trigger }
381
- assert_raises(TaskScheduler::Error){ @ts.trigger(9999) }
382
- end
383
-
384
- def test_set_trigger
385
- assert_respond_to(@ts, :trigger=)
386
- assert_nothing_raised{ @ts.trigger = @trigger }
387
- end
388
-
389
- def test_set_trigger_transforms_and_validates
390
- symbol_trigger = @trigger.dup
391
- symbol_trigger[:TriGger_type] = symbol_trigger.delete('trigger_type')
392
- assert_nothing_raised{ @ts.trigger = symbol_trigger }
393
- end
394
-
395
- def test_set_trigger_expected_errors
396
- assert_raises(TypeError){ @ts.trigger = 'blah' }
397
- end
398
-
399
- def test_add_trigger
400
- assert_respond_to(@ts, :add_trigger)
401
- assert_nothing_raised{ @ts.add_trigger(0, @trigger) }
402
- end
403
-
404
- def test_add_trigger_transforms_and_validates
405
- symbol_trigger = @trigger.dup
406
- symbol_trigger[:TriGger_type] = symbol_trigger.delete('trigger_type')
407
- assert_nothing_raised{ @ts.add_trigger(0, symbol_trigger) }
408
- end
409
-
410
- def test_add_trigger_expected_errors
411
- assert_raises(ArgumentError){ @ts.add_trigger }
412
- assert_raises(ArgumentError){ @ts.add_trigger(0) }
413
- assert_raises(TypeError){ @ts.add_trigger(0, 'foo') }
414
- end
415
-
416
- def test_trigger_count
417
- assert_respond_to(@ts, :trigger_count)
418
- assert_nothing_raised{ @ts.trigger_count }
419
- assert_kind_of(Fixnum, @ts.trigger_count)
420
- end
421
-
422
- def test_trigger_count_expected_errors
423
- assert_raise(ArgumentError){ @ts.trigger_count(true) }
424
- assert_raise(NoMethodError){ @ts.trigger_count = 1 }
425
- end
426
-
427
- def test_trigger_delete
428
- assert_respond_to(@ts, :delete_trigger)
429
- assert_nothing_raised{ @ts.delete_trigger(0) }
430
- end
431
-
432
- def test_trigger_delete_expected_errors
433
- assert_raise(ArgumentError){ @ts.delete_trigger }
434
- assert_raise(TaskScheduler::Error){ @ts.delete_trigger(9999) }
435
- end
436
-
437
- def test_trigger_string
438
- assert_respond_to(@ts, :trigger_string)
439
- assert_nothing_raised{ @ts.trigger_string(0) }
440
- assert_equal('At 7:14 AM every day, starting 4/11/2009', @ts.trigger_string(0))
441
- end
442
-
443
- def test_trigger_string_expected_errors
444
- assert_raise(ArgumentError){ @ts.trigger_string }
445
- assert_raise(ArgumentError){ @ts.trigger_string(0, 0) }
446
- assert_raise(TypeError){ @ts.trigger_string('alpha') }
447
- assert_raise(TaskScheduler::Error){ @ts.trigger_string(9999) }
448
- end
449
-
450
- def test_get_working_directory
451
- assert_respond_to(@ts, :working_directory)
452
- assert_nothing_raised{ @ts.working_directory }
453
- assert_kind_of(String, @ts.working_directory)
454
- end
455
-
456
- def test_get_working_directory_expected_errors
457
- assert_raise(ArgumentError){ @ts.working_directory(true) }
458
- end
459
-
460
- def test_set_working_directory
461
- assert_respond_to(@ts, :working_directory=)
462
- assert_nothing_raised{ @ts.working_directory = "C:\\" }
463
- end
464
-
465
- def test_set_working_directory_expected_errors
466
- assert_raise(ArgumentError){ @ts.send(:working_directory=) }
467
- assert_raise(TypeError){ @ts.working_directory = 1 }
468
- end
469
-
470
- def test_constants
471
- assert_not_nil(TaskScheduler::MONDAY)
472
- assert_not_nil(TaskScheduler::TUESDAY)
473
- assert_not_nil(TaskScheduler::WEDNESDAY)
474
- assert_not_nil(TaskScheduler::THURSDAY)
475
- assert_not_nil(TaskScheduler::FRIDAY)
476
- assert_not_nil(TaskScheduler::SATURDAY)
477
- assert_not_nil(TaskScheduler::SUNDAY)
478
-
479
- assert_not_nil(TaskScheduler::JANUARY)
480
- assert_not_nil(TaskScheduler::FEBRUARY)
481
- assert_not_nil(TaskScheduler::MARCH)
482
- assert_not_nil(TaskScheduler::APRIL)
483
- assert_not_nil(TaskScheduler::MAY)
484
- assert_not_nil(TaskScheduler::JUNE)
485
- assert_not_nil(TaskScheduler::JULY)
486
- assert_not_nil(TaskScheduler::AUGUST)
487
- assert_not_nil(TaskScheduler::SEPTEMBER)
488
- assert_not_nil(TaskScheduler::OCTOBER)
489
- assert_not_nil(TaskScheduler::NOVEMBER)
490
- assert_not_nil(TaskScheduler::DECEMBER)
491
-
492
- assert_not_nil(TaskScheduler::ONCE)
493
- assert_not_nil(TaskScheduler::DAILY)
494
- assert_not_nil(TaskScheduler::WEEKLY)
495
- assert_not_nil(TaskScheduler::MONTHLYDATE)
496
- assert_not_nil(TaskScheduler::MONTHLYDOW)
497
-
498
- assert_not_nil(TaskScheduler::ON_IDLE)
499
- assert_not_nil(TaskScheduler::AT_SYSTEMSTART)
500
- assert_not_nil(TaskScheduler::AT_LOGON)
501
-
502
- assert_not_nil(TaskScheduler::INTERACTIVE)
503
- assert_not_nil(TaskScheduler::DELETE_WHEN_DONE)
504
- assert_not_nil(TaskScheduler::DISABLED)
505
- assert_not_nil(TaskScheduler::START_ONLY_IF_IDLE)
506
- assert_not_nil(TaskScheduler::KILL_ON_IDLE_END)
507
- assert_not_nil(TaskScheduler::DONT_START_IF_ON_BATTERIES)
508
- assert_not_nil(TaskScheduler::KILL_IF_GOING_ON_BATTERIES)
509
- assert_not_nil(TaskScheduler::HIDDEN)
510
- assert_not_nil(TaskScheduler::RESTART_ON_IDLE_RESUME)
511
- assert_not_nil(TaskScheduler::SYSTEM_REQUIRED)
512
- assert_not_nil(TaskScheduler::FLAG_HAS_END_DATE)
513
- assert_not_nil(TaskScheduler::FLAG_KILL_AT_DURATION_END)
514
- assert_not_nil(TaskScheduler::FLAG_DISABLED)
515
- assert_not_nil(TaskScheduler::MAX_RUN_TIMES)
516
-
517
- assert_not_nil(TaskScheduler::IDLE)
518
- assert_not_nil(TaskScheduler::NORMAL)
519
- assert_not_nil(TaskScheduler::HIGH)
520
- assert_not_nil(TaskScheduler::REALTIME)
521
- assert_not_nil(TaskScheduler::ABOVE_NORMAL)
522
- assert_not_nil(TaskScheduler::BELOW_NORMAL)
523
- end
524
-
525
- def teardown
526
- File.delete(@job_file) if File.exists?(@job_file)
527
- @ts.delete(@task) if @ts.enum.include?(@task + '.job')
528
-
529
- @ts = nil
530
- @trigger = nil
531
- @job_file = nil
532
- @task = nil
533
- end
534
-
535
- def self.shutdown
536
- @@host = nil
537
- end
538
- end
1
+ ##########################################################################
2
+ # test_taskscheduler.rb
3
+ #
4
+ # Test suite for the win32-taskscheduler package. You should run this
5
+ # via the 'rake test' task.
6
+ ##########################################################################
7
+ require 'win32/taskscheduler'
8
+ require 'win32/security'
9
+ require 'socket'
10
+ require 'test-unit'
11
+ require 'etc'
12
+ include Win32
13
+
14
+ class TC_TaskScheduler < Test::Unit::TestCase
15
+ def self.startup
16
+ @@host = Socket.gethostname
17
+ @@user = Etc.getlogin
18
+ @@elevated = Win32::Security.elevated_security?
19
+ end
20
+
21
+ def setup
22
+ @task = 'foo'
23
+
24
+ @trigger = {
25
+ :start_year => 2015,
26
+ :start_month => 4,
27
+ :start_day => 11,
28
+ :start_hour => 7,
29
+ :start_minute => 14,
30
+ :trigger_type => TaskScheduler::DAILY,
31
+ :type => { :days_interval => 1 }
32
+ }
33
+
34
+ @ts = TaskScheduler.new
35
+ end
36
+
37
+ # Helper method
38
+ def setup_task
39
+ @ts.new_work_item(@task, @trigger)
40
+ @ts.activate(@task)
41
+ end
42
+
43
+ test "version constant is set to expected value" do
44
+ assert_equal('0.3.0', TaskScheduler::VERSION)
45
+ end
46
+
47
+ test "account_information method basic functionality" do
48
+ assert_respond_to(@ts, :account_information)
49
+ end
50
+
51
+ test "account_information returns the task owner" do
52
+ setup_task
53
+ assert_equal("#{@@host}\\#{@@user}", @ts.account_information)
54
+ end
55
+
56
+ test "account_information returns nil if no task has been activated" do
57
+ assert_nil(@ts.account_information)
58
+ end
59
+
60
+ test "account_information does not accept any arguments" do
61
+ assert_raise(ArgumentError){ @ts.account_information('foo') }
62
+ end
63
+
64
+ test "set_account_information basic functionality" do
65
+ assert_respond_to(@ts, :set_account_information)
66
+ end
67
+
68
+ test "set_account_information works as expected" do
69
+ setup_task
70
+ #assert_nothing_raised{ @ts.set_account_information(@@user, 'XXXX') }
71
+ #assert_equal('test', @ts.account_information)
72
+ end
73
+
74
+ test "set_account_information requires two arguments" do
75
+ setup_task
76
+ assert_raise(ArgumentError){ @ts.set_account_information }
77
+ assert_raise(ArgumentError){ @ts.set_account_information('x') }
78
+ assert_raise(ArgumentError){ @ts.set_account_information('x', 'y', 'z') }
79
+ end
80
+
81
+ test "arguments to set_account_information must be strings" do
82
+ setup_task
83
+ assert_raise(TypeError){ @ts.set_account_information(1, 'XXX') }
84
+ assert_raise(TypeError){ @ts.set_account_information('x', 1) }
85
+ end
86
+
87
+ test "activate method basic functionality" do
88
+ assert_respond_to(@ts, :activate)
89
+ end
90
+
91
+ test "activate behaves as expected" do
92
+ @ts.new_work_item(@task, @trigger)
93
+ assert_nothing_raised{ @ts.activate(@task) }
94
+ end
95
+
96
+ test "calling activate on the same object multiple times has no effect" do
97
+ @ts.new_work_item(@task, @trigger)
98
+ assert_nothing_raised{ @ts.activate(@task) }
99
+ assert_nothing_raised{ @ts.activate(@task) }
100
+ end
101
+
102
+ test "activate requires a single argument" do
103
+ assert_raise(ArgumentError){ @ts.activate }
104
+ assert_raise(ArgumentError){ @ts.activate('foo', 'bar') }
105
+ end
106
+
107
+ test "activate requires a string argument" do
108
+ assert_raise(TypeError){ @ts.activate(1) }
109
+ end
110
+
111
+ test "attempting to activate a bad task results in an error" do
112
+ assert_raise(TaskScheduler::Error){ @ts.activate('bogus') }
113
+ end
114
+
115
+ test "application_name basic functionality" do
116
+ assert_respond_to(@ts, :application_name)
117
+ end
118
+
119
+ test "application_name returns a string or nil" do
120
+ setup_task
121
+ assert_nothing_raised{ @ts.application_name }
122
+ assert_kind_of([String, NilClass], @ts.application_name)
123
+ end
124
+
125
+ test "application_name does not accept any arguments" do
126
+ assert_raises(ArgumentError){ @ts.application_name('bogus') }
127
+ end
128
+
129
+ test "application_name= basic functionality" do
130
+ assert_respond_to(@ts, :application_name=)
131
+ end
132
+
133
+ test "application_name= works as expected" do
134
+ setup_task
135
+ assert_nothing_raised{ @ts.application_name = "notepad.exe" }
136
+ assert_equal("notepad.exe", @ts.application_name)
137
+ end
138
+
139
+ test "application_name= requires a string argument" do
140
+ assert_raise(TypeError){ @ts.application_name = 1 }
141
+ end
142
+
143
+ test "comment method basic functionality" do
144
+ assert_respond_to(@ts, :comment)
145
+ end
146
+
147
+ test "comment method returns a string" do
148
+ setup_task
149
+ assert_nothing_raised{ @ts.comment }
150
+ assert_kind_of(String, @ts.comment)
151
+ end
152
+
153
+ test "comment method does not accept any arguments" do
154
+ assert_raise(ArgumentError){ @ts.comment('test') }
155
+ end
156
+
157
+ test "comment= method basic functionality" do
158
+ assert_respond_to(@ts, :comment=)
159
+ end
160
+
161
+ test "comment= works as expected" do
162
+ setup_task
163
+ assert_nothing_raised{ @ts.comment = "test" }
164
+ assert_equal("test", @ts.comment)
165
+ end
166
+
167
+ test "comment= method requires a string argument" do
168
+ assert_raise(TypeError){ @ts.comment = 1 }
169
+ end
170
+
171
+ test "creator method basic functionality" do
172
+ setup_task
173
+ assert_respond_to(@ts, :creator)
174
+ assert_nothing_raised{ @ts.creator }
175
+ assert_kind_of(String, @ts.creator)
176
+ end
177
+
178
+ test "creator method returns expected value" do
179
+ setup_task
180
+ assert_equal('', @ts.creator)
181
+ end
182
+
183
+ test "creator method does not accept any arguments" do
184
+ assert_raise(ArgumentError){ @ts.creator('foo') }
185
+ end
186
+
187
+ test "creator= method basic functionality" do
188
+ assert_respond_to(@ts, :creator=)
189
+ end
190
+
191
+ test "creator= method works as expected" do
192
+ setup_task
193
+ assert_nothing_raised{ @ts.creator = "Test Creator" }
194
+ assert_equal("Test Creator", @ts.creator)
195
+ end
196
+
197
+ test "creator= method requires a string argument" do
198
+ assert_raise(TypeError){ @ts.creator = 1 }
199
+ end
200
+
201
+ test "delete method basic functionality" do
202
+ assert_respond_to(@ts, :delete)
203
+ end
204
+
205
+ test "delete method works as expected" do
206
+ setup_task
207
+ assert_nothing_raised{ @ts.delete(@task) }
208
+ assert_false(@ts.exists?(@task))
209
+ end
210
+
211
+ test "delete method requires a single argument" do
212
+ assert_raise(ArgumentError){ @ts.delete }
213
+ end
214
+
215
+ test "delete method raises an error if the task does not exist" do
216
+ assert_raise(TaskScheduler::Error){ @ts.delete("foofoo") }
217
+ end
218
+
219
+ test "enum basic functionality" do
220
+ assert_respond_to(@ts, :enum)
221
+ assert_nothing_raised{ @ts.enum }
222
+ end
223
+
224
+ test "enum method returns an array of strings" do
225
+ assert_kind_of(Array, @ts.enum)
226
+ assert_kind_of(String, @ts.enum.first)
227
+ end
228
+
229
+ test "tasks is an alias for enum" do
230
+ assert_respond_to(@ts, :tasks)
231
+ assert_alias_method(@ts, :tasks, :enum)
232
+ end
233
+
234
+ test "enum method does not accept any arguments" do
235
+ assert_raise(ArgumentError){ @ts.enum(1) }
236
+ end
237
+
238
+ test "exists? basic functionality" do
239
+ assert_respond_to(@ts, :exists?)
240
+ assert_boolean(@ts.exists?(@task))
241
+ end
242
+
243
+ test "exists? returns expected value" do
244
+ setup_task
245
+ assert_true(@ts.exists?(@task))
246
+ assert_false(@ts.exists?('bogusXYZ'))
247
+ end
248
+
249
+ test "exists? method requires a single argument" do
250
+ assert_raise(ArgumentError){ @ts.exists? }
251
+ assert_raise(ArgumentError){ @ts.exists?('foo', 'bar') }
252
+ end
253
+
254
+ test "exit_code basic functionality" do
255
+ setup_task
256
+ assert_respond_to(@ts, :exit_code)
257
+ assert_nothing_raised{ @ts.exit_code }
258
+ assert_kind_of(Fixnum, @ts.exit_code)
259
+ end
260
+
261
+ test "exit_code takes no arguments" do
262
+ assert_raise(ArgumentError){ @ts.exit_code(true) }
263
+ assert_raise(NoMethodError){ @ts.exit_code = 1 }
264
+ end
265
+
266
+ test "machine= basic functionality" do
267
+ assert_respond_to(@ts, :machine=)
268
+ end
269
+
270
+ test "machine= works as expected" do
271
+ omit_unless(@@elevated)
272
+ setup_task
273
+ assert_nothing_raised{ @ts.machine = @@host }
274
+ assert_equal(@@host, @ts.machine)
275
+ end
276
+
277
+ test "host= is an alias for machine=" do
278
+ assert_alias_method(@ts, :machine=, :host=)
279
+ end
280
+
281
+ test "set_machine basic functionality" do
282
+ assert_respond_to(@ts, :set_machine)
283
+ end
284
+
285
+ test "set_host is an alias for set_machine" do
286
+ assert_alias_method(@ts, :set_machine, :set_host)
287
+ end
288
+
289
+ test "max_run_time basic functionality" do
290
+ assert_respond_to(@ts, :max_run_time)
291
+ end
292
+
293
+ test "max_run_time works as expected" do
294
+ setup_task
295
+ assert_nothing_raised{ @ts.max_run_time }
296
+ assert_kind_of(Fixnum, @ts.max_run_time)
297
+ end
298
+
299
+ test "max_run_time accepts no arguments" do
300
+ assert_raise(ArgumentError){ @ts.max_run_time(true) }
301
+ end
302
+
303
+ test "max_run_time= basic functionality" do
304
+ assert_respond_to(@ts, :max_run_time=)
305
+ end
306
+
307
+ test "max_run_time= works as expected" do
308
+ setup_task
309
+ assert_nothing_raised{ @ts.max_run_time = 20000 }
310
+ assert_equal(20000, @ts.max_run_time)
311
+ end
312
+
313
+ test "max_run_time= requires a numeric argument" do
314
+ assert_raise(TypeError){ @ts.max_run_time = true }
315
+ end
316
+
317
+ test "most_recent_run_time basic functionality" do
318
+ setup_task
319
+ assert_respond_to(@ts, :most_recent_run_time)
320
+ assert_nothing_raised{ @ts.most_recent_run_time }
321
+ end
322
+
323
+ test "most_recent_run_time is nil if task hasn't run" do
324
+ setup_task
325
+ assert_nil(@ts.most_recent_run_time)
326
+ end
327
+
328
+ test "most_recent_run_time does not accept any arguments" do
329
+ assert_raise(ArgumentError){ @ts.most_recent_run_time(true) }
330
+ assert_raise(NoMethodError){ @ts.most_recent_run_time = Time.now }
331
+ end
332
+
333
+ test "new_work_item basic functionality" do
334
+ assert_respond_to(@ts, :new_work_item)
335
+ end
336
+
337
+ test "new_work_item accepts a trigger/hash" do
338
+ assert_nothing_raised{ @ts.new_work_item('bar', @trigger) }
339
+ end
340
+
341
+ test "new_work_item fails if a bogus trigger key is present" do
342
+ assert_raise(ArgumentError){ @ts.new_work_item('test', {:bogus => 1}) }
343
+ end
344
+
345
+ test "new_task is an alias for new_work_item" do
346
+ assert_respond_to(@ts, :new_task)
347
+ assert_alias_method(@ts, :new_task, :new_work_item)
348
+ end
349
+
350
+ test "new_work_item requires a task name and a trigger" do
351
+ assert_raise(ArgumentError){ @ts.new_work_item }
352
+ assert_raise(ArgumentError){ @ts.new_work_item('bar') }
353
+ end
354
+
355
+ test "new_work_item expects a string for the first argument" do
356
+ assert_raise(TypeError){ @ts.new_work_item(1, @trigger) }
357
+ end
358
+
359
+ test "new_work_item expects a hash for the second argument" do
360
+ assert_raise(TypeError){ @ts.new_work_item(@task, 1) }
361
+ end
362
+
363
+ test "next_run_time basic functionality" do
364
+ assert_respond_to(@ts, :next_run_time)
365
+ end
366
+
367
+ test "next_run_time returns a Time object" do
368
+ setup_task
369
+ assert_nothing_raised{ @ts.next_run_time }
370
+ assert_kind_of(Time, @ts.next_run_time)
371
+ end
372
+
373
+ test "next_run_time does not take any arguments" do
374
+ assert_raise(ArgumentError){ @ts.next_run_time(true) }
375
+ assert_raise(NoMethodError){ @ts.next_run_time = Time.now }
376
+ end
377
+
378
+ test "parameters basic functionality" do
379
+ setup_task
380
+ assert_respond_to(@ts, :parameters)
381
+ assert_nothing_raised{ @ts.parameters }
382
+ end
383
+
384
+ test "parameters method does not take any arguments" do
385
+ assert_raise(ArgumentError){ @ts.parameters('test') }
386
+ end
387
+
388
+ test "parameters= basic functionality" do
389
+ assert_respond_to(@ts, :parameters=)
390
+ end
391
+
392
+ test "parameters= works as expected" do
393
+ setup_task
394
+ assert_nothing_raised{ @ts.parameters = "somefile.txt" }
395
+ assert_equal("somefile.txt", @ts.parameters)
396
+ end
397
+
398
+ test "parameters= requires a string argument" do
399
+ assert_raise(ArgumentError){ @ts.send(:parameters=) }
400
+ assert_raise(TypeError){ @ts.parameters = 1 }
401
+ end
402
+
403
+ test "priority basic functionality" do
404
+ assert_respond_to(@ts, :priority)
405
+ end
406
+
407
+ test "priority returns the expected value" do
408
+ setup_task
409
+ assert_nothing_raised{ @ts.priority }
410
+ assert_kind_of(String, @ts.priority)
411
+ end
412
+
413
+ test "priority method does not accept any arguments" do
414
+ assert_raise(ArgumentError){ @ts.priority(true) }
415
+ end
416
+
417
+ test "priority= basic functionality" do
418
+ assert_respond_to(@ts, :priority=)
419
+ end
420
+
421
+ test "priority= works as expected" do
422
+ setup_task
423
+ assert_nothing_raised{ @ts.priority = TaskScheduler::NORMAL }
424
+ assert_equal('normal', @ts.priority)
425
+ end
426
+
427
+ test "priority= requires a numeric argument" do
428
+ assert_raise(TypeError){ @ts.priority = 'alpha' }
429
+ end
430
+
431
+ # TODO: Find a harmless way to test this.
432
+ test "run basic functionality" do
433
+ assert_respond_to(@ts, :run)
434
+ end
435
+
436
+ test "run does not accept any arguments" do
437
+ assert_raise(ArgumentError){ @ts.run(true) }
438
+ assert_raise(NoMethodError){ @ts.run = true }
439
+ end
440
+
441
+ test "save basic functionality" do
442
+ assert_respond_to(@ts, :save)
443
+ end
444
+
445
+ test "status basic functionality" do
446
+ setup_task
447
+ assert_respond_to(@ts, :status)
448
+ assert_nothing_raised{ @ts.status }
449
+ assert_kind_of(String, @ts.status)
450
+ end
451
+
452
+ test "status returns the expected value" do
453
+ setup_task
454
+ assert_equal('ready', @ts.status)
455
+ end
456
+
457
+ test "status does not accept any arguments" do
458
+ assert_raise(ArgumentError){ @ts.status(true) }
459
+ end
460
+
461
+ test "terminate basic functionality" do
462
+ assert_respond_to(@ts, :terminate)
463
+ end
464
+
465
+ test "terminate does not accept any arguments" do
466
+ assert_raise(ArgumentError){ @ts.terminate(true) }
467
+ assert_raise(NoMethodError){ @ts.terminate = true }
468
+ end
469
+
470
+ test "calling terminate on a task that isn't running raises an error" do
471
+ assert_raise(TaskScheduler::Error){ @ts.terminate }
472
+ end
473
+
474
+ test "trigger basic functionality" do
475
+ setup_task
476
+ assert_respond_to(@ts, :trigger)
477
+ assert_nothing_raised{ @ts.trigger(0) }
478
+ end
479
+
480
+ test "trigger returns a hash object" do
481
+ setup_task
482
+ assert_kind_of(Hash, @ts.trigger(0))
483
+ end
484
+
485
+ test "trigger requires an index" do
486
+ assert_raises(ArgumentError){ @ts.trigger }
487
+ end
488
+
489
+ test "trigger raises an error if the index is invalid" do
490
+ assert_raises(TaskScheduler::Error){ @ts.trigger(9999) }
491
+ end
492
+
493
+ test "trigger= basic functionality" do
494
+ assert_respond_to(@ts, :trigger=)
495
+ end
496
+
497
+ test "trigger= works as expected" do
498
+ setup_task
499
+ assert_nothing_raised{ @ts.trigger = @trigger }
500
+ end
501
+
502
+ test "trigger= requires a hash argument" do
503
+ assert_raises(TypeError){ @ts.trigger = 'blah' }
504
+ end
505
+
506
+ test "add_trigger basic functionality" do
507
+ assert_respond_to(@ts, :add_trigger)
508
+ end
509
+
510
+ test "add_trigger works as expected" do
511
+ setup_task
512
+ assert_nothing_raised{ @ts.add_trigger(0, @trigger) }
513
+ end
514
+
515
+ test "add_trigger requires two arguments" do
516
+ assert_raises(ArgumentError){ @ts.add_trigger }
517
+ assert_raises(ArgumentError){ @ts.add_trigger(0) }
518
+ end
519
+
520
+ test "add_trigger reqiuires an integer for the first argument" do
521
+ assert_raises(TypeError){ @ts.add_trigger('foo', @trigger) }
522
+ end
523
+
524
+ test "add_trigger reqiuires a hash for the second argument" do
525
+ assert_raises(TypeError){ @ts.add_trigger(0, 'foo') }
526
+ end
527
+
528
+ test "trigger_count basic functionality" do
529
+ setup_task
530
+ assert_respond_to(@ts, :trigger_count)
531
+ assert_nothing_raised{ @ts.trigger_count }
532
+ assert_kind_of(Fixnum, @ts.trigger_count)
533
+ end
534
+
535
+ test "trigger_count returns the expected value" do
536
+ setup_task
537
+ assert_equal(1, @ts.trigger_count)
538
+ end
539
+
540
+ test "trigger_count does not accept any arguments" do
541
+ assert_raise(ArgumentError){ @ts.trigger_count(true) }
542
+ assert_raise(NoMethodError){ @ts.trigger_count = 1 }
543
+ end
544
+
545
+ test "delete_trigger basic functionality" do
546
+ assert_respond_to(@ts, :delete_trigger)
547
+ end
548
+
549
+ test "delete_trigger works as expected" do
550
+ setup_task
551
+ assert_nothing_raised{ @ts.delete_trigger(0) }
552
+ assert_equal(0, @ts.trigger_count)
553
+ end
554
+
555
+ test "passing a bad index to delete_trigger will raise an error" do
556
+ assert_raise(TaskScheduler::Error){ @ts.delete_trigger(9999) }
557
+ end
558
+
559
+ test "delete_trigger requires at least one argument" do
560
+ assert_raise(ArgumentError){ @ts.delete_trigger }
561
+ end
562
+
563
+ test "trigger_string basic functionality" do
564
+ setup_task
565
+ assert_respond_to(@ts, :trigger_string)
566
+ assert_nothing_raised{ @ts.trigger_string(0) }
567
+ end
568
+
569
+ test "trigger_string returns the expected value" do
570
+ setup_task
571
+ assert_equal('Starting 2015-04-11T07:14:00', @ts.trigger_string(0))
572
+ end
573
+
574
+ test "trigger_string requires a single argument" do
575
+ assert_raise(ArgumentError){ @ts.trigger_string }
576
+ assert_raise(ArgumentError){ @ts.trigger_string(0, 0) }
577
+ end
578
+
579
+ test "trigger_string requires a numeric argument" do
580
+ assert_raise(TypeError){ @ts.trigger_string('alpha') }
581
+ end
582
+
583
+ test "trigger_string raises an error if the index is invalid" do
584
+ assert_raise(TaskScheduler::Error){ @ts.trigger_string(9999) }
585
+ end
586
+
587
+ test "working_directory basic functionality" do
588
+ setup_task
589
+ assert_respond_to(@ts, :working_directory)
590
+ assert_nothing_raised{ @ts.working_directory }
591
+ assert_kind_of(String, @ts.working_directory)
592
+ end
593
+
594
+ test "working_directory takes no arguments" do
595
+ assert_raise(ArgumentError){ @ts.working_directory(true) }
596
+ end
597
+
598
+ test "working_directory= basic functionality" do
599
+ assert_respond_to(@ts, :working_directory=)
600
+ end
601
+
602
+ test "working_directory= works as expected" do
603
+ setup_task
604
+ assert_nothing_raised{ @ts.working_directory = "C:\\" }
605
+ end
606
+
607
+ test "working_directory= requires a string argument" do
608
+ setup_task
609
+ assert_raise(TypeError){ @ts.working_directory = 1 }
610
+ end
611
+
612
+ test "expected day constants are defined" do
613
+ assert_not_nil(TaskScheduler::MONDAY)
614
+ assert_not_nil(TaskScheduler::TUESDAY)
615
+ assert_not_nil(TaskScheduler::WEDNESDAY)
616
+ assert_not_nil(TaskScheduler::THURSDAY)
617
+ assert_not_nil(TaskScheduler::FRIDAY)
618
+ assert_not_nil(TaskScheduler::SATURDAY)
619
+ assert_not_nil(TaskScheduler::SUNDAY)
620
+ end
621
+
622
+ test "expected month constants are defined" do
623
+ assert_not_nil(TaskScheduler::JANUARY)
624
+ assert_not_nil(TaskScheduler::FEBRUARY)
625
+ assert_not_nil(TaskScheduler::MARCH)
626
+ assert_not_nil(TaskScheduler::APRIL)
627
+ assert_not_nil(TaskScheduler::MAY)
628
+ assert_not_nil(TaskScheduler::JUNE)
629
+ assert_not_nil(TaskScheduler::JULY)
630
+ assert_not_nil(TaskScheduler::AUGUST)
631
+ assert_not_nil(TaskScheduler::SEPTEMBER)
632
+ assert_not_nil(TaskScheduler::OCTOBER)
633
+ assert_not_nil(TaskScheduler::NOVEMBER)
634
+ assert_not_nil(TaskScheduler::DECEMBER)
635
+ end
636
+
637
+ test "expected repeat constants are defined" do
638
+ assert_not_nil(TaskScheduler::ONCE)
639
+ assert_not_nil(TaskScheduler::DAILY)
640
+ assert_not_nil(TaskScheduler::WEEKLY)
641
+ assert_not_nil(TaskScheduler::MONTHLYDATE)
642
+ assert_not_nil(TaskScheduler::MONTHLYDOW)
643
+ end
644
+
645
+ test "expected start constants are defined" do
646
+ assert_not_nil(TaskScheduler::ON_IDLE)
647
+ assert_not_nil(TaskScheduler::AT_SYSTEMSTART)
648
+ assert_not_nil(TaskScheduler::AT_LOGON)
649
+ end
650
+
651
+ test "expected flag constants are defined" do
652
+ assert_not_nil(TaskScheduler::INTERACTIVE)
653
+ assert_not_nil(TaskScheduler::DELETE_WHEN_DONE)
654
+ assert_not_nil(TaskScheduler::DISABLED)
655
+ assert_not_nil(TaskScheduler::START_ONLY_IF_IDLE)
656
+ assert_not_nil(TaskScheduler::KILL_ON_IDLE_END)
657
+ assert_not_nil(TaskScheduler::DONT_START_IF_ON_BATTERIES)
658
+ assert_not_nil(TaskScheduler::KILL_IF_GOING_ON_BATTERIES)
659
+ assert_not_nil(TaskScheduler::HIDDEN)
660
+ assert_not_nil(TaskScheduler::RESTART_ON_IDLE_RESUME)
661
+ assert_not_nil(TaskScheduler::SYSTEM_REQUIRED)
662
+ assert_not_nil(TaskScheduler::FLAG_HAS_END_DATE)
663
+ assert_not_nil(TaskScheduler::FLAG_KILL_AT_DURATION_END)
664
+ assert_not_nil(TaskScheduler::FLAG_DISABLED)
665
+ assert_not_nil(TaskScheduler::MAX_RUN_TIMES)
666
+ end
667
+
668
+ test "expected priority constants are defined" do
669
+ assert_not_nil(TaskScheduler::IDLE)
670
+ assert_not_nil(TaskScheduler::NORMAL)
671
+ assert_not_nil(TaskScheduler::HIGH)
672
+ assert_not_nil(TaskScheduler::REALTIME)
673
+ assert_not_nil(TaskScheduler::ABOVE_NORMAL)
674
+ assert_not_nil(TaskScheduler::BELOW_NORMAL)
675
+ end
676
+
677
+ def teardown
678
+ @ts.delete(@task) if @ts.exists?(@task)
679
+ @ts = nil
680
+ @task = nil
681
+ @trigger = nil
682
+ end
683
+
684
+ def self.shutdown
685
+ @@host = nil
686
+ @@user = nil
687
+ @@elevated = nil
688
+ end
689
+ end