public void Should_Return_Log_When_Create_With_Manager_And_Specified_UserId()
{
// Arrange
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 = fakes.Get <CreateLogRequest>().First();
var log = fakes.Get <Log>().First();
var response = fakes.Mapper.Map <LogResponse>(log);
response.Id = 999; // Mocked id when creating a new log
response.Archived = false; // By default, log is created as unarchived
response.UserId = request.UserId.Value; // UserId were specified, so it should be equal to the UserId in request
// Act
var service = new LogService(fakes.Mapper, fakeRepository, userService);
var actual = service.Create(request).Result;
response.CreatedAt = (actual.Data as LogResponse).CreatedAt;
var expected = Responses.OkResponse(null, response);
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new LogResponseComparer());
}
public void Should_Return_User_When_Register_With_Valid_Credentials()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var tokenService = new TokenService(fakeConfig);
var hashService = new HashService();
var mockUserRepository = fakes.FakeUserRepository();
// Returns null when GetByEmail is called, so the service doesn't return Conflict.
mockUserRepository.Setup(x => x.GetByEmail(It.IsAny <string>()))
.Returns(Task.FromResult <User>(null));
var fakeUserRepository = mockUserRepository.Object;
var request = fakes.Get <RegisterUserRequest>().First();
var user = fakes.Get <User>().First();
var response = fakes.Mapper.Map <UserResponse>(user);
response.Id = 999; // Expected user id
response.Role = EUserRole.DEVELOPER; // By default, user is created as DEVELOPER
// Act
var service = new AuthService(fakes.Mapper, fakeUserRepository, tokenService, hashService);
var actual = service.Register(request).Result;
response.CreatedAt = (actual.Data as UserResponse).CreatedAt;
var expected = Responses.OkResponse(null, response);
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new UserResponseComparer());
}
public void Should_Return_User_And_Token_When_Authenticate_With_Correct_Credentials()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var tokenService = new TokenService(fakeConfig);
var hashService = new HashService();
var request = fakes.Get <LoginUserRequest>().First();
var user = fakes.Get <User>().First();
var response = new LoginUserResponse();
response.User = fakes.Mapper.Map <UserResponse>(user);
response.ExpiresIn = tokenService.GetExpirationInSeconds();
// Act
var service = new AuthService(fakes.Mapper, fakeUserRepository, tokenService, hashService);
var actual = service.Authenticate(request).Result;
var data = actual.Data as LoginUserResponse;
response.Token = data.Token; // Should use the generated token for comparison
var expected = Responses.OkResponse(null, response);
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new LoginUserResponseComparer());
Assert.True(tokenService.IsValid(data.Token));
}
public void Should_Return_User_When_Update_With_Manager()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var request = fakes.Get <UpdateUserRequest>().First();
request.Name = "Updated Title";
var user = fakes.Get <User>().First();
user.Name = request.Name;
var response = fakes.Mapper.Map <UserResponse>(user);
var expected = Responses.OkResponse(null, response);
// Act
var service = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var actual = service.Update(user.Id, request).Result;
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new UserResponseComparer());
}
public void Should_Return_BadRequest_When_Update_And_An_Error_Happens()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeUserRepositoryException().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var user = fakes.Get <User>().First();
var request = fakes.Get <UpdateUserRequest>().First();
// Act
var controller = new UserController(fakes.Mapper, userService);
var actual = controller.Put(user.Id, 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 void Should_Return_User_When_Create_With_Manager()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var hashService = new HashService();
var mockRepository = fakes.FakeUserRepository();
// Returns null when GetByEmail is called, so the service doesn't return Conflict.
mockRepository.Setup(x => x.GetByEmail(It.IsAny <string>()))
.Returns(Task.FromResult <User>(null));
var fakeRepository = mockRepository.Object;
var request = fakes.Get <CreateUserRequest>().First();
var user = fakes.Get <User>().First();
var response = fakes.Mapper.Map <UserResponse>(user);
response.Id = 999; // Mocked id when creating a new user
response.Role = EUserRole.DEVELOPER; // By default, user is created as DEVELOPER
// Act
var service = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var actual = service.Create(request).Result;
response.CreatedAt = (actual.Data as UserResponse).CreatedAt;
var expected = Responses.OkResponse(null, response);
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new UserResponseComparer());
}
public async void Should_Return_Ok_When_Put_With_Manager(int userId)
{
// Arrange
var loginResponse = await LoginAsManager(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = new UpdateUserRequest();
requestData.Name = "Some Test Name";
var data = Fakes.Get <UserResponse>().Find(x => x.Id == userId);
data.Email = requestData.Name;
var expected = Responses.OkResponse(null, data);
// Act
var request = await _fixture.Client.PutAsJsonAsync($"api/v1/user/{userId}", requestData);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <UserResponse>();
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new UserResponseComparer());
}
public async void Should_Return_Ok_When_Post_With_Manager()
{
// Arrange
var loginResponse = await LoginAsManager(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = Fakes.Get <CreateUserRequest>().First();
requestData.Email = "*****@*****.**";
// Act
var request = await _fixture.Client.PostAsJsonAsync($"api/v1/user", requestData);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <UserResponse>();
var data = Fakes.Get <UserResponse>().First();
data.Id = (response.Data as UserResponse).Id;
data.Email = requestData.Email;
data.Role = EUserRole.DEVELOPER;
data.CreatedAt = (response.Data as UserResponse).CreatedAt;
var expected = Responses.OkResponse(null, data);
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new UserResponseComparer());
}
public void Should_Return_NotFound_When_Authenticate_With_Incorrect_Email()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var tokenService = new TokenService(fakeConfig);
var authService = new AuthService(fakes.Mapper, fakeUserRepository, tokenService, hashService);
var request = fakes.Get <LoginUserRequest>().First();
request.Email = "*****@*****.**";
// Act
var controller = new AuthController(fakes.Mapper, authService);
var actual = controller.Authenticate(request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(404, result.StatusCode); // Not Found
Assert.IsType <Response>(result.Value);
}
public async void Should_Return_Ok_When_Register_With_Valid_Credentials()
{
// Arrange
RemoveClientAuthToken(_fixture.Client);
var data = Fakes.Get <RegisterUserRequest>().First();
data.Email = "*****@*****.**"; // Email that doesn't exist
// Act
var request = await _fixture.Client.PostAsJsonAsync("api/v1/auth/register", data);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <UserResponse>();
var user = Fakes.Get <UserResponse>().First();
user.Id = (response.Data as UserResponse).Id;
user.Email = data.Email;
user.Role = EUserRole.DEVELOPER;
user.CreatedAt = (response.Data as UserResponse).CreatedAt;
var expected = Responses.OkResponse(null, user);
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new UserResponseComparer());
}
public void Should_Return_Ok_When_Post_With_Manager_And_Specified_UserId()
{
// Arrange
var userId = 1;
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).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 = fakes.Get <CreateLogRequest>().First();
request.UserId = userId;
// Act
var controller = new LogController(fakes.Mapper, logService);
var actual = controller.Post(request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(200, result.StatusCode); // Ok
Assert.IsType <Response>(result.Value);
}
public async void Should_Return_Ok_When_Authenticate_With_Correct_Credentials()
{
// Arrange
RemoveClientAuthToken(_fixture.Client);
var data = Fakes.Get <LoginUserRequest>().First();
var loginResponse = new LoginUserResponse();
loginResponse.User = Fakes.Get <UserResponse>().First();
// Act
var request = await _fixture.Client.PostAsJsonAsync("api/v1/auth/login", data);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <LoginUserResponse>();
var responseData = response.Data as LoginUserResponse;
loginResponse.Token = responseData.Token; // Should use the generated token for comparison
loginResponse.ExpiresIn = responseData.ExpiresIn;
var expected = Responses.OkResponse(null, loginResponse);
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LoginUserResponseComparer());
}
public async void Should_Return_Ok_When_Put_With_Owner()
{
// Arrange
var logId = 1;
var userId = 9;
var user = Fakes.Get <User>().Find(x => x.Id == userId);
var loginResponse = await LoginUser(_fixture.Client, user.Email);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = Fakes.Get <UpdateLogRequest>().First();
requestData.Title = "Some Test Title";
var data = Fakes.Get <LogResponse>().First();
data.Title = requestData.Title;
var expected = Responses.OkResponse(null, data);
// Act
var request = await _fixture.Client.PutAsJsonAsync($"api/v1/log/{logId}", requestData);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <LogResponse>();
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseComparer());
}
public void Should_Return_Ok_When_Register_With_Valid_Credentials()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var tokenService = new TokenService(fakeConfig);
var authService = new AuthService(fakes.Mapper, fakeUserRepository, tokenService, hashService);
var request = fakes.Get <RegisterUserRequest>().First();
request.Email = "*****@*****.**"; // Email that doesn't exist
// Act
var controller = new AuthController(fakes.Mapper, authService);
var actual = controller.Register(request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(200, result.StatusCode); // Ok
Assert.IsType <Response>(result.Value);
}
public void Should_Return_NotFound_When_Update_With_An_Incorrect_Id()
{
// Arrange
var userId = 999;
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var request = fakes.Get <UpdateUserRequest>().First();
// Act
var controller = new UserController(fakes.Mapper, userService);
var actual = controller.Put(userId, request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(404, result.StatusCode); // Not Found
Assert.IsType <Response>(result.Value);
}
public void Should_Return_Ok_When_Create_With_Manager()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var request = fakes.Get <CreateUserRequest>().First();
request.Email = "*****@*****.**"; // Email that doesn't exist in test data
// Act
var controller = new UserController(fakes.Mapper, userService);
var actual = controller.Post(request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(200, result.StatusCode); // Ok
Assert.IsType <Response>(result.Value);
}
public void Should_Return_Conflict_When_Create_With_Existing_Email()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeRepository, hashService);
var request = fakes.Get <CreateUserRequest>().First();
// Act
var controller = new UserController(fakes.Mapper, userService);
var actual = controller.Post(request);
// Assert
Assert.NotNull(actual);
Assert.IsType <ObjectResult>(actual.Result);
var result = actual.Result as ObjectResult;
Assert.NotNull(result.Value);
Assert.Equal(409, result.StatusCode); // Conflict
Assert.IsType <Response>(result.Value);
}
public async void Should_Return_Ok_When_Archive_With_Owner()
{
// Arrange
var logId = 15;
var userId = 6;
var user = Fakes.Get <User>().Find(x => x.Id == userId);
var loginResponse = await LoginUser(_fixture.Client, user.Email);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var data = Fakes.Get <LogResponse>().Find(x => x.Id == logId);
data.Archived = !data.Archived;
var expected = Responses.OkResponse(null, data);
// Act
var request = await _fixture.Client.PatchAsync($"api/v1/log/archive/{logId}", null);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <LogResponse>();
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseComparer());
}
public async void Should_Return_Ok_When_Put_With_Manager()
{
// Arrange
var logId = 20;
var index = logId - 1;
var loginResponse = await LoginAsManager(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = Fakes.Get <UpdateLogRequest>().ElementAt(index);
requestData.Title = "Some Test Title";
// Act
var request = await _fixture.Client.PutAsJsonAsync($"api/v1/log/{logId}", requestData);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <LogResponse>();
var data = Fakes.Get <LogResponse>().ElementAt(index);
data.Title = requestData.Title;
data.UserName = (response.Data as LogResponse).UserName;
var expected = Responses.OkResponse(null, data);
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseComparer());
}
public async void Should_Return_Forbidden_When_Put_Without_Authorization()
{
// Arrange
var logId = 1;
var userId = 3;
var user = Fakes.Get <User>().Find(x => x.Id == userId);
var loginResponse = await LoginUser(_fixture.Client, user.Email);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = Fakes.Get <UpdateLogRequest>().First();
requestData.Title = "Some Test Title";
var expected = Responses.ForbiddenResponse(
"Não é possível atualizar um log de outro usuário");
// Act
var request = await _fixture.Client.PutAsJsonAsync($"api/v1/log/{logId}", requestData);
var response = await request.Content.ReadAsAsync <Response>();
var responseStr = await request.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.Forbidden, request.StatusCode);
Assert.Equal(expected, response, new ResponseComparer());
}
public async void Should_Return_Ok_When_Post_With_Manager_And_Specified_UserId()
{
// Arrange
var userId = 9;
var loginResponse = await LoginAsManager(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var requestData = Fakes.Get <CreateLogRequest>().First();
requestData.UserId = userId;
// Act
var request = await _fixture.Client.PostAsJsonAsync($"api/v1/log", requestData);
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JObject)response.Data).ToObject <LogResponse>();
var data = Fakes.Get <LogResponse>().First();
data.Id = (response.Data as LogResponse).Id;
data.UserId = userId;
data.UserName = (response.Data as LogResponse).UserName;
data.Archived = false;
data.CreatedAt = (response.Data as LogResponse).CreatedAt;
var expected = Responses.OkResponse(null, data);
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseComparer());
}
public async void Should_Return_Ok_When_GetArchivedLogsByUserId_With_Manager()
{
// Arrange
var userId = 3;
var user = Fakes.Get <User>().Find(x => x.Id == userId);
var loginResponse = await LoginAsManager(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
var data = Fakes.Get <LogResponse>()
.Where(x => x.UserId == userId)
.Where(x => x.Archived == true)
.ToArray();
Response expected = Responses.OkResponse(null, data);
// Act
var request = await _fixture.Client.GetAsync($"api/v1/log/archived/user/{userId}");
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JArray)response.Data).ToObject <LogResponse[]>();
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseListComparer());
}
public async void Should_Return_Ok_When_Get_With_Logged_User()
{
// Arrange
var loginResponse = await LoginAsDesigner(_fixture.Client);
SetClientAuthToken(_fixture.Client, loginResponse.Token);
// "Get" returns only unarchived logs
var data = Fakes.Get <LogResponse>()
.Where(x => x.Archived == false)
.ToArray();
Response expected = Responses.OkResponse(null, data);
// Act
var request = await _fixture.Client.GetAsync("api/v1/log");
var response = await request.Content.ReadAsAsync <Response>();
response.Data = ((JArray)response.Data).ToObject <LogResponse[]>();
var responseStr = await request.Content.ReadAsStringAsync();
// Assert
Assert.True(request.IsSuccessStatusCode);
Assert.Equal(expected, response, new LogResponseListComparer());
}
public void Should_Return_BadRequest_When_Register_And_An_Error_Happens()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var fakeUserRepository = fakes.FakeUserRepositoryException().Object;
var hashService = new HashService();
var tokenService = new TokenService(fakeConfig);
var authService = new AuthService(fakes.Mapper, fakeUserRepository, tokenService, hashService);
var request = fakes.Get <RegisterUserRequest>().First();
// Act
var controller = new AuthController(fakes.Mapper, authService);
var actual = controller.Register(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);
}
protected async Task <LoginUserResponse> LoginUser(HttpClient client, string email)
{
var data = Fakes.Get <LoginUserRequest>().Find(x => x.Email == email);
var request = await client.PostAsJsonAsync("api/v1/auth/login", data);
var response = await request.Content.ReadAsAsync <Response>();
return(JsonConvert.DeserializeObject <LoginUserResponse>(response.Data.ToString()));
}
public async void Should_Return_Unauthorized_When_Post_Without_Logged_User()
{
// Arrange
RemoveClientAuthToken(_fixture.Client);
var requestData = Fakes.Get <CreateLogRequest>().First();
// Act
var request = await _fixture.Client.PostAsJsonAsync($"api/v1/log", requestData);
// Assert
Assert.Equal(HttpStatusCode.Unauthorized, request.StatusCode);
}
public void Should_Return_True_When_IsValid_With_Valid_Token()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var user = fakes.Get <User>().First();
// Act
var service = new TokenService(fakeConfig);
var token = service.GenerateToken(user);
var valid = service.IsValid(token);
// Assert
Assert.True(valid);
}
public void Should_Return_Valid_Token_When_GenerateToken()
{
// Arrange
var fakes = new Fakes();
var fakeConfig = fakes.FakeConfiguration().Object;
var user = fakes.Get <User>().First();
// Act
var service = new TokenService(fakeConfig);
var token = service.GenerateToken(user);
// Assert
Assert.NotNull(token);
Assert.IsType <string>(token);
Assert.True(service.IsValid(token));
}
public async void Should_Return_Conflict_When_Register_With_Email_Already_In_Use()
{
// Arrange
RemoveClientAuthToken(_fixture.Client);
var data = Fakes.Get <RegisterUserRequest>().First();
var expected = Responses.ConflictResponse("Esse email já está sendo utilizado");
// Act
var request = await _fixture.Client.PostAsJsonAsync("api/v1/auth/register", data);
var response = await request.Content.ReadAsAsync <Response>();
// Assert
Assert.Equal(HttpStatusCode.Conflict, request.StatusCode);
Assert.Equal(expected, response, new ResponseComparer());
}
public async void Should_Return_NotFound_When_Authenticate_With_Incorrect_Email()
{
// Arrange
RemoveClientAuthToken(_fixture.Client);
var data = Fakes.Get <LoginUserRequest>().First();
data.Email = "*****@*****.**"; // Incorrect email
var expected = Responses.NotFoundResponse("Usuário não encontrado");
// Act
var request = await _fixture.Client.PostAsJsonAsync("api/v1/auth/login", data);
var response = await request.Content.ReadAsAsync <Response>();
// Assert
Assert.Equal(HttpStatusCode.NotFound, request.StatusCode);
Assert.Equal(expected, response, new ResponseComparer());
}
