mono_logger 1.1.0 → 1.1.2

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