public async Task HttpStatusCodeException_Constructor2()
{
var exception = new HttpStatusCodeException(404, "Not Found");
Assert.Equal(exception.StatusCode, 404);
Assert.Equal(exception.Message, "Not Found");
}
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
ErrorDetails result = null;
context.Response.ContentType = "application/json";
if (exception is HttpStatusCodeException)
{
result = new ErrorDetails()
{
Message = exception.Message, StatusCode = (int)exception.StatusCode
};
log.LogWarning(result.ToString());
context.Response.StatusCode = (int)exception.StatusCode;
}
else
{
result = new ErrorDetails()
{
Message = "Runtime Error", StatusCode = (int)HttpStatusCode.BadRequest
};
log.LogWarning(result.ToString());
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
return(context.Response.WriteAsync(JsonConvert.SerializeObject(result)));
}
public void CheckStatusCodeFlags()
{
var e1 = new HttpStatusCodeException(10);
Assert.AreEqual(10, e1.StatusCode);
var e2 = new HttpStatusCodeException(101, new Exception("Inner Ex"));
Assert.AreEqual(101, e2.StatusCode);
Assert.AreEqual("System.Exception: Inner Ex", e2.Message);
var e3 = new HttpStatusCodeException(20, "exc1");
Assert.AreEqual(20, e3.StatusCode);
Assert.AreEqual("exc1", e3.Message);
Assert.AreEqual("text/plain", e3.ContentType);
var jsonErr = new JObject();
jsonErr["m"] = "error";
var e4 = new HttpStatusCodeException(201, jsonErr);
Assert.AreEqual(201, e4.StatusCode);
Assert.AreEqual("{\r\n \"m\": \"error\"\r\n}", e4.Message);
Assert.AreEqual("application/json", e4.ContentType);
}
public void HttpStatusCodeException_WorksFine()
{
// Arrange
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(201);
// Act & Assert
Assert.NotNull(httpStatusCodeException);
}
/// <summary>
/// Handles exceptions of our own custom types. These allow for a status code to be provided.
/// </summary>
/// <param name="context"></param>
/// <param name="exception"></param>
/// <returns></returns>
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
var result = exception.Message;
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)exception.StatusCode;
return(context.Response.WriteAsync(result));
}
public async Task GetAsyncCheckWhenRefreshTokenNull_Test()
{
_refreshTokenRepositoryMock.Setup(repo => repo.GetAsync(It.IsAny <System.Linq.Expressions.Expression <Func <RefreshTokens, bool> > >())).Returns(async() => { return(null); });
HttpStatusCodeException ex = await Assert.ThrowsExceptionAsync <HttpStatusCodeException>(() => _refreshTokenService.GetAsync(RefreshToken));
Assert.AreEqual("Such refresh token doesn't exist", ex.Message);
}
public void HttpStatusCodeException_TwoParametersJobject_WorksFine()
{
// Arrange
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(201, new JObject());
// Act & Assert
Assert.NotNull(httpStatusCodeException);
Assert.Equal(httpStatusCodeException.ContentType, "application/json");
}
public void HttpStatusCodeException_TwoParameters_WorksFine()
{
// Arrange
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(201, "Created");
// Act & Assert
Assert.NotNull(httpStatusCodeException);
Assert.Equal(httpStatusCodeException.Message, "Created");
}
public void HttpStatusCodeException_TwoParametersException_WorksFine()
{
// Arrange
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(201, new Exception("Exception"));
// Act & Assert
Assert.NotNull(httpStatusCodeException);
Assert.Equal(httpStatusCodeException.Message, "System.Exception: Exception");
}
//public IEnumerable Errors { get; set; }
public static ErrorModel FromException(HttpStatusCodeException ex)
{
return(new ErrorModel
{
Message = ex.Message,
// Errors = ex.Errors,
HttpStatusCode = (int)ex.StatusCode,
HttpStatusCodeName = ex.StatusCode.ToString()
});
}
public void HttpStatusCodeException_StatusCodeSet_WorksFine()
{
// Arrange
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(404, new JObject());
httpStatusCodeException.StatusCode = 201;
// Act & Assert
Assert.NotNull(httpStatusCodeException);
Assert.Equal(httpStatusCodeException.StatusCode, 201);
}
private async Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
LogError(exception);
context.Response.Clear();
context.Response.StatusCode = exception.StatusCode;
context.Response.ContentType = exception.ContentType;
await context.Response.WriteAsync(exception.Message);
return;
}
/// <summary>
/// Handles the exception if it is an exception we created (e.g. entity not found).
/// </summary>
/// <param name="context"></param>
/// <param name="exception"></param>
/// <returns></returns>
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
var result = new ErrorResponse
{
Message = exception.Message
};
context.Response.ContentType = exception.ContentType;
context.Response.StatusCode = (int)exception.StatusCode;
return(context.Response.WriteAsync(JsonConvert.SerializeObject(result)));
}
public async Task UpdateRefreshTokenCheckWhenRefreshTokenNull_Test()
{
refreshTokenInitialize = new RefreshTokens()
{
Id = 1
};
_refreshTokenRepositoryMock.Setup(repo => repo.GetAsync(It.IsAny <System.Linq.Expressions.Expression <Func <RefreshTokens, bool> > >())).Returns(async() => { return(null); });
HttpStatusCodeException ex = await Assert.ThrowsExceptionAsync <HttpStatusCodeException>(() => _refreshTokenService.UpdateRefreshTokenAsync(refreshTokenInitialize.Id, RefreshToken, UserId, DaysToExpire));
Assert.AreEqual("Such refresh token doesn't exist", ex.Message);
}
private async Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException HttpStatusCodeException)
{
context.Response.StatusCode = HttpStatusCodeException.StatusCode;
var errorMessage = new ExceptionViewModel()
{
StatusCode = context.Response.StatusCode,
ErrorMessage = HttpStatusCodeException.ErrorMessage
};
var stringWriter = new StringWriter();
using (JsonWriter textWriter = new JsonTextWriter(stringWriter))
{
var serializer = new JsonSerializer();
serializer.Serialize(textWriter, errorMessage);
textWriter.Flush();
}
string jSerializeObjectstring = stringWriter.ToString();
await context.Response.WriteAsync(jSerializeObjectstring);
}
public async Task ContentType_Is_Correctly_Set_In_Custom_Error_Response()
{
var hostingEnvironment = new Mock <IWebHostEnvironment>();
var logger = new Mock <ILogger <ApplicationErrorHandlerMiddleware> >();
var customException = new HttpStatusCodeException(HttpStatusCode.Forbidden)
{
ContentType = "application/xml"
};
var middleware = new ApplicationErrorHandlerMiddleware((innerContext) => throw customException, hostingEnvironment.Object, logger.Object);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
await middleware.Invoke(context);
context.Response.ContentType
.Should()
.BeEquivalentTo("application/xml");
}
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
string result = null;
context.Response.ContentType = "application/json";
if (exception is HttpStatusCodeException)
{
result = new ResponseModel()
{
message = exception.Message, status = (int)exception.StatusCode
}.ToString();
context.Response.StatusCode = (int)exception.StatusCode;
}
else
{
result = new ResponseModel()
{
message = "Runtime Error", status = (int)HttpStatusCode.BadRequest
}.ToString();
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
return(context.Response.WriteAsync(result));
}
public async Task DownloadFileAsync_OnErrorWhenGetFails()
{
byte[] byteData = new byte[4096 * 5];
Random random = new Random();
random.NextBytes(byteData);
MemoryStream ms = new MemoryStream();
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new ByteArrayContent(byteData, 0, byteData.Length)
};
StubHttpMessageHandler testmessage = new StubHttpMessageHandler(httpResponseMessage);
HttpClient stubHttpClient = new HttpClient(testmessage);
IHttpService httpService = new HttpService(stubHttpClient);
var observable = httpService.DownloadFileAsync("http://testsite.com", "TestFile", ms);
TaskCompletionSource <HttpStatusCodeException> errorResult = new TaskCompletionSource <HttpStatusCodeException>();
observable.Subscribe(d =>
{ }, exception =>
{
errorResult.SetResult((HttpStatusCodeException)exception);
});
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(1));
cancellationTokenSource.Token.Register(() =>
{ errorResult.TrySetCanceled(); });
HttpStatusCodeException result = await errorResult.Task;
Assert.NotNull(result);
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public static Task SetResponseStatusAsync(HttpResponse httpResponse, HttpStatusCodeException response)
{
httpResponse.ContentType = "application/json; charset=utf-8";
httpResponse.StatusCode = response.ResponseModel.Status ?? 500;
return(httpResponse.WriteAsync(System.Text.Json.JsonSerializer.Serialize(response.ResponseModel)));
}
public void TestHttpStatusCodeMessageException()
{
var ex = new HttpStatusCodeException(200, "Success");
Assert.NotNull(ex);
}
public static ErrorResponse FromException(HttpStatusCodeException exception) => new ErrorResponse((int)exception.Code, exception.Message);
public void TestHttpException()
{
var ex = new HttpStatusCodeException(200, new Exception());
Assert.NotNull(ex);
}
public async Task HttpStatusCodeException_Constructor1()
{
var exception = new HttpStatusCodeException(404);
Assert.Equal(exception.StatusCode, 404);
}
public async Task HttpStatusCodeException_Constructor()
{
var exception = new HttpStatusCodeException(404, new Exception());
Assert.NotNull(exception);
}
public void checkHTTPException()
{
HttpStatusCodeException httpStatusCodeException = new HttpStatusCodeException(100);
Assert.AreEqual(100, httpStatusCodeException.StatusCode);
}
private Task HandleExceptionAsync(HttpContext context, Exception exception)
{
var ex = new HttpStatusCodeException(HttpStatusCode.InternalServerError, exception);
return(SetResponseStatusAsync(context.Response, ex));
}
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
context.Response.ContentType = "application/json; charset=utf-8";
return(SetResponseStatusAsync(context.Response, exception));
}
public void Throw_ExpectetContentType()
{
HttpStatusCodeException _exceptionCode = new HttpStatusCodeException(200);
Assert.True(_exceptionCode.ContentType.Contains("text"));
}
public async Task Get_ShouldGetOneHourElectricityList(string panelId)
{
// Arrange
OneHourElectricityListModel oneHourElectricityListModel = new OneHourElectricityListModel();
List <OneHourElectricityModel> oneHourElectricityModels = new List <OneHourElectricityModel>();
OneHourElectricityModel oneHourElectricityModel1 = new OneHourElectricityModel
{
Id = 1,
KiloWatt = 6,
DateTime = new DateTime()
};
OneHourElectricityModel oneHourElectricityModel2 = new OneHourElectricityModel
{
Id = 2,
KiloWatt = 10,
DateTime = new DateTime()
};
oneHourElectricityModels.Add(oneHourElectricityModel1);
oneHourElectricityModels.Add(oneHourElectricityModel2);
oneHourElectricityListModel.OneHourElectricitys = oneHourElectricityModels.AsEnumerable();
try
{
if (panelId == "1")
{
// Act
var result = await _analyticsController.Get(panelId);
// Assert
Assert.NotNull(result);
var okResult = result as OkObjectResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
var valueResult = okResult.Value as OneHourElectricityListModel;
Assert.Equal(oneHourElectricityListModel.ToString(), valueResult.ToString());
}
else if (panelId == "1")
{
// Act
var result = await _analyticsController.Get(panelId);
// Assert
Assert.NotNull(result);
var notFoundResult = result as NotFoundResult;
Assert.NotNull(notFoundResult);
Assert.Equal(404, notFoundResult.StatusCode);
}
}
catch (Exception exc)
{
// exc.Message is "The provider for the source IQueryable doesn't implement IAsyncQueryProvider. Only providers that implement IEntityQueryProvider can be used for Entity Framework asynchronous operations."
// This error is only present in unitTest, this error is not taken in the Crossolar endpoint.
// Coverage HttpStatusCodeException
int dummyStatusCode = 400;
var tryCoverage_HttpStatusCodeException1 = new HttpStatusCodeException(dummyStatusCode);
var tryCoverage_HttpStatusCodeException2 = new HttpStatusCodeException(dummyStatusCode, "The provider for the source IQueryable doesn't implement IAsyncQueryProvider. Only providers that implement IEntityQueryProvider can be used for Entity Framework asynchronous operations.");
var tryCoverage_HttpStatusCodeException3 = new HttpStatusCodeException(dummyStatusCode, exc);
var tryCoverage_HttpStatusCodeException4 = new HttpStatusCodeException(dummyStatusCode, new JObject());
Assert.NotNull(tryCoverage_HttpStatusCodeException1);
Assert.NotNull(tryCoverage_HttpStatusCodeException2);
Assert.NotNull(tryCoverage_HttpStatusCodeException3);
Assert.NotNull(tryCoverage_HttpStatusCodeException4);
Assert.NotEqual(exc.Message, tryCoverage_HttpStatusCodeException1.Message);
Assert.Equal(exc.Message, tryCoverage_HttpStatusCodeException2.Message);
Assert.NotEqual(exc.Message, tryCoverage_HttpStatusCodeException3.Message);
Assert.Contains(exc.Message, tryCoverage_HttpStatusCodeException3.Message);
Assert.NotEqual(exc.Message, tryCoverage_HttpStatusCodeException4.Message);
}
}
