public void SetUp()
{
_matriculaId = 342;
_matricula = FluentBuilder <Matricula> .New().Build();
_matriculaRepositorio = new Mock <IMatriculaRepositorio>();
_matriculaRepositorio.Setup(r => r.ObterPorId(_matriculaId)).Returns(_matricula);
_canceladorDeMatricula = new CanceladorDeMatricula(_matriculaRepositorio.Object);
}
public void DeveInformarAMaiorCartaJogada()
{
var nomeDoJogador = "jogador1";
var carta = FluentBuilder <Carta> .New().Build();
_parcial.Jogar(nomeDoJogador, carta);
Assert.AreEqual(carta, _parcial.MaiorCartaJogada);
}
public void NaoDeveJogarQuandoNaoForAVezDoJogador()
{
const string nomeDoJogador = "jogador2";
var carta = FluentBuilder <Carta> .New().Build();
var message = Assert.ThrowsException <ExcecaoDeDominio>(() => _parcial.Jogar(nomeDoJogador, carta)).Message;
Assert.AreEqual(message, "Não é permitido jogar na vez de outro jogador");
}
public void Deve_aprovar_solicitacao_de_manutencao()
{
var aprovador = new Autor(1, "Reprovador");
var solicitacao = FluentBuilder <SolicitacaoDeManutencao> .New().Build();
solicitacao.Aprovar(aprovador);
Assert.Equal(StatusDaSolicitacao.Aprovada, solicitacao.StatusDaSolicitacao);
}
public void Deve_informar_o_aprovador_da_aprovacao()
{
var aprovador = new Autor(1, "Reprovador");
var solicitacao = FluentBuilder <SolicitacaoDeManutencao> .New().Build();
solicitacao.Aprovar(aprovador);
Assert.Equal(aprovador, solicitacao.Aprovador);
}
public void DeveSelecionarOProximoJogadorDaCarta(int indexDoAtualJogadorDaCarta, int indexDoEsperadoJogadorDaCarta)
{
var parcial = FluentBuilder <Parcial> .New().With(p => p.Jogadores, _jogadores)
.With(p => p.JogadorDaCarta, _jogadores[indexDoAtualJogadorDaCarta]).Build();
parcial.ProximoJogadorDaCarta();
Assert.AreEqual(_jogadores[indexDoEsperadoJogadorDaCarta], parcial.JogadorDaCarta);
}
public void Should_build_object_setting_default_values()
{
var createdObject = FluentBuilder <SampleClass> .New().Build();
Assert.IsNotNull(createdObject.PublicField);
Assert.IsNotNull(createdObject.CollectionWithFieldFollowingNameConvention);
Assert.IsNotNull(createdObject.PropertyWithSetter);
Assert.IsNotNull(createdObject.ReadOnlyProperty);
}
public CriterioDeRendaEntre901Ah1500Teste()
{
_criterio = new CriterioDeRendaEntre901Ah1500();
_pessoaUm = PessoaBuilder.UmaPessoa().Build();
_pessoaDois = PessoaBuilder.UmaPessoa().Build();
var pessoas = new[] { _pessoaUm, _pessoaDois };
_familia = FluentBuilder <Familia> .New()
.WithCollection(f => f.Pessoas, pessoas).Build();
}
public void DeveNotaDoAlunoSerZeroQuandoStatusDeAprovacaoEhReprovado()
{
const int notaEsperada = 0;
const int notaInvalida = 100;
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.AdicionarNotaDoAlunoNoCurso(notaInvalida, StatusDaAprovacaoDaMatricula.Reprovado);
Assert.AreEqual(notaEsperada, matricula.NotaDoAlunoNoCurso);
}
public void DevePoderAdicionarNotaDoAlunoNoCursoEStatusDeAprovacao()
{
const float notaDoAlunoNoCurso = 97.50f;
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.AdicionarNotaDoAlunoNoCurso(notaDoAlunoNoCurso, StatusDaAprovacaoDaMatricula.Aprovado);
Assert.AreEqual(notaDoAlunoNoCurso, matricula.NotaDoAlunoNoCurso);
Assert.AreEqual(StatusDaAprovacaoDaMatricula.Aprovado, matricula.StatusDaAprovacao);
}
private Pessoa EditarPessoa()
{
var pessoa = FluentBuilder <Pessoa> .New().Build();
pessoa.Editar(
_nome, _cpf, _orgaoEmissorDoRg, _rg, _dataDeNascimento, _registroProfissional, _telefone,
_endereco, _tipoDePublico, _especialidade, _midiaSocial);
return(pessoa);
}
public void DeveEfetuarUmaDoacaoParaOJogador()
{
var doacao = FluentBuilder <Doacao> .New().Build();
var jogador = FluentBuilder <Jogador> .New().Build();
jogador.Efetuar(doacao);
Assert.IsTrue(jogador.Doacoes.Any(doa => doa == doacao));
}
public void Should_build_object_within_a_list()
{
var collectionWithOneComplexType = FluentBuilder <SampleClass>
.New()
.With(newObject => newObject.PropertyWithSetter, "Some value")
.AsList();
Assert.AreEqual(1, collectionWithOneComplexType.Count());
Assert.AreEqual("Some value", collectionWithOneComplexType.First().PropertyWithSetter);
}
public void Deve_validar_solicitacao_de_manutencao_quando_ja_aprovada()
{
const string mensagemEsperada = "Solicitação já analisada e está aprovada";
_solicitacaoDeManutencao = FluentBuilder <SolicitacaoDeManutencao> .New().With(solicitacao => solicitacao.StatusDaSolicitacao, StatusDaSolicitacao.Aprovada).Build();
_solicitacaoDeManutencaoRepositorio.ObterPorId(_dto.IdDaSolicitacao).Returns(_solicitacaoDeManutencao);
AssertExtensions.ThrowsWithMessageAsync(() => _analiseDeAprovacaoDaSolicitacao.Analisar(_dto), mensagemEsperada);
}
public void DeveAtualizarCurso()
{
const int idCurso = 1;
_cursoRepositorio.Setup(r => r.ObterPorId(idCurso)).Returns(
FluentBuilder <Curso> .New().Build());
_armazenador.Armazenar(_codigo, idCurso, _nome, _descricao, _precoSugerido, _publicosSugeridos, _requisitos, _periodoValidoEmAno);
_cursoRepositorio.Verify(r => r.Adicionar(It.IsAny <Curso>()), Times.Never);
}
public void DeveCriar()
{
var instrutor = FluentBuilder <Pessoa> .New().Build();
var cargo = CargoNaTurma.Coordenador;
var instrutorDaTurma = new InstrutorDaTurma(instrutor, cargo);
Assert.AreEqual(instrutor, instrutorDaTurma.Instrutor);
Assert.AreEqual(cargo, instrutorDaTurma.Cargo);
}
public void Should_build_object_setting_dependency()
{
var concreteService = new SampleConcreteDependency();
var createdObject = FluentBuilder <SampleServiceWithDependency>
.New()
.WithDependency <IDependency, SampleConcreteDependency>(concreteService)
.Build();
Assert.AreEqual(createdObject.PropertyOnlyForTestingPurpose, concreteService);
}
public void Setup()
{
_idMatricula = 100;
_statusDaAprovacao = null;
_ip = true;
_matricula = FluentBuilder <Matricula> .New().Build();
_matriculaRepositorio = new Mock <IRepositorio <Matricula> >();
_matriculaRepositorio.Setup(r => r.ObterPorId(_idMatricula)).Returns(_matricula);
_alteracaoDeDadosDaMatricula = new AlteracaoDeDadosDaMatricula(_matriculaRepositorio.Object);
}
public void DeveDarAsCartasDoJogador()
{
var jogador = FluentBuilder <Jogador> .New().Build();
var cartas = FluentBuilder <Carta> .Many(3);
var cartasDoJogador = new CartasDoJogador(jogador, cartas.ToList());
Assert.AreEqual(jogador, cartasDoJogador.Jogador);
Assert.AreEqual(cartas, cartasDoJogador.Cartas);
}
public void DeveEditarCursoAberto()
{
_dto.Id = 7;
_cursoAbertoRepositorio.Setup(repositorio => repositorio.ObterPorId(_dto.Id))
.Returns(FluentBuilder <CursoAberto> .New().Build());
_armazenador.Armazenar(_dto);
_cursoAbertoRepositorio.Verify(repositorio =>
repositorio.Adicionar(It.IsAny <CursoAberto>()), Times.Never);
}
public void Should_build_object_setting_get_only_property()
{
const string newValue = "Robson";
var createdObject = FluentBuilder <SampleClass>
.New()
.With(newObject => newObject.GetOnlyProperty, newValue)
.Build();
Assert.AreEqual(newValue, createdObject.GetOnlyProperty);
}
public void NaoDeveAdicionarNotaInvalidaDoAlunoNoCurso()
{
var matricula = FluentBuilder <Matricula> .New().Build();
var message0 = Assert.ThrowsException <ExcecaoDeDominio>(() => matricula.AdicionarNotaDoAlunoNoCurso(0, StatusDaAprovacaoDaMatricula.Aprovado)).Message;
Assert.AreEqual("Nota do aluno no curso é inválido", message0);
var message11 = Assert.ThrowsException <ExcecaoDeDominio>(() => matricula.AdicionarNotaDoAlunoNoCurso(101, StatusDaAprovacaoDaMatricula.Aprovado)).Message;
Assert.AreEqual("Nota do aluno no curso é inválido", message11);
}
public void NaoDevePermitirInserirOMesmoInstrutorComMesmoCargo()
{
const int quantidadeEsperada = 1;
var instrutor = FluentBuilder <Pessoa> .New().With(i => i.Id, 5).Build();
var cargo = CargoNaTurma.Coordenador;
_cursoAberto.AdicionarInstrutor(instrutor, cargo);
_cursoAberto.AdicionarInstrutor(instrutor, cargo);
Assert.AreEqual(quantidadeEsperada, _cursoAberto.Instrutores.Count);
}
public void DeveEditarAluno()
{
const int id = 1;
_alunoRepositorio.Setup(repositorio => repositorio.ObterPorId(id))
.Returns(FluentBuilder <Pessoa> .New().Build());
_armazenador.Armazenar(id, _nome, _cpf, _orgaoEmissorDoRg, _rg, _dataDeNascimento, _registroProfissional, _telefone, _numero, _logradouro, _cep, _bairro, _complemento, _cidade, _estado,
_publicoAlvo, _especialidade, _midiaSocial, TipoDePessoa.Aluno);
_alunoRepositorio.Verify(repositorio => repositorio.Adicionar(It.IsAny <Pessoa>()), Times.Never);
}
public void Setup()
{
_codigo = "AAXD";
_nome = "Curso A";
_descricao = "Descrição A";
_precoSugerido = 1000m;
_publicosAlvo = new List <string> {
"Médico(a)"
};
_requisitos = "pagar antes";
_periodoValidoEmAno = 1;
_curso = FluentBuilder <Curso> .New().Build();
}
public void Deve_pontuar_familia_quando_criterio_for_atendido(
int anoDeNascimento, int mesDeNascimento, int diaDeNascimento)
{
const int pontuacaoEsperada = 3;
var dataDeNascimentoDe45Anos = new DateTime(anoDeNascimento, mesDeNascimento, diaDeNascimento);
var pessoaUm = PessoaBuilder.UmaPessoa().ComDataDeNascimento(dataDeNascimentoDe45Anos).Build();
var pessoas = new[] { pessoaUm, _pessoaDois };
var familia = FluentBuilder <Familia> .New().WithCollection(f => f.Pessoas, pessoas).Build();
var pontuacaoObtida = _criterioDePretendetenComIdadeMaiorIgualA45Anos.EhAtendidoPela(familia);
Assert.Equal(pontuacaoEsperada, pontuacaoObtida);
}
public void Deve_pontuar_familia_quando_criterio_for_atendido(int anoDeNascimento, int mesDeNascimento, int diaDeNascimento)
{
const int pontuacaoEsperada = 1;
var dataDeNascimento = new DateTime(anoDeNascimento, mesDeNascimento, diaDeNascimento);
var pretendente = PessoaBuilder.UmaPessoa().ComTipo(TipoDePessoa.Pretendete)
.ComDataDeNascimento(dataDeNascimento).Build();
var pessoas = new[] { pretendente };
var familia = FluentBuilder <Familia> .New().WithCollection(f => f.Pessoas, pessoas).Build();
var pontuacaoObtida = _criterio.EhAtendidoPela(familia);
Assert.Equal(pontuacaoEsperada, pontuacaoObtida);
}
public void Setup()
{
_codigo = "XPTO";
_preco = 1000m;
_empresa = "Empresa";
_tipoDeCursoAberto = TipoDeCursoAberto.Publico;
_curso = FluentBuilder <Curso> .New().Build();
_periodoInicialParaMatricula = DateTime.Now.AddDays(-1);
_periodoFinalParaMatricula = DateTime.Now;
_dataDeInicioDoCurso = DateTime.Now.AddDays(+1);
_dataDeFimDoCurso = DateTime.Now.AddDays(+10);
_cursoAberto = FluentBuilder <CursoAberto> .New().Build();
}
public void Should_build_object_setting_field_using_naming_convention()
{
var newValueForComplexType = new OneMoreComplexType();
const string newValueForString = "Robson";
var createdObject = FluentBuilder <SampleClass>
.New()
.WithFieldValue(newValueForComplexType)
.WithFieldValue(newValueForString)
.Build();
Assert.AreEqual(newValueForComplexType, createdObject.OneMoreComplexType);
Assert.AreEqual(newValueForString, createdObject.String);
}
public void DeveEditarCurso()
{
var curso = FluentBuilder <Curso> .New().Build();
curso.Editar(_codigo, _nome, _descricao, _precoSugerido, _publicosAlvo, _requisitos, _periodoValidoEmAno);
Assert.AreEqual(curso.Codigo, _codigo);
Assert.AreEqual(curso.Nome, _nome);
Assert.AreEqual(curso.Descricao, _descricao);
Assert.AreEqual(_requisitos, curso.Requisitos);
Assert.AreEqual(_periodoValidoEmAno, curso.PeriodoValidoEmAno);
//Testar
//CollectionAssert.AreEqual(curso.PublicosAlvo, _publicosAlvo);
}
