public async Task Update_Should_Update_Todo_List_From_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == UserConstants.DefaultUserDb.Email).FirstOrDefaultAsync();
var todoList = Builder <TodoList> .CreateNew()
.With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id)
.Build();
var todoListFromDatabase = (await context.TodoLists.AddAsync(todoList)).Entity;
await((DbContext)context).SaveChangesAsync();
var updateTodoListModel = Builder <UpdateTodoListModel> .CreateNew()
.With(utl => utl.Title = "UpdateTodoListTitleIntegration").Build();
// Act
var apiResponse = await Client.PutAsync($"/api/todoLists/{todoListFromDatabase.Id}",
new JsonContent(updateTodoListModel));
// Assert
context = (await GetNewHostAsync()).Services.GetRequiredService <DatabaseContext>();
var response = await ResponseHelper.GetApiResultAsync <UpdateTodoListResponseModel>(apiResponse);
var updatedTodoListFromDatabase = await context.TodoLists
.Where(tl => tl.Id == response.Result.Id)
.FirstOrDefaultAsync();
CheckResponse.Succeeded(response);
updatedTodoListFromDatabase.Should().NotBeNull();
updatedTodoListFromDatabase.Title.Should().Be(updateTodoListModel.Title);
}
public async Task Get_Todo_Lists_Should_Return_All_Todo_Lists_For_Specified_User_From_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == UserConstants.DefaultUserDb.Email)
.FirstOrDefaultAsync();
context.TodoLists.RemoveRange(context.TodoLists.ToList());
var todoLists = Builder <TodoList> .CreateListOfSize(10).All()
.With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id)
.Build();
var todoListsNotBelongToTheUser = Builder <TodoList> .CreateListOfSize(10).All()
.With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = Guid.NewGuid().ToString())
.Build();
await context.TodoLists.AddRangeAsync(todoLists);
await context.TodoLists.AddRangeAsync(todoListsNotBelongToTheUser);
await((DbContext)context).SaveChangesAsync();
// Act
var apiResponse = await Client.GetAsync("/api/todoLists");
// Assert
var response = await ResponseHelper.GetApiResultAsync <IEnumerable <TodoListResponseModel> >(apiResponse);
CheckResponse.Succeeded(response);
response.Result.Should().HaveCount(10);
}
public async Task Create_Should_Add_TodoItem_In_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == UserConstants.DefaultUserDb.Email).FirstOrDefaultAsync();
var todoListFromDatabase = Builder <TodoList> .CreateNew().With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id).Build();
await context.TodoLists.AddAsync(todoListFromDatabase);
await context.SaveChangesAsync();
var createTodoItemModel = Builder <CreateTodoItemModel> .CreateNew()
.With(cti => cti.TodoListId = todoListFromDatabase.Id).Build();
// Act
var apiResponse = await Client.PostAsync("/api/todoItems", new JsonContent(createTodoItemModel));
// Assert
var response =
JsonConvert.DeserializeObject <ApiResult <CreateTodoItemResponseModel> >(
await apiResponse.Content.ReadAsStringAsync());
var todoItemFromDatabase =
await context.TodoItems.Where(ti => ti.Id == response.Result.Id).FirstOrDefaultAsync();
CheckResponse.Succeeded(response);
todoItemFromDatabase.Should().NotBeNull();
todoItemFromDatabase.Title.Should().Be(createTodoItemModel.Title);
todoItemFromDatabase.List.Id.Should().Be(todoListFromDatabase.Id);
}
public async Task Delete_Should_Delete_Todo_List_From_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == "*****@*****.**").FirstOrDefaultAsync();
var todoList = Builder <TodoList> .CreateNew()
.With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id)
.Build();
var todoListFromDatabase = (await context.TodoLists.AddAsync(todoList)).Entity;
await context.SaveChangesAsync();
// Act
var apiResponse = await Client.DeleteAsync($"/api/todoLists/{todoListFromDatabase.Id}");
// Assert
var response = await ResponseHelper.GetApiResultAsync <BaseResponseModel>(apiResponse);
var updatedTodoListFromDatabase =
await context.TodoLists.Where(tl => tl.Id == response.Result.Id).FirstOrDefaultAsync();
CheckResponse.Succeeded(response);
updatedTodoListFromDatabase.Should().BeNull();
}
public async Task Delete_Should_Delete_Todo_Item_From_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == UserConstants.DefaultUserDb.Email).FirstOrDefaultAsync();
var todoItemFromDatabase = Builder <TodoItem> .CreateNew().With(ti => ti.Id = Guid.NewGuid())
.With(ti => ti.CreatedBy = user.Id).Build();
var todoListFromDatabase = Builder <TodoList> .CreateNew().With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id).Build();
todoListFromDatabase.Items.Add(todoItemFromDatabase);
await context.TodoLists.AddAsync(todoListFromDatabase);
await context.SaveChangesAsync();
// Act
var apiResponse = await Client.DeleteAsync($"/api/todoItems/{todoItemFromDatabase.Id}");
// Assert
var response =
JsonConvert.DeserializeObject <ApiResult <BaseResponseModel> >(await apiResponse.Content.ReadAsStringAsync());
var deletedTodoListFromDatabase =
await context.TodoItems.Where(ti => ti.Id == response.Result.Id).FirstOrDefaultAsync();
CheckResponse.Succeeded(response);
deletedTodoListFromDatabase.Should().BeNull();
}
public async Task ChangePassword_Should_Update_User_Password_If_OldPassword_And_NewPassword_Are_Ok()
{
// Arrange
var user = Builder <ApplicationUser> .CreateNew()
.With(u => u.UserName = "******")
.With(u => u.Email = "*****@*****.**")
.With(u => u.EmailConfirmed = true)
.Build();
var userManager = Host.Services.GetRequiredService <UserManager <ApplicationUser> >();
await userManager.CreateAsync(user, "Password.1!");
var changePasswordModel = Builder <ChangePasswordModel> .CreateNew()
.With(cu => cu.OldPassword = "******")
.With(cu => cu.NewPassword = "******")
.Build();
// Act
var apiResponse =
await Client.PutAsync($"/api/users/{user.Id}/changePassword", new JsonContent(changePasswordModel));
// Assert
apiResponse.StatusCode.Should().Be(HttpStatusCode.OK);
var response = await ResponseHelper.GetApiResultAsync <BaseResponseModel>(apiResponse);
CheckResponse.Succeeded(response);
response.Result.Id.Should().Be(user.Id);
}
public async Task ConfirmEmail_Should_Update_User_Status()
{
// Arrange
var user = Builder <ApplicationUser> .CreateNew()
.With(u => u.UserName = "******")
.With(u => u.Email = "*****@*****.**")
.Build();
var context = (await GetNewHostAsync()).Services.GetRequiredService <DatabaseContext>();
var userManager = Host.Services.GetRequiredService <UserManager <ApplicationUser> >();
await userManager.CreateAsync(user, "Password.1!");
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmEmailModel = Builder <ConfirmEmailModel> .CreateNew()
.With(ce => ce.UserId = user.Id)
.With(ce => ce.Token = token)
.Build();
// Act
var apiResponse = await Client.PostAsync("/api/users/confirmEmail", new JsonContent(confirmEmailModel));
// Assert
var response = await ResponseHelper.GetApiResultAsync <ConfirmEmailResponseModel>(apiResponse);
var userFromDatabase = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id);
CheckResponse.Succeeded(response);
response.Result.Confirmed.Should().BeTrue();
userFromDatabase.EmailConfirmed.Should().BeTrue();
}
public async Task Login_Should_Return_User_Information_And_Token()
{
// Arrange
// Act
var apiResponse = await Client.GetAsync("/api/WeatherForecast");
// Assert
var response = await ResponseHelper.GetApiResultAsync <IEnumerable <WeatherForecastResponseModel> >(apiResponse);
CheckResponse.Succeeded(response);
response.Result.Should().HaveCount(5);
}
public async Task GetAllByListId_Should_Return_All_Todo_Items_From_Specific_List()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var user = await context.Users.Where(u => u.Email == UserConstants.DefaultUserDb.Email).FirstOrDefaultAsync();
var todoListFromDatabase = Builder <TodoList> .CreateNew().With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = user.Id).Build();
todoListFromDatabase.Items.AddRange(Builder <TodoItem> .CreateListOfSize(25).All()
.With(ti => ti.Id = Guid.NewGuid()).Build());
var todoListFromAnotherUsers = Builder <TodoList> .CreateListOfSize(10).All()
.With(tl => tl.Id = Guid.NewGuid())
.With(tl => tl.CreatedBy = Guid.NewGuid().ToString())
.Build();
foreach (var todoList in todoListFromAnotherUsers)
{
todoList.Items.AddRange(Builder <TodoItem> .CreateListOfSize(10).All().With(ti => ti.Id = Guid.NewGuid())
.Build());
}
await context.TodoLists.AddAsync(todoListFromDatabase);
await context.TodoLists.AddRangeAsync(todoListFromAnotherUsers);
await context.SaveChangesAsync();
// Act
var apiResponse = await Client.GetAsync($"/api/todoLists/{todoListFromDatabase.Id}/todoItems");
// Assert
var response =
JsonConvert.DeserializeObject <ApiResult <IEnumerable <TodoItemResponseModel> > >(
await apiResponse.Content.ReadAsStringAsync());
CheckResponse.Succeeded(response);
response.Result.Should().NotBeNullOrEmpty();
response.Result.Should().HaveCount(25);
response.Result.Should().BeEquivalentTo(todoListFromDatabase.Items, options => options.Including(tl => tl.Id));
}
public async Task Login_Should_Return_User_Information_And_Token()
{
// Arrange
var loginUserModel = Builder <LoginUserModel> .CreateNew()
.With(cu => cu.Username = UserConstants.DefaultUserDb.Username)
.With(cu => cu.Password = UserConstants.DefaultUserDb.Password)
.Build();
// Act
var apiResponse = await Client.PostAsync("/api/users/authenticate", new JsonContent(loginUserModel));
// Assert
var response = await ResponseHelper.GetApiResultAsync <LoginResponseModel>(apiResponse);
CheckResponse.Succeeded(response);
response.Result.Username.Should().Be(UserConstants.DefaultUserDb.Username);
response.Result.Email.Should().Be(UserConstants.DefaultUserDb.Email);
response.Result.Token.Should().NotBeNullOrEmpty();
}
public async Task Create_Should_Add_TodoList_In_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var createTodoListModel = Builder <CreateTodoListModel> .CreateNew()
.Build();
// Act
var apiResponse = await Client.PostAsync("/api/todoLists", new JsonContent(createTodoListModel));
// Assert
var response = await ResponseHelper.GetApiResultAsync <CreateTodoListResponseModel>(apiResponse);
var todoListFromDatabase =
await context.TodoLists.Where(u => u.Id == response.Result.Id).FirstOrDefaultAsync();
CheckResponse.Succeeded(response);
todoListFromDatabase.Should().NotBeNull();
todoListFromDatabase.Title.Should().Be(createTodoListModel.Title);
}
public async Task Create_User_Should_Add_User_To_Database()
{
// Arrange
var context = Host.Services.GetRequiredService <DatabaseContext>();
var createModel = Builder <CreateUserModel> .CreateNew()
.With(cu => cu.Email = "*****@*****.**")
.With(cu => cu.Username = "******")
.With(cu => cu.Password = "******")
.Build();
// Act
var apiResponse = await Client.PostAsync("/api/users", new JsonContent(createModel));
// Assert
apiResponse.StatusCode.Should().Be(HttpStatusCode.OK);
var response = await ResponseHelper.GetApiResultAsync <CreateUserResponseModel>(apiResponse);
CheckResponse.Succeeded(response);
context.Users.Should().Contain(u => u.Id == response.Result.Id.ToString());
}
