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); }