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