public void GetOrCreateChapterAsyncShouldReturnChapterIfItExistsForTheCurrentPeriod()
{
//Arrange
var existingPeriod = new Period {
Id = _random.NextPositive()
};
var courseCode = Guid.NewGuid().ToString();
var existingChapter = new ChapterBuilder().WithId()
.WithCourse(courseCode)
.WithPeriod(existingPeriod).Build();
_periodRepositoryMock.Setup(repo => repo.GetCurrentPeriodAsync()).ReturnsAsync(existingPeriod);
_chapterRepositoryMock.Setup(repo => repo.GetSingleAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
//Act
var result = _service.GetOrCreateChapterAsync(courseCode, existingChapter.Number).Result;
//Assert
_periodRepositoryMock.Verify(repo => repo.GetCurrentPeriodAsync(), Times.Once);
_chapterRepositoryMock.Verify(repo => repo.GetSingleAsync(courseCode, existingChapter.Number, existingPeriod.Id), Times.Once);
_chapterRepositoryMock.Verify(repo => repo.AddAsync(It.IsAny <Chapter>()), Times.Never);
Assert.That(result, Is.EqualTo(existingChapter));
}
public void LoadChapterWithTestsAsyncShouldLoadTheChapterItsExercisesAndItsTests()
{
//Arrange
var existingPeriod = new Period();
var courseCode = Guid.NewGuid().ToString();
var existingChapter = new ChapterBuilder().WithId()
.WithCourse(courseCode)
.WithPeriod(existingPeriod).Build();
_periodRepositoryMock.Setup(repo => repo.GetCurrentPeriodAsync()).ReturnsAsync(existingPeriod);
_chapterRepositoryMock.Setup(repo => repo.LoadWithExercisesAndTestsAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
//Act
var result = _service.LoadChapterWithTestsAsync(existingChapter.CourseId, existingChapter.Number).Result;
//Assert
_periodRepositoryMock.Verify(repo => repo.GetCurrentPeriodAsync(), Times.Once);
_chapterRepositoryMock.Verify();
_chapterRepositoryMock.Verify(repo => repo.LoadWithExercisesAndTestsAsync(existingChapter.CourseId, existingChapter.Number, existingPeriod.Id), Times.Once);
Assert.That(result, Is.EqualTo(existingChapter));
}
public async Task Setup()
{
var reader = AccountBuilder.InLibrary(LibraryId).As(Role.Reader).Build();
_chapter = ChapterBuilder.WithLibrary(LibraryId).WithContents().WithoutAnyAssignment().Build();
_response = await Client.PostObject($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.ChapterNumber}/assign", new { AccountId = reader.Id, Type = "write" });
}
public async Task Setup()
{
var _newContents = RandomData.Words(12);
var chapter = ChapterBuilder.WithLibrary(LibraryId).WithoutContents().Build();
_response = await Client.DeleteAsync($"/libraries/{LibraryId}/books/{chapter.BookId}/chapters/{chapter.ChapterNumber}/contents?language={RandomData.Locale}");
}
public async Task Setup()
{
var book = BookBuilder.WithLibrary(LibraryId).Build();
var chapter = ChapterBuilder.WithLibrary(LibraryId).Build();
_response = await Client.PostString($"/libraries/{-RandomData.Number}/books/{book.Id}/chapters/{chapter.Id}/contents?language={RandomData.Locale}", RandomData.String, RandomData.Locale);
}
public void ToChapterSummaryModel_ShouldCorrectlyConvertValidChapter(int numberOfTests,
int numberOfPassingTests,
int numberOfFailingTests,
int numberOfUsers)
{
//Arrange
var chapter = new ChapterBuilder().WithId().WithExercises(5, numberOfTests).Build();
var userExerciseResults = GenerateAssignmentResults(chapter, numberOfPassingTests, numberOfFailingTests);
//Act
var model = _converter.ToChapterSummaryModel(chapter, userExerciseResults);
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.Id, Is.EqualTo(chapter.Id));
Assert.That(model.Number, Is.EqualTo(chapter.Number));
Assert.That(model.ExerciseSummaries, Is.Not.Null);
Assert.That(model.ExerciseSummaries.Count, Is.EqualTo(chapter.Exercises.Count));
foreach (var exercise in chapter.Exercises)
{
var userExerciseSummary = model.ExerciseSummaries.FirstOrDefault(summary => summary.ExerciseId == exercise.Id);
Assert.That(userExerciseSummary, Is.Not.Null);
Assert.That(userExerciseSummary.Code, Is.EqualTo(exercise.Code));
Assert.That(userExerciseSummary.NumberOfPassedTests, Is.EqualTo(numberOfPassingTests));
Assert.That(userExerciseSummary.NumberOfFailedTests, Is.EqualTo(numberOfFailingTests));
Assert.That(userExerciseSummary.NumberOfTests, Is.EqualTo(numberOfTests));
}
}
public void GetChapterSummaryShouldReturnContentsIfParamatersAreValid()
{
//Arrange
var existingChapter = new ChapterBuilder().WithId().Build();
var chapterContents = new ChapterSummaryModel();
var userExerciseResults = new List <AssignmentResultDto>();
_chapterServiceMock.Setup(service => service.LoadChapterWithTestsAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
_chapterServiceMock.Setup(service => service.GetResultsForUserAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime?>()))
.ReturnsAsync(userExerciseResults);
_chapterConverterMock.Setup(converter => converter.ToChapterSummaryModel(It.IsAny <Chapter>(),
It.IsAny <IList <AssignmentResultDto> >()))
.Returns(chapterContents);
//Act
var actionResult = _controller.GetChapterSummary(existingChapter.CourseId, existingChapter.Number, _userId, null).Result as OkObjectResult;
//Assert
Assert.That(actionResult, Is.Not.Null);
_chapterServiceMock.Verify(service => service.LoadChapterWithTestsAsync(existingChapter.CourseId, existingChapter.Number), Times.Once);
_chapterServiceMock.Verify(service => service.GetResultsForUserAsync(existingChapter.Id, _userId, null), Times.Once);
_chapterConverterMock.Verify(converter => converter.ToChapterSummaryModel(existingChapter, userExerciseResults), Times.Once);
Assert.That(actionResult.Value, Is.EqualTo(chapterContents));
}
public async Task Setup()
{
_chapter = ChapterBuilder.WithLibrary(LibraryId).Private().WithContents().Build();
var content = ChapterBuilder.Contents.Single(x => x.ChapterId == _chapter.Id);
_response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.Id}/contents?language={content.Language}");
}
public void GetChapterStatisticsShouldNotUseCacheWhenDateIsTooFarInThePast()
{
//Arrange
var existingChapter = new ChapterBuilder().WithId().Build();
var chapterStatistics = new List <AssignmentStatisticsDto>();
var chapterStatisticsModel = new ChapterStatisticsModel();
var aLongTimeAgo = DateTime.Now.AddSeconds(-ChapterController.CacheTimeInSeconds - 1);
_chapterServiceMock.Setup(service => service.LoadChapterAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
_chapterServiceMock.Setup(service => service.GetChapterStatisticsAsync(It.IsAny <int>(), It.IsAny <DateTime?>()))
.ReturnsAsync(chapterStatistics);
_chapterConverterMock.Setup(converter => converter.ToChapterStatisticsModel(It.IsAny <Chapter>(), It.IsAny <IList <AssignmentStatisticsDto> >()))
.Returns(chapterStatisticsModel);
//Act
var actionResult = _controller.GetChapterStatistics(existingChapter.CourseId, existingChapter.Number, aLongTimeAgo).Result as OkObjectResult;
//Assert
Assert.That(actionResult, Is.Not.Null);
object cachedEntry;
_memoryCacheMock.Verify(cache => cache.TryGetValue(It.IsAny <object>(), out cachedEntry), Times.Never);
_chapterServiceMock.Verify(service => service.LoadChapterAsync(existingChapter.CourseId, existingChapter.Number), Times.Once);
_chapterServiceMock.Verify(service => service.GetChapterStatisticsAsync(existingChapter.Id, aLongTimeAgo.ToUniversalTime()), Times.Once);
_chapterConverterMock.Verify(converter => converter.ToChapterStatisticsModel(existingChapter, chapterStatistics), Times.Once);
Assert.That(actionResult.Value, Is.EqualTo(chapterStatisticsModel));
}
public void GetChapterStatisticsShouldReturnStatisticsIfParamatersAreValid()
{
//Arrange
var existingChapter = new ChapterBuilder().WithId().Build();
var chapterStatistics = new List <AssignmentStatisticsDto>();
var chapterStatisticsModel = new ChapterStatisticsModel();
var date = DateTime.Now.AddDays(-1);
_chapterServiceMock.Setup(service => service.LoadChapterAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
_chapterServiceMock.Setup(service => service.GetChapterStatisticsAsync(It.IsAny <int>(), It.IsAny <DateTime?>()))
.ReturnsAsync(chapterStatistics);
_chapterConverterMock.Setup(converter => converter.ToChapterStatisticsModel(It.IsAny <Chapter>(), It.IsAny <IList <AssignmentStatisticsDto> >()))
.Returns(chapterStatisticsModel);
//Act
var actionResult = _controller.GetChapterStatistics(existingChapter.CourseId, existingChapter.Number, date).Result as OkObjectResult;
//Assert
Assert.That(actionResult, Is.Not.Null);
_chapterServiceMock.Verify(service => service.LoadChapterAsync(existingChapter.CourseId, existingChapter.Number), Times.Once);
_chapterServiceMock.Verify(service => service.GetChapterStatisticsAsync(existingChapter.Id, date.ToUniversalTime()), Times.Once);
_chapterConverterMock.Verify(converter => converter.ToChapterStatisticsModel(existingChapter, chapterStatistics), Times.Once);
Assert.That(actionResult.Value, Is.EqualTo(chapterStatisticsModel));
}
public async Task Setup()
{
_expected = ChapterBuilder.WithLibrary(LibraryId).Build(4).First();
_response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_expected.BookId}/chapters/{_expected.ChapterNumber}");
_assert = ChapterAssert.FromResponse(_response, LibraryId);
}
public async Task Setup()
{
_chapter = ChapterBuilder.WithLibrary(LibraryId).Build();
_response = await Client.PostString($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.ChapterNumber}/contents", RandomData.String, null);
_assert = new ChapterContentAssert(_response, Library);
}
public async Task Setup()
{
_chapter = ChapterBuilder.WithLibrary(LibraryId).Public().Build();
_contents = RandomData.String;
_response = await Client.PostString($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.ChapterNumber}/contents?language={RandomData.Locale}", _contents, RandomData.Locale);
_assert = new ChapterContentAssert(_response, LibraryId);
}
public async Task Setup()
{
var _newContents = RandomData.Words(12);
var chapter = ChapterBuilder.WithLibrary(LibraryId).WithContents().Build();
_content = ChapterBuilder.Contents.Single(x => x.ChapterId == chapter.Id);
_response = await Client.DeleteAsync($"/libraries/{LibraryId}/books/{chapter.BookId}/chapters/{chapter.ChapterNumber}/contents?language={_content.Language}");
}
public async Task Setup()
{
_chapter = ChapterBuilder.WithLibrary(LibraryId).Public().WithContents().Build();
_content = ChapterBuilder.Contents.Single(x => x.ChapterId == _chapter.Id);
_newContents = RandomData.String;
_response = await Client.PutString($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.Id}/contents?language={_content.Language}", _newContents);
}
public async Task Setup()
{
_chapter = ChapterBuilder.WithLibrary(LibraryId).Public().WithContents().Build();
_content = ChapterBuilder.Contents.Single(x => x.ChapterId == _chapter.Id);
_response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_chapter.BookId}/chapters/{_chapter.ChapterNumber}/contents?language={_content.Language}");
_assert = new ChapterContentAssert(_response, LibraryId);
}
public async Task Setup()
{
_chapters = ChapterBuilder.WithLibrary(LibraryId).WithContents().Build(4);
_book = DatabaseConnection.GetBookById(_chapters.PickRandom().BookId);
_response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_book.Id}/chapters");
_view = _response.GetContent <ListView <ChapterView> >().Result;
}
public async Task Setup()
{
var chapters = ChapterBuilder.WithLibrary(LibraryId).WithContents(2).Build(4);
_expected = chapters.PickRandom();
_response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_expected.BookId}/chapters/{_expected.ChapterNumber}");
_assert = ChapterAssert.FromResponse(_response, LibraryId);
}
public async Task Setup()
{
var chapters = ChapterBuilder.WithLibrary(LibraryId).WithContents().Build(4);
var chapter = chapters.PickRandom();
var chapter2 = new ChapterView {
Title = RandomData.Name
};
_response = await Client.PutObject($"/libraries/{LibraryId}/books/{chapter.BookId}/chapters/{chapter.ChapterNumber}", chapter2);
}
public void ToExerciseDetailModel_ShouldThrowArgumentExceptionIfCourseOfChapterOfExerciseIsNotLoaded()
{
//Arrange
var chapter = new ChapterBuilder().WithoutCourseLoaded().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act + Assert
Assert.That(
() => _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), new ExerciseTestRunInfoDto()),
Throws.ArgumentException);
}
public void ToExerciseDetailModel_ShouldThrowArgumentExceptionIfTestRunInfoIsNotProvided()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act + Assert
Assert.That(
() => _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), null),
Throws.ArgumentNullException);
}
public void GetOrCreateChapterAsync_ShouldThrowDataNotFoundExeptionWhenNoCurrentPeriodIsFound()
{
//Arrange
var courseCode = Guid.NewGuid().ToString();
var existingChapter = new ChapterBuilder().WithId().Build();
_periodRepositoryMock.Setup(repo => repo.GetCurrentPeriodAsync()).Throws <DataNotFoundException>();
//Act + Assert
Assert.That(() => _service.GetOrCreateChapterAsync(courseCode, existingChapter.Number).Result,
Throws.InstanceOf <AggregateException>().With.Matches((AggregateException ex) =>
ex.InnerExceptions.OfType <DataNotFoundException>().Any()));
}
public async Task Setup()
{
var chapters = ChapterBuilder.WithLibrary(LibraryId).Build(4);
var chapter = chapters.PickRandom();
newChapter = new ChapterView {
Title = RandomData.Name, BookId = chapter.BookId
};
_response = await Client.PutObject($"/libraries/{LibraryId}/books/{chapter.BookId}/chapters/{chapter.ChapterNumber}", newChapter);
_assert = ChapterAssert.FromResponse(_response, LibraryId);
}
public void ToChapterModel_ShouldCorrectlyCovertValidChapter()
{
//Arrange
var chapter = new ChapterBuilder().WithId().Build();
//Act
var model = _converter.ToChapterModel(chapter);
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.Id, Is.EqualTo(chapter.Id));
Assert.That(model.Number, Is.EqualTo(chapter.Number));
}
public void ToChapterSummaryModel_ShouldThrowArgumentExceptionWhenTestsOfExercisesAreMissing()
{
//Arrange
var chapter = new ChapterBuilder().WithExercises(1, 1).Build();
chapter.Exercises.First().Tests = null;
var userExerciseResults = new List <AssignmentResultDto>();
// var averageExerciseResults = new List<AssignmentResultDto>();
//Act + Assert
Assert.That(() => _converter.ToChapterSummaryModel(chapter, userExerciseResults), Throws.InstanceOf <ArgumentException>());
}
public void ToExerciseDetailModel_ShouldAlsoWorkWhenNoTestResultsAreProvided()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act
var model = _converter.ToExerciseDetailModel(exercise, null, new ExerciseTestRunInfoDto());
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.TestResults, Is.Not.Null);
Assert.That(model.TestResults, Has.Count.Zero);
}
public void ToExerciseDetailModel_ShouldHaveATestResultForEachTest()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var numberOfTests = _random.Next(2, 10);
var exercise = new ExerciseBuilder().WithChapter(chapter).WithRandomTests(numberOfTests).Build();
//Act
var model = _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), new ExerciseTestRunInfoDto());
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.TestResults, Is.Not.Null);
Assert.That(model.TestResults, Has.Count.EqualTo(exercise.Tests.Count));
}
public void GetChapterStatisticsShouldCacheCreatedModel()
{
//Arrange
var existingChapter = new ChapterBuilder().WithId().Build();
var chapterStatistics = new List <AssignmentStatisticsDto>();
var chapterStatisticsModel = new ChapterStatisticsModel();
var date = DateTime.Now.AddSeconds(-ChapterController.CacheTimeInSeconds + 1);
var expectedCacheKey = $"GetChapterStatistics-{existingChapter.CourseId}-{existingChapter.Number}";
_chapterServiceMock.Setup(service => service.LoadChapterAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(existingChapter);
_chapterServiceMock.Setup(service => service.GetChapterStatisticsAsync(It.IsAny <int>(), It.IsAny <DateTime?>()))
.ReturnsAsync(chapterStatistics);
_chapterConverterMock.Setup(converter => converter.ToChapterStatisticsModel(It.IsAny <Chapter>(), It.IsAny <IList <AssignmentStatisticsDto> >()))
.Returns(chapterStatisticsModel);
object cachedChapterStatisticsModel;
_memoryCacheMock.Setup(cache => cache.TryGetValue(It.IsAny <object>(), out cachedChapterStatisticsModel))
.Returns(false);
var cacheEntryMock = new Mock <ICacheEntry>();
_memoryCacheMock.Setup(cache => cache.CreateEntry(It.IsAny <object>())).Returns(cacheEntryMock.Object);
//Act
var actionResult = _controller.GetChapterStatistics(existingChapter.CourseId, existingChapter.Number, date).Result as OkObjectResult;
//Assert
Assert.That(actionResult, Is.Not.Null);
_memoryCacheMock.Verify(cache => cache.TryGetValue(expectedCacheKey, out cachedChapterStatisticsModel), Times.Once);
_memoryCacheMock.Verify(cache => cache.CreateEntry(expectedCacheKey), Times.Once);
Assert.That(actionResult.Value, Is.EqualTo(chapterStatisticsModel));
}
public void ToExerciseDetailModel_ShouldCorrectlyConvertTestRunInfoFields()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
var utcNow = DateTime.UtcNow;
var testRunInfo = new ExerciseTestRunInfoDto
{
FirstRunDateTime = utcNow.AddDays(-1),
LastRunDateTime = utcNow,
NumberOfRuns = _random.NextPositive()
};
//Act
var model = _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), testRunInfo);
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.FirstRun, Is.EqualTo(testRunInfo.FirstRunDateTime));
Assert.That(model.LastRun, Is.EqualTo(testRunInfo.LastRunDateTime));
Assert.That(model.NumberOfRuns, Is.EqualTo(testRunInfo.NumberOfRuns));
}
public void GetOrCreateChapterAsyncShouldCreateChapterIfItDoesNotExist()
{
//Arrange
var existingPeriod = new Period()
{
Id = _random.NextPositive()
};
_periodRepositoryMock.Setup(repo => repo.GetCurrentPeriodAsync()).ReturnsAsync(existingPeriod);
var existingCourse = new CourseBuilder().WithId().Build();
_courseRepositoryMock.Setup(repo => repo.GetSingleAsync(It.IsAny <string>())).ReturnsAsync(existingCourse);
_chapterRepositoryMock.Setup(repo => repo.GetSingleAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()))
.Throws <DataNotFoundException>();
var addedChapter = new ChapterBuilder().WithId().Build();
_chapterRepositoryMock.Setup(repo => repo.AddAsync(It.IsAny <Chapter>())).ReturnsAsync(addedChapter);
//Act
var result = _service.GetOrCreateChapterAsync(existingCourse.Code, addedChapter.Number).Result;
//Assert
_periodRepositoryMock.Verify(repo => repo.GetCurrentPeriodAsync(), Times.Once);
_chapterRepositoryMock.Verify(repo => repo.GetSingleAsync(existingCourse.Code, addedChapter.Number, existingPeriod.Id), Times.Once);
_chapterRepositoryMock.Verify(
repo => repo.AddAsync(It.Is <Chapter>(ch =>
ch.PeriodId == existingPeriod.Id && ch.CourseId == existingCourse.Id &&
ch.Number == addedChapter.Number)), Times.Once);
_courseRepositoryMock.Verify(repo => repo.GetSingleAsync(existingCourse.Code), Times.Once);
Assert.That(result, Is.EqualTo(addedChapter));
}