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 RnComunicarInicioExclusaoTarefaTest() { const string ipServidor = "127.0.0.1"; const int porta = 8086; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, OidCronograma = "C1", Porta = porta, Login = "******" }; cliente.AoServidorDesconectar += (mensagem) => { }; cliente.Conectar(); TcpClient tcpEmServidor = servidor.AcceptTcpClient(); //interceptando a mensagem de conexão TcpUtil.ReceberMensagemTcp(tcpEmServidor); cliente.RnComunicarInicioExclusaoTarefa(new string[] { "T1", "T2", "T3" }); string resposta = TcpUtil.ReceberMensagemTcp(tcpEmServidor); resposta = TcpUtil.RemoverStringProtecaoDeIntegridade(resposta); MensagemDto mensagemDto = Mensagem.DeserializarMensagemDto(resposta); Assert.AreEqual(CsTipoMensagem.ExclusaoTarefaIniciada, mensagemDto.Tipo, "A mensagem recebida veio com tipo diferente do original"); Assert.IsTrue(mensagemDto.Propriedades.ContainsKey(Constantes.AUTOR_ACAO), "A mensagem deveria conter o usuário que solicitou a exclusão"); Assert.AreEqual("Joao", (string)mensagemDto.Propriedades[Constantes.AUTOR_ACAO], "O usuário deveria ser o Joao"); Assert.IsTrue(mensagemDto.Propriedades.ContainsKey(Constantes.TAREFAS), "A mensagem deveria conter tarefas"); CollectionAssert.AreEquivalent(new string[] { "T1", "T2", "T3" }, (string[])mensagemDto.Propriedades["tarefas"], "A mensagem recebida deveria possuir as mesmas tarefas que foram enviadas"); }
public void MultiAccessClientComunicarManagerSobreFimEdicaoTarefa() { const string ipServidor = "127.0.0.1"; const int porta = 8086; TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta); servidor.Start(); WexMultiAccessClientMock cliente = new WexMultiAccessClientMock() { EnderecoIp = ipServidor, Porta = porta, Login = "******", OidCronograma = "C1" }; cliente.AoServidorDesconectar += (mensagemDto) => { }; cliente.Conectar(); TcpClient conexaoTcpEmServidor = servidor.AcceptTcpClient(); //efetuando a leitura da primeira mensagem do cliente mensagemd e autenticação TcpUtil.ReceberMensagemTcp(conexaoTcpEmServidor); ///Comunicando o fim da tarefa cliente.RnComunicarFimEdicaoTarefa("T2"); string mensagemJson = TcpUtil.ReceberMensagemTcp(conexaoTcpEmServidor); mensagemJson = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemJson); MensagemDto mensagem = Mensagem.DeserializarMensagemDto(mensagemJson); Assert.AreEqual(cliente.OidCronograma, (string)mensagem.Propriedades[Constantes.OIDCRONOGRAMA], "Deveria ser o mesmo cronograma em que esta conectado o client"); Assert.IsTrue(mensagem.Propriedades.ContainsKey(Constantes.AUTOR_ACAO), "Deveria conter o login do colaborador que esta editou a tarefa"); Assert.AreEqual("T2", (string)mensagem.Propriedades[Constantes.OIDTAREFA], "Deveria ser a mesma tarefa comunicada na mensagem de fim de edição"); cliente.RnDesconectar(); servidor.Stop(); }
public void EnviarEReceberApenasMaisDeUmaMensagemTest() { IPAddress ipServidor = IPAddress.Parse("127.0.0.1"); const int portaServidor = 8052; TcpListener servidor = new TcpListener(ipServidor, portaServidor); servidor.Start(); Dictionary <string, TcpClient> usuariosDic = new Dictionary <string, TcpClient>(); Dictionary <string, TcpClient> usuariosEmServidorDic = new Dictionary <string, TcpClient>(); TcpClient tcpTemp1, tcpTemp2; string[] nomeUsuarios = new string[] { "Joao", "Pedro", "Paulo", "Marcos" }; foreach (string nome in nomeUsuarios) { tcpTemp1 = new TcpClient(); tcpTemp1.Connect(ipServidor, portaServidor); usuariosDic.Add(nome, tcpTemp1); tcpTemp2 = servidor.AcceptTcpClient(); usuariosEmServidorDic.Add(nome, tcpTemp2); } //Enviar Várias Mensagens List <string> listaMensagensEsperadas = new List <string>(); string txMensagem; foreach (var usuario in usuariosDic) { txMensagem = string.Format("Mensagem enviada pelo usuario:{0}", usuario.Key); listaMensagensEsperadas.Add(txMensagem); TcpUtil.EnviarMensagemTcp(txMensagem, usuario.Value); } //Receber Várias Mensagens List <string> listaMensagensRecebidas = new List <string>(); foreach (var usuario in usuariosEmServidorDic) { txMensagem = TcpUtil.ReceberMensagemTcp(usuario.Value); listaMensagensRecebidas.Add(txMensagem); } //Asserts Assert.AreEqual(listaMensagensEsperadas.Count, listaMensagensRecebidas.Count); for (int i = 0; i < listaMensagensEsperadas.Count; i++) { Assert.AreEqual(listaMensagensEsperadas.ElementAt(i), listaMensagensRecebidas.ElementAt(i), "Deveriam ser a mesma mensagem"); } servidor.Stop(); for (int i = 0; i < usuariosDic.Count; i++) { usuariosDic.ElementAt(i).Value.Close(); usuariosEmServidorDic.ElementAt(i).Value.Close(); } }
public void RnComunicarFimExclusaoTarefaConcluidaTest() { DateUtil.CurrentDateTime = DateTime.Now; //inicializar o Dicionário tarefasGrid const string ipServidor = "127.0.0.1"; const int porta = 8092; 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); //representar as tarefas no grid Dictionary <string, Int16> tarefasGrid = new Dictionary <string, short>(); //preencher as tarefas no grid //representar as tarefas excluidas string[] tarefasExcluidas = new string[] { "T1", "T2" }; Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>(); tarefasImpactadas.Add("T3", 1); tarefasImpactadas.Add("T4", 2); client.RnComunicarFimExclusaoTarefaConcluida(tarefasExcluidas, tarefasImpactadas, new string[] { }, DateUtil.CurrentDateTime); string msgJson = TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor); msgJson = TcpUtil.RemoverStringProtecaoDeIntegridade(msgJson); MensagemDto mensagemRecebida = Mensagem.DeserializarMensagemDto(msgJson); Assert.AreEqual(CsTipoMensagem.ExclusaoTarefaFinalizada, mensagemRecebida.Tipo, string.Format("A mensagem deveria ser do tipo {0}", CsTipoMensagem.ExclusaoTarefaFinalizada)); Assert.AreEqual("C1", (string)mensagemRecebida.Propriedades[Constantes.OIDCRONOGRAMA], "O cronograma da mensagem deveria ser C1"); Assert.AreEqual("Joao", (string)mensagemRecebida.Propriedades[Constantes.AUTOR_ACAO], "O login do colaborador que comunicou a exclusão da mensagem deveria ser Joao"); CollectionAssert.AreEquivalent(tarefasImpactadas, (Dictionary <string, Int16>)mensagemRecebida.Propriedades[Constantes.TAREFAS_IMPACTADAS], "Deveria possuir as " + "mesmas tarefas na ordem indicada da reordenação"); CollectionAssert.AreEquivalent(new string[] { }, (string[])mensagemRecebida.Propriedades[Constantes.TAREFAS_NAO_EXCLUIDAS]); }
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 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 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 EnviarEReceberApenasUmaMensagemDeTextoTest() { IPAddress ipServidor = IPAddress.Parse("127.0.0.1"); const int portaServidor = 8050; TcpListener servidor = new TcpListener(ipServidor, portaServidor); servidor.Start(); string m1 = "Este texto deve chegar ao destino completamente intacto"; TcpClient tcp = new TcpClient(); tcp.Connect(ipServidor, portaServidor); TcpClient tcpServidor = servidor.AcceptTcpClient(); TcpUtil.EnviarMensagemTcp(m1, tcp); string m1Result = TcpUtil.ReceberMensagemTcp(tcpServidor); Assert.AreEqual(m1, m1Result, "A mensagem retornada deveria estar intacta portanto igual a de origem"); servidor.Stop(); tcp.Close(); }
public void EnviarEReceberUmaMensagemDtoTest() { IPAddress ipServidor = IPAddress.Parse("127.0.0.1"); const int portaServidor = 8051; TcpListener servidor = new TcpListener(ipServidor, portaServidor); servidor.Start(); MensagemDto mensagemDto = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { "Joao" }, "C1"); string m1 = JsonConvert.SerializeObject(mensagemDto); TcpClient tcp = new TcpClient(); tcp.Connect(ipServidor, portaServidor); TcpClient tcpServidor = servidor.AcceptTcpClient(); TcpUtil.EnviarMensagemTcp(m1, tcp); string m1Result = TcpUtil.ReceberMensagemTcp(tcpServidor); Assert.AreEqual(m1, m1Result, "A mensagem retornada deveria estar intacta portanto igual a de origem"); servidor.Stop(); tcp.Close(); }
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(); }