public async Task TestBlockUser() { //Arrange var owner = EntitiesCreationService.GetOwner("BlockerOwner"); owner.HashedPassword = "******"; var user = EntitiesCreationService.GetUser("BlockingUser"); user.HashedPassword = "******"; user = await accountsRepository.AddAsync(user); owner = await accountsRepository.AddAsync(owner); try { //Act await accountsService.BanUser(owner.AccountId, user.UserName); //Assert var blockedUserOwners = blockedUsersRepository.BlokedUserOwners(user.AccountId); Assert.Contains(blockedUserOwners, buo => buo.OwnerId == owner.AccountId && buo.AccountId == user.AccountId); } finally { //Clean accountsRepository.Remove(user); accountsRepository.Remove(owner); } }
public async Task GetAllOrdersForRegularUserTest() { //Arrange var newOrder = await GetNewAddedEntity(); var secondOrder = EntitiesCreationService.GetOrder(); secondOrder.CustomerId = newOrder.CustomerId; secondOrder.RestaurantId = newOrder.RestaurantId; var addedSecondOrder = await repository.AddAsync(secondOrder); try { //Act var foundOrders = repository.GetAllOrdersForRegularUser((int)newOrder.CustomerId); //Assert Assert.Contains(foundOrders, fo => fo.EntityId == newOrder.EntityId); Assert.Contains(foundOrders, fo => fo.EntityId == addedSecondOrder.EntityId); } finally { //Clean CleaningDb(newOrder); CleaningDb(addedSecondOrder); } }
public async Task GetOwnersRestaurantsTest() { //Arrange var restaurant = await GetNewAddedEntity(); var secondRestaurant = EntitiesCreationService.GetRestaurant(); secondRestaurant.OwnerId = restaurant.OwnerId; var addedSecondRestaurant = await repository.AddAsync(secondRestaurant); try { //Act var restaurants = repository.GetOwnersRestaurants(restaurant.OwnerId); //Assert Assert.Contains(restaurants, r => r.RestaurantId == restaurant.RestaurantId); Assert.Contains(restaurants, r => r.RestaurantId == addedSecondRestaurant.RestaurantId); } finally { //Clean CleaningDb(restaurant); CleaningDb(secondRestaurant); } }
public async Task GetAllMealsForRestaurantTest() { //Arrange var meal = await GetNewAddedEntity(); var secondMeal = EntitiesCreationService.GetMeal(); secondMeal.RestaurantId = meal.RestaurantId; var seccondAddedMeal = await repository.AddAsync(secondMeal); try { //Act var meals = repository.GetAllMealsForRestaurant(meal.RestaurantId); //Assert Assert.Contains(meals, m => m.EntityId == meal.EntityId); Assert.Contains(meals, m => m.EntityId == seccondAddedMeal.EntityId); } finally { //Clean CleaningDb(meal); } }
private async Task <Meal> GetNewMeal() { var restaurant = await GetRestaurant(); var meal = EntitiesCreationService.GetMeal(); meal.RestaurantId = restaurant.RestaurantId; return(meal); }
public async Task UpdateStausTestPositive(AccountRoles accountRole, OrderStatuses previousOrderStatus, OrderStatuses nextStatus) { //Arrange var owner = EntitiesCreationService.GetOwner(); owner.HashedPassword = "******"; var restaurant = EntitiesCreationService.GetRestaurant(); owner.Restaurants = new List <Restaurant>() { restaurant }; owner = await accountsRepository.AddAsync(owner); var account = EntitiesCreationService.GetOwner(); account.HashedPassword = "******"; account.Role = accountRole; var order = EntitiesCreationService.GetOrder(); var orderStatus = EntitiesCreationService.GetOrderStatus(); orderStatus.Status = previousOrderStatus; order.OrderStatuses = new List <OrderStatus>() { orderStatus }; order.RestaurantId = owner.Restaurants[0].RestaurantId; account.Orders = new List <Order>() { order }; account = await accountsRepository.AddAsync(account); try { //Act await orderService.UpdateStaus(account.AccountId, account.Orders[0].EntityId, nextStatus); //Assert var statuses = ordersStatusRepository.GetAllStatusesForOrder(account.Orders[0].EntityId); Assert.Contains(statuses, s => s.Status == nextStatus); var orders = ordersRepository.GetAllOrdersForRegularUser(account.EntityId); Assert.Equal(orders[0].LatestOrderStatus, nextStatus); } finally { //Clear accountsRepository.Remove(account); accountsRepository.Remove(owner); } }
private async Task <Restaurant> GetRestaurant() { var owner = await GetOwner(); var restaurnt = EntitiesCreationService.GetRestaurant(); restaurnt.OwnerId = owner.AccountId; return(await restaurantsRepository.AddAsync(restaurnt)); }
private async Task <Order> GetNewOrder() { var user = await GetUser(); var restaurant = await GetRestaurant(); var order = EntitiesCreationService.GetOrder(); order.RestaurantId = restaurant.EntityId; order.CustomerId = user.EntityId; return(order); }
public async Task UpdateStausTestNegative(AccountRoles accountRole, OrderStatuses previousOrderStatus, OrderStatuses nextStatus) { //Arrange var owner = EntitiesCreationService.GetOwner(); owner.HashedPassword = "******"; var restaurant = EntitiesCreationService.GetRestaurant(); owner.Restaurants = new List <Restaurant>() { restaurant }; owner = await accountsRepository.AddAsync(owner); var account = EntitiesCreationService.GetOwner(); account.HashedPassword = "******"; account.Role = accountRole; var order = EntitiesCreationService.GetOrder(); var orderStatus = EntitiesCreationService.GetOrderStatus(); orderStatus.Status = previousOrderStatus; order.OrderStatuses = new List <OrderStatus>() { orderStatus }; order.RestaurantId = owner.Restaurants[0].RestaurantId; account.Orders = new List <Order>() { order }; account = await accountsRepository.AddAsync(account); try { //Act //Assert await Assert.ThrowsAnyAsync <Exception>(async() => await orderService.UpdateStaus(account.AccountId, account.Orders[0].EntityId, nextStatus)); } finally { //Clear accountsRepository.Remove(account); } }
private async Task <Account> GetOwner() { var owner = EntitiesCreationService.GetOwner(); return(await accountsRepository.AddAccount(owner, "password")); }
public async Task TestGetAllAvailableRestaurantsForUser() { //Arrange var owner1 = EntitiesCreationService.GetOwner("BlockerOwner1"); owner1.HashedPassword = "******"; var restaurant1Owner1 = EntitiesCreationService.GetRestaurant(); var restaurant2Owner1 = EntitiesCreationService.GetRestaurant(); owner1.Restaurants = new List <Restaurant>() { restaurant1Owner1, restaurant2Owner1 }; var owner2 = EntitiesCreationService.GetOwner("BlockerOwner2"); owner2.HashedPassword = "******"; var restaurant1Owner2 = EntitiesCreationService.GetRestaurant(); var restaurant2Owner2 = EntitiesCreationService.GetRestaurant(); owner2.Restaurants = new List <Restaurant>() { restaurant1Owner2, restaurant2Owner2 }; var user1 = EntitiesCreationService.GetUser("BlockingUser1"); user1.HashedPassword = "******"; var user2 = EntitiesCreationService.GetUser("BlockingUser2"); user2.HashedPassword = "******"; user1 = await accountsRepository.AddAsync(user1); user2 = await accountsRepository.AddAsync(user2); owner1 = await accountsRepository.AddAsync(owner1); owner2 = await accountsRepository.AddAsync(owner2); await accountsService.BanUser(owner1.AccountId, user1.UserName); await accountsService.BanUser(owner2.AccountId, user2.UserName); try { //Act var firstRestaurants = accountsService.GetAllAvailableRestaurantsForUser(user1.AccountId); var secondRestaurants = accountsService.GetAllAvailableRestaurantsForUser(user2.AccountId); //Assert Assert.DoesNotContain(firstRestaurants, fr => fr.EntityId == owner1.Restaurants[0].EntityId || fr.EntityId == owner1.Restaurants[1].EntityId); Assert.DoesNotContain(secondRestaurants, sr => sr.EntityId == owner2.Restaurants[0].EntityId || sr.EntityId == owner2.Restaurants[1].EntityId); Assert.Contains(firstRestaurants, fr => fr.EntityId == owner2.Restaurants[0].EntityId || fr.EntityId == owner2.Restaurants[1].EntityId); Assert.Contains(secondRestaurants, sr => sr.EntityId == owner1.Restaurants[0].EntityId || sr.EntityId == owner1.Restaurants[1].EntityId); } finally { //Clean accountsRepository.Remove(user1); accountsRepository.Remove(owner1); accountsRepository.Remove(user2); accountsRepository.Remove(owner2); } }