Merge 2d10d87 into 60d9ac8

errors/errors.go

@@ -0,0 +1,99 @@
+package errorhandler
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const (
+	MsgErrMissingParam = "missingParameter"
+
+	MsgErrInvalidQueryParam = "invalidQueryParameter"
+	MsgErrInvalidPathParam  = "invalidPathParameter"
+	MsgErrInvalidParam      = "invalidParameter"
+
+	MsgErrOpNotPermitted = "operationNotPermitted"
+	AuthHeader           = "authorizationHeader"
+	BasicToken           = "basicToken"
+	BearerToken          = "bearerToken"
+	Token                = "token"
+	Level                = "level"
+)
+
+var emitter string
+
+// SetEmitter is called by the components that call the methods of the common service
+func SetEmitter(e string) {
+	emitter = e
+}
+
+// GetEmitter allows to see who called the common service
+func GetEmitter() string {
+	return emitter
+}
+
+// Error can be returned by the API endpoints
+type Error struct {
+	Status  int
+	Message string
+}
+
+func (e Error) Error() string {
+	return fmt.Sprintf("%d %s", e.Status, e.Message)
+}
+
+// CreateInternalServerError creates an error relative to an internal server error
+func CreateInternalServerError(message string) Error {
+	return Error{
+		Status:  http.StatusInternalServerError,
+		Message: GetEmitter() + "." + message,
+	}
+}
+
+// CreateMissingParameterError creates an error relative to a missing mandatory parameter
+func CreateMissingParameterError(name string) Error {
+	return Error{
+		Status:  http.StatusBadRequest,
+		Message: fmt.Sprintf("%s.%s.%s", GetEmitter(), MsgErrMissingParam, name),
+	}
+}
+
+// CreateInvalidQueryParameterError creates an error relative to a invalid query parameter
+func CreateInvalidQueryParameterError(paramName string) Error {
+	return Error{
+		Status:  http.StatusBadRequest,
+		Message: fmt.Sprintf("%s.%s.%s", GetEmitter(), MsgErrInvalidQueryParam, paramName),
+	}
+}
+
+// CreateInvalidPathParameterError creates an error relative to a invalid path parameter
+func CreateInvalidPathParameterError(paramName string) Error {
+	return Error{
+		Status:  http.StatusBadRequest,
+		Message: fmt.Sprintf("%s.%s.%s", GetEmitter(), MsgErrInvalidPathParam, paramName),
+	}
+}
+
+// CreateBadRequestError creates an error relative to a bad request
+func CreateBadRequestError(publicMessage string) Error {
+	return Error{
+		Status:  http.StatusBadRequest,
+		Message: GetEmitter() + "." + publicMessage,
+	}
+}
+
+// CreateNotAllowedError creates an error relative to a not allowed request
+func CreateNotAllowedError(publicMessage string) Error {
+	return Error{
+		Status:  http.StatusMethodNotAllowed,
+		Message: GetEmitter() + "." + publicMessage,
+	}
+}
+
+// CreateNotFoundError creates an error relative to a not found request
+func CreateNotFoundError(publicMessage string) Error {
+	return Error{
+		Status:  http.StatusNotFound,
+		Message: GetEmitter() + "." + publicMessage,
+	}
+}

errors/errors_test.go

@@ -0,0 +1,37 @@
+package errorhandler
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHTTPResponse(t *testing.T) {
+	// Coverage
+	var error = CreateMissingParameterError("parameter")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateBadRequestError("message")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateInternalServerError("message")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateInvalidQueryParameterError("message")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateInvalidPathParameterError("message")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateNotAllowedError("message")
+	assert.Contains(t, error.Error(), error.Message)
+
+	error = CreateNotFoundError("message")
+	assert.Contains(t, error.Error(), error.Message)
+}
+
+func TestEmitter(t *testing.T) {
+	var emitter = "component"
+	SetEmitter(emitter)
+	assert.Equal(t, GetEmitter(), emitter)
+}

http/handlers.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"regexp"
 
+	errorhandler "github.com/cloudtrust/common-service/errors"
 	"github.com/cloudtrust/common-service/log"
 	"github.com/cloudtrust/common-service/security"
 	"github.com/go-kit/kit/ratelimit"
@@ -80,7 +81,7 @@ func DecodeRequest(_ context.Context, req *http.Request, pathParams map[string]s
 	for key, validationRegExp := range pathParams {
 		if v, ok := m[key]; ok {
 			if matched, _ := regexp.Match(validationRegExp, []byte(v)); !matched {
-				return nil, CreateInvalidQueryParameterError(key)
+				return nil, errorhandler.CreateInvalidQueryParameterError(key)
 			}
 			request[key] = m[key]
 		}
@@ -98,7 +99,7 @@ func DecodeRequest(_ context.Context, req *http.Request, pathParams map[string]s
 	for key, validationRegExp := range queryParams {
 		if value := req.URL.Query().Get(key); value != "" {
 			if matched, _ := regexp.Match(validationRegExp, []byte(value)); !matched {
-				return nil, CreateInvalidPathParameterError(key)
+				return nil, errorhandler.CreateInvalidPathParameterError(key)
 			}
 
 			request[key] = value
@@ -150,7 +151,8 @@ func ErrorHandler(logger log.Logger) func(context.Context, error, http.ResponseW
 		switch e := errors.Cause(err).(type) {
 		case security.ForbiddenError:
 			w.WriteHeader(http.StatusForbidden)
-		case Error:
+			w.Write([]byte(errorhandler.GetEmitter() + "." + errorhandler.MsgErrOpNotPermitted))
+		case errorhandler.Error:
 			w.WriteHeader(e.Status)
 			// You should really take care of what you are sending here : e.Message should not leak any sensitive information
 			w.Write([]byte(e.Message))

http/handlers_test.go

@@ -15,9 +15,9 @@ import (
 	"net/url"
 	"testing"
 
-	"github.com/cloudtrust/common-service/security"
-
+	errorhandler "github.com/cloudtrust/common-service/errors"
 	"github.com/cloudtrust/common-service/http/mock"
+	"github.com/cloudtrust/common-service/security"
 	"github.com/go-kit/kit/endpoint"
 	"github.com/go-kit/kit/ratelimit"
 	http_transport "github.com/go-kit/kit/transport/http"
@@ -310,12 +310,13 @@ func TestErrorHandler(t *testing.T) {
 	// ForbiddenError
 	{
 		mockRespWriter.EXPECT().WriteHeader(http.StatusForbidden).Times(1)
+		mockRespWriter.EXPECT().Write(gomock.Any()).Times(1)
 		ErrorHandlerNoLog()(context.Background(), security.ForbiddenError{}, mockRespWriter)
 	}
 
 	// HTTPError
 	{
-		err := Error{
+		err := errorhandler.Error{
 			Status:  123,
 			Message: "abc",
 		}

log/log.go

@@ -1,8 +1,9 @@
 package log
 
 import (
-	"fmt"
+	"errors"
 
+	errorhandler "github.com/cloudtrust/common-service/errors"
 	kit_log "github.com/go-kit/kit/log"
 	kit_level "github.com/go-kit/kit/log/level"
 )
@@ -58,7 +59,7 @@ func ConvertToLevel(strLevel string) (kit_level.Option, error) {
 	var level, ok = levels[strLevel]
 
 	if !ok {
-		return nil, fmt.Errorf("Invalid level")
+		return nil, errors.New(errorhandler.MsgErrInvalidParam + errorhandler.Level)
 	}
 
 	return level, nil