public void Should_Return_Forbidden_When_Put_Without_Authorization()
{
// Arrange
var logId = 1;
var userId = 3; // User with id 3 isn't owner of the log with id 1
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(false, userId).Object;
var fakeRepository = fakes.FakeLogRepository().Object;
var fakeUserRepo = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepo, hashService);
var logService = new LogService(fakes.Mapper, fakeRepository, userService);
var request = new UpdateLogRequest();
// Act
var controller = new LogController(fakes.Mapper, logService);
var actual = controller.Put(logId, request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(403, result.StatusCode); // Forbidden
Assert.IsType <Response>(result.Value);
}
public void Should_Return_BadRequest_When_Put_And_An_Error_Happens()
{
// Arrange
var logId = 1;
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeLogRepositoryException().Object;
var fakeUserRepo = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepo, hashService);
var logService = new LogService(fakes.Mapper, fakeRepository, userService);
var request = new UpdateLogRequest();
// Act
var controller = new LogController(fakes.Mapper, logService);
var actual = controller.Put(logId, request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(400, result.StatusCode); // Bad Request
Assert.IsType <Response>(result.Value);
}
public async Task <Response> Update(int logId, UpdateLogRequest request)
{
try
{
var log = await _repository.GetById(logId);
if (!_userService.IsAuthenticated(log.UserId))
{
return(ForbiddenResponse(
"Não é possível atualizar um log de outro usuário"));
}
log = MapUpdateLogRequestToLog(log, request);
_repository.Update(log);
if (await _repository.SaveChangesAsync())
{
var response = _mapper.Map <LogResponse>(log);
return(OkResponse(null, response));
}
return(BadRequestResponse("Erro desconhecido"));
}
catch (NullReferenceException)
{
return(NotFoundResponse("Log não encontrado"));
}
catch (Exception ex)
{
return(BadRequestResponse(ex.Message));
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UpdateLogRequest request;
try
{
request = new UpdateLogRequest
{
LogGroupId = LogGroupId,
LogId = LogId,
UpdateLogDetails = UpdateLogDetails,
IfMatch = IfMatch,
OpcRequestId = OpcRequestId
};
response = client.UpdateLog(request).GetAwaiter().GetResult();
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task <IActionResult> Put(int logId, UpdateLogRequest request)
{
var mapped = request.MapToCoreRequest(_mapper);
var response = await _logService.Update(logId, mapped);
return(StatusCode(response.Code, response));
}
private Log MapUpdateLogRequestToLog(Log log, UpdateLogRequest request)
{
log.Description = request.Description;
log.Title = request.Title;
log.Details = request.Details;
log.Source = request.Source;
log.EventCount = request.EventCount;
log.Level = request.Level;
log.Channel = request.Channel;
return(log);
}
public async void Should_Return_Unauthorized_When_Put_Without_Logged_User()
{
// Arrange
var logId = 3;
RemoveClientAuthToken(_fixture.Client);
var requestData = new UpdateLogRequest();
requestData.Title = "Some Test Title";
// Act
var request = await _fixture.Client.PutAsJsonAsync($"api/v1/log/{logId}", requestData);
// Assert
Assert.Equal(HttpStatusCode.Unauthorized, request.StatusCode);
}
public void Should_Return_NotFound_When_Update_With_An_Incorrect_Id()
{
// Arrange
var logId = 9999;
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeLogRepository().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepository, hashService);
var request = new UpdateLogRequest();
var expected = Responses.NotFoundResponse("Log não encontrado");
// Act
var service = new LogService(fakes.Mapper, fakeRepository, userService);
var actual = service.Update(logId, request).Result;
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new ResponseComparer());
}
public void Should_Return_BadRequest_When_Update_And_Exception_Is_Thrown()
{
// Arrange
var logId = 1;
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeLogRepositoryException().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepository, hashService);
var request = new UpdateLogRequest();
var expected = Responses.BadRequestResponse("Test Exception");
// Act
var service = new LogService(fakes.Mapper, fakeRepository, userService);
var actual = service.Update(logId, request).Result;
// Assert
Assert.ThrowsAnyAsync <Exception>(() => service.Update(logId, request));
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new ResponseComparer());
}
public static Core.Dto.Requests.UpdateLogRequest MapToCoreRequest(
this UpdateLogRequest request,
IMapper mapper)
{
return(mapper.Map <Core.Dto.Requests.UpdateLogRequest>(request));
}
