test(utils): logger

pkg/utils/logger.go

@@ -8,36 +8,43 @@ import (
 
 // Logger allows you to log messages in the terminal
 type Logger struct {
-	newColor func(value ...color.Attribute) *color.Color
+	NewColor func(value ...color.Attribute) Color
+}
+
+type Color interface {
+	Println(a ...interface{}) (int, error)
+	Printf(format string, a ...interface{}) (int, error)
 }
 
 // Infoln logs an info message
 func (l *Logger) Infoln(s ...string) {
-	l.newColor(color.FgCyan).Println("[i]", strings.Join(s, " "))
+	l.NewColor(color.FgCyan).Println("[i]", strings.Join(s, " "))
 }
 
 // Warnln logs an warning message
 func (l *Logger) Warnln(s ...string) {
-	l.newColor(color.FgYellow).Println("[*]", strings.Join(s, " "))
+	l.NewColor(color.FgYellow).Println("[*]", strings.Join(s, " "))
 }
 
 // Errorln logs an error message
 func (l *Logger) Errorln(s ...string) {
-	l.newColor(color.FgRed).Println("[!]", strings.Join(s, " "))
+	l.NewColor(color.FgRed).Println("[!]", strings.Join(s, " "))
 }
 
 // Successln logs a success message
 func (l *Logger) Successln(s ...string) {
-	l.newColor(color.FgGreen).Println("[+]", strings.Join(s, " "))
+	l.NewColor(color.FgGreen).Println("[+]", strings.Join(s, " "))
 }
 
 // Successf logs a success message
 func (l *Logger) Successf(format string, messages ...interface{}) {
-	l.newColor(color.FgGreen).Printf("[+] "+format, messages...)
-	l.newColor().Printf("\n")
+	l.NewColor(color.FgGreen).Printf("[+] "+format, messages...)
+	l.NewColor().Printf("\n")
 }
 
 // LoggerService is the default logger instance
 var LoggerService = &Logger{
-	newColor: color.New,
+	NewColor: func(value ...color.Attribute) Color {
+		return color.New(value...)
+	},
 }

pkg/utils/utils_test.go

@@ -3,7 +3,10 @@ package utils
 import (
 	"testing"
 
+	"github.com/fatih/color"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"gopkg.in/sundowndev/phoneinfoga.v2/pkg/utils/mocks"
 )
 
 func TestUtils(t *testing.T) {
@@ -56,4 +59,103 @@ func TestUtils(t *testing.T) {
 			assert.Equal(result, false, "they should be equal")
 		})
 	})
+
+	t.Run("Logger", func(t *testing.T) {
+		t.Run("Infoln", func(t *testing.T) {
+			mLogger := new(mocks.Color)
+
+			mLogger.On("Println", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(0, nil)
+
+			log := &Logger{
+				NewColor: func(value ...color.Attribute) Color {
+					assert.Equal([]color.Attribute([]color.Attribute{36}), value, "they should be equal")
+
+					return mLogger
+				},
+			}
+
+			log.Infoln("test")
+
+			mLogger.AssertCalled(t, "Println", "[i]", "test")
+		})
+
+		t.Run("Warnln", func(t *testing.T) {
+			mLogger := new(mocks.Color)
+
+			mLogger.On("Println", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(0, nil)
+
+			log := &Logger{
+				NewColor: func(value ...color.Attribute) Color {
+					assert.Equal([]color.Attribute([]color.Attribute{33}), value, "they should be equal")
+
+					return mLogger
+				},
+			}
+
+			log.Warnln("test")
+
+			mLogger.AssertCalled(t, "Println", "[*]", "test")
+		})
+
+		t.Run("Errorln", func(t *testing.T) {
+			mLogger := new(mocks.Color)
+
+			mLogger.On("Println", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(0, nil)
+
+			log := &Logger{
+				NewColor: func(value ...color.Attribute) Color {
+					assert.Equal([]color.Attribute([]color.Attribute{31}), value, "they should be equal")
+
+					return mLogger
+				},
+			}
+
+			log.Errorln("test")
+
+			mLogger.AssertCalled(t, "Println", "[!]", "test")
+		})
+
+		t.Run("Successln", func(t *testing.T) {
+			mLogger := new(mocks.Color)
+
+			mLogger.On("Println", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(0, nil)
+
+			log := &Logger{
+				NewColor: func(value ...color.Attribute) Color {
+					assert.Equal([]color.Attribute([]color.Attribute{32}), value, "they should be equal")
+
+					return mLogger
+				},
+			}
+
+			log.Successln("test")
+
+			mLogger.AssertCalled(t, "Println", "[+]", "test")
+		})
+
+		t.Run("Successf", func(t *testing.T) {
+			var ColorNumberOfCalls int
+
+			mLogger := new(mocks.Color)
+
+			mLogger.On("Printf", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(0, nil)
+			mLogger.On("Printf", mock.AnythingOfType("string")).Return(0, nil)
+
+			log := &Logger{
+				NewColor: func(value ...color.Attribute) Color {
+					if ColorNumberOfCalls == 0 {
+						assert.Equal([]color.Attribute([]color.Attribute{32}), value, "they should be equal")
+						ColorNumberOfCalls++
+					}
+
+					return mLogger
+				},
+			}
+
+			log.Successf("%s", "test")
+
+			mLogger.AssertNumberOfCalls(t, "Printf", 2)
+			mLogger.AssertCalled(t, "Printf", "[+] %s", "test")
+		})
+	})
 }