public async Task MoveToSameHeap()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var lastLearnTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : lastLearnTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, 1, card.Id.AsArray()));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(1, cardInDeck.CurrentHeap);
Assert.AreEqual(lastLearnTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(lastLearnTime.AddDays(1), cardInDeck.ExpiryUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(1, cardInDeck.BiggestHeapReached);
}
}
public async Task CardWithPreviousVersion()
{
var db = DbHelper.GetEmptyTestDB();
var language = await CardLanguagHelper.CreateAsync(db);
var firstVersionCreatorId = await UserHelper.CreateInDbAsync(db);
var firstVersionDate = RandomHelper.Date();
var card = await CardHelper.CreateAsync(db, firstVersionCreatorId, language : language, versionDate : firstVersionDate);
var lastVersionCreatorName = RandomHelper.String();
var lastVersionCreatorId = await UserHelper.CreateInDbAsync(db, userName : lastVersionCreatorName);
var lastVersionDate = RandomHelper.Date();
var lastVersionDescription = RandomHelper.String();
var lastVersionFrontSide = RandomHelper.String();
using (var dbContext = new MemCheckDbContext(db))
await new UpdateCard(dbContext.AsCallContext(), lastVersionDate).RunAsync(UpdateCardHelper.RequestForFrontSideChange(card, lastVersionFrontSide, versionCreator: lastVersionCreatorId, versionDescription: lastVersionDescription));
var otherUserId = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
{
var loaded = await new GetCardForEdit(dbContext.AsCallContext()).RunAsync(new GetCardForEdit.Request(otherUserId, card.Id));
Assert.AreEqual(firstVersionDate, loaded.FirstVersionUtcDate);
Assert.AreEqual(lastVersionDate, loaded.LastVersionUtcDate);
Assert.AreEqual(lastVersionCreatorName, loaded.LastVersionCreatorName);
Assert.AreEqual(lastVersionDescription, loaded.LastVersionDescription);
Assert.AreEqual(lastVersionFrontSide, loaded.FrontSide);
}
}
public async Task Complex()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var tag1 = await TagHelper.CreateAsync(db);
var card1 = await CardHelper.CreateAsync(db, user, tagIds : tag1.AsArray());
await DeckHelper.AddCardAsync(db, deck, card1.Id);
var tag2 = await TagHelper.CreateAsync(db);
var card2 = await CardHelper.CreateAsync(db, user, tagIds : tag2.AsArray());
await DeckHelper.AddCardAsync(db, deck, card2.Id);
var card3 = await CardHelper.CreateAsync(db, user, tagIds : new[] { tag1, tag2 });
await DeckHelper.AddCardAsync(db, deck, card3.Id);
var card4 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card4.Id);
using var dbContext = new MemCheckDbContext(db);
var request = new GetTagsOfDeck.Request(user, deck);
var result = await new GetTagsOfDeck(dbContext).RunAsync(request);
Assert.AreEqual(2, result.Count());
Assert.IsTrue(result.Any(t => t.TagId == tag1));
Assert.IsTrue(result.Any(t => t.TagId == tag2));
}
public async Task Ratings()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUser = await UserHelper.CreateInDbAsync(db);
var userToDelete = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, userToDelete);
using (var dbContext = new MemCheckDbContext(db))
{
await new SetCardRating(dbContext.AsCallContext()).RunAsync(new SetCardRating.Request(loggedUser, card.Id, 3));
await new SetCardRating(dbContext.AsCallContext()).RunAsync(new SetCardRating.Request(userToDelete, card.Id, 3));
}
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDelete));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.IsFalse(await dbContext.UserCardRatings.AnyAsync(rating => rating.UserId == userToDelete));
Assert.IsTrue(await dbContext.UserCardRatings.AnyAsync(rating => rating.UserId == loggedUser));
}
}
public async Task PrivateCardDeleted()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUser = await UserHelper.CreateInDbAsync(db);
var language = await CardLanguagHelper.CreateAsync(db);
var userToDelete = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, userToDelete, language : language); //Public
await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForVisibilityChange(card, userWithViewIds: userToDelete.AsArray())); //Private
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDelete));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.IsFalse(dbContext.Cards.Any());
Assert.IsFalse(dbContext.CardPreviousVersions.Any());
}
}
public async Task TwoCardsWithLanguages()
{
var db = DbHelper.GetEmptyTestDB();
var french = await CardLanguagHelper.CreateAsync(db, "Français");
var otherLanguage = await CardLanguagHelper.CreateAsync(db, RandomHelper.String());
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var frenchCreatedCard = await CardHelper.CreateAsync(db, user, language : french);
var otherLanguageCard = await CardHelper.CreateAsync(db, user, language : otherLanguage);
await DeckHelper.AddNeverLearntCardAsync(db, deck, frenchCreatedCard.Id);
await DeckHelper.AddNeverLearntCardAsync(db, deck, otherLanguageCard.Id);
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 10);
var cards = await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request);
Assert.IsTrue(cards.Cards.Single(card => card.CardId == frenchCreatedCard.Id).IsInFrench);
Assert.IsFalse(cards.Cards.Single(card => card.CardId == otherLanguageCard.Id).IsInFrench);
}
public async Task UsedInCards()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var name = RandomHelper.String();
var source = RandomHelper.String();
var description = RandomHelper.String();
var uploadDate = RandomHelper.Date();
var versionDescription = RandomHelper.String();
var image = await ImageHelper.CreateAsync(db, user, name : name, source : source, description : description, lastChangeUtcDate : uploadDate, versionDescription : versionDescription);
var otherImage = await ImageHelper.CreateAsync(db, user);
await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image, otherImage });
await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image });
await CardHelper.CreateAsync(db, user, frontSideImages : new[] { otherImage });
using var dbContext = new MemCheckDbContext(db);
var loaded = await new GetImageInfoFromId(dbContext.AsCallContext()).RunAsync(new GetImageInfoFromId.Request(image));
Assert.AreEqual(user, loaded.Owner.Id);
Assert.AreEqual(name, loaded.Name);
Assert.AreEqual(description, loaded.Description);
Assert.AreEqual(source, loaded.Source);
Assert.AreEqual(2, loaded.CardCount);
Assert.AreEqual(uploadDate, loaded.InitialUploadUtcDate);
Assert.AreEqual(uploadDate, loaded.LastChangeUtcDate);
Assert.AreEqual(versionDescription, loaded.CurrentVersionDescription);
}
public async Task LearnMoveToUnknown()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 4);
var runTime = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, CardInDeck.UnknownHeap));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(CardInDeck.UnknownHeap, cardInDeck.CurrentHeap);
Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(2, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(4, cardInDeck.BiggestHeapReached);
Assert.AreEqual(DateTime.MinValue, cardInDeck.ExpiryUtcTime);
}
}
public async Task TestCardCountOnLastRun()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
var subscription = await SearchSubscriptionHelper.CreateAsync(testDB, userId);
using (var dbContext = new MemCheckDbContext(testDB))
await new UserSearchNotifier(dbContext.AsCallContext(), 100, new DateTime(2050, 05, 01)).RunAsync(subscription.Id);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new GetSearchSubscriptions.Request(userId);
var s = (await new GetSearchSubscriptions(dbContext.AsCallContext()).RunAsync(request)).Single();
Assert.AreEqual(0, s.CardCountOnLastRun);
}
await CardHelper.CreateAsync(testDB, userId);
await CardHelper.CreateAsync(testDB, userId);
await CardHelper.CreateAsync(testDB, userId);
await CardHelper.CreateAsync(testDB, userId);
using (var dbContext = new MemCheckDbContext(testDB))
await new UserSearchNotifier(dbContext.AsCallContext(), 100, new DateTime(2050, 05, 02)).RunAsync(subscription.Id);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new GetSearchSubscriptions.Request(userId);
var s = (await new GetSearchSubscriptions(dbContext.AsCallContext()).RunAsync(request)).Single();
Assert.AreEqual(4, s.CardCountOnLastRun);
}
}
public async Task LearnMoveUp()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : UnitTestsHeapingAlgorithm.ID);
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1);
var runTime = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 2));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(2, cardInDeck.CurrentHeap);
Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(2, cardInDeck.BiggestHeapReached);
Assert.AreEqual(runTime.AddDays(2), cardInDeck.ExpiryUtcTime);
}
}
public async Task LearnMoveToSameHeap()
{
//This could happen due to multiple sessions by the user
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var initialTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : initialTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), RandomHelper.Date(initialTime)).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 1));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(1, cardInDeck.CurrentHeap);
Assert.AreEqual(initialTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(1, cardInDeck.BiggestHeapReached);
Assert.AreEqual(initialTime.AddDays(1), cardInDeck.ExpiryUtcTime);
}
}
public async Task CardWithoutPreviousVersion_ToBeNotified_UsingApplicationDelete()
{
var db = GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(db, user, card.Id, new DateTime(2020, 11, 1));
await DeleteCardAsync(db, user, card.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 3);
using (var dbContext = new MemCheckDbContext(db))
{
var notifier = new UserCardDeletionsNotifier(dbContext.AsCallContext(), now);
var deletions = await notifier.RunAsync(user);
Assert.AreEqual(1, deletions.Length);
Assert.IsTrue(deletions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, deletions[0].FrontSide);
Assert.AreEqual(DeletionDescription, deletions[0].DeletionDescription);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user).LastNotificationUtcDate);
}
public async Task FailIfNotCreatorOfCurrentVersion()
{
var db = DbHelper.GetEmptyTestDB();
var firstVersionCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, firstVersionCreator, language : languageId);
var lastVersionCreator = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
await new UpdateCard(dbContext.AsCallContext()).RunAsync(UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), lastVersionCreator));
using (var dbContext = new MemCheckDbContext(db))
{
var deleter = new DeleteCards(dbContext.AsCallContext(new TestLocalizer(new System.Collections.Generic.KeyValuePair <string, string>("YouAreNotTheCreatorOfCurrentVersion", "YouAreNotTheCreatorOfCurrentVersion"))));
var e = await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await deleter.RunAsync(new DeleteCards.Request(firstVersionCreator, card.Id.AsArray())));
StringAssert.Contains(e.Message, "YouAreNotTheCreatorOfCurrentVersion");
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.AreEqual(card.Id, dbContext.Cards.Single().Id);
Assert.AreEqual(card.Id, dbContext.CardPreviousVersions.Single().Card);
}
}
public async Task MoveToZeroTwice()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var addTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 8, lastLearnUtcTime : addTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, CardInDeck.UnknownHeap, card.Id.AsArray()));
for (int i = 0; i < 2; i++)
{
using (var dbContext = new MemCheckDbContext(db))
{
var loadedCard = dbContext.CardsInDecks.Single();
Assert.AreEqual(CardInDeck.UnknownHeap, loadedCard.CurrentHeap);
Assert.AreEqual(addTime, loadedCard.LastLearnUtcTime);
Assert.AreEqual(DateTime.MinValue, loadedCard.ExpiryUtcTime);
Assert.AreEqual(2, loadedCard.NbTimesInNotLearnedHeap);
Assert.AreEqual(8, loadedCard.BiggestHeapReached);
}
}
}
public async Task UnknownCardsLearnt_CheckOrder()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID);
const int cardCount = 100;
for (int i = 0; i < cardCount; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, 0);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount);
var cards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.ToImmutableArray();
Assert.AreEqual(cardCount, cards.Length);
for (int i = 1; i < cards.Length; i++)
{
Assert.IsTrue(cards[i].LastLearnUtcTime >= cards[i - 1].LastLearnUtcTime);
}
}
public async Task CardToReportBecauseFirstRun()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user, versionDate : new DateTime(2050, 03, 01), userWithViewIds : user.AsArray());
var subscription = await SearchSubscriptionHelper.CreateAsync(db, user);
var runDate = new DateTime(2050, 05, 01);
using (var dbContext = new MemCheckDbContext(db))
{
var searchResult = await new UserSearchNotifier(dbContext.AsCallContext(), 100, runDate).RunAsync(subscription.Id);
Assert.AreEqual(1, searchResult.TotalNewlyFoundCardCount);
Assert.AreEqual(1, searchResult.NewlyFoundCards.Length);
Assert.AreEqual(0, searchResult.CountOfCardsNotFoundAnymore_StillExists_UserAllowedToView);
Assert.AreEqual(0, searchResult.CardsNotFoundAnymore_StillExists_UserAllowedToView.Length);
Assert.AreEqual(0, searchResult.CountOfCardsNotFoundAnymore_Deleted_UserAllowedToView);
Assert.AreEqual(0, searchResult.CardsNotFoundAnymore_Deleted_UserAllowedToView.Length);
Assert.AreEqual(0, searchResult.CountOfCardsNotFoundAnymore_StillExists_UserNotAllowedToView);
Assert.AreEqual(0, searchResult.CountOfCardsNotFoundAnymore_Deleted_UserNotAllowedToView);
var foundCard = searchResult.NewlyFoundCards.Single();
Assert.AreEqual(card.Id, foundCard.CardId);
Assert.AreEqual(card.FrontSide, foundCard.FrontSide);
Assert.AreEqual(card.VersionDescription, foundCard.VersionDescription);
Assert.AreEqual(card.VersionUtcDate, foundCard.VersionUtcDate);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(runDate, dbContext.SearchSubscriptions.Single(s => s.Id == subscription.Id).LastRunUtcDate);
}
public async Task OrderingOfNeverLearnt()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DefaultHeapingAlgorithm.ID);
var randomDate = RandomHelper.Date();
var cardAddedLater = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, cardAddedLater.Id, randomDate.AddDays(1));
for (int i = 0; i < 9; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, card.Id, randomDate);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 3);
var downloadedCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableHashSet();
Assert.IsFalse(downloadedCards.Contains(cardAddedLater.Id));
}
public async Task CardWithoutPreviousVersion_ToBeNotified()
{
var testDB = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user, new DateTime(2020, 11, 2));
await CardSubscriptionHelper.CreateAsync(testDB, user, card.Id, new DateTime(2020, 11, 1));
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 2)).RunAsync(user);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, versions[0].FrontSide);
Assert.AreEqual(card.VersionDescription, versions[0].VersionDescription);
Assert.IsNull(versions[0].VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user);
Assert.IsTrue(notif.LastNotificationUtcDate > new DateTime(2020, 11, 1));
}
}
public async Task Complex()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card1 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card1.Id);
var card2 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card2.Id);
var card3 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card3.Id);
using (var dbContext = new MemCheckDbContext(db))
await new RemoveCardFromDeck(dbContext.AsCallContext()).RunAsync(new RemoveCardFromDeck.Request(user, deck, card2.Id));
await DeckHelper.CheckDeckDoesNotContainCard(db, deck, card2.Id);
await DeckHelper.CheckDeckContainsCards(db, deck, card1.Id, card3.Id);
}
public async Task CardWithPreviousVersions_NotToBeNotified_BecauseLastNotifAfterVersion()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 3));
var user2 = await UserHelper.CreateInDbAsync(testDB);
var previousVersion1 = await CreateCardPreviousVersionAsync(testDB, user2, card.Id, new DateTime(2020, 11, 2));
await CreatePreviousVersionPreviousVersionAsync(testDB, user2, previousVersion1, new DateTime(2020, 11, 1));
var lastNotificationDate = new DateTime(2020, 11, 3);
await CardSubscriptionHelper.CreateAsync(testDB, user1, card.Id, lastNotificationDate);
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 5)).RunAsync(user1);
Assert.AreEqual(0, versions.Length);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1);
Assert.AreEqual(lastNotificationDate, notif.LastNotificationUtcDate);
}
}
public async Task DoesNotDeleteOtherUserDeck()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUser = await UserHelper.CreateInDbAsync(db);
var deckNotToDelete = await DeckHelper.CreateAsync(db, loggedUser);
var userToDelete = await UserHelper.CreateInDbAsync(db);
var deckToDelete = await DeckHelper.CreateAsync(db, userToDelete);
var card = await CardHelper.CreateAsync(db, userToDelete);
await DeckHelper.AddCardAsync(db, deckToDelete, card.Id);
await DeckHelper.AddCardAsync(db, deckNotToDelete, card.Id);
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDelete));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.IsFalse(await dbContext.Decks.AnyAsync(deck => deck.Id == deckToDelete));
Assert.IsFalse(await dbContext.CardsInDecks.AnyAsync(cardInDeck => cardInDeck.Deck.Id == deckToDelete));
Assert.IsTrue(await dbContext.Decks.AnyAsync(deck => deck.Id == deckNotToDelete));
Assert.IsTrue(await dbContext.CardsInDecks.AnyAsync(cardInDeck => cardInDeck.Deck.Id == deckNotToDelete));
}
}
public async Task CardWithPreviousVersions_ToBeNotified_LastNotifBeforePreviousVersionCreation()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 5));
var user2 = await UserHelper.CreateInDbAsync(testDB);
var previousVersion1 = await CreateCardPreviousVersionAsync(testDB, user2, card.Id, new DateTime(2020, 11, 3));
var oldestVersion = await CreatePreviousVersionPreviousVersionAsync(testDB, user2, previousVersion1, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 5);
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), now).RunAsync(user1);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
Assert.AreEqual(oldestVersion.Id, versions[0].VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1);
Assert.AreEqual(now, notif.LastNotificationUtcDate);
}
}
public async Task NonPrivateCardNotDeleted_UserOwnerOfCurrentButNotPrevious()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUserName = RandomHelper.String();
var loggedUser = await UserHelper.CreateInDbAsync(db, userName : loggedUserName);
var language = await CardLanguagHelper.CreateAsync(db);
var userToDelete = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, loggedUser, language : language);
await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), versionCreator: userToDelete));
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDelete));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.AreEqual(DeleteUserAccount.DeletedUserName, dbContext.Cards.Include(card => card.VersionCreator).Single(card => card.Id == card.Id).VersionCreator.UserName);
Assert.AreEqual(loggedUserName, dbContext.CardPreviousVersions.Include(cardPreviousVersion => cardPreviousVersion.VersionCreator).Single(cardPreviousVersion => cardPreviousVersion.Card == card.Id).VersionCreator.UserName);
}
}
public async Task FailIfUserCanNotViewCurrentVersion()
{
var db = DbHelper.GetEmptyTestDB();
var userName = RandomHelper.String();
var userId = await UserHelper.CreateInDbAsync(db, userName : userName);
var originalVersionDate = RandomHelper.Date();
var originalFrontSide = RandomHelper.String();
var originalVersionDescription = RandomHelper.String();
var language = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, userId, originalVersionDate, frontSide : originalFrontSide, language : language, versionDescription : originalVersionDescription);
var newFrontSide = RandomHelper.String();
var newVersionDate = RandomHelper.Date(originalVersionDate);
var newVersionDescription = RandomHelper.String();
using (var dbContext = new MemCheckDbContext(db))
await new UpdateCard(dbContext.AsCallContext(), newVersionDate).RunAsync(UpdateCardHelper.RequestForVisibilityChange(card, userWithViewIds: userId.AsArray()));
Guid previousVersionId;
using (var dbContext = new MemCheckDbContext(db))
previousVersionId = (await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync()).Id;
var otherUserId = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetCardDiff(dbContext.AsCallContext()).RunAsync(new GetCardDiff.Request(otherUserId, card.Id, previousVersionId)));
}
public async Task ComplexCase()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var registeredCard1 = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, registeredCard1.Id);
var registeredCard2 = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, registeredCard2.Id);
var deletedCard = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, deletedCard.Id);
using (var dbContext = new MemCheckDbContext(db))
await new DeleteCards(dbContext.AsCallContext()).RunAsync(new DeleteCards.Request(user, deletedCard.Id.AsArray()));
var nonRegisteredCard = await CardHelper.CreateAsync(db, user);
using (var dbContext = new MemCheckDbContext(db))
{
var result = new CardRegistrationsLoader(dbContext).RunForCardIds(user, new[] { registeredCard1.Id, registeredCard2.Id, deletedCard.Id, nonRegisteredCard.Id });
Assert.AreEqual(4, result.Count);
Assert.IsTrue(result[registeredCard1.Id]);
Assert.IsTrue(result[registeredCard2.Id]);
Assert.IsTrue(result[deletedCard.Id]);
Assert.IsFalse(result[nonRegisteredCard.Id]);
}
}
public async Task Complex()
{
var db = DbHelper.GetEmptyTestDB();
var language1Name = RandomHelper.String();
var language1 = await CardLanguagHelper.CreateAsync(db, language1Name);
var language2Name = RandomHelper.String();
var language2 = await CardLanguagHelper.CreateAsync(db, language2Name);
var user = await UserHelper.CreateInDbAsync(db);
await CardHelper.CreateAsync(db, versionCreatorId : user, language : language1);
await CardHelper.CreateAsync(db, versionCreatorId : user, language : language1);
await CardHelper.CreateAsync(db, versionCreatorId : user, language : language1);
await CardHelper.CreateAsync(db, versionCreatorId : user, language : language2);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetAllLanguages(dbContext.AsCallContext()).RunAsync(new GetAllLanguages.Request());
var resultLang1 = result.Single(l => l.Id == language1);
Assert.AreEqual(language1Name, resultLang1.Name);
Assert.AreEqual(3, resultLang1.CardCount);
var resultLang2 = result.Single(l => l.Id == language2);
Assert.AreEqual(language2Name, resultLang2.Name);
Assert.AreEqual(1, resultLang2.CardCount);
}
public async Task TestOtherUserCreatesVersion()
{
var testDB = DbHelper.GetEmptyTestDB();
var ownerId = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, ownerId);
var newVersionCreatorId = await UserHelper.CreateInDbAsync(testDB, subscribeToCardOnEdit : true);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new PreviousVersionCreator(dbContext);
await request.RunAsync(card.Id, newVersionCreatorId, RandomHelper.String());
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var previousVersion = await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync();
Assert.AreNotEqual(card.Id, previousVersion.Id);
}
Assert.IsTrue(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(testDB, newVersionCreatorId, card.Id));
}
public async Task CardsNeverLearnt_NotTheSameOrderOnSuccessiveRuns()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DefaultHeapingAlgorithm.ID);
const int cardCount = 100;
for (int i = 0; i < cardCount; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, card.Id);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount);
var firstRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, firstRunCards.Length);
var secondRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, secondRunCards.Length);
var thirdRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, thirdRunCards.Length);
Assert.IsFalse(firstRunCards.SequenceEqual(secondRunCards));
Assert.IsFalse(firstRunCards.SequenceEqual(thirdRunCards));
Assert.IsFalse(secondRunCards.SequenceEqual(thirdRunCards));
}
public async Task OneDeck()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : HeapingAlgorithms.DefaultAlgoId);
var tag1 = await TagHelper.CreateAsync(db);
var tag2 = await TagHelper.CreateAsync(db);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user, tagIds: tag1.AsArray())).Id, 0);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 0);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 1);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user, tagIds: new[] { tag1, tag2 })).Id, 1);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 2);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetUserDecksWithHeapsAndTags(dbContext.AsCallContext()).RunAsync(new GetUserDecksWithHeapsAndTags.Request(user));
var resultDeck = result.Single();
Assert.AreEqual(deck, resultDeck.DeckId);
Assert.IsTrue(resultDeck.Heaps.SequenceEqual(new[] { 0, 1, 2, 4 }));
Assert.AreEqual(2, resultDeck.Tags.Count());
Assert.IsTrue(resultDeck.Tags.Any(tag => tag.TagId == tag1));
Assert.IsTrue(resultDeck.Tags.Any(tag => tag.TagId == tag2));
}
public async Task ReduceVisibility_OtherUserHasView_NoUserHasInDeck_OnlyAuthor()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var otherUser = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : new[] { cardCreator, otherUser });
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, otherUser, card.Id);
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, cardCreator.AsArray());
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
Assert.ThrowsException <InvalidOperationException>(() => CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, otherUser, card.Id));
}
}
