public void Deve_Entregar_Contratos_Vigentes_Nas_Competencias()
        {
            throw new NotImplementedException();
            //Arrange
            string jsonCompetencias = jsonCompetenciaMensalJaneiro;
            IServicoFaturamento servicoConfiguracoesMock         = LOMock.ConfigurarServicoFaturamentoMock(jsonCompetencias);
            IServicoRetaguarda  servicoRetaguardaMock            = LOMock.ConfiguraRetaguardaMock(servicoConfiguracoesMock);
            IEnumerable <IContratoDeRemuneracao>       contratos = ConfiguraContratosMock();
            Mock <IRepositorioDeContratoDeRemuneracao> repositorioContratosMock = ConfigurarRepositorioContratos(contratos);
            IEnumerable <IRegraDeRemuneracao>          regras = ConfiguraRegrasMock();
            Mock <IRepositorioDeRegras> repositorioRegrasMock = ConfigurarRepositorioRegras(regras);
            Mock <LawofficeContext>     mockContext           = new Mock <LawofficeContext>();

            // TODO mudar para lógica de descobridor
            //var gerenciador = new GerenciadorDeRequisicoesDeContrato(repositorioContratosMock.Object, repositorioRegrasMock.Object, servicoRetaguardaMock.Object);
            ////gerenciador.ConfiguraServicosAsync(mockContext.Object).Wait();

            ////Act
            //var taskLista = gerenciador.RequisicaoListaContratosVigentesEmAsync(new[] { "201801" });
            //taskLista.Wait();
            //IEnumerable<IContratoDeRemuneracao> results = taskLista.Result;

            ////Arrange
            //Assert.True(contratos.SequenceEqual(results));
        }
        public async Task <Competencia[]> ConverteStringEmCompetenciasAsync(string[] competenciasString)
        {
            IServicoFaturamento servicoFaturamento = await _servicoRetaguarda.ObtemServicoDeFaturamentoAsync();

            IEnumerable <Competencia> competencias = await servicoFaturamento.ObterCompetenciasAsync(competenciasString);

            return(competencias.ToArray());
        }
        public static IServicoRetaguarda ConfiguraRetaguardaMock(IServicoFaturamento servicoFaturamento, IServicoProfissional servicoProfissional = null)
        {
            Mock <IServicoRetaguarda> mock = new Mock <IServicoRetaguarda>();

            mock.Setup(m => m.ObtemServicoDeFaturamentoAsync()).Returns(Task.FromResult(servicoFaturamento));
            mock.Setup(m => m.ObtemServicoDeProfissionaisAsync()).Returns(Task.FromResult(servicoProfissional));

            return(mock.Object);;
        }
        public static IRegraDeRemuneracao ConstroiRegraPorHora(ParametrosDeRegraDeRemuneracao parametrosDeRegra, IFavorecimento favorecimento, ITabelaDePreco <int> tabelaDePreco)
        {
            Fixture             fixture            = new Fixture();
            IServicoFaturamento servicoFaturamento = ConfigurarServicoFaturamentoMock(tabelasDePreco: new[] { tabelaDePreco });
            IServicoRetaguarda  servicoRetaguarda  = ConfiguraRetaguardaMock(servicoFaturamento);

            IRegraDeRemuneracao regra = new ConstrutorDeRegraDeRemuneracaoPorHora(servicoRetaguarda)
                                        .ComFavorecimento(favorecimento)
                                        .ComParametros(parametrosDeRegra)
                                        .Construir();

            return(regra);
        }