github.com/ssgreg/logf@v1.4.1/level_test.go (about)

     1  package logf
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestLevelChecker(t *testing.T) {
    11  	type LevelCheck struct {
    12  		level   Level
    13  		enabled bool
    14  	}
    15  
    16  	cases := []struct {
    17  		level   Level
    18  		goldens []LevelCheck
    19  	}{
    20  		{
    21  			LevelError,
    22  			[]LevelCheck{{LevelError, true}, {LevelWarn, false}, {LevelInfo, false}, {LevelDebug, false}},
    23  		},
    24  		{
    25  			LevelWarn,
    26  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, false}, {LevelDebug, false}},
    27  		},
    28  		{
    29  			LevelInfo,
    30  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, true}, {LevelDebug, false}},
    31  		},
    32  		{
    33  			LevelDebug,
    34  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, true}, {LevelDebug, true}},
    35  		},
    36  	}
    37  
    38  	for _, cs := range cases {
    39  		checker := cs.level.LevelChecker()
    40  		for _, golden := range cs.goldens {
    41  			assert.Equal(t, golden.enabled, checker(golden.level), "%q checks with %q", cs.level, golden.level)
    42  		}
    43  	}
    44  }
    45  
    46  func TestLevelString(t *testing.T) {
    47  	cases := []struct {
    48  		level        Level
    49  		strGolden    string
    50  		capStrGolden string
    51  	}{
    52  		{LevelError, "error", "ERROR"},
    53  		{LevelWarn, "warn", "WARN"},
    54  		{LevelInfo, "info", "INFO"},
    55  		{LevelDebug, "debug", "DEBUG"},
    56  		{Level(42), "unknown", "UNKNOWN"},
    57  	}
    58  
    59  	for _, cs := range cases {
    60  		assert.Equal(t, cs.strGolden, cs.level.String(), "check level %d String", int(cs.level))
    61  		assert.Equal(t, cs.capStrGolden, cs.level.UpperCaseString(), "check level %d UpperCaseString", int(cs.level))
    62  	}
    63  }
    64  
    65  func TestLevelFromString(t *testing.T) {
    66  	cases := []struct {
    67  		checking []string
    68  		golden   Level
    69  	}{
    70  		{[]string{"error", "ERROR"}, LevelError},
    71  		{[]string{"warn", "WARN", "warning", "WARNING"}, LevelWarn},
    72  		{[]string{"info", "INFO", "information", "INFORMATION"}, LevelInfo},
    73  		{[]string{"debug", "DEBUG"}, LevelDebug},
    74  	}
    75  
    76  	for _, cs := range cases {
    77  		for _, lvl := range cs.checking {
    78  			level, ok := LevelFromString(lvl)
    79  			assert.True(t, ok, "validate %q", lvl)
    80  			assert.Equal(t, cs.golden, level, "compare golden %q with %q", cs.golden, level)
    81  		}
    82  	}
    83  
    84  	_, ok := LevelFromString("unknown")
    85  	assert.False(t, ok, "fail is expected")
    86  }
    87  
    88  func TestDefaultLevelEncoder(t *testing.T) {
    89  	enc := testTypeEncoder{}
    90  	DefaultLevelEncoder(LevelError, &enc)
    91  
    92  	assert.EqualValues(t, "error", enc.result)
    93  }
    94  
    95  func TestUpperCaseLevelEncoder(t *testing.T) {
    96  	enc := testTypeEncoder{}
    97  	UpperCaseLevelEncoder(LevelError, &enc)
    98  
    99  	assert.EqualValues(t, "ERROR", enc.result)
   100  }
   101  
   102  func TestMutableLevelChecker(t *testing.T) {
   103  	type LevelCheck struct {
   104  		level   Level
   105  		enabled bool
   106  	}
   107  
   108  	cases := []struct {
   109  		checker LevelChecker
   110  		goldens []LevelCheck
   111  	}{
   112  		{
   113  			NewMutableLevel(LevelError).LevelChecker(),
   114  			[]LevelCheck{{LevelError, true}, {LevelWarn, false}, {LevelInfo, false}, {LevelDebug, false}},
   115  		},
   116  		{
   117  			NewMutableLevel(LevelWarn).LevelChecker(),
   118  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, false}, {LevelDebug, false}},
   119  		},
   120  		{
   121  			NewMutableLevel(LevelInfo).LevelChecker(),
   122  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, true}, {LevelDebug, false}},
   123  		},
   124  		{
   125  			NewMutableLevel(LevelDebug).LevelChecker(),
   126  			[]LevelCheck{{LevelError, true}, {LevelWarn, true}, {LevelInfo, true}, {LevelDebug, true}},
   127  		},
   128  	}
   129  
   130  	for i, cs := range cases {
   131  		for _, golden := range cs.goldens {
   132  			assert.Equal(t, golden.enabled, cs.checker(golden.level), "%d checks with %q", i, golden.level)
   133  		}
   134  	}
   135  }
   136  
   137  func TestMutableLevel(t *testing.T) {
   138  	level := NewMutableLevel(LevelError)
   139  	assert.Equal(t, LevelError, level.Level())
   140  
   141  	level.Set(LevelDebug)
   142  	assert.Equal(t, LevelDebug, level.Level())
   143  }
   144  
   145  func TestLevelUnmarshal(t *testing.T) {
   146  	v := struct {
   147  		Level Level `json:"level"`
   148  	}{}
   149  
   150  	err := json.Unmarshal([]byte(`{"level": "warn"}`), &v)
   151  	assert.NoError(t, err)
   152  	assert.Equal(t, LevelWarn, v.Level)
   153  }
   154  
   155  func TestLevelUnmarshalInvalid(t *testing.T) {
   156  	v := struct {
   157  		Level Level `json:"level"`
   158  	}{}
   159  
   160  	err := json.Unmarshal([]byte(`{"level": "some-invalid-value"}`), &v)
   161  	assert.EqualError(t, err, `invalid logging level "some-invalid-value"`)
   162  	assert.Equal(t, LevelError, v.Level)
   163  }