private void ThrowForStatus(HttpResponse response, RSA publicKey, string requestId, List <int> httpStatusCodeWhiteList)
{
var code = (int)response.StatusCode;
var name = response.StatusDescription;
// whitelisted HTTP code, ignore it
if (httpStatusCodeWhiteList != null && httpStatusCodeWhiteList.Contains((int)response.StatusCode))
{
return;
}
// server didn't like our request
if (response.StatusCode == HttpStatusCode.BadRequest || response.StatusCode == HttpStatusCode.Conflict)
{
// no body came back ... throw generic http 400 exception
if (string.IsNullOrWhiteSpace(response.ResponseBody))
{
throw new InvalidRequestException(response.StatusDescription, null, "HTTP-400");
}
else
{
ValidateEncryptedResponse(response, publicKey, requestId);
var errorResponse = DecryptResponse <Sdk.Domain.Error>(response);
throw InvalidRequestException.FromErrorCode(errorResponse.ErrorCode, _jsonDecoder.EncodeObject(errorResponse.ErrorDetail), errorResponse.ErrorData);
}
}
// other non-valid responses. Throw an appropriate exception
if (!(code >= 200 && code < 300))
{
throw CommunicationErrorException.FromStatusCode(code, $"HTTP Error: [{code}] {name}");
}
}
internal static IActionResult ErrorResult <TModel>(BaseException exception)
{
switch (exception)
{
case ForbiddenException _:
case NotFoundException _:
case UnauthorizedException _:
LogWarning <TModel>("A warning has occurred.", exception);
break;
default:
LogError <TModel>("An error has occurred.", exception);
break;
}
var @try = HandleException <TModel>(exception);
return(@try.Match(
failure => failure switch
{
InvalidRequestException _ => new BadRequestObjectResult(@try),
ForbiddenException _ => new ObjectResult(@try)
{
StatusCode = 403
},
NotFoundException _ => new NotFoundObjectResult(@try),
AlreadyExistsException _ => new ConflictObjectResult(@try),
UnauthorizedException _ => new UnauthorizedObjectResult(@try),
InvalidObjectException _ => new UnprocessableEntityObjectResult(@try),
_ => new ObjectResult(@try)
{
StatusCode = 500
},
},
public InvalidRequestProblemDetails(InvalidRequestException exception, string traceId)
{
Title = "Request validation error";
Status = StatusCodes.Status400BadRequest;
Type = "https://httpstatuses.com/400";
Errors = exception.Errors;
Instance = traceId;
}
private InvalidRequestProblemDetails GetBadRequestProblemDetails(InvalidRequestException ex)
{
string traceId = Guid.NewGuid().ToString();
var invalidRequestProblemDetails = new InvalidRequestProblemDetails(ex, traceId);
return(invalidRequestProblemDetails);
}
private void AssertInvalidRequestHasReason(InvalidRequestException ex, string expectedReason)
{
var reasonsString = ex.Reasons == null
? "(null)"
: ex.Reasons.Select(x => $" > {x}").Aggregate((x, y) => $"{x}\n{y}");
Assert.IsNotNull(ex.Reasons?.SingleOrDefault(r => r == expectedReason),
$"Could not find expected reason {expectedReason}\nReasons:\n{reasonsString}\n");
}
public void TestInvalidRequestException()
{
var url = new Uri("https://www.maxmind.com/");
var code = "INVALID_INPUT";
var e = new InvalidRequestException("message", code, url);
Assert.Equal(code, e.Code);
Assert.Equal(url, e.Uri);
}
public void FromStatusCodeSvc005WithNoMyAuth_ShouldReturnExpectedData()
{
IDictionary <string, Object> errorData = new Dictionary <string, object>();
errorData["auth_request"] = "adc0d351-d8a8-11e8-9fe8-acde48001122";
errorData["expires"] = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
Assert.AreEqual(
new AuthorizationInProgress("Important error", null, "SVC-005", "adc0d351-d8a8-11e8-9fe8-acde48001122", false, new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
InvalidRequestException.FromErrorCode("SVC-005", "Important error", errorData));
}
private Task HandleInvalidRequestExceptionAsync(HttpContext context, InvalidRequestException exception)
{
var result = JsonSerializer.Serialize(exception.ValidationResults, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(context.Response.WriteAsync(result));
}
public void FromStatusCodeSvc005WithNoExpires_ShouldReturnExpectedData()
{
IDictionary <string, Object> errorData = new Dictionary <string, object>();
errorData["auth_request"] = "adc0d351-d8a8-11e8-9fe8-acde48001122";
errorData["from_same_service"] = true;
errorData["expires"] = null;
Assert.AreEqual(
new AuthorizationInProgress("Important error", null, "SVC-005", "adc0d351-d8a8-11e8-9fe8-acde48001122", true, null),
InvalidRequestException.FromErrorCode("SVC-005", "Important error", errorData));
}
public Task <TOut> Handle(TIn request, CancellationToken cancellationToken)
{
var context = new ValidationContext(request);
var failures = _validators
.Select(v => v.Validate(context))
.SelectMany(result => result.Errors)
.Where(f => f != null)
.ToList();
if (failures.Count > 0)
{
var exception = new InvalidRequestException(failures);
throw exception;
}
return(_decorated.Handle(request, cancellationToken));
}
public void ThenThrowsInvalidRequestExceptionIfCommandInvalid(
SendNotificationCommand command,
ValidationFailure validationFailure,
ValidationResult validationResult,
InvalidRequestException validationException)
{
validationResult.Errors.Add(validationFailure);
_mockValidator
.Setup(validator => validator.Validate(command))
.Returns(validationResult);
Func <Task> act = async() => { await _sut.Handle(command, new CancellationToken()); };
act.ShouldThrowExactly <ValidationException>()
.Which.Errors.ToList().Contains(validationFailure).Should().BeTrue();
}
public async Task AndManagerThrowsInvalidRequestExceptionWhenGettingProviderThenItShouldReturnBadRequest()
{
var exception = new InvalidRequestException("unit test exception");
_feProviderManagerMock.Setup(manager => manager.RetrieveAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(exception);
var result = await _controller.GetStatisticsAsync("1", CancellationToken.None);
var badRequestResult = result as BadRequestObjectResult;
var problemDetails = badRequestResult?.Value as ProblemDetails;
Assert.IsNotNull(result);
Assert.IsNotNull(badRequestResult);
Assert.IsNotNull(problemDetails);
Assert.AreEqual(exception.Message, problemDetails.Detail);
}
public async Task AndManagerThrowsInvalidRequestExceptionThenItShouldReturnBadRequest()
{
var exception = new InvalidRequestException("unit test exception");
_learningDeliveryManagerMock.Setup(manager => manager.ListForProviderAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(exception);
var result = await _controller.ListByUkprnAsync("12345678", "1", CancellationToken.None);
var badRequestResult = result as BadRequestObjectResult;
var problemDetails = badRequestResult?.Value as ProblemDetails;
Assert.IsNotNull(result);
Assert.IsNotNull(badRequestResult);
Assert.IsNotNull(problemDetails);
Assert.AreEqual(exception.Message, problemDetails.Detail);
}
public void ThenThrowsInvalidRequestExceptionIfCommandInvalid(
SendNotificationCommand command,
string propertyName,
ValidationResult validationResult,
InvalidRequestException validationException,
[Frozen] Mock <IValidator <SendNotificationCommand> > mockValidator,
SendNotificationCommandHandler sut)
{
validationResult.AddError(propertyName);
mockValidator
.Setup(validator => validator.Validate(command))
.Returns(validationResult);
Func <Task> act = async() => { await sut.Handle(command); };
act.ShouldThrowExactly <InvalidRequestException>()
.Which.ErrorMessages.ContainsKey(propertyName).Should().BeTrue();
}
public void FromStatusCode_ShouldReturnExpectedTypes()
{
Assert.AreEqual(new InvalidParameters("Important error", null, "ARG-001"), InvalidRequestException.FromErrorCode("ARG-001", "Important error"));
Assert.AreEqual(new InvalidRoute("Important error", null, "ARG-002"), InvalidRequestException.FromErrorCode("ARG-002", "Important error"));
Assert.AreEqual(new ServiceNameTaken("Important error", null, "SVC-001"), InvalidRequestException.FromErrorCode("SVC-001", "Important error"));
Assert.AreEqual(new InvalidPolicyInput("Important error", null, "SVC-002"), InvalidRequestException.FromErrorCode("SVC-002", "Important error"));
Assert.AreEqual(new PolicyFailure("Important error", null, "SVC-003"), InvalidRequestException.FromErrorCode("SVC-003", "Important error"));
Assert.AreEqual(new ServiceNotFound("Important error", null, "SVC-004"), InvalidRequestException.FromErrorCode("SVC-004", "Important error"));
// SVC-005 covered inother tests
Assert.AreEqual(new AuthorizationResponseExists("Important error", null, "SVC-006"), InvalidRequestException.FromErrorCode("SVC-006", "Important error"));
Assert.AreEqual(new AuthorizationRequestCanceled("Important error", null, "SVC-007"), InvalidRequestException.FromErrorCode("SVC-007", "Important error"));
Assert.AreEqual(new InvalidDirectoryIdentifier("Important error", null, "DIR-001"), InvalidRequestException.FromErrorCode("DIR-001", "Important error"));
Assert.AreEqual(new InvalidPublicKey("Important error", null, "KEY-001"), InvalidRequestException.FromErrorCode("KEY-001", "Important error"));
Assert.AreEqual(new PublicKeyAlreadyInUse("Important error", null, "KEY-002"), InvalidRequestException.FromErrorCode("KEY-002", "Important error"));
Assert.AreEqual(new PublicKeyDoesNotExist("Important error", null, "KEY-003"), InvalidRequestException.FromErrorCode("KEY-003", "Important error"));
Assert.AreEqual(new LastRemainingKey("Important error", null, "KEY-004"), InvalidRequestException.FromErrorCode("KEY-004", "Important error"));
Assert.AreEqual(new DirectoryNameInUse("Important error", null, "ORG-003"), InvalidRequestException.FromErrorCode("ORG-003", "Important error"));
Assert.AreEqual(new LastRemainingSDKKey("Important error", null, "ORG-005"), InvalidRequestException.FromErrorCode("ORG-005", "Important error"));
Assert.AreEqual(new InvalidSDKKey("Important error", null, "ORG-006"), InvalidRequestException.FromErrorCode("ORG-006", "Important error"));
}
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("InternalServerException"))
{
InternalServerException ex = new InternalServerException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode);
return(ex);
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRequestException"))
{
InvalidRequestException ex = new InvalidRequestException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode);
return(ex);
}
return(new AmazonElasticMapReduceException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
public void FromStatusCodeSvc005WithNoErrorData_ShouldSetAllNulls()
{
Assert.AreEqual(new AuthorizationInProgress("Important error", null, "SVC-005", null, false, null), InvalidRequestException.FromErrorCode("SVC-005", "Important error", null));
}
public CassandraClientInvalidRequestException(string message, InvalidRequestException innerException)
: base(message + Environment.NewLine + "Why: " + innerException.Why, innerException)
{
}
internal CassandraClientInvalidRequestException(string message, InvalidRequestException innerException)
: base($"{message}{Environment.NewLine}Why: {innerException.Why}", innerException)
{
}
public CassandraOperationException(InvalidRequestException exc)
: base(exc.Why, exc)
{
}
