From 57330048a4cf3188b6fd7655acfaacf85b2c135b Mon Sep 17 00:00:00 2001 From: mrz1836 Date: Mon, 16 Nov 2020 23:58:22 -0500 Subject: [PATCH] Working on interface for all log methods --- log_entries.go | 45 ++++++++++++++++++ log_entries_test.go | 4 +- logger.go | 82 +++++++++++++++++++++++++++++---- logger_test.go | 109 ++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 224 insertions(+), 16 deletions(-) diff --git a/log_entries.go b/log_entries.go index 260c2ac..678a910 100644 --- a/log_entries.go +++ b/log_entries.go @@ -130,6 +130,41 @@ func (l *LogClient) write(data string) { l.messages.Enqueue(&buff) } +// Panic overloads built-in method +func (l *LogClient) Panic(v ...interface{}) { + var buff bytes.Buffer + buff.WriteString(l.token) + buff.WriteByte(' ') + buff.WriteString(fmt.Sprint(v...)) + _ = l.sendOne(&buff) + os.Exit(1) +} + +// Panicln overloads built-in method +func (l *LogClient) Panicln(v ...interface{}) { + var buff bytes.Buffer + buff.WriteString(l.token) + buff.WriteByte(' ') + buff.WriteString(fmt.Sprintln(v...)) + _ = l.sendOne(&buff) + os.Exit(1) +} + +// Panicf overloads built-in method +func (l *LogClient) Panicf(format string, v ...interface{}) { + var buff bytes.Buffer + buff.WriteString(l.token) + buff.WriteByte(' ') + buff.WriteString(fmt.Sprintf(format, v...)) + _ = l.sendOne(&buff) + os.Exit(1) +} + +// Print overloads built-in method +func (l *LogClient) Print(v ...interface{}) { + l.write(fmt.Sprint(v...)) +} + // Println overloads built-in method func (l *LogClient) Println(v ...interface{}) { l.write(fmt.Sprintln(v...)) @@ -140,6 +175,16 @@ func (l *LogClient) Printf(format string, v ...interface{}) { l.write(fmt.Sprintf(format, v...)) } +// Fatal overloads built-in method +func (l *LogClient) Fatal(v ...interface{}) { + var buff bytes.Buffer + buff.WriteString(l.token) + buff.WriteByte(' ') + buff.WriteString(fmt.Sprint(v...)) + _ = l.sendOne(&buff) + os.Exit(1) +} + // Fatalln overloads built-in method func (l *LogClient) Fatalln(v ...interface{}) { var buff bytes.Buffer diff --git a/log_entries_test.go b/log_entries_test.go index 3b07ea6..16a22bd 100644 --- a/log_entries_test.go +++ b/log_entries_test.go @@ -22,11 +22,11 @@ func TestNewLogEntriesClient(t *testing.T) { assert.Equal(t, LogEntriesURL, client.endpoint) assert.Equal(t, testToken, client.token) - client, err = NewLogEntriesClient("token", LogEntriesURL, "101010") + client, err = NewLogEntriesClient(testToken, LogEntriesURL, "101010") assert.Error(t, err) assert.NotNil(t, client) - client, err = NewLogEntriesClient("token", "http://badurl.com", LogEntriesPort) + client, err = NewLogEntriesClient(testToken, "http://badurl.com", LogEntriesPort) assert.Error(t, err) assert.NotNil(t, client) diff --git a/logger.go b/logger.go index 68d1aef..020ae1d 100644 --- a/logger.go +++ b/logger.go @@ -15,10 +15,15 @@ import ( // Logger interface describes the functionality that a log service must implement type Logger interface { - Println(v ...interface{}) - Printf(format string, v ...interface{}) - Fatalln(v ...interface{}) + Fatal(...interface{}) Fatalf(format string, v ...interface{}) + Fatalln(v ...interface{}) + Panic(...interface{}) + Panicf(string, ...interface{}) + Panicln(...interface{}) + Print(...interface{}) + Printf(format string, v ...interface{}) + Println(v ...interface{}) } // KeyValue key value for errors @@ -119,6 +124,33 @@ func FileTagComponents(level int) []string { return []string{strings.Join(path[len(path)-2:], "/"), methodPath[len(methodPath)-1], strconv.Itoa(line)} } +// Panic is equivalent to Print() followed by a call to os.Exit(1) +func Panic(v ...interface{}) { + values := []interface{}{FileTag(2)} + values = append(values, v...) + implementation.Panic(values...) +} + +// Panicln is equivalent to Println() followed by a call to os.Exit(1) +func Panicln(v ...interface{}) { + values := []interface{}{FileTag(2)} + values = append(values, v...) + implementation.Panicln(values...) +} + +// Panicf is equivalent to Printf() followed by a call to os.Exit(1) +func Panicf(format string, v ...interface{}) { + implementation.Panicf(FileTag(2)+" "+format, v...) +} + +// Print calls Output to print to the connected logger. +// Arguments are handled in the manner of fmt.Print. +func Print(v ...interface{}) { + values := []interface{}{FileTag(2)} + values = append(values, v...) + implementation.Print(values...) +} + // Println calls Output to print to the connected logger. // Arguments are handled in the manner of fmt.Println. func Println(v ...interface{}) { @@ -127,6 +159,12 @@ func Println(v ...interface{}) { implementation.Println(values...) } +// Printf calls Output to print to the connected logger. +// Arguments are handled in the manner of fmt.Printf. +func Printf(format string, v ...interface{}) { + implementation.Printf(FileTag(2)+" "+format, v...) +} + // NoFilePrintln calls Output to print to the connected logger. // Arguments are handled in the manner of fmt.Println. func NoFilePrintln(v ...interface{}) { @@ -135,18 +173,19 @@ func NoFilePrintln(v ...interface{}) { implementation.Println(values...) } -// Printf calls Output to print to the connected logger. -// Arguments are handled in the manner of fmt.Printf. -func Printf(format string, v ...interface{}) { - implementation.Printf(FileTag(2)+" "+format, v...) -} - // NoFilePrintf calls Output to print to the connected logger. // Arguments are handled in the manner of fmt.Printf. func NoFilePrintf(format string, v ...interface{}) { implementation.Printf(format, v...) } +// Fatal is equivalent to Print() followed by a call to os.Exit(1) +func Fatal(v ...interface{}) { + values := []interface{}{FileTag(2)} + values = append(values, v...) + implementation.Fatal(values...) +} + // Fatalln is equivalent to Println() followed by a call to os.Exit(1) func Fatalln(v ...interface{}) { values := []interface{}{FileTag(2)} @@ -224,6 +263,26 @@ func NoFileData(logLevel LogLevel, message string, args ...KeyValue) { NoFilePrintln(buf.String()) } +// Panic is normal panic +func (l *logPkg) Panic(v ...interface{}) { + log.Fatal(v...) +} + +// Panicln fatal line +func (l *logPkg) Panicln(v ...interface{}) { + log.Fatalln(v...) +} + +// Panicf fatal sprint line +func (l *logPkg) Panicf(format string, v ...interface{}) { + log.Fatalf(format, v...) +} + +// Print prints +func (l *logPkg) Print(v ...interface{}) { + log.Print(v...) +} + // Println print line func (l *logPkg) Println(v ...interface{}) { log.Println(v...) @@ -234,6 +293,11 @@ func (l *logPkg) Printf(format string, v ...interface{}) { log.Printf(format, v...) } +// Fatal is normal fatal +func (l *logPkg) Fatal(v ...interface{}) { + log.Fatal(v...) +} + // Fatalln fatal line func (l *logPkg) Fatalln(v ...interface{}) { log.Fatalln(v...) diff --git a/logger_test.go b/logger_test.go index 52ef878..1847832 100644 --- a/logger_test.go +++ b/logger_test.go @@ -161,6 +161,16 @@ func TestPrintln(t *testing.T) { assert.Contains(t, captured, "test this method") } +// TestPrint test the print method +func TestPrint(t *testing.T) { + captured := captureOutput(func() { + Print("test this method") + }) + + assert.Contains(t, captured, "go-logger/logger_test.go:go-logger.TestPrint") + assert.Contains(t, captured, "test this method") +} + // TestNoFilePrintln test the print line method func TestNoFilePrintln(t *testing.T) { captured := captureOutput(func() { @@ -324,8 +334,7 @@ func BenchmarkLogPkg_Println(b *testing.B) { // TestFatalf will test the Fatalf() method func TestFatalf(t *testing.T) { - token := "token" - client, err := NewLogEntriesClient(token, LogEntriesURL, LogEntriesPort) + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) assert.NoError(t, err) assert.NotNil(t, client) @@ -347,11 +356,32 @@ func TestFatalf(t *testing.T) { t.Fatalf("process ran with err %v, want exit status 1", err) } -// TestFatalf will test the Fatalln() method +// TestFatal will test the Fatal() method +func TestFatal(t *testing.T) { + + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) + assert.NoError(t, err) + assert.NotNil(t, client) + + SetImplementation(client) + + if os.Getenv("EXIT_FUNCTION") == "1" { + Fatal("test exit") + return + } + cmd := exec.Command(os.Args[0], "-test.run=TestFatal") + cmd.Env = append(os.Environ(), "EXIT_FUNCTION=1") + err = cmd.Run() + if e, ok := err.(*exec.ExitError); ok && !e.Success() { + return + } + t.Fatalf("process ran with err %v, want exit status 1", err) +} + +// TestFatalln will test the Fatalln() method func TestFatalln(t *testing.T) { - token := "token" - client, err := NewLogEntriesClient(token, LogEntriesURL, LogEntriesPort) + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) assert.NoError(t, err) assert.NotNil(t, client) @@ -369,3 +399,72 @@ func TestFatalln(t *testing.T) { } t.Fatalf("process ran with err %v, want exit status 1", err) } + +// TestPanic will test the Panic() method +func TestPanic(t *testing.T) { + + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) + assert.NoError(t, err) + assert.NotNil(t, client) + + SetImplementation(client) + + if os.Getenv("EXIT_FUNCTION") == "1" { + Panic("test exit") + return + } + cmd := exec.Command(os.Args[0], "-test.run=TestPanic") + cmd.Env = append(os.Environ(), "EXIT_FUNCTION=1") + err = cmd.Run() + if e, ok := err.(*exec.ExitError); ok && !e.Success() { + return + } + t.Fatalf("process ran with err %v, want exit status 1", err) +} + +// TestPanicln will test the Panicln() method +func TestPanicln(t *testing.T) { + + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) + assert.NoError(t, err) + assert.NotNil(t, client) + + SetImplementation(client) + + if os.Getenv("EXIT_FUNCTION") == "1" { + Panicln("test exit") + return + } + cmd := exec.Command(os.Args[0], "-test.run=TestPanicln") + cmd.Env = append(os.Environ(), "EXIT_FUNCTION=1") + err = cmd.Run() + if e, ok := err.(*exec.ExitError); ok && !e.Success() { + return + } + t.Fatalf("process ran with err %v, want exit status 1", err) +} + +// TestPanicf will test the Panicf() method +func TestPanicf(t *testing.T) { + + client, err := NewLogEntriesClient(testToken, LogEntriesURL, LogEntriesPort) + assert.NoError(t, err) + assert.NotNil(t, client) + + SetImplementation(client) + + theImplementation := GetImplementation() + assert.NotNil(t, theImplementation) + + if os.Getenv("EXIT_FUNCTION") == "1" { + Panicf("test %d", 1) + return + } + cmd := exec.Command(os.Args[0], "-test.run=TestPanicf") + cmd.Env = append(os.Environ(), "EXIT_FUNCTION=1") + err = cmd.Run() + if e, ok := err.(*exec.ExitError); ok && !e.Success() { + return + } + t.Fatalf("process ran with err %v, want exit status 1", err) +}