public void AuthenticateIfTokenExpiredAsync_TokenHasExpired_ErrorResponse_TikkieErrorResponseExceptionExpected()
{
// Arrange
// Mocks Tikkie Configuration
var mockTikkieConfiguration = new Mock <ITikkieConfiguration>();
mockTikkieConfiguration
.Setup(m => m.RSAKey)
.Returns(new RSACryptoServiceProvider());
mockTikkieConfiguration
.Setup(m => m.ApiBaseUrl)
.Returns("https://tikkie.unittests");
// Mocks HttpClient
var errorResponse = new ErrorResponses()
{
ErrorResponseArray = new[] { new ErrorResponse() }
};
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When($"{mockTikkieConfiguration.Object.ApiBaseUrl}{UrlProvider.AuthenticationUrlSuffix}")
.Respond(HttpStatusCode.BadRequest, "application/json", JsonConvert.SerializeObject(errorResponse));
// Sets up authorization token
var sut = CreateSut(mockTikkieConfiguration.Object, () => mockHttp.ToHttpClient(), new AuthorizationToken());
// Act + Assert
Assert.ThrowsAsync <TikkieErrorResponseException>(async() => await sut.AuthenticateIfTokenExpiredAsync());
}
public ActionResult <string> GetUserSubmission(string userName, string antName)
{
string fileName = $"{userName}_{antName}";
if (_fileService.UserSubmissionExists(fileName))
{
return(Ok(_fileService.GetUserSubmission(antName, userName)));
}
return(NotFound(new ErrorResponse {
ErrorCode = 404, ErrorMessage = ErrorResponses.SubmissionNotFound($"{userName}_{antName}")
}));
}
public ActionResult DeleteSubmission(string antName, string userName)
{
string fileName = $"{userName}_{antName}";
if (_fileService.UserSubmissionExists(fileName))
{
_fileService.DeleteUserSubmission(antName, userName);
return(NoContent());
}
return(NotFound(new ErrorResponse {
ErrorCode = 404, ErrorMessage = ErrorResponses.SubmissionNotFound($"{userName}_{antName}")
}));
}
public void PostOrExceptionAsync_ErrorResponse_CallsAuthentication_AddsHeaders_TikkieErrorResponseExceptionExpected()
{
// Arrange
var requestUrlSuffix = "/test/post";
var jsonRequest = JsonConvert.SerializeObject(new TestRequest());
var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
// Mock Tikkie Configuration
var mockTikkieConfiguration = new Mock <ITikkieConfiguration>();
mockTikkieConfiguration
.Setup(m => m.ApiBaseUrl)
.Returns("https://tikkie.unittests");
mockTikkieConfiguration
.Setup(m => m.ApiKey)
.Returns("AnAPIKey");
// Mock Authentication Requests Handler
var mockAuthenticationRequestsHandler = new Mock <IAuthenticationRequestsHandler>();
mockAuthenticationRequestsHandler
.Setup(m => m.AuthorizationTokenInfo)
.Returns(new AuthorizationToken()
{
TokenType = "Bearer",
AccessToken = "tHeToKen"
});
// Mock Http Client
var errorResponse = new ErrorResponses()
{
ErrorResponseArray = new[] { new ErrorResponse() }
};
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When($"{mockTikkieConfiguration.Object.ApiBaseUrl}{requestUrlSuffix}")
.Respond(HttpStatusCode.BadRequest, "application/json", JsonConvert.SerializeObject(errorResponse));
var httpClient = mockHttp.ToHttpClient();
var sut = CreateSut(mockTikkieConfiguration.Object, mockAuthenticationRequestsHandler.Object, () => httpClient);
// Act + Assert
Assert.ThrowsAsync <TikkieErrorResponseException>(async() => await sut.PostOrExceptionAsync <TestResponse>(requestUrlSuffix, content));
mockAuthenticationRequestsHandler.Verify(m => m.AuthenticateIfTokenExpiredAsync(), Times.Once);
Assert.IsTrue(httpClient.DefaultRequestHeaders.Contains("Authorization"));
Assert.IsTrue(httpClient.DefaultRequestHeaders.Contains("API-Key"));
}
protected override IActionResult CreateResult(HttpContext context)
{
var result = ErrorResponses.MethodNotAllowed(context, Code, Message);
return(allowedMethods.Length == 0 ? result : new AllowHeaderResult(result, allowedMethods));
}
internal static dynamic DoAPIRequest(string Baseurl, string ApiPath, string token, string requestBody, string RequestType, bool isObject = false)
{
if (!string.IsNullOrEmpty(Baseurl) && !string.IsNullOrEmpty(ApiPath) && !string.IsNullOrEmpty(token) && !string.IsNullOrEmpty(requestBody))
{
ErrorResponses error = new ErrorResponses();
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);
var response = client.PostAsync(Baseurl + ApiPath, new StringContent(requestBody)).Result;
var content = response.Content.ReadAsStringAsync().Result;
if (content.Contains("statusCode"))
{
error = JsonConvert.DeserializeObject <ErrorResponses>(content);
}
if (!string.IsNullOrEmpty(content) && error.statusCode != 0 && (error.statusCode != 200 || error.statusCode != 201))
{
throw new System.ArgumentException(error.statusCode + " Response Received With " + error.message);
}
else if (!string.IsNullOrEmpty(content) && content.Contains("keyword"))
{
if (isObject)
{
return(JsonConvert.DeserializeObject <KeywordsResponse[][]>(content));
}
else
{
return(content);
}
}
else if (!string.IsNullOrEmpty(content) && content.Contains("uniqueFeatures"))
{
if (isObject)
{
return(JsonConvert.DeserializeObject <List <ClassifierInformationResponse> >(content));
}
else
{
return(content);
}
}
else if (!string.IsNullOrEmpty(content) && content.Contains("textCoverage"))
{
if (isObject)
{
return(JsonConvert.DeserializeObject <ClassificationResponse[]>(content)[0]);
}
else
{
return(content);
}
}
else
{
return(true);
}
}
}
else
{
throw new System.ArgumentException("Baseurl,ApiPath,Token,RequestBody cant be null or empty!");
}
}
protected override IActionResult CreateResult(HttpContext context) => ErrorResponses.BadRequest(context, Code, Message);
