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 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 KitchenUserServiceUnitTest()
{
_testUser = InMemoryDataGenerator.TestUser;
_context = InMemoryDataGenerator.CreateAndInitializeInMemoryDatabaseContext(Guid.NewGuid().ToString(), _testUser, insertIngredientData: false);
_kitchenUserService = new KitchenUserService(_context);
}
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 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 void AcceptInviteToKitchen_InvalidKitchen_ThrowsKitchenNotFoundException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
Assert.Throws <KitchenNotFoundException>(() =>
{
_kitchenUserService.AcceptInviteToKitchenByKitchenId(-5, newUser);
});
}
public void InviteUserToKitchenByUsername_InvalidKitchenId_ThrowsKitchenNotFoundException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
Assert.Throws <KitchenNotFoundException>(() =>
{
_kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, -5, _testUser);
});
}
public void InviteUserToKitchenByUsername_NullKitchen_ThrowsArgumentNullException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
Assert.Throws <ArgumentNullException>(() =>
{
_kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, null, _testUser);
});
}
public KitchenServiceUnitTest()
{
_testUser = new PantryPlannerUser()
{
Id = "Constructor123",
UserName = "******",
Email = "*****@*****.**"
};
_context = InMemoryDataGenerator.CreateAndInitializeInMemoryDatabaseContext(Guid.NewGuid().ToString(), _testUser, insertIngredientData: false);
_kitchenService = new KitchenService(_context);
}
public void AcceptInviteToKitchen_NoKitchenInvite_ThrowsInviteNotFoundException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
// get valid kitchen from test user
Kitchen kitchen = _testUser.KitchenUser.FirstOrDefault()?.Kitchen;
Assert.Throws <InviteNotFoundException>(() =>
{
_kitchenUserService.AcceptInviteToKitchen(kitchen, newUser);
});
}
public void DenyInviteToKitchen_NoInviteExists_ThrowsInviteNotFoundException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
Kitchen kitchenToJoin = _testUser.KitchenUser.FirstOrDefault().Kitchen;
Assert.Throws <InviteNotFoundException>(() =>
{
_kitchenUserService.DenyInviteToKitchen(kitchenToJoin, newUser);
});
}
public async Task AddIngredientToKitchen_KitchenNotExists_ReturnsNotFound()
{
Ingredient newIngredient = InMemoryDataGenerator.AddNewRandomIngredient(_context, _userManager.TestUser);
if (newIngredient == null)
{
throw new Exception("not setup for testing");
}
ActionResult <KitchenIngredientDto> actualResult = await _controller.AddIngredientToKitchenAsync(-5, newIngredient.IngredientId);
Assert.IsType <NotFoundObjectResult>(actualResult.Result);
}
public AccountServiceUnitTests()
{
_testUser = InMemoryDataGenerator.TestUser;
_context = InMemoryDataGenerator.CreateAndInitializeInMemoryDatabaseContext(Guid.NewGuid().ToString(), _testUser, insertIngredientData: false);
_userManager = UserManagerMock.MockUserManager <PantryPlannerUser>().Object;
_signInManager = new SignInManager <PantryPlannerUser>(_userManager
, new Mock <IHttpContextAccessor>().Object
, new Mock <IUserClaimsPrincipalFactory <PantryPlannerUser> >().Object
, new Mock <IOptions <IdentityOptions> >().Object
, new Mock <ILogger <SignInManager <PantryPlannerUser> > >().Object
, new Mock <IAuthenticationSchemeProvider>().Object);
_service = new AccountService(_userManager, _signInManager, null);
}
public void InviteUserToKitchenByUsername_ValidUserName_ReturnsTrue()
{
// 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 actualResult = _kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, kitchen, _testUser);
Assert.True(actualResult);
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
//find service layer in the scope
var services = scope.ServiceProvider;
//get the instance of DBContext service layers
var context = services.GetRequiredService <EdlizContext>();
//initialise data in memory
InMemoryDataGenerator.Initialise(services);
}
host.Run();
}
public async Task InviteUserToKitchen_ValidKitchen_ReturnsOKAndInviteSent()
{
PantryPlannerUser userToInvite = InMemoryDataGenerator.AddNewRandomUser(_context);
Kitchen kitchen = _userManager.TestUser.KitchenUser.FirstOrDefault()?.Kitchen;
if (userToInvite == null || kitchen == null)
{
throw new Exception("user or kitchen is not setup for testing");
}
ActionResult inviteResult = await _controller.InviteUserToKitchen(userToInvite.UserName, kitchen.KitchenId);
Assert.IsType <OkResult>(inviteResult);
Assert.True(_context.KitchenUser.Any(k => k.KitchenId == kitchen.KitchenId && k.UserId == userToInvite.Id && !k.HasAcceptedInvite.Value));
}
public async void UpdateKitchenIngredient_UserNoRights_ThrowsPermissionsException()
{
Kitchen kitchen = _testUser.KitchenUser.FirstOrDefault().Kitchen;
KitchenIngredient ingredient = kitchen.KitchenIngredient.FirstOrDefault();
PantryPlannerUser otherUserTryingToUpdate = InMemoryDataGenerator.AddNewRandomUser(_context);
if (ingredient == null || kitchen == null || otherUserTryingToUpdate == null)
{
throw new ArgumentNullException("ingredient, kitchen, or user is not setup for testing");
}
await Assert.ThrowsAsync <PermissionsException>(async() =>
{
await _service.UpdateKitchenIngredientAsync(ingredient, otherUserTryingToUpdate);
});
}
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 void InviteUserToKitchenByUsername_NotInKitchen_ThrowsPermissionsException()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
List <long> myKitchenIds = _testUser.KitchenUser.Select(k => k.KitchenId).Distinct().ToList();
Kitchen notMyKitchen = _context.Kitchen.Where(k => myKitchenIds.Contains(k.KitchenId) == false).FirstOrDefault();
if (notMyKitchen == null)
{
throw new Exception("kitchen is not setup for testing");
}
Assert.Throws <PermissionsException>(() =>
{
_kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, notMyKitchen.KitchenId, _testUser);
});
}
public void AcceptInviteToKitchen_ValidKitchen_ReturnsTrue()
{
// add random user to test against
PantryPlannerUser newUser = InMemoryDataGenerator.AddNewRandomUser(_context);
Kitchen kitchenToJoin = _testUser.KitchenUser.FirstOrDefault()?.Kitchen;
if (kitchenToJoin == null)
{
throw new Exception("kitchen is not setup for testing");
}
// send invite for new user
_kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, kitchenToJoin.KitchenId, _testUser);
// have new user accept invite
_kitchenUserService.AcceptInviteToKitchen(kitchenToJoin, newUser);
}
public void GetMyInvites_ValidUser_ReturnsCorrectResult()
{
// 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 inviteResult = _kitchenUserService.InviteUserToKitchenByUsername(newUser.UserName, kitchen, _testUser);
List <KitchenUser> actualResult = _kitchenUserService.GetMyInvites(newUser);
Assert.True(actualResult.Count == 1);
Assert.True(actualResult[0].KitchenId == kitchen.KitchenId);
}
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 static void Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
//1. Get the IWebHost which will host this application.
var host = CreateHostBuilder(args).Build();
//2. Find the service layer within our scope.
using (var scope = host.Services.CreateScope())
{
//3. Get the instance of BoardGamesDBContext in our services layer
var services = scope.ServiceProvider;
//var context = services.GetRequiredService<LifeBoatMediatRDbContext>();
//4. Call the DataGenerator to create sample data
InMemoryDataGenerator.Initialize(services);
}
//Continue to run the application
host.Run();
}
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 KitchenUserControllerUnitTest()
{
_userManager = new FakeUserManager();
_context = InMemoryDataGenerator.CreateAndInitializeInMemoryDatabaseContext(Guid.NewGuid().ToString(), _userManager.TestUser, insertIngredientData: false);
_controller = new PantryPlanner.Controllers.KitchenUserController(_context, _userManager);
}
public FoodCompositionETLUnitTest()
{
_context = InMemoryDataGenerator.CreateInMemoryDatabaseContext("FoodCompositionETLUnitTestDB");
_etl = new USDAFoodCompositionDbETL(FoodCompositionFolderLocation);
}
