public void NaoDeveCriarEstudanteComCPFInvalido(string InvalidCPF)
{
FluentActions.Invoking(() => StudentBuilder.New().WithCPF(InvalidCPF).Build())
.Should()
.Throw <DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidCPF));
}
public void DeveAlterarPublicoAlvoDoEstudante()
{
var valorEsperado = _faker.PickRandom <TargetAudience>();
var student = StudentBuilder.New().Build();
student.UpdateTargetAudience(valorEsperado);
student.TargetAudience.Should().Be(valorEsperado);
}
public void DeveAlterarCPFDoEstudante()
{
var valorEsperado = _faker.Person.Cpf();
var student = StudentBuilder.New().Build();
student.UpdateCPF(valorEsperado);
student.CPF.Should().Be(valorEsperado);
}
public void DeveAlterarNomeDoEstudante()
{
var valorEsperado = _faker.Person.FullName;
var student = StudentBuilder.New().Build();
student.UpdateName(valorEsperado);
student.Name.Should().Be(valorEsperado);
}
public void DeveAlterarEmailDoEstudante()
{
var valorEsperado = _faker.Person.Email;
var student = StudentBuilder.New().Build();
student.UpdateEmail(valorEsperado);
student.Email.Should().Be(valorEsperado);
}
public void NaoDeveAdicionarCursoComOMesmoNomeEIdDiferenteDoOutroSalvo()
{
var studentAlreadySaved = StudentBuilder.New().WithCPF(_studentDTO.CPF).WithId(60).Build();
_studentRepositoryMock.Setup(r => r.GetByCPF(_studentDTO.CPF)).Returns(studentAlreadySaved);
_studentDTO.Id = _faker.Random.Int(50, 100);
FluentActions.Invoking(() => _studentService.Save(_studentDTO)).Should().Throw <DomainException>().Where(d => d.ErrorMessages.Contains(Resource.CPFAlreadyExists));
}
public void DeveAlterarNome()
{
var novoNomeEsperado = _faker.Person.FullName;
var aluno = StudentBuilder.New().Build();
aluno.ChangeName(novoNomeEsperado);
Assert.Equal(novoNomeEsperado, aluno.Name);
}
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 NaoDeveAdicionarAlunoQuandoCpfJaFoiCadastrado()
{
var studentWithSameNif = StudentBuilder.New().WithId(34).Build();
_studentRepository.Setup(r => r.GetByNif(_studentDto.Nif)).Returns(studentWithSameNif);
Assert.Throws <DomainException>(() => _studentStorer.Store(_studentDto))
.ComMensagem(Resource.AlreadyRegisteredNif);
}
public void NaoDevePublicoAlvoDeAlunoECursoSeremDiferentes()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(TargetAudience.Employee).Build();
var aluno = StudentBuilder.New().WithTargetAudience(TargetAudience.Graduate).Build();
Assert.Throws <DomainException>(() =>
MatriculaBuilder.Novo().ComAluno(aluno).ComCurso(curso).Build())
.ComMensagem(Resource.DifferentTargetAudience);
}
public void NaoDeveAlterarEstudanteComNomeInvalido(string InvalidName)
{
var student = StudentBuilder.New().Build();
FluentActions.Invoking(() => student.UpdateName(InvalidName))
.Should()
.Throw <DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidName));
}
public void ShouldChangeName()
{
var expectedName = _faker.Person.FullName;
var student = StudentBuilder.New().Build();
student.ChangeName(expectedName);
Assert.Equal(expectedName, student.Name);
}
public void NaoDeveAdicionarQuandoForEdicao()
{
_studentDto.Id = 35;
var alunoJaSalvo = StudentBuilder.New().Build();
_studentRepository.Setup(r => r.GetById(_studentDto.Id)).Returns(alunoJaSalvo);
_studentStorer.Store(_studentDto);
_studentRepository.Verify(r => r.Add(It.IsAny <Student>()), Times.Never);
}
public void DeveEditarNomeDoAluno()
{
_studentDto.Id = 35;
_studentDto.Name = _faker.Person.FullName;
var alunoJaSalvo = StudentBuilder.New().Build();
_studentRepository.Setup(r => r.GetById(_studentDto.Id)).Returns(alunoJaSalvo);
_studentStorer.Store(_studentDto);
Assert.Equal(_studentDto.Name, alunoJaSalvo.Name);
}
public void ShouldUpdateStudent()
{
var studentAlreadySave = StudentBuilder.New().Build();
_studentRepositoryMock.Setup(r => r.GetById(_studentDto.Id)).Returns(studentAlreadySave);
_studentService.Update(_studentDto);
Assert.Equal(_studentDto.Name, studentAlreadySave.Name);
_studentRepositoryMock.Verify(r => r.Update(It.IsAny <Student>()));
_studentRepositoryMock.Verify(r => r.Add(It.IsAny <Student>()), Times.Never());
}
public void DeveCriarMatricula()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(TargetAudience.Entrepreneur).Build();
var matriculaEsperada = new
{
Aluno = StudentBuilder.New().WithTargetAudience(TargetAudience.Entrepreneur).Build(),
Curso = curso,
ValorPago = curso.Amount
};
var matricula = new Enrollment(matriculaEsperada.Aluno, matriculaEsperada.Curso, matriculaEsperada.ValorPago);
matriculaEsperada.ToExpectedObject().ShouldMatch(matricula);
}
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 NaoDeveEditarDemaisInformacoesDoAluno()
{
_studentDto.Id = 35;
var alunoJaSalvo = StudentBuilder.New().Build();
var cpfEsperado = alunoJaSalvo.Nif;
var emailEsperado = alunoJaSalvo.Email;
var publicoAlvoEsperado = alunoJaSalvo.TargetAudience;
_studentRepository.Setup(r => r.GetById(_studentDto.Id)).Returns(alunoJaSalvo);
_studentStorer.Store(_studentDto);
Assert.Equal(cpfEsperado, alunoJaSalvo.Nif);
Assert.Equal(emailEsperado, alunoJaSalvo.Email);
Assert.Equal(publicoAlvoEsperado, alunoJaSalvo.TargetAudience);
}
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 CriacaoDaMatriculaTest()
{
_cursoRepositorio = new Mock <ICourseRepository>();
_alunoRepositorio = new Mock <IStudentRepository>();
_matriculaRepositorio = new Mock <IEnrollmentRepository>();
_aluno = StudentBuilder.New().WithId(23).WithTargetAudience(TargetAudience.Graduate).Build();
_alunoRepositorio.Setup(r => r.GetById(_aluno.Id)).Returns(_aluno);
_course = CursoBuilder.Novo().ComId(45).ComPublicoAlvo(TargetAudience.Graduate).Build();
_cursoRepositorio.Setup(r => r.GetById(_course.Id)).Returns(_course);
_enrollmentDto = new EnrollmentDto {
StudentId = _aluno.Id, CourseId = _course.Id, PaidAmount = _course.Amount
};
_enrollmentCreation = new EnrollmentCreation(_alunoRepositorio.Object, _cursoRepositorio.Object, _matriculaRepositorio.Object);
}
public void ShouldNotHaveStudentInvalidEmail(string invalidEmail)
{
Assert.Throws <DomainException>(() => StudentBuilder.New().WithEmail(invalidEmail).Build());
}
public void ShouldNotChangeInvalidName(string invalidName)
{
var student = StudentBuilder.New().Build();
Assert.Throws <DomainException>(() => student.ChangeName(invalidName)).WithMessage(Messages.INVALID_NAME);
}
public void NaoDeveCriarComNomeInvalido(string nomeInvalido)
{
Assert.Throws <DomainException>(() =>
StudentBuilder.New().WithName(nomeInvalido).Build())
.ComMensagem(Resource.InvalidName);
}
public void NaoDeveCriarComCpfInvalido(string cpfInvalido)
{
Assert.Throws <DomainException>(() =>
StudentBuilder.New().WithNif(cpfInvalido).Build())
.ComMensagem(Resource.InvalidNif);
}
public void NaoDeveCriarComEmailInvalido(string emailInvalido)
{
Assert.Throws <DomainException>(() =>
StudentBuilder.New().WithEmail(emailInvalido).Build())
.ComMensagem(Resource.InvalidEmail);
}
