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 RemoverProtecaoIntegridadeMensagemTest()
{
string mensagem = "uma mensagem \n de texto \n qualquer \n";
string mensagemConvertida = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagem);
string mensagemDesconvertida = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemConvertida);
Assert.AreEqual(mensagem, mensagemDesconvertida, "A mensagem de entrada deveria ser a mesma de saída");
}
public void AdicionarProtecaoIntegridadeMensagemTest()
{
const string mensagem = "uma mensagem \n de texto \n qualquer \n";
string mensagemConvertida = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagem);
Assert.AreEqual("uma mensagem *EnT3R* de texto *EnT3R* qualquer *EnT3R*\n", mensagemConvertida, "A mensagem de entrada deveria ter acrescentado as tags especiais que representam o /n");
string mensagemDesconvertida = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemConvertida);
Assert.AreEqual(mensagem, mensagemDesconvertida, "A mensagem de entrada deveria ser a mesma de saída");
}
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]);
}
/// <summary>
/// Responsável por fazer a escuta em tempo real da threadComunicaoServidor
/// </summary>
protected virtual void RnProcessarEventos()
{
String mensagemJson = "";
MensagemDto m;
List <string> mensagens;
string msgAtual = "";
try
{
while (autenticado)
{
if (tcpAdapter == null || !tcpAdapter.ValidarConexao())
{
ProcessarMensagemEvento(Mensagem.RnCriarMensagemServidorDesconectando("Você acabou se ser desconectado, verifique sua rede ou contate o administrador"));
continue;
}
if (!autenticado)
{
continue;
}
if (!tcpAdapter.PossuiDadosParaLeitura())
{
Thread.Sleep(15);
continue;
}
mensagemJson = tcpAdapter.EfetuarLeitura();
if (mensagemJson.Trim() == "")
{
continue;
}
if (mensagemJson.Contains("\n"))
{
mensagens = mensagemJson.Split('\n').ToList();
foreach (string msg in mensagens)
{
if (String.IsNullOrEmpty(msg))
{
continue;
}
msgAtual = msg.Trim();
if (Buffer != "")
{
msgAtual = Buffer + msgAtual;
Buffer = "";
}
m = Mensagem.DeserializarMensagemDto(TcpUtil.RemoverStringProtecaoDeIntegridade(msgAtual));
ProcessarMensagemEvento(m);
msgAtual = "";
}
}
else
{
Buffer += mensagemJson;
}
Thread.Sleep(10);
}
}
catch (JsonException excessao)
{
Debug.WriteLine(string.Format("MultiAccessClient do {3} (Leitura) - Mensagem Json:{2}Excessão:{0}\nCallStack{1}", excessao.Message, excessao.StackTrace, msgAtual, Login), "JsonConvert:");
//continue;
throw excessao;
}
catch (InvalidOperationException e)
{
Debug.WriteLine(string.Format("Ocorreu a excessão:{0}\nLocal:{1}", e.Message, e.StackTrace), Thread.CurrentThread.Name);
ProcessarMensagemEvento(Mensagem.RnCriarMensagemServidorDesconectando(String.Format("{0}\n {1}", e.Message, e.StackTrace)));
RnDesconectar();
throw e;
}
catch (Exception e)
{
DumperExtension.ShowStackTrace("Exception no client.");
Debug.WriteLine(string.Format("Ocorreu a excessão:{0}\nLocal:{1}\n Target Site:{2}", e.Message, e.StackTrace, e.TargetSite), Thread.CurrentThread.Name);
RnDesconectar();
throw e;
}
}