public async Task TwoDecks()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck1Name = RandomHelper.String();
var deck1Algo = RandomHelper.HeapingAlgorithm();
var deck1 = await DeckHelper.CreateAsync(db, user, deck1Name, deck1Algo);
var deck2Name = RandomHelper.String();
var deck2Algo = RandomHelper.HeapingAlgorithm();
var deck2 = await DeckHelper.CreateAsync(db, user, deck2Name, deck2Algo);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetUserDecks(dbContext.AsCallContext()).RunAsync(new GetUserDecks.Request(user));
Assert.AreEqual(2, result.Count());
var resultDeck1 = result.Single(d => d.DeckId == deck1);
Assert.AreEqual(deck1Name, resultDeck1.Description);
Assert.AreEqual(deck1Algo, resultDeck1.HeapingAlgorithmId);
var resultDeck2 = result.Single(d => d.DeckId == deck2);
Assert.AreEqual(deck2Name, resultDeck2.Description);
Assert.AreEqual(deck2Algo, resultDeck2.HeapingAlgorithmId);
}
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 CorrectDeletion_OtherSubscriptionsExist()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
await SearchSubscriptionHelper.CreateAsync(testDB, userId);
var subscription = await SearchSubscriptionHelper.CreateAsync(testDB, userId);
await SearchSubscriptionHelper.CreateAsync(testDB, userId);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new DeleteSearchSubscription.Request(userId, subscription.Id);
await new DeleteSearchSubscription(dbContext.AsCallContext()).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new GetSearchSubscriptions.Request(userId);
var subscriptions = await new GetSearchSubscriptions(dbContext.AsCallContext()).RunAsync(request);
Assert.AreEqual(2, subscriptions.Count());
Assert.IsFalse(subscriptions.Any(s => s.Id == subscription.Id));
}
}
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 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 Filtering()
{
var db = DbHelper.GetEmptyTestDB();
var imageName = RandomHelper.String();
var user = await UserHelper.CreateInDbAsync(db);
await ImageHelper.CreateAsync(db, user, name : imageName);
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 1, RandomHelper.String()));
Assert.AreEqual(0, result.PageCount);
Assert.AreEqual(0, result.TotalCount);
Assert.IsFalse(result.Images.Any());
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 1, imageName));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(1, result.Images.Count());
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 1, imageName.Substring(1, 5)));
Assert.AreEqual(1, result.PageCount);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(1, result.Images.Count());
}
}
public async Task TagUsedInCards()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var otherTag = await TagHelper.CreateAsync(db);
var tagName = RandomHelper.String();
var description = RandomHelper.String();
var tag = await TagHelper.CreateAsync(db, tagName, description);
await CardHelper.CreateAsync(db, user, tagIds : new[] { tag, otherTag });
await CardHelper.CreateAsync(db, user, tagIds : new[] { tag });
await CardHelper.CreateAsync(db, user);
using var dbContext = new MemCheckDbContext(db);
var loadedTag = await new GetTag(dbContext.AsCallContext()).RunAsync(new GetTag.Request(tag));
Assert.AreEqual(tag, loadedTag.TagId);
Assert.AreEqual(tagName, loadedTag.TagName);
Assert.AreEqual(description, loadedTag.Description);
Assert.AreEqual(2, loadedTag.CardCount);
}
public async Task 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 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 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 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 static async Task CheckDeckContainsCards(DbContextOptions <MemCheckDbContext> testDB, Guid deck, params Guid[] cards)
{
using var dbContext = new MemCheckDbContext(testDB);
var matchingCardsInDeckCount = await dbContext.CardsInDecks.AsNoTracking().CountAsync(cardInDeck => cardInDeck.DeckId == deck && cards.Contains(cardInDeck.CardId));
Assert.AreEqual(cards.Length, matchingCardsInDeckCount);
}
public static async Task AddCardAsync(DbContextOptions <MemCheckDbContext> testDB, Guid deck, Guid card, int?heap = null, DateTime?lastLearnUtcTime = null, DateTime?addToDeckUtcTime = null)
{
heap ??= RandomHelper.Heap();
lastLearnUtcTime ??= RandomHelper.Date();
using var dbContext = new MemCheckDbContext(testDB);
DateTime expiryTime;
if (heap.Value != CardInDeck.UnknownHeap)
{
var heapingAlgo = await HeapingAlgorithm.OfDeckAsync(dbContext, deck);
expiryTime = heapingAlgo.ExpiryUtcDate(heap.Value, lastLearnUtcTime.Value);
}
else
{
expiryTime = DateTime.MinValue;
}
var cardForUser = new CardInDeck()
{
CardId = card,
DeckId = deck,
CurrentHeap = heap.Value,
LastLearnUtcTime = lastLearnUtcTime.Value,
ExpiryUtcTime = expiryTime,
AddToDeckUtcTime = addToDeckUtcTime ?? DateTime.UtcNow,
NbTimesInNotLearnedHeap = 1,
BiggestHeapReached = heap.Value
};
dbContext.CardsInDecks.Add(cardForUser);
await dbContext.SaveChangesAsync();
}
private async Task CheckCardVersionsCreatorsAsync(Guid cardId, MemCheckDbContext dbContext, ILocalized localizer)
{
var currentVersionCreator = await dbContext.Cards
.Include(card => card.VersionCreator)
.Where(card => card.Id == cardId)
.Select(card => card.VersionCreator)
.SingleAsync();
if (currentVersionCreator.Id != UserId && currentVersionCreator.DeletionDate == null)
{
//You are not the creator of the current version of the card with front side
//Vous n'êtes pas l'auteur de la version actuelle de la carte avec avant
throw new RequestInputException(localizer.Get("YouAreNotTheCreatorOfCurrentVersion") + await CardFrontSideInfoForExceptionMessageAsync(cardId, dbContext, localizer));
}
var anyPreviousVersionHasOtherCreator = await dbContext.CardPreviousVersions
.Include(version => version.VersionCreator)
.Where(version => version.Card == cardId && version.VersionCreator.Id != UserId && version.VersionCreator.DeletionDate == null)
.AnyAsync();
if (anyPreviousVersionHasOtherCreator)
{
//You are not the creator of all the previous versions of the card with front side
//Vous n'êtes pas l'auteur de toutes les versions précédentes de la carte avec avant
throw new RequestInputException(localizer.Get("YouAreNotTheCreatorOfAllPreviousVersions") + await CardFrontSideInfoForExceptionMessageAsync(cardId, dbContext, localizer));
}
}
public AdminController(MemCheckDbContext dbContext, UserManager <MemCheckUser> userManager, IStringLocalizer <AdminController> localizer, IEmailSender emailSender, LinkGenerator linkGenerator, TelemetryClient telemetryClient) : base(localizer)
{
callContext = new CallContext(dbContext, new MemCheckTelemetryClient(telemetryClient), this, new ProdRoleChecker(userManager));
this.emailSender = emailSender;
this.linkGenerator = linkGenerator;
this.userManager = userManager;
}
public async Task TwoPages()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var img1 = await ImageHelper.CreateAsync(db, user);
var img2 = await ImageHelper.CreateAsync(db, user);
var loaded = new HashSet <Guid>();
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 1, ""));
Assert.AreEqual(2, result.PageCount);
Assert.AreEqual(2, result.TotalCount);
loaded.Add(result.Images.Single().ImageId);
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 2, ""));
Assert.AreEqual(2, result.PageCount);
Assert.AreEqual(2, result.TotalCount);
loaded.Add(result.Images.Single().ImageId);
}
using (var dbContext = new MemCheckDbContext(db))
{
var result = await new GetImageList(dbContext.AsCallContext()).RunAsync(new GetImageList.Request(1, 3, ""));
Assert.AreEqual(2, result.PageCount);
Assert.AreEqual(2, result.TotalCount);
Assert.IsFalse(result.Images.Any());
}
Assert.IsTrue(loaded.Contains(img1));
Assert.IsTrue(loaded.Contains(img2));
}
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 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 ManageRoles(IServiceProvider serviceProvider)
{
dbContext = serviceProvider.GetRequiredService <MemCheckDbContext>();
logger = serviceProvider.GetRequiredService <ILogger <ManageRoles> >();
roleManager = serviceProvider.GetRequiredService <RoleManager <MemCheckUserRole> >();
userManager = serviceProvider.GetRequiredService <UserManager <MemCheckUser> >();
}
async public Task RunAsync(MemCheckDbContext dbContext)
{
var user = dbContext.Users.Where(user => user.UserName == "Voltan").Single();
var deck = dbContext.Decks.Where(deck => deck.Owner == user).First();
if (realCode)
{
var chronos = new List <double>();
for (int i = 0; i < 5; i++)
{
var realCodeChrono = Stopwatch.StartNew();
var request = new GetCardsToLearn.Request(user.Id, deck.Id, false, new Guid[0], new Guid[0], 30);
var runner = new GetCardsToLearn(dbContext);
var cards = await runner.RunAsync(request);
logger.LogInformation($"Got {cards.Count()} in {realCodeChrono.Elapsed}");
chronos.Add(realCodeChrono.Elapsed.TotalSeconds);
}
logger.LogInformation($"Average time: {chronos.Average()} seconds");
}
else
{
var chrono = Stopwatch.StartNew();
var logLines = await GetCardsToRepeatAsync(user.Id, deck.Id, new Guid[0], new Guid[0]);
chrono.Stop();
foreach (var logLine in logLines)
{
logger.LogInformation(logLine);
}
logger.LogInformation($"Ran in {chrono.Elapsed}");
}
}
public async Task DoesNotExist()
{
var db = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(db);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new UpdateTag(dbContext.AsCallContext()).RunAsync(new UpdateTag.Request(userId, Guid.NewGuid(), RandomHelper.String(), "")));
}
public async Task CardDoesNotExist()
{
var db = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(db);
using var dbContext = new MemCheckDbContext(DbHelper.GetEmptyTestDB());
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetCardVersions(dbContext.AsCallContext()).RunAsync(new GetCardVersions.Request(userId, Guid.NewGuid())));
}
public AdminController(MemCheckDbContext dbContext, UserManager <MemCheckUser> userManager, IStringLocalizer <TagsController> localizer, IEmailSender emailSender, IHttpContextAccessor contextAccessor, LinkGenerator linkGenerator) : base()
{
this.dbContext = dbContext;
this.localizer = localizer;
this.emailSender = emailSender;
this.userManager = userManager;
authoringPageLink = linkGenerator.GetUriByPage(contextAccessor.HttpContext, page: "/Authoring/Index");
}
public GetCurrentUserViewModel(MemCheckUser user, MemCheckDbContext dbContext)
{
UserId = user.Id;
UserName = user.UserName;
var cardLanguage = user.PreferredCardCreationLanguage ?? dbContext.CardLanguages.OrderBy(lang => lang.Name).First();
PreferredCardCreationLanguageId = cardLanguage.Id;
}
private static IMigrationsAssembly GetMigrationsAssembly()
{
using var dbContext = new MemCheckDbContext(new DbContextOptionsBuilder <MemCheckDbContext>().UseSqlServer(@"Server=none;Database=none;Trusted_Connection=True;").Options);
IMigrationsAssembly?result = dbContext.GetService <IMigrationsAssembly>();
Assert.IsNotNull(result);
return(result);
}
public MakeUserAdmin(IServiceProvider serviceProvider)
{
dbContext = serviceProvider.GetRequiredService <MemCheckDbContext>();
logger = serviceProvider.GetRequiredService <ILogger <MakeUserAdmin> >();
roleManager = serviceProvider.GetRequiredService <RoleManager <MemCheckUserRole> >();
userManager = serviceProvider.GetRequiredService <UserManager <MemCheckUser> >();
listUsers = new ListUsers(serviceProvider);
}
public async Task NameWithForbiddenChar()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new CreateLanguage(dbContext.AsCallContext()).RunAsync(new CreateLanguage.Request(user, "a<b")));
}
public async Task NameTooLong()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new CreateLanguage(dbContext.AsCallContext()).RunAsync(new CreateLanguage.Request(user, RandomHelper.String(QueryValidationHelper.LanguageMaxNameLength + 1))));
}
public async Task NameNotTrimmed()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new CreateLanguage(dbContext.AsCallContext()).RunAsync(new CreateLanguage.Request(user, RandomHelper.String(QueryValidationHelper.LanguageMinNameLength) + '\t')));
}
