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 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 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 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");
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoServidorDesconectar(WexMultiAccessClientMock cliente)
{
cliente.AoServidorDesconectar += (mensagem) =>
{
string key = StepContextUtil.CriarKeyEventoServidorDesconectado(cliente.Login, cliente.OidCronograma);
StepContextUtil.SalvarKey(key);
};
}
public void QuandoOCronogramaC1ForAbertoPeloColaboradorJoao(string cronograma, string login)
{
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
WexMultiAccessClientMock client = CriarMultiAccessClient(login, oidCronograma);
client.Conectar();
StepContextUtil.SalvarAccessClientNoContextoDoCenario(client);
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoSerCriadaNovaTarefa(WexMultiAccessClientMock cliente)
{
cliente.AoSerCriadaNovaTarefa += (mensagem) =>
{
string oidNovaTarefa = mensagem.Propriedades[Constantes.OIDTAREFA] as string;
string key = StepContextUtil.CriarKeyEventoAoSerCriadaNovaTarefa(cliente.Login, cliente.OidCronograma, oidNovaTarefa);
StepContextUtil.SalvarKey(key);
};
}
/// <summary>
/// Criar uma chave para identificação de uma conexão
/// </summary>
/// <param name="cliente"></param>
/// <returns></returns>
private string CriarChave(WexMultiAccessClientMock cliente)
{
if (cliente == null || string.IsNullOrWhiteSpace(cliente.Login) || string.IsNullOrEmpty(cliente.OidCronograma))
{
return(null);
}
return(string.Format("{0}_{1}", cliente.Login, cliente.OidCronograma));
}
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]);
}
/// <summary>
/// Remover um cliente do pool de conexões
/// </summary>
/// <param name="cliente">cliente a ser removido</param>
public void RemoverConexao(WexMultiAccessClientMock cliente)
{
lock (conexoes)
{
string key = CriarChave(cliente);
if (!string.IsNullOrEmpty(key) && conexoes.ContainsKey(key))
{
conexoes.Remove(key);
}
}
}
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();
}
/// <summary>
/// Método para simular uma mensagem do servidor direcionada para um cliente
/// </summary>
/// <param name="cliente">cliente que irá receber a mensagem</param>
/// <param name="mensagem">mensagem json a ser enviada</param>
public void EnviarMensagemPara(WexMultiAccessClientMock cliente, string mensagem)
{
lock (conexoes)
{
var stub = GetTcpAdapterStub(cliente);
if (stub != null)
{
stub.Mensagem += mensagem;
}
}
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoIniciarEdicaoTarefa(WexMultiAccessClientMock cliente)
{
cliente.AoIniciarEdicaoTarefa += (mensagem) =>
{
Dictionary <string, string> autoresAcao = mensagem.Propriedades[Constantes.AUTORES_ACAO] as Dictionary <string, string>;
string key;
foreach (var item in autoresAcao)
{
key = StepContextUtil.CriarKeyEventoAoIniciarEdicaoTarefa(cliente.Login, cliente.OidCronograma, item.Value);
StepContextUtil.SalvarKey(key);
}
};
}
/// <summary>
/// Efetuar o registro do cliente no pool
/// </summary>
/// <param name="cliente">cliente a ser adicionado no pool de conexões</param>
public void AceitarConexao(WexMultiAccessClientMock cliente)
{
lock (conexoes)
{
string key = CriarChave(cliente);
if (!string.IsNullOrEmpty(key) && !conexoes.ContainsKey(key))
{
conexoes.Add(key, cliente.TcpAdapter);
var stub = ConverterParaTcpAdapterStub(cliente.TcpAdapter);
stub.TcpPool = this;
}
}
}
/// <summary>
/// Retornar o TcpAdapterStub do cliente
/// </summary>
/// <param name="cliente"></param>
/// <returns></returns>
private TcpAdapterStub GetTcpAdapterStub(WexMultiAccessClientMock cliente)
{
lock (conexoes)
{
string key = CriarChave(cliente);
if (conexoes != null && conexoes.ContainsKey(key))
{
var stub = ConverterParaTcpAdapterStub(conexoes[key]);
return(stub);
}
}
return(null);
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoUsuarioDesconectar(WexMultiAccessClientMock cliente)
{
cliente.AoUsuarioDesconectar += (mensagem) =>
{
string[] usuarios = (string[])mensagem.Propriedades[Constantes.USUARIOS];
string key;
for (int i = 0; i < usuarios.Length; i++)
{
key = StepContextUtil.CriarKeyEventoUsuarioDesconectado(cliente.Login, cliente.OidCronograma, usuarios[i]);
ScenarioContext.Current.Set(true, key);
}
};
}
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 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();
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoFinalizadaEdicaoTarefa(WexMultiAccessClientMock cliente)
{
string key;
cliente.AoSerFinalizadaEdicaoTarefaPorOutroUsuario += (mensagem) =>
{
Dictionary <string, string> autoresAcao = mensagem.Propriedades[Constantes.AUTORES_ACAO] as Dictionary <string, string>;
foreach (var item in autoresAcao)
{
key = StepContextUtil.CriarKeyEventoFimEdicaoTarefa(cliente.Login, item.Key, item.Value);
StepContextUtil.SalvarKey(key);
key = StepContextUtil.CriarKeyRecebeuAtualizacaoEdicaoTarefa(cliente.Login, item.Key);
StepContextUtil.SalvarKey(key);
}
};
}
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 EntaoOServidorDeveraRecusarAEdicaoDoNomeDoCronogramaParaOColaborador(string cronograma, string login)
{
string oidCronograma = StepCronograma.GetOidCronograma(cronograma);
WexMultiAccessClientMock cliente = StepContextUtil.GetAccessClientNoContexto(login, oidCronograma);
List <MensagemDto> mensagens = null;
MensagemDto mensagem = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagens = new List <MensagemDto>(cliente.MensagensRecebidas);
mensagem = mensagens.FirstOrDefault(o => o.Propriedades[Constantes.OIDCRONOGRAMA].ToString() == oidCronograma && o.Tipo == CsTipoMensagem.EdicaoNomeCronogramaRecusada);
return(mensagem != null);
});
Assert.IsNotNull(mensagem, "Deveria ter recebido a mensagem do permissão de edição do nome do cronograma");
Assert.AreEqual(login, mensagem.Propriedades[Constantes.AUTOR_ACAO], string.Format("O proprietario da mensagem deveria ser o colaborador {0}", login));
}
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 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();
}
/// <summary>
/// Configurar comportamento relevante as expectativas do bbd
/// </summary>
/// <param name="cliente">wex client que recebera o comportamento do evento</param>
private static void ConfigurarEventoAoSerAutenticado(WexMultiAccessClientMock cliente)
{
cliente.AoSerAutenticadoComSucesso += (mensagem) =>
{
Debug.WriteLine(string.Format("AccessClient {0} - Usuarios Online:", cliente.Login));
string[] usuarios = (string[])mensagem.Propriedades[Constantes.USUARIOS];
Dictionary <string, string> EdicoesExistentes = mensagem.Propriedades[Constantes.EDICOES_CRONOGRAMA] as Dictionary <string, string>;
string key;
foreach (var item in EdicoesExistentes)
{
key = StepContextUtil.CriarKeyTarefaJaEstavamEmEdicao(cliente.Login, item.Key, item.Value);
StepContextUtil.SalvarKey(key);
}
foreach (var usuario in usuarios)
{
Debug.WriteLine(usuario);
}
};
}
/// <summary>
/// Instanciar e configurar um WexMultiAccessClient
/// </summary>
/// <param name="cronograma">nome do cronograma</param>
/// <param name="enderecoIp">Endereço ip do servidor</param>
/// <param name="porta">Porta do servidor</param>
/// <returns>Um MultiAccessClient configurado para o cenário</returns>
public WexMultiAccessClientMock CriarMultiAccessClient(string login, string oidCronograma)
{
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
Login = login,
OidCronograma = oidCronograma,
EnderecoIp = EnderecoIpServidor,
Porta = PortaTcp
};
ConfiguarEventosSemAcao(cliente);
ConfigurarEventoAoSerCriadaNovaTarefa(cliente);
ConfigurarEventoAoServidorDesconectar(cliente);
ConfigurarEventoAoSerAutenticado(cliente);
ConfigurarEventoAoUsuarioDesconectar(cliente);
ConfigurarEventoAoIniciarEdicaoTarefa(cliente);
ConfigurarEventoAoFinalizadaEdicaoTarefa(cliente);
ConexoesClient.Add(cliente);
return(cliente);
}
/// <summary>
/// Efetuar broadcast de uma mensagem para outros clientes
/// </summary>
/// <param name="mensagem">mensagem a ser comunicada aos outros clientes</param>
/// <param name="cliente">cliente que está enviando a mensagem</param>
public void EnviarMensagem(string mensagem, WexMultiAccessClientMock cliente)
{
lock (conexoes)
{
string key = CriarChave(cliente);
foreach (var conexao in conexoes)
{
if (conexao.Key.Equals(key))
{
continue;
}
if (!string.IsNullOrEmpty(mensagem))
{
TcpAdapterStub stub = conexao.Value as TcpAdapterStub;
stub.Mensagem += mensagem;
}
}
}
}
/// <summary>
/// Mockar os eventos em que o comportamentos de disparo são irrelevantes ao contexto do bdd
/// </summary>
/// <param name="cliente">wex client a ser mockado</param>
private static void ConfiguarEventosSemAcao(WexMultiAccessClientMock cliente)
{
//criado para mockar o disparo dos eventos de tela não realizando nenhuma ação
MensagemDtoEventHandler disparoEventoNaoPrecisaFazerNada = (mensagem) => { };
//empilhamento dos eventos
cliente.AoFalharConexaoNoServidor += (oidCronogramaAtual, loginAccessClient) => { };
cliente.AoConectarNovoUsuario += (mensagem, loginAccessClient) => { };
cliente.AoIniciarEdicaoDadosCronograma += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerRecusadaEdicaoDadosCronograma += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerPermitidaEdicaoDadosCronograma += disparoEventoNaoPrecisaFazerNada;
cliente.AoOcorrerMovimentacaoPosicaoTarefa += disparoEventoNaoPrecisaFazerNada;
cliente.AoServidorDesconectar += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerAutorizadaEdicaoTarefa += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerRecusadaEdicaoTarefa += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerExcluidaTarefaPorOutroUsuario += disparoEventoNaoPrecisaFazerNada;
cliente.ExecutarExclusaoTarefa += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerNotificadoAlteracaoDadosCronograma += disparoEventoNaoPrecisaFazerNada;
cliente.AoReceberConexaoRecusada += disparoEventoNaoPrecisaFazerNada;
cliente.AoSerDesconectado += () => { };
}
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();
}
