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();
}