chore: fix and add unit test

Author: ardikabs

pkg/config/config.go

@@ -10,6 +10,8 @@ import (
 	"github.com/spf13/viper"
 )
 
+// NewConfig return a viper.Viper instance from given configuration details
+// Configuration details consist of the configuration file path, configuration file name, also the env prefix if available
 func NewConfig(configPath, configName, envPrefix string) *viper.Viper {
 	fang := viper.New()
 

pkg/errs/errs.go renamed to pkg/errs/error.go

@@ -65,28 +65,34 @@ func (e *Error) Cause() error {
 }
 
 func (e Error) Unwrap() error {
-	return e.Err
+	return errs.Unwrap(e.Err)
 }
 
 func (e *Error) Error() string {
 	return e.Err.Error()
 }
 
-// StackTrace satisfy errors.StackTrace interface
-func (e Error) StackTrace() errors.StackTrace {
-	type stackTracer interface {
-		StackTrace() errors.StackTrace
-	}
-
-	if st, ok := e.Err.(stackTracer); ok {
-		return st.StackTrace()
+func (e *Error) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			if st, ok := e.Err.(interface {
+				StackTrace() errors.StackTrace
+			}); ok {
+				for _, fr := range st.StackTrace()[1:] {
+					fmt.Fprintf(s, "\n%+v", fr)
+				}
+				return
+			}
+		}
+		fallthrough
+	case 's':
+		fmt.Fprintf(s, "%s", e.Error())
 	}
-
-	return nil
 }
 
 func (e *Error) isZero() bool {
-	return e.Err == nil &&
+	return e.Is(ErrUndefined) &&
 		e.User == "" &&
 		e.Param == "" &&
 		e.Code == ""
@@ -145,6 +151,7 @@ func (k Kind) String() string {
 }
 
 var DefaultRealm Realm = "restricted"
+var ErrUndefined = errors.New("undefined error")
 
 // E builds an error value from its arguments.
 // There must be at least one argument or E panics.
@@ -153,28 +160,30 @@ var DefaultRealm Realm = "restricted"
 // only the last one is recorded.
 //
 // The types are:
-//	errs.Kind
-//		The class of error, such as permission failure.
 //	errs.UserName
 //		The username of the user attempting the operation.
+//	errs.Kind
+//		The class of error, such as permission failure.
+//	errs.Code
+//		The code for a human-readable purpose about the error.
+//	errs.Parameter
+//		The parameter represent the parameter related with the error.
 //	string
 //		Treated as an error message and assigned to the
 //		Err field after a call to errors.New.
 //	error
-//		The underlying error that triggered this one.
+//		The underlying error that triggered this one, if the error not contains stack,
+// 		we will wrap it
 //
 // If the error is printed, only those items that have been
 // set to non-zero values will appear in the result.
 //
 // If Kind is not specified or Other, we set it to the Kind of
 // the underlying error.
 func E(args ...interface{}) error {
-	type stackTracer interface {
-		StackTrace() errors.StackTrace
-	}
 
 	if len(args) == 0 {
-		panic("call to errors.E with no arguments")
+		panic("call to errs.E with no arguments")
 	}
 
 	e := &Error{}
@@ -204,7 +213,9 @@ func E(args ...interface{}) error {
 			// if the error implements stackTracer, then it is
 			// a pkg/errors error type and does not need to have
 			// the stack added
-			_, ok := arg.(stackTracer)
+			_, ok := arg.(interface {
+				StackTrace() errors.StackTrace
+			})
 			if ok {
 				e.Err = arg
 			} else {
@@ -220,7 +231,11 @@ func E(args ...interface{}) error {
 	// If this error and the inner still has Realm == "", while error Kind is Unauthenticated
 	// then the realm set to default "restricted" method
 	if e.Realm == "" && e.Kind == Unauthenticated {
-		e.Realm = "restricted"
+		e.Realm = DefaultRealm
+	}
+
+	if e.Err == nil {
+		e.Err = ErrUndefined
 	}
 
 	prev, ok := e.Err.(*Error)
@@ -255,8 +270,8 @@ func E(args ...interface{}) error {
 		prev.Realm = ""
 	}
 
-	// If this inner error hasn't Default Realm, then pull up the inner Realm
-	if prev.Realm != DefaultRealm && e.Realm == DefaultRealm {
+	// If this inner error has Realm, pull up the inner one
+	if e.Realm == "" {
 		e.Realm = prev.Realm
 		prev.Realm = ""
 	}

pkg/errs/errs_test.go renamed to pkg/errs/error_test.go

@@ -1,6 +1,7 @@
 package errs_test
 
 import (
+	"errors"
 	"fmt"
 	"testing"
 
@@ -29,6 +30,18 @@ func TestErrs(t *testing.T) {
 		assert.Equal(t, "other_error", errs.Other.String())
 		assert.Equal(t, "I/O_error", errs.IO.String())
 	})
+
+	t.Run("Unwrap the error should return the unwrapped error", func(t *testing.T) {
+		var errX = fmt.Errorf("error X")
+
+		err := errs.E(
+			errs.Code("internal"),
+			errs.Internal,
+			fmt.Errorf("internal error from X: %w", errX),
+		)
+		assert.True(t, errors.Is(errors.Unwrap(err), errX))
+		assert.True(t, errs.KindIs(errs.Internal, err))
+	})
 }
 
 func TestKindIs(t *testing.T) {

pkg/errs/http_error.go renamed to pkg/errs/httperror.go

@@ -81,16 +81,19 @@ func HTTPErrorHandler(w http.ResponseWriter, lgr zerolog.Logger, err error) {
 
 func commonErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
 	if e.isZero() {
-		lgr.Error().Stack().
-			Str("kind", string(e.Kind)).
-			Msg("empty error")
+		lgr.Error().
+			Stack().
+			Str("kind", e.Kind.String()).
+			Msg(e.Error())
 
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	lgr.Error().Stack().Err(e.Err).
-		Str("kind", string(e.Kind)).
+	lgr.Error().
+		Stack().
+		Err(e.Err).
+		Str("kind", e.Kind.String()).
 		Str("username", string(e.User)).
 		Str("parameter", string(e.Param)).
 		Str("code", string(e.Code)).
@@ -101,14 +104,14 @@ func commonErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
 	case Internal, Database, IO:
 		errResponse = HTTPErrResponse{
 			Error: &ServiceError{
-				Kind:    string(e.Kind),
+				Kind:    e.Kind.String(),
 				Message: "internal server error",
 			},
 		}
 	default:
 		errResponse = HTTPErrResponse{
 			Error: &ServiceError{
-				Kind:    string(e.Kind),
+				Kind:    e.Kind.String(),
 				Code:    string(e.Code),
 				Param:   string(e.Param),
 				Message: e.Error(),
@@ -119,8 +122,8 @@ func commonErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
 	errJSON, _ := json.Marshal(errResponse)
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
-	w.Write(errJSON)
 	w.WriteHeader(HTTPStatusCodeFromError(e))
+	w.Write(errJSON)
 }
 
 func validationErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
@@ -137,29 +140,31 @@ func validationErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
 		Int("fields", len(verr)).
 		Msg("input validation error")
 
-	var errFields []ServiceError
+	var errs []ServiceError
 	for _, err := range verr {
 		ie, ok := err.(*Error)
 		if !ok {
+			lgr.Error().
+				Stack().
+				Err(err).
+				Msg("input validation error - unexpected error")
 			continue
 		}
 
-		errFields = append(errFields, ServiceError{
+		errs = append(errs, ServiceError{
 			Code:    string(ie.Code),
 			Param:   string(ie.Param),
 			Message: ie.Error(),
 		})
 	}
 
-	var errResponse = HTTPErrResponse{
-		Errors: errFields,
-	}
-
-	errJSON, _ := json.Marshal(errResponse)
+	errJSON, _ := json.Marshal(HTTPErrResponse{
+		Errors: errs,
+	})
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
-	w.Write(errJSON)
 	w.WriteHeader(HTTPStatusCodeFromError(e))
+	w.Write(errJSON)
 }
 
 func unauthenticatedErrHandler(w http.ResponseWriter, lgr zerolog.Logger, e *Error) {
@@ -193,21 +198,21 @@ func unknownErrHandler(w http.ResponseWriter, lgr zerolog.Logger, err error) {
 		},
 	}
 
-	lgr.Error().Stack().Err(err).Msg("unknown error")
+	lgr.Error().Stack().Err(err).Int("code", HTTPStatusCodeFromError(err)).Msg("unknown error")
 
 	errJSON, _ := json.Marshal(errResponse)
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.WriteHeader(http.StatusNotImplemented)
 	w.Write(errJSON)
-	w.WriteHeader(http.StatusInternalServerError)
 }
 
 // HTTPStatusCodeFromError translate error to an http status code
 func HTTPStatusCodeFromError(err error) int {
 
 	var e *Error
 	if !errors.As(err, &e) {
-		return http.StatusInternalServerError
+		return http.StatusNotImplemented
 	}
 
 	switch e.Kind {