public void RnComunicarAlteracaoNomeCronogramaTest() { //inicializar o Dicionário tarefasGrid const string ipServidor = "127.0.0.1"; const int porta = 8093; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); WexMultiAccessClientMock client = new WexMultiAccessClientMock(); client.Porta = porta; client.EnderecoIp = ipServidor; client.Login = "******"; client.OidCronograma = "C1"; client.Conectar(); client.AoServidorDesconectar += (mensagemDto) => { }; TcpClient conexaoClienteNoServidor = servidor.AcceptTcpClient(); //efetuar a leitura da autenticacao do client TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor); client.RnComunicarAlteracaoDadosCronograma(); ControleDeEsperaUtil.AguardarAte(() => { return(conexaoClienteNoServidor.Available > 0); }); string mensagemJson = TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor); mensagemJson = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemJson); MensagemDto mensagemRecebida = JsonConvert.DeserializeObject <MensagemDto>(mensagemJson); Assert.AreEqual(client.Login, (string)mensagemRecebida.Propriedades[Constantes.AUTOR_ACAO], "O nome do autor da ação deveria corresponder ao nome esperado"); Assert.AreEqual(client.OidCronograma, (string)mensagemRecebida.Propriedades[Constantes.OIDCRONOGRAMA], "O oid do cronograma atual deveria corresponder ao oid atual"); }
public void EntaoOServidorNaoDeveraTerEmSuaListaDeColaboradoresOnlineNoCronogramaOSColaboradorEs(string cronograma, string login) { string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString(); ControleDeEsperaUtil.AguardarAte(() => { return(!manager.ColaboradorConectado(login, oidCronograma)); }); Assert.IsFalse(manager.ColaboradorConectado(login, oidCronograma), "Deveria encontrar o colaborador João no dicionário de usuários conectados"); }
public void EntaoOServidorDeveSerComunicadoQueQueOSColaboradorEsJoaoEstaOConectadoSAoCronograma01(string login, string cronograma) { string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString(); ControleDeEsperaUtil.AguardarAte(() => { return(manager.ColaboradorConectado(login, oidCronograma)); }); Assert.IsTrue(manager.ColaboradorConectado(login, oidCronograma), "Deveria encontrar o colaborador João no dicionário de usuários conectados"); }
public void EntaoOServidorDeveraReceberASolicitacaoParaExcluirASTarefaSNoCronograma(string tarefasString, string naoUsada, string cronograma) { List <string> tarefasEsperadas = tarefasString.Replace("\'", "").Split(',').Select(o => o.Trim()).ToList(); List <string> oidTarefas; Dictionary <string, string> TarefasDic = new Dictionary <string, string>(); Dictionary <string, bool> exclusoesSolicitadas = new Dictionary <string, bool>(); string oidTarefa; foreach (string tarefa in tarefasEsperadas) { oidTarefa = StepCronograma.CronogramaTarefasDic[cronograma][tarefa].Oid.ToString(); exclusoesSolicitadas.Add(oidTarefa, false); TarefasDic.Add(oidTarefa, tarefa); } oidTarefas = exclusoesSolicitadas.Select(o => o.Key).ToList(); string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString(); ControleDeEsperaUtil.AguardarAte(() => { return(manager.SolicitacoesExclusao.ContainsKey(oidCronograma) && manager.SolicitacoesExclusao[oidCronograma].Count == tarefasEsperadas.Count); }); foreach (string oid in oidTarefas) { ControleDeEsperaUtil.AguardarAte(() => { return(manager.SolicitacoesExclusao[oidCronograma].Contains(oid)); }); Assert.IsTrue(manager.SolicitacoesExclusao[oidCronograma].Contains(oid), string.Format("O cronograma {0} deveria ter recebido a solicitação da exclusão da tarefa {1}", cronograma, TarefasDic[oid])); } }
public void EntaoOServidorDeveSerComunicadoQueATarefaDoCronogramaEstaSendoEditadaPeloColaborador(string tarefa, string cronograma, string login) { string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString(); string oidTarefa = StepCronograma.CronogramaTarefasDic[cronograma][tarefa].Oid.ToString(); List <MensagemDto> mensagens = null; MensagemDto mensagemFiltrada = null; ControleDeEsperaUtil.AguardarAte(() => { mensagens = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas); mensagemFiltrada = mensagens.FirstOrDefault (o => o.Tipo == CsTipoMensagem.InicioEdicaoTarefa && o.Propriedades[Constantes.AUTOR_ACAO].ToString() == login && o.Propriedades[Constantes.OIDTAREFA].ToString() == oidTarefa ); return(mensagemFiltrada != null); }); Assert.IsNotNull(mensagemFiltrada, "Não deveria ter sido nula, colaborador deveria ter recebido a mensagem pesquisada"); Assert.AreEqual(login, mensagemFiltrada.Propriedades[Constantes.AUTOR_ACAO].ToString(), string.Format("O colaborador autor da mensagem deveria ser {0}", login)); Assert.AreEqual(oidTarefa, mensagemFiltrada.Propriedades[Constantes.OIDTAREFA].ToString(), string.Format("O Oid da tarefa editada deveria ser {0}", oidTarefa)); Assert.AreEqual(oidCronograma, mensagemFiltrada.Propriedades[Constantes.OIDCRONOGRAMA].ToString(), string.Format("O Oid do Cronograma atual deveria ser {0}", oidCronograma)); }
public void RnProcessarEventosFinalizarEdicaoTarefa() { int contador = 0; WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { TcpAdapterStubAtivo = true }; TcpAdapterPool pool = new TcpAdapterPool(); #region Preenchendo informações do cliente cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); pool.AceitarConexao(cliente); cliente.AoSerFinalizadaEdicaoTarefaPorOutroUsuario += (mensagem) => { contador++; }; cliente.AoServidorDesconectar += (mensagemDto) => { }; #endregion //Criando a mensagem de fim de edição de uma tarefa por outro colaborador MensagemDto mensagemFimDeEdicao = Mensagem.RnCriarMensagemFinalizarEdicaoTarefa("T1", "Marcos", "C1"); string mensagemJson = JsonConvert.SerializeObject(mensagemFimDeEdicao); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); pool.EnviarMensagemPara(cliente, mensagemJson); ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); }); Assert.AreEqual(1, contador, "Deveria ter sido disparado o evento AoEdicaoTarefaSerRecusada"); cliente.RnDesconectar(); }
public void GetConfigColaboradoresQuandoVariosColaboradoresJaTiveramSuasCoresSelecionadas() { string cor1 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[0]); string cor2 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[1]); string cor3 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[2]); string cor4 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[0]); string corSelecionda1 = ProjetoColaboradorConfig.RnEscolherCor(s1, colaborador1.Oid, projeto1.Oid); SessionTest.DropIdentityMap(); string corSelecionda2 = ProjetoColaboradorConfig.RnEscolherCor(s2, colaborador2.Oid, projeto1.Oid); SessionTest.DropIdentityMap(); string corSelecionda3 = ProjetoColaboradorConfig.RnEscolherCor(s3, colaborador3.Oid, projeto1.Oid); SessionTest.DropIdentityMap(); string corSelecionda4 = ProjetoColaboradorConfig.RnEscolherCor(s4, colaborador4.Oid, projeto2.Oid); List <ProjetoColaboradorConfig> configs = null; ControleDeEsperaUtil.AguardarAte(() => { configs = new List <ProjetoColaboradorConfig>(ProjetoColaboradorConfig.GetConfigColaboradores(SessionTest, projeto1.Oid)); return(configs != null && configs.Count == 3); }); //List<ProjetoColaboradorConfig> configs = ProjetoColaboradorConfig.GetConfigColaboradores( SessionTest, projeto1.Oid ); //Assert.AreEqual( 3, configs.Count, string.Format( "Deveria possuir 3 configs salvos para o {0}",projeto1.TxNome ) ); Assert.AreEqual(cor1, corSelecionda1, "Deveria ter encontrado a cor selecionada para o usuário"); Assert.AreEqual(cor2, corSelecionda2, "Deveria ter encontrado a cor selecionada para o usuário"); Assert.AreEqual(cor3, corSelecionda3, "Deveria ter encontrado a cor selecionada para o usuário"); Assert.AreEqual(cor4, corSelecionda4, "Deveria ter encontrado a cor selecionada para o usuário"); }
public void RnProcessarEventosDispararEventoAoReceberMensagemDeServidorDesconectando() { int contador = 0; string oidCronograma = Guid.NewGuid().ToString(); TcpAdapterPool poolTcp = new TcpAdapterPool(); //Criando a mensagem de desconexão do servidor MensagemDto mensagemTemporaria = Mensagem.RnCriarMensagemServidorDesconectando("Servidor Efetuando Processo de Desligamento!"); string mensagemJson = JsonConvert.SerializeObject(mensagemTemporaria); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); WexMultiAccessClientMock client = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, Porta = porta, Login = "******", OidCronograma = oidCronograma, TcpAdapterStubAtivo = true }; client.Conectar(); poolTcp.AceitarConexao(client); client.AoServidorDesconectar += (mensagem) => { contador++; }; poolTcp.ServerBroadCast(mensagemJson); ControleDeEsperaUtil.AguardarAte(() => { return(contador > 0); }); Assert.AreEqual(1, contador, "O contador adicionado ao Evento AoServidorDesconectar deveria ter sido contado 1 vez"); client.RnDesconectar(); }
public void EntaoOServidorDeveSerComunicadoQueOColaboradorSeDesconectou(string login) { bool recebeu = false; List <MensagemDto> mensagensFiltradas = null; string[] usuarios = null; ControleDeEsperaUtil.AguardarAte(() => { mensagensFiltradas = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas).Where(o => o.Tipo.Equals(CsTipoMensagem.UsuarioDesconectado)).ToList(); if (mensagensFiltradas != null) { foreach (var item in mensagensFiltradas) { usuarios = (string[])item.Propriedades[Constantes.USUARIOS]; if (usuarios.Contains(login)) { recebeu = true; break; } } } return(recebeu); }, 7); Assert.IsTrue(recebeu, string.Format("O deveria possuir a mensagem de que {0} se desconectou", login)); }
public void EntaoOServidorDeveDetectarDeQueOSColaboradorEsForamDesconectadoS(string colaboradores, string naoUsado) { string[] logins = colaboradores.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray(); foreach (string colaborador in logins) { ControleDeEsperaUtil.AguardarAte(() => { return(!manager.ColaboradorConectado(colaborador)); }, 10); Assert.IsFalse(manager.ColaboradorConectado(colaborador), "O Colaborador Não Deveria estar conectado ao manager"); } }
public void RnComunicarCriacaoNovaTarefaQuandoEnviarMensagemNovaTarefaTest() { int contador = 0; TcpAdapterPool poolTcp = new TcpAdapterPool(); WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, OidCronograma = "C1", Porta = porta, Login = "******", TcpAdapterStubAtivo = true }; WexMultiAccessClientMock cliente2 = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, OidCronograma = "C1", Porta = porta, Login = "******", TcpAdapterStubAtivo = true }; cliente.Conectar(); poolTcp.AceitarConexao(cliente); cliente2.Conectar(); poolTcp.AceitarConexao(cliente2); cliente.AoServidorDesconectar += (mensagemDto) => { }; cliente2.AoServidorDesconectar += (mensagemDto) => { }; Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>(); tarefasImpactadas.Add("T2", 3); tarefasImpactadas.Add("T3", 4); tarefasImpactadas.Add("T4", 5); tarefasImpactadas.Add("T5", 6); tarefasImpactadas.Add("T6", 7); tarefasImpactadas.Add("T7", 8); DateUtil.CurrentDateTime = DateTime.Now; cliente.RnComunicarNovaTarefaCriada("T1", "C1", null, DateUtil.CurrentDateTime); int codigoTipoMensagem = (int)CsTipoMensagem.NovaTarefaCriada; ControleDeEsperaUtil.AguardarAte(() => { return(cliente2.contagemTiposMensagemDtoRecebidas.ContainsKey(codigoTipoMensagem) && cliente2.contagemTiposMensagemDtoRecebidas[codigoTipoMensagem] > 0); }); MensagemDto mensagemRecebida = cliente2.MensagensRecebidas.FirstOrDefault(o => o.Tipo.Equals(CsTipoMensagem.NovaTarefaCriada)); MensagemDto objetoMensagemEsperado = Mensagem.RnCriarMensagemNovaTarefaCriada("T1", cliente.Login, "C1", null, DateUtil.CurrentDateTime); Assert.AreEqual(objetoMensagemEsperado.Propriedades[OIDTAREFA], mensagemRecebida.Propriedades[OIDTAREFA]); Assert.AreEqual(objetoMensagemEsperado.Propriedades[LOGIN], mensagemRecebida.Propriedades[LOGIN]); Assert.AreEqual(objetoMensagemEsperado.Propriedades[OIDCRONOGRAMA], mensagemRecebida.Propriedades[OIDCRONOGRAMA]); Assert.AreEqual(objetoMensagemEsperado.Propriedades[DATAHORA_ACAO], mensagemRecebida.Propriedades[DATAHORA_ACAO]); }
public void RnProcessarEventosProcessarMensagemInicioEdicaoTarefaTest() { bool mensagemRecebida = false; TcpAdapterPool pool = new TcpAdapterPool(); WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { TcpAdapterStubAtivo = true }; #region Preenchendo informações do cliente cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); pool.AceitarConexao(cliente); cliente.AoServidorDesconectar += (mensagemDto) => { }; #endregion WexMultiAccessClientMock cliente2 = new WexMultiAccessClientMock() { TcpAdapterStubAtivo = true }; #region Preenchendo informações cliente2 cliente2.EnderecoIp = ipServidor; cliente2.OidCronograma = "C1"; cliente2.Porta = porta; cliente2.Login = "******"; cliente2.Conectar(); pool.AceitarConexao(cliente2); cliente2.AoServidorDesconectar += (mensagemDto) => { }; cliente2.AoIniciarEdicaoTarefa += (mensagemDto) => { if (mensagemDto != null && mensagemDto.Tipo.Equals(CsTipoMensagem.InicioEdicaoTarefa)) { mensagemRecebida = true; } }; #endregion cliente.RnComunicarInicioEdicaoTarefa("T1"); ControleDeEsperaUtil.AguardarAte(() => { return(mensagemRecebida); }); //Criando uma réplica do que deverá ser recebido pelo cliente2 MensagemDto objetoMensagemEsperado = Mensagem.RnCriarMensagemInicioEdicaoTarefa("T1", cliente.Login, "C1"); objetoMensagemEsperado.Propriedades.Add(Constantes.LOGIN_WEX_CLIENT, cliente2.Login); MensagemDto objetoMensagem = cliente2.MensagensRecebidas.FirstOrDefault(o => o.Tipo.Equals(CsTipoMensagem.InicioEdicaoTarefa)); Assert.IsNotNull(objetoMensagem, string.Format("{0} deveria ser avisado que uma tarefa entrou em edição.", cliente2.Login)); CollectionAssert.AreEquivalent(objetoMensagemEsperado.Propriedades, objetoMensagem.Propriedades, "Deveria ter recebido as informações esperadas."); cliente.RnDesconectar(); }
public void RnComunicarInicioEdicaoTarefaTest() { bool foiInformado = false; WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { TcpAdapterStubAtivo = true }; TcpAdapterPool pool = new TcpAdapterPool(); cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); pool.AceitarConexao(cliente); cliente.AoServidorDesconectar += (mensagemDto) => { }; WexMultiAccessClientMock cliente2 = new WexMultiAccessClientMock() { TcpAdapterStubAtivo = true }; cliente2.EnderecoIp = ipServidor; cliente2.OidCronograma = "C1"; cliente2.Porta = porta; cliente2.Login = "******"; cliente2.Conectar(); pool.AceitarConexao(cliente2); cliente2.AoServidorDesconectar += (mensagemDto) => { }; cliente2.AoIniciarEdicaoTarefa += (mensagemDto) => { if (mensagemDto != null && mensagemDto.Tipo.Equals(CsTipoMensagem.InicioEdicaoTarefa)) { foiInformado = true; } }; cliente.RnComunicarInicioEdicaoTarefa("T1"); ControleDeEsperaUtil.AguardarAte(() => { return(foiInformado); }); //Recebendo a mensagem de que iniciou edição de uma tarefa MensagemDto objetoMensagemEsperado = Mensagem.RnCriarMensagemInicioEdicaoTarefa("T1", cliente.Login, "C1"); objetoMensagemEsperado.Propriedades.Add(Constantes.LOGIN_WEX_CLIENT, cliente2.Login); MensagemDto objetoMensagem = cliente2.MensagensRecebidas.FirstOrDefault(o => o.Tipo.Equals(CsTipoMensagem.InicioEdicaoTarefa)); Assert.IsNotNull(objetoMensagem, "Deveria ter recebido a mensagem esperada"); CollectionAssert.AreEquivalent(objetoMensagemEsperado.Propriedades, objetoMensagem.Propriedades); cliente.RnDesconectar(); }
public void RnProcessarEventosRecebendoMensagemDoTipoExclusaoTarefaFinalizada() { DateUtil.CurrentDateTime = DateTime.Now; const string ipServidor = "127.0.0.1"; const int porta = 8091; bool disparoEvento = false; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>() { CallBase = true }; WexMultiAccessClientMock cliente = clienteMock.Object; cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); cliente.AoSerExcluidaTarefaPorOutroUsuario += (mensagemDto) => { disparoEvento = true; }; cliente.AoServidorDesconectar += (mensagemDto) => { }; TcpClient tcpEmServidor = servidor.AcceptTcpClient(); //interceptando a mensagem de conexão TcpUtil.ReceberMensagemTcp(tcpEmServidor); Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>(); tarefasImpactadas.Add("T3", 3); tarefasImpactadas.Add("T4", 4); MensagemDto mensagem = Mensagem.RnCriarMensagemComunicarExclusaoTarefaConcluida(new string[] { "T1", "T5" }, tarefasImpactadas, "C1", "Joao", DateUtil.CurrentDateTime, new string[] { "T2" }); string mensagemJson = JsonConvert.SerializeObject(mensagem); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); //enviando mensagem ao cliente TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor); ControleDeEsperaUtil.AguardarAte(() => { return(disparoEvento); }); Assert.IsTrue(disparoEvento, "Deveria ter sido acionado o evento AoSerExcluidaTarefaPorOutroUsuario"); MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.ExclusaoTarefaFinalizada).FirstOrDefault(); Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo AoSerExcluidaTarefaPorOutroUsuario"); CollectionAssert.AreEqual(tarefasImpactadas, (Dictionary <string, Int16>)mensagemEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS]); CollectionAssert.AreEqual(new string[] { "T1", "T5" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS]); CollectionAssert.AreEqual(new string[] { "T2" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS_NAO_EXCLUIDAS]); Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA]); Assert.AreEqual("Joao", (string)mensagemEsperada.Propriedades[Constantes.AUTOR_ACAO]); Assert.AreEqual(DateUtil.CurrentDateTime, (DateTime)mensagemEsperada.Propriedades[Constantes.DATAHORA_ACAO]); cliente.RnDesconectar(); }
public void EntaoOServidorDeveraComunicarOColaboradorQueNoCronogramaAsSeguintesTarefaSEstaoEmEdicao(string colaborador, string cronograma, Table table) { string oidTarefa; string key; IEnumerable <EdicaoTarefaHelper> edicoes = table.CreateSet <EdicaoTarefaHelper>(); foreach (var edicao in edicoes) { oidTarefa = StepCronograma.GetOidTarefaNoCronograma(cronograma, edicao.Tarefa); key = StepContextUtil.CriarKeyTarefaJaEstavamEmEdicao(colaborador, oidTarefa, edicao.Autor); ControleDeEsperaUtil.AguardarAte(() => { return(StepContextUtil.CenarioAtualContemAChave(key)); }); Assert.IsTrue(StepContextUtil.CenarioAtualContemAChave(key), string.Format("{0} deveria ter sido avisado de que a tarefa {1} estava em edição pelo colaborador {2}" + " no cronograma {3}", colaborador, edicao.Tarefa, edicao.Autor, cronograma)); } }
public void EntaoOServidorDeveraRecusarAEdicaoDoNomeDoCronogramaParaOColaborador(string cronograma, string login) { string oidCronograma = StepCronograma.GetOidCronograma(cronograma); WexMultiAccessClientMock cliente = StepContextUtil.GetAccessClientNoContexto(login, oidCronograma); List <MensagemDto> mensagens = null; MensagemDto mensagem = null; ControleDeEsperaUtil.AguardarAte(() => { mensagens = new List <MensagemDto>(cliente.MensagensRecebidas); mensagem = mensagens.FirstOrDefault(o => o.Propriedades[Constantes.OIDCRONOGRAMA].ToString() == oidCronograma && o.Tipo == CsTipoMensagem.EdicaoNomeCronogramaRecusada); return(mensagem != null); }); Assert.IsNotNull(mensagem, "Deveria ter recebido a mensagem do permissão de edição do nome do cronograma"); Assert.AreEqual(login, mensagem.Propriedades[Constantes.AUTOR_ACAO], string.Format("O proprietario da mensagem deveria ser o colaborador {0}", login)); }
public void RnProcessarEventosRecebendoMensagemDoTipoExclusaoTarefaPermitida() { const string ipServidor = "127.0.0.1"; const int porta = 8090; int contador = 0; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); MensagemDto mensagemEsperada = new MensagemDto(); Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>() { CallBase = true }; WexMultiAccessClientMock cliente = clienteMock.Object; cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); cliente.ExecutarExclusaoTarefa += (mensagemDto) => { contador++; mensagemEsperada = mensagemDto; }; cliente.AoServidorDesconectar += (mensagemDto) => { }; TcpClient tcpEmServidor = servidor.AcceptTcpClient(); //interceptando a mensagem de conexão TcpUtil.ReceberMensagemTcp(tcpEmServidor); Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>(); tarefasImpactadas.Add("T3", 3); tarefasImpactadas.Add("T4", 4); //MensagemDto mensagem = Mensagem.RnCriarMensagemEdicaoTarefaAutorizada(2 ,4 ,"T2","Joao" ,"C1"); MensagemDto mensagem = Mensagem.RnCriarMensagemEfetuarExclusaoTarefas(new string[] { "T1", "T2" }, new string[] { }, "C1", "Joao"); string mensagemJson = JsonConvert.SerializeObject(mensagem); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); //enviando mensagem ao cliente TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor); ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); }); Assert.AreEqual(1, contador, "Deveria ter sido acionado o evento ExecutarExclusaoTarefa"); //MensagemDto mensagemEsperada = cliente.mensagensDtoEvento.Where(o => o.Tipo == CsTipoMensagem.ExclusaoTarefaPermitida).FirstOrDefault(); Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo ExecutarExclusaoTarefa"); CollectionAssert.AreEqual(new string[] { "T1", "T2" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS]); Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA]); Assert.AreEqual("Joao", (string)mensagemEsperada.Propriedades[Constantes.AUTOR_ACAO]); cliente.RnDesconectar(); }
public void EntaoOServidorNaoDeveComunicarAoSColaboradorEsDeQueASTarefaSRecebeuRamAtualizacaoOesNoCronograma(string colaboradores, string naoUsado, string tarefasOutroCronograma, string naoUsado2, string outroCronograma) { string[] logins = colaboradores.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray(); string[] tarefas = tarefasOutroCronograma.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray(); string oidTarefa; string key; for (int i = 0; i < logins.Length; i++) { for (int x = 0; x < tarefas.Length; x++) { oidTarefa = StepCronograma.GetOidTarefaNoCronograma(outroCronograma, tarefas[x]); key = StepContextUtil.CriarKeyRecebeuAtualizacaoEdicaoTarefa(logins[i], oidTarefa); ControleDeEsperaUtil.AguardarAte(() => { return(StepContextUtil.CenarioAtualContemAChave(key)); }); Assert.IsFalse(StepContextUtil.CenarioAtualContemAChave(key), string.Format("{0} não deveria ter sido comunicado da atualização da tarefa {1} que pertence outro cronograma '{2}'", logins[i], tarefas[x], outroCronograma)); } } }
public void QuandoOServidorReceberASolicitacaoDeAlteracaoDoNomeDoCronogramaPeloColaborador(string cronograma, string login) { List <MensagemDto> mensagens = null; MensagemDto mensagemEsperada = null; ControleDeEsperaUtil.AguardarAte(() => { mensagens = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas); mensagemEsperada = mensagens.FirstOrDefault(o => o.Propriedades.ContainsKey(Constantes.AUTOR_ACAO) && o.Propriedades[Constantes.AUTOR_ACAO].ToString() == login && o.Tipo == CsTipoMensagem.InicioEdicaoNomeCronograma); return(mensagemEsperada != null); }); Assert.IsNotNull(mensagemEsperada, string.Format("Deveria ter recebido a mensagem enviada pelo colaborador {0}", login)); Assert.AreEqual(1, manager.CronogramasNomeEmEdicao.Count, "Deveria possuir 1 cronograma com nome em edição"); string oidCronograma = mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA] as string; Assert.IsNotNull(oidCronograma, "Deveria ter recebido o oid do cronograma que possui o nome a ser alterado"); }
public void RnComunicarFimEdicaoTarefaTest() { int contador = 0; TcpAdapterPool pool = new TcpAdapterPool(); WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, OidCronograma = "C1", Porta = porta, Login = "******", TcpAdapterStubAtivo = true }; WexMultiAccessClientMock cliente2 = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, OidCronograma = "C1", Porta = porta, Login = "******", TcpAdapterStubAtivo = true }; cliente.Conectar(); pool.AceitarConexao(cliente); cliente2.Conectar(); pool.AceitarConexao(cliente2); cliente2.AoServidorDesconectar += (mensagem) => { }; cliente2.AoSerFinalizadaEdicaoTarefaPorOutroUsuario += (mensagem) => { contador++; }; cliente.AoServidorDesconectar += (mensagem) => { }; cliente.RnComunicarFimEdicaoTarefa("T1"); ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); }); MensagemDto mensagemDto = cliente2.MensagensRecebidas.FirstOrDefault(o => o.Tipo.Equals(CsTipoMensagem.EdicaoTarefaFinalizada)); Assert.AreEqual(CsTipoMensagem.EdicaoTarefaFinalizada, mensagemDto.Tipo, "A mensagem recebida veio com tipo diferente do original"); Assert.IsTrue(mensagemDto.Propriedades.ContainsKey(Constantes.AUTOR_ACAO), "Deveria possuir joao na sua lista de propriedades"); Assert.AreEqual("T1", (string)mensagemDto.Propriedades[Constantes.OIDTAREFA]); Assert.AreEqual("C1", (string)mensagemDto.Propriedades[OIDCRONOGRAMA]); }
public void RnProcessarEventosRecebendoMensagemDoTipoMovimentacaoPosicaoTarefa() { DateUtil.CurrentDateTime = DateTime.Now; const string ipServidor = "127.0.0.1"; const int porta = 8089; int contador = 0; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>() { CallBase = true }; WexMultiAccessClientMock cliente = clienteMock.Object; cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); cliente.AoOcorrerMovimentacaoPosicaoTarefa += (mensagemDto) => { contador++; }; cliente.AoServidorDesconectar += (mensagemDto) => { }; TcpClient tcpEmServidor = servidor.AcceptTcpClient(); //interceptando a mensagem de conexão TcpUtil.ReceberMensagemTcp(tcpEmServidor); Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>(); tarefasImpactadas.Add("T3", 3); tarefasImpactadas.Add("T4", 4); MensagemDto mensagem = Mensagem.RnCriarMensagemMovimentacaoTarefa(2, 4, "T2", tarefasImpactadas, "Joao", "C1", DateUtil.CurrentDateTime); string mensagemJson = JsonConvert.SerializeObject(mensagem); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); //enviando mensagem ao cliente TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor); ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); }); Assert.AreEqual(1, contador, "Deveria ter sido acionado o evento AoOcorrerMovimentacaoPosicaoTarefa"); MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.MovimentacaoPosicaoTarefa).FirstOrDefault(); Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo MovimentacaoPosicaoTarefa"); CollectionAssert.AreEqual(tarefasImpactadas, (Dictionary <string, Int16>)mensagemEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS]); cliente.RnDesconectar(); }
public void DadoQueOServidorContenhaOSColaboradorEsConectadoSNoCronograma(string colaboradores, string naoUsado, string cronograma) { string[] cols = colaboradores.Split(','); WexMultiAccessClientMock cliente; string login; foreach (string colaborador in cols) { login = colaborador.Replace("\'", ""); login = login.Trim(); string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString(); cliente = CriarMultiAccessClient(login, oidCronograma); cliente.Conectar(); ControleDeEsperaUtil.AguardarAte(() => { return(manager.ColaboradorConectado(login, oidCronograma)); }); StepContextUtil.SalvarAccessClientNoContextoDoCenario(cliente); } }
public void RnProcessarEventosRecebendoMensagemDoTipoEdicaoTarefaAutorizada() { const string ipServidor = "127.0.0.1"; const int porta = 8088; int contador = 0; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>() { CallBase = true }; WexMultiAccessClientMock cliente = clienteMock.Object; cliente.EnderecoIp = ipServidor; cliente.OidCronograma = "C1"; cliente.Porta = porta; cliente.Login = "******"; cliente.Conectar(); cliente.AoSerAutorizadaEdicaoTarefa += (mensagem) => { contador++; }; cliente.AoServidorDesconectar += (mensagemDto) => { }; TcpClient tcpEmServidor = servidor.AcceptTcpClient(); //interceptando a mensagem de conexão TcpUtil.ReceberMensagemTcp(tcpEmServidor); MensagemDto mensagemEdicaoAutorizada = Mensagem.RnCriarMensagemEdicaoTarefaAutorizada("Joao", "C1", "T1"); string mensagemJson = JsonConvert.SerializeObject(mensagemEdicaoAutorizada); mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson); TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor); ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); }); Assert.AreEqual(1, contador, "Deveria ter siso disparado o evento AoEdicaoTarefaSerRecusada"); MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.EdicaoTarefaAutorizada).First(); Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA], "A mensagem recebida deveria ser do cronograma indicado"); Assert.AreEqual("T1", (string)mensagemEsperada.Propriedades[Constantes.OIDTAREFA], "O oid da tarefa da mensagem recebida deveria ser o passado na criação da mensagem"); cliente.RnDesconectar(); }
public void EntaoOCronogramaNaoDeveComunicarAoSColaboradorEsDeQueEstaOSendoExcluidaSTarefaSNoCronograma(string cronograma, string colaboradoresString, string naoUsada1, string outroCronograma) { List <string> colaboradores = colaboradoresString.Replace("\'", "").Split(',').Select(o => o.Trim()).ToList(); Dictionary <string, bool> colaboradoresAvisados = new Dictionary <string, bool>(); //Montando Dicionário em que nenhum colaborador foi avisado sobre a exclusão foreach (string colaboradorAtual in colaboradores) { colaboradoresAvisados.Add(colaboradorAtual, false); } WexMultiAccessClientMock clientAtual; string oidCronograma = StepCronograma.GetOidCronograma(cronograma); string oidOutroCronograma = StepCronograma.GetOidCronograma(outroCronograma); bool foiComunicado; List <MensagemDto> mensagens = null; MensagemDto mensagem; foreach (var colaboradorAtual in colaboradores) { foiComunicado = false; clientAtual = StepContextUtil.GetAccessClientNoContexto(colaboradorAtual, oidCronograma); ControleDeEsperaUtil.AguardarAte(() => { mensagens = new List <MensagemDto>(clientAtual.MensagensRecebidas); mensagem = mensagens.FirstOrDefault( o => o.Tipo == CsTipoMensagem.ExclusaoTarefaFinalizada && !o.Propriedades[Constantes.OIDCRONOGRAMA].ToString().Equals(oidOutroCronograma) ); if (mensagem != null) { foiComunicado = true; } return(foiComunicado); }); Assert.IsFalse(foiComunicado, string.Format("{0} não deveria ser comunicado de que houve exclusão em um cronograma diferente ('{1}')", colaboradorAtual, outroCronograma)); } }
public void DesconectarConexaoClienteTest() { IPAddress ipServidor = IPAddress.Parse("127.0.0.1"); const int porta = 8003; TcpListener servidor = new TcpListener(ipServidor, porta); servidor.Start(); TcpClient tcpCliente = new TcpClient(); tcpCliente.Connect(ipServidor, porta); servidor.AcceptTcpClient(); Queue <MensagemDto> fila = new Queue <MensagemDto>(); const string login = "******"; ConexaoCliente conexao = new ConexaoCliente(login, tcpCliente, fila); conexao.Desconectar(); ControleDeEsperaUtil.AguardarAte(() => { return(!conexao.threadProcessarLeitura.IsAlive); }); //TODO: @wex developer rever permissão cliente. Assert.IsFalse(conexao.PermissaoDeEscrita, "Deveria ter a permissão de processamento de escrita desativada"); Assert.IsFalse(conexao.PermissaoDeLeitura, "Deveria ter a permissão de processamento de leitura desativada"); Assert.IsFalse(conexao.threadProcessarLeitura.IsAlive, "Sem a permissão a thread de processamento de leitura deveria ter encerrado"); }
public void ConsultarSemaforosImpactadosPorCronogramaQuandoExistiremVariosConflitantesTest() { #region contexto //semáforo já existente SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20); //semáforo já existente no cronograma SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle() { lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>() }; semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1); //mockando o método que realiza a liberação de um semáforo. Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>() { CallBase = true }; SemaforoSingletonMock.SetInstancia(mockSemaforo.Object); SemaforoSingletonMock.cronogramaSemaforosMock.Clear(); SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1); cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 5, final = 8, tempoDeEspera = 0 }; cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 1, final = 5, tempoDeEspera = 6000 }; cronogramaIntervalo cronoIntervalo3 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 6, final = 10, tempoDeEspera = 8000 }; cronogramaIntervalo cronoIntervalo4 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 2, final = 5, tempoDeEspera = 1000 }; cronogramaIntervalo cronoIntervalo5 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 2, final = 4, tempoDeEspera = 2000 }; cronogramaIntervalo cronoIntervalo6 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 1, final = 6, tempoDeEspera = 3000 }; Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Highest, Name = "Thread 1", }; Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 2" }; Thread thread3 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 3" }; Thread thread4 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 4" }; Thread thread5 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 5" }; Thread thread6 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 6" }; #endregion thread1.Start(cronoIntervalo1); thread2.Start(cronoIntervalo2); thread3.Start(cronoIntervalo3); thread4.Start(cronoIntervalo4); thread5.Start(cronoIntervalo5); thread6.Start(cronoIntervalo6); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Stopped && thread2.ThreadState == System.Threading.ThreadState.Stopped && thread3.ThreadState == System.Threading.ThreadState.Stopped && thread4.ThreadState == System.Threading.ThreadState.Stopped && thread5.ThreadState == System.Threading.ThreadState.Stopped && thread6.ThreadState == System.Threading.ThreadState.Stopped); }, 180); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo."); Assert.AreEqual(5, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados."); }
public void ConsultarSemaforosImpactadosPorCronogramaQuandoIntervaloAbrangerOutrosIntervalosTest() { //semáforo já existente SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20); //semáforo já existente no cronograma SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle() { lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>() }; semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1); //mockando o método que realiza a liberação de um semáforo. Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>() { CallBase = true }; SemaforoSingletonMock.SetInstancia(mockSemaforo.Object); SemaforoSingletonMock.cronogramaSemaforosMock.Clear(); SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1); cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 5, final = 15, tempoDeEspera = 0 }; cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 8, final = 22, tempoDeEspera = 5000 }; Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Highest, Name = "Thread 1", }; Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 2" }; thread1.Start(cronoIntervalo1); thread2.Start(cronoIntervalo2); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Stopped && thread2.ThreadState == System.Threading.ThreadState.Stopped); }, 60); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo."); Assert.AreEqual(3, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados."); List <SemaforoPorIntervalo> semaforosCriados = SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos; Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == semaforoIntervalo1.inicio && o.final == semaforoIntervalo1.final), "Deveria existir o semáforo, pois já estava criado."); Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 5 && o.final == 9), "Deveria existir o semáforo, pois a thread 1 criou."); Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 21 && o.final == 22), "Deveria existir o semáforo, pois a thread 2 criou."); }
public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasIguaisAcessaremSimultaneamenteEUmaEstiverEscrevendoNaListaEUmaEsperandoNaEscritaParaAdicionarOMesmoCronogramaTest() { //mockando o método que realiza a liberação de um semáforo. Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>() { CallBase = true }; mockSemaforo.Setup(o => o.EsperarLeituraCronogramas()); mockSemaforo.Setup(o => o.LiberarLeituraCronogramas()); SemaforoSingletonMock.SetInstancia(mockSemaforo.Object); SemaforoSingletonMock.cronogramaSemaforosMock.Clear(); cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 1, final = 10, tempoDeEspera = 0 }; cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 11, final = 15, tempoDeEspera = 500 }; Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados) { Priority = ThreadPriority.Highest, Name = "Thread 1", }; Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados) { Priority = ThreadPriority.Normal, Name = "Thread 2" }; thread1.Start(cronoIntervalo1); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Running); }); thread2.Start(cronoIntervalo2); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Stopped && thread2.ThreadState == System.Threading.ThreadState.Stopped); }, 15); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método."); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread 2 deveria estar em estado de finalizada, pois a thread 2 esperou a thread 1 e depois finalizou seu processamento."); Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista, pois a thread 1 já adicionou-o."); }
public void ConsultarSemaforosImpactadosPorCronogramaQuandoThreadsAcessaremSimultanementeDeCronogramasDiferentesTest() { SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(80, 100); SemaforoPorIntervalo semaforoIntervalo2 = new SemaforoPorIntervalo(80, 100); SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle() { lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>() }; SemaforoSingleton.SemaforosControle semaforoPorCronogramaC2 = new SemaforoSingleton.SemaforosControle() { lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>() }; semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1); semaforoPorCronogramaC2.semaforos.Add(semaforoIntervalo2); //mockando o método que realiza a liberação de um semáforo. Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>() { CallBase = true }; mockSemaforo.Setup(o => o.LiberarEscritaSemaforos(It.IsAny <Guid>())); SemaforoSingletonMock.SetInstancia(mockSemaforo.Object); SemaforoSingletonMock.cronogramaSemaforosMock.Clear(); SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[1].Oid, semaforoPorCronogramaC2); SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1); cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 5, final = 10, tempoDeEspera = 0 }; cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo() { oidCronograma = cronogramas[1].Oid, inicio = 8, final = 15, tempoDeEspera = 0 }; Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Highest, Name = "Thread 1", }; Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma) { Priority = ThreadPriority.Normal, Name = "Thread 2" }; thread1.Start(cronoIntervalo1); thread2.Start(cronoIntervalo2); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Stopped && thread2.ThreadState == System.Threading.ThreadState.Stopped); }, 60); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra."); Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir dois índices no dicionário de cronograma, pois 2 threads de cronogramas diferentes efetuaram o processo."); Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados."); Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[1].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados."); }
public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasDiferentesAcessaremSimultaneamenteUmaEstiverEscrevendoNaListaEUmaEsperandoParaEscreverNaListaTest() { //mockando o método que realiza a liberação de um semáforo. Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>() { CallBase = true }; mockSemaforo.Setup(o => o.EsperarLeituraCronogramas()); mockSemaforo.Setup(o => o.LiberarLeituraCronogramas()); mockSemaforo.Setup(o => o.LiberarEscritaCronogramas()); SemaforoSingletonMock.SetInstancia(mockSemaforo.Object); SemaforoSingletonMock.cronogramaSemaforosMock.Clear(); cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo() { oidCronograma = cronogramas[0].Oid, inicio = 1, final = 10, tempoDeEspera = 0 }; cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo() { oidCronograma = cronogramas[1].Oid, inicio = 11, final = 15, tempoDeEspera = 1000 }; Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados) { Priority = ThreadPriority.Highest, Name = "Thread 1", }; Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados) { Priority = ThreadPriority.Normal, Name = "Thread 2" }; thread1.Start(cronoIntervalo1); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Running); }); thread2.Start(cronoIntervalo2); ControleDeEsperaUtil.AguardarAte(() => { return(thread1.ThreadState == System.Threading.ThreadState.Stopped && thread2.ThreadState == System.Threading.ThreadState.WaitSleepJoin && SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount == 1); }, 100); Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método."); Assert.AreEqual(System.Threading.ThreadState.WaitSleepJoin, thread2.ThreadState, "A thread 2 deveria estar em estado de espera, pois a thread 1 ainda está realizando o processamento e a thread 2 não pode impactar a thread 2."); Assert.AreEqual(1, SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount, "Deveria ter 1 thread em espera de escrita, pois a thread 1 está realizando a escrita."); Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista."); Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock[cronogramas[0].Oid].semaforos.Count, "Deveria ter criado um semáforo."); }