Return Error from ParseLevel

level.go

@@ -1,6 +1,9 @@
 package log
 
-import "strings"
+import (
+	"fmt"
+	"strings"
+)
 
 // Level is a logging level.
 type Level int32
@@ -38,20 +41,24 @@ func (l Level) String() string {
 	}
 }
 
+func parseLevelError(level string) error {
+	return fmt.Errorf("invalid level %s", strings.ToLower(level))
+}
+
 // ParseLevel converts level in string to Level type. Default level is InfoLevel.
-func ParseLevel(level string) Level {
+func ParseLevel(level string) (Level, error) {
 	switch strings.ToLower(level) {
 	case DebugLevel.String():
-		return DebugLevel
+		return DebugLevel, nil
 	case InfoLevel.String():
-		return InfoLevel
+		return InfoLevel, nil
 	case WarnLevel.String():
-		return WarnLevel
+		return WarnLevel, nil
 	case ErrorLevel.String():
-		return ErrorLevel
+		return ErrorLevel, nil
 	case FatalLevel.String():
-		return FatalLevel
+		return FatalLevel, nil
 	default:
-		return InfoLevel
+		return InfoLevel, parseLevelError(level)
 	}
 }

level_test.go

@@ -10,52 +10,59 @@ func TestDefaultLevel(t *testing.T) {
 	var level Level
 	assert.Equal(t, InfoLevel, level)
 }
+
+type parseLevelResult struct {
+	level Level
+	err   error
+}
+
 func TestParseLevel(t *testing.T) {
 	testCases := []struct {
-		name     string
-		level    string
-		expLevel Level
+		name   string
+		input  string
+		result parseLevelResult
 	}{
 		{
-			name:     "Parse debug",
-			level:    "debug",
-			expLevel: DebugLevel,
+			name:   "Parse debug",
+			input:  "debug",
+			result: parseLevelResult{DebugLevel, nil},
 		},
 		{
-			name:     "Parse info",
-			level:    "Info",
-			expLevel: InfoLevel,
+			name:   "Parse info",
+			input:  "Info",
+			result: parseLevelResult{InfoLevel, nil},
 		},
 		{
-			name:     "Parse warn",
-			level:    "WARN",
-			expLevel: WarnLevel,
+			name:   "Parse warn",
+			input:  "WARN",
+			result: parseLevelResult{WarnLevel, nil},
 		},
 		{
-			name:     "Parse error",
-			level:    "error",
-			expLevel: ErrorLevel,
+			name:   "Parse error",
+			input:  "error",
+			result: parseLevelResult{ErrorLevel, nil},
 		},
 		{
-			name:     "Parse fatal",
-			level:    "FATAL",
-			expLevel: FatalLevel,
+			name:   "Parse fatal",
+			input:  "FATAL",
+			result: parseLevelResult{FatalLevel, nil},
 		},
 		{
-			name:     "Default",
-			level:    "",
-			expLevel: InfoLevel,
+			name:   "Default",
+			input:  "",
+			result: parseLevelResult{InfoLevel, parseLevelError("")},
 		},
 		{
-			name:     "Wrong level, set INFO",
-			level:    "WRONG_LEVEL",
-			expLevel: InfoLevel,
+			name:   "Wrong level, set INFO",
+			input:  "WRONG_LEVEL",
+			result: parseLevelResult{InfoLevel, parseLevelError("WRONG_LEVEL")},
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.expLevel, ParseLevel(tc.level))
+			lvl, err := ParseLevel(tc.input)
+			assert.Equal(t, tc.result, parseLevelResult{lvl, err})
 		})
 	}
 }