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 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 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 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 RnProcessarEventosReceberMensagensComStringDeProtecao()
{
int contador = 0;
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
Porta = porta, EnderecoIp = ipServidor, Login = "******", OidCronograma = "C1", TcpAdapterStubAtivo = true
};
TcpAdapterPool pool = new TcpAdapterPool();
// mensagemDto que serão preenchidas no disparo dos eventos do client
MensagemDto mensagemAutenticacaoEsperada = new MensagemDto();
MensagemDto mensagemNovaTarefaCriadaEsperada = new MensagemDto();
MensagemDto mensagemInicioEdicaoTarefaCriada = new MensagemDto();
//eventos que deverão preencher as mensagensDto anteriores para comparação posterior
cliente.AoSerAutenticadoComSucesso += (mensagem) => { contador++; mensagemAutenticacaoEsperada = mensagem; };
cliente.AoSerCriadaNovaTarefa += (mensagem) => { contador++; mensagemNovaTarefaCriadaEsperada = mensagem; };
cliente.AoIniciarEdicaoTarefa += (mensagem) => { contador++; mensagemInicioEdicaoTarefaCriada = mensagem; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
cliente.Conectar();
pool.AceitarConexao(cliente);
//dicionário de tarefas impactadas
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T2", 1);
tarefasImpactadas.Add("T3", 2);
tarefasImpactadas.Add("T4", 3);
tarefasImpactadas.Add("T5", 4);
//mensagens que serão comunicadas ao client e deverão ser recebidas com sucesso no client
MensagemDto autenticacaoEnviada, novaTarefaCriadaEnviada, inicioEdicaoTarefaEnviada;
//criando mensagem de conexão aceita e retornando a mensagem ao client
autenticacaoEnviada = Mensagem.RnCriarMensagemConexaoEfetuadaComSucesso(new string[] { "Joao", "Pedro" }, "C1", null);
string json = JsonConvert.SerializeObject(autenticacaoEnviada);
json = TcpUtil.AdicionarStringProtecaoDeIntegridade(json);
//criando mensagem de inicio de edição de uma tarefa e comunicando ao client
inicioEdicaoTarefaEnviada = Mensagem.RnCriarMensagemInicioEdicaoTarefa("T1", "Joao", "C1");
string json2 = JsonConvert.SerializeObject(inicioEdicaoTarefaEnviada);
json2 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json2);
DateUtil.CurrentDateTime = DateTime.Now;
//criando mensagem de criação de uma nova tarefa
novaTarefaCriadaEnviada = Mensagem.RnCriarMensagemNovaTarefaCriada("T2", "Gabriel", "C2", tarefasImpactadas, DateUtil.CurrentDateTime);
string json3 = JsonConvert.SerializeObject(novaTarefaCriadaEnviada);
json3 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json3);
//unindo as mensagens em uma unica para testar o envio e o recebimento de mensagens coladas
json = json + json2 + json3;
pool.EnviarMensagemPara(cliente, json);
//aguardar até que os 3 eventos do client sejam disparados ao receber e tratar as mensagens enviadas
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 3); });
Assert.AreEqual(3, contador, "Deveria ter contado 3 pois foram é a quantidade de mensagens acumuladas no tcp");
//asserts para a mensagem de autenticação
Assert.AreEqual(mensagemAutenticacaoEsperada.Tipo, autenticacaoEnviada.Tipo, "A mensagem recebida de autenticação deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemAutenticacaoEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)autenticacaoEnviada.Propriedades["oidCronograma"], "Deveria possuir o mesmo" +
" cronograma nas mensagens de autenticação");
CollectionAssert.AreEquivalent((string[])mensagemAutenticacaoEsperada.Propriedades[Constantes.USUARIOS], (string[])autenticacaoEnviada.Propriedades[Constantes.USUARIOS], "Deveria possuir a mesma lista de usuários online");
//asserts para mensagem de criação de nova tarefa
Assert.AreEqual(mensagemNovaTarefaCriadaEsperada.Tipo, novaTarefaCriadaEnviada.Tipo, "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)novaTarefaCriadaEnviada.Propriedades[Constantes.OIDCRONOGRAMA], "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
CollectionAssert.AreEquivalent((Dictionary <string, Int16>)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS], (Dictionary <string, Int16>)novaTarefaCriadaEnviada.Propriedades[Constantes.TAREFAS_IMPACTADAS], "Deveria possuir as tarefas impactadas com a mesma ordenacao");
}
