public async Task EditAsync_WithCorrectData_ShouldSuccessfullyEdit()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var topicRepository = new EfDeletableEntityRepository <Topic>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var topicsService = new TopicsService(topicRepository, userRepository);
var createInputModel = new CreateTopicInputModel()
{
Title = "TestTitle",
Content = "TestContent_TestContent_TestContent_TestContent_TestContent_TestContent",
};
await topicsService.CreateAsync(createInputModel);
var topic = topicRepository.All().FirstOrDefault(t => t.Title == "TestTitle");
var editInputModel = new TopicEditViewModel()
{
Id = topic.Id,
Title = "Edited_TestTitle",
Content = "Edited_TestContent_TestContent_TestContent_TestContent_TestContent_TestContent",
};
// Act
var expectedTopicTitle = "Edited_TestTitle";
var expectedTopicContent = "Edited_TestContent_TestContent_TestContent_TestContent_TestContent_TestContent";
await topicsService.EditAsync(editInputModel);
// Assert
topic = await topicRepository.GetByIdWithDeletedAsync(editInputModel.Id);
Assert.Equal(expectedTopicTitle, topic.Title);
Assert.Equal(expectedTopicContent, topic.Content);
}
public async Task AddProductsToOrder_WithExistingOrderAndNoProducts_ShouldReturnFalse()
{
string onTrueErrorMessage = "The method returned true upon no products input.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var orderService = new OrderService(context);
var products = await this.GetProductsForOrder();
OrderBindingModel model = new OrderBindingModel
{
DeliveryType = DeliveryType.Express,
PaymentType = PaymentType.OnDelivery,
Products = products,
};
var orderId = await orderService.CreateOrder(model);
// Passing null instead of the products
var methodResult = await orderService.AddProductsToOrder(orderId, null);
Assert.False(methodResult, onTrueErrorMessage);
}
public async Task GetShoppingListsByUserIdAsync_WithNonExistentUserId_ShouldReturnEmptyCollection()
{
var errorMessagePrefix = "UserShoppingListService GetShoppingListsByUserIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userShoppingListRepository = new EfRepository <UserShoppingList>(context);
var userShoppingListService = new UserShoppingListService(userShoppingListRepository);
await this.SeedDataAsync(context);
var nonExistentUserId = Guid.NewGuid().ToString();
// Act
var actualResult = (await userShoppingListService
.GetShoppingListsByUserIdAsync(nonExistentUserId))
.ToList()
.Count;
var expectedResult = 0;
// Assert
Assert.True(expectedResult == actualResult, errorMessagePrefix + " " + "Collection is not empty.");
}
public async Task GetByIdAsync_WithExistentUserId_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "UserService GetByIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var userService = this.GetUserService(userRepository, context);
await this.SeedDataForGetByIdMethod(context);
var userId = userRepository.All().First().Id;
// Act
var actualResult = await userService.GetByIdAsync(userId);
var expectedResult = userRepository
.All()
.First()
.To <ApplicationUserServiceModel>();
// Assert
Assert.True(expectedResult.Id == actualResult.Id, errorMessagePrefix + " " + "Id is not returned properly.");
Assert.True(expectedResult.FullName == actualResult.FullName, errorMessagePrefix + " " + "FullName is not returned properly.");
Assert.True(expectedResult.Biography == actualResult.Biography, errorMessagePrefix + " " + "Biography is not returned properly.");
Assert.True(expectedResult.ProfilePhoto == actualResult.ProfilePhoto, errorMessagePrefix + " " + "ProfilePhoto is not returned properly.");
Assert.True(expectedResult.Lifestyle.Id == actualResult.Lifestyle.Id, errorMessagePrefix + " " + "Lifestyle is not returned properly.");
Assert.True(expectedResult.HasAdditionalInfo == actualResult.HasAdditionalInfo, errorMessagePrefix + " " + "HasAdditionalInfo is not returned properly.");
Assert.True(expectedResult.Allergies.First().Allergen.Id == actualResult.Allergies.First().Allergen.Id, errorMessagePrefix + " " + "Allergen is not returned properly.");
Assert.True(expectedResult.Recipes.First().Id == actualResult.Recipes.First().Id, errorMessagePrefix + " " + "Recipe is not returned properly.");
Assert.True(expectedResult.FavoriteRecipes.First().Recipe.Id == actualResult.FavoriteRecipes.First().Recipe.Id, errorMessagePrefix + " " + "FavoriteRecipe is not returned properly.");
Assert.True(expectedResult.CookedRecipes.First().Recipe.Id == actualResult.CookedRecipes.First().Recipe.Id, errorMessagePrefix + " " + "CookedRecipe is not returned properly.");
Assert.True(expectedResult.Reviews.First().Id == actualResult.Reviews.First().Id, errorMessagePrefix + " " + "Review is not returned properly.");
Assert.True(expectedResult.ShoppingLists.First().ShoppingList.Id == actualResult.ShoppingLists.First().ShoppingList.Id, errorMessagePrefix + " " + "ShoppingList is not returned properly.");
}
public async Task TestCreateASyncMethodWithWrongData()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var articleRepository = new EfDeletableEntityRepository <Article>(context);
var articlesService = new ArticlesService(articleRepository);
var inputModel = new CreateArticleViewModel
{
ImgUrl = string.Empty,
Content = string.Empty,
Title = string.Empty,
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await articlesService.CreateAsync(inputModel, "1");
});
}
public async Task DeleteUserAsyncShouldDeleteUserAccountCorrectly()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var testAccountRepository = new EfDeletableEntityRepository <Account>(context);
var testAccounts = TestDataHelpers.GetTestData();
foreach (var acc in testAccounts)
{
await testAccountRepository.AddAsync(acc);
await testAccountRepository.SaveChangesAsync();
}
var testUserRepository = new Mock <IDeletableEntityRepository <ApplicationUser> >();
testUserRepository
.Setup(a => a.GetByIdWithDeletedAsync(It.IsAny <string>()))
.ReturnsAsync(new ApplicationUser()
{
Id = "1",
IsDeleted = false,
});
testUserRepository
.Setup(a => a.Delete(It.IsAny <ApplicationUser>()));
testUserRepository
.Setup(a => a.SaveChangesAsync());
var testAccountManagementService = new AccountManagementService(this.userManager.Object, testUserRepository.Object, testAccountRepository, this.positionService.Object, this.feePaymentsRepository.Object);
await testAccountManagementService.DeleteUserAsync("1", 1);
var account = testAccountRepository.AllWithDeleted().FirstOrDefault(a => a.Id == 1);
Assert.IsTrue(account.IsDeleted);
}
public async Task CheckIfActiveTaskIsComplete()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var tasksService = this.GetTasksService(context);
var seeder = new UsersSeeder();
await seeder.SeedUsers(context);
var user1 = context.Users.First(x => x.UserName == "User1");
var user2 = context.Users.First(x => x.UserName == "User2");
await context.TasksGather.AddAsync(new TaskGather
{
Id = Guid.NewGuid().ToString(),
UserId = user1.Id,
IsComplete = false,
EndTime = DateTime.UtcNow.AddDays(-1),
});
await context.TasksGather.AddAsync(new TaskGather
{
Id = Guid.NewGuid().ToString(),
UserId = user2.Id,
IsComplete = false,
EndTime = DateTime.UtcNow.AddDays(1)
});
await context.SaveChangesAsync();
var returnsTrue = await tasksService.CheckGatheringTaskCompletion(user1.Id);
var returnsFalse = await tasksService.CheckGatheringTaskCompletion(user2.Id);
Assert.True(returnsTrue == true, $"User didn't complete his task.");
Assert.True(returnsFalse == false, $"User completed his task when he shouldn't have.");
}
public async Task AddReview_WithCorrectData_ShouldCreateSuccessfully()
{
string onFalseErrorMessage = "The method returned false on valid creation model.";
string onNullErrorMessage = "The review was not added to the database.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var reviewService = new ReviewService(context);
ReviewBindingModel model = new ReviewBindingModel
{
ClientFullName = "TestClient",
Comment = "TestComment",
Rating = 5,
};
var methodResult = await reviewService.AddReview(model);
Assert.True(methodResult, onFalseErrorMessage);
var reviewExists = context.Reviews.FirstOrDefaultAsync(x => x.ClientFullName == model.ClientFullName);
AssertExtensions.NotNullWithMessage(reviewExists, onNullErrorMessage);
}
public async Task RecommendProduct_WithExistingProduct_ShouldReturnTrue()
{
string onFalseErrorMessage = "The method returned false on existing product.";
string onNullErrorMessage = "The product was either not in the database or not recommended.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var cloudinaryServiceMock = new Mock <ICloudinaryService>();
var productService = new ProductService(context, cloudinaryServiceMock.Object);
// Get the product and seed it
var product = this.GetProduct();
await this.SeedSingleProduct(context);
var methodResult = await productService.RecommendProduct(product.Id);
Assert.True(methodResult, onFalseErrorMessage);
var productFromDatabase = context.Products.FirstOrDefaultAsync(p => p.IsHidden == true);
AssertExtensions.NotNullWithMessage(productFromDatabase, onNullErrorMessage);
}
public async Task AddSuggestProduct_WithCorrectData_ShouldSuccessfullyAddSuggestion()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var groupRepository = new EfDeletableEntityRepository <Product_Group>(context);
var productRepository = new EfDeletableEntityRepository <Product>(context);
var fireplacesRepository = new EfDeletableEntityRepository <Fireplace_chamber>(context);
var suggestItemsReposotory = new EfDeletableEntityRepository <SuggestProduct>(context);
var groupService = new GroupService(groupRepository);
var prodcutService = new ProductService(productRepository, groupService);
var sugestItemsRepositoryService = new SuggestProdcut(suggestItemsReposotory);
var cloudinaryService = new FakeCloudinary();
var fireplaceService = new FireplaceService(fireplacesRepository, groupService, prodcutService, cloudinaryService, sugestItemsRepositoryService);
var seeder = new DbContextTestsSeeder();
await seeder.SeedUsersAsync(context);
await seeder.SeedGroupAsync(context);
await seeder.SeedProdcutAsync(context);
await seeder.SeedFireplacesAsync(context);
string[] selectedFireplace = new string[] { "Гк Оливия" };
// Act
AutoMapperConfig.RegisterMappings(typeof(FireplaceInputModel).Assembly);
await fireplaceService.AddSuggestionToFireplaceAsync("Гк Мая", "abc1", selectedFireplace, null, null, null);
var count = context.SuggestProducts.Count();
// Assert
Assert.True(count == 1, string.Format(ErrorMessage, "Add suggestion method"));
}
public void TestGetAllFireplaces_WithoutAnyData_ShouldReturnEmptyList()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var groupRepository = new EfDeletableEntityRepository <Product_Group>(context);
var productRepository = new EfDeletableEntityRepository <Product>(context);
var fireplacesRepository = new EfDeletableEntityRepository <Fireplace_chamber>(context);
var suggestItemsReposotory = new EfDeletableEntityRepository <SuggestProduct>(context);
var groupService = new GroupService(groupRepository);
var prodcutService = new ProductService(productRepository, groupService);
var sugestItemsRepositoryService = new SuggestProdcut(suggestItemsReposotory);
var cloudinaryService = new FakeCloudinary();
var fireplaceService = new FireplaceService(fireplacesRepository, groupService, prodcutService, cloudinaryService, sugestItemsRepositoryService);
// Act
AutoMapperConfig.RegisterMappings(typeof(AllFireplaceViewModel).Assembly);
var result = fireplaceService.GetAllFireplaceAsync <AllFireplaceViewModel>(TypeOfChamber.Basic.ToString());
var count = result.ToList().Count;
// Assert
Assert.True(count == 0, string.Format(ErrorMessage, "Get all fireplaces empty list"));
}
public async Task GetRemainingMinutesToCreateTopic_WhenThereIsOtherTopicWith30Minutes_ShouldReturnCorrectMinutes()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var topicRepository = new EfDeletableEntityRepository <Topic>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var topicsService = new TopicsService(topicRepository, userRepository);
var user = new ApplicationUser()
{
UserName = "******",
};
user.Topics.Add(new Topic()
{
Title = "testTitle",
});
user.Topics.Add(new Topic()
{
Title = "secondTestTitle",
});
await userRepository.AddAsync(user);
await userRepository.SaveChangesAsync();
var userId = userRepository.All().FirstOrDefault(u => u.UserName == "testUsername").Id;
// Act
var expectedRemainingMinutes = 30;
var actualRemainingMinutes = topicsService.GetRemainingMinutesToCreateTopic(userId);
// Assert
Assert.Equal(expectedRemainingMinutes, actualRemainingMinutes);
}
public async Task GetTopicsGetTopicsCountOfUser_ShouldReturnCorrectCount()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var topicRepository = new EfDeletableEntityRepository <Topic>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var topicsService = new TopicsService(topicRepository, userRepository);
var user = new ApplicationUser()
{
UserName = "******",
};
user.Topics.Add(new Topic()
{
Title = "testTitle",
});
user.Topics.Add(new Topic()
{
Title = "secondTestTitle",
});
await userRepository.AddAsync(user);
await userRepository.SaveChangesAsync();
var userId = userRepository.All().FirstOrDefault(u => u.UserName == "testUsername").Id;
// Act
var expectedTopicsCount = 2;
var actualTopicsCount = topicsService.GetTopicsCountOfUser(userId);
// Assert
Assert.Equal(expectedTopicsCount, actualTopicsCount);
}
public async Task EditAsync_WithIncorrectData_ShouldThrowArgumentNullException()
{
// Arrange
var incorrentInputModelId = "IncorrentId";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var topicRepository = new EfDeletableEntityRepository <Topic>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var topicsService = new TopicsService(topicRepository, userRepository);
var editInputModel = new TopicEditViewModel()
{
Id = incorrentInputModelId,
Title = "Edited_TestTitle",
Content = "Edited_TestContent_TestContent_TestContent_TestContent_TestContent_TestContent",
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await topicsService.EditAsync(editInputModel);
});
}
public async Task GetAllProductTypes_WithDummyData_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "ProductsService GetAllProductTypesAsync() method does not work properly.";
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedData(dbContext);
this.productsService = new ProductsService(dbContext);
var actualResult = await this.productsService.GetAllProductTypes <ProductTypesServiceModel>().ToListAsync();
var expectedResult = this.GetDummyData().Select(p => p.ProductType).To <ProductTypesServiceModel>().ToList();
Assert.True(actualResult.Count == expectedResult.Count, errorMessagePrefix);
// TODO:
// for (int i = 0; i < expectedResult.Count; i++)
// {
// var expectedEntry = expectedResult[i];
// var actualEntry = actualResult[i];
// Assert.True(expectedEntry.Name == actualEntry.Name, errorMessagePrefix + " " + "Name is not returned properly.");
// }
}
public async Task GetProducts_WithNullInput_ShouldReturnAllProductsTheSameOrder()
{
string onCountDifferenceErrorMessage = "The count of the returned products is not correct.";
string onFalseErrorMessage = "The returned products are not correct.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var cloudinaryServiceMock = new Mock <ICloudinaryService>();
var productService = new ProductService(context, cloudinaryServiceMock.Object);
// Get multiple products and seed the categories with the products
var products = this.GetMultipleProducts();
await this.SeedMultipleSubCategoriesAndCategories(context);
await this.SeedMultipleProducts(context);
string emptyString = string.Empty;
var resultProducts = await productService.GetProducts(null, null, 0);
// (They should be 2 because 2 products are recommended)
var expectedProductsCount = 2;
// Making sure the count of the returned products is correct before comparing them
AssertExtensions.EqualCountWithMessage(
expectedProductsCount, resultProducts.Count(), onCountDifferenceErrorMessage);
foreach (var prd in resultProducts)
{
// The 2 recommended product names
Assert.True(
prd.Name == "thirdProductName" || prd.Name == "sixthProductName", onFalseErrorMessage);
}
}
public async Task CreateRecipientNotNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var recipientHospitalDataRepository = new EfDeletableEntityRepository <RecipientHospitalData>(dbContext);
var service = new RecipientsService(
recipientRepository,
hospitalDataRepository,
recipientReques,
recipientHospitalDataRepository);
await SeedDataAsync(dbContext);
var user = recipientRepository
.All()
.Where(u => u.Age == 85)
.FirstOrDefault();
Assert.NotNull(user);
}
public async Task GetProducts_WithGivenAllFilterOptions_ShouldReturnTheProductsMatchingAllTheGivenCriteria()
{
string onCountDifferenceErrorMessage = "The returned products are not with the same count as expected.";
string onStringDifferenceErrorMessage = "The products sorting is wrong.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var cloudinaryServiceMock = new Mock <ICloudinaryService>();
var productService = new ProductService(context, cloudinaryServiceMock.Object);
// Get multiple products and seed the categories with the products
var products = this.GetMultipleProducts();
await this.SeedMultipleSubCategoriesAndCategories(context);
await this.SeedMultipleProducts(context);
// Should return products ordered by name descending
string searchString = "first";
string subCategoryId = "A-SubCategoryId-forFirst";
int sortBy = 4;
var resultProducts = await productService.GetProducts(searchString, subCategoryId, sortBy);
var expectedCount = 2;
AssertExtensions.EqualCountWithMessage(
expectedCount, resultProducts.Count(), onCountDifferenceErrorMessage);
var expectedFirstProductName = "B-firstProductName";
var firstActualProductName = resultProducts.First().Name;
AssertExtensions.EqualStringWithMessage(
expectedFirstProductName, firstActualProductName, onStringDifferenceErrorMessage);
}
public async Task GetAllHospitalsShouldBeOneTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var rolesRepository = new EfDeletableEntityRepository <ApplicationRole>(dbContext);
var appUsersHospitalRepository = new EfDeletableEntityRepository <ApplicationUserHospitalData>(dbContext);
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var bloodBankRepository = new EfDeletableEntityRepository <BloodBank>(dbContext);
var hospitalBloodBankRepository = new EfDeletableEntityRepository <HospitalDataBloodBank>(dbContext);
var bagRepository = new EfDeletableEntityRepository <BloodBag>(dbContext);
var userManager = this.GetUserManagerMock();
var service = new HospitalsService(
usersRepository,
hospitalDataRepository,
rolesRepository,
appUsersHospitalRepository,
recipientRepository,
bloodBankRepository,
hospitalBloodBankRepository,
bagRepository);
await SeedDataAsync(dbContext);
var user = usersRepository.All().FirstOrDefault(u => u.UserName == "User1");
await service.CreateHospitalProfileAsync(this.SeedInputs(), user.Id);
var result = service.GetAllHospitals <HospitalProfileInputModel>().Count();
Assert.Equal(1, result);
}
public async Task FindProduct_WithExistingId_ShouldSuccessfullyFind()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var groupRepository = new EfDeletableEntityRepository <Product_Group>(context);
var productRepository = new EfDeletableEntityRepository <Product>(context);
var groupService = new GroupService(groupRepository);
var productService = new ProductService(productRepository, groupService);
var seeder = new DbContextTestsSeeder();
await seeder.SeedGroupAsync(context);
await seeder.SeedProdcutAsync(context);
// Act
var result = productService.GetById("abc").Name;
var actual = context.Products.SingleOrDefault(p => p.Id == "abc").Name;
// Assert
AssertExtension.EqualsWithMessage(actual, result, string.Format(ErrorMessage, "ProductGetIdByNameAndGroup"));
}
public async Task SetShoppingListAsync_WithNonExistentUserId_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var userService = this.GetUserService(userRepository, context);
await context.ShoppingLists.AddAsync(new ShoppingList());
await context.SaveChangesAsync();
var nonExistentUserId = Guid.NewGuid().ToString();
var shoppingListServiceModel = context.ShoppingLists
.First()
.To <ShoppingListServiceModel>();
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await userService.SetShoppingListAsync(nonExistentUserId, shoppingListServiceModel);
});
}
public async Task Edit_WithCorrectData_ShouldEditServiceCorrectly()
{
var errorMessagePrefix = "ServicesService EditAsync() method does not work properly.";
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedData(dbContext);
this.servicesService = new ServicesService(dbContext);
var expectedResult = dbContext.Services.First().To <ServicesServiceModel>();
expectedResult.Name = "Name";
expectedResult.Picture = "Picture";
expectedResult.Description = "Description";
await this.servicesService.EditAsync(expectedResult.Id, expectedResult);
var actualResult = dbContext.Services.First().To <ServicesServiceModel>();
Assert.True(expectedResult.Name == actualResult.Name, errorMessagePrefix + " " + "Name is not return properly.");
Assert.True(expectedResult.Description == actualResult.Description, errorMessagePrefix + " " + "Description is not return properly.");
Assert.True(expectedResult.Picture == actualResult.Picture, errorMessagePrefix + " " + "Picture is not return properly.");
}
public async Task TestGetAllMethod()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var articleRepository = new EfDeletableEntityRepository <Article>(context);
var articlesService = new ArticlesService(articleRepository);
var seeder = new ArticlesTestsSeeder();
for (int i = 0; i < 10; i++)
{
var inputModel = new CreateArticleViewModel
{
ImgUrl = $"TT{i}{i * 2}asd",
Content = $"Ten{i}{i * 2}",
Title = $"Article{i}",
};
await articlesService.CreateAsync(inputModel, i.ToString());
}
var result = articlesService.GetAll <IndexArticleViewModel>();
Assert.Equal(10, result.Count());
}
public async Task DeleteByIdAsync_WithExistentId_ShouldSuccessfullyDelete()
{
var errorMessagePrefix = "NutritionalValueService DeleteByIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedDataAsync(context);
var nutritionalValueRepository = new EfDeletableEntityRepository <NutritionalValue>(context);
var nutritionalValueService = new NutritionalValueService(nutritionalValueRepository);
var existentId = nutritionalValueRepository.All().First().Id;
// Act
var nutritionalValuesCount = nutritionalValueRepository.All().Count();
await nutritionalValueService.DeleteByIdAsync(existentId);
var actualResult = nutritionalValueRepository.All().Count();
var expectedResult = nutritionalValuesCount - 1;
// Assert
Assert.True(actualResult == expectedResult, errorMessagePrefix + " " + "NutritionalValues count is not reduced.");
}
public async Task EditProfileAsync_ReturnsTrueAndMakesChanges_IfTheModelIsCorrect()
{
var errorMessageBool = "EditProfileAsync did not return true";
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var userService = this.GetUserService(userRepository, context);
var seeder = new UserTestSeeder();
await seeder.SeedUsersWithAddressesAsync(context);
var userWithoutAddresses = context.Users.First(x => x.UserName == "UserWithoutAddresses");
var profileEditInputModel = new ProfileEdintInputModel()
{
Id = userWithoutAddresses.Id,
Username = "******",
};
var result = await userService.EditProfileAsync(profileEditInputModel);
Assert.True(result, errorMessageBool);
Assert.Equal("Changed", userWithoutAddresses.UserName);
}
public async Task TestGetExercisesByCategoryAsync_WithValidData_ShouldReturnCorrectExercises()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <Exercise>(context);
await repository.AddAsync(new Exercise { Name = "first", MuscleGroup = MuscleGroup.Abs });
await repository.AddAsync(new Exercise { Name = "second", MuscleGroup = MuscleGroup.Abs });
await repository.AddAsync(new Exercise { Name = "third", MuscleGroup = MuscleGroup.Shoulders });
await repository.AddAsync(new Exercise { Name = "fourth", MuscleGroup = MuscleGroup.Upper_Legs });
await repository.SaveChangesAsync();
var service = new ExercisesService(repository);
var exercises = await service.GetExercisesByCategoryAsync(false, null, MuscleGroup.Abs.ToString(), null);
Assert.Equal(2, exercises.Count);
Assert.Equal("first", exercises[0].Name);
Assert.Equal("second", exercises[1].Name);
}
public async Task DeleteByShoppingListIdAsync_WithExistentShoppingListId_ShouldSuccessfullyDelete()
{
var errorMessagePrefix = "UserShoppingListService DeleteByShoppingListIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userShoppingListRepository = new EfRepository <UserShoppingList>(context);
var userShoppingListService = new UserShoppingListService(userShoppingListRepository);
await this.SeedDataAsync(context);
var shoppingListId = context.ShoppingLists.First(x => x.Ingredients == "Ingredients 1").Id;
// Act
var userShoppingListsCount = userShoppingListRepository.All().Count();
await userShoppingListService.DeleteByShoppingListIdAsync(shoppingListId);
var actualResult = userShoppingListRepository.All().Count();
var expectedResult = userShoppingListsCount - 1;
// Assert
Assert.True(expectedResult == actualResult, errorMessagePrefix + " " + "Count is not reduced properly.");
}
public async Task Create_WithCorrectData_ShouldSuccsessfullyCreate()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedData(dbContext);
this.productsService = new ProductsService(dbContext);
var testProductService = new ProductsServiceModel
{
Name = "cleaning",
Description = "cleaning desc",
Picture = "default",
ProductType = new ProductTypesServiceModel
{
Name = "cleaning",
},
};
var expectedResultId = 3;
var actualResultId = await this.productsService.CreateProductAsync(testProductService);
Assert.Equal(actualResultId, expectedResultId);
}
public async Task GetAllUserAddresses_WithNonExistingUser_ShouldReturnCorrectAddresses()
{
string onNonEmptyCollectionErrorMessage = "The method does not return the expected count.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var addressService = new AddressService(context);
// passing a non-existing user Id
var addresses = await addressService.GetAllUserAddresses("randomId");
var expectedCount = 0;
var actualCount = 0;
foreach (var address in addresses)
{
actualCount++;
}
AssertExtensions.EqualCountWithMessage(
expectedCount,
actualCount,
onNonEmptyCollectionErrorMessage);
}
public async Task OrderProducts_OrdersProductsCorectly()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var productRepository = new EfDeletableEntityRepository <Product>(context);
var productsTestSeeder = new ProductTestSeeder();
var productsService = this.GetProductsService(productRepository, context);
await productsTestSeeder.SeedProducts(context);
var products = productRepository.All().To <ProductSingleViewModel>();
var priceDesc = "price-highest-to-lowest";
var priceAsc = "price-lowest-to-highest";
var productsActualDesc = productsService.OrderProducts(priceDesc, products);
var productsActualAsc = productsService.OrderProducts(priceAsc, products);
var productExpectedDesc = productRepository.All().OrderByDescending(x => x.Price).To <ProductSingleViewModel>();
var productExpectedAsc = productRepository.All().OrderBy(x => x.Price).To <ProductSingleViewModel>();
Assert.Equal(productExpectedDesc, productsActualDesc);
Assert.Equal(productExpectedAsc, productsActualAsc);
}
