Added logger level

http_test.go

@@ -47,11 +47,11 @@ type mockedHTTPClient func(req *http.Request) (*http.Response, error)
 
 func (c mockedHTTPClient) Do(req *http.Request) (*http.Response, error) { return c(req) }
 
-type mockedNetError struct{ temporary bool }
+type mockedNetError struct{ timeout bool }
 
 func (err mockedNetError) Error() string   { return "" }
-func (err mockedNetError) Timeout() bool   { return false }
-func (err mockedNetError) Temporary() bool { return err.temporary }
+func (err mockedNetError) Timeout() bool   { return err.timeout }
+func (err mockedNetError) Temporary() bool { return false }
 
 func TestHTTPSender(t *testing.T) {
 	// All errors
@@ -80,7 +80,7 @@ func TestHTTPSender(t *testing.T) {
 			case 1:
 				resp = &http.Response{StatusCode: http.StatusInternalServerError}
 			case 2:
-				err = mockedNetError{temporary: true}
+				err = mockedNetError{timeout: true}
 			default:
 				// No retrying
 				resp = &http.Response{StatusCode: http.StatusBadRequest}

logger.go

@@ -4,6 +4,59 @@ import (
 	"context"
 )
 
+// LoggerLevel represents a logger level
+type LoggerLevel int
+
+// Logger levels
+const (
+	LoggerLevelDebug LoggerLevel = iota
+	LoggerLevelError
+	LoggerLevelFatal
+	LoggerLevelInfo
+	LoggerLevelWarn
+)
+
+// LoggerLevelFromString creates a logger level from string
+func LoggerLevelFromString(s string) LoggerLevel {
+	switch s {
+	case "debug":
+		return LoggerLevelDebug
+	case "error":
+		return LoggerLevelError
+	case "fatal":
+		return LoggerLevelFatal
+	case "warn":
+		return LoggerLevelWarn
+	default:
+		return LoggerLevelInfo
+	}
+}
+
+func (l LoggerLevel) String() string {
+	switch l {
+	case LoggerLevelDebug:
+		return "debug"
+	case LoggerLevelError:
+		return "error"
+	case LoggerLevelFatal:
+		return "fatal"
+	case LoggerLevelWarn:
+		return "warn"
+	default:
+		return "info"
+	}
+}
+
+func (l *LoggerLevel) UnmarshalText(b []byte) error {
+	*l = LoggerLevelFromString(string(b))
+	return nil
+}
+
+func (l LoggerLevel) MarshalText() ([]byte, error) {
+	b := []byte(l.String())
+	return b, nil
+}
+
 // CompleteLogger represents a complete logger
 type CompleteLogger interface {
 	StdLogger

logger_test.go

@@ -0,0 +1,55 @@
+package astikit
+
+import (
+	"testing"
+)
+
+func TestLoggerLevel(t *testing.T) {
+	var l LoggerLevel
+	for _, v := range []struct {
+		l LoggerLevel
+		s string
+	}{
+		{
+			l: LoggerLevelDebug,
+			s: "debug",
+		},
+		{
+			l: LoggerLevelError,
+			s: "error",
+		},
+		{
+			l: LoggerLevelFatal,
+			s: "fatal",
+		},
+		{
+			l: LoggerLevelInfo,
+			s: "info",
+		},
+		{
+			l: LoggerLevelWarn,
+			s: "warn",
+		},
+	} {
+		if e, g := v.s, v.l.String(); e != g {
+			t.Errorf("expected %s, got %s", e, g)
+		}
+		b, err := v.l.MarshalText()
+		if err != nil {
+			t.Errorf("expected no error, got %s", err)
+		}
+		if e, g := v.s, string(b); e != g {
+			t.Errorf("expected %s, got %s", e, g)
+		}
+		if e, g := v.l, LoggerLevelFromString(v.s); e != g {
+			t.Errorf("expected %s, got %s", e, g)
+		}
+		err = l.UnmarshalText([]byte(v.s))
+		if err != nil {
+			t.Errorf("expected no error, got %s", err)
+		}
+		if e, g := v.l, l; e != g {
+			t.Errorf("expected %s, got %s", e, g)
+		}
+	}
+}