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