Added ParseLevel

Author: ricardorg79

lib.go

@@ -2,11 +2,29 @@ package log
 
 import (
 	golog "log"
+	"strings"
 )
 
 // Level Log level to use in `SetLevel()` function
 type Level int
 
+func (l Level) String() string {
+	if l == LevelFatal {
+		return "FATAL"
+	} else if l == LevelError {
+		return "ERROR"
+	} else if l == LevelWarn {
+		return "WARN"
+	} else if l == LevelInfo {
+		return "INFO"
+	} else if l == LevelDebug {
+		return "DEBUG"
+	} else if l == LevelTrace {
+		return "TRACE"
+	}
+	return "UNKNOWN"
+}
+
 const (
 	// LevelFatal to be used with `SetLevel(LevelFatal)`, to set log level to only Fatal calls
 	LevelFatal Level = iota
@@ -38,6 +56,38 @@ func SetLevel(level Level) {
 	logLevel = level
 }
 
+// ParseLevel takes as string and return the corresponding level.  The strLevel argument
+// is case insensitive. The strLevel argument just needs to begin with one of the logging
+// level names.
+// Logging level names are TRACE, DEBUG, INFO, WARN, ERROR and FATAL
+//
+// e.g.: ParseLevel("debug")     // LevelDebug
+// e.g.: ParseLevel("DEBUG")     // LevelDebug
+// e.g.: ParseLevel("debugging") // LevelDebug
+// e.g.: ParseLevel("warn")      // LevelWarn
+// e.g.: ParseLevel("warni")     // LevelWarn
+// e.g.: ParseLevel("warnin")    // LevelWarn
+// e.g.: ParseLevel("warning")   // LevelWarn
+// e.g.: ParseLevel("WARNING")   // LevelWarn
+//
+func ParseLevel(strLevel string) Level {
+	str := strings.ToLower(strLevel)
+	if strings.HasPrefix(str, "trace") {
+		return LevelTrace
+	} else if strings.HasPrefix(str, "debug") {
+		return LevelDebug
+	} else if strings.HasPrefix(str, "info") {
+		return LevelInfo
+	} else if strings.HasPrefix(str, "warn") {
+		return LevelWarn
+	} else if strings.HasPrefix(str, "error") {
+		return LevelError
+	} else if strings.HasPrefix(str, "fatal") {
+		return LevelFatal
+	}
+	return LevelInfo
+}
+
 // Fatal is equivalent to Print() followed by a call to os.Exit(1).
 func Fatal(v ...interface{}) {
 	golog.Fatal(v...)

lib_test.go

@@ -0,0 +1,84 @@
+package log
+
+import (
+	"testing"
+)
+
+func TestSetLevel(t *testing.T) {
+	// given
+	levels := []Level{LevelTrace, LevelDebug, LevelInfo, LevelWarn, LevelError, LevelFatal}
+
+	for _, level := range levels {
+		// when
+		SetLevel(level)
+
+		// then
+		if logLevel != level {
+			t.Errorf("Expected %s, bug got %s", level, logLevel)
+		}
+	}
+}
+
+func TestParseLevelLowerCase(t *testing.T) {
+	// given
+	levels := map[string]Level{
+		"trace":     LevelTrace,
+		"tracei":    LevelTrace,
+		"tracein":   LevelTrace,
+		"traceing":  LevelTrace,
+		"debug":     LevelDebug,
+		"debugg":    LevelDebug,
+		"debuggi":   LevelDebug,
+		"debuggin":  LevelDebug,
+		"debugging": LevelDebug,
+		"info":      LevelInfo,
+		"warn":      LevelWarn,
+		"warni":     LevelWarn,
+		"warnin":    LevelWarn,
+		"warning":   LevelWarn,
+		"error":     LevelError,
+		"fatal":     LevelFatal,
+	}
+
+	for str, level := range levels {
+		// when
+		result := ParseLevel(str)
+
+		// then
+		if result != level {
+			t.Errorf("Expected %s, bug got %s", level, result)
+		}
+	}
+}
+
+func TestParseLevelUpperCase(t *testing.T) {
+	// given
+	levels := map[string]Level{
+		"TRACE":     LevelTrace,
+		"TRACEI":    LevelTrace,
+		"TRACEIN":   LevelTrace,
+		"TRACEING":  LevelTrace,
+		"DEBUG":     LevelDebug,
+		"DEBUGG":    LevelDebug,
+		"DEBUGGI":   LevelDebug,
+		"DEBUGGIN":  LevelDebug,
+		"DEBUGGING": LevelDebug,
+		"INFO":      LevelInfo,
+		"WARN":      LevelWarn,
+		"WARNI":     LevelWarn,
+		"WARNIN":    LevelWarn,
+		"WARNING":   LevelWarn,
+		"ERROR":     LevelError,
+		"FATAL":     LevelFatal,
+	}
+
+	for str, level := range levels {
+		// when
+		result := ParseLevel(str)
+
+		// then
+		if result != level {
+			t.Errorf("Expected %s, bug got %s", level, result)
+		}
+	}
+}