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