Implement string to level helper (#52)

logger.go

@@ -21,31 +21,48 @@ const (
 	DebugLevel
 )
 
-// Level represent log Entry level
+var stringToLevel = map[string]Level{
+	"emergency": EmergencyLevel,
+	"alert":     AlertLevel,
+	"critical":  CriticalLevel,
+	"error":     ErrorLevel,
+	"warning":   WarningLevel,
+	"notice":    NoticeLevel,
+	"info":      InfoLevel,
+	"debug":     DebugLevel,
+}
+
+var levelToString = map[Level]string{
+	EmergencyLevel: "emergency",
+	AlertLevel:     "alert",
+	CriticalLevel:  "critical",
+	ErrorLevel:     "error",
+	WarningLevel:   "warning",
+	NoticeLevel:    "notice",
+	InfoLevel:      "info",
+	DebugLevel:     "debug",
+}
+
+// LevelString represent log Entry level as string
+type LevelString string
+
+// Level will return log Level for string or DebugLevel if unknown value
+func (l LevelString) Level() Level {
+	if v, ok := stringToLevel[string(l)]; ok {
+		return v
+	}
+	return DebugLevel
+}
+
+// Level represent log Entry levelString
 type Level int8
 
 // String will return Level as string
 func (l Level) String() string {
-	switch l {
-	case DebugLevel:
-		return "debug"
-	case InfoLevel:
-		return "info"
-	case NoticeLevel:
-		return "notice"
-	case WarningLevel:
-		return "warning"
-	case ErrorLevel:
-		return "error"
-	case CriticalLevel:
-		return "critical"
-	case AlertLevel:
-		return "alert"
-	case EmergencyLevel:
-		return "emergency"
-	default:
-		return fmt.Sprintf("level(%d)", l)
+	if v, ok := levelToString[l]; ok {
+		return v
 	}
+	return fmt.Sprintf("level(%d)", l)
 }
 
 // LogInterface define simplest logger contract

logger_test.go

@@ -18,6 +18,27 @@ import (
 	"github.com/gol4ng/logger/middleware"
 )
 
+func TestLevelString_Level(t *testing.T) {
+	tests := []struct {
+		levelString logger.LevelString
+		expected    logger.Level
+	}{
+		{levelString: "debug", expected: logger.DebugLevel},
+		{levelString: "info", expected: logger.InfoLevel},
+		{levelString: "notice", expected: logger.NoticeLevel},
+		{levelString: "warning", expected: logger.WarningLevel},
+		{levelString: "error", expected: logger.ErrorLevel},
+		{levelString: "critical", expected: logger.CriticalLevel},
+		{levelString: "alert", expected: logger.AlertLevel},
+		{levelString: "emergency", expected: logger.EmergencyLevel},
+		{levelString: "anothervalue", expected: logger.DebugLevel},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(t, tt.expected, tt.levelString.Level())
+	}
+}
+
 func TestLevel_String(t *testing.T) {
 	tests := []struct {
 		level    logger.Level
@@ -77,7 +98,7 @@ func TestLogger_Log(t *testing.T) {
 			level: logger.EmergencyLevel,
 		},
 		{
-			name:  "test Log(custom level)",
+			name:  "test Log(custom levelString)",
 			level: logger.Level(127),
 		},
 	}