mono_logger 1.1.0 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. checksums.yaml +5 -5
  2. data/.github/workflows/build.yml +33 -0
  3. data/.gitignore +17 -17
  4. data/.travis.yml +4 -7
  5. data/Gemfile +8 -4
  6. data/LICENSE.txt +20 -20
  7. data/README.md +68 -66
  8. data/Rakefile +12 -12
  9. data/lib/mono_logger/version.rb +5 -5
  10. data/lib/mono_logger.rb +89 -93
  11. data/mono_logger.gemspec +24 -25
  12. data/test/mri_logger_test.rb +544 -533
  13. metadata +17 -32
data/test/mri_logger_test.rb CHANGED
@@ -1,533 +1,544 @@
1
- # coding: US-ASCII
2
- require 'test/unit'
3
- require 'mono_logger'
4
- require 'tempfile'
5
-
6
- Logger = MonoLogger
7
-
8
-
9
- class TestLoggerSeverity < Test::Unit::TestCase
10
- def test_enum
11
- logger_levels = Logger.constants
12
- levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
13
- Logger::Severity.constants.each do |level|
14
- assert(levels.include?(level.to_s))
15
- assert(logger_levels.include?(level))
16
- end
17
- assert_equal(levels.size, Logger::Severity.constants.size)
18
- end
19
- end
20
-
21
-
22
- class TestLogger < Test::Unit::TestCase
23
- include Logger::Severity
24
-
25
- def setup
26
- @logger = Logger.new(nil)
27
- end
28
-
29
- class Log
30
- attr_reader :label, :datetime, :pid, :severity, :progname, :msg
31
- def initialize(line)
32
- /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
33
- @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
34
- end
35
- end
36
-
37
- def log_add(logger, severity, msg, progname = nil, &block)
38
- log(logger, :add, severity, msg, progname, &block)
39
- end
40
-
41
- def log(logger, msg_id, *arg, &block)
42
- Log.new(log_raw(logger, msg_id, *arg, &block))
43
- end
44
-
45
- def log_raw(logger, msg_id, *arg, &block)
46
- logdev = Tempfile.new(File.basename(__FILE__) + '.log')
47
- logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
48
- logger.__send__(msg_id, *arg, &block)
49
- logdev.open
50
- msg = logdev.read
51
- logdev.close
52
- msg
53
- end
54
-
55
- def test_level
56
- @logger.level = UNKNOWN
57
- assert_equal(UNKNOWN, @logger.level)
58
- @logger.level = INFO
59
- assert_equal(INFO, @logger.level)
60
- @logger.sev_threshold = ERROR
61
- assert_equal(ERROR, @logger.sev_threshold)
62
- @logger.sev_threshold = WARN
63
- assert_equal(WARN, @logger.sev_threshold)
64
- assert_equal(WARN, @logger.level)
65
-
66
- @logger.level = DEBUG
67
- assert(@logger.debug?)
68
- assert(@logger.info?)
69
- @logger.level = INFO
70
- assert(!@logger.debug?)
71
- assert(@logger.info?)
72
- assert(@logger.warn?)
73
- @logger.level = WARN
74
- assert(!@logger.info?)
75
- assert(@logger.warn?)
76
- assert(@logger.error?)
77
- @logger.level = ERROR
78
- assert(!@logger.warn?)
79
- assert(@logger.error?)
80
- assert(@logger.fatal?)
81
- @logger.level = FATAL
82
- assert(!@logger.error?)
83
- assert(@logger.fatal?)
84
- @logger.level = UNKNOWN
85
- assert(!@logger.error?)
86
- assert(!@logger.fatal?)
87
- end
88
-
89
- def test_progname
90
- assert_nil(@logger.progname)
91
- @logger.progname = "name"
92
- assert_equal("name", @logger.progname)
93
- end
94
-
95
- def test_datetime_format
96
- dummy = STDERR
97
- logger = Logger.new(dummy)
98
- log = log_add(logger, INFO, "foo")
99
- assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+ $/, log.datetime)
100
- logger.datetime_format = "%d%b%Y@%H:%M:%S"
101
- log = log_add(logger, INFO, "foo")
102
- assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
103
- logger.datetime_format = ""
104
- log = log_add(logger, INFO, "foo")
105
- assert_match(/^$/, log.datetime)
106
- end
107
-
108
- def test_formatter
109
- dummy = STDERR
110
- logger = Logger.new(dummy)
111
- # default
112
- log = log(logger, :info, "foo")
113
- assert_equal("foo\n", log.msg)
114
- # config
115
- logger.formatter = proc { |severity, timestamp, progname, msg|
116
- "#{severity}:#{msg}\n\n"
117
- }
118
- line = log_raw(logger, :info, "foo")
119
- assert_equal("INFO:foo\n\n", line)
120
- # recover
121
- logger.formatter = nil
122
- log = log(logger, :info, "foo")
123
- assert_equal("foo\n", log.msg)
124
- # again
125
- o = Object.new
126
- def o.call(severity, timestamp, progname, msg)
127
- "<<#{severity}-#{msg}>>\n"
128
- end
129
- logger.formatter = o
130
- line = log_raw(logger, :info, "foo")
131
- assert_equal("<""<INFO-foo>>\n", line)
132
- end
133
-
134
- def test_initialize
135
- logger = Logger.new(STDERR)
136
- assert_nil(logger.progname)
137
- assert_equal(DEBUG, logger.level)
138
- assert_nil(logger.datetime_format)
139
- end
140
-
141
- def test_add
142
- logger = Logger.new(nil)
143
- logger.progname = "my_progname"
144
- assert(logger.add(INFO))
145
- log = log_add(logger, nil, "msg")
146
- assert_equal("ANY", log.severity)
147
- assert_equal("my_progname", log.progname)
148
- logger.level = WARN
149
- assert(logger.log(INFO))
150
- assert_nil(log_add(logger, INFO, "msg").msg)
151
- log = log_add(logger, WARN, nil) { "msg" }
152
- assert_equal("msg\n", log.msg)
153
- log = log_add(logger, WARN, "") { "msg" }
154
- assert_equal("\n", log.msg)
155
- assert_equal("my_progname", log.progname)
156
- log = log_add(logger, WARN, nil, "progname?")
157
- assert_equal("progname?\n", log.msg)
158
- assert_equal("my_progname", log.progname)
159
- end
160
-
161
- def test_level_log
162
- logger = Logger.new(nil)
163
- logger.progname = "my_progname"
164
- log = log(logger, :debug, "custom_progname") { "msg" }
165
- assert_equal("msg\n", log.msg)
166
- assert_equal("custom_progname", log.progname)
167
- assert_equal("DEBUG", log.severity)
168
- assert_equal("D", log.label)
169
- #
170
- log = log(logger, :debug) { "msg_block" }
171
- assert_equal("msg_block\n", log.msg)
172
- assert_equal("my_progname", log.progname)
173
- log = log(logger, :debug, "msg_inline")
174
- assert_equal("msg_inline\n", log.msg)
175
- assert_equal("my_progname", log.progname)
176
- #
177
- log = log(logger, :info, "custom_progname") { "msg" }
178
- assert_equal("msg\n", log.msg)
179
- assert_equal("custom_progname", log.progname)
180
- assert_equal("INFO", log.severity)
181
- assert_equal("I", log.label)
182
- #
183
- log = log(logger, :warn, "custom_progname") { "msg" }
184
- assert_equal("msg\n", log.msg)
185
- assert_equal("custom_progname", log.progname)
186
- assert_equal("WARN", log.severity)
187
- assert_equal("W", log.label)
188
- #
189
- log = log(logger, :error, "custom_progname") { "msg" }
190
- assert_equal("msg\n", log.msg)
191
- assert_equal("custom_progname", log.progname)
192
- assert_equal("ERROR", log.severity)
193
- assert_equal("E", log.label)
194
- #
195
- log = log(logger, :fatal, "custom_progname") { "msg" }
196
- assert_equal("msg\n", log.msg)
197
- assert_equal("custom_progname", log.progname)
198
- assert_equal("FATAL", log.severity)
199
- assert_equal("F", log.label)
200
- #
201
- log = log(logger, :unknown, "custom_progname") { "msg" }
202
- assert_equal("msg\n", log.msg)
203
- assert_equal("custom_progname", log.progname)
204
- assert_equal("ANY", log.severity)
205
- assert_equal("A", log.label)
206
- end
207
-
208
- def test_close
209
- r, w = IO.pipe
210
- assert(!w.closed?)
211
- logger = Logger.new(w)
212
- logger.close
213
- assert(w.closed?)
214
- r.close
215
- end
216
-
217
- class MyError < StandardError
218
- end
219
-
220
- class MyMsg
221
- def inspect
222
- "my_msg"
223
- end
224
- end
225
-
226
- def test_format
227
- logger = Logger.new(nil)
228
- log = log_add(logger, INFO, "msg\n")
229
- assert_equal("msg\n\n", log.msg)
230
- begin
231
- raise MyError.new("excn")
232
- rescue MyError => e
233
- log = log_add(logger, INFO, e)
234
- assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
235
- # expects backtrace is dumped across multi lines. 10 might be changed.
236
- assert(log.msg.split(/\n/).size >= 10)
237
- end
238
- log = log_add(logger, INFO, MyMsg.new)
239
- assert_equal("my_msg\n", log.msg)
240
- end
241
-
242
- def test_lshift
243
- r, w = IO.pipe
244
- logger = Logger.new(w)
245
- logger << "msg"
246
- read_ready, = IO.select([r], nil, nil, 0.1)
247
- w.close
248
- msg = r.read
249
- r.close
250
- assert_equal("msg", msg)
251
- #
252
- r, w = IO.pipe
253
- logger = Logger.new(w)
254
- logger << "msg2\n\n"
255
- read_ready, = IO.select([r], nil, nil, 0.1)
256
- w.close
257
- msg = r.read
258
- r.close
259
- assert_equal("msg2\n\n", msg)
260
- end
261
- end
262
-
263
- class TestLogDevice < Test::Unit::TestCase
264
- class LogExcnRaiser
265
- def write(*arg)
266
- raise 'disk is full'
267
- end
268
-
269
- def close
270
- end
271
-
272
- def stat
273
- Object.new
274
- end
275
- end
276
-
277
- def setup
278
- @tempfile = Tempfile.new("logger")
279
- @tempfile.close
280
- @filename = @tempfile.path
281
- File.unlink(@filename)
282
- end
283
-
284
- def teardown
285
- @tempfile.close(true)
286
- end
287
-
288
- def d(log, opt = {})
289
- Logger::LogDevice.new(log, opt)
290
- end
291
-
292
- def test_initialize
293
- logdev = d(STDERR)
294
- assert_equal(STDERR, logdev.dev)
295
- assert_nil(logdev.filename)
296
- assert_raises(TypeError) do
297
- d(nil)
298
- end
299
- #
300
- logdev = d(@filename)
301
- begin
302
- assert(File.exist?(@filename))
303
- assert(logdev.dev.sync)
304
- assert_equal(@filename, logdev.filename)
305
- logdev.write('hello')
306
- ensure
307
- logdev.close
308
- end
309
- # create logfile whitch is already exist.
310
- logdev = d(@filename)
311
- begin
312
- logdev.write('world')
313
- logfile = File.read(@filename)
314
- assert_equal(2, logfile.split(/\n/).size)
315
- assert_match(/^helloworld$/, logfile)
316
- ensure
317
- logdev.close
318
- end
319
- end
320
-
321
- def test_write
322
- r, w = IO.pipe
323
- logdev = d(w)
324
- logdev.write("msg2\n\n")
325
- read_ready, = IO.select([r], nil, nil, 0.1)
326
- w.close
327
- msg = r.read
328
- r.close
329
- assert_equal("msg2\n\n", msg)
330
- #
331
- logdev = d(LogExcnRaiser.new)
332
- class << (stderr = '')
333
- alias write <<
334
- end
335
- $stderr, stderr = stderr, $stderr
336
- begin
337
- assert_nothing_raised do
338
- logdev.write('hello')
339
- end
340
- ensure
341
- logdev.close
342
- $stderr, stderr = stderr, $stderr
343
- end
344
- assert_equal "log writing failed. disk is full\n", stderr
345
- end
346
-
347
- def test_close
348
- r, w = IO.pipe
349
- logdev = d(w)
350
- logdev.write("msg2\n\n")
351
- read_ready, = IO.select([r], nil, nil, 0.1)
352
- assert(!w.closed?)
353
- logdev.close
354
- assert(w.closed?)
355
- r.close
356
- end
357
-
358
- def test_shifting_size
359
- skip("shifting age doesn't work because rotation doesn't work")
360
- tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
361
- logfile = tmpfile.path
362
- logfile0 = logfile + '.0'
363
- logfile1 = logfile + '.1'
364
- logfile2 = logfile + '.2'
365
- logfile3 = logfile + '.3'
366
- tmpfile.close(true)
367
- File.unlink(logfile) if File.exist?(logfile)
368
- File.unlink(logfile0) if File.exist?(logfile0)
369
- File.unlink(logfile1) if File.exist?(logfile1)
370
- File.unlink(logfile2) if File.exist?(logfile2)
371
- logger = Logger.new(logfile, 4, 100)
372
- logger.error("0" * 15)
373
- assert(File.exist?(logfile))
374
- assert(!File.exist?(logfile0))
375
- logger.error("0" * 15)
376
- assert(File.exist?(logfile0))
377
- assert(!File.exist?(logfile1))
378
- logger.error("0" * 15)
379
- assert(File.exist?(logfile1))
380
- assert(!File.exist?(logfile2))
381
- logger.error("0" * 15)
382
- assert(File.exist?(logfile2))
383
- assert(!File.exist?(logfile3))
384
- logger.error("0" * 15)
385
- assert(!File.exist?(logfile3))
386
- logger.error("0" * 15)
387
- assert(!File.exist?(logfile3))
388
- logger.close
389
- File.unlink(logfile)
390
- File.unlink(logfile0)
391
- File.unlink(logfile1)
392
- File.unlink(logfile2)
393
-
394
- tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
395
- logfile = tmpfile.path
396
- logfile0 = logfile + '.0'
397
- logfile1 = logfile + '.1'
398
- logfile2 = logfile + '.2'
399
- logfile3 = logfile + '.3'
400
- tmpfile.close(true)
401
- logger = Logger.new(logfile, 4, 150)
402
- logger.error("0" * 15)
403
- assert(File.exist?(logfile))
404
- assert(!File.exist?(logfile0))
405
- logger.error("0" * 15)
406
- assert(!File.exist?(logfile0))
407
- logger.error("0" * 15)
408
- assert(File.exist?(logfile0))
409
- assert(!File.exist?(logfile1))
410
- logger.error("0" * 15)
411
- assert(!File.exist?(logfile1))
412
- logger.error("0" * 15)
413
- assert(File.exist?(logfile1))
414
- assert(!File.exist?(logfile2))
415
- logger.error("0" * 15)
416
- assert(!File.exist?(logfile2))
417
- logger.error("0" * 15)
418
- assert(File.exist?(logfile2))
419
- assert(!File.exist?(logfile3))
420
- logger.error("0" * 15)
421
- assert(!File.exist?(logfile3))
422
- logger.error("0" * 15)
423
- assert(!File.exist?(logfile3))
424
- logger.error("0" * 15)
425
- assert(!File.exist?(logfile3))
426
- logger.close
427
- File.unlink(logfile)
428
- File.unlink(logfile0)
429
- File.unlink(logfile1)
430
- File.unlink(logfile2)
431
- end
432
-
433
- def test_shifting_age_variants
434
- skip("shifting age doesn't work because rotation doesn't work")
435
- logger = Logger.new(@filename, 'daily')
436
- logger.info('daily')
437
- logger.close
438
- logger = Logger.new(@filename, 'weekly')
439
- logger.info('weekly')
440
- logger.close
441
- logger = Logger.new(@filename, 'monthly')
442
- logger.info('monthly')
443
- logger.close
444
- end
445
-
446
- def test_shifting_age
447
- skip("shifting age doesn't work because rotation doesn't work")
448
- # shift_age other than 'daily', 'weekly', and 'monthly' means 'everytime'
449
- yyyymmdd = Time.now.strftime("%Y%m%d")
450
- filename1 = @filename + ".#{yyyymmdd}"
451
- filename2 = @filename + ".#{yyyymmdd}.1"
452
- filename3 = @filename + ".#{yyyymmdd}.2"
453
- begin
454
- logger = Logger.new(@filename, 'now')
455
- assert(File.exist?(@filename))
456
- assert(!File.exist?(filename1))
457
- assert(!File.exist?(filename2))
458
- assert(!File.exist?(filename3))
459
- logger.info("0" * 15)
460
- assert(File.exist?(@filename))
461
- assert(File.exist?(filename1))
462
- assert(!File.exist?(filename2))
463
- assert(!File.exist?(filename3))
464
- logger.warn("0" * 15)
465
- assert(File.exist?(@filename))
466
- assert(File.exist?(filename1))
467
- assert(File.exist?(filename2))
468
- assert(!File.exist?(filename3))
469
- logger.error("0" * 15)
470
- assert(File.exist?(@filename))
471
- assert(File.exist?(filename1))
472
- assert(File.exist?(filename2))
473
- assert(File.exist?(filename3))
474
- ensure
475
- logger.close if logger
476
- [filename1, filename2, filename3].each do |filename|
477
- File.unlink(filename) if File.exist?(filename)
478
- end
479
- end
480
- end
481
- end
482
-
483
-
484
- class TestLoggerApplication < Test::Unit::TestCase
485
- def setup
486
- @app = Logger::Application.new('appname')
487
- @tempfile = Tempfile.new("logger")
488
- @tempfile.close
489
- @filename = @tempfile.path
490
- File.unlink(@filename)
491
- end
492
-
493
- def teardown
494
- @tempfile.close(true)
495
- end
496
-
497
- def test_initialize
498
- app = Logger::Application.new('appname')
499
- assert_equal('appname', app.appname)
500
- end
501
-
502
- def test_start
503
- @app.set_log(@filename)
504
- begin
505
- @app.level = Logger::UNKNOWN
506
- @app.start # logs FATAL log
507
- assert_equal(1, File.read(@filename).split(/\n/).size)
508
- ensure
509
- @app.logger.close
510
- end
511
- end
512
-
513
- def test_logger
514
- @app.level = Logger::WARN
515
- @app.set_log(@filename)
516
- begin
517
- assert_equal(Logger::WARN, @app.logger.level)
518
- ensure
519
- @app.logger.close
520
- end
521
- @app.logger = logger = Logger.new(STDOUT)
522
- assert_equal(logger, @app.logger)
523
- assert_equal(Logger::WARN, @app.logger.level)
524
- @app.log = @filename
525
- begin
526
- assert(logger != @app.logger)
527
- assert_equal(Logger::WARN, @app.logger.level)
528
- ensure
529
- @app.logger.close
530
- end
531
- end
532
- end
533
-
1
+ # coding: US-ASCII
2
+
3
+ require 'minitest/autorun'
4
+ require 'mono_logger'
5
+ # Logger::Application was dropped at Ruby 2.2.
6
+ require 'logger-application' unless defined?(Logger::Application)
7
+ require 'tempfile'
8
+
9
+ if defined? Minitest::Test
10
+ # We're on Minitest 5+. Nothing to do here.
11
+ else
12
+ # Minitest 4 doesn't have Minitest::Test yet.
13
+ Minitest::Test = MiniTest::Unit::TestCase
14
+ end
15
+
16
+ Logger = MonoLogger
17
+
18
+
19
+ class TestLoggerSeverity < Minitest::Test
20
+ def test_enum
21
+ logger_levels = Logger.constants
22
+ levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
23
+ Logger::Severity.constants.each do |level|
24
+ assert(levels.include?(level.to_s))
25
+ assert(logger_levels.include?(level))
26
+ end
27
+ assert_equal(levels.size, Logger::Severity.constants.size)
28
+ end
29
+ end
30
+
31
+
32
+ class TestLogger < Minitest::Test
33
+ include Logger::Severity
34
+
35
+ def setup
36
+ @logger = Logger.new(nil)
37
+ end
38
+
39
+ class Log
40
+ attr_reader :label, :datetime, :pid, :severity, :progname, :msg
41
+ def initialize(line)
42
+ /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
43
+ @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
44
+ end
45
+ end
46
+
47
+ def log_add(logger, severity, msg, progname = nil, &block)
48
+ log(logger, :add, severity, msg, progname, &block)
49
+ end
50
+
51
+ def log(logger, msg_id, *arg, &block)
52
+ Log.new(log_raw(logger, msg_id, *arg, &block))
53
+ end
54
+
55
+ def log_raw(logger, msg_id, *arg, &block)
56
+ logdev = Tempfile.new(File.basename(__FILE__) + '.log')
57
+ logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
58
+ logger.__send__(msg_id, *arg, &block)
59
+ logdev.open
60
+ msg = logdev.read
61
+ logdev.close
62
+ msg
63
+ end
64
+
65
+ def test_level
66
+ @logger.level = UNKNOWN
67
+ assert_equal(UNKNOWN, @logger.level)
68
+ @logger.level = INFO
69
+ assert_equal(INFO, @logger.level)
70
+ @logger.sev_threshold = ERROR
71
+ assert_equal(ERROR, @logger.sev_threshold)
72
+ @logger.sev_threshold = WARN
73
+ assert_equal(WARN, @logger.sev_threshold)
74
+ assert_equal(WARN, @logger.level)
75
+
76
+ @logger.level = DEBUG
77
+ assert(@logger.debug?)
78
+ assert(@logger.info?)
79
+ @logger.level = INFO
80
+ assert(!@logger.debug?)
81
+ assert(@logger.info?)
82
+ assert(@logger.warn?)
83
+ @logger.level = WARN
84
+ assert(!@logger.info?)
85
+ assert(@logger.warn?)
86
+ assert(@logger.error?)
87
+ @logger.level = ERROR
88
+ assert(!@logger.warn?)
89
+ assert(@logger.error?)
90
+ assert(@logger.fatal?)
91
+ @logger.level = FATAL
92
+ assert(!@logger.error?)
93
+ assert(@logger.fatal?)
94
+ @logger.level = UNKNOWN
95
+ assert(!@logger.error?)
96
+ assert(!@logger.fatal?)
97
+ end
98
+
99
+ def test_progname
100
+ assert_nil(@logger.progname)
101
+ @logger.progname = "name"
102
+ assert_equal("name", @logger.progname)
103
+ end
104
+
105
+ def test_datetime_format
106
+ # We use strip because we don't care about the upstream changes that
107
+ # happened to whitespace, and this makes the test behave the same
108
+ # regardless of Ruby/Logger version.
109
+ dummy = STDERR
110
+ logger = Logger.new(dummy)
111
+ log = log_add(logger, INFO, "foo")
112
+ assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+$/, log.datetime.strip)
113
+ logger.datetime_format = "%d%b%Y@%H:%M:%S"
114
+ log = log_add(logger, INFO, "foo")
115
+ assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime.strip)
116
+ logger.datetime_format = ""
117
+ log = log_add(logger, INFO, "foo")
118
+ assert_match(/^$/, log.datetime.strip)
119
+ end
120
+
121
+ def test_formatter
122
+ dummy = STDERR
123
+ logger = Logger.new(dummy)
124
+ # default
125
+ log = log(logger, :info, "foo")
126
+ assert_equal("foo\n", log.msg)
127
+ # config
128
+ logger.formatter = proc { |severity, timestamp, progname, msg|
129
+ "#{severity}:#{msg}\n\n"
130
+ }
131
+ line = log_raw(logger, :info, "foo")
132
+ assert_equal("INFO:foo\n\n", line)
133
+ # recover
134
+ logger.formatter = nil
135
+ log = log(logger, :info, "foo")
136
+ assert_equal("foo\n", log.msg)
137
+ # again
138
+ o = Object.new
139
+ def o.call(severity, timestamp, progname, msg)
140
+ "<<#{severity}-#{msg}>>\n"
141
+ end
142
+ logger.formatter = o
143
+ line = log_raw(logger, :info, "foo")
144
+ assert_equal("<""<INFO-foo>>\n", line)
145
+ end
146
+
147
+ def test_initialize
148
+ logger = Logger.new(STDERR)
149
+ assert_nil(logger.progname)
150
+ assert_equal(DEBUG, logger.level)
151
+ assert_nil(logger.datetime_format)
152
+ end
153
+
154
+ def test_add
155
+ logger = Logger.new(nil)
156
+ logger.progname = "my_progname"
157
+ assert(logger.add(INFO))
158
+ log = log_add(logger, nil, "msg")
159
+ assert_equal("ANY", log.severity)
160
+ assert_equal("my_progname", log.progname)
161
+ logger.level = WARN
162
+ assert(logger.log(INFO))
163
+ assert_nil(log_add(logger, INFO, "msg").msg)
164
+ log = log_add(logger, WARN, nil) { "msg" }
165
+ assert_equal("msg\n", log.msg)
166
+ log = log_add(logger, WARN, "") { "msg" }
167
+ assert_equal("\n", log.msg)
168
+ assert_equal("my_progname", log.progname)
169
+ log = log_add(logger, WARN, nil, "progname?")
170
+ assert_equal("progname?\n", log.msg)
171
+ assert_equal("my_progname", log.progname)
172
+ end
173
+
174
+ def test_level_log
175
+ logger = Logger.new(nil)
176
+ logger.progname = "my_progname"
177
+ log = log(logger, :debug, "custom_progname") { "msg" }
178
+ assert_equal("msg\n", log.msg)
179
+ assert_equal("custom_progname", log.progname)
180
+ assert_equal("DEBUG", log.severity)
181
+ assert_equal("D", log.label)
182
+ #
183
+ log = log(logger, :debug) { "msg_block" }
184
+ assert_equal("msg_block\n", log.msg)
185
+ assert_equal("my_progname", log.progname)
186
+ log = log(logger, :debug, "msg_inline")
187
+ assert_equal("msg_inline\n", log.msg)
188
+ assert_equal("my_progname", log.progname)
189
+ #
190
+ log = log(logger, :info, "custom_progname") { "msg" }
191
+ assert_equal("msg\n", log.msg)
192
+ assert_equal("custom_progname", log.progname)
193
+ assert_equal("INFO", log.severity)
194
+ assert_equal("I", log.label)
195
+ #
196
+ log = log(logger, :warn, "custom_progname") { "msg" }
197
+ assert_equal("msg\n", log.msg)
198
+ assert_equal("custom_progname", log.progname)
199
+ assert_equal("WARN", log.severity)
200
+ assert_equal("W", log.label)
201
+ #
202
+ log = log(logger, :error, "custom_progname") { "msg" }
203
+ assert_equal("msg\n", log.msg)
204
+ assert_equal("custom_progname", log.progname)
205
+ assert_equal("ERROR", log.severity)
206
+ assert_equal("E", log.label)
207
+ #
208
+ log = log(logger, :fatal, "custom_progname") { "msg" }
209
+ assert_equal("msg\n", log.msg)
210
+ assert_equal("custom_progname", log.progname)
211
+ assert_equal("FATAL", log.severity)
212
+ assert_equal("F", log.label)
213
+ #
214
+ log = log(logger, :unknown, "custom_progname") { "msg" }
215
+ assert_equal("msg\n", log.msg)
216
+ assert_equal("custom_progname", log.progname)
217
+ assert_equal("ANY", log.severity)
218
+ assert_equal("A", log.label)
219
+ end
220
+
221
+ def test_close
222
+ r, w = IO.pipe
223
+ assert(!w.closed?)
224
+ logger = Logger.new(w)
225
+ logger.close
226
+ assert(w.closed?)
227
+ r.close
228
+ end
229
+
230
+ class MyError < StandardError
231
+ end
232
+
233
+ class MyMsg
234
+ def inspect
235
+ "my_msg"
236
+ end
237
+ end
238
+
239
+ def test_format
240
+ logger = Logger.new(nil)
241
+ log = log_add(logger, INFO, "msg\n")
242
+ assert_equal("msg\n\n", log.msg)
243
+ begin
244
+ raise MyError.new("excn")
245
+ rescue MyError => e
246
+ log = log_add(logger, INFO, e)
247
+ assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
248
+ # expects backtrace is dumped across multi lines. 10 might be changed.
249
+ assert(log.msg.split(/\n/).size >= 10)
250
+ end
251
+ log = log_add(logger, INFO, MyMsg.new)
252
+ assert_equal("my_msg\n", log.msg)
253
+ end
254
+
255
+ def test_lshift
256
+ r, w = IO.pipe
257
+ logger = Logger.new(w)
258
+ logger << "msg"
259
+ _, = IO.select([r], nil, nil, 0.1)
260
+ w.close
261
+ msg = r.read
262
+ r.close
263
+ assert_equal("msg", msg)
264
+ #
265
+ r, w = IO.pipe
266
+ logger = Logger.new(w)
267
+ logger << "msg2\n\n"
268
+ _, = IO.select([r], nil, nil, 0.1)
269
+ w.close
270
+ msg = r.read
271
+ r.close
272
+ assert_equal("msg2\n\n", msg)
273
+ end
274
+ end
275
+
276
+ class TestLogDevice < Minitest::Test
277
+ class LogExcnRaiser
278
+ def write(*arg)
279
+ raise 'disk is full'
280
+ end
281
+
282
+ def close
283
+ end
284
+
285
+ def stat
286
+ Object.new
287
+ end
288
+ end
289
+
290
+ def setup
291
+ @tempfile = Tempfile.new("logger")
292
+ @tempfile.close
293
+ @filename = @tempfile.path
294
+ File.unlink(@filename)
295
+ end
296
+
297
+ def teardown
298
+ @tempfile.close(true)
299
+ end
300
+
301
+ def d(log, opt = {})
302
+ Logger::LogDevice.new(log, **opt)
303
+ end
304
+
305
+ def test_initialize
306
+ logdev = d(STDERR)
307
+ assert_equal(STDERR, logdev.dev)
308
+ assert_nil(logdev.filename)
309
+ assert_raises(TypeError) do
310
+ d(nil)
311
+ end
312
+ #
313
+ logdev = d(@filename)
314
+ begin
315
+ assert(File.exist?(@filename))
316
+ assert(logdev.dev.sync)
317
+ assert_equal(@filename, logdev.filename)
318
+ logdev.write('hello')
319
+ ensure
320
+ logdev.close
321
+ end
322
+ # create logfile whitch is already exist.
323
+ logdev = d(@filename)
324
+ begin
325
+ logdev.write('world')
326
+ logfile = File.read(@filename)
327
+ assert_equal(2, logfile.split(/\n/).size)
328
+ assert_match(/^helloworld$/, logfile)
329
+ ensure
330
+ logdev.close
331
+ end
332
+ end
333
+
334
+ def test_write
335
+ r, w = IO.pipe
336
+ logdev = d(w)
337
+ logdev.write("msg2\n\n")
338
+ _, = IO.select([r], nil, nil, 0.1)
339
+ w.close
340
+ msg = r.read
341
+ r.close
342
+ assert_equal("msg2\n\n", msg)
343
+ #
344
+ logdev = d(LogExcnRaiser.new)
345
+ class << (stderr = '')
346
+ alias write <<
347
+ end
348
+ $stderr, stderr = stderr, $stderr
349
+ begin
350
+ logdev.write('hello')
351
+ ensure
352
+ logdev.close
353
+ $stderr, stderr = stderr, $stderr
354
+ end
355
+ assert_equal "log writing failed. disk is full\n", stderr
356
+ end
357
+
358
+ def test_close
359
+ r, w = IO.pipe
360
+ logdev = d(w)
361
+ logdev.write("msg2\n\n")
362
+ _, = IO.select([r], nil, nil, 0.1)
363
+ assert(!w.closed?)
364
+ logdev.close
365
+ assert(w.closed?)
366
+ r.close
367
+ end
368
+
369
+ def test_shifting_size
370
+ skip("shifting age doesn't work because rotation doesn't work")
371
+ tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
372
+ logfile = tmpfile.path
373
+ logfile0 = logfile + '.0'
374
+ logfile1 = logfile + '.1'
375
+ logfile2 = logfile + '.2'
376
+ logfile3 = logfile + '.3'
377
+ tmpfile.close(true)
378
+ File.unlink(logfile) if File.exist?(logfile)
379
+ File.unlink(logfile0) if File.exist?(logfile0)
380
+ File.unlink(logfile1) if File.exist?(logfile1)
381
+ File.unlink(logfile2) if File.exist?(logfile2)
382
+ logger = Logger.new(logfile, 4, 100)
383
+ logger.error("0" * 15)
384
+ assert(File.exist?(logfile))
385
+ assert(!File.exist?(logfile0))
386
+ logger.error("0" * 15)
387
+ assert(File.exist?(logfile0))
388
+ assert(!File.exist?(logfile1))
389
+ logger.error("0" * 15)
390
+ assert(File.exist?(logfile1))
391
+ assert(!File.exist?(logfile2))
392
+ logger.error("0" * 15)
393
+ assert(File.exist?(logfile2))
394
+ assert(!File.exist?(logfile3))
395
+ logger.error("0" * 15)
396
+ assert(!File.exist?(logfile3))
397
+ logger.error("0" * 15)
398
+ assert(!File.exist?(logfile3))
399
+ logger.close
400
+ File.unlink(logfile)
401
+ File.unlink(logfile0)
402
+ File.unlink(logfile1)
403
+ File.unlink(logfile2)
404
+
405
+ tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
406
+ logfile = tmpfile.path
407
+ logfile0 = logfile + '.0'
408
+ logfile1 = logfile + '.1'
409
+ logfile2 = logfile + '.2'
410
+ logfile3 = logfile + '.3'
411
+ tmpfile.close(true)
412
+ logger = Logger.new(logfile, 4, 150)
413
+ logger.error("0" * 15)
414
+ assert(File.exist?(logfile))
415
+ assert(!File.exist?(logfile0))
416
+ logger.error("0" * 15)
417
+ assert(!File.exist?(logfile0))
418
+ logger.error("0" * 15)
419
+ assert(File.exist?(logfile0))
420
+ assert(!File.exist?(logfile1))
421
+ logger.error("0" * 15)
422
+ assert(!File.exist?(logfile1))
423
+ logger.error("0" * 15)
424
+ assert(File.exist?(logfile1))
425
+ assert(!File.exist?(logfile2))
426
+ logger.error("0" * 15)
427
+ assert(!File.exist?(logfile2))
428
+ logger.error("0" * 15)
429
+ assert(File.exist?(logfile2))
430
+ assert(!File.exist?(logfile3))
431
+ logger.error("0" * 15)
432
+ assert(!File.exist?(logfile3))
433
+ logger.error("0" * 15)
434
+ assert(!File.exist?(logfile3))
435
+ logger.error("0" * 15)
436
+ assert(!File.exist?(logfile3))
437
+ logger.close
438
+ File.unlink(logfile)
439
+ File.unlink(logfile0)
440
+ File.unlink(logfile1)
441
+ File.unlink(logfile2)
442
+ end
443
+
444
+ def test_shifting_age_variants
445
+ skip("shifting age doesn't work because rotation doesn't work")
446
+ logger = Logger.new(@filename, 'daily')
447
+ logger.info('daily')
448
+ logger.close
449
+ logger = Logger.new(@filename, 'weekly')
450
+ logger.info('weekly')
451
+ logger.close
452
+ logger = Logger.new(@filename, 'monthly')
453
+ logger.info('monthly')
454
+ logger.close
455
+ end
456
+
457
+ def test_shifting_age
458
+ skip("shifting age doesn't work because rotation doesn't work")
459
+ # shift_age other than 'daily', 'weekly', and 'monthly' means 'everytime'
460
+ yyyymmdd = Time.now.strftime("%Y%m%d")
461
+ filename1 = @filename + ".#{yyyymmdd}"
462
+ filename2 = @filename + ".#{yyyymmdd}.1"
463
+ filename3 = @filename + ".#{yyyymmdd}.2"
464
+ begin
465
+ logger = Logger.new(@filename, 'now')
466
+ assert(File.exist?(@filename))
467
+ assert(!File.exist?(filename1))
468
+ assert(!File.exist?(filename2))
469
+ assert(!File.exist?(filename3))
470
+ logger.info("0" * 15)
471
+ assert(File.exist?(@filename))
472
+ assert(File.exist?(filename1))
473
+ assert(!File.exist?(filename2))
474
+ assert(!File.exist?(filename3))
475
+ logger.warn("0" * 15)
476
+ assert(File.exist?(@filename))
477
+ assert(File.exist?(filename1))
478
+ assert(File.exist?(filename2))
479
+ assert(!File.exist?(filename3))
480
+ logger.error("0" * 15)
481
+ assert(File.exist?(@filename))
482
+ assert(File.exist?(filename1))
483
+ assert(File.exist?(filename2))
484
+ assert(File.exist?(filename3))
485
+ ensure
486
+ logger.close if logger
487
+ [filename1, filename2, filename3].each do |filename|
488
+ File.unlink(filename) if File.exist?(filename)
489
+ end
490
+ end
491
+ end
492
+ end
493
+
494
+
495
+ class TestLoggerApplication < Minitest::Test
496
+ def setup
497
+ @app = Logger::Application.new('appname')
498
+ @tempfile = Tempfile.new("logger")
499
+ @tempfile.close
500
+ @filename = @tempfile.path
501
+ File.unlink(@filename)
502
+ end
503
+
504
+ def teardown
505
+ @tempfile.close(true)
506
+ end
507
+
508
+ def test_initialize
509
+ app = Logger::Application.new('appname')
510
+ assert_equal('appname', app.appname)
511
+ end
512
+
513
+ def test_start
514
+ @app.set_log(@filename)
515
+ begin
516
+ @app.level = Logger::UNKNOWN
517
+ @app.start # logs FATAL log
518
+ assert_equal(1, File.read(@filename).split(/\n/).size)
519
+ ensure
520
+ @app.logger.close
521
+ end
522
+ end
523
+
524
+ def test_logger
525
+ @app.level = Logger::WARN
526
+ @app.set_log(@filename)
527
+ begin
528
+ assert_equal(Logger::WARN, @app.logger.level)
529
+ ensure
530
+ @app.logger.close
531
+ end
532
+ @app.logger = logger = Logger.new(STDOUT)
533
+ assert_equal(logger, @app.logger)
534
+ assert_equal(Logger::WARN, @app.logger.level)
535
+ @app.log = @filename
536
+ begin
537
+ assert(logger != @app.logger)
538
+ assert_equal(Logger::WARN, @app.logger.level)
539
+ ensure
540
+ @app.logger.close
541
+ end
542
+ end
543
+ end
544
+