def test_validar_desafio_novo_entrante_com_saidas_e_entradas_jogadores(self): """Testa se valida desafio de novo entrante, com uma entrada e saídas desde último desafio de novo entrante""" horario_atual = timezone.localtime().replace(day=15) # Remover jogadores na ladder histórico remocao_1 = RemocaoJogador.objects.create(jogador=self.mad, data=horario_atual.replace(day=1), admin_removedor=self.teets, posicao_jogador=4, remocao_por_inatividade=True) remover_jogador(remocao_1) remocao_2 = RemocaoJogador.objects.create(jogador=self.saraiva, data=horario_atual.replace(day=2), admin_removedor=self.teets, posicao_jogador=2, remocao_por_inatividade=True) remover_jogador(remocao_2) remocao_3 = RemocaoJogador.objects.create(jogador=self.sena, data=horario_atual.replace(day=3), admin_removedor=self.teets, posicao_jogador=2, remocao_por_inatividade=True) remover_jogador(remocao_3) # Validar desafio de novo entrante novo_entrante_1 = criar_jogador_teste('new3') desafio_ladder_novo_entrante_1 = criar_desafio_ladder_simples_teste(novo_entrante_1, self.teets, 1, 3, horario_atual.replace(day=4, hour=10), True, self.tiovsky) validar_desafio_ladder_teste(desafio_ladder_novo_entrante_1, self.teets) # Adicionar outro novo entrante novo_entrante_2 = criar_jogador_teste('new4') desafio_ladder_novo_entrante_2 = criar_desafio_ladder_simples_teste(novo_entrante_2, self.teets, 1, 3, horario_atual.replace(day=4, hour=11), True, self.tiovsky) validar_desafio_ladder_teste(desafio_ladder_novo_entrante_2, self.teets) self.assertEqual(PosicaoLadder.objects.get(jogador=novo_entrante_2).posicao, 9)
def test_cancelar_desafio_validado_atual_sucesso(self): """Testa cancelar desafio de ladder atual validado com sucesso""" # Guardar ladder original pré-validação ladder_pre = list(PosicaoLadder.objects.all().order_by('posicao')) # Definir desafio como validado validar_desafio_ladder_teste(self.desafio_ladder, self.teets) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post(reverse('ladder:cancelar_desafio_ladder', kwargs={'desafio_id': self.desafio_ladder.id}), {'salvar': 1}) self.assertEqual(response.status_code, 302) url_esperada = reverse('ladder:detalhar_desafio_ladder', kwargs={'desafio_id': self.desafio_ladder.id}) self.assertRedirects(response, url_esperada) # Garantir que desafio de ladder está cancelado self.assertTrue(DesafioLadder.objects.filter(id=self.desafio_ladder.id, cancelamentodesafioladder__isnull=False).exists()) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) self.assertEqual(str(messages[0]), MENSAGEM_SUCESSO_CANCELAR_DESAFIO_LADDER) # Ladder deve voltar a posição original ladder_pos = list(PosicaoLadder.objects.all().order_by('posicao')) for posicao_pre, posicao_pos in zip(ladder_pre, ladder_pos): self.assertEqual(posicao_pre, posicao_pos)
def test_erro_cancelar_remocao_desafio_posterior_impossivel(self): """Testa cancelar remoção com desafio de jogador que se torna impossível""" # Gerar desafio entre o 2 + LIMITE_POSICOES_DESAFIO e o 2 jogador_limite = PosicaoLadder.objects.get( posicao=(2 + DesafioLadder.LIMITE_POSICOES_DESAFIO)).jogador desafio_ladder = criar_desafio_ladder_simples_teste( jogador_limite, self.saraiva, 1, 3, timezone.localtime(), False, self.saraiva) validar_desafio_ladder_teste(desafio_ladder, self.teets) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post( reverse('ladder:cancelar_remocao_jogador_ladder', kwargs={'remocao_id': self.remocao_admin.id}), {'salvar': 1}) self.assertEqual(response.status_code, 200) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) # self.assertEqual(str(messages[0]), f'Remoção não pode ser cancelada') regex = re.escape(f'Desafio Ladder {desafio_ladder.id}: ') + r'.+' self.assertRegex(str(messages[0]), regex) self.assertTrue( RemocaoJogador.objects.filter(id=self.remocao_admin.id).exists())
def test_erro_remover_permissao_com_desafio_cadastrado(self): """Testa erro ao tentar remover permissão que já possui desafio cadastrado""" # Gerar permissão para remoção permissao = PermissaoAumentoRange.objects.create( admin_permissor=self.admin, jogador=self.jogador_8, data_hora=timezone.localtime()) # Cadastrar desafio usando permissão desafio = DesafioLadder.objects.create(desafiante=self.jogador_8, desafiado=self.admin, data_hora=timezone.localtime(), score_desafiante=0, score_desafiado=3, desafio_coringa=False, adicionado_por=self.admin) validar_desafio_ladder_teste(desafio, self.admin) self.client.login(username=self.admin.user.username, password=SENHA_TESTE) response = self.client.post( reverse('ladder:remover_permissao_aumento_range', kwargs={'permissao_id': permissao.id}), {'permissao_id': permissao.id}) self.assertEqual(response.status_code, 200) messages = list(response.context['messages']) self.assertEqual(len(messages), 1) self.assertEqual( str(messages[0]), PermissaoAumentoRange.MENSAGEM_ERRO_DESAFIO_UTILIZANDO_PERMISSAO) # Verificar que não há mais permissões cadastradas self.assertEqual(PermissaoAumentoRange.objects.all().count(), 1)
def test_remover_jogador_ladder_atual_pre_desafios(self): """Testa erro ao remover um jogador da ladder, na data atual antes de um desafio""" # Validar desafio validar_desafio_ladder_teste(self.desafio_ladder, self.teets) ladder_antes = list(PosicaoLadder.objects.all().order_by('posicao')) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post( reverse('ladder:remover_jogador_ladder'), { 'jogador': self.sena.id, 'data': datetime.datetime.now().replace(day=10) }) self.assertEqual(response.status_code, 200) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) # Verificar que ladder se mantém e não foi criada remoção ladder_depois = list(PosicaoLadder.objects.all().order_by('posicao')) for posicao_antes, posicao_depois in zip(ladder_antes, ladder_depois): self.assertEqual(posicao_antes.posicao, posicao_depois.posicao) self.assertEqual(posicao_antes.jogador, posicao_depois.jogador) self.assertFalse( RemocaoJogador.objects.filter(jogador=self.sena).exists())
def test_mostrar_top_5_vitorias(self): """Testa se tela mostra corretamente top 5 vitórias de jogadores com o personagem""" validar_desafio_ladder_teste(self.desafio, self.jogador_2) response = self.client.get(reverse('personagens:detalhar_personagem_por_id', kwargs={'personagem_id': self.personagem.id})) self.assertTrue(hasattr(response.context['personagem'], 'top_5_ganhadores')) self.assertEqual(response.context['personagem'].top_5_ganhadores[0], {'jogador': self.jogador_1, 'qtd_vitorias': 100, 'qtd_lutas': 3})
def test_posicao_em_jogador_com_desafios_cancelados(self): """Testa se retorno desconsidera desafios cancelados""" # Validar desafio em que sena toma posição de teets validar_desafio_ladder_teste(self.desafio_ladder, self.teets) # Cancelar desafio CancelamentoDesafioLadder.objects.create( desafio_ladder=self.desafio_ladder, data_hora=self.horario_mes, jogador=self.teets) recalcular_ladder(self.desafio_ladder) self.assertEqual(self.teets.posicao_em(self.horario_atual), 1)
def test_nao_mostrar_permissoes_com_remocao_impossivel(self): """Testa se tela não mostra permissões cuja remoção não seja possível, por tempo decorrido ou já utilizada""" # Adicionar permissão com período inválido permissao_passada = PermissaoAumentoRange.objects.create(admin_permissor=self.admin, jogador=self.jogador_2, data_hora=timezone.localtime() \ - datetime.timedelta(hours=PermissaoAumentoRange.PERIODO_VALIDADE + 1)) # Adicionar permissão com desafio já cadastrado permissao_utilizada = PermissaoAumentoRange.objects.create( admin_permissor=self.admin, jogador=self.jogador_8, data_hora=timezone.localtime()) # Cadastrar desafio usando permissão desafio = DesafioLadder.objects.create(desafiante=self.jogador_8, desafiado=self.admin, data_hora=timezone.localtime(), score_desafiante=0, score_desafiado=3, desafio_coringa=False, adicionado_por=self.admin) validar_desafio_ladder_teste(desafio, self.admin) # Adicionar permissão válida permissao_valida = PermissaoAumentoRange.objects.create( admin_permissor=self.admin, jogador=self.jogador_2, data_hora=timezone.localtime()) self.client.login(username=self.admin.user.username, password=SENHA_TESTE) response = self.client.get( reverse('ladder:remover_permissao_aumento_range')) self.assertEqual(response.status_code, 200) # Verificar quais permissões estão sendo mostradas self.assertEqual(len(response.context['permissoes']), 1) self.assertEqual(response.context['permissoes'][0], permissao_valida) # Permitir remover apenas válida self.assertContains( response, reverse('ladder:remover_permissao_aumento_range', kwargs={'permissao_id': permissao_valida.id})) self.assertNotContains( response, reverse('ladder:remover_permissao_aumento_range', kwargs={'permissao_id': permissao_utilizada.id})) self.assertNotContains( response, reverse('ladder:remover_permissao_aumento_range', kwargs={'permissao_id': permissao_passada.id}))
def test_remover_jogador_ladder_antes_desafio_cancelado(self): """Testa remover jogador de ladder em data anterior a um desafio cancelado""" # Validar desafio validar_desafio_ladder_teste(self.desafio_ladder, self.teets) # Tornar desafio cancelado CancelamentoDesafioLadder.objects.create( desafio_ladder=self.desafio_ladder, data_hora=self.horario_atual, jogador=self.teets) recalcular_ladder(self.desafio_ladder) # Guardar ladder antes da operação ladder_antes = list(PosicaoLadder.objects.all().order_by('posicao')) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post( reverse('ladder:remover_jogador_ladder'), { 'jogador': self.sena.id, 'data': datetime.datetime.now().replace(day=10) }) self.assertEqual(response.status_code, 302) self.assertRedirects(response, reverse('ladder:detalhar_ladder_atual')) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) ladder_depois = list(PosicaoLadder.objects.all().order_by('posicao')) # Verifica se registro de remoção foi criado self.assertTrue( RemocaoJogador.objects.filter(jogador=self.sena).exists()) # Compara ladder self.assertEqual(len(ladder_antes) - 1, len(ladder_depois)) # Jogadores acima na ladder não são afetados for posicao_antes, posicao_depois in zip(ladder_antes[:2], ladder_depois[:2]): self.assertEqual(posicao_antes.posicao, posicao_depois.posicao) self.assertEqual(posicao_antes.jogador, posicao_depois.jogador) # Jogadores abaixo sobem uma posição for posicao_antes, posicao_depois in zip(ladder_antes[3:], ladder_depois[2:]): self.assertEqual(posicao_antes.posicao - 1, posicao_depois.posicao) self.assertEqual(posicao_antes.jogador, posicao_depois.jogador)
def test_erro_remover_jogador_com_desafio_no_mesmo_dia(self): """Testa erro ao remover jogador que tenha um desafio no mesmo dia""" # Gerar desafio e validar desafio_ladder = criar_desafio_ladder_simples_teste( self.sena, self.teets, 3, 1, self.horario_atual, False, self.teets) validar_desafio_ladder_teste(desafio_ladder, self.teets) form = RemocaoJogadorForm({ 'jogador': self.tiovsky.id, 'data': self.horario_atual, 'admin_removedor': self.teets.id }) self.assertFalse(form.is_valid()) self.assertIn('Jogador possui desafio na data apontada para remoção', form.errors['__all__'])
def test_cancelar_remocao_desafio_posterior_sucesso(self): """Testa cancelar remoção com desafio de jogador que continua sendo possível""" # Guardar ladder pré-cancelamento ladder_pre = list(PosicaoLadder.objects.all().order_by('posicao')) # Gerar desafio entre o 3 e o 2 desafio_ladder = criar_desafio_ladder_simples_teste( self.mad, self.saraiva, 1, 3, timezone.localtime(), False, self.mad) validar_desafio_ladder_teste(desafio_ladder, self.teets) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post( reverse('ladder:cancelar_remocao_jogador_ladder', kwargs={'remocao_id': self.remocao_admin.id}), {'salvar': 1}) self.assertEqual(response.status_code, 302) self.assertRedirects(response, reverse('ladder:listar_remocoes_jogador_ladder')) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) self.assertEqual(str(messages[0]), f'Remoção cancelada com sucesso') # Jogador deve voltar a ladder e alterar posições ladder_pos = list(PosicaoLadder.objects.all().order_by('posicao')) self.assertEqual(len(ladder_pre) + 1, len(ladder_pos)) # Do 1 ao 2, não há diferença for posicao_pre, posicao_pos in zip(ladder_pre[:2], ladder_pos[:2]): self.assertEqual(posicao_pre, posicao_pos) # O 3 é o jogador que retorna self.assertEqual(ladder_pos[2].jogador, self.sena) # Do 4 em diante for posicao_pre, posicao_pos in zip(ladder_pre[2:], ladder_pos[3:]): self.assertEqual(posicao_pre.jogador, posicao_pos.jogador) self.assertEqual(posicao_pre.posicao + 1, posicao_pos.posicao) # Desafio deve ser atualizado, agora é entre o 4 e o 2 desafio_ladder = DesafioLadder.objects.get(desafiante=self.mad) self.assertEqual(desafio_ladder.posicao_desafiante, 4)
def test_cancelar_desafio_validado_erro_ladder_inconsistente(self): """Testa cancelar desafio de ladder validado que gera inconsistência em desafio futuro""" # Definir desafio como validado validar_desafio_ladder_teste(self.desafio_ladder, self.teets) validar_desafio_ladder_teste(self.desafio_ladder_volta, self.teets) self.client.login(username=self.teets.user.username, password=SENHA_TESTE) response = self.client.post(reverse('ladder:cancelar_desafio_ladder', kwargs={'desafio_id': self.desafio_ladder.id}), {'salvar': 1}) self.assertEqual(response.status_code, 200) # Garantir que desafio de ladder não está cancelado self.assertTrue(DesafioLadder.objects.filter(id=self.desafio_ladder.id, cancelamentodesafioladder__isnull=True).exists()) # Verificar mensagens messages = list(get_messages(response.wsgi_request)) self.assertEqual(len(messages), 1) regex = re.escape(f'Desafio Ladder {self.desafio_ladder_volta.id}: ') + r'.+' self.assertRegex(str(messages[0]), regex)
def test_posicao_em_jogador_com_desafios_removido_ladder(self): """Testa se retorno é 0 devido a remoção da ladder""" # Validar desafio em que sena toma posição de teets validar_desafio_ladder_teste(self.desafio_ladder, self.teets) # Verificar que sena está em primeiro self.assertEqual( self.sena.posicao_em(self.horario_atual.replace(day=16)), 1) # Remover sena remover_jogador( RemocaoJogador.objects.create( jogador=self.sena, data=self.horario_mes.replace(day=16), admin_removedor=self.teets, posicao_jogador=self.sena.posicao_em( self.horario_mes.replace(day=16)))) self.assertFalse( PosicaoLadder.objects.filter(jogador=self.sena).exists()) self.assertEqual( self.sena.posicao_em(self.horario_atual.replace(day=16)), 0) self.assertEqual( self.teets.posicao_em(self.horario_atual.replace(day=16)), 1)
def testa_gerar_primeira_season(self): """Testa gerar primeira season""" criar_jogadores_teste() # Pegar objetos de jogador de acordo com sua posição jogador_pos_1 = Jogador.objects.get(nick='teets') jogador_pos_2 = Jogador.objects.get(nick='saraiva') jogador_pos_3 = Jogador.objects.get(nick='sena') jogador_pos_4 = Jogador.objects.get(nick='mad') jogador_pos_5 = Jogador.objects.get(nick='blöwer') jogador_pos_6 = Jogador.objects.get(nick='frodo') jogador_pos_7 = Jogador.objects.get(nick='dan') jogador_pos_8 = Jogador.objects.get(nick='phils') jogador_pos_9 = Jogador.objects.get(nick='rata') jogador_pos_10 = Jogador.objects.get(nick='tiovsky') criar_season_teste( data_inicio=timezone.localdate() - datetime.timedelta(days=30), data_fim=timezone.localdate() - datetime.timedelta(days=1)) criar_ladder_inicial_teste() criar_ladder_teste() horario_atual = timezone.localtime() ano, mes = mes_ano_ant(horario_atual.month, horario_atual.year) criar_ladder_historico_teste(ano, mes) # Criar desafios desafio_ladder = criar_desafio_ladder_simples_teste( jogador_pos_3, jogador_pos_1, 3, 1, horario_atual, False, jogador_pos_1) validar_desafio_ladder_teste(desafio_ladder, jogador_pos_1) criar_desafio_ladder_simples_teste(jogador_pos_4, jogador_pos_2, 3, 1, horario_atual, False, jogador_pos_1) # Pegar situação da ladder inicial antes ladder_inicial_antes = list( InicioLadder.objects.all().order_by('posicao').values_list( 'jogador', 'posicao')) # Pegar situação da ladder atual antes ladder_atual_antes = list( PosicaoLadder.objects.all().order_by('posicao').values_list( 'jogador', 'posicao')) guardar_dados_season_anterior() apagar_ladder_season_anterior() gerar_nova_season() self.assertFalse(HistoricoLadder.objects.exists()) self.assertEqual(DesafioLadder.objects.count(), 1) self.assertTrue( DesafioLadder.objects.filter(id=desafio_ladder.id).exists()) # Validar ladder inicial e atual ladder_inicial_apos = list( InicioLadder.objects.all().order_by('posicao').values_list( 'jogador', 'posicao')) ladder_atual_apos = list( PosicaoLadder.objects.all().order_by('posicao').values_list( 'jogador', 'posicao')) self.assertEqual(len(ladder_inicial_antes), len(ladder_inicial_apos)) for situacao_antes, situacao_apos in zip(ladder_inicial_antes, ladder_inicial_apos): self.assertNotEqual(situacao_antes, situacao_apos) self.assertEqual(len(ladder_atual_antes), len(ladder_atual_apos)) for situacao_antes, situacao_apos in zip(ladder_atual_antes, ladder_atual_apos): self.assertNotEqual(situacao_antes, situacao_apos)
def test_posicao_em_jogador_com_desafios_validados(self): """Testa se retorno é posição do jogador após o último desafio validado""" # Validar desafio em que sena toma posição de teets validar_desafio_ladder_teste(self.desafio_ladder, self.teets) self.assertEqual(self.sena.posicao_em(self.horario_atual), 1) self.assertEqual(self.teets.posicao_em(self.horario_atual), 2)
def test_posicao_em_jogador_afetado_desafios_terceiros(self): """Testa se retorno é 3 devido a desafio de terceiros""" # Validar desafio em que sena toma posição de teets validar_desafio_ladder_teste(self.desafio_ladder, self.teets) self.assertEqual(self.saraiva.posicao_em(self.horario_atual), 3)