public async Task OneImageInDb() { var db = DbHelper.GetEmptyTestDB(); var imageName = RandomHelper.String(); var userName = RandomHelper.String(); var user = await UserHelper.CreateInDbAsync(db, userName : userName); var description = RandomHelper.String(); var source = RandomHelper.String(); var uploadDate = RandomHelper.Date(); var versionDescription = RandomHelper.String(); var image = await ImageHelper.CreateAsync(db, user, name : imageName, description : description, source : source, lastChangeUtcDate : uploadDate, versionDescription : versionDescription); using var dbContext = new MemCheckDbContext(db); var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 1, "")); Assert.AreEqual(1, result.PageCount); Assert.AreEqual(1, result.TotalCount); var loaded = result.Images.Single(); Assert.AreEqual(image, loaded.ImageId); Assert.AreEqual(imageName, loaded.ImageName); Assert.AreEqual(0, loaded.CardCount); Assert.AreEqual("InvalidForUnitTests", loaded.OriginalImageContentType); Assert.AreEqual(userName, loaded.Uploader); Assert.AreEqual(description, loaded.Description); Assert.AreEqual(source, loaded.Source); Assert.AreEqual(4, loaded.OriginalImageSize); Assert.AreEqual(1, loaded.SmallSize); Assert.AreEqual(2, loaded.MediumSize); Assert.AreEqual(3, loaded.BigSize); Assert.AreEqual(uploadDate, loaded.InitialUploadUtcDate); Assert.AreEqual(uploadDate, loaded.LastChangeUtcDate); Assert.AreEqual(versionDescription, loaded.CurrentVersionDescription); }
public void Seed(DatabaseContext context) { List <Member> members = context.Members.ToList(); List <AchievementType> achievementTypes = context.AchievementTypes.ToList(); List <string> assignedBy = new List <string> { "John Brown", "Asim Dule", "Milan Pavica", "Redžo Kar", "Anica Dobra", "Dunja Zaklan", "Bego Begajić" }; List <string> note = new List <string> { "Napomena 123", "Sedam dana i sedam noći", "Zelena je trava", "Babo ručo", "Nije niko lud da spava", "Bila mama Kukunka" }; List <string> name = new List <string> { "Nagrada 1. Maj", "Pohvala Ilije Lije", "Izvanredan uspjeh iz rezbaranja", "Priznanje Drug Tito", "Zeleni mrav" }; List <Achievement> achievements = new List <Achievement>(); foreach (Member member in members) { int count = RandomHelper.Next(0, 3); for (int i = 0; i < count; i++) { achievements.Add(new Achievement { Member = member, AchievementType = RandomHelper.List(achievementTypes), AssignedBy = RandomHelper.List(assignedBy), AssignedDate = RandomHelper.Date(), Note = RandomHelper.List(note), Name = RandomHelper.List(name) }); } } context.Achievements.AddRange(achievements); }
public async Task UsedInCards() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var name = RandomHelper.String(); var source = RandomHelper.String(); var description = RandomHelper.String(); var uploadDate = RandomHelper.Date(); var versionDescription = RandomHelper.String(); var image = await ImageHelper.CreateAsync(db, user, name : name, source : source, description : description, lastChangeUtcDate : uploadDate, versionDescription : versionDescription); var otherImage = await ImageHelper.CreateAsync(db, user); await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image, otherImage }); await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image }); await CardHelper.CreateAsync(db, user, frontSideImages : new[] { otherImage }); using var dbContext = new MemCheckDbContext(db); var loaded = await new GetImageInfoFromId(dbContext.AsCallContext()).RunAsync(new GetImageInfoFromId.Request(image)); Assert.AreEqual(user, loaded.Owner.Id); Assert.AreEqual(name, loaded.Name); Assert.AreEqual(description, loaded.Description); Assert.AreEqual(source, loaded.Source); Assert.AreEqual(2, loaded.CardCount); Assert.AreEqual(uploadDate, loaded.InitialUploadUtcDate); Assert.AreEqual(uploadDate, loaded.LastChangeUtcDate); Assert.AreEqual(versionDescription, loaded.CurrentVersionDescription); }
public async Task OrderingOfNeverLearnt() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DefaultHeapingAlgorithm.ID); var randomDate = RandomHelper.Date(); var cardAddedLater = await CardHelper.CreateAsync(db, user); await DeckHelper.AddNeverLearntCardAsync(db, deck, cardAddedLater.Id, randomDate.AddDays(1)); for (int i = 0; i < 9; i++) { var card = await CardHelper.CreateAsync(db, user); await DeckHelper.AddNeverLearntCardAsync(db, deck, card.Id, randomDate); } using var dbContext = new MemCheckDbContext(db); var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 3); var downloadedCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableHashSet(); Assert.IsFalse(downloadedCards.Contains(cardAddedLater.Id)); }
public async Task LearnMoveToSameHeap() { //This could happen due to multiple sessions by the user var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var card = await CardHelper.CreateAsync(db, user); var initialTime = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : initialTime); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardToHeap(dbContext.AsCallContext(), RandomHelper.Date(initialTime)).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 1)); using (var dbContext = new MemCheckDbContext(db)) { var cardInDeck = dbContext.CardsInDecks.Single(); Assert.AreEqual(1, cardInDeck.CurrentHeap); Assert.AreEqual(initialTime, cardInDeck.LastLearnUtcTime); Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap); Assert.AreEqual(1, cardInDeck.BiggestHeapReached); Assert.AreEqual(initialTime.AddDays(1), cardInDeck.ExpiryUtcTime); } }
public async Task CascadeDeletionOfImageInCardPreviousVersion_ImageChangesSide() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var image1 = await ImageHelper.CreateAsync(db, user); var image2 = await ImageHelper.CreateAsync(db, user); var card = await CardHelper.CreateAsync(db, user, language : languageId, frontSideImages : image1.AsArray()); await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForImageChange(card, Array.Empty <Guid>(), image1.AsArray(), image2.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(5, dbContext.ImagesInCardPreviousVersions.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.ImagesInCardPreviousVersions.Count()); } }
public async Task CardWithIntermediaryVersionsToBeDeletedFromPreviousVersions() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, user, language : languageId); await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String())); var runDate = RandomHelper.Date(); using (var dbContext = new MemCheckDbContext(db)) { var deleter = new DeleteCards(dbContext.AsCallContext(), RandomHelper.DateBefore(runDate)); await deleter.RunAsync(new DeleteCards.Request(user, card.Id.AsArray())); } using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(3, dbContext.CardPreviousVersions.Count()); using (var dbContext = new MemCheckDbContext(db)) await new DeleteCardPreviousVersionsOfDeletedCards(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(new DeleteCardPreviousVersionsOfDeletedCards.Request(user, runDate)); using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(0, dbContext.CardPreviousVersions.Count()); }
public async Task LearnMoveToUnknown() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var card = await CardHelper.CreateAsync(db, user); await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 4); var runTime = RandomHelper.Date(); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, CardInDeck.UnknownHeap)); using (var dbContext = new MemCheckDbContext(db)) { var cardInDeck = dbContext.CardsInDecks.Single(); Assert.AreEqual(CardInDeck.UnknownHeap, cardInDeck.CurrentHeap); Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime); Assert.AreEqual(2, cardInDeck.NbTimesInNotLearnedHeap); Assert.AreEqual(4, cardInDeck.BiggestHeapReached); Assert.AreEqual(DateTime.MinValue, cardInDeck.ExpiryUtcTime); } }
public async Task TwoCardsWithLanguages() { var db = DbHelper.GetEmptyTestDB(); var french = await CardLanguagHelper.CreateAsync(db, "Français"); var otherLanguage = await CardLanguagHelper.CreateAsync(db, RandomHelper.String()); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var frenchCreatedCard = await CardHelper.CreateAsync(db, user, language : french); var otherLanguageCard = await CardHelper.CreateAsync(db, user, language : otherLanguage); var addDate = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, frenchCreatedCard.Id, 1, addDate); await DeckHelper.AddCardAsync(db, deck, otherLanguageCard.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(card => card.CardId == frenchCreatedCard.Id).IsInFrench); Assert.IsFalse(cards.Cards.Single(card => card.CardId == otherLanguageCard.Id).IsInFrench); }
public async Task UpdateDescription() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var name = RandomHelper.String(); var source = RandomHelper.String(); var uploadDate = RandomHelper.Date(); var image = await ImageHelper.CreateAsync(db, user, name : name, source : source, lastChangeUtcDate : uploadDate); var newDescription = RandomHelper.String(); var runDate = RandomHelper.Date(uploadDate); var versionDescription = RandomHelper.String(); using (var dbContext = new MemCheckDbContext(db)) { var request = new UpdateImageMetadata.Request(image, user, name, source, newDescription, versionDescription); await new UpdateImageMetadata(dbContext.AsCallContext(), runDate).RunAsync(request); } using (var dbContext = new MemCheckDbContext(db)) { var fromDb = await dbContext.Images.Include(img => img.Owner).SingleAsync(); Assert.AreEqual(image, fromDb.Id); Assert.AreEqual(name, fromDb.Name); Assert.AreEqual(user, fromDb.Owner.Id); Assert.AreEqual(newDescription, fromDb.Description); Assert.AreEqual(source, fromDb.Source); Assert.AreEqual(uploadDate, fromDb.InitialUploadUtcDate); Assert.AreEqual(runDate, fromDb.LastChangeUtcDate); Assert.AreEqual(versionDescription, fromDb.VersionDescription); Assert.AreEqual(ImageVersionType.Changes, fromDb.VersionType); } }
public async Task OneCardWithImages() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var image1 = await ImageHelper.CreateAsync(db, user); var image2 = await ImageHelper.CreateAsync(db, user); var createdCard = await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image1, image2 }); var addDate = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, createdCard.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); var resultImages = cards.Cards.Single().Images; Assert.AreEqual(2, resultImages.Count()); Assert.AreEqual(image1, resultImages.First().ImageId); Assert.AreEqual(image2, resultImages.Last().ImageId); }
public async Task CheckOrder() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID); var loadTime = RandomHelper.Date(); const int cardCount = 100; for (int i = 0; i < cardCount; i++) { var card = await CardHelper.CreateAsync(db, user); await DeckHelper.AddCardAsync(db, deck, card.Id, RandomHelper.Heap(true), RandomHelper.DateBefore(loadTime)); } using var dbContext = new MemCheckDbContext(db); var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount); var cards = (await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request)).Cards.ToImmutableArray(); Assert.AreEqual(cardCount, cards.Length); for (int i = 1; i < cards.Length; i++) { Assert.IsTrue(cards[i].Heap <= cards[i - 1].Heap); if (cards[i].Heap == cards[i - 1].Heap) { Assert.IsTrue(cards[i].LastLearnUtcTime >= cards[i - 1].LastLearnUtcTime); } } }
public async Task RequestedCount() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID); var loadTime = RandomHelper.Date(); const int cardCount = 50; for (int i = 0; i < cardCount; i++) { var card = await CardHelper.CreateAsync(db, user); await DeckHelper.AddCardAsync(db, deck, card.Id, RandomHelper.Heap(true), RandomHelper.DateBefore(loadTime)); } using var dbContext = new MemCheckDbContext(db); var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount / 2); var cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request); Assert.AreEqual(request.CardsToDownload, cards.Cards.Count()); request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount); cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request); Assert.AreEqual(request.CardsToDownload, cards.Cards.Count()); request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount * 2); cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request); Assert.AreEqual(cardCount, cards.Cards.Count()); }
public async Task FailIfUserCanNotViewCurrentVersion() { var db = DbHelper.GetEmptyTestDB(); var userName = RandomHelper.String(); var userId = await UserHelper.CreateInDbAsync(db, userName : userName); var originalVersionDate = RandomHelper.Date(); var originalFrontSide = RandomHelper.String(); var originalVersionDescription = RandomHelper.String(); var language = await CardLanguagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, userId, originalVersionDate, frontSide : originalFrontSide, language : language, versionDescription : originalVersionDescription); var newFrontSide = RandomHelper.String(); var newVersionDate = RandomHelper.Date(originalVersionDate); var newVersionDescription = RandomHelper.String(); using (var dbContext = new MemCheckDbContext(db)) await new UpdateCard(dbContext.AsCallContext(), newVersionDate).RunAsync(UpdateCardHelper.RequestForVisibilityChange(card, userWithViewIds: userId.AsArray())); Guid previousVersionId; using (var dbContext = new MemCheckDbContext(db)) previousVersionId = (await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync()).Id; var otherUserId = await UserHelper.CreateInDbAsync(db); using (var dbContext = new MemCheckDbContext(db)) await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetCardDiff(dbContext.AsCallContext()).RunAsync(new GetCardDiff.Request(otherUserId, card.Id, previousVersionId))); }
public async Task CardWithPreviousVersion() { var db = DbHelper.GetEmptyTestDB(); var language = await CardLanguagHelper.CreateAsync(db); var firstVersionCreatorId = await UserHelper.CreateInDbAsync(db); var firstVersionDate = RandomHelper.Date(); var card = await CardHelper.CreateAsync(db, firstVersionCreatorId, language : language, versionDate : firstVersionDate); var lastVersionCreatorName = RandomHelper.String(); var lastVersionCreatorId = await UserHelper.CreateInDbAsync(db, userName : lastVersionCreatorName); var lastVersionDate = RandomHelper.Date(); var lastVersionDescription = RandomHelper.String(); var lastVersionFrontSide = RandomHelper.String(); using (var dbContext = new MemCheckDbContext(db)) await new UpdateCard(dbContext.AsCallContext(), lastVersionDate).RunAsync(UpdateCardHelper.RequestForFrontSideChange(card, lastVersionFrontSide, versionCreator: lastVersionCreatorId, versionDescription: lastVersionDescription)); var otherUserId = await UserHelper.CreateInDbAsync(db); using (var dbContext = new MemCheckDbContext(db)) { var loaded = await new GetCardForEdit(dbContext.AsCallContext()).RunAsync(new GetCardForEdit.Request(otherUserId, card.Id)); Assert.AreEqual(firstVersionDate, loaded.FirstVersionUtcDate); Assert.AreEqual(lastVersionDate, loaded.LastVersionUtcDate); Assert.AreEqual(lastVersionCreatorName, loaded.LastVersionCreatorName); Assert.AreEqual(lastVersionDescription, loaded.LastVersionDescription); Assert.AreEqual(lastVersionFrontSide, loaded.FrontSide); } }
public async Task MoveToZeroTwice() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var card = await CardHelper.CreateAsync(db, user); var addTime = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 8, lastLearnUtcTime : addTime); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, CardInDeck.UnknownHeap, card.Id.AsArray())); for (int i = 0; i < 2; i++) { using (var dbContext = new MemCheckDbContext(db)) { var loadedCard = dbContext.CardsInDecks.Single(); Assert.AreEqual(CardInDeck.UnknownHeap, loadedCard.CurrentHeap); Assert.AreEqual(addTime, loadedCard.LastLearnUtcTime); Assert.AreEqual(DateTime.MinValue, loadedCard.ExpiryUtcTime); Assert.AreEqual(2, loadedCard.NbTimesInNotLearnedHeap); Assert.AreEqual(8, loadedCard.BiggestHeapReached); } } }
public async Task CascadeDeletionOfUserWithViewOnCardPreviousVersion() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var otherUser = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var card = await CardHelper.CreateAsync(db, user, language : languageId, userWithViewIds : user.AsArray()); await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForVisibilityChange(card, new[] { user, otherUser })); 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(5, dbContext.UsersWithViewOnCardPreviousVersions.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.UsersWithViewOnCardPreviousVersions.Count()); } }
public async Task LearnMoveUp() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : UnitTestsHeapingAlgorithm.ID); var card = await CardHelper.CreateAsync(db, user); await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1); var runTime = RandomHelper.Date(); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 2)); using (var dbContext = new MemCheckDbContext(db)) { var cardInDeck = dbContext.CardsInDecks.Single(); Assert.AreEqual(2, cardInDeck.CurrentHeap); Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime); Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap); Assert.AreEqual(2, cardInDeck.BiggestHeapReached); Assert.AreEqual(runTime.AddDays(2), cardInDeck.ExpiryUtcTime); } }
public async Task MoveToSameHeap() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user); var card = await CardHelper.CreateAsync(db, user); var lastLearnTime = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : lastLearnTime); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, 1, card.Id.AsArray())); using (var dbContext = new MemCheckDbContext(db)) { var cardInDeck = dbContext.CardsInDecks.Single(); Assert.AreEqual(1, cardInDeck.CurrentHeap); Assert.AreEqual(lastLearnTime, cardInDeck.LastLearnUtcTime); Assert.AreEqual(lastLearnTime.AddDays(1), cardInDeck.ExpiryUtcTime); Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap); Assert.AreEqual(1, cardInDeck.BiggestHeapReached); } }
public void ExpiryDateInCorrectInterval(int heap) { var lastLearnDate = RandomHelper.Date(); var expiryDate = algo.ExpiryUtcDate(heap, lastLearnDate); var nbDaysForExpiration = Math.Pow(2, heap); DateAssert.IsInRange(lastLearnDate.AddDays(nbDaysForExpiration), TimeSpan.FromMinutes(nbDaysForExpiration * 10), expiryDate); }
public async Task Versionning() { var db = DbHelper.GetEmptyTestDB(); var user1Name = RandomHelper.String(); var user1 = await UserHelper.CreateInDbAsync(db, userName : user1Name); var initialVersionDate = RandomHelper.Date(); var initialName = RandomHelper.String(); var initialSource = RandomHelper.String(); var initialVersionDescription = RandomHelper.String(); var image = await ImageHelper.CreateAsync(db, user1, lastChangeUtcDate : initialVersionDate, name : initialName, source : initialSource, versionDescription : initialVersionDescription); var user2Name = RandomHelper.String(); var user2 = await UserHelper.CreateInDbAsync(db, userName : user2Name); var firstVersionDate = RandomHelper.Date(initialVersionDate); var firstVersionDescription = RandomHelper.String(); using (var dbContext = new MemCheckDbContext(db)) await new UpdateImageMetadata(dbContext.AsCallContext(), firstVersionDate).RunAsync(new UpdateImageMetadata.Request(image, user2, initialName, initialSource, RandomHelper.String(), firstVersionDescription)); var user3Name = RandomHelper.String(); var user3 = await UserHelper.CreateInDbAsync(db, userName : user3Name); var lastVersionDate = RandomHelper.Date(firstVersionDate); var lastVersionDescription = RandomHelper.String(); using (var dbContext = new MemCheckDbContext(db)) await new UpdateImageMetadata(dbContext.AsCallContext(), lastVersionDate).RunAsync(new UpdateImageMetadata.Request(image, user3, initialName, RandomHelper.String(), RandomHelper.String(), lastVersionDescription)); using (var dbContext = new MemCheckDbContext(db)) { var versions = (await new GetImageVersions(dbContext.AsCallContext()).RunAsync(new GetImageVersions.Request(image))).ToList(); var currentVersion = versions[0]; Assert.AreEqual(user3Name, currentVersion.Author); Assert.AreEqual(lastVersionDate, currentVersion.VersionUtcDate); Assert.AreEqual(lastVersionDescription, currentVersion.VersionDescription); Assert.AreEqual(2, currentVersion.ChangedFieldNames.Count()); var previousVersion = versions[1]; Assert.AreEqual(user2Name, previousVersion.Author); Assert.AreEqual(firstVersionDate, previousVersion.VersionUtcDate); Assert.AreEqual(firstVersionDescription, previousVersion.VersionDescription); Assert.AreEqual(1, previousVersion.ChangedFieldNames.Count()); var initialVersion = versions[2]; Assert.AreEqual(user1Name, initialVersion.Author); Assert.AreEqual(initialVersionDate, initialVersion.VersionUtcDate); Assert.AreEqual(initialVersionDescription, initialVersion.VersionDescription); Assert.AreEqual(3, initialVersion.ChangedFieldNames.Count()); } }
public async Task OneDeck_WithCards() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var deck = await DeckHelper.CreateAsync(db, user, algorithmId : HeapingAlgorithms.DefaultAlgoId); var runDate = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).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, RandomHelper.DateBefore(runDate.AddDays(-3))); //expired await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 1, runDate.AddDays(-1)); await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 2, runDate.AddDays(-10)); //expired await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4, runDate.AddDays(-10)); await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4, runDate.AddDays(-13)); using var dbContext = new MemCheckDbContext(db); var result = await new GetUserDecksWithHeaps(dbContext.AsCallContext(), runDate).RunAsync(new GetUserDecksWithHeaps.Request(user)); var resultDeck = result.Single(); Assert.AreEqual(deck, resultDeck.DeckId); Assert.AreEqual(7, resultDeck.CardCount); Assert.AreEqual(4, resultDeck.Heaps.Count()); var unknownHeap = resultDeck.Heaps.Single(heap => heap.HeapId == 0); Assert.AreEqual(DateTime.MaxValue, unknownHeap.NextExpiryUtcDate); Assert.AreEqual(2, unknownHeap.TotalCardCount); var heap1 = resultDeck.Heaps.Single(heap => heap.HeapId == 1); Assert.AreEqual(2, heap1.TotalCardCount); Assert.AreEqual(1, heap1.ExpiredCardCount); DateAssert.IsInRange(runDate.AddDays(1), TimeSpan.FromMinutes(20), heap1.NextExpiryUtcDate); var heap2 = resultDeck.Heaps.Single(heap => heap.HeapId == 2); Assert.AreEqual(1, heap2.TotalCardCount); Assert.AreEqual(1, heap2.ExpiredCardCount); Assert.AreEqual(DateTime.MaxValue, heap2.NextExpiryUtcDate); var heap4 = resultDeck.Heaps.Single(heap => heap.HeapId == 4); Assert.AreEqual(2, heap4.TotalCardCount); Assert.AreEqual(0, heap4.ExpiredCardCount); DateAssert.IsInRange(runDate.AddDays(3), TimeSpan.FromMinutes(160), heap4.NextExpiryUtcDate); }
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 MultipleCase() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var languageId = await CardLanguagHelper.CreateAsync(db); var runDate = RandomHelper.Date(); var cardNotDeleted = await CardHelper.CreateAsync(db, user, language : languageId); await UpdateCardHelper.RunAsync(db, UpdateCardHelper.RequestForFrontSideChange(cardNotDeleted, RandomHelper.String())); using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(1, dbContext.CardPreviousVersions.Count()); var cardDeletedAfterRunDate = await CardHelper.CreateAsync(db, user, language : languageId); using (var dbContext = new MemCheckDbContext(db)) { var deleter = new DeleteCards(dbContext.AsCallContext(), RandomHelper.Date(runDate)); await deleter.RunAsync(new DeleteCards.Request(user, cardDeletedAfterRunDate.Id.AsArray())); } using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(3, dbContext.CardPreviousVersions.Count()); var cardDeletedBeforeRunDate = await CardHelper.CreateAsync(db, user, language : languageId); using (var dbContext = new MemCheckDbContext(db)) { var deleter = new DeleteCards(dbContext.AsCallContext(), RandomHelper.DateBefore(runDate)); await deleter.RunAsync(new DeleteCards.Request(user, cardDeletedBeforeRunDate.Id.AsArray())); } using (var dbContext = new MemCheckDbContext(db)) Assert.AreEqual(5, dbContext.CardPreviousVersions.Count()); using (var dbContext = new MemCheckDbContext(db)) await new DeleteCardPreviousVersionsOfDeletedCards(dbContext.AsCallContext(new TestRoleChecker(user))).RunAsync(new DeleteCardPreviousVersionsOfDeletedCards.Request(user, runDate)); using (var dbContext = new MemCheckDbContext(db)) { var previousVersions = await dbContext.CardPreviousVersions.ToListAsync(); Assert.AreEqual(3, previousVersions.Count); Assert.AreEqual(1, previousVersions.Where(pv => pv.Card == cardNotDeleted.Id).Count()); Assert.AreEqual(2, previousVersions.Where(pv => pv.Card == cardDeletedAfterRunDate.Id).Count()); } }
public void ExpiryDateIsRandom(int heap) { var lastLearnDate = RandomHelper.Date(); var expiryDate = algo.ExpiryUtcDate(heap, lastLearnDate); for (int i = 0; i < 10; i++) { if (algo.ExpiryUtcDate(heap, lastLearnDate) != expiryDate) { return; } } Assert.Fail("Always got the same expiry date"); }
public async Task MultipleImagesOnAdditionalSide() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var language = await CardLanguagHelper.CreateAsync(db); var image1 = await ImageHelper.CreateAsync(db, user); var image2 = await ImageHelper.CreateAsync(db, user); Guid cardGuid; var createRequest = new CreateCard.Request( user, RandomHelper.String(), Array.Empty <Guid>(), RandomHelper.String(), Array.Empty <Guid>(), RandomHelper.String(), new Guid[] { image1, image2 }, language, Array.Empty <Guid>(), Array.Empty <Guid>(), RandomHelper.String()); using (var dbContext = new MemCheckDbContext(db)) cardGuid = (await new CreateCard(dbContext.AsCallContext()).RunAsync(createRequest)).CardId; var deck = await DeckHelper.CreateAsync(db, user); var addToDeckDate = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, cardGuid, 1, addToDeckDate); using (var dbContext = new MemCheckDbContext(db)) { var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 10); var card = (await new GetCardsToRepeat(dbContext.AsCallContext(), addToDeckDate.AddDays(1)).RunAsync(request)).Cards.Single(); var images = card.Images; Assert.AreEqual(2, images.Count()); var first = card.Images.First(); Assert.AreEqual(ImageInCard.AdditionalInfo, first.CardSide); Assert.AreEqual(image1, first.ImageId); var last = card.Images.Last(); Assert.AreEqual(ImageInCard.AdditionalInfo, last.CardSide); Assert.AreEqual(image2, last.ImageId); } }
public async Task MoveMultiple() { 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); var card1LastLearnTime = RandomHelper.Date(); var card2LastLearnTime = RandomHelper.Date(); var card3LastLearnTime = RandomHelper.Date(); await DeckHelper.AddCardAsync(db, deck, card1.Id, heap : 1, lastLearnUtcTime : card1LastLearnTime); await DeckHelper.AddCardAsync(db, deck, card2.Id, heap : 8, lastLearnUtcTime : card2LastLearnTime); await DeckHelper.AddCardAsync(db, deck, card3.Id, heap : CardInDeck.UnknownHeap, lastLearnUtcTime : card3LastLearnTime); using (var dbContext = new MemCheckDbContext(db)) await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, 3, new[] { card1.Id, card2.Id, card3.Id })); using (var dbContext = new MemCheckDbContext(db)) { var loadedCard1 = dbContext.CardsInDecks.Single(c => c.CardId == card1.Id); Assert.AreEqual(3, loadedCard1.CurrentHeap); Assert.AreEqual(card1LastLearnTime, loadedCard1.LastLearnUtcTime); Assert.AreEqual(card1LastLearnTime.AddDays(3), loadedCard1.ExpiryUtcTime); Assert.AreEqual(1, loadedCard1.NbTimesInNotLearnedHeap); Assert.AreEqual(3, loadedCard1.BiggestHeapReached); var loadedCard2 = dbContext.CardsInDecks.Single(c => c.CardId == card2.Id); Assert.AreEqual(3, loadedCard2.CurrentHeap); Assert.AreEqual(card2LastLearnTime, loadedCard2.LastLearnUtcTime); Assert.AreEqual(card2LastLearnTime.AddDays(3), loadedCard2.ExpiryUtcTime); Assert.AreEqual(1, loadedCard2.NbTimesInNotLearnedHeap); Assert.AreEqual(8, loadedCard2.BiggestHeapReached); var loadedCard3 = dbContext.CardsInDecks.Single(c => c.CardId == card3.Id); Assert.AreEqual(3, loadedCard3.CurrentHeap); Assert.AreEqual(card3LastLearnTime, loadedCard3.LastLearnUtcTime); Assert.AreEqual(card3LastLearnTime.AddDays(3), loadedCard3.ExpiryUtcTime); Assert.AreEqual(1, loadedCard3.NbTimesInNotLearnedHeap); Assert.AreEqual(3, loadedCard3.BiggestHeapReached); } }
public async Task Complex() { var db = DbHelper.GetEmptyTestDB(); var user = await UserHelper.CreateInDbAsync(db); var otherImage = await ImageHelper.CreateAsync(db, user); var imageName = RandomHelper.String(); var imageCreationVersionDescription = RandomHelper.String(); var imageUploadDate = RandomHelper.Date(); var image = await ImageHelper.CreateAsync(db, user, imageName, imageCreationVersionDescription, lastChangeUtcDate : imageUploadDate); var card = await CardHelper.CreateAsync(db, user, frontSideImages : otherImage.AsArray(), additionalSideImages : image.AsArray()); using (var dbContext = new MemCheckDbContext(db)) await new DeleteCards(dbContext.AsCallContext()).RunAsync(new DeleteCards.Request(user, card.Id.AsArray())); var deletionDescription = RandomHelper.String(); var deletionDate = RandomHelper.Date(imageUploadDate); using (var dbContext = new MemCheckDbContext(db)) await new DeleteImage(dbContext.AsCallContext(), deletionDate).RunAsync(new DeleteImage.Request(user, image, deletionDescription)); using (var dbContext = new MemCheckDbContext(db)) { Assert.AreEqual(otherImage, dbContext.Images.Single().Id); var initialPreviousVersion = dbContext.ImagePreviousVersions.Include(prev => prev.Owner).Single(prev => prev.PreviousVersion == null); Assert.AreEqual(image, initialPreviousVersion.Image); Assert.AreEqual(user, initialPreviousVersion.Owner.Id); Assert.AreEqual(imageName, initialPreviousVersion.Name); Assert.AreEqual(imageCreationVersionDescription, initialPreviousVersion.VersionDescription); Assert.AreEqual(imageUploadDate, initialPreviousVersion.InitialUploadUtcDate); Assert.AreEqual(imageUploadDate, initialPreviousVersion.VersionUtcDate); Assert.IsNull(initialPreviousVersion.PreviousVersion); var lastPreviousVersion = dbContext.ImagePreviousVersions.Include(prev => prev.Owner).Single(prev => prev.PreviousVersion != null); Assert.AreEqual(image, lastPreviousVersion.Image); Assert.AreEqual(user, lastPreviousVersion.Owner.Id); Assert.AreEqual(imageName, lastPreviousVersion.Name); Assert.AreEqual(deletionDescription, lastPreviousVersion.VersionDescription); Assert.AreEqual(imageUploadDate, lastPreviousVersion.InitialUploadUtcDate); Assert.AreEqual(deletionDate, lastPreviousVersion.VersionUtcDate); Assert.AreEqual(initialPreviousVersion, lastPreviousVersion.PreviousVersion); Assert.IsFalse(await dbContext.ImagesInCardPreviousVersions.Where(imageInCardPreviousVersions => imageInCardPreviousVersions.ImageId == image).AnyAsync()); Assert.IsTrue(await dbContext.ImagesInCardPreviousVersions.Where(imageInCardPreviousVersions => imageInCardPreviousVersions.ImageId == otherImage).AnyAsync()); } }
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); } }