public void DeleteKitchenUserByKitchenUserId_ValidKitchenUser_ReturnsDeletedUser() { KitchenUser myKitchenUser = _testUser.KitchenUser.Where(u => u.IsOwner).FirstOrDefault(); if (myKitchenUser == null) { throw new Exception("kKitchenUser is not setup for testing"); } var newUser = InMemoryDataGenerator.AddNewRandomUser(_context); _kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, myKitchenUser.Kitchen, _testUser); _kitchenUserService.AcceptInviteToKitchenByKitchenId(myKitchenUser.KitchenId, newUser); KitchenUser expectedUserToDelete = myKitchenUser.Kitchen.KitchenUser.Where(u => u.UserId == newUser.Id).FirstOrDefault(); if (expectedUserToDelete == null) { throw new Exception("expectedUserToDelete is not setup for testing"); } KitchenUser actualDeletedUser = _kitchenUserService.OwnerDeleteKitchenUserByKitchenUserId(expectedUserToDelete.KitchenUserId, _testUser); Assert.Equal(expectedUserToDelete, actualDeletedUser); }
public bool DenyInviteToKitchen(long kitchenId, PantryPlannerUser user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (Context.KitchenExists(kitchenId) == false) { throw new KitchenNotFoundException(kitchenId); } if (Context.UserExists(user.Id) == false) { throw new UserNotFoundException(user.UserName); } KitchenUser inviteToDeny = user.KitchenUser.Where(k => k.KitchenId == kitchenId && k.UserId == user.Id && k.HasAcceptedInvite.Value == false).FirstOrDefault(); if (inviteToDeny == null) { throw new InviteNotFoundException("No invite found for kitchen."); } Context.KitchenUser.Remove(inviteToDeny); Context.SaveChangesAsync(); return(true); }
public async Task AddKitchenIngredient_ValidKitchenIngredient_ReturnsOkAndNewKitchenIngredient() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); Ingredient newIngredient = InMemoryDataGenerator.AddNewRandomIngredient(_context, _userManager.TestUser); if (kitchenUser == null || newIngredient == null) { throw new Exception("not setup for testing"); } KitchenIngredientDto kitchenIngredient = new KitchenIngredientDto() { KitchenId = kitchenUser.Kitchen.KitchenId, IngredientId = newIngredient.IngredientId, AddedByKitchenUserId = kitchenUser.KitchenUserId }; ActionResult <KitchenIngredientDto> actualResult = await _controller.AddKitchenIngredientAsync(kitchenIngredient); Assert.IsType <OkObjectResult>(actualResult.Result); var actualIngredientsInKitchen = (actualResult.Result as OkObjectResult).Value; Assert.IsType <KitchenIngredientDto>(actualIngredientsInKitchen); }
public async Task AddKitchenIngredient_DuplicateKitchenIngredient_Returns405Result() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); Ingredient newIngredient = InMemoryDataGenerator.AddNewRandomIngredient(_context, _userManager.TestUser); if (kitchenUser == null || newIngredient == null) { throw new Exception("not setup for testing"); } KitchenIngredientDto kitchenIngredient = new KitchenIngredientDto() { KitchenId = kitchenUser.Kitchen.KitchenId, IngredientId = newIngredient.IngredientId, AddedByKitchenUserId = kitchenUser.KitchenUserId }; // add it once await _controller.AddKitchenIngredientAsync(kitchenIngredient); // add it again ActionResult <KitchenIngredientDto> actualResult = await _controller.AddKitchenIngredientAsync(kitchenIngredient); Assert.IsType <ObjectResult>(actualResult.Result); Assert.Equal(StatusCodes.Status405MethodNotAllowed, (actualResult.Result as ObjectResult).StatusCode); }
public async Task UpdateKitchenIngredientAsync_ValidKitchenIngredient_ReturnsOkAndOnlyUpdatesQty() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); KitchenIngredient ingredientToUpdate = kitchenUser?.Kitchen.KitchenIngredient.FirstOrDefault(); if (ingredientToUpdate == null) { throw new Exception("not setup for testing"); } KitchenIngredientDto updateDto = new KitchenIngredientDto(ingredientToUpdate); string noteBeforeUpdate = ingredientToUpdate.Note; int expectedQty = 5; updateDto.Note = null; updateDto.Quantity = expectedQty; DateTime timeBeforeUpdate = DateTime.UtcNow; var updateResult = await _controller.UpdateKitchenIngredientAsync(updateDto.KitchenIngredientId, updateDto); KitchenIngredient updatedIngredient = _context.KitchenIngredient.Where(ki => ki.KitchenIngredientId == updateDto.KitchenIngredientId).FirstOrDefault(); Assert.IsType <OkResult>(updateResult); Assert.Equal(noteBeforeUpdate, updatedIngredient.Note); Assert.Equal(expectedQty, updatedIngredient.Quantity); Assert.True(updatedIngredient.LastUpdated >= timeBeforeUpdate); }
/// <summary> /// Creates users and adds them to already existing kitchens. /// </summary> /// <param name="context"> create users using this DbContext and adds them Kitchens in it </param> /// <param name="numOfUsersToAddPerKitchen"> amount of users to add per Kitchen </param> internal static void AddNewRandomUsersToKitchens(PantryPlannerContext context, int numOfUsersToAddPerKitchen) { if (context.Kitchen.Count() == 0) { throw new Exception("Cannot add users because Kitchen is not populated"); } Random randGenerator = new Random(); foreach (Kitchen kitchen in context.Kitchen) { bool hasAccepted = true; // this will guarantee that atleast one new user has accepted the Invite (i.e. HasAcceptedInvite = true) for (int i = 0; i < numOfUsersToAddPerKitchen; i++) { PantryPlannerUser newUser = AddNewRandomUser(context); KitchenUser newKitchenUser = new KitchenUser() { KitchenId = kitchen.KitchenId, UserId = newUser.Id, DateAdded = DateTime.Now, IsOwner = false, HasAcceptedInvite = hasAccepted }; context.KitchenUser.Add(newKitchenUser); context.SaveChanges(); hasAccepted = (randGenerator.Next(0, 2) == 0); } } }
public async Task DeleteKitchenUserByKitchenUserId_ValidKitchenAndUser_ReturnsDeletedUser() { // generate test data to ensure atleast 1 user is in kitchen that can be removed InMemoryDataGenerator.AddNewRandomUsersToKitchens(_context, 1); Kitchen myKitchen = _userManager.TestUser.KitchenUser.Where(k => k.IsOwner).FirstOrDefault()?.Kitchen; // find a user in the kitchen to delete (that is not the test user) KitchenUser userToDelete = myKitchen?.KitchenUser.Where(k => k.UserId != _userManager.TestUser.Id && !k.IsOwner).FirstOrDefault(); if (userToDelete == null) { throw new Exception("user not setup for testing"); } int countBeforeDelete = myKitchen.KitchenUser.Count; ActionResult <KitchenUserDto> deleteResult = await _controller.DeleteKitchenUserByKitchenUserId(userToDelete.KitchenUserId); Assert.IsType <OkObjectResult>(deleteResult.Result); KitchenUserDto deletedKitchen = (deleteResult.Result as OkObjectResult).Value as KitchenUserDto; Assert.Equal(countBeforeDelete - 1, myKitchen.KitchenUser.Count); Assert.Equal(new KitchenUserDto(userToDelete).ToString(), deletedKitchen.ToString()); Assert.Equal(new KitchenUserDto(userToDelete).UserId, deletedKitchen.UserId); Assert.Equal(new KitchenUserDto(userToDelete).KitchenId, deletedKitchen.KitchenId); }
public async Task AddIngredientToKitchen_IngredientNotExists_ReturnsNotFound() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); if (kitchenUser == null) { throw new Exception("not setup for testing"); } ActionResult <KitchenIngredientDto> actualResult = await _controller.AddIngredientToKitchenAsync(kitchenUser.KitchenId, -5); Assert.IsType <NotFoundObjectResult>(actualResult.Result); }
/// <summary> /// Creates two Kitchens for <paramref name="testUser"/> and adds the correct KitchenUser data for the <paramref name="testUser"/>. /// The <paramref name="testUser"/> will own one kitchen, and NOT own the second. /// </summary> internal static void InitializeKitchenAndKitchenUserForUser(PantryPlannerContext context, PantryPlannerUser testUser) { // generate kitchen and KitchenUser relationship for test user passed in Kitchen testKitchen = new Kitchen() { Name = $"Kitchen for {testUser.UserName}", Description = "auto created for testing", CreatedByUserId = testUser.Id, DateCreated = DateTime.Now, UniquePublicGuid = Guid.NewGuid() }; Kitchen notOwnedKitchen = new Kitchen() { Name = $"NOT OWNED Kitchen for {testUser.UserName}", Description = "auto created for testing", CreatedByUserId = null, DateCreated = DateTime.Now, UniquePublicGuid = Guid.NewGuid() }; context.Kitchen.Add(testKitchen); context.Kitchen.Add(notOwnedKitchen); KitchenUser testKitchenUser = new KitchenUser() { KitchenId = testKitchen.KitchenId, UserId = testUser.Id, DateAdded = DateTime.Now, IsOwner = true, HasAcceptedInvite = true }; KitchenUser notOwnerKitchenUser = new KitchenUser() { KitchenId = notOwnedKitchen.KitchenId, UserId = testUser.Id, DateAdded = DateTime.Now, IsOwner = false, HasAcceptedInvite = true }; context.KitchenUser.Add(testKitchenUser); context.KitchenUser.Add(notOwnerKitchenUser); context.SaveChanges(); return; }
public void DeleteKitchenUserFromKitchenByUsername_NotOwnerDelete_ThrowsPermissionsException() { KitchenUser notMyKitchenUser = _testUser.KitchenUser.Where(u => !u.IsOwner).FirstOrDefault(); if (notMyKitchenUser == null) { throw new Exception("KitchenUser is not setup for testing"); } Assert.Throws <PermissionsException>(() => { _kitchenUserService.DeleteKitchenUserFromKitchenByUsername(notMyKitchenUser.Kitchen, _testUser.UserName, _testUser); }); }
public void DeleteKitchenUserFromKitchenByUsername_DeleteMyself_ThrowsInvalidOperationException() { KitchenUser myKitchenUser = _testUser.KitchenUser.Where(u => u.IsOwner).FirstOrDefault(); if (myKitchenUser == null) { throw new Exception("kKitchenUser is not setup for testing"); } Assert.Throws <InvalidOperationException>(() => { _kitchenUserService.DeleteKitchenUserFromKitchenByUsername(myKitchenUser.KitchenId, _testUser.UserName, _testUser); }); }
private bool UpdateKitchenUser(KitchenUser kitchenUser, PantryPlannerUser userEditing) { if (kitchenUser == null) { throw new ArgumentNullException(nameof(kitchenUser)); } if (!Permissions.UserHasRightsToKitchen(userEditing, kitchenUser.KitchenId)) { throw new PermissionsException(); } Context.Entry(kitchenUser).State = EntityState.Modified; Context.SaveChanges(); return(true); }
public KitchenUserDto(KitchenUser user) { if (user == null) { return; } KitchenUserId = user.KitchenUserId; UserId = user.UserId; KitchenId = user.KitchenId; IsOwner = user.IsOwner; DateAdded = user.DateAdded; HasAcceptedInvite = user.HasAcceptedInvite.Value; Username = user.User?.UserName; KitchenName = user.Kitchen?.Name; }
public async Task UpdateKitchenIngredientAsync_KitchenIngredientNotExists_ReturnsNotFound() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); KitchenIngredient ingredientToUpdate = kitchenUser?.Kitchen.KitchenIngredient.FirstOrDefault(); if (ingredientToUpdate == null) { throw new Exception("not setup for testing"); } KitchenIngredientDto updateDto = new KitchenIngredientDto(ingredientToUpdate); updateDto.KitchenIngredientId = -5; var updateResult = await _controller.UpdateKitchenIngredientAsync(updateDto.KitchenIngredientId, updateDto); Assert.IsType <NotFoundObjectResult>(updateResult); }
public void DeleteMyselfFromKitchen_OnlyOneUserInKitchen_ThrowsInvalidOperationException() { InMemoryDataGenerator.InitializeKitchenAndKitchenUserForUser(_context, _testUser); KitchenUser expectedResult = _testUser.KitchenUser.Where(k => k.Kitchen.KitchenUser.Count == 1 && k.IsOwner == false).FirstOrDefault(); Kitchen notOwnedKitchen = expectedResult?.Kitchen; if (notOwnedKitchen == null) { throw new Exception("kitchen not setup for testing"); } Assert.Throws <InvalidOperationException>(() => { _kitchenUserService.DeleteMyselfFromKitchen(notOwnedKitchen, _testUser); }); }
public async Task DeleteKitchenIngredient_ValidKitchenIngredient_ReturnsOkAndDeletedKitchenIngredient() { KitchenUser kitchenUser = _userManager.TestUser.KitchenUser.FirstOrDefault(); KitchenIngredient ingredientToDelete = kitchenUser?.Kitchen.KitchenIngredient.FirstOrDefault(); if (ingredientToDelete == null) { throw new Exception("not setup for testing"); } var deleteResult = await _controller.DeleteKitchenIngredientAsync(ingredientToDelete.KitchenIngredientId); Assert.IsType <OkObjectResult>(deleteResult.Result); var actualDeletedIngredient = (deleteResult.Result as OkObjectResult).Value; Assert.IsType <KitchenIngredientDto>(actualDeletedIngredient); Xunit.Asserts.Compare.DeepAssert.Equals(new KitchenIngredientDto(ingredientToDelete), (actualDeletedIngredient as KitchenIngredientDto)); }
public void InviteUserToKitchenByUsername_ValidUserName_KitchenUserIsAdded() { // add random user to test against PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context); Kitchen kitchen = _testUser.KitchenUser.FirstOrDefault()?.Kitchen; if (kitchen == null) { throw new Exception("kitchen is not setup for testing"); } bool result = _kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, kitchen, _testUser); KitchenUser actualResult = _context.KitchenUser .Where(u => u.UserId == newUser.Id && u.KitchenId == kitchen.KitchenId && u.HasAcceptedInvite == false && u.IsOwner == false) .FirstOrDefault(); Assert.True(actualResult != null); }
public KitchenUser DeleteKitchenUserFromKitchen(long kitchenId, string userId, PantryPlannerUser userDeleting) { if (Context.KitchenExists(kitchenId) == false) { throw new KitchenNotFoundException(kitchenId); } if (Context.UserExists(userId) == false) { throw new UserNotFoundException(userId); } KitchenUser userToDelete = Context.KitchenUser.Where(k => k.KitchenId == kitchenId && k.UserId == userId).FirstOrDefault(); if (userToDelete == null) { throw new KitchenUserNotFoundException(); } return(OwnerDeleteKitchenUserByKitchenUserId(userToDelete.KitchenUserId, userDeleting)); }
public KitchenUser DeleteMyselfFromKitchen(Kitchen kitchen, PantryPlannerUser user) { if (kitchen == null) { throw new ArgumentNullException(nameof(user)); } if (user == null) { throw new ArgumentNullException(nameof(user)); } if (Context.KitchenUserExists(kitchen.KitchenId, user.Id) == false) { throw new KitchenUserNotFoundException(); } KitchenUser kitchenUser = user.KitchenUser.Where(ku => ku.KitchenId == kitchen.KitchenId).FirstOrDefault(); return(DeleteMyselfFromKitchenByKitchenUserId(kitchenUser.KitchenUserId, user)); }
public bool AcceptInviteToKitchenByKitchenId(long kitchenId, PantryPlannerUser userAccepting) { if (userAccepting == null) { throw new ArgumentNullException("user is null"); } if (Context.KitchenExists(kitchenId) == false) { throw new KitchenNotFoundException(kitchenId); } KitchenUser kitchenToAccept = Context.KitchenUser.Where(k => k.KitchenId == kitchenId && k.UserId == userAccepting.Id && k.HasAcceptedInvite.Value == false).FirstOrDefault(); if (kitchenToAccept == null) { throw new InviteNotFoundException(kitchenId); } kitchenToAccept.HasAcceptedInvite = true; return(UpdateKitchenUser(kitchenToAccept, userAccepting)); }
/// <summary> /// Loop over every Kitchen available and add a random amount of ingredients to each one /// </summary> internal static void InitializeKitchenIngredients(PantryPlannerContext context) { if (context.Ingredient.Count() == 0) { throw new Exception("Ingredient must be populated to initialize"); } Random randomGen = new Random(); foreach (Kitchen kitchen in context.Kitchen) { int numOfIngredientsToAdd = randomGen.Next(1, 25); int randomOffset = randomGen.Next(100); KitchenUser someUserInKitchen = kitchen.KitchenUser.FirstOrDefault(); for (int i = 0; i < numOfIngredientsToAdd; i++) { Ingredient ingredient = context.Ingredient.Skip(randomOffset)?.ToList()[i]; if (ingredient == null) { break; } KitchenIngredient kitchenIngredient = new KitchenIngredient() { KitchenId = kitchen.KitchenId, IngredientId = ingredient.IngredientId, LastUpdated = DateTime.Now, AddedByKitchenUserId = someUserInKitchen?.KitchenUserId }; context.KitchenIngredient.Add(kitchenIngredient); } } context.SaveChanges(); }
public void DeleteMyselfFromKitchen_ValidKitchenUser_ReturnsKitchenUser() { KitchenUser expectedResult = _testUser.KitchenUser.Where(k => k.IsOwner == false).FirstOrDefault(); int kitchenCountBefore = _testUser.KitchenUser.Count; Kitchen notOwnedKitchen = expectedResult?.Kitchen; if (notOwnedKitchen == null) { throw new Exception("kitchen not setup for testing"); } // ensure a another user is in Kitchen var newUser = InMemoryDataGenerator.AddNewRandomUser(_context); _kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, notOwnedKitchen, _testUser); _kitchenUserService.AcceptInviteToKitchen(notOwnedKitchen, newUser); KitchenUser actualResult = _kitchenUserService.DeleteMyselfFromKitchen(notOwnedKitchen, _testUser); Assert.Equal(expectedResult, actualResult); Assert.Equal(kitchenCountBefore - 1, _testUser.KitchenUser.Count); }
public async Task <bool> AddKitchenAsync(Kitchen kitchen, PantryPlannerUser user) { if (kitchen == null) { throw new ArgumentNullException(nameof(kitchen)); } if (user == null) { throw new ArgumentNullException(nameof(user)); } if (Context.UserExists(user.Id) == false) { throw new UserNotFoundException(user.UserName); } // add the kitchen kitchen.CreatedByUserId = user.Id; kitchen.DateCreated = DateTime.Now; kitchen.UniquePublicGuid = Guid.NewGuid(); Context.Kitchen.Add(kitchen); try { await Context.SaveChangesAsync(); } catch (Exception) { if (Context.KitchenExists(kitchen.KitchenId)) { throw new Exception("Kitchen already exists"); } else { throw; } } // create relationship between user and new kitchen KitchenUser kitchenUser = new KitchenUser() { KitchenId = kitchen.KitchenId, UserId = user.Id, User = user, Kitchen = kitchen, DateAdded = DateTime.Now, IsOwner = true, // the user that created the kitchen is the owner HasAcceptedInvite = true }; Context.KitchenUser.Add(kitchenUser); try { await Context.SaveChangesAsync(); } catch (Exception) { if (Context.KitchenExists(kitchen.KitchenId)) { throw new Exception("Kitchen already exists"); } else { throw; } } return(true); }