public async Task TagUsedInCards() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var otherTag = await TagHelper.CreateAsync(db); var tagName = RandomHelper.String(); var description = RandomHelper.String(); var tag = await TagHelper.CreateAsync(db, tagName, description); await CardHelper.CreateAsync(db, user, tagIds : new[] { tag, otherTag }); await CardHelper.CreateAsync(db, user, tagIds : new[] { tag }); await CardHelper.CreateAsync(db, user); using var dbContext = new MemCheckDbContext(db); var loadedTag = await new GetTag(dbContext.AsCallContext()).RunAsync(new GetTag.Request(tag)); Assert.AreEqual(tag, loadedTag.TagId); Assert.AreEqual(tagName, loadedTag.TagName); Assert.AreEqual(description, loadedTag.Description); Assert.AreEqual(2, loadedTag.CardCount); }
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 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 DescriptionNotTrimmed() { var db = DbHelper.GetEmptyTestDB(); var tag = await TagHelper.CreateAsync(db); var userId = await UserHelper.CreateInDbAsync(db); using var dbContext = new MemCheckDbContext(db); await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, tag, RandomHelper.String(), "\t"))); }
public async Task DescriptionTooLong() { var db = DbHelper.GetEmptyTestDB(); var tag = await TagHelper.CreateAsync(db); var userId = await UserHelper.CreateInDbAsync(db); using var dbContext = new MemCheckDbContext(db); await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, tag, RandomHelper.String(), RandomHelper.String(Tag.MaxDescriptionLength + 1)))); }
public async Task NameWithForbiddenChar() { var db = DbHelper.GetEmptyTestDB(); var tag = await TagHelper.CreateAsync(db); var userId = await UserHelper.CreateInDbAsync(db); using var dbContext = new MemCheckDbContext(db); await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, tag, "a<b", ""))); }
public async Task TwoDecks_WithTags() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck1Name = RandomHelper.String(); var deck1Algo = RandomHelper.HeapingAlgorithm(); var deck1 = await DeckHelper.CreateAsync(db, user, deck1Name, deck1Algo); var deck2Name = RandomHelper.String(); var deck2Algo = RandomHelper.HeapingAlgorithm(); var deck2 = await DeckHelper.CreateAsync(db, user, deck2Name, deck2Algo); var tag1 = await TagHelper.CreateAsync(db); var card1 = await CardHelper.CreateAsync(db, user, tagIds : tag1.AsArray()); await DeckHelper.AddCardAsync(db, deck1, card1.Id); await DeckHelper.AddCardAsync(db, deck2, card1.Id); var tag2 = await TagHelper.CreateAsync(db); var card2 = await CardHelper.CreateAsync(db, user, tagIds : tag2.AsArray()); await DeckHelper.AddCardAsync(db, deck1, card2.Id); var card3 = await CardHelper.CreateAsync(db, user, tagIds : new[] { tag1, tag2 }); await DeckHelper.AddCardAsync(db, deck1, card3.Id); var card4 = await CardHelper.CreateAsync(db, user); await DeckHelper.AddCardAsync(db, deck1, card4.Id); await DeckHelper.AddCardAsync(db, deck2, card4.Id); using var dbContext = new MemCheckDbContext(db); var result = await new GetUserDecksWithTags(dbContext.AsCallContext()).RunAsync(new GetUserDecksWithTags.Request(user)); var resultDeck1 = result.Single(d => d.DeckId == deck1); Assert.AreEqual(deck1, resultDeck1.DeckId); Assert.AreEqual(deck1Name, resultDeck1.Description); Assert.AreEqual(2, resultDeck1.Tags.Count()); Assert.IsTrue(resultDeck1.Tags.Any(t => t.TagId == tag1)); Assert.IsTrue(resultDeck1.Tags.Any(t => t.TagId == tag2)); var resultDeck2 = result.Single(d => d.DeckId == deck2); Assert.AreEqual(deck2, resultDeck2.DeckId); Assert.AreEqual(deck2Name, resultDeck2.Description); Assert.AreEqual(tag1, resultDeck2.Tags.Single().TagId); }
public async Task SearchSubscriptions() { var db = DbHelper.GetEmptyTestDB(); var loggedUser = await UserHelper.CreateInDbAsync(db); var userToDelete = await UserHelper.CreateInDbAsync(db); var tag = await TagHelper.CreateAsync(db); await CardHelper.CreateAsync(db, userToDelete, tagIds : tag.AsArray()); await CardHelper.CreateAsync(db, userToDelete); await CardHelper.CreateAsync(db, loggedUser, tagIds : tag.AsArray()); Guid loggedUserSubscriptionId; Guid userToDeleteSubscriptionId; using (var dbContext = new MemCheckDbContext(db)) { loggedUserSubscriptionId = (await new SubscribeToSearch(dbContext.AsCallContext()).RunAsync(new SubscribeToSearch.Request(loggedUser, Guid.Empty, RandomHelper.String(), "", tag.AsArray(), Array.Empty <Guid>()))).SearchId; userToDeleteSubscriptionId = (await new SubscribeToSearch(dbContext.AsCallContext()).RunAsync(new SubscribeToSearch.Request(userToDelete, Guid.Empty, RandomHelper.String(), "", tag.AsArray(), Array.Empty <Guid>()))).SearchId; } using (var dbContext = new MemCheckDbContext(db)) { await new UserSearchNotifier(dbContext.AsCallContext(), 10, new DateTime(2050, 05, 01)).RunAsync(loggedUserSubscriptionId); await new UserSearchNotifier(dbContext.AsCallContext(), 10, new DateTime(2050, 05, 01)).RunAsync(userToDeleteSubscriptionId); } using (var dbContext = new MemCheckDbContext(db)) { Assert.AreEqual(2, dbContext.CardsInSearchResults.Count(c => c.SearchSubscriptionId == loggedUserSubscriptionId)); Assert.AreEqual(2, dbContext.CardsInSearchResults.Count(c => c.SearchSubscriptionId == userToDeleteSubscriptionId)); } 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(1, await dbContext.SearchSubscriptions.CountAsync(sub => sub.Id == loggedUserSubscriptionId)); Assert.AreEqual(0, await dbContext.SearchSubscriptions.CountAsync(sub => sub.Id == userToDeleteSubscriptionId)); Assert.AreEqual(1, await dbContext.RequiredTagInSearchSubscriptions.CountAsync(reqTag => reqTag.SearchSubscriptionId == loggedUserSubscriptionId)); Assert.AreEqual(0, await dbContext.RequiredTagInSearchSubscriptions.CountAsync(reqTag => reqTag.SearchSubscriptionId == userToDeleteSubscriptionId)); Assert.AreEqual(2, await dbContext.CardsInSearchResults.CountAsync(cardInSearchResult => cardInSearchResult.SearchSubscriptionId == loggedUserSubscriptionId)); Assert.AreEqual(0, await dbContext.CardsInSearchResults.CountAsync(cardInSearchResult => cardInSearchResult.SearchSubscriptionId == userToDeleteSubscriptionId)); } }
public async Task NoChange() { var name = RandomHelper.String(); var description = RandomHelper.String(); var db = DbHelper.GetEmptyTestDB(); var tag = await TagHelper.CreateAsync(db, name, description); var userId = await UserHelper.CreateInDbAsync(db); using var dbContext = new MemCheckDbContext(db); await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, tag, name, description))); }
public async Task WithIgnoredTags() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : UnitTestsHeapingAlgorithm.ID); var tagToIgnore = await TagHelper.CreateAsync(db); var otherTag = await TagHelper.CreateAsync(db); var runDate = RandomHelper.Date(); //Add unkown cards await DeckHelper.AddNewCardAsync(db, deck, CardInDeck.UnknownHeap); await DeckHelper.AddNewCardAsync(db, deck, CardInDeck.UnknownHeap, tagIds : tagToIgnore.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, CardInDeck.UnknownHeap, tagIds : otherTag.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, CardInDeck.UnknownHeap, tagIds : new[] { tagToIgnore, otherTag }); //Add non expired cards await DeckHelper.AddNewCardAsync(db, deck, RandomHelper.Heap(true), runDate.AddHours(Randomizer.Next(-23, -1))); await DeckHelper.AddNewCardAsync(db, deck, RandomHelper.Heap(true), runDate.AddHours(Randomizer.Next(-23, -1)), tagIds : tagToIgnore.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, RandomHelper.Heap(true), runDate.AddHours(Randomizer.Next(-23, -1)), tagIds : otherTag.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, RandomHelper.Heap(true), runDate.AddHours(Randomizer.Next(-23, -1)), tagIds : new[] { tagToIgnore, otherTag }); //Add expired cards await DeckHelper.AddNewCardAsync(db, deck, 1, runDate.AddDays(-2)); await DeckHelper.AddNewCardAsync(db, deck, 1, runDate.AddDays(-2), tagIds : tagToIgnore.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, 1, runDate.AddDays(-2), tagIds : otherTag.AsArray()); await DeckHelper.AddNewCardAsync(db, deck, 1, runDate.AddDays(-2), tagIds : new[] { tagToIgnore, otherTag }); using var dbContext = new MemCheckDbContext(db); var expiredRequest = new GetRemainingCardsInLesson.Request(user, deck, false, tagToIgnore.AsArray()); var expiredResult = await new GetRemainingCardsInLesson(dbContext.AsCallContext(), runDate).RunAsync(expiredRequest); Assert.AreEqual(2, expiredResult.Count); var unknownRequest = new GetRemainingCardsInLesson.Request(user, deck, true, tagToIgnore.AsArray()); var unknownResult = await new GetRemainingCardsInLesson(dbContext.AsCallContext(), runDate).RunAsync(unknownRequest); Assert.AreEqual(2, unknownResult.Count); }
public async Task CheckAllFields() { var db = DbHelper.GetEmptyTestDB(); var languageName = RandomHelper.String(); var language = await CardLanguagHelper.CreateAsync(db, languageName); var creatorName = RandomHelper.String(); var creatorId = await UserHelper.CreateInDbAsync(db, userName : creatorName); var creationDate = RandomHelper.Date(); var frontSide = RandomHelper.String(); var backSide = RandomHelper.String(); var additionalInfo = RandomHelper.String(); var tagName = RandomHelper.String(); var tag = await TagHelper.CreateAsync(db, tagName); var otherUserName = RandomHelper.String(); var otherUserId = await UserHelper.CreateInDbAsync(db, userName : otherUserName); var versionDescription = RandomHelper.String(); var card = await CardHelper.CreateAsync(db, creatorId, language : language, versionDate : creationDate, frontSide : frontSide, backSide : backSide, additionalInfo : additionalInfo, tagIds : tag.AsArray(), userWithViewIds : new[] { creatorId, otherUserId }, versionDescription : versionDescription); var deck = await DeckHelper.CreateAsync(db, otherUserId); await DeckHelper.AddCardAsync(db, deck, card.Id); using var dbContext = new MemCheckDbContext(db); var loaded = await new GetCardForEdit(dbContext.AsCallContext()).RunAsync(new GetCardForEdit.Request(creatorId, card.Id)); Assert.AreEqual(frontSide, loaded.FrontSide); Assert.AreEqual(backSide, loaded.BackSide); Assert.AreEqual(additionalInfo, loaded.AdditionalInfo); Assert.AreEqual(language, loaded.LanguageId); Assert.AreEqual(languageName, loaded.LanguageName); Assert.AreEqual(tag, loaded.Tags.Single().TagId); Assert.AreEqual(tagName, loaded.Tags.Single().TagName); Assert.AreEqual(2, loaded.UsersWithVisibility.Count()); Assert.IsTrue(loaded.UsersWithVisibility.Count(u => u.UserId == creatorId) == 1); Assert.AreEqual(creatorName, loaded.UsersWithVisibility.Single(u => u.UserId == creatorId).UserName); Assert.IsTrue(loaded.UsersWithVisibility.Count(u => u.UserId == otherUserId) == 1); Assert.AreEqual(otherUserName, loaded.UsersWithVisibility.Single(u => u.UserId == otherUserId).UserName); Assert.AreEqual(creationDate, loaded.FirstVersionUtcDate); Assert.AreEqual(creationDate, loaded.LastVersionUtcDate); Assert.AreEqual(creatorName, loaded.LastVersionCreatorName); Assert.AreEqual(versionDescription, loaded.LastVersionDescription); Assert.AreEqual(1, loaded.UsersOwningDeckIncluding.Count()); Assert.IsTrue(loaded.UsersOwningDeckIncluding.Single() == otherUserName); Assert.AreEqual(0, loaded.Images.Count()); Assert.AreEqual(0, loaded.UserRating); Assert.AreEqual(0, loaded.AverageRating); Assert.AreEqual(0, loaded.CountOfUserRatings); }
public async Task UserNotLoggedIn() { var db = DbHelper.GetEmptyTestDB(); var name = RandomHelper.String(); var tag = await TagHelper.CreateAsync(db, name); using (var dbContext = new MemCheckDbContext(db)) await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(Guid.Empty, tag, RandomHelper.String(), RandomHelper.String()))); using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(name, (await new GetTag(dbContext.AsCallContext()).RunAsync(new GetTag.Request(tag))).TagName); }
public async Task TagsDiff() { 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 originalTagName1 = RandomHelper.String(); var originalTagId1 = await TagHelper.CreateAsync(db, originalTagName1); var originalTagName2 = RandomHelper.String(); var originalTagId2 = await TagHelper.CreateAsync(db, originalTagName2); var language = await CardLanguagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, userId, originalVersionDate, tagIds : new[] { originalTagId1, originalTagId2 }, 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.RequestForTagChange(card, originalTagId1.AsArray(), 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); var expectedTagDiffString = string.Join(",", new[] { originalTagName1, originalTagName2 }.OrderBy(s => s)); Assert.AreEqual(new(originalTagName1, expectedTagDiffString), result.Tags); Assert.IsNull(result.FrontSide); Assert.IsNull(result.BackSide); Assert.IsNull(result.Language); Assert.IsNull(result.AdditionalInfo); Assert.IsNull(result.UsersWithView); Assert.IsNull(result.ImagesOnFrontSide); Assert.IsNull(result.ImagesOnBackSide); Assert.IsNull(result.ImagesOnAdditionalSide); } }
public async Task EmptyDeck() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var tag = await TagHelper.CreateAsync(db); await CardHelper.CreateAsync(db, user, tagIds : tag.AsArray()); using var dbContext = new MemCheckDbContext(db); var request = new GetTagsOfDeck.Request(user, deck); var result = await new GetTagsOfDeck(dbContext).RunAsync(request); Assert.IsFalse(result.Any()); }
public async Task TestDBWithOnePublicCard_FindAll() { var testDB = DbHelper.GetEmptyTestDB(); var userId = await UserHelper.CreateInDbAsync(testDB); var tag1Name = RandomHelper.String(); var tag1 = await TagHelper.CreateAsync(testDB, tag1Name); var tag2Name = RandomHelper.String(); var tag2 = await TagHelper.CreateAsync(testDB, tag2Name); var card = await CardHelper.CreateAsync(testDB, userId, tagIds : new[] { tag1, tag2 }); using var dbContext = new MemCheckDbContext(testDB); var requestWithUser = new SearchCards.Request { UserId = userId }; var resultWithUser = await new SearchCards(dbContext.AsCallContext()).RunAsync(requestWithUser); Assert.AreEqual(1, resultWithUser.TotalNbCards); Assert.AreEqual(1, resultWithUser.PageCount); Assert.AreEqual(card.Id, resultWithUser.Cards.First().CardId); var requestWithoutUser = new SearchCards.Request(); var resultWithoutUser = await new SearchCards(dbContext.AsCallContext()).RunAsync(requestWithoutUser); Assert.AreEqual(1, resultWithoutUser.TotalNbCards); Assert.AreEqual(1, resultWithoutUser.PageCount); var foundCard = resultWithoutUser.Cards.First(); Assert.AreEqual(card.Id, foundCard.CardId); Assert.AreEqual(card.TagsInCards.Count(), foundCard.Tags.Count()); Assert.IsTrue(foundCard.Tags.Any(t => t == tag1Name)); Assert.IsTrue(foundCard.Tags.Any(t => t == tag2Name)); Assert.AreEqual(0, foundCard.CountOfUserRatings); Assert.AreEqual(0, foundCard.AverageRating); Assert.AreEqual(0, foundCard.CurrentUserRating); Assert.IsTrue(!foundCard.DeckInfo.Any()); Assert.AreEqual(card.FrontSide, foundCard.FrontSide); Assert.AreEqual(userId, foundCard.VersionCreator.Id); Assert.AreEqual(card.VersionDescription, foundCard.VersionDescription); Assert.AreEqual(card.VersionUtcDate, foundCard.VersionUtcDate); Assert.IsTrue(!foundCard.VisibleTo.Any()); }
public async Task SuccessfulUpdateOfDescription() { var db = DbHelper.GetEmptyTestDB(); var name = RandomHelper.String(); var tag = await TagHelper.CreateAsync(db, name); var description = RandomHelper.String(); var userId = await UserHelper.CreateInDbAsync(db); using (var dbContext = new MemCheckDbContext(db)) await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, tag, name, description)); using (var dbContext = new MemCheckDbContext(db)) { var loaded = await new GetTag(dbContext.AsCallContext()).RunAsync(new GetTag.Request(tag)); Assert.AreEqual(name, loaded.TagName); Assert.AreEqual(description, loaded.Description); } }
public async Task OneTag() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var tag = await TagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, user, tagIds : tag.AsArray()); await DeckHelper.AddCardAsync(db, deck, card.Id); using var dbContext = new MemCheckDbContext(db); var request = new GetTagsOfDeck.Request(user, deck); var result = await new GetTagsOfDeck(dbContext).RunAsync(request); Assert.AreEqual(tag, result.Single().TagId); }
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 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 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 CardNotificationSubscriptions() { var db = DbHelper.GetEmptyTestDB(); var loggedUser = await UserHelper.CreateInDbAsync(db); var userToDelete = await UserHelper.CreateInDbAsync(db); var tag = await TagHelper.CreateAsync(db); var card1 = await CardHelper.CreateAsync(db, loggedUser, tagIds : tag.AsArray()); var card2 = await CardHelper.CreateAsync(db, userToDelete); var card3 = await CardHelper.CreateAsync(db, loggedUser, tagIds : tag.AsArray()); using (var dbContext = new MemCheckDbContext(db)) { await new AddCardSubscriptions(dbContext.AsCallContext()).RunAsync(new AddCardSubscriptions.Request(userToDelete, new Guid[] { card1.Id, card2.Id })); await new AddCardSubscriptions(dbContext.AsCallContext()).RunAsync(new AddCardSubscriptions.Request(loggedUser, new Guid[] { card2.Id, card3.Id })); } using (var dbContext = new MemCheckDbContext(db)) { Assert.AreEqual(2, dbContext.CardNotifications.Count(cardNotifSubscription => cardNotifSubscription.UserId == loggedUser)); Assert.AreEqual(2, dbContext.CardNotifications.Count(cardNotifSubscription => cardNotifSubscription.UserId == 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(2, dbContext.CardNotifications.Count(cardNotifSubscription => cardNotifSubscription.UserId == loggedUser)); Assert.AreEqual(0, dbContext.CardNotifications.Count(cardNotifSubscription => cardNotifSubscription.UserId == userToDelete)); } }
public async Task CascadeDeletionOfTagInPreviousCardVersion() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var tag1 = await TagHelper.CreateAsync(db); var tag2 = await TagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, user, language : languageId, tagIds : new[] { tag1, tag2 }); var tag3 = await TagHelper.CreateAsync(db); await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForTagChange(card, tag3.AsArray())); 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(4, dbContext.TagInPreviousCardVersions.Count()); } using (var dbContext = new MemCheckDbContext(db)) await new DeleteCardPreviousVersionsOfDeletedCards(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(new DeleteCardPreviousVersionsOfDeletedCards.Request(user, RandomHelper.Date(deletionDate))); using (var dbContext = new MemCheckDbContext(db)) { Assert.AreEqual(0, dbContext.CardPreviousVersions.Count()); Assert.AreEqual(0, dbContext.TagInPreviousCardVersions.Count()); } }
public async Task UpdateAllFields() { var db = DbHelper.GetEmptyTestDB(); var cardCreator = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var originalCard = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : Array.Empty <Guid>()); var newVersionCreator = await UserHelper.CreateInDbAsync(db); var frontSide = RandomHelper.String(); var backSide = RandomHelper.String(); var additionalInfo = RandomHelper.String(); var versionDescription = RandomHelper.String(); var newLanguageId = await CardLanguagHelper.CreateAsync(db); var imageOnFrontSideId = await ImageHelper.CreateAsync(db, cardCreator); var imageOnBackSide1Id = await ImageHelper.CreateAsync(db, cardCreator); var imageOnBackSide2Id = await ImageHelper.CreateAsync(db, cardCreator); var imageOnAdditionalInfoId = await ImageHelper.CreateAsync(db, cardCreator); var tagId = await TagHelper.CreateAsync(db); using (var dbContext = new MemCheckDbContext(db)) { var request = new UpdateCard.Request( originalCard.Id, newVersionCreator, frontSide, new Guid[] { imageOnFrontSideId }, backSide, new Guid[] { imageOnBackSide1Id, imageOnBackSide2Id }, additionalInfo, new Guid[] { imageOnAdditionalInfoId }, languageId, new Guid[] { tagId }, new Guid[] { cardCreator, newVersionCreator }, versionDescription); await new UpdateCard(dbContext.AsCallContext()).RunAsync(request); } using (var dbContext = new MemCheckDbContext(db)) { var updatedCard = dbContext.Cards .Include(c => c.VersionCreator) .Include(c => c.CardLanguage) .Include(c => c.UsersWithView) .Include(c => c.Images) .Include(c => c.TagsInCards) .Single(c => c.Id == originalCard.Id); Assert.AreEqual(newVersionCreator, updatedCard.VersionCreator.Id); Assert.AreEqual(frontSide, updatedCard.FrontSide); Assert.AreEqual(backSide, updatedCard.BackSide); Assert.AreEqual(additionalInfo, updatedCard.AdditionalInfo); Assert.AreEqual(versionDescription, updatedCard.VersionDescription); Assert.AreEqual(languageId, updatedCard.CardLanguage.Id); Assert.AreEqual(ImageInCard.FrontSide, updatedCard.Images.Single(i => i.ImageId == imageOnFrontSideId).CardSide); Assert.AreEqual(ImageInCard.BackSide, updatedCard.Images.Single(i => i.ImageId == imageOnBackSide1Id).CardSide); Assert.AreEqual(ImageInCard.BackSide, updatedCard.Images.Single(i => i.ImageId == imageOnBackSide2Id).CardSide); Assert.AreEqual(ImageInCard.AdditionalInfo, updatedCard.Images.Single(i => i.ImageId == imageOnAdditionalInfoId).CardSide); Assert.IsTrue(updatedCard.TagsInCards.Any(t => t.TagId == tagId)); } using (var dbContext = new MemCheckDbContext(db)) { CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, originalCard.Id); CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, newVersionCreator, originalCard.Id); } }
public async Task WithAllData() { var testDB = DbHelper.GetEmptyTestDB(); var userWithViewId = await UserHelper.CreateInDbAsync(testDB); var ownerId = await UserHelper.CreateInDbAsync(testDB, subscribeToCardOnEdit : false); var frontSide = RandomHelper.String(); var backSide = RandomHelper.String(); var additionalInfo = RandomHelper.String(); var versionDescription = RandomHelper.String(); var languageId = await CardLanguagHelper.CreateAsync(testDB); var imageOnFrontSideId = await ImageHelper.CreateAsync(testDB, ownerId); var imageOnBackSide1Id = await ImageHelper.CreateAsync(testDB, ownerId); var imageOnBackSide2Id = await ImageHelper.CreateAsync(testDB, ownerId); var imageOnAdditionalInfoId = await ImageHelper.CreateAsync(testDB, ownerId); var tagId = await TagHelper.CreateAsync(testDB); Guid cardGuid = Guid.Empty; using (var dbContext = new MemCheckDbContext(testDB)) { var request = new CreateCard.Request( ownerId, frontSide, new Guid[] { imageOnFrontSideId }, backSide, new Guid[] { imageOnBackSide1Id, imageOnBackSide2Id }, additionalInfo, new Guid[] { imageOnAdditionalInfoId }, languageId, new Guid[] { tagId }, new Guid[] { ownerId, userWithViewId }, versionDescription); cardGuid = (await new CreateCard(dbContext.AsCallContext()).RunAsync(request)).CardId; Assert.AreNotEqual(Guid.Empty, cardGuid); } using (var dbContext = new MemCheckDbContext(testDB)) { var card = dbContext.Cards .Include(c => c.VersionCreator) .Include(c => c.CardLanguage) .Include(c => c.UsersWithView) .Include(c => c.Images) .Include(c => c.TagsInCards) .Single(c => c.Id == cardGuid); Assert.AreEqual(ownerId, card.VersionCreator.Id); Assert.AreEqual(frontSide, card.FrontSide); Assert.AreEqual(backSide, card.BackSide); Assert.AreEqual(additionalInfo, card.AdditionalInfo); Assert.AreEqual(versionDescription, card.VersionDescription); Assert.AreEqual(languageId, card.CardLanguage.Id); Assert.IsTrue(card.UsersWithView.Any(u => u.UserId == ownerId)); Assert.IsTrue(card.UsersWithView.Any(u => u.UserId == userWithViewId)); Assert.AreEqual(ImageInCard.FrontSide, card.Images.Single(i => i.ImageId == imageOnFrontSideId).CardSide); Assert.AreEqual(ImageInCard.BackSide, card.Images.Single(i => i.ImageId == imageOnBackSide1Id).CardSide); Assert.AreEqual(ImageInCard.BackSide, card.Images.Single(i => i.ImageId == imageOnBackSide2Id).CardSide); Assert.AreEqual(ImageInCard.AdditionalInfo, card.Images.Single(i => i.ImageId == imageOnAdditionalInfoId).CardSide); Assert.IsTrue(card.TagsInCards.Any(t => t.TagId == tagId)); Assert.AreEqual(0, card.RatingCount); Assert.AreEqual(0, card.AverageRating); } Assert.IsFalse(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(testDB, ownerId, cardGuid)); }
public async Task NewAndNotAnymoreToReport() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var language = await CardLanguagHelper.CreateAsync(db); var ignoredTag = await TagHelper.CreateAsync(db); var requiredTag1 = await TagHelper.CreateAsync(db); var requiredTag2 = await TagHelper.CreateAsync(db); var excludedTag = await TagHelper.CreateAsync(db); var card1 = await CardHelper.CreateAsync(db, user, language : language, tagIds : new[] { ignoredTag, requiredTag1, requiredTag2, excludedTag }); var card2 = await CardHelper.CreateAsync(db, user, language : language, tagIds : new[] { ignoredTag, requiredTag1, requiredTag2 }); var card3 = await CardHelper.CreateAsync(db, user, language : language, tagIds : new[] { ignoredTag }); var card4 = await CardHelper.CreateAsync(db, user, language : language, tagIds : new[] { ignoredTag }); Guid subscriptionId; using (var dbContext = new MemCheckDbContext(db)) { var subscriberRequest = new SubscribeToSearch.Request(user, Guid.Empty, RandomHelper.String(), "", new[] { requiredTag1, requiredTag2 }, new[] { excludedTag }); subscriptionId = (await new SubscribeToSearch(dbContext.AsCallContext()).RunAsync(subscriberRequest)).SearchId; } using (var dbContext = new MemCheckDbContext(db)) { var searchResult = await new UserSearchNotifier(dbContext.AsCallContext(), 10, new DateTime(2050, 05, 01)).RunAsync(subscriptionId); Assert.AreEqual(1, searchResult.TotalNewlyFoundCardCount); Assert.AreEqual(1, searchResult.NewlyFoundCards.Length); Assert.AreEqual(card2.Id, searchResult.NewlyFoundCards.Single().CardId); 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)) { var updateDate = new DateTime(2050, 05, 02); await new UpdateCard(dbContext.AsCallContext(), updateDate).RunAsync(UpdateCardHelper.RequestForTagChange(card1, new[] { ignoredTag, requiredTag1, requiredTag2 })); await new UpdateCard(dbContext.AsCallContext(), updateDate).RunAsync(UpdateCardHelper.RequestForTagChange(card2, new[] { requiredTag1, requiredTag2, excludedTag })); await new UpdateCard(dbContext.AsCallContext(), updateDate).RunAsync(UpdateCardHelper.RequestForTagChange(card3, new[] { requiredTag1 })); await new UpdateCard(dbContext.AsCallContext(), new DateTime(2050, 05, 03)).RunAsync(UpdateCardHelper.RequestForTagChange(card3, new[] { requiredTag1, requiredTag2 })); await new UpdateCard(dbContext.AsCallContext(), updateDate).RunAsync(UpdateCardHelper.RequestForTagChange(card4, new[] { requiredTag1 })); } var runDate = new DateTime(2050, 05, 04); using (var dbContext = new MemCheckDbContext(db)) { var searchResult = await new UserSearchNotifier(dbContext.AsCallContext(), 55, runDate).RunAsync(subscriptionId); Assert.AreEqual(2, searchResult.TotalNewlyFoundCardCount); Assert.AreEqual(2, searchResult.NewlyFoundCards.Length); Assert.IsTrue(searchResult.NewlyFoundCards.Any(c => c.CardId == card1.Id)); Assert.IsTrue(searchResult.NewlyFoundCards.Any(c => c.CardId == card3.Id)); Assert.AreEqual(1, searchResult.CountOfCardsNotFoundAnymore_StillExists_UserAllowedToView); Assert.AreEqual(1, searchResult.CardsNotFoundAnymore_StillExists_UserAllowedToView.Length); Assert.AreEqual(card2.Id, searchResult.CardsNotFoundAnymore_StillExists_UserAllowedToView.Single().CardId); 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 == subscriptionId).LastRunUtcDate); }