t/log.t

   1 use strict;
   2 use warnings;
   3
   4 use Log::Contextual qw{:log with_logger set_logger};
   5 use Log::Contextual::SimpleLogger;
   6 use Test::More qw(no_plan);
   7 my $var1;
   8 my $var2;
   9 my $var3;
  10 my $var_logger1 = Log::Contextual::SimpleLogger->new({
  11    levels  => [qw(trace debug info warn error fatal)],
  12    coderef => sub { $var1 = shift },
  13 });
  14
  15 my $var_logger2 = Log::Contextual::SimpleLogger->new({
  16    levels  => [qw(trace debug info warn error fatal)],
  17    coderef => sub { $var2 = shift },
  18 });
  19
  20 my $var_logger3 = Log::Contextual::SimpleLogger->new({
  21    levels  => [qw(trace debug info warn error fatal)],
  22    coderef => sub { $var3 = shift },
  23 });
  24
  25 SETLOGGER: {
  26    set_logger(sub { $var_logger3 });
  27    log_debug { 'set_logger' };
  28    is( $var3, "[debug] set_logger\n", 'set logger works' );
  29 }
  30
  31 SETLOGGERTWICE: {
  32    my $foo;
  33    local $SIG{__WARN__} = sub { $foo = shift };
  34    set_logger(sub { $var_logger3 });
  35    like(
  36       $foo, qr/set_logger \(or -logger\) called more than once!  This is a bad idea! at/,
  37       'set_logger twice warns correctly'
  38    );
  39 }
  40
  41 WITHLOGGER: {
  42    with_logger sub { $var_logger2 } => sub {
  43
  44       with_logger $var_logger1 => sub {
  45          log_debug { 'nothing!' }
  46       };
  47       log_debug { 'frew!' };
  48
  49    };
  50
  51    is( $var1, "[debug] nothing!\n", 'inner scoped logger works' );
  52    is( $var2, "[debug] frew!\n", 'outer scoped logger works' );
  53 }
  54
  55 SETWITHLOGGER: {
  56    with_logger $var_logger1 => sub {
  57       log_debug { 'nothing again!' };
  58       # do this just so the following set_logger won't warn
  59       local $SIG{__WARN__} = sub {};
  60       set_logger(sub { $var_logger3 });
  61       log_debug { 'this is a set inside a with' };
  62    };
  63
  64    is( $var1, "[debug] nothing again!\n",
  65       'inner scoped logger works after using set_logger'
  66    );
  67
  68    is( $var3, "[debug] this is a set inside a with\n",
  69       'set inside with works'
  70    );
  71
  72    log_debug { 'frioux!' };
  73    is( $var3, "[debug] frioux!\n",
  74       q{set_logger's logger comes back after scoped logger}
  75    );
  76 }
  77
  78 VANILLA: {
  79    log_trace { 'fiSMBoC' };
  80    is( $var3, "[trace] fiSMBoC\n", 'trace works');
  81
  82    log_debug { 'fiSMBoC' };
  83    is( $var3, "[debug] fiSMBoC\n", 'debug works');
  84
  85    log_info { 'fiSMBoC' };
  86    is( $var3, "[info] fiSMBoC\n", 'info works');
  87
  88    log_warn { 'fiSMBoC' };
  89    is( $var3, "[warn] fiSMBoC\n", 'warn works');
  90
  91    log_error { 'fiSMBoC' };
  92    is( $var3, "[error] fiSMBoC\n", 'error works');
  93
  94    log_fatal { 'fiSMBoC' };
  95    is( $var3, "[fatal] fiSMBoC\n", 'fatal works');
  96
  97 }
  98
  99 ok(!eval { Log::Contextual->import; 1 }, 'Blank Log::Contextual import dies');
 100
 101 PASSTHROUGH: {
 102    my @vars;
 103
 104    @vars = log_trace { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 105    is( $var3, "[trace] fiSMBoC: bar\n", 'log_trace works with input');
 106    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_trace passes data through correctly');
 107
 108    @vars = log_debug { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 109    is( $var3, "[debug] fiSMBoC: bar\n", 'log_debug works with input');
 110    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_debug passes data through correctly');
 111
 112    @vars = log_info { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 113    is( $var3, "[info] fiSMBoC: bar\n", 'log_info works with input');
 114    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_info passes data through correctly');
 115
 116    @vars = log_warn { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 117    is( $var3, "[warn] fiSMBoC: bar\n", 'log_warn works with input');
 118    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_warn passes data through correctly');
 119
 120    @vars = log_error { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 121    is( $var3, "[error] fiSMBoC: bar\n", 'log_error works with input');
 122    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_error passes data through correctly');
 123
 124    @vars = log_fatal { 'fiSMBoC: ' . $_[1] } qw{foo bar baz};
 125    is( $var3, "[fatal] fiSMBoC: bar\n", 'log_fatal works with input');
 126    ok( eq_array(\@vars, [qw{foo bar baz}]), 'log_fatal passes data through correctly');
 127
 128
 129
 130    my $val;
 131    $val = logS_trace { 'fiSMBoC: ' . $_[0] } 'foo';
 132    is( $var3, "[trace] fiSMBoC: foo\n", 'logS_trace works with input');
 133    is( $val, 'foo', 'logS_trace passes data through correctly');
 134
 135    $val = logS_debug { 'fiSMBoC: ' . $_[0] } 'foo';
 136    is( $var3, "[debug] fiSMBoC: foo\n", 'logS_debug works with input');
 137    is( $val, 'foo', 'logS_debug passes data through correctly');
 138
 139    $val = logS_info { 'fiSMBoC: ' . $_[0] } 'foo';
 140    is( $var3, "[info] fiSMBoC: foo\n", 'logS_info works with input');
 141    is( $val, 'foo', 'logS_info passes data through correctly');
 142
 143    $val = logS_warn { 'fiSMBoC: ' . $_[0] } 'foo';
 144    is( $var3, "[warn] fiSMBoC: foo\n", 'logS_warn works with input');
 145    is( $val, 'foo', 'logS_warn passes data through correctly');
 146
 147    $val = logS_error { 'fiSMBoC: ' . $_[0] } 'foo';
 148    is( $var3, "[error] fiSMBoC: foo\n", 'logS_error works with input');
 149    is( $val, 'foo', 'logS_error passes data through correctly');
 150
 151    $val = logS_fatal { 'fiSMBoC: ' . $_[0] } 'foo';
 152    is( $var3, "[fatal] fiSMBoC: foo\n", 'logS_fatal works with input');
 153    is( $val, 'foo', 'logS_fatal passes data through correctly');
 154
 155    ok(!eval "logS_error { 'frew' } 'bar', 'baz'; 1", 'logS_$level dies from too many args');
 156 }