public void NaoDevePermitirJogarQuandoTodosOsJogadoresJogaram()
{
var parcial = FluentBuilder <Parcial> .New().With(p => p.Jogadores, _jogadores)
.With(p => p.JogadorDaCarta, _jogadores.Last()).Build();
Assert.IsFalse(parcial.PermiteJogar());
}
Nao_deve_alterar_a_pontuacao_da_familia_e_nem_alterar_quantidade_de_criterios_atendidos_quando_ela_nao_atender_o_criterio()
{
const int quantidadeDeCriteriosInicialmenteAtendidos = 1;
const int pontuacaoInicialDaFamilia = 4;
const int valorDaRendaUm = 400;
const int valorDaRendaDois = 800;
var rendaDaPessoaUm = FluentBuilder <Renda> .New().With(renda => renda.Valor, valorDaRendaUm).Build();
var rendaDaPessoaDois = FluentBuilder <Renda> .New().With(renda => renda.Valor, valorDaRendaDois).Build();
var pessoaUm = FluentBuilder <Pessoa> .New().With(pessoa => pessoa.Renda, rendaDaPessoaUm).Build();
var pessoaDois = FluentBuilder <Pessoa> .New().With(pessoa => pessoa.Renda, rendaDaPessoaDois).Build();
var pessoas = new[] { pessoaUm, pessoaDois };
var familia = FluentBuilder <Familia> .New()
.With(f => f.QuantidadeDeCriteriosAtendidos, quantidadeDeCriteriosInicialmenteAtendidos)
.With(f => f.Pontuacao, pontuacaoInicialDaFamilia)
.WithCollection(f => f.Pessoas, pessoas).Build();
_pontuacaoDeFamilias.Pontuar(_criterioDeRendaInferiorA900, familia);
Assert.Equal(pontuacaoInicialDaFamilia, familia.Pontuacao);
Assert.Equal(quantidadeDeCriteriosInicialmenteAtendidos, familia.QuantidadeDeCriteriosAtendidos);
}
public void TestBuilderImplicitlyCoercesFromStartingState()
{
var startingValue = Any.Int();
FluentBuilder <int> builder = startingValue;
builder.Apply().Should().Be(startingValue);
}
public void Setup()
{
_dto = new CursoAbertoParaCadastroViewModel
{
Preco = "10",
Codigo = "XPTO",
IdCurso = 10,
PeriodoFinalParaMatricula = DateTime.Now.AddDays(-1),
PeriodoInicialParaMatricula = DateTime.Now.AddDays(-10),
InicioDoCurso = DateTime.Now,
FimDoCurso = DateTime.Now.AddDays(10),
TipoDeCursoAberto = "Publico"
};
_cursoRepositorio = new Mock <IRepositorio <Curso> >();
_cursoRepositorio.Setup(repositorio => repositorio.ObterPorId(_dto.IdCurso))
.Returns(FluentBuilder <Curso> .New().Build);
_cursoAbertoRepositorio = new Mock <ICursoAbertoRepositorio>();
_instrutorRepositorio = new Mock <IPessoaRepositorio>();
_instrutor = FluentBuilder <Pessoa> .New().With(i => i.Id, InstrutorId).Build();
_instrutorRepositorio.Setup(r => r.ObterPorId(InstrutorId)).Returns(_instrutor);
_armazenador = new ArmazenadorDeCursoAberto(
_cursoRepositorio.Object,
_cursoAbertoRepositorio.Object,
_instrutorRepositorio.Object);
}
public SolicitadorDeManutencaoTeste()
{
_dto = new SolicitacaoDeManutencaoDto
{
SubsidiariaId = "XPTO-ABC",
SolicitanteId = 1,
NomeDoSolicitante = "Ricardo José",
TipoDeSolicitacaoDeManutencao = TipoDeSolicitacaoDeManutencao.Jardinagem.GetHashCode(),
Justificativa = "Grama Alta",
NumeroDoContrato = "2135",
InicioDesejadoParaManutencao = DateTime.Now.AddMonths(2)
};
_contratoDto = new ContratoDto
{
Numero = _dto.NumeroDoContrato,
NomeDaTerceirizada = "Grama SA",
GestorDoContrato = "Edivaldo Pereira",
CnpjDaTerceirizada = "00000000000000",
DataFinalDaVigencia = DateTime.Now.AddMonths(1)
};
_solicitacaoDeManutencaoRepositorio = Substitute.For <ISolicitacaoDeManutencaoRepositorio>();
var subsidiariaRepositorio = Substitute.For <ISubsidiariaRepositorio>();
_subsidiaria = FluentBuilder <Subsidiaria> .New().Build();
subsidiariaRepositorio.ObterPorId(_dto.SubsidiariaId).Returns(_subsidiaria);
_canceladorDeSolicitacoesDeManutencaoPendentes = Substitute.For <ICanceladorDeSolicitacoesDeManutencaoPendentes>();
_buscadorDeContrato = Substitute.For <IBuscadorDeContrato>();
_buscadorDeContrato.Buscar(_dto.NumeroDoContrato).Returns(_contratoDto);
_solicitador = new SolicitadorDeManutencao(_solicitacaoDeManutencaoRepositorio, subsidiariaRepositorio, _buscadorDeContrato, _canceladorDeSolicitacoesDeManutencaoPendentes);
}
public void Nao_deve_pontuar_quando_familia_nao_atender_ao_criterio()
{
const int pontuacaoEsperada = 0;
var dependenteMenorDeIdadeUm = PessoaBuilder.UmaPessoa()
.ComTipo(TipoDePessoa.Dependente)
.ComDataDeNascimento(new DateTime(2006, 12, 1))
.Build();
var dependenteMenorDeIdadeDois = PessoaBuilder.UmaPessoa()
.ComTipo(TipoDePessoa.Dependente)
.ComDataDeNascimento(new DateTime(2005, 12, 1))
.Build();
var dependenteMenorDeIdadeTres = PessoaBuilder.UmaPessoa()
.ComTipo(TipoDePessoa.Dependente)
.ComDataDeNascimento(new DateTime(2000, 12, 1))
.Build();
var pretendente = PessoaBuilder.UmaPessoa().ComTipo(TipoDePessoa.Pretendete).Build();
var pessoas = new[]
{ dependenteMenorDeIdadeUm, dependenteMenorDeIdadeDois, dependenteMenorDeIdadeTres, pretendente };
var familia = FluentBuilder <Familia> .New()
.WithCollection(f => f.Pessoas, pessoas)
.Build();
var pontuacaoObtida = _criterio.EhAtendidoPela(familia);
Assert.Equal(pontuacaoEsperada, pontuacaoObtida);
}
public void WithFieldValue_throws_exception_when_member_was_not_found()
{
var newValue = new StandAloneComplexType();
Assert.Throws <FluentBuilderException>(() => FluentBuilder <SampleClass> .New()
.WithFieldValue(newValue));
}
/// <summary>
/// Updates help options to use the given column widths.
/// </summary>
/// <param name="builder">Options builder.</param>
/// <param name="widths">Column widths.</param>
/// <returns>The updated builder.</returns>
public static FluentBuilder <ArgumentSetHelpOptions> ColumnWidths(this FluentBuilder <ArgumentSetHelpOptions> builder, params int[] widths)
{
builder.AddTransformer(options =>
{
if (options.Arguments.Layout is TwoColumnArgumentHelpLayout layout)
{
if (widths.Length > 2)
{
throw new NotSupportedException("May only specify up to 2 column widths with this layout");
}
if (widths.Length >= 1)
{
layout.ColumnWidths[0] = widths[0];
}
if (widths.Length >= 2)
{
layout.ColumnWidths[1] = widths[1];
}
}
else
{
throw new NotSupportedException("Cannot specify column widths on this layout");
}
});
return(builder);
}
public void Builder_Should_ProperlyBuildMoreComplicatedObjects(PersonExtendedInfo sourcePersonInfo)
{
dynamic personInfoBuilder = new FluentBuilder <PersonExtendedInfo>();
personInfoBuilder.WithActive(sourcePersonInfo.Active)
.WithAdditionalData(sourcePersonInfo.AdditionalData)
.WithAddress(sourcePersonInfo.Address)
.WithAge(sourcePersonInfo.Age)
.WithDateOfBirth(sourcePersonInfo.DateOfBirth)
.WithDateOfDeath(sourcePersonInfo.DateOfDeath)
.WithName(sourcePersonInfo.Name)
.WithSurname(sourcePersonInfo.Surname)
.WithSalary(sourcePersonInfo.Salary);
PersonExtendedInfo builtPersonInfo = personInfoBuilder.Get();
//TODO: find/write some Shouldly method to compare objects only by property values
builtPersonInfo.Active.ShouldBe(sourcePersonInfo.Active);
builtPersonInfo.AdditionalData.ShouldBe(sourcePersonInfo.AdditionalData);
builtPersonInfo.Address.ShouldBe(sourcePersonInfo.Address);
builtPersonInfo.Age.ShouldBe(sourcePersonInfo.Age);
builtPersonInfo.DateOfBirth.ShouldBe(sourcePersonInfo.DateOfBirth);
builtPersonInfo.DateOfDeath.ShouldBe(sourcePersonInfo.DateOfDeath);
builtPersonInfo.Name.ShouldBe(sourcePersonInfo.Name);
builtPersonInfo.Surname.ShouldBe(sourcePersonInfo.Surname);
builtPersonInfo.Salary.ShouldBe(sourcePersonInfo.Salary);
}
public void BuilderCreatesDefaultObject()
{
var builder = new FluentBuilder <Car>();
Car car = builder.Create();
car.Should().NotBeNull();
}
public void Setup()
{
_pessoa = FluentBuilder <Pessoa> .New().With(a => a.TipoDePublico, "Medico(a)").Build();
var cursoAbertoMock = new Mock <CursoAberto>();
cursoAbertoMock.Setup(c => c.ContemPublicoAlvo(_pessoa.TipoDePublico)).Returns(true);
_cursoAberto = cursoAbertoMock.Object;
_estaPago = true;
_valorPago = 100m;
_idCursoAberto = 100;
_idAluno = 600;
_idComoFicouSabendo = 346;
_comoFicouSabendo = FluentBuilder <ComoFicouSabendo> .New().With(c => c.Id, _idComoFicouSabendo).Build();
_matriculaRepositorio = new Mock <IMatriculaRepositorio>();
_cursoAbertoRepositorio = new Mock <ICursoAbertoRepositorio>();
_cursoAbertoRepositorio.Setup(r => r.ObterPorId(_idCursoAberto)).Returns(_cursoAberto);
_alunoRepositorio = new Mock <IPessoaRepositorio>();
_alunoRepositorio.Setup(r => r.ObterPorId(_idAluno)).Returns(_pessoa);
_comoFicouSabendoRepositorio = new Mock <IRepositorio <ComoFicouSabendo> >();
_comoFicouSabendoRepositorio.Setup(r => r.ObterPorId(_idComoFicouSabendo)).Returns(_comoFicouSabendo);
_criacaoDeMatricula =
new CriacaoDeMatricula(_matriculaRepositorio.Object, _cursoAbertoRepositorio.Object, _alunoRepositorio.Object, _comoFicouSabendoRepositorio.Object);
}
public void TestBuilderWithNoTransformationsAppliesToStartingState()
{
var startingValue = Any.Int();
var builder = new FluentBuilder <int>(startingValue);
builder.Apply().Should().Be(startingValue);
}
public IBehaviour <Creature> AttackBehaviour()
{
return(FluentBuilder.Create <Creature>()
.Selector("attack-behaviour")
//.Wait("GCD", 1400)
.Random("change-to-random", .05)
.Do("change-to-random", ChangeToRandomTarget)
.End()
.Random("seeping-wound", .05)
.Do("seeping-wound", SeepingWound)
.End()
.Random("touch-of-palsy", .10)
.Do("touch-of-palsy", TouchOfPalsy)
.End()
.Random("ravage", 25.00)
.Do("ravage", Ravage)
.End()
.Random("Taunt", 0.05)
.Do("Taunt", Taunt)
.End()
.End()
.Build());
}
public void NaoDeveAdicionarStatusDeAprovacaoDaMatriculaInvalida()
{
var matricula = FluentBuilder <Matricula> .New().Build();
Assert.ThrowsException <ExcecaoDeDominio>(() => matricula.AdicionarNotaDoAlunoNoCurso(1, StatusDaAprovacaoDaMatricula.Nenhum))
.Message.StartsWith("Status de aprovação é inválido");
}
public void Should_build_a_collection_of_objects()
{
const int amountOfObjects = 3;
var collection = FluentBuilder <SampleClass> .Many(amountOfObjects);
Assert.AreEqual(amountOfObjects, collection.Count());
}
public void Deve_cancelar_solicitacao_de_manutencao()
{
var solicitacao = FluentBuilder <SolicitacaoDeManutencao> .New().Build();
solicitacao.Cancelar();
Assert.Equal(StatusDaSolicitacao.Cancelada, solicitacao.StatusDaSolicitacao);
}
public void should_fail()
{
IFluentBuilder <Bar> nonListBuilder = new FluentBuilder <Bar>();
Action setList = () => _builder.SetList(x => x.Bars, nonListBuilder);
setList.ShouldThrow <ArgumentException>();
}
public void NodeTests()
{
var builder = new FluentBuilder();
builder.For<Foo>()
.Setup(m => m.Value)
.Setup(m => m.Value)
.EndSetup();
}
public void TestBuilderImplicitlyCoercesToAppliedResult()
{
var startingValue = Any.Int();
var builder = new FluentBuilder <int>(startingValue);
int coerced = builder;
builder.Apply().Should().Be(coerced);
}
public void BuilderCreatesObjectWithRequiredProperty()
{
var builder = new FluentBuilder <Car>();
Car car = builder.Create(1);
car.Should().NotBeNull();
car.Id.Should().Be(1);
}
public void BuildMethods_Should_ReturnBuilderObject()
{
var builder = new FluentBuilder <SomeClass>();
FluentBuilder <SomeClass> builderAfterMethodCall = ((dynamic)builder).WithSomeNumber(1);
builderAfterMethodCall.ShouldBeSameAs(builder);
}
public void Should_build_object_using_implicit_conversion_when_not_calling_build_method()
{
const string newValue = "Robson";
SampleClass createdObject = FluentBuilder <SampleClass> .New().With(newObject => newObject.PropertyWithSetter, newValue);
Assert.AreEqual(newValue, createdObject.PropertyWithSetter);
}
public void DeveSerPossivelCancelarMatricula()
{
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.CancelarMatricula();
Assert.IsTrue(matricula.Cancelada);
}
public void DevePoderAdicionarStatusDeReprovadoESemNota()
{
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.AdicionarNotaDoAlunoNoCurso(0, StatusDaAprovacaoDaMatricula.Reprovado);
Assert.AreEqual(StatusDaAprovacaoDaMatricula.Reprovado, matricula.StatusDaAprovacao);
}
public void NaoDeveAdicionarObservacaoVazia()
{
var matricula = FluentBuilder <Matricula> .New().Build();
var message = Assert.ThrowsException <ExcecaoDeDominio>(() => matricula.AdicionarObservacao(null)).Message;
Assert.AreEqual("Observação é obrigatório", message);
}
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 DevePoderAdicionarObservacao()
{
const string observacao = "observacao";
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.AdicionarObservacao(observacao);
Assert.AreEqual(observacao, matricula.Observacao);
}
public void DevePoderInformarSeAlunoEhUmInstrutorEmPotencial()
{
const bool ip = true;
var matricula = FluentBuilder <Matricula> .New().Build();
matricula.EhInstrutorEmPotencial(ip);
Assert.AreEqual(ip, matricula.Ip);
}
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 ShouldCreateEngine()
{
var builder = new FluentBuilder();
builder.For<Foo>()
.Setup(m => m.Value)
.MustBeGreaterThan(10);
var engine = builder.Build();
Assert.IsTrue(engine.Validate(new Foo(11)));
Assert.IsFalse(engine.Validate(new Foo(9)));
}
