public void DeveAlterarPublicoAlvo()
{
var valorEsperado = _faker.PickRandom<TargetAudience>();
var curso = CourseBuilder.New().Build();
curso.UpdateTargetAudience(valorEsperado);
curso.TargetAudience.Should().Be(valorEsperado);
}
private void SetupDbState()
{
var optedIn = Context.Providers.First(x => x.ProviderCode == OptedInProviderCode && x.OptedIn);
var allTypes = Enum.GetValues(typeof(CourseType)).Cast <CourseType>().ToArray();
Context.Courses.Add(CourseBuilder.Build("allTypes", allTypes, optedIn));
allTypes = allTypes.Where(x => x != CourseType.RunningPublished).ToArray();
Context.Courses.Add(CourseBuilder.Build("allTypes_1", allTypes, optedIn));
allTypes = allTypes.Where(x => x != CourseType.RunningUnpublished).ToArray();
Context.Courses.Add(CourseBuilder.Build("allTypes_2", allTypes, optedIn));
allTypes = allTypes.Where(x => x != CourseType.NewUnpublished).ToArray();
Context.Courses.Add(CourseBuilder.Build("allTypes_3", allTypes, optedIn));
allTypes = allTypes.Where(x => x != CourseType.NewPublished).ToArray();
Context.Courses.Add(CourseBuilder.Build("allTypes_4", allTypes, optedIn));
Context.Save();
}
public IActionResult Edit(int?id)
{
if (this.CurrentUserCanWrite())
{
Course course;
if (id.HasValue)
{
course = this.CourseForId(id.Value);
}
else
{
CourseBuilder courseBuilder = new CourseBuilder(this.DatabaseContext);
courseBuilder.Title = "Neuer Kurs";
courseBuilder.Designation = "Bezeichnung";
courseBuilder.Year = DateTime.Now.Year;
courseBuilder.Save();
course = courseBuilder.Course();
}
return(View(course));
}
else
{
return(RedirectToAction("index"));
}
}
public void DeveAlterarCargaHoraria()
{
var valorEsperado = _faker.Random.Int(50, 1000);
var curso = CourseBuilder.New().Build();
curso.UpdateWorkload(valorEsperado);
curso.Workload.Should().Be(valorEsperado);
}
public void Post_ValidCourseIsSavedInRepository()
{
// Arrange
var newCourse = new CourseBuilder().Build();
_coursesRepositoryMock.Setup(repo => repo.Add(It.IsAny <Course>())).Returns(() =>
{
newCourse.CourseID = new Random().Next(1, int.MaxValue);
return(newCourse);
});
var urlHelperMock = new Mock <UrlHelper>();
urlHelperMock.Setup(helper => helper.Link(It.IsAny <string>(), It.IsAny <object>())).Returns(() => Guid.NewGuid().ToString());
_controller.Url = urlHelperMock.Object;
// Act
var actionResult = _controller.Post(newCourse) as CreatedNegotiatedContentResult <Course>;
// Assert
Assert.That(actionResult, Is.Not.Null);
Assert.That(actionResult.Content.CourseID, Is.GreaterThan(0));
Assert.That(actionResult.Content.Title, Is.EqualTo(newCourse.Title));
_coursesRepositoryMock.Verify(repo => repo.Add(newCourse), Times.Once);
urlHelperMock.Verify(helper => helper.Link("DefaultApi", It.IsAny <object>()), Times.Once);
}
public void GetOrCreateProjectAsync_ShouldCreateProjectIfItDoesNotExist()
{
//Arrange
var existingPeriod = new Period {
Id = _random.NextPositive()
};
var existingCourse = new CourseBuilder().WithId().Build();
_periodRepositoryMock.Setup(repo => repo.GetCurrentPeriodAsync()).ReturnsAsync(existingPeriod);
_courseRepositoryMock.Setup(repo => repo.GetSingleAsync(It.IsAny <string>())).ReturnsAsync(existingCourse);
_projectRepositoryMock
.Setup(repo => repo.GetSingleAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()))
.Throws <DataNotFoundException>();
var addedProject = new ProjectBuilder().WithId().Build();
_projectRepositoryMock.Setup(repo => repo.AddAsync(It.IsAny <Project>())).ReturnsAsync(addedProject);
//Act
var result = _service.GetOrCreateProjectAsync(existingCourse.Code, addedProject.Code).Result;
//Assert
_periodRepositoryMock.Verify(repo => repo.GetCurrentPeriodAsync(), Times.Once);
_projectRepositoryMock.Verify(repo => repo.GetSingleAsync(existingCourse.Code, addedProject.Code, existingPeriod.Id), Times.Once);
_projectRepositoryMock.Verify(
repo => repo.AddAsync(It.Is <Project>(p =>
p.PeriodId == existingPeriod.Id && p.CourseId == existingCourse.Id &&
p.Code == addedProject.Code)), Times.Once);
_courseRepositoryMock.Verify(repo => repo.GetSingleAsync(existingCourse.Code), Times.Once);
Assert.That(result, Is.EqualTo(addedProject));
}
public void ToCourseContentsModel_ShouldCorrectlyConvertValidData()
{
//Arrange
var course = new CourseBuilder().WithId().Build();
var chapters = new List <Chapter>
{
new ChapterBuilder().Build(),
new ChapterBuilder().Build()
};
//Act
var model = _converter.ToCourseContentsModel(course, chapters);
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.Id, Is.EqualTo(course.Id));
Assert.That(model.Code, Is.EqualTo(course.Code));
Assert.That(model.Name, Is.EqualTo(course.Name));
Assert.That(model.Chapters, Is.Not.Null);
Assert.That(model.Chapters, Has.Count.EqualTo(chapters.Count));
foreach (var chapter in chapters)
{
_chapterConverter.Verify(converter => converter.ToChapterModel(chapter), Times.Once);
}
}
public void CursoNaoDeveSerAlteradoComValorMenorQue1(double invalidFee)
{
var course = CourseBuilder.New().Build();
FluentActions.Invoking(() => course.UpdateCourseFee(invalidFee))
.Should().Throw<DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidCourseFee));
}
public void CursoNaoDeveSerCriadoComCargaHorariaMenorQue1(int invalidWorkload)
{
FluentActions.Invoking(() => CourseBuilder.New().WithWorkload(invalidWorkload).Build())
.Should().Throw<DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidWorkload));
}
public void FundingOptions_Salary()
{
var course = CourseBuilder.BuildCourse("Salary")
.AddSalary();
course.FundingOptions().Should().Be(CourseExtensions.FundingOption_Salary);
}
public void FundingOptions_Bursary()
{
var course = CourseBuilder.BuildCourse("Bursary")
.AddBursarySubject();
course.FundingOptions().Should().Be(CourseExtensions.FundingOption_Bursary);
}
public void GetCourseContentsShouldGetTheChaptersFromTheRepositoryAndConvertThemToModels()
{
//Arrange
var existingCourse = new CourseBuilder().WithId().Build();
var existingChapters = new List <Chapter>
{
new ChapterBuilder().Build(),
new ChapterBuilder().Build(),
};
var convertedCourse = new CourseContentsModel();
_chapterServiceMock.Setup(service => service.GetChaptersOfCourseAsync(It.IsAny <int>())).ReturnsAsync(existingChapters);
var courseId = _random.NextPositive();
_courseServiceMock.Setup(service => service.GetCourseByIdAsync(It.IsAny <int>()))
.ReturnsAsync(existingCourse);
_courseConverterMock
.Setup(converter => converter.ToCourseContentsModel(It.IsAny <Course>(), It.IsAny <IList <Chapter> >()))
.Returns(convertedCourse);
//Act
var actionResult = _controller.GetCourseContents(courseId).Result as OkObjectResult;
//Assert
Assert.That(actionResult, Is.Not.Null);
_chapterServiceMock.Verify(service => service.GetChaptersOfCourseAsync(courseId), Times.Once);
_courseConverterMock.Verify(converter => converter.ToCourseContentsModel(existingCourse, existingChapters), Times.Once);
Assert.That(actionResult.Value, Is.EqualTo(convertedCourse));
}
public void CourseWithBursary_HasBursary_IsTrue()
{
var course = CourseBuilder.BuildCourse("Bursary")
.AddBursarySubject();
course.HasBursary().Should().BeTrue("There is funding on the course");
}
public void FundingOptions_Scholarship()
{
var course = CourseBuilder.BuildCourse("Scholarship")
.AddBursaryAndScholarshipSubject();
course.FundingOptions().Should().Be(CourseExtensions.FundingOption_Scholarship);
}
public void CourseWithBursaryAndScholarship_HasScholarshipAndBursary_IsTrue()
{
var course = CourseBuilder.BuildCourse("Scholarship")
.AddBursaryAndScholarshipSubject();
course.HasScholarshipAndBursary().Should().BeTrue("There is scholarship funding on the course");
}
public void LessonCompleted_DoesntIncrementProgressForFinishedLessonAchievements()
{
//arrange
var course = new CourseBuilder().Build();
var typesToUpdate = new AchievementTypesToUpdate {
LessonCompleted = true
};
var availableAchievements = new List <Achievement>
{
new AchievementBuilder().WithValues(3, AchievementType.CompleteLesson).Build(), //[0]
new AchievementBuilder().WithValues(5, AchievementType.CompleteLesson).Build(), //[1]
new AchievementBuilder().WithValues(2, AchievementType.CompleteChapter).Build(), //[2]
new AchievementBuilder().WithValues(1, AchievementType.CompleteCourse).Build() //[3]
};
var user = new UserBuilder()
.AddAchievement(availableAchievements[0], 3) //isCompleted
.AddAchievement(availableAchievements[1], 3) //3 out of 5
.AddAchievement(availableAchievements[2], 1) //1 chapter out of 2
.Build();
var utcNow = DateTime.UtcNow;
//act
var achievementsUpdatedNow = updater.UpdateUserAchievements(user, course, typesToUpdate,
availableAchievements, utcNow);
//assert
//modified achievements
Assert.Single(achievementsUpdatedNow);
Assert.Equal(4, achievementsUpdatedNow[0].Progress);
Assert.False(achievementsUpdatedNow[0].IsCompleted);
//not modified achievements
Assert.Equal(3, user.Achievements.ToList()[0].Progress); //isCompleted lesson achievement remains unchanged
Assert.Equal(1, user.Achievements.ToList()[2].Progress); //chapter achievement remains unchanged
Assert.Equal(3, user.Achievements.Count);
}
public void CourseWithBursary_HasScholarshipAndBursary_IsFalse()
{
var course = CourseBuilder.BuildCourse("Bursary")
.AddBursarySubject();
course.HasScholarshipAndBursary().Should().BeFalse("There is only a bursary on the course");
}
public void DeveAlterarDescricao()
{
var valorEsperado = _faker.Lorem.Paragraphs(3);
var curso = CourseBuilder.New().Build();
curso.UpdateDescription(valorEsperado);
curso.Description.Should().Be(valorEsperado);
}
public void DeveAlterarNome()
{
var valorEsperado = _faker.Random.Word();
var curso = CourseBuilder.New().Build();
curso.UpdateName(valorEsperado);
curso.Name.Should().Be(valorEsperado);
}
public void OverriddenFunding(string courseName)
{
using (new AssertionScope())
{
var course1 = CourseBuilder.BuildCourse(courseName)
.AddBursarySubject()
.AddBursaryAndScholarshipSubject();
course1.FundingOptions().Should().Be(CourseExtensions.FundingOption_StudentFinance);
var course2 = CourseBuilder.BuildCourse(courseName)
.AddSubject()
.AddBursaryAndScholarshipSubject();
course2.FundingOptions().Should().Be(CourseExtensions.FundingOption_StudentFinance);
var course3 = CourseBuilder.BuildCourse(courseName)
.AddSubject()
.AddBursarySubject();
course3.FundingOptions().Should().Be(CourseExtensions.FundingOption_StudentFinance);
var course4 = CourseBuilder.BuildCourse(courseName)
.AddSubject();
course4.FundingOptions().Should().Be(CourseExtensions.FundingOption_StudentFinance);
var course5 = CourseBuilder.BuildCourse(courseName)
.AddSubject()
.AddSubject();
course5.FundingOptions().Should().Be(CourseExtensions.FundingOption_StudentFinance);
var course6 = CourseBuilder.BuildCourse(courseName)
.AddBursarySubject();
course6.FundingOptions().Should().Be(CourseExtensions.FundingOption_Bursary);
var course7 = CourseBuilder.BuildCourse(courseName)
.AddBursaryAndScholarshipSubject();
course7.FundingOptions().Should().Be(CourseExtensions.FundingOption_Scholarship);
}
}
public void CursoNaoDeveSerCriadoComNomeInválido(string invalidName)
{
FluentActions.Invoking(() => CourseBuilder.New().WithName(invalidName).Build())
.Should()
.Throw<DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidName));
}
public void ShouldMap()
{
var entity = new CourseBuilder().Build();
var model = new CourseToCourseJsonModelMapper().Build(entity);
model.CourseCode.ShouldBe(entity.CourseCode);
model.CourseTitle.ShouldBe(entity.CourseTitle);
}
public void CursoNaoDeveSerAlteradoComNomeInválido(string invalidName)
{
var course = CourseBuilder.New().Build();
FluentActions.Invoking(() => course.UpdateName(invalidName))
.Should()
.Throw<DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidName));
}
public void ToChapterSummaryModel_ShouldThrowArgumentExceptionWhenChaptersAreMissing()
{
//Arrange
var course = new CourseBuilder().WithId().Build();
//Act + Assert
Assert.That(() => _converter.ToCourseContentsModel(course, null), Throws.InstanceOf <ArgumentException>());
}
public void NaoDeveAdicionarCursoComOMesmoNomeEIdDiferenteDoOutroSalvo()
{
var cursoJaSalvo = CourseBuilder.New().WithName(_courseDTO.Name).WithId(40).Build();
_courseRepositoryMock.Setup(r => r.GetByName(_courseDTO.Name)).Returns(cursoJaSalvo);
_courseDTO.Id = 60;
FluentActions.Invoking(() => _courseService.Save(_courseDTO)).Should().Throw <DomainException>().Where(d => d.ErrorMessages.Contains(Resource.CourseNameAlreadyExists));
}
public void ShouldNot_Add_CourseWithSameNameOfOtherCourseAlreadyExistent()
{
var courseAlreadySave = CourseBuilder.New().WithName(_courseDto.Name).Build();
_courseRepositoryMock.Setup(r => r.GetByName(_courseDto.Name)).Returns(courseAlreadySave);
Assert.Throws <ArgumentException>(() => _courseStore.Store(_courseDto))
.WithMessage("Course's name already exists on database");
}
public void ShouldNotAddCourseWithSameName()
{
var courseAlreadySave = CourseBuilder.New().WithName(_courseDto.Name).Build();
_courseRepositoryMock.Setup(r => r.GetByName(_courseDto.Name)).Returns(courseAlreadySave);
Assert.Throws <DomainException>(() => _courseService.Add(_courseDto))
.WithMessage(Messages.NAME_IS_ALREADY_EXISTS);
}
public void ShouldNotCreateWithTargetAudienceIsDiferent()
{
var course = CourseBuilder.New().WithTargetAudience(TargetAudience.Employee).Build();
var student = StudentBuilder.New().WithTargetAudience(TargetAudience.Student).Build();
Assert.Throws <DomainException>(() =>
RegistrationBuilder.New().WithCourse(course).WithStudent(student).Build())
.WithMessage(Messages.TARGET_AUDIENCE_IS_DIFERENT_STUDENT_COURSE);
}
public void ShouldNotInsertCoursesWithTheSameName()
{
var courseInserted = CourseBuilder.New().WithName(_courseDto.Name).Build();
_courseRepositoryMock.Setup(s => s.GetByName(_courseDto.Name)).Returns(courseInserted);
Assert.Throws <ArgumentException>(() => _courseInserter.Insert(_courseDto))
.WithMessage("Course name already inserted!");
}
public void ShouldNotCreateRegistrationWithValueBiggerThanCourseValue()
{
var course = CourseBuilder.New().WithValue(100).Build();
var valueBiggerThanCourse = course.Value + 1;
Assert.Throws <DomainException>(() => RegistrationBuilder.New().WithCourse(course).WithValue(valueBiggerThanCourse).Build())
.WithMessage(Messages.REGISTRATION_VALUE_SHOULD_NOT_BE_BIGGER_THAN_COURSE);
}
