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);
}
