public async Task CardWithoutPreviousVersion_ToBeNotified()
{
var testDB = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user, new DateTime(2020, 11, 2));
await CardSubscriptionHelper.CreateAsync(testDB, user, card.Id, new DateTime(2020, 11, 1));
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 2)).RunAsync(user);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, versions[0].FrontSide);
Assert.AreEqual(card.VersionDescription, versions[0].VersionDescription);
Assert.IsNull(versions[0].VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user);
Assert.IsTrue(notif.LastNotificationUtcDate > new DateTime(2020, 11, 1));
}
}
public async Task TestOtherUserCreatesVersion()
{
var testDB = DbHelper.GetEmptyTestDB();
var ownerId = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, ownerId);
var newVersionCreatorId = await UserHelper.CreateInDbAsync(testDB, subscribeToCardOnEdit : true);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new PreviousVersionCreator(dbContext);
await request.RunAsync(card.Id, newVersionCreatorId, RandomHelper.String());
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var previousVersion = await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync();
Assert.AreNotEqual(card.Id, previousVersion.Id);
}
Assert.IsTrue(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(testDB, newVersionCreatorId, card.Id));
}
public async Task CardWithPreviousVersions_NotToBeNotified_BecauseLastNotifAfterVersion()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 3));
var user2 = await UserHelper.CreateInDbAsync(testDB);
var previousVersion1 = await CreateCardPreviousVersionAsync(testDB, user2, card.Id, new DateTime(2020, 11, 2));
await CreatePreviousVersionPreviousVersionAsync(testDB, user2, previousVersion1, new DateTime(2020, 11, 1));
var lastNotificationDate = new DateTime(2020, 11, 3);
await CardSubscriptionHelper.CreateAsync(testDB, user1, card.Id, lastNotificationDate);
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 5)).RunAsync(user1);
Assert.AreEqual(0, versions.Length);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1);
Assert.AreEqual(lastNotificationDate, notif.LastNotificationUtcDate);
}
}
public async Task ComplexCase()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var registeredCard1 = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, registeredCard1.Id);
var registeredCard2 = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, registeredCard2.Id);
var deletedCard = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, deletedCard.Id);
using (var dbContext = new MemCheckDbContext(db))
await new DeleteCards(dbContext.AsCallContext()).RunAsync(new DeleteCards.Request(user, deletedCard.Id.AsArray()));
var nonRegisteredCard = await CardHelper.CreateAsync(db, user);
using (var dbContext = new MemCheckDbContext(db))
{
var result = new CardRegistrationsLoader(dbContext).RunForCardIds(user, new[] { registeredCard1.Id, registeredCard2.Id, deletedCard.Id, nonRegisteredCard.Id });
Assert.AreEqual(4, result.Count);
Assert.IsTrue(result[registeredCard1.Id]);
Assert.IsTrue(result[registeredCard2.Id]);
Assert.IsTrue(result[deletedCard.Id]);
Assert.IsFalse(result[nonRegisteredCard.Id]);
}
}
public async Task CardWithPreviousVersions_ToBeNotified_LastNotifBeforePreviousVersionCreation()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 5));
var user2 = await UserHelper.CreateInDbAsync(testDB);
var previousVersion1 = await CreateCardPreviousVersionAsync(testDB, user2, card.Id, new DateTime(2020, 11, 3));
var oldestVersion = await CreatePreviousVersionPreviousVersionAsync(testDB, user2, previousVersion1, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 5);
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), now).RunAsync(user1);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
Assert.AreEqual(oldestVersion.Id, versions[0].VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1);
Assert.AreEqual(now, notif.LastNotificationUtcDate);
}
}
public async Task TestRun_UsersWithSubscriptions()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var user2 = await UserHelper.CreateInDbAsync(testDB);
await CardSubscriptionHelper.CreateAsync(testDB, user2, await CardHelper.CreateIdAsync(testDB, user1));
var user3 = await UserHelper.CreateInDbAsync(testDB);
await CardSubscriptionHelper.CreateAsync(testDB, user3, await CardHelper.CreateIdAsync(testDB, user1));
await CardSubscriptionHelper.CreateAsync(testDB, user3, await CardHelper.CreateIdAsync(testDB, user2));
await CardSubscriptionHelper.CreateAsync(testDB, user3, await CardHelper.CreateIdAsync(testDB, user3));
using var dbContext = new MemCheckDbContext(testDB);
var counter = new UserCardSubscriptionCounter(dbContext.AsCallContext());
Assert.AreEqual(0, await counter.RunAsync(user1));
Assert.AreEqual(1, await counter.RunAsync(user2));
Assert.AreEqual(3, await counter.RunAsync(user3));
}
public async Task WithUserSubscribingToCardOnEdit()
{
var testDB = DbHelper.GetEmptyTestDB();
var ownerId = await UserHelper.CreateInDbAsync(testDB, subscribeToCardOnEdit : true);
var languageId = await CardLanguagHelper.CreateAsync(testDB);
Guid cardGuid = Guid.Empty;
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new CreateCard.Request(
ownerId,
RandomHelper.String(),
Array.Empty <Guid>(),
RandomHelper.String(),
Array.Empty <Guid>(),
RandomHelper.String(),
Array.Empty <Guid>(),
languageId,
Array.Empty <Guid>(),
Array.Empty <Guid>(),
RandomHelper.String());
cardGuid = (await new CreateCard(dbContext.AsCallContext()).RunAsync(request)).CardId;
}
Assert.IsTrue(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(testDB, ownerId, cardGuid));
}
public async Task CardWithoutPreviousVersion_ToBeNotified_UsingApplicationDelete()
{
var db = GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(db, user, card.Id, new DateTime(2020, 11, 1));
await DeleteCardAsync(db, user, card.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 3);
using (var dbContext = new MemCheckDbContext(db))
{
var notifier = new UserCardDeletionsNotifier(dbContext.AsCallContext(), now);
var deletions = await notifier.RunAsync(user);
Assert.AreEqual(1, deletions.Length);
Assert.IsTrue(deletions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, deletions[0].FrontSide);
Assert.AreEqual(DeletionDescription, deletions[0].DeletionDescription);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user).LastNotificationUtcDate);
}
public async Task CardWithoutPreviousVersion_ToBeNotifiedWithoutVisibility()
{
var db = GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(db);
var deletedCard = await CreateDeletedCardAsync(db, user1, new DateTime(2020, 11, 2), user1.AsArray());
var user2 = await UserHelper.CreateInDbAsync(db);
await CardSubscriptionHelper.CreateAsync(db, user2, deletedCard.Card, new DateTime(2020, 11, 1));
var now = new DateTime(2020, 11, 2);
using (var dbContext = new MemCheckDbContext(db))
{
var notifier = new UserCardDeletionsNotifier(dbContext.AsCallContext(), now);
var versions = await notifier.RunAsync(user2);
Assert.AreEqual(1, versions.Length);
Assert.IsFalse(versions[0].CardIsViewable);
Assert.IsNull(versions[0].FrontSide);
Assert.IsNull(versions[0].DeletionDescription);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == deletedCard.Card && cn.UserId == user2).LastNotificationUtcDate);
}
public async Task TestRun_UserWithOneSubscription()
{
var testDB = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user);
await CardSubscriptionHelper.CreateAsync(testDB, user, card.Id);
using var dbContext = new MemCheckDbContext(testDB);
var count = await new UserCardSubscriptionCounter(dbContext.AsCallContext()).RunAsync(user);
Assert.AreEqual(1, count);
}
public async Task CardRegistered()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user);
await CardSubscriptionHelper.CreateAsync(db, user, card.Id);
using var dbContext = new MemCheckDbContext(db);
var result = new CardRegistrationsLoader(dbContext).RunForCardIds(user, card.Id.AsArray());
Assert.AreEqual(1, result.Count);
Assert.IsTrue(result[card.Id]);
}
public async Task DeletingMustNotDeleteCardNotifications()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(db, user, card.Id);
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(1, dbContext.CardNotifications.Count());
await CardDeletionHelper.DeleteCardAsync(db, user, card.Id, new DateTime(2020, 11, 2));
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(1, dbContext.CardNotifications.Count());
}
public async Task UserNotSubscribingToCardOnEdit()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId);
var newVersionCreator = await UserHelper.CreateInDbAsync(db, subscribeToCardOnEdit : false);
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), newVersionCreator);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
Assert.IsFalse(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(db, newVersionCreator, card.Id));
}
public async Task CardWithoutPreviousVersion_NotChangedSinceLastNotif()
{
var testDB = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user, new DateTime(2020, 11, 2));
var lastNotificationDate = new DateTime(2020, 11, 3);
await CardSubscriptionHelper.CreateAsync(testDB, user, card.Id, lastNotificationDate);
using (var dbContext = new MemCheckDbContext(testDB))
{
var versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 5)).RunAsync(user);
Assert.AreEqual(0, versions.Length);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user);
Assert.IsTrue(notif.LastNotificationUtcDate == lastNotificationDate);
}
}
public async Task CardWithOnePreviousVersion_ToBeNotifiedWithoutAccessibility()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 2), user1.AsArray());
var previousVersion = await CreateCardPreviousVersionAsync(testDB, user1, card.Id, new DateTime(2020, 11, 1));
var user2 = await UserHelper.CreateInDbAsync(testDB);
await CardSubscriptionHelper.CreateAsync(testDB, user2, card.Id, new DateTime(2020, 11, 1));
var now = new DateTime(2020, 11, 2);
using (var dbContext = new MemCheckDbContext(testDB))
{
var notifier = new UserCardVersionsNotifier(dbContext.AsCallContext(), now);
var user1versions = await notifier.RunAsync(user1);
Assert.AreEqual(0, user1versions.Length);
var user2versions = await notifier.RunAsync(user2);
Assert.AreEqual(1, user2versions.Length);
Assert.AreEqual(card.Id, user2versions[0].CardId);
Assert.IsFalse(user2versions[0].CardIsViewable);
Assert.IsNull(user2versions[0].VersionDescription);
Assert.IsNull(user2versions[0].FrontSide);
Assert.AreEqual(previousVersion.Id, user2versions[0].VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user2);
Assert.AreEqual(now, notif.LastNotificationUtcDate);
}
}
public async Task CardWithoutPreviousVersion_NotToBeNotified()
{
var db = GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, user, new DateTime(2020, 11, 1));
await CardSubscriptionHelper.CreateAsync(db, user, card.Id, new DateTime(2020, 11, 3));
var lastNotificationDate = new DateTime(2020, 11, 3);
await DeleteCardAsync(db, user, card.Id, lastNotificationDate);
using (var dbContext = new MemCheckDbContext(db))
{
var notifier = new UserCardDeletionsNotifier(dbContext.AsCallContext(), new DateTime(2020, 11, 10));
var versions = await notifier.RunAsync(user);
Assert.AreEqual(0, versions.Length);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.IsTrue(dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user).LastNotificationUtcDate == lastNotificationDate);
}
public async Task MultipleVersions()
{
var testDB = DbHelper.GetEmptyTestDB();
var user1 = await UserHelper.CreateInDbAsync(testDB);
var user2 = await UserHelper.CreateInDbAsync(testDB);
var card1 = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 10));
var card1PV1 = await CreateCardPreviousVersionAsync(testDB, user2, card1.Id, new DateTime(2020, 11, 5));
var card1PV2 = await CreatePreviousVersionPreviousVersionAsync(testDB, user2, card1PV1, new DateTime(2020, 11, 1));
var card1Oldest = await CreatePreviousVersionPreviousVersionAsync(testDB, user2, card1PV2, new DateTime(2020, 10, 15));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card1.Id, new DateTime(2020, 11, 2));
var card2 = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 10));
var card2PV1 = await CreateCardPreviousVersionAsync(testDB, user2, card2.Id, new DateTime(2020, 11, 5));
var card2Oldest = await CreatePreviousVersionPreviousVersionAsync(testDB, user2, card2PV1, new DateTime(2020, 11, 2));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card2.Id, new DateTime(2020, 11, 1));
var card3 = await CardHelper.CreateAsync(testDB, user1, new DateTime(2020, 11, 10));
var card3PV1 = await CreateCardPreviousVersionAsync(testDB, user2, card3.Id, new DateTime(2020, 11, 5));
await CreatePreviousVersionPreviousVersionAsync(testDB, user2, card3PV1, new DateTime(2020, 11, 2));
var card3LastNotifDate = new DateTime(2020, 11, 11);
await CardSubscriptionHelper.CreateAsync(testDB, user1, card3.Id, card3LastNotifDate);
var card4 = await CardHelper.CreateAsync(testDB, user2, new DateTime(2020, 11, 10), new Guid[] { user2 }); //Not to be notified because no access for user1
await CreateCardPreviousVersionAsync(testDB, user2, card4.Id, new DateTime(2020, 11, 5));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card4.Id, new DateTime(2020, 11, 2));
var card5 = await CardHelper.CreateAsync(testDB, user2, new DateTime(2020, 11, 10), new Guid[] { user1, user2 });
await CreateCardPreviousVersionAsync(testDB, user2, card5.Id, new DateTime(2020, 11, 5));
await CardSubscriptionHelper.CreateAsync(testDB, user1, card5.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 5);
using (var dbContext = new MemCheckDbContext(testDB))
{
var user1Versions = await new UserCardVersionsNotifier(dbContext.AsCallContext(), now).RunAsync(user1);
Assert.AreEqual(4, user1Versions.Length);
var notifForCard1 = user1Versions.Where(v => v.CardId == card1.Id).Single();
Assert.IsTrue(notifForCard1.CardIsViewable);
Assert.AreEqual(card1PV2.Id, notifForCard1.VersionIdOnLastNotification);
var notifForCard2 = user1Versions.Where(v => v.CardId == card2.Id).Single();
Assert.IsTrue(notifForCard2.CardIsViewable);
Assert.IsNull(notifForCard2.VersionIdOnLastNotification);
Assert.IsFalse(user1Versions.Any(v => v.CardId == card3.Id));
var notifForCard4 = user1Versions.Where(v => v.CardId == card4.Id).Single();
Assert.IsFalse(notifForCard4.CardIsViewable);
Assert.IsNull(notifForCard4.VersionIdOnLastNotification);
var notifForCard5 = user1Versions.Where(v => v.CardId == card5.Id).Single();
Assert.IsTrue(notifForCard5.CardIsViewable);
Assert.IsNull(notifForCard5.VersionIdOnLastNotification);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card1.Id && cn.UserId == user1).LastNotificationUtcDate);
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card2.Id && cn.UserId == user1).LastNotificationUtcDate);
Assert.AreEqual(card3LastNotifDate, dbContext.CardNotifications.Single(cn => cn.CardId == card3.Id && cn.UserId == user1).LastNotificationUtcDate);
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card4.Id && cn.UserId == user1).LastNotificationUtcDate);
Assert.AreEqual(now, dbContext.CardNotifications.Single(cn => cn.CardId == card5.Id && cn.UserId == user1).LastNotificationUtcDate);
}
}
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));
}
