public async Task OneDeck_Empty()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deckName = RandomHelper.String();
var deckAlgo = RandomHelper.HeapingAlgorithm();
var deck = await DeckHelper.CreateAsync(db, user, deckName, deckAlgo);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetUserDecksWithHeaps(dbContext.AsCallContext()).RunAsync(new GetUserDecksWithHeaps.Request(user));
var resultDeck = result.Single();
Assert.AreEqual(deck, resultDeck.DeckId);
Assert.AreEqual(deckName, resultDeck.Description);
Assert.AreEqual(deckAlgo, resultDeck.HeapingAlgorithmId);
Assert.AreEqual(0, resultDeck.CardCount);
Assert.IsFalse(resultDeck.Heaps.Any());
}
public async Task TestRun_DBWithTwoUsersToNotify()
{
var testDB = DbHelper.GetEmptyTestDB();
var userToNotify1 = await UserHelper.CreateInDbAsync(testDB, 1, new DateTime(2030, 10, 19));
await UserHelper.CreateInDbAsync(testDB);
await UserHelper.CreateInDbAsync(testDB, 2, new DateTime(2030, 10, 19));
var userToNotify2 = await UserHelper.CreateInDbAsync(testDB, 30, new DateTime(2030, 9, 20));
using var dbContext = new MemCheckDbContext(testDB);
var users = new UsersToNotifyGetter(dbContext.AsCallContext()).Run(new DateTime(2030, 10, 20));
Assert.AreEqual(2, users.Length);
Assert.IsTrue(users.Any(u => u.Id == userToNotify1));
Assert.IsTrue(users.Any(u => u.Id == userToNotify2));
}
public async Task Success()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var name = RandomHelper.String();
int algo = RandomHelper.HeapingAlgorithm();
using (var dbContext = new MemCheckDbContext(db))
await new CreateDeck(dbContext.AsCallContext()).RunAsync(new CreateDeck.Request(user, name, algo));
using (var dbContext = new MemCheckDbContext(db))
{
var deckFromDb = await dbContext.Decks.SingleAsync();
Assert.AreEqual(name, deckFromDb.Description);
Assert.AreEqual(algo, deckFromDb.HeapingAlgorithmId);
}
}
public async Task Success()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var name = RandomHelper.String();
var description = RandomHelper.String();
var source = RandomHelper.String();
var uploadDate = RandomHelper.Date();
var versionDesc = RandomHelper.String();
using (var dbContext = new MemCheckDbContext(db))
{
var request = new StoreImage.Request(user, name, description, source, StoreImage.pngImageContentType, pngImage);
var localizer = new TestLocalizer(new KeyValuePair <string, string>("InitialImageVersionCreation", versionDesc).AsArray());
await new StoreImage(dbContext.AsCallContext(localizer), uploadDate).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(db))
{
var image = await dbContext.Images.Include(img => img.Owner).Include(img => img.Cards).SingleAsync();
Assert.AreEqual(user, image.Owner.Id);
Assert.AreEqual(name, image.Name);
Assert.AreEqual(description, image.Description);
Assert.AreEqual(source, image.Source);
Assert.AreEqual(uploadDate, image.InitialUploadUtcDate);
Assert.AreEqual(uploadDate, image.LastChangeUtcDate);
Assert.AreEqual(versionDesc, image.VersionDescription);
Assert.AreEqual(ImageVersionType.Creation, image.VersionType);
Assert.AreEqual(StoreImage.pngImageContentType, image.OriginalContentType);
Assert.AreEqual(pngImage.Length, image.OriginalSize);
Assert.IsTrue(pngImage.SequenceEqual(image.OriginalBlob));
Assert.IsTrue(image.SmallBlobSize > 0);
Assert.AreEqual(image.SmallBlobSize, image.SmallBlob.Length);
Assert.IsTrue(image.MediumBlobSize > 0);
Assert.AreEqual(image.MediumBlobSize, image.MediumBlob.Length);
Assert.IsTrue(image.BigBlobSize > 0);
Assert.AreEqual(image.BigBlobSize, image.BigBlob.Length);
Assert.IsFalse(image.Cards.Any());
Assert.IsNull(image.PreviousVersion);
}
}
public async Task CardWithoutPreviousVersion_ToBeNotified()
{
var db = GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(db);
var user2 = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user1, new DateTime(2020, 11, 1), new[] { user1, user2 });
await CardSubscriptionHelper.CreateAsync(db, user1, card.Id, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(db, user2, card.Id, new DateTime(2020, 11, 1));
await DeleteCardAsync(db, user1, 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 user1versions = await notifier.RunAsync(user1);
Assert.AreEqual(1, user1versions.Length);
Assert.IsTrue(user1versions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, user1versions[0].FrontSide);
Assert.AreEqual(DeletionDescription, user1versions[0].DeletionDescription);
var user2versions = await notifier.RunAsync(user2);
Assert.AreEqual(1, user2versions.Length);
Assert.IsTrue(user2versions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, user2versions[0].FrontSide);
Assert.AreEqual(DeletionDescription, user2versions[0].DeletionDescription);
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1).LastNotificationUtcDate);
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user2).LastNotificationUtcDate);
}
}
public async Task Test_Deck_Exclusive()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1Id = await UserHelper.CreateInDbAsync(testDB);
var user2Id = await UserHelper.CreateInDbAsync(testDB);
var card1 = await CardHelper.CreateAsync(testDB, user1Id);
var card2 = await CardHelper.CreateAsync(testDB, user1Id);
var card3 = await CardHelper.CreateAsync(testDB, user1Id);
var user1Emptydeck = await DeckHelper.CreateAsync(testDB, user1Id);
var user1deck = await DeckHelper.CreateAsync(testDB, user1Id);
using (var dbContext = new MemCheckDbContext(testDB))
await new AddCardsInDeck(dbContext.AsCallContext()).RunAsync(new AddCardsInDeck.Request(user1Id, user1deck, new[] { card1.Id, card2.Id }));
using (var dbContext = new MemCheckDbContext(testDB))
{
Assert.AreEqual(3, (await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
UserId = user1Id, Deck = user1Emptydeck, DeckIsInclusive = false
})).TotalNbCards);
var resultOnDeck = await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
UserId = user1Id, Deck = user1deck, DeckIsInclusive = false
});
Assert.AreEqual(1, resultOnDeck.TotalNbCards);
Assert.IsTrue(resultOnDeck.Cards.Any(card => card.CardId == card3.Id));
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
Deck = user1Emptydeck, DeckIsInclusive = false
}));
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
UserId = user2Id, Deck = user1deck, DeckIsInclusive = false
}));
}
}
public async Task VisibilityDiff()
{
var db = DbHelper.GetEmptyTestDB();
var userName = RandomHelper.String();
var userId = await UserHelper.CreateInDbAsync(db, userName : userName);
var originalVersionDate = RandomHelper.Date();
var originalVersionDescription = RandomHelper.String();
var language = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, userId, originalVersionDate, userWithViewIds : userId.AsArray(), language : language, versionDescription : originalVersionDescription);
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, Array.Empty <Guid>(), versionDescription: newVersionDescription));
Guid previousVersionId;
using (var dbContext = new MemCheckDbContext(db))
previousVersionId = (await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync()).Id;
using (var dbContext = new MemCheckDbContext(db))
{
var diffRequest = new GetCardDiff.Request(userId, card.Id, previousVersionId);
var result = await new GetCardDiff(dbContext.AsCallContext()).RunAsync(diffRequest);
Assert.AreEqual(userName, result.CurrentVersionCreator);
Assert.AreEqual(userName, result.OriginalVersionCreator);
Assert.AreEqual(newVersionDate, result.CurrentVersionUtcDate);
Assert.AreEqual(originalVersionDate, result.OriginalVersionUtcDate);
Assert.AreEqual(newVersionDescription, result.CurrentVersionDescription);
Assert.AreEqual(originalVersionDescription, result.OriginalVersionDescription);
Assert.AreEqual(new("", userName), result.UsersWithView);
Assert.IsNull(result.FrontSide);
Assert.IsNull(result.BackSide);
Assert.IsNull(result.Language);
Assert.IsNull(result.AdditionalInfo);
Assert.IsNull(result.Tags);
Assert.IsNull(result.ImagesOnFrontSide);
Assert.IsNull(result.ImagesOnBackSide);
Assert.IsNull(result.ImagesOnAdditionalSide);
}
}
public async Task DoesNotThrowWhenCardNotInTheDeck()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card1 = await CardHelper.CreateAsync(db, user);
var card2 = await CardHelper.CreateAsync(db, user);
var card3 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card1.Id);
await DeckHelper.AddCardAsync(db, deck, card3.Id);
using var dbContext = new MemCheckDbContext(db);
await new RemoveCardsFromDeck(dbContext.AsCallContext()).RunAsync(new RemoveCardsFromDeck.Request(user, deck, new[] { card1.Id, card2.Id }));
}
public async Task Success()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var deckOwner = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, deckOwner);
var card1 = await CardHelper.CreateAsync(db, cardCreator, userWithViewIds : new Guid[] { cardCreator, deckOwner });
var card2 = await CardHelper.CreateAsync(db, deckOwner, userWithViewIds : new Guid[] { deckOwner });
var card3 = await CardHelper.CreateAsync(db, cardCreator);
using (var dbContext = new MemCheckDbContext(db))
await new AddCardsInDeck(dbContext.AsCallContext()).RunAsync(new AddCardsInDeck.Request(deckOwner, deck, new[] { card1.Id, card2.Id, card3.Id }));
await DeckHelper.CheckDeckContainsCards(db, deck, card1.Id, card2.Id, card3.Id);
}
public async Task FailIfDeletedUser()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user);
var adminUser = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
using (var userManager = UserHelper.GetUserManager(dbContext))
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(adminUser)), userManager).RunAsync(new DeleteUserAccount.Request(adminUser, user));
using (var dbContext = new MemCheckDbContext(db))
{
var deleter = new DeleteCards(dbContext.AsCallContext());
var e = await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await deleter.RunAsync(new DeleteCards.Request(user, card.Id.AsArray())));
Assert.AreEqual("User not found", e.Message);
}
}
public async Task Success()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var otherDeck = await DeckHelper.CreateAsync(db, user);
var request = new DeleteDeck.Request(user, deck);
using (var dbContext = new MemCheckDbContext(db))
await new DeleteDeck(dbContext.AsCallContext()).RunAsync(request);
using (var dbContext = new MemCheckDbContext(db))
{
Assert.IsFalse(await dbContext.Decks.AnyAsync(d => d.Id == deck));
Assert.IsTrue(await dbContext.Decks.AnyAsync(d => d.Id == otherDeck));
}
}
public async Task UserNotSubscribingToCardOnEdit()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId);
var newVersionCreator = await UserHelper.CreateInDbAsync(db, subscribeToCardOnEdit : false);
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), newVersionCreator);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
Assert.IsFalse(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(db, newVersionCreator, card.Id));
}
public async Task OneExpiredAndOneToExpireInTheHour()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
var deck1 = await DeckHelper.CreateAsync(testDB, userId, RandomHelper.String());
var addToDeckDate = RandomHelper.Date();
await DeckHelper.AddCardAsync(testDB, deck1, (await CardHelper.CreateAsync(testDB, userId)).Id, 1, addToDeckDate);
await DeckHelper.AddCardAsync(testDB, deck1, (await CardHelper.CreateAsync(testDB, userId)).Id, 1, addToDeckDate.AddHours(2));
using var dbContext = new MemCheckDbContext(testDB);
var resultDeck = (await new GetDecksWithLearnCounts(dbContext.AsCallContext(), addToDeckDate.AddDays(1).AddHours(1.5)).RunAsync(new GetDecksWithLearnCounts.Request(userId))).First();
Assert.AreEqual(1, resultDeck.ExpiredCardCount);
Assert.AreEqual(1, resultDeck.ExpiringNextHourCount);
Assert.AreEqual(0, resultDeck.ExpiringFollowing24hCount);
Assert.AreEqual(0, resultDeck.ExpiringFollowing3DaysCount);
}
public static async Task DeleteAsync(DbContextOptions <MemCheckDbContext> db, Guid userToDeleteId, Guid?deleterUserId = null)
{
DeleteUserAccount.Request request;
TestRoleChecker roleChecker;
if (deleterUserId == null)
{
roleChecker = new TestRoleChecker();
request = new DeleteUserAccount.Request(userToDeleteId, userToDeleteId);
}
else
{
roleChecker = new TestRoleChecker(deleterUserId.Value);
request = new DeleteUserAccount.Request(deleterUserId.Value, userToDeleteId);
}
using var dbContext = new MemCheckDbContext(db);
using var userManager = GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(roleChecker), userManager).RunAsync(request);
}
public async Task TestSearchWithSameExcludedTagTwice()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
Guid tagId;
using (var dbContext = new MemCheckDbContext(testDB))
{
var user = await dbContext.Users.SingleAsync();
tagId = (await new CreateTag(dbContext.AsCallContext()).RunAsync(new CreateTag.Request(user.Id, RandomHelper.String(), ""))).TagId;
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new SubscribeToSearch.Request(userId, Guid.Empty, RandomHelper.String(), "", Array.Empty <Guid>(), new Guid[] { tagId, tagId });
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new SubscribeToSearch(dbContext.AsCallContext()).RunAsync(request));
}
}
async public Task RunAsync()
{
var author = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
var ratingUser = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
var cardIds = await dbContext.Cards.Where(card => card.VersionCreator.Id == author.Id).Select(card => card.Id).ToListAsync();
var rater = new SetCardRating(dbContext.AsCallContext());
foreach (var cardId in cardIds)
{
var request = new SetCardRating.Request(ratingUser.Id, cardId, 5);
await rater.RunAsync(request);
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Rating finished");
}
public async Task OneCardInFrench()
{
var db = DbHelper.GetEmptyTestDB();
var french = await CardLanguagHelper.CreateAsync(db, "Français");
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user, language : french);
var addDate = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, 1, addDate);
using var dbContext = new MemCheckDbContext(db);
var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 10);
var cards = await new GetCardsToRepeat(dbContext.AsCallContext(), addDate.AddDays(1)).RunAsync(request);
Assert.IsTrue(cards.Cards.Single().IsInFrench);
}
public async Task OneTagInDb()
{
var db = DbHelper.GetEmptyTestDB();
var tagName = RandomHelper.String();
var tag = await TagHelper.CreateAsync(db, tagName);
var user = await UserHelper.CreateInDbAsync(db);
await CardHelper.CreateAsync(db, user, tagIds : tag.AsArray());
using var dbContext = new MemCheckDbContext(db);
var result = await new GetAllTags(dbContext.AsCallContext()).RunAsync(new GetAllTags.Request(1, 1, ""));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(1, result.Tags.Count());
Assert.AreEqual(tag, result.Tags.Single().TagId);
Assert.AreEqual(tagName, result.Tags.Single().TagName);
Assert.AreEqual(1, result.Tags.Single().CardCount);
}
public async Task FailIfUserCanNotViewCurrentVersion()
{
var db = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(db);
var language = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, userId, language : language); //Created public
using (var dbContext = new MemCheckDbContext(db))
await new UpdateCard(dbContext.AsCallContext()).RunAsync(UpdateCardHelper.RequestForVisibilityChange(card, userWithViewIds: userId.AsArray())); //Now private
var otherUserId = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
{
var versions = await new GetCardVersions(dbContext.AsCallContext()).RunAsync(new GetCardVersions.Request(userId, card.Id));
Assert.AreEqual(2, versions.Count());
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetCardVersions(dbContext.AsCallContext()).RunAsync(new GetCardVersions.Request(otherUserId, card.Id)));
}
}
public async Task Paging()
{
var db = DbHelper.GetEmptyTestDB();
await TagHelper.CreateAsync(db);
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetAllTags(dbContext.AsCallContext()).RunAsync(new GetAllTags.Request(1, 1, ""));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(1, result.Tags.Count());
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetAllTags(dbContext.AsCallContext()).RunAsync(new GetAllTags.Request(1, 2, ""));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.IsFalse(result.Tags.Any());
}
}
public async Task Rating_SingleCard_SearchByOtherUser()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
var cardId = await CardHelper.CreateIdAsync(testDB, userId);
using (var dbContext = new MemCheckDbContext(testDB))
{
var result = await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
RatingFiltering = SearchCards.Request.RatingFilteringMode.NoRating
});
Assert.AreEqual(1, result.TotalNbCards);
Assert.AreEqual(0, result.Cards.Single().CurrentUserRating);
Assert.AreEqual(0, result.Cards.Single().CountOfUserRatings);
Assert.AreEqual(0, result.Cards.Single().AverageRating);
}
using (var dbContext = new MemCheckDbContext(testDB))
await new SetCardRating(dbContext.AsCallContext()).RunAsync(new SetCardRating.Request(userId, cardId, 4));
using (var dbContext = new MemCheckDbContext(testDB))
{
var result = await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
RatingFiltering = SearchCards.Request.RatingFilteringMode.NoRating
});
Assert.AreEqual(0, result.TotalNbCards);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var result = await new SearchCards(dbContext.AsCallContext()).RunAsync(new SearchCards.Request {
RatingFiltering = SearchCards.Request.RatingFilteringMode.AtLeast, RatingFilteringValue = 3
});
Assert.AreEqual(1, result.TotalNbCards);
Assert.AreEqual(0, result.Cards.Single().CurrentUserRating);
Assert.AreEqual(1, result.Cards.Single().CountOfUserRatings);
Assert.AreEqual(4, result.Cards.Single().AverageRating);
}
}
public async Task NothingToReportBecauseCardWasAlreadyInPreviousSearch()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var language = await CardLanguagHelper.CreateAsync(db);
await CardHelper.CreateAsync(db, user, versionDate : new DateTime(2050, 03, 01), language : language);
var card2 = await CardHelper.CreateAsync(db, user, versionDate : new DateTime(2050, 04, 02), language : language);
var subscription = await SearchSubscriptionHelper.CreateAsync(db, user, lastNotificationDate : new DateTime(2050, 04, 01));
using (var dbContext = new MemCheckDbContext(db))
await new UserSearchNotifier(dbContext.AsCallContext(), 100, new DateTime(2050, 05, 01)).RunAsync(subscription.Id);
using (var dbContext = new MemCheckDbContext(db))
{
var updateRequest = new UpdateCard.Request(card2.Id, user, RandomHelper.String(), Array.Empty <Guid>(), RandomHelper.String(), Array.Empty <Guid>(), RandomHelper.String(), Array.Empty <Guid>(), language, Array.Empty <Guid>(), Array.Empty <Guid>(), RandomHelper.String());
await new UpdateCard(dbContext.AsCallContext(), new DateTime(2050, 05, 02)).RunAsync(updateRequest);
}
var runDate = new DateTime(2050, 05, 03);
using (var dbContext = new MemCheckDbContext(db))
{
var searchResult = await new UserSearchNotifier(dbContext.AsCallContext(), 100, runDate).RunAsync(subscription.Id);
Assert.AreEqual(0, searchResult.TotalNewlyFoundCardCount);
Assert.AreEqual(0, 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);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(runDate, dbContext.SearchSubscriptions.Single(s => s.Id == subscription.Id).LastRunUtcDate);
}
public async Task Filtering()
{
var db = DbHelper.GetEmptyTestDB();
var tagName = RandomHelper.String();
await TagHelper.CreateAsync(db, tagName);
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetAllTags(dbContext.AsCallContext()).RunAsync(new GetAllTags.Request(1, 1, RandomHelper.String()));
Assert.AreEqual(0, result.PageCount);
Assert.AreEqual(0, result.TotalCount);
Assert.AreEqual(0, result.Tags.Count());
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetAllTags(dbContext.AsCallContext()).RunAsync(new GetAllTags.Request(1, 1, tagName.Substring(1, 5)));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(1, result.Tags.Count());
}
}
public async Task OnlyUser()
{
var db = DbHelper.GetEmptyTestDB();
var userName = RandomHelper.String();
var userEMail = RandomHelper.String();
var user = await UserHelper.CreateInDbAsync(db, userName : userName, userEMail : userEMail);
using var dbContext = new MemCheckDbContext(db);
var loaded = await new GetAllUsers(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(new GetAllUsers.Request(user, 10, 1, ""));
Assert.AreEqual(1, loaded.TotalCount);
Assert.AreEqual(1, loaded.PageCount);
var loadedUsers = loaded.Users.ToArray();
Assert.AreEqual(1, loadedUsers.Length);
Assert.AreEqual(userName, loadedUsers[0].UserName);
Assert.AreEqual(IRoleChecker.AdminRoleName, loadedUsers[0].Roles);
Assert.AreEqual(userEMail, loadedUsers[0].Email);
Assert.AreEqual(0, loadedUsers[0].NotifInterval);
Assert.AreEqual(DateTime.MinValue, loadedUsers[0].LastNotifUtcDate);
}
public async Task PublicCard()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : Array.Empty <Guid>());
var otherUser = await UserHelper.CreateInDbAsync(db);
var newFrontSide = RandomHelper.String();
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForFrontSideChange(card, newFrontSide, otherUser);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
await CardHelper.AssertCardHasFrontSide(db, card.Id, newFrontSide);
}
public async Task TestRun()
{
var testDB = DbHelper.GetEmptyTestDB();
var card = await CardHelper.CreateAsync(testDB, await UserHelper.CreateInDbAsync(testDB));
var otherUserId = await UserHelper.CreateInDbAsync(testDB);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new AddCardSubscriptions.Request(otherUserId, new Guid[] { card.Id });
await new AddCardSubscriptions(dbContext.AsCallContext()).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var subscription = await dbContext.CardNotifications.SingleAsync(notif => notif.UserId == otherUserId && notif.CardId == card.Id);
Assert.AreEqual(CardNotificationSubscription.CardNotificationRegistrationMethod_ExplicitByUser, subscription.RegistrationMethod);
}
}
public async Task OneEmptyDeck()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
var description = RandomHelper.String();
var deck = await DeckHelper.CreateAsync(testDB, userId, description);
using var dbContext = new MemCheckDbContext(testDB);
var request = new GetDecksWithLearnCounts.Request(userId);
var result = await new GetDecksWithLearnCounts(dbContext.AsCallContext()).RunAsync(request);
Assert.AreEqual(1, result.Count());
var loaded = result.First();
Assert.AreEqual(deck, loaded.Id);
Assert.AreEqual(description, loaded.Description);
Assert.AreEqual(0, loaded.UnknownCardCount);
Assert.AreEqual(0, loaded.ExpiredCardCount);
Assert.AreEqual(0, loaded.CardCount);
}
public async Task CascadeDeletionOfImageInCardPreviousVersion_ImageRemoved()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var image = await ImageHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user, language : languageId, frontSideImages : image.AsArray());
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(1, dbContext.ImagesInCards.Count());
await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForImageChange(card, Array.Empty <Guid>(), Array.Empty <Guid>(), Array.Empty <Guid>()));
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(0, dbContext.ImagesInCards.Count());
var deletionDate = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
{
var deleter = new DeleteCards(dbContext.AsCallContext(), deletionDate);
await deleter.RunAsync(new DeleteCards.Request(user, card.Id.AsArray()));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.AreEqual(3, dbContext.CardPreviousVersions.Count());
Assert.AreEqual(1, dbContext.ImagesInCardPreviousVersions.Count());
}
using (var dbContext = new MemCheckDbContext(db))
{
var request = new DeleteCardPreviousVersionsOfDeletedCards.Request(user, RandomHelper.Date(deletionDate));
await new DeleteCardPreviousVersionsOfDeletedCards(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.AreEqual(0, dbContext.CardPreviousVersions.Count());
Assert.AreEqual(0, dbContext.ImagesInCardPreviousVersions.Count());
}
}
public async Task Success()
{
var name = RandomHelper.String();
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
Guid createdId;
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new CreateLanguage(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(new CreateLanguage.Request(user, name));
Assert.AreEqual(name, result.Name);
Assert.AreEqual(0, result.CardCount);
createdId = result.Id;
}
using (var dbContext = new MemCheckDbContext(db))
{
var fromDb = await dbContext.CardLanguages.SingleAsync(l => l.Name == name);
Assert.AreEqual(createdId, fromDb.Id);
}
}
public async Task FieldsCorrectlyUpdated()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var newName = RandomHelper.String();
int newAlgo = RandomHelper.HeapingAlgorithm();
var request = new UpdateDeck.Request(user, deck, newName, newAlgo);
using (var dbContext = new MemCheckDbContext(db))
await new UpdateDeck(dbContext.AsCallContext()).RunAsync(request);
using (var dbContext = new MemCheckDbContext(db))
{
var deckFromDb = await dbContext.Decks.SingleAsync(d => d.Id == deck);
Assert.AreEqual(newName, deckFromDb.Description);
Assert.AreEqual(newAlgo, deckFromDb.HeapingAlgorithmId);
}
}
