github.com/lingyao2333/mo-zero@v1.4.1/core/logx/writer_test.go (about)

     1  package logx
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"errors"
     7  	"log"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestNewWriter(t *testing.T) {
    14  	const literal = "foo bar"
    15  	var buf bytes.Buffer
    16  	w := NewWriter(&buf)
    17  	w.Info(literal)
    18  	assert.Contains(t, buf.String(), literal)
    19  	buf.Reset()
    20  	w.Debug(literal)
    21  	assert.Contains(t, buf.String(), literal)
    22  }
    23  
    24  func TestConsoleWriter(t *testing.T) {
    25  	var buf bytes.Buffer
    26  	w := newConsoleWriter()
    27  	lw := newLogWriter(log.New(&buf, "", 0))
    28  	w.(*concreteWriter).errorLog = lw
    29  	w.Alert("foo bar 1")
    30  	var val mockedEntry
    31  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    32  		t.Fatal(err)
    33  	}
    34  	assert.Equal(t, levelAlert, val.Level)
    35  	assert.Equal(t, "foo bar 1", val.Content)
    36  
    37  	buf.Reset()
    38  	w.(*concreteWriter).errorLog = lw
    39  	w.Error("foo bar 2")
    40  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    41  		t.Fatal(err)
    42  	}
    43  	assert.Equal(t, levelError, val.Level)
    44  	assert.Equal(t, "foo bar 2", val.Content)
    45  
    46  	buf.Reset()
    47  	w.(*concreteWriter).infoLog = lw
    48  	w.Info("foo bar 3")
    49  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    50  		t.Fatal(err)
    51  	}
    52  	assert.Equal(t, levelInfo, val.Level)
    53  	assert.Equal(t, "foo bar 3", val.Content)
    54  
    55  	buf.Reset()
    56  	w.(*concreteWriter).severeLog = lw
    57  	w.Severe("foo bar 4")
    58  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    59  		t.Fatal(err)
    60  	}
    61  	assert.Equal(t, levelFatal, val.Level)
    62  	assert.Equal(t, "foo bar 4", val.Content)
    63  
    64  	buf.Reset()
    65  	w.(*concreteWriter).slowLog = lw
    66  	w.Slow("foo bar 5")
    67  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    68  		t.Fatal(err)
    69  	}
    70  	assert.Equal(t, levelSlow, val.Level)
    71  	assert.Equal(t, "foo bar 5", val.Content)
    72  
    73  	buf.Reset()
    74  	w.(*concreteWriter).statLog = lw
    75  	w.Stat("foo bar 6")
    76  	if err := json.Unmarshal(buf.Bytes(), &val); err != nil {
    77  		t.Fatal(err)
    78  	}
    79  	assert.Equal(t, levelStat, val.Level)
    80  	assert.Equal(t, "foo bar 6", val.Content)
    81  
    82  	w.(*concreteWriter).infoLog = hardToCloseWriter{}
    83  	assert.NotNil(t, w.Close())
    84  	w.(*concreteWriter).infoLog = easyToCloseWriter{}
    85  	w.(*concreteWriter).errorLog = hardToCloseWriter{}
    86  	assert.NotNil(t, w.Close())
    87  	w.(*concreteWriter).errorLog = easyToCloseWriter{}
    88  	w.(*concreteWriter).severeLog = hardToCloseWriter{}
    89  	assert.NotNil(t, w.Close())
    90  	w.(*concreteWriter).severeLog = easyToCloseWriter{}
    91  	w.(*concreteWriter).slowLog = hardToCloseWriter{}
    92  	assert.NotNil(t, w.Close())
    93  	w.(*concreteWriter).slowLog = easyToCloseWriter{}
    94  	w.(*concreteWriter).statLog = hardToCloseWriter{}
    95  	assert.NotNil(t, w.Close())
    96  	w.(*concreteWriter).statLog = easyToCloseWriter{}
    97  }
    98  
    99  func TestNopWriter(t *testing.T) {
   100  	assert.NotPanics(t, func() {
   101  		var w nopWriter
   102  		w.Alert("foo")
   103  		w.Debug("foo")
   104  		w.Error("foo")
   105  		w.Info("foo")
   106  		w.Severe("foo")
   107  		w.Stack("foo")
   108  		w.Stat("foo")
   109  		w.Slow("foo")
   110  		w.Close()
   111  	})
   112  }
   113  
   114  func TestWriteJson(t *testing.T) {
   115  	var buf bytes.Buffer
   116  	log.SetOutput(&buf)
   117  	writeJson(nil, "foo")
   118  	assert.Contains(t, buf.String(), "foo")
   119  	buf.Reset()
   120  	writeJson(nil, make(chan int))
   121  	assert.Contains(t, buf.String(), "unsupported type")
   122  }
   123  
   124  func TestWritePlainAny(t *testing.T) {
   125  	var buf bytes.Buffer
   126  	log.SetOutput(&buf)
   127  	writePlainAny(nil, levelInfo, "foo")
   128  	assert.Contains(t, buf.String(), "foo")
   129  
   130  	buf.Reset()
   131  	writePlainAny(nil, levelDebug, make(chan int))
   132  	assert.Contains(t, buf.String(), "unsupported type")
   133  	writePlainAny(nil, levelDebug, 100)
   134  	assert.Contains(t, buf.String(), "100")
   135  
   136  	buf.Reset()
   137  	writePlainAny(nil, levelError, make(chan int))
   138  	assert.Contains(t, buf.String(), "unsupported type")
   139  	writePlainAny(nil, levelSlow, 100)
   140  	assert.Contains(t, buf.String(), "100")
   141  
   142  	buf.Reset()
   143  	writePlainAny(hardToWriteWriter{}, levelStat, 100)
   144  	assert.Contains(t, buf.String(), "write error")
   145  
   146  	buf.Reset()
   147  	writePlainAny(hardToWriteWriter{}, levelSevere, "foo")
   148  	assert.Contains(t, buf.String(), "write error")
   149  
   150  	buf.Reset()
   151  	writePlainAny(hardToWriteWriter{}, levelAlert, "foo")
   152  	assert.Contains(t, buf.String(), "write error")
   153  
   154  	buf.Reset()
   155  	writePlainAny(hardToWriteWriter{}, levelFatal, "foo")
   156  	assert.Contains(t, buf.String(), "write error")
   157  
   158  }
   159  
   160  type mockedEntry struct {
   161  	Level   string `json:"level"`
   162  	Content string `json:"content"`
   163  }
   164  
   165  type easyToCloseWriter struct{}
   166  
   167  func (h easyToCloseWriter) Write(_ []byte) (_ int, _ error) {
   168  	return
   169  }
   170  
   171  func (h easyToCloseWriter) Close() error {
   172  	return nil
   173  }
   174  
   175  type hardToCloseWriter struct{}
   176  
   177  func (h hardToCloseWriter) Write(_ []byte) (_ int, _ error) {
   178  	return
   179  }
   180  
   181  func (h hardToCloseWriter) Close() error {
   182  	return errors.New("close error")
   183  }
   184  
   185  type hardToWriteWriter struct{}
   186  
   187  func (h hardToWriteWriter) Write(_ []byte) (_ int, _ error) {
   188  	return 0, errors.New("write error")
   189  }