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 EntaoOServidorNaoDeveraTerEmSuaListaDeColaboradoresOnlineNoCronogramaOSColaboradorEs(string cronograma, string login)
{
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
ControleDeEsperaUtil.AguardarAte(() => { return(!manager.ColaboradorConectado(login, oidCronograma)); });
Assert.IsFalse(manager.ColaboradorConectado(login, oidCronograma), "Deveria encontrar o colaborador João no dicionário de usuários conectados");
}
public void EntaoOServidorDeveSerComunicadoQueQueOSColaboradorEsJoaoEstaOConectadoSAoCronograma01(string login, string cronograma)
{
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
ControleDeEsperaUtil.AguardarAte(() => { return(manager.ColaboradorConectado(login, oidCronograma)); });
Assert.IsTrue(manager.ColaboradorConectado(login, oidCronograma), "Deveria encontrar o colaborador João no dicionário de usuários conectados");
}
public void EntaoOServidorDeveraReceberASolicitacaoParaExcluirASTarefaSNoCronograma(string tarefasString, string naoUsada, string cronograma)
{
List <string> tarefasEsperadas = tarefasString.Replace("\'", "").Split(',').Select(o => o.Trim()).ToList();
List <string> oidTarefas;
Dictionary <string, string> TarefasDic = new Dictionary <string, string>();
Dictionary <string, bool> exclusoesSolicitadas = new Dictionary <string, bool>();
string oidTarefa;
foreach (string tarefa in tarefasEsperadas)
{
oidTarefa = StepCronograma.CronogramaTarefasDic[cronograma][tarefa].Oid.ToString();
exclusoesSolicitadas.Add(oidTarefa, false);
TarefasDic.Add(oidTarefa, tarefa);
}
oidTarefas = exclusoesSolicitadas.Select(o => o.Key).ToList();
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
ControleDeEsperaUtil.AguardarAte(() =>
{
return(manager.SolicitacoesExclusao.ContainsKey(oidCronograma) && manager.SolicitacoesExclusao[oidCronograma].Count == tarefasEsperadas.Count);
});
foreach (string oid in oidTarefas)
{
ControleDeEsperaUtil.AguardarAte(() =>
{
return(manager.SolicitacoesExclusao[oidCronograma].Contains(oid));
});
Assert.IsTrue(manager.SolicitacoesExclusao[oidCronograma].Contains(oid), string.Format("O cronograma {0} deveria ter recebido a solicitação da exclusão da tarefa {1}", cronograma, TarefasDic[oid]));
}
}
public void EntaoOServidorDeveSerComunicadoQueATarefaDoCronogramaEstaSendoEditadaPeloColaborador(string tarefa, string cronograma, string login)
{
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
string oidTarefa = StepCronograma.CronogramaTarefasDic[cronograma][tarefa].Oid.ToString();
List <MensagemDto> mensagens = null;
MensagemDto mensagemFiltrada = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagens = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas);
mensagemFiltrada = mensagens.FirstOrDefault
(o =>
o.Tipo == CsTipoMensagem.InicioEdicaoTarefa &&
o.Propriedades[Constantes.AUTOR_ACAO].ToString() == login &&
o.Propriedades[Constantes.OIDTAREFA].ToString() == oidTarefa
);
return(mensagemFiltrada != null);
});
Assert.IsNotNull(mensagemFiltrada, "Não deveria ter sido nula, colaborador deveria ter recebido a mensagem pesquisada");
Assert.AreEqual(login, mensagemFiltrada.Propriedades[Constantes.AUTOR_ACAO].ToString(), string.Format("O colaborador autor da mensagem deveria ser {0}", login));
Assert.AreEqual(oidTarefa, mensagemFiltrada.Propriedades[Constantes.OIDTAREFA].ToString(), string.Format("O Oid da tarefa editada deveria ser {0}", oidTarefa));
Assert.AreEqual(oidCronograma, mensagemFiltrada.Propriedades[Constantes.OIDCRONOGRAMA].ToString(),
string.Format("O Oid do Cronograma atual deveria ser {0}", oidCronograma));
}
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 GetConfigColaboradoresQuandoVariosColaboradoresJaTiveramSuasCoresSelecionadas()
{
string cor1 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[0]);
string cor2 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[1]);
string cor3 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[2]);
string cor4 = ConverterCorToArgbString(ColaboradorConfigBo.Cores[0]);
string corSelecionda1 = ProjetoColaboradorConfig.RnEscolherCor(s1, colaborador1.Oid, projeto1.Oid);
SessionTest.DropIdentityMap();
string corSelecionda2 = ProjetoColaboradorConfig.RnEscolherCor(s2, colaborador2.Oid, projeto1.Oid);
SessionTest.DropIdentityMap();
string corSelecionda3 = ProjetoColaboradorConfig.RnEscolherCor(s3, colaborador3.Oid, projeto1.Oid);
SessionTest.DropIdentityMap();
string corSelecionda4 = ProjetoColaboradorConfig.RnEscolherCor(s4, colaborador4.Oid, projeto2.Oid);
List <ProjetoColaboradorConfig> configs = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
configs = new List <ProjetoColaboradorConfig>(ProjetoColaboradorConfig.GetConfigColaboradores(SessionTest, projeto1.Oid));
return(configs != null && configs.Count == 3);
});
//List<ProjetoColaboradorConfig> configs = ProjetoColaboradorConfig.GetConfigColaboradores( SessionTest, projeto1.Oid );
//Assert.AreEqual( 3, configs.Count, string.Format( "Deveria possuir 3 configs salvos para o {0}",projeto1.TxNome ) );
Assert.AreEqual(cor1, corSelecionda1, "Deveria ter encontrado a cor selecionada para o usuário");
Assert.AreEqual(cor2, corSelecionda2, "Deveria ter encontrado a cor selecionada para o usuário");
Assert.AreEqual(cor3, corSelecionda3, "Deveria ter encontrado a cor selecionada para o usuário");
Assert.AreEqual(cor4, corSelecionda4, "Deveria ter encontrado a cor selecionada para o usuário");
}
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 EntaoOServidorDeveSerComunicadoQueOColaboradorSeDesconectou(string login)
{
bool recebeu = false;
List <MensagemDto> mensagensFiltradas = null;
string[] usuarios = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagensFiltradas = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas).Where(o => o.Tipo.Equals(CsTipoMensagem.UsuarioDesconectado)).ToList();
if (mensagensFiltradas != null)
{
foreach (var item in mensagensFiltradas)
{
usuarios = (string[])item.Propriedades[Constantes.USUARIOS];
if (usuarios.Contains(login))
{
recebeu = true;
break;
}
}
}
return(recebeu);
}, 7);
Assert.IsTrue(recebeu, string.Format("O deveria possuir a mensagem de que {0} se desconectou", login));
}
public void EntaoOServidorDeveDetectarDeQueOSColaboradorEsForamDesconectadoS(string colaboradores, string naoUsado)
{
string[] logins = colaboradores.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray();
foreach (string colaborador in logins)
{
ControleDeEsperaUtil.AguardarAte(() => { return(!manager.ColaboradorConectado(colaborador)); }, 10);
Assert.IsFalse(manager.ColaboradorConectado(colaborador), "O Colaborador Não Deveria estar conectado ao manager");
}
}
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 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 EntaoOServidorDeveraComunicarOColaboradorQueNoCronogramaAsSeguintesTarefaSEstaoEmEdicao(string colaborador, string cronograma, Table table)
{
string oidTarefa;
string key;
IEnumerable <EdicaoTarefaHelper> edicoes = table.CreateSet <EdicaoTarefaHelper>();
foreach (var edicao in edicoes)
{
oidTarefa = StepCronograma.GetOidTarefaNoCronograma(cronograma, edicao.Tarefa);
key = StepContextUtil.CriarKeyTarefaJaEstavamEmEdicao(colaborador, oidTarefa, edicao.Autor);
ControleDeEsperaUtil.AguardarAte(() => { return(StepContextUtil.CenarioAtualContemAChave(key)); });
Assert.IsTrue(StepContextUtil.CenarioAtualContemAChave(key),
string.Format("{0} deveria ter sido avisado de que a tarefa {1} estava em edição pelo colaborador {2}" +
" no cronograma {3}", colaborador, edicao.Tarefa, edicao.Autor, cronograma));
}
}
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 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 EntaoOServidorNaoDeveComunicarAoSColaboradorEsDeQueASTarefaSRecebeuRamAtualizacaoOesNoCronograma(string colaboradores, string naoUsado, string tarefasOutroCronograma, string naoUsado2, string outroCronograma)
{
string[] logins = colaboradores.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray();
string[] tarefas = tarefasOutroCronograma.Replace("\'", "").Split(',').Select(o => o.Trim()).ToArray();
string oidTarefa;
string key;
for (int i = 0; i < logins.Length; i++)
{
for (int x = 0; x < tarefas.Length; x++)
{
oidTarefa = StepCronograma.GetOidTarefaNoCronograma(outroCronograma, tarefas[x]);
key = StepContextUtil.CriarKeyRecebeuAtualizacaoEdicaoTarefa(logins[i], oidTarefa);
ControleDeEsperaUtil.AguardarAte(() => { return(StepContextUtil.CenarioAtualContemAChave(key)); });
Assert.IsFalse(StepContextUtil.CenarioAtualContemAChave(key), string.Format("{0} não deveria ter sido comunicado da atualização da tarefa {1} que pertence outro cronograma '{2}'", logins[i], tarefas[x], outroCronograma));
}
}
}
public void QuandoOServidorReceberASolicitacaoDeAlteracaoDoNomeDoCronogramaPeloColaborador(string cronograma, string login)
{
List <MensagemDto> mensagens = null;
MensagemDto mensagemEsperada = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagens = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas);
mensagemEsperada = mensagens.FirstOrDefault(o => o.Propriedades.ContainsKey(Constantes.AUTOR_ACAO) && o.Propriedades[Constantes.AUTOR_ACAO].ToString() == login && o.Tipo == CsTipoMensagem.InicioEdicaoNomeCronograma);
return(mensagemEsperada != null);
});
Assert.IsNotNull(mensagemEsperada, string.Format("Deveria ter recebido a mensagem enviada pelo colaborador {0}", login));
Assert.AreEqual(1, manager.CronogramasNomeEmEdicao.Count, "Deveria possuir 1 cronograma com nome em edição");
string oidCronograma = mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA] as string;
Assert.IsNotNull(oidCronograma, "Deveria ter recebido o oid do cronograma que possui o nome a ser alterado");
}
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();
}
public void DadoQueOServidorContenhaOSColaboradorEsConectadoSNoCronograma(string colaboradores, string naoUsado, string cronograma)
{
string[] cols = colaboradores.Split(',');
WexMultiAccessClientMock cliente;
string login;
foreach (string colaborador in cols)
{
login = colaborador.Replace("\'", "");
login = login.Trim();
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
cliente = CriarMultiAccessClient(login, oidCronograma);
cliente.Conectar();
ControleDeEsperaUtil.AguardarAte(() =>
{
return(manager.ColaboradorConectado(login, oidCronograma));
});
StepContextUtil.SalvarAccessClientNoContextoDoCenario(cliente);
}
}
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();
}
public void EntaoOCronogramaNaoDeveComunicarAoSColaboradorEsDeQueEstaOSendoExcluidaSTarefaSNoCronograma(string cronograma, string colaboradoresString, string naoUsada1, string outroCronograma)
{
List <string> colaboradores = colaboradoresString.Replace("\'", "").Split(',').Select(o => o.Trim()).ToList();
Dictionary <string, bool> colaboradoresAvisados = new Dictionary <string, bool>();
//Montando Dicionário em que nenhum colaborador foi avisado sobre a exclusão
foreach (string colaboradorAtual in colaboradores)
{
colaboradoresAvisados.Add(colaboradorAtual, false);
}
WexMultiAccessClientMock clientAtual;
string oidCronograma = StepCronograma.GetOidCronograma(cronograma);
string oidOutroCronograma = StepCronograma.GetOidCronograma(outroCronograma);
bool foiComunicado;
List <MensagemDto> mensagens = null;
MensagemDto mensagem;
foreach (var colaboradorAtual in colaboradores)
{
foiComunicado = false;
clientAtual = StepContextUtil.GetAccessClientNoContexto(colaboradorAtual, oidCronograma);
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagens = new List <MensagemDto>(clientAtual.MensagensRecebidas);
mensagem = mensagens.FirstOrDefault(
o => o.Tipo == CsTipoMensagem.ExclusaoTarefaFinalizada &&
!o.Propriedades[Constantes.OIDCRONOGRAMA].ToString().Equals(oidOutroCronograma)
);
if (mensagem != null)
{
foiComunicado = true;
}
return(foiComunicado);
});
Assert.IsFalse(foiComunicado, string.Format("{0} não deveria ser comunicado de que houve exclusão em um cronograma diferente ('{1}')", colaboradorAtual, outroCronograma));
}
}
public void DesconectarConexaoClienteTest()
{
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int porta = 8003;
TcpListener servidor = new TcpListener(ipServidor, porta);
servidor.Start();
TcpClient tcpCliente = new TcpClient();
tcpCliente.Connect(ipServidor, porta);
servidor.AcceptTcpClient();
Queue <MensagemDto> fila = new Queue <MensagemDto>();
const string login = "******";
ConexaoCliente conexao = new ConexaoCliente(login, tcpCliente, fila);
conexao.Desconectar();
ControleDeEsperaUtil.AguardarAte(() => { return(!conexao.threadProcessarLeitura.IsAlive); });
//TODO: @wex developer rever permissão cliente.
Assert.IsFalse(conexao.PermissaoDeEscrita, "Deveria ter a permissão de processamento de escrita desativada");
Assert.IsFalse(conexao.PermissaoDeLeitura, "Deveria ter a permissão de processamento de leitura desativada");
Assert.IsFalse(conexao.threadProcessarLeitura.IsAlive, "Sem a permissão a thread de processamento de leitura deveria ter encerrado");
}
public void ConsultarSemaforosImpactadosPorCronogramaQuandoExistiremVariosConflitantesTest()
{
#region contexto
//semáforo já existente
SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20);
//semáforo já existente no cronograma
SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);
//mockando o método que realiza a liberação de um semáforo.
Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
{
CallBase = true
};
SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);
SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);
cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 5,
final = 8,
tempoDeEspera = 0
};
cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 1,
final = 5,
tempoDeEspera = 6000
};
cronogramaIntervalo cronoIntervalo3 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 6,
final = 10,
tempoDeEspera = 8000
};
cronogramaIntervalo cronoIntervalo4 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 2,
final = 5,
tempoDeEspera = 1000
};
cronogramaIntervalo cronoIntervalo5 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 2,
final = 4,
tempoDeEspera = 2000
};
cronogramaIntervalo cronoIntervalo6 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 1,
final = 6,
tempoDeEspera = 3000
};
Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Highest,
Name = "Thread 1",
};
Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 2"
};
Thread thread3 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 3"
};
Thread thread4 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 4"
};
Thread thread5 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 5"
};
Thread thread6 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 6"
};
#endregion
thread1.Start(cronoIntervalo1);
thread2.Start(cronoIntervalo2);
thread3.Start(cronoIntervalo3);
thread4.Start(cronoIntervalo4);
thread5.Start(cronoIntervalo5);
thread6.Start(cronoIntervalo6);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
thread2.ThreadState == System.Threading.ThreadState.Stopped &&
thread3.ThreadState == System.Threading.ThreadState.Stopped &&
thread4.ThreadState == System.Threading.ThreadState.Stopped &&
thread5.ThreadState == System.Threading.ThreadState.Stopped &&
thread6.ThreadState == System.Threading.ThreadState.Stopped);
}, 180);
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo.");
Assert.AreEqual(5, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados.");
}
public void ConsultarSemaforosImpactadosPorCronogramaQuandoIntervaloAbrangerOutrosIntervalosTest()
{
//semáforo já existente
SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20);
//semáforo já existente no cronograma
SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);
//mockando o método que realiza a liberação de um semáforo.
Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
{
CallBase = true
};
SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);
SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);
cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 5,
final = 15,
tempoDeEspera = 0
};
cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 8,
final = 22,
tempoDeEspera = 5000
};
Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Highest,
Name = "Thread 1",
};
Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 2"
};
thread1.Start(cronoIntervalo1);
thread2.Start(cronoIntervalo2);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
thread2.ThreadState == System.Threading.ThreadState.Stopped);
}, 60);
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo.");
Assert.AreEqual(3, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados.");
List <SemaforoPorIntervalo> semaforosCriados = SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos;
Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == semaforoIntervalo1.inicio && o.final == semaforoIntervalo1.final), "Deveria existir o semáforo, pois já estava criado.");
Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 5 && o.final == 9), "Deveria existir o semáforo, pois a thread 1 criou.");
Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 21 && o.final == 22), "Deveria existir o semáforo, pois a thread 2 criou.");
}
public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasIguaisAcessaremSimultaneamenteEUmaEstiverEscrevendoNaListaEUmaEsperandoNaEscritaParaAdicionarOMesmoCronogramaTest()
{
//mockando o método que realiza a liberação de um semáforo.
Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
{
CallBase = true
};
mockSemaforo.Setup(o => o.EsperarLeituraCronogramas());
mockSemaforo.Setup(o => o.LiberarLeituraCronogramas());
SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);
SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 1,
final = 10,
tempoDeEspera = 0
};
cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 11,
final = 15,
tempoDeEspera = 500
};
Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
{
Priority = ThreadPriority.Highest,
Name = "Thread 1",
};
Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
{
Priority = ThreadPriority.Normal,
Name = "Thread 2"
};
thread1.Start(cronoIntervalo1);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Running);
});
thread2.Start(cronoIntervalo2);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
thread2.ThreadState == System.Threading.ThreadState.Stopped);
}, 15);
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método.");
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread 2 deveria estar em estado de finalizada, pois a thread 2 esperou a thread 1 e depois finalizou seu processamento.");
Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista, pois a thread 1 já adicionou-o.");
}
public void ConsultarSemaforosImpactadosPorCronogramaQuandoThreadsAcessaremSimultanementeDeCronogramasDiferentesTest()
{
SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(80, 100);
SemaforoPorIntervalo semaforoIntervalo2 = new SemaforoPorIntervalo(80, 100);
SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
SemaforoSingleton.SemaforosControle semaforoPorCronogramaC2 = new SemaforoSingleton.SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);
semaforoPorCronogramaC2.semaforos.Add(semaforoIntervalo2);
//mockando o método que realiza a liberação de um semáforo.
Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
{
CallBase = true
};
mockSemaforo.Setup(o => o.LiberarEscritaSemaforos(It.IsAny <Guid>()));
SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);
SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[1].Oid, semaforoPorCronogramaC2);
SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);
cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 5,
final = 10,
tempoDeEspera = 0
};
cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[1].Oid,
inicio = 8,
final = 15,
tempoDeEspera = 0
};
Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Highest,
Name = "Thread 1",
};
Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
{
Priority = ThreadPriority.Normal,
Name = "Thread 2"
};
thread1.Start(cronoIntervalo1);
thread2.Start(cronoIntervalo2);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
thread2.ThreadState == System.Threading.ThreadState.Stopped);
}, 60);
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir dois índices no dicionário de cronograma, pois 2 threads de cronogramas diferentes efetuaram o processo.");
Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados.");
Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[1].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados.");
}
public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasDiferentesAcessaremSimultaneamenteUmaEstiverEscrevendoNaListaEUmaEsperandoParaEscreverNaListaTest()
{
//mockando o método que realiza a liberação de um semáforo.
Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
{
CallBase = true
};
mockSemaforo.Setup(o => o.EsperarLeituraCronogramas());
mockSemaforo.Setup(o => o.LiberarLeituraCronogramas());
mockSemaforo.Setup(o => o.LiberarEscritaCronogramas());
SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);
SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[0].Oid,
inicio = 1,
final = 10,
tempoDeEspera = 0
};
cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
{
oidCronograma = cronogramas[1].Oid,
inicio = 11,
final = 15,
tempoDeEspera = 1000
};
Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
{
Priority = ThreadPriority.Highest,
Name = "Thread 1",
};
Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
{
Priority = ThreadPriority.Normal,
Name = "Thread 2"
};
thread1.Start(cronoIntervalo1);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Running);
});
thread2.Start(cronoIntervalo2);
ControleDeEsperaUtil.AguardarAte(() =>
{
return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
thread2.ThreadState == System.Threading.ThreadState.WaitSleepJoin &&
SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount == 1);
}, 100);
Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método.");
Assert.AreEqual(System.Threading.ThreadState.WaitSleepJoin, thread2.ThreadState, "A thread 2 deveria estar em estado de espera, pois a thread 1 ainda está realizando o processamento e a thread 2 não pode impactar a thread 2.");
Assert.AreEqual(1, SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount, "Deveria ter 1 thread em espera de escrita, pois a thread 1 está realizando a escrita.");
Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista.");
Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock[cronogramas[0].Oid].semaforos.Count, "Deveria ter criado um semáforo.");
}
