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 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 DeveAlterarNome()
{
var valorEsperado = _faker.Random.Word();
var curso = CourseBuilder.New().Build();
curso.UpdateName(valorEsperado);
curso.Name.Should().Be(valorEsperado);
}
public void CursoNaoDeveSerCriadoComCargaHorariaMenorQue1(int invalidWorkload)
{
FluentActions.Invoking(() => CourseBuilder.New().WithWorkload(invalidWorkload).Build())
.Should().Throw<DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidWorkload));
}
public void DeveAlterarPublicoAlvo()
{
var valorEsperado = _faker.PickRandom<TargetAudience>();
var curso = CourseBuilder.New().Build();
curso.UpdateTargetAudience(valorEsperado);
curso.TargetAudience.Should().Be(valorEsperado);
}
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 DeveAlterarDescricao()
{
var valorEsperado = _faker.Lorem.Paragraphs(3);
var curso = CourseBuilder.New().Build();
curso.UpdateDescription(valorEsperado);
curso.Description.Should().Be(valorEsperado);
}
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 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 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 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);
}
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 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 ShouldChangeValue()
{
var expectedValue = 800;
var course = CourseBuilder.New().Build();
course.ChangeValue(expectedValue);
Assert.Equal(expectedValue, course.Value);
}
public void ShouldChangeName()
{
var expectedName = _faker.Person.FullName;
var course = CourseBuilder.New().Build();
course.ChangeName(expectedName);
Assert.Equal(expectedName, course.Name);
}
public void ShouldChangeWorkLoad()
{
var expectedWorkLoad = 80;
var course = CourseBuilder.New().Build();
course.ChangeWorkLoad(expectedWorkLoad);
Assert.Equal(expectedWorkLoad, course.WorkLoad);
}
public void ShouldIndicateThatThereWasDiscountInRegistration()
{
var course = CourseBuilder.New().WithValue(100).Build();
var valuePaidWithDiscount = course.Value - 1;
var registration = RegistrationBuilder.New().WithCourse(course).WithValue(valuePaidWithDiscount).Build();
Assert.True(registration.HasDiscount);
}
public void ShouldAddRegistration()
{
var course = CourseBuilder.New().Build();
var expectedRegistration = new
{
Student = StudentBuilder.New().Build(),
Course = course,
course.Value
};
var registration = new Registration(expectedRegistration.Student, expectedRegistration.Course, expectedRegistration.Value);
expectedRegistration.ToExpectedObject().ShouldMatch(registration);
}
public void ShouldUpdateCourse()
{
var courseAlreadySave = CourseBuilder.New().Build();
_courseRepositoryMock.Setup(r => r.GetById(_courseDto.Id)).Returns(courseAlreadySave);
_courseService.Update(_courseDto);
Assert.Equal(_courseDto.Name, courseAlreadySave.Name);
Assert.Equal(_courseDto.WorkLoad, courseAlreadySave.WorkLoad);
Assert.Equal(_courseDto.Value, courseAlreadySave.Value);
_courseRepositoryMock.Verify(r => r.Update(It.IsAny <Course>()));
_courseRepositoryMock.Verify(r => r.Add(It.IsAny <Course>()), Times.Never());
}
public RegistrationCreationTest()
{
_courseRepository = new Mock <ICourseRepository>();
_studentRepository = new Mock <IStudentRepository>();
_registrationRepository = new Mock <IRegistrationRepository>();
_registrationCreation = new RegistrationCreation(_studentRepository.Object, _courseRepository.Object, _registrationRepository.Object);
_course = CourseBuilder.New().WithTargetAudience(TargetAudience.Student).Build();
_courseRepository.Setup(r => r.GetById(_course.Id)).Returns(_course);
_student = StudentBuilder.New().WithTargetAudience(TargetAudience.Student).Build();
_studentRepository.Setup(r => r.GetById(_student.Id)).Returns(_student);
_registrationDto = new RegistrationDto {
StudentId = _student.Id, CourseId = _course.Id, Value = _course.Value
};
}
public void ShouldNotHaveCourseWorkLoadLessThanOne(double invalidWorkLoad)
{
Assert.Throws <DomainException>(() => CourseBuilder.New().WithWorkLoad(invalidWorkLoad).Build()).WithMessage(Messages.INVALID_WORKLOAD);
}
public void CourseValueMustNotBeLowerThanOne(double valueInvalid)
{
//Assert
Assert.Throws <ArgumentException>(() =>
CourseBuilder.New().WithValue(valueInvalid).Build()).WithMessage("Invalid Value");
}
public void CourseLoadMustNotBeLowerThanOne(double courseLoadInvalid)
{
//Assert
Assert.Throws <ArgumentException>(() =>
CourseBuilder.New().WithCourseLoad(courseLoadInvalid).Build()).WithMessage("Invalid CourseLoad");
}
public void CourseNameMustNotBeInvalid(string InvalidName)
{
//Assert
Assert.Throws <ArgumentException>(() =>
CourseBuilder.New().WithName(InvalidName).Build()).WithMessage("Invalid Name");
}
public void ShouldNotChangeInvalidName(string invalidName)
{
var course = CourseBuilder.New().Build();
Assert.Throws <DomainException>(() => course.ChangeName(invalidName)).WithMessage(Messages.INVALID_NAME);
}
public void ShouldNotChangeInvalidWorkLoad(int invalidWorkLoad)
{
var course = CourseBuilder.New().Build();
Assert.Throws <DomainException>(() => course.ChangeWorkLoad(invalidWorkLoad)).WithMessage(Messages.INVALID_WORKLOAD);
}
public void ShouldNotHaveCourseValueLessThanOne(decimal invalidValue)
{
Assert.Throws <DomainException>(() => CourseBuilder.New().WithValue(invalidValue).Build()).WithMessage(Messages.INVALID_VALUE);
}
public void ShouldNotChangeInvalidValue(decimal invalidValue)
{
var course = CourseBuilder.New().Build();
Assert.Throws <DomainException>(() => course.ChangeValue(invalidValue)).WithMessage(Messages.INVALID_VALUE);
}
public void ShouldNotHaveCourseInvalidName(string invalidName)
{
Assert.Throws <DomainException>(() => CourseBuilder.New().WithName(invalidName).Build()).WithMessage(Messages.INVALID_NAME);
}
