gitlab.com/beacon-software/gadget@v0.0.0-20181217202115-54565ea1ed5e/log/log_test.go (about)

     1  package log
     2  
     3  import (
     4  	stdlog "log"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  
    10  	"gitlab.com/beacon-software/gadget/errors"
    11  	"gitlab.com/beacon-software/gadget/generator"
    12  )
    13  
    14  type ErrorPlus struct {
    15  	A     string
    16  	b     string
    17  	trace []string
    18  }
    19  
    20  func NewErrorPlus(a, b string) *ErrorPlus {
    21  	return &ErrorPlus{
    22  		A:     a,
    23  		b:     b,
    24  		trace: errors.GetStackTrace(),
    25  	}
    26  }
    27  
    28  func (err *ErrorPlus) Error() string {
    29  	return err.b
    30  }
    31  
    32  // Trace returns the stack trace for the error
    33  func (err *ErrorPlus) Trace() []string {
    34  	return err.trace
    35  }
    36  
    37  func (err *ErrorPlus) String() string {
    38  	return err.A
    39  }
    40  
    41  // Global instance
    42  
    43  func TestStandardLogger(t *testing.T) {
    44  	assert := assert.New(t)
    45  	id := generator.String(5)
    46  	var actual Message
    47  	f := func(m Message) {
    48  		actual = m
    49  	}
    50  	NewGlobal(id, NewOutput(FlagAll, f))
    51  	msg := generator.String(7)
    52  	stdlog.Print(msg)
    53  	assert.True(strings.HasPrefix(actual.Caller, "log_test.go:"))
    54  	assert.Equal(id, actual.LogIdentifier)
    55  	assert.Equal(LevelInfo, actual.Level)
    56  	assert.Equal(msg, actual.Message)
    57  	assert.True(strings.HasPrefix(actual.Timestamp, "20"))
    58  	assert.True(strings.HasSuffix(actual.Timestamp, "UTC"))
    59  }
    60  
    61  func TestLogFormat(t *testing.T) {
    62  	assert := assert.New(t)
    63  	var tests = []struct {
    64  		function func(string, ...interface{}) string
    65  		expected Level
    66  	}{
    67  		{
    68  			function: Auditf,
    69  			expected: LevelAudit,
    70  		},
    71  		{
    72  			function: Infof,
    73  			expected: LevelInfo,
    74  		},
    75  		{
    76  			function: Accessf,
    77  			expected: LevelAccess,
    78  		},
    79  		{
    80  			function: Warnf,
    81  			expected: LevelWarn,
    82  		},
    83  		{
    84  			function: Errorf,
    85  			expected: LevelError,
    86  		},
    87  		{
    88  			function: Debugf,
    89  			expected: LevelDebug,
    90  		},
    91  	}
    92  	for _, t := range tests {
    93  		id := generator.String(5)
    94  		var actual Message
    95  		f := func(m Message) {
    96  			actual = m
    97  		}
    98  		NewGlobal(id, NewOutput(FlagAll, f))
    99  		msg := generator.String(7)
   100  		t.function(msg)
   101  		assert.True(strings.HasPrefix(actual.Caller, "log_test.go"), "test for %s failed", t.expected)
   102  		assert.Equal(id, actual.LogIdentifier, id)
   103  		assert.Equal(t.expected, actual.Level, t.expected)
   104  		assert.Equal(msg, actual.Message)
   105  		assert.True(strings.HasPrefix(actual.Timestamp, "20"), t.expected)
   106  		assert.True(strings.HasSuffix(actual.Timestamp, "UTC"), t.expected)
   107  	}
   108  }
   109  
   110  func TestLogErrorObj(t *testing.T) {
   111  	assert := assert.New(t)
   112  	var tests = []struct {
   113  		function func(err error) error
   114  		expected Level
   115  		noCaller bool
   116  	}{
   117  		{
   118  			function: Audit,
   119  			expected: LevelAudit,
   120  			noCaller: true,
   121  		},
   122  		{
   123  			function: Info,
   124  			expected: LevelInfo,
   125  		},
   126  		{
   127  			function: Access,
   128  			expected: LevelAccess,
   129  		},
   130  		{
   131  			function: Warn,
   132  			expected: LevelWarn,
   133  		},
   134  		{
   135  			function: Error,
   136  			expected: LevelError,
   137  		},
   138  		{
   139  			function: Fatal,
   140  			expected: LevelFatal,
   141  		},
   142  		{
   143  			function: Debug,
   144  			expected: LevelDebug,
   145  		},
   146  	}
   147  	for _, t := range tests {
   148  		id := generator.String(5)
   149  		var actual Message
   150  		f := func(m Message) {
   151  			actual = m
   152  		}
   153  		NewGlobal(id, NewOutput(FlagAll, f))
   154  		err := errors.New(generator.String(7))
   155  		t.function(err)
   156  		if !t.noCaller {
   157  			assert.True(strings.HasPrefix(actual.Caller, "log_test.go"), "test for %s failed", t.expected)
   158  		}
   159  
   160  		assert.Equal(id, actual.LogIdentifier, id)
   161  		assert.Equal(t.expected, actual.Level, t.expected)
   162  		assert.Equal(err.Error(), actual.Message)
   163  		assert.True(strings.HasPrefix(actual.Timestamp, "20"), t.expected)
   164  		assert.True(strings.HasSuffix(actual.Timestamp, "UTC"), t.expected)
   165  	}
   166  }
   167  
   168  func TestLogger_AddOutput(t *testing.T) {
   169  	assert := assert.New(t)
   170  	var actual Message
   171  	var actual1 Message
   172  	f := func(m Message) {
   173  		actual = m
   174  	}
   175  	NewGlobal("TestLogger_AddOutput", NewOutput(FlagAll, f))
   176  
   177  	f1 := func(m Message) {
   178  		actual1 = m
   179  	}
   180  	output := NewOutput(FlagError, f1)
   181  	AddOutput(output)
   182  
   183  	assert.Contains(publicLogger.outputs[idxError], output)
   184  	expected := generator.String(10)
   185  	Warnf(expected)
   186  	assert.Equal(expected, actual.Message)
   187  	assert.Empty(actual1.Message)
   188  
   189  	expected = generator.String(10)
   190  	Errorf(expected)
   191  	assert.Equal(expected, actual.Message)
   192  	assert.Equal(expected, actual1.Message)
   193  }