public void EmailEditadoNaoDeveSerInvalidoTest(string emailEdicao)
{
var nome = AlunoBuilder.Novo().Build();
Assert.Throws <ExcecaoDeDominio>(() => nome.AlterarEmail(emailEdicao))
.ComMensagem(Resource.EmailInvalido);
}
public void NaoDeveAlunoTerUmCpfInvalidoTest(string cpf)
{
Assert.Throws <ExcecaoDeDominio>(() => AlunoBuilder
.Novo()
.ComCpf(cpf)
.Build())
.ComMensagem(Resource.CpfInvalido);
}
public void NaoDeveAlunoTerNomeInvalidoTest(string nome)
{
Assert.Throws <ExcecaoDeDominio>(() => AlunoBuilder
.Novo()
.ComNome(nome)
.Build())
.ComMensagem(Resource.NomeInvalido);
}
public void NaoDeveAlunoTerEmailInvalidoTest(string email)
{
Assert.Throws <ExcecaoDeDominio>(() => AlunoBuilder
.Novo()
.ComEmail(email)
.Build())
.ComMensagem(Resource.EmailInvalido);
}
public void NaoDeveAlterarAlunoComNomeInvalido(string nomeInvalido)
{
var aluno = AlunoBuilder.Novo().Build();
Assert.Throws <ExcecaoDeDominio>(() =>
aluno.AlterarNome(nomeInvalido))
.ComMensagem(Resource.NomeInvalido);
}
public void NaoDevePublicoAlvoDeAlunoECursoSeremDiferentes()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empregado).Build();
var aluno = AlunoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Universitário).Build();
Assert.Throws <ExcecaoDeDominio>(() =>
MatriculaBuilder.Novo().ComAluno(aluno).ComCurso(curso).Build())
.ComMensagem(Resource.PublicosAlvoDiferentes);
}
public void DeveAlterarDataNasc()
{
var dataAux = _faker.Date.Past();
var novaDataEsperada = dataAux.ToString("dd/MM/yyyy");
var aluno = AlunoBuilder.Novo().Build();
aluno.AlteraDataNasc(novaDataEsperada);
Assert.Equal(novaDataEsperada, aluno.DataNasc);
}
public void NaoDeveAdicionarAlunoQuandoCpfJaFoiCadastrado()
{
var alunoComMesmoCpf = AlunoBuilder.Novo().ComId(34).Build();
_alunoRepositorio.Setup(r => r.ObterPeloCpf(_alunoDto.Cpf)).Returns(alunoComMesmoCpf);
Assert.Throws <ExcecaoDeDominio>(() => _armazenadorDeAluno.Armazenar(_alunoDto))
.ComMensagem(Resource.CpfJaCadastrado);
}
public void DeveAlterarNome()
{
var novoNomeEsperado = _faker.Person.FullName;
var aluno = AlunoBuilder.Novo().Build();
aluno.AlterarNome(novoNomeEsperado);
Assert.Equal(novoNomeEsperado, aluno.Nome);
}
public void DeveAlterarEmailAlunoTest()
{
var email = _faker.Person.Email;
var aluno = AlunoBuilder.Novo().Build();
aluno.AlterarEmail(email);
Assert.Equal(email, aluno.Email);
}
public void NaoDeveAdicionarAlunoComMesmoCpfDeOutroJaSalvo()
{
var alunoJaSalvo = AlunoBuilder.Novo().ComId(_faker.Random.Int(1, 999999999)).Build();
_alunoRepositorioMock.Setup(c => c.ObterPorCpf(_alunoDTO.Cpf)).Returns(alunoJaSalvo);
Assert.Throws <ExcecaoDeDominio>(() => _armazenadorDeAluno.Armazenar(_alunoDTO))
.ComMensagem(Resource.CpfAlunoJaExiste);
}
public void DeveAlterarNomeCadastrado()
{
var nome = _faker.Person.FullName;
var aluno = AlunoBuilder.Novo().Build();
aluno.AlterarNome(nome);
Assert.Equal(nome, aluno.Nome);
}
public void DeveCriarUmAluno()
{
//Given
var alunoEsperado = AlunoBuilder.Novo().Build();
//When
var aluno = new Aluno(alunoEsperado.Nome, alunoEsperado.Cpf, alunoEsperado.Email, alunoEsperado.PublicoAlvo);
//Then
alunoEsperado.ToExpectedObject().ShouldMatch(aluno);
}
public void NaoDeveCursoEAlunoTerPublicoAlvoDiferentes()
{
// Arrange
var curso = CursoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empreendedor).Build();
var aluno = AlunoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Estudante).Build();
Assert.Throws <ExcecaoDeDominio>(() => MatriculaBuilder.Novo().ComAluno(aluno).ComCurso(curso).Build())
.ComMensagem(Resource.PublicoAlvoDiferente);
}
public void NaoDeveAdicionarNoRepositorioQuandoOCursoJaExiste()
{
_alunoDTO.Id = _faker.Random.Int(1, 999999999);
var aluno = AlunoBuilder.Novo().Build();
_alunoRepositorioMock.Setup(c => c.ObterPorId(_alunoDTO.Id)).Returns(aluno);
_armazenadorDeAluno.Armazenar(_alunoDTO);
_alunoRepositorioMock.Verify(c => c.Adicionar(It.IsAny <Aluno>()), Times.Never);
}
public void NaoDeveAdicionarQuandoForEdicao()
{
_alunoDto.Id = _faker.Random.Int(1, 1000);
var aluno = AlunoBuilder.Novo().Build();
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(aluno);
_armazenadorDeAluno.Cadastrar(_alunoDto);
_alunoRepositorio.Verify(r => r.Adicionar(It.IsAny <Aluno>()), Times.Never);
}
public void DeveAlterarNomeDoAluno()
{
_alunoDTO.Nome = _faker.Person.FullName;
var aluno = AlunoBuilder.Novo().ComNome(_alunoDTO.Nome).Build();
_alunoRepositorioMock.Setup(c => c.ObterPorId(_alunoDTO.Id)).Returns(aluno);
_armazenadorDeAluno.Armazenar(_alunoDTO);
Assert.Equal(_alunoDTO.Nome, aluno.Nome);
}
public void NaoDeveEditarDemaisInformacoes()
{
_alunoDto.Id = 35;
var alunoJaSalvo = AlunoBuilder.Novo().Build();
var cpfEsperado = alunoJaSalvo.Cpf;
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(alunoJaSalvo);
_armazenadorDeAluno.Armazenar(_alunoDto);
Assert.Equal(cpfEsperado, alunoJaSalvo.Cpf);
}
public void DeveAlterarNomeAluno()
{
//Given
var novoNomeEsperado = faker.Name.FirstName();
var aluno = AlunoBuilder.Novo().Build();
//When
aluno.AlterarNome(novoNomeEsperado);
//Then
Assert.Equal(novoNomeEsperado, aluno.Nome);
}
public static MatriculaBuilder Novo()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empreendedor).Build();
return(new MatriculaBuilder
{
Aluno = AlunoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empreendedor).Build(),
Curso = curso,
ValorPago = Convert.ToDecimal(curso.Valor)
});
}
public void NaoDeveAdicionarQuandoForEdicao()
{
_alunoDto.Id = 35;
var alunoJaSalvo = AlunoBuilder.Novo().Build();
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(alunoJaSalvo);
_armazenadorDeAluno.Armazenar(_alunoDto);
_alunoRepositorio.Verify(r => r.Adicionar(It.IsAny <Aluno>()), Times.Never);
}
public void DeveAlterarNomeDoAluno()
{
_alunoDto.Id = _faker.Random.Int(1, 1000);
_alunoDto.Nome = _faker.Person.FullName;
var aluno = AlunoBuilder.Novo().Build();
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(aluno);
_armazenadorDeAluno.Cadastrar(_alunoDto);
Assert.Equal(_alunoDto.Nome, aluno.Nome);
}
public void DeveEditarNomeDoAluno()
{
_alunoDto.Id = 35;
_alunoDto.Nome = _faker.Person.FullName;
var alunoJaSalvo = AlunoBuilder.Novo().Build();
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(alunoJaSalvo);
_armazenadorDeAluno.Armazenar(_alunoDto);
Assert.Equal(_alunoDto.Nome, alunoJaSalvo.Nome);
}
public void NaoDeveAlterarTodosCamposDoAluno()
{
_alunoDTO.Cpf = _faker.Person.Cpf(true);
var aluno = AlunoBuilder.Novo().ComCpf(_alunoDTO.Cpf).Build();
_alunoRepositorioMock.Setup(c => c.ObterPorId(_alunoDTO.Id)).Returns(aluno);
_armazenadorDeAluno.Armazenar(_alunoDTO);
Assert.Equal(_alunoDTO.Cpf, aluno.Cpf);
}
public void PublicoAlvoDevemSerIguais()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empregado).Build();
var aluno = AlunoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Universitário).Build();
var matriculaDto = new MatriculaDto {
AlunoId = aluno.Id, CursoId = curso.Id
};
Assert.Throws <ExcecaoDeDominio>(() =>
MatriculaBuilder.Novo().ComAluno(aluno).ComCurso(curso).Build())
.ComMensagem(Resource.PublicoAlvoDiferente);
}
public void DeveCriarMatricula()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empreendedor).Build();
var matriculaEsperada = new
{
Aluno = AlunoBuilder.Novo().ComPublicoAlvo(PublicoAlvo.Empreendedor).Build(),
Curso = curso,
ValorPago = curso.Valor
};
var matricula = new Matricula(matriculaEsperada.Aluno, matriculaEsperada.Curso, matriculaEsperada.ValorPago);
matriculaEsperada.ToExpectedObject().ShouldMatch(matricula);
}
public void DeveAlterarNome()
{
#region Arrange
var novoNomeEsperado = _faker.Person.FullName;
var aluno = AlunoBuilder.Novo().Build();
#endregion
#region Act
aluno.AlterarNome(novoNomeEsperado);
#endregion
#region Assert
Assert.Equal(novoNomeEsperado, aluno.Nome);
#endregion
}
public void NaoDeveCriarComEmailInvalido(string emailInvalido)
{
#region Arrange
var builder = AlunoBuilder.Novo().ComEmail(emailInvalido);
#endregion
#region Act
Action act = () => builder.Build();
#endregion
#region Assert
Assert.Throws <ExcecaoDeDominio>(act)
.ComMensagem(Resource.EmailInvalido);
#endregion
}
public void NaoDeveEditarDemaisInformacoes()
{
_alunoDto.Id = _faker.Random.Int(1, 1000);
var alunoJaSalvo = AlunoBuilder.Novo().Build();
var cpfEsperado = alunoJaSalvo.Cpf;
var emailEsperado = alunoJaSalvo.Email;
var publicoAlvoEsperado = alunoJaSalvo.PublicoAlvo;
_alunoRepositorio.Setup(r => r.ObterPorId(_alunoDto.Id)).Returns(alunoJaSalvo);
_armazenadorDeAluno.Cadastrar(_alunoDto);
Assert.Equal(cpfEsperado, alunoJaSalvo.Cpf);
Assert.Equal(emailEsperado, alunoJaSalvo.Email);
Assert.Equal(publicoAlvoEsperado, alunoJaSalvo.PublicoAlvo);
}
public void NaoDevePublicoAlvoDeAlunoECursoSeremDiferentes()
{
#region Arrange
var curso = CursoBuilder.Novo().ComPublicoAlvo(Dominio.PublicosAlvo.PublicoAlvo.Empregado).Build();
var aluno = AlunoBuilder.Novo().ComPublicoAlvo(Dominio.PublicosAlvo.PublicoAlvo.Universitario).Build();
#endregion
#region Act
Action act = () => MatriculaBuilder.Novo().ComCurso(curso).ComAluno(aluno).Build();
#endregion
#region Assert
Assert.Throws <ExcecaoDeDominio>(act)
.ComMensagem(Resource.PublicosAlvoDiferentes);
#endregion
}