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)
