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