private async Task <ResultHandler <string> > GetStringResponseByHttpRequest(HttpRequestModel httpRequestModel)
{
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
HttpRequestMessage httpRequestMessage = CreateHttpRequestMessage(httpRequestModel.MethodName, httpRequestModel.QueryString, httpRequestModel.HttpMethod, httpRequestModel.HttpContent);
HttpClient httpClient = CreateHttpClient(httpRequestModel.ClientName, httpRequestModel.Headers);
HttpResponseMessage httpResponseMessage = await SendHttpResponseMessage(httpRequestMessage, httpClient, httpRequestModel.CompletionOption, httpRequestModel.CancellationToken);
httpResponseMessage.EnsureSuccessStatusCode();
var content = await httpResponseMessage.Content.ReadAsStringAsync();
return(ResultHandler.Ok(content));
}
catch (TaskCanceledException tcex)
{
stopwatch.Stop();
_logger.LogError(tcex, $"GetStreamResponseByHttpRequest, time out was: {stopwatch.Elapsed.TotalSeconds}", new object[] { httpRequestModel });
return(ResultHandler.Fail <string>(tcex));
}
catch (Exception ex)
{
_logger.LogError(ex, "GetStreamResponseByHttpRequest", new object[] { httpRequestModel });
return(ResultHandler.Fail <string>(ex));
}
}
public async Task <ResultHandler <TRes> > GetHttpResponse <TRes>(HttpRequestModel httpRequest)
{
try
{
if (!httpRequest.IsValid)
{
this._logger.LogError($"GetHttpResponse Not Valid! ValidationError: {httpRequest.ValidationError}", new object[] { httpRequest });
return(ResultHandler.Fail <TRes>(E_ErrorType.EntityNotValid));
}
ResultHandler <Stream> resultHandler = await GetStreamResponseByHttpRequest(httpRequest);
if (!resultHandler.Success)
{
this._logger.LogError("GetStreamResponseByHttpRequest Failed", new object[] { httpRequest });
return(ResultHandler.Fail <TRes>(resultHandler.ErrorType));
}
using (Stream stream = resultHandler.Value)
{
TRes result = await JsonSerializer.DeserializeAsync <TRes>(stream, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
}, httpRequest.CancellationToken);
return(ResultHandler.Ok(result));
}
}
catch (Exception ex)
{
this._logger.LogError("GetHttpResponse Exception", new object[] { httpRequest });
return(ResultHandler.Fail <TRes>(ex));
}
}
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
if (request.Id.HasValue)
{
nameValueCollection.Add("Id", request.Id.Value.ToString());
}
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Users",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Typicode,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = nameValueCollection
};
var usersResult = await this._httpClientFactoryService.GetHttpResponse <User[]>(httpRequestModel);
if (!usersResult.Success)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType));
}
List <UserModel> result = new List <UserModel>();
foreach (User user in usersResult.Value)
{
result.Add(new UserModel()
{
Id = user.Id,
Name = user.Name
});
}
Thread.Sleep(TimeSpan.FromSeconds(_typicodeConfig.UsersThreadSleep));
return(ResultHandler.Ok <IEnumerable <UserModel> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(ex));
}
}
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
nameValueCollection.Add("order", "desc");
nameValueCollection.Add("sort", "reputation");
nameValueCollection.Add("site", "stackoverflow");
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Users",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Stackoverflow,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = nameValueCollection
};
var usersResult = await this._httpClientFactoryService.GetHttpResponse <UserResponse>(httpRequestModel);
if (!usersResult.Success)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType));
}
List <UserModel> result = new List <UserModel>();
foreach (User user in usersResult.Value.items)
{
result.Add(new UserModel()
{
Id = user.user_id,
Name = user.display_name
});
}
Thread.Sleep(TimeSpan.FromSeconds(this._stackoverflowConfig.UsersThreadSleep));
return(ResultHandler.Ok <IEnumerable <UserModel> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(ex));
}
}
public async Task Delete_WhenCalled_ShouldReturnOk()
{
//Arrange
ResultHandler expected = ResultHandler.Ok();
this._genericServiceMock
.Setup(items => items.Delete(this._eventModels.First().Id))
.ReturnsAsync(expected);
//Act
IActionResult actual = await this._controller.Delete(this._eventModels.First().Id);
//Assert
AssertHttpCode <OkObjectResult>(actual, this._eventModels.First().Id.GetHashCode());
}
public async Task Post_WhenCalled_ShouldReturnPost()
{
//Arrange
ResultHandler expected = ResultHandler.Ok();
this._genericServiceMock
.Setup(items => items.InsertRange(It.IsAny <IEnumerable <EventModel> >()))
.ReturnsAsync(expected);
//Act
IActionResult actual = await this._controller.Insert(this._eventModelPostsDTOs);
//Assert
AssertHttpCode <CreatedAtActionResult>(actual, this._eventModelsDTOs.GetHashCode());
}
public async Task <ResultHandler <IEnumerable <Album> > > GetAlbums(AlbumsRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <Album> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
if (request.Id.HasValue)
{
nameValueCollection.Add("Id", request.Id.Value.ToString());
}
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Albums",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Typicode,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = null
};
List <Album> result = new List <Album>();
for (int i = 0; i < 50; i++)
{
var albumsResponseResult = await this._httpClientFactoryService.GetHttpResponse <Album[]>(httpRequestModel);
if (!albumsResponseResult.Success)
{
return(ResultHandler.Fail <IEnumerable <Album> >(albumsResponseResult.ErrorType));
}
result.AddRange(albumsResponseResult.Value);
}
return(ResultHandler.Ok <IEnumerable <Album> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <Album> >(ex));
}
}
public async Task <ResultHandler <string> > GetAlbumYaml(int id)
{
try
{
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
nameValueCollection.Add("Id", id.ToString());
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Albums",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Typicode,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = null
};
var albumsResponseResult = await this._httpClientFactoryService.GetHttpResponse <Album[]>(httpRequestModel);
if (!albumsResponseResult.Success)
{
return(ResultHandler.Fail <string>(albumsResponseResult.ErrorType));
}
Album album = albumsResponseResult.Value.FirstOrDefault();
var serializer = new SerializerBuilder()
.WithNamingConvention(CamelCaseNamingConvention.Instance)
.Build();
if (album == null)
{
return(ResultHandler.Fail <string>(E_ErrorType.Supplier));
}
var result = serializer.Serialize(album);
return(ResultHandler.Ok <string>(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <string>(ex));
}
}
public async Task Get_WhenCalledWithNull_ShouldReturnOk()
{
//Arrange
var expected = ResultHandler.Ok(this._asyncEventModels);
this._genericServiceMock
.Setup(items => items.Get(It.IsAny <IEnumerable <FilterStatement <EventModel> > >(),
It.IsAny <OrderByStatement <EventModel> >(),
It.IsAny <string>()))
.Returns(() => expected);
//Act
IActionResult actual = await this._controller.Search(null);
//Assert
AssertHttpCode <OkObjectResult>(actual, 0);
OkObjectResult okObjectResult = actual as OkObjectResult;
var list = okObjectResult.Value as List <EventModelDTO>;
CollectionAssert.AreEqual(this._eventModelsDTOs, list);
}
public async Task Put_WhenCalled_ShouldReturnPut()
{
//Arrange
ResultHandler <EventModel> expected = ResultHandler.Ok(this._eventModels.First());
this._genericServiceMock
.Setup(x => x.GetById(It.IsAny <Guid>()))
.ReturnsAsync(expected);
this._genericServiceMock
.Setup(x => x.Update(It.IsAny <EventModel>()))
.ReturnsAsync(ResultHandler.Ok());
this._userServiceMock
.Setup(x => x.OwnerId)
.Returns(Guid.Parse(this._eventModels.First().OwnerId));
//Act
IActionResult actual = await this._controller.Update(new EventPutRequest());
//Assert
AssertHttpCode <OkObjectResult>(actual, this._eventModelsDTOs.First().GetHashCode());
}
public async Task Put_WhenDifferentOwnerId_ShouldReturnUnauthorized()
{
//Arrange
ResultHandler <EventModel> expected = ResultHandler.Ok(this._eventModels.First());
this._genericServiceMock
.Setup(x => x.GetById(It.IsAny <Guid>()))
.ReturnsAsync(expected);
this._genericServiceMock
.Setup(x => x.Update(It.IsAny <EventModel>()))
.ReturnsAsync(ResultHandler.Ok());
this._userServiceMock
.Setup(x => x.OwnerId)
.Returns(Guid.NewGuid());
//Act
EventPutRequest eventPutRequest = new EventPutRequest();
IActionResult actual = await this._controller.Update(eventPutRequest);
//Assert
AssertHttpCode <UnauthorizedObjectResult>(actual, eventPutRequest.GetHashCode());
}
