mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
226 lines
10 KiB
Go
226 lines
10 KiB
Go
package httperror_test
|
|
|
|
import (
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/effective-security/porto/xhttp/httperror"
|
|
"github.com/stretchr/testify/assert"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
func Test_ErrorCodes(t *testing.T) {
|
|
assert.Equal(t, "account_not_found", httperror.CodeAccountNotFound)
|
|
assert.Equal(t, "bad_nonce", httperror.CodeBadNonce)
|
|
assert.Equal(t, "conflict", httperror.CodeConflict)
|
|
assert.Equal(t, "connection", httperror.CodeConnection)
|
|
assert.Equal(t, "content_length_required", httperror.CodeContentLengthRequired)
|
|
assert.Equal(t, "forbidden", httperror.CodeForbidden)
|
|
assert.Equal(t, "invalid_content_type", httperror.CodeInvalidContentType)
|
|
assert.Equal(t, "invalid_json", httperror.CodeInvalidJSON)
|
|
assert.Equal(t, "invalid_parameter", httperror.CodeInvalidParam)
|
|
assert.Equal(t, "invalid_request", httperror.CodeInvalidRequest)
|
|
assert.Equal(t, "malformed", httperror.CodeMalformed)
|
|
assert.Equal(t, "not_found", httperror.CodeNotFound)
|
|
assert.Equal(t, "not_ready", httperror.CodeNotReady)
|
|
assert.Equal(t, "rate_limit_exceeded", httperror.CodeRateLimitExceeded)
|
|
assert.Equal(t, "request_body", httperror.CodeFailedToReadRequestBody)
|
|
assert.Equal(t, "request_too_large", httperror.CodeRequestTooLarge)
|
|
assert.Equal(t, "unauthorized", httperror.CodeUnauthorized)
|
|
assert.Equal(t, "unexpected", httperror.CodeUnexpected)
|
|
}
|
|
|
|
func Test_StatusCodes(t *testing.T) {
|
|
tcases := []struct {
|
|
httpErr *httperror.Error
|
|
expStatus int
|
|
expMsg string
|
|
}{
|
|
{httperror.InvalidParam("1"), http.StatusBadRequest, "invalid_parameter: 1"},
|
|
{httperror.InvalidJSON("1"), http.StatusBadRequest, "invalid_json: 1"},
|
|
{httperror.BadNonce("1"), http.StatusBadRequest, "bad_nonce: 1"},
|
|
{httperror.InvalidRequest("1"), http.StatusBadRequest, "invalid_request: 1"},
|
|
{httperror.Malformed("1"), http.StatusBadRequest, "malformed: 1"},
|
|
{httperror.InvalidContentType("1"), http.StatusBadRequest, "invalid_content_type: 1"},
|
|
{httperror.ContentLengthRequired(), http.StatusBadRequest, "content_length_required: Content-Length header not provided"},
|
|
{httperror.NotFound("1"), http.StatusNotFound, "not_found: 1"},
|
|
{httperror.RequestTooLarge("1"), http.StatusRequestEntityTooLarge, "request_too_large: 1"},
|
|
{httperror.FailedToReadRequestBody("1"), http.StatusInternalServerError, "request_body: 1"},
|
|
{httperror.RateLimitExceeded("1"), http.StatusTooManyRequests, "rate_limit_exceeded: 1"},
|
|
{httperror.TooEarly("1"), http.StatusTooEarly, "too_early: 1"},
|
|
{httperror.Unexpected("1"), http.StatusInternalServerError, "unexpected: 1"},
|
|
{httperror.Forbidden("1"), http.StatusForbidden, "forbidden: 1"},
|
|
{httperror.Unauthorized("1"), http.StatusUnauthorized, "unauthorized: 1"},
|
|
{httperror.AccountNotFound("1"), http.StatusForbidden, "account_not_found: 1"},
|
|
{httperror.NotReady("1"), http.StatusServiceUnavailable, "not_ready: 1"},
|
|
{httperror.Conflict("1"), http.StatusConflict, "conflict: 1"},
|
|
{httperror.Timeout("1"), http.StatusRequestTimeout, "timeout: 1"},
|
|
}
|
|
for _, tc := range tcases {
|
|
t.Run(tc.httpErr.Code, func(t *testing.T) {
|
|
assert.Equal(t, tc.expStatus, tc.httpErr.HTTPStatus)
|
|
assert.Equal(t, tc.expMsg, tc.httpErr.Error())
|
|
assert.NotNil(t, tc.httpErr.GRPCStatus())
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_OAuthError(t *testing.T) {
|
|
assert.EqualError(t, httperror.FromOAuth("1", "2"), "1: 2")
|
|
assert.EqualError(t, httperror.FromOAuth("invalid_request", "aaa"), "invalid_request: aaa")
|
|
assert.EqualError(t, httperror.FromOAuth("temporarily_unavailable", "aaa"), "temporarily_unavailable: aaa")
|
|
assert.EqualError(t, httperror.FromOAuth("server_error", "aaa"), "server_error: aaa")
|
|
assert.EqualError(t, httperror.FromOAuth("invalid_client", "aaa"), "invalid_client: aaa")
|
|
}
|
|
|
|
func Test_AuthStatusMapping(t *testing.T) {
|
|
t.Parallel()
|
|
// Google API mapping: Unauthenticated is 401, PermissionDenied is 403.
|
|
assert.Equal(t, http.StatusUnauthorized, httperror.HTTPStatusFromRPC(codes.Unauthenticated))
|
|
assert.Equal(t, http.StatusForbidden, httperror.HTTPStatusFromRPC(codes.PermissionDenied))
|
|
assert.Equal(t, codes.Unauthenticated, httperror.Unauthorized("1").RPCStatus)
|
|
assert.Equal(t, codes.PermissionDenied, httperror.Forbidden("1").RPCStatus)
|
|
|
|
denied := httperror.NewFromPb(status.Error(codes.PermissionDenied, "denied"))
|
|
assert.Equal(t, http.StatusForbidden, denied.HTTPStatus)
|
|
assert.Equal(t, httperror.CodeForbidden, denied.Code)
|
|
assert.Equal(t, http.StatusForbidden, httperror.Status(status.Error(codes.PermissionDenied, "denied")))
|
|
|
|
unauthenticated := httperror.NewFromPb(status.Error(codes.Unauthenticated, "who"))
|
|
assert.Equal(t, http.StatusUnauthorized, unauthenticated.HTTPStatus)
|
|
assert.Equal(t, httperror.CodeUnauthorized, unauthenticated.Code)
|
|
assert.Equal(t, http.StatusUnauthorized, httperror.Status(status.Error(codes.Unauthenticated, "who")))
|
|
|
|
assert.Equal(t, http.StatusForbidden, httperror.NewGrpc(codes.PermissionDenied, "denied").HTTPStatus)
|
|
assert.Equal(t, http.StatusUnauthorized, httperror.NewGrpc(codes.Unauthenticated, "who").HTTPStatus)
|
|
}
|
|
|
|
func Test_RPCCodeToHTTPStatus(t *testing.T) {
|
|
t.Parallel()
|
|
// gRPC code → HTTP status and httperror code (codeStatus, then httpCode).
|
|
// Several gRPC codes share one HTTP status; NewFromPb keeps the gRPC code
|
|
// on RPCStatus. A bare FailedPrecondition is 400 bad_request: 409 is
|
|
// AlreadyExists and Aborted, and 500 would label it unexpected.
|
|
cases := []struct {
|
|
rpc codes.Code
|
|
httpStatus int
|
|
code string
|
|
}{
|
|
{codes.OK, http.StatusOK, ""},
|
|
{codes.Canceled, http.StatusRequestTimeout, "request_timeout"},
|
|
{codes.Unknown, http.StatusInternalServerError, httperror.CodeUnexpected},
|
|
{codes.InvalidArgument, http.StatusBadRequest, "bad_request"},
|
|
{codes.DeadlineExceeded, http.StatusRequestTimeout, "request_timeout"},
|
|
{codes.NotFound, http.StatusNotFound, httperror.CodeNotFound},
|
|
{codes.AlreadyExists, http.StatusConflict, httperror.CodeConflict},
|
|
{codes.PermissionDenied, http.StatusForbidden, httperror.CodeForbidden},
|
|
{codes.ResourceExhausted, http.StatusTooManyRequests, "too_many_requests"},
|
|
{codes.FailedPrecondition, http.StatusBadRequest, "bad_request"},
|
|
{codes.Aborted, http.StatusConflict, httperror.CodeConflict},
|
|
{codes.OutOfRange, http.StatusBadRequest, "bad_request"},
|
|
{codes.Unimplemented, http.StatusNotImplemented, "not_implemented"},
|
|
{codes.Internal, http.StatusInternalServerError, httperror.CodeUnexpected},
|
|
{codes.Unavailable, http.StatusServiceUnavailable, "unavailable"},
|
|
{codes.DataLoss, http.StatusInternalServerError, httperror.CodeUnexpected},
|
|
{codes.Unauthenticated, http.StatusUnauthorized, httperror.CodeUnauthorized},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.rpc.String(), func(t *testing.T) {
|
|
t.Parallel()
|
|
assert.Equal(t, tc.httpStatus, httperror.HTTPStatusFromRPC(tc.rpc))
|
|
|
|
viaGrpc := httperror.NewGrpc(tc.rpc, "msg")
|
|
assert.Equal(t, tc.httpStatus, viaGrpc.HTTPStatus)
|
|
assert.Equal(t, tc.code, viaGrpc.Code)
|
|
assert.Equal(t, tc.rpc, viaGrpc.RPCStatus)
|
|
|
|
if tc.rpc == codes.OK {
|
|
return
|
|
}
|
|
pbErr := status.Error(tc.rpc, "org state")
|
|
got := httperror.NewFromPb(pbErr)
|
|
assert.Equal(t, tc.httpStatus, got.HTTPStatus)
|
|
assert.Equal(t, tc.code, got.Code)
|
|
assert.Equal(t, tc.rpc, got.RPCStatus)
|
|
assert.Equal(t, "org state", got.Message)
|
|
assert.Equal(t, tc.httpStatus, httperror.Status(pbErr))
|
|
})
|
|
}
|
|
|
|
assert.Equal(t, 0, httperror.HTTPStatusFromRPC(codes.Code(99)))
|
|
}
|
|
|
|
func Test_ErrorCodeToRPCStatus(t *testing.T) {
|
|
t.Parallel()
|
|
// httperror code → gRPC code (statusCode), the reverse of Test_RPCCodeToHTTPStatus.
|
|
cases := []struct {
|
|
code string
|
|
rpc codes.Code
|
|
}{
|
|
{httperror.CodeAccountNotFound, codes.NotFound},
|
|
{httperror.CodeBadNonce, codes.InvalidArgument},
|
|
{httperror.CodeConflict, codes.AlreadyExists},
|
|
{httperror.CodeConnection, codes.Unknown},
|
|
{httperror.CodeContentLengthRequired, codes.InvalidArgument},
|
|
{httperror.CodeFailedToReadRequestBody, codes.InvalidArgument},
|
|
{httperror.CodeForbidden, codes.PermissionDenied},
|
|
{httperror.CodeInvalidContentType, codes.InvalidArgument},
|
|
{httperror.CodeInvalidJSON, codes.InvalidArgument},
|
|
{httperror.CodeInvalidParam, codes.InvalidArgument},
|
|
{httperror.CodeInvalidRequest, codes.InvalidArgument},
|
|
{httperror.CodeMalformed, codes.InvalidArgument},
|
|
{httperror.CodeNotFound, codes.NotFound},
|
|
{httperror.CodeNotReady, codes.Unavailable},
|
|
{httperror.CodeRateLimitExceeded, codes.ResourceExhausted},
|
|
{httperror.CodeRequestFailed, codes.Unknown},
|
|
{httperror.CodeRequestTooLarge, codes.ResourceExhausted},
|
|
{httperror.CodeTimeout, codes.DeadlineExceeded},
|
|
{httperror.CodeTooEarly, codes.ResourceExhausted},
|
|
{httperror.CodeUnauthorized, codes.Unauthenticated},
|
|
{httperror.CodeUnexpected, codes.Internal},
|
|
|
|
{"bad_request", codes.InvalidArgument},
|
|
{"payment_required", codes.PermissionDenied},
|
|
{"not_allowed", codes.InvalidArgument},
|
|
{"not_acceptable", codes.InvalidArgument},
|
|
{"auth_required", codes.Unauthenticated},
|
|
{"request_timeout", codes.Canceled},
|
|
{"gone", codes.NotFound},
|
|
{"length_required", codes.InvalidArgument},
|
|
{"precondition_failed", codes.FailedPrecondition},
|
|
{"too_large", codes.InvalidArgument},
|
|
{"uri_too_long", codes.InvalidArgument},
|
|
{"unsupported_media_type", codes.InvalidArgument},
|
|
{"expectation_failed", codes.InvalidArgument},
|
|
{"teapot", codes.InvalidArgument},
|
|
{"misdirected", codes.InvalidArgument},
|
|
{"unprocessable", codes.InvalidArgument},
|
|
{"locked", codes.FailedPrecondition},
|
|
{"failed_dependency", codes.FailedPrecondition},
|
|
{"upgrade_required", codes.FailedPrecondition},
|
|
{"precondition_required", codes.FailedPrecondition},
|
|
{"too_many_requests", codes.ResourceExhausted},
|
|
{"legal_reason", codes.PermissionDenied},
|
|
{"not_implemented", codes.Unimplemented},
|
|
{"bad_gateway", codes.Unavailable},
|
|
{"unavailable", codes.Unavailable},
|
|
{"gateway_timeout", codes.Unavailable},
|
|
{"not_supported", codes.Unimplemented},
|
|
{"insufficient_storage", codes.ResourceExhausted},
|
|
{"loop_detected", codes.ResourceExhausted},
|
|
{"not_extended", codes.Unimplemented},
|
|
{"authentication_required", codes.Unauthenticated},
|
|
|
|
{"no_such_code", codes.OK},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.code, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := httperror.New(http.StatusBadRequest, tc.code, "m")
|
|
assert.Equal(t, tc.rpc, got.RPCStatus)
|
|
assert.Equal(t, tc.rpc, got.GRPCStatus().Code())
|
|
})
|
|
}
|
|
}
|