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 setUpTestData(cls):
super(ViewCancelarDesafioLadderTestCase, cls).setUpTestData()
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets') # Admin, com desafios
cls.saraiva = Jogador.objects.get(nick='saraiva') # Admin, sem desafios
cls.sena = Jogador.objects.get(nick='sena') # Não-admin, com desafios
cls.mad = Jogador.objects.get(nick='mad') # Não-admin, sem desafios
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
horario_atual = timezone.localtime()
data_atual = horario_atual.date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
horario_historico = horario_atual.replace(year=cls.ano, month=cls.mes)
cls.desafio_ladder = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(day=10), False, cls.sena)
cls.desafio_ladder_volta = criar_desafio_ladder_simples_teste(cls.teets, cls.sena, 3, 1,
horario_atual.replace(day=20), False, cls.sena)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_historico, False, cls.sena)
def setUpTestData(cls):
super(JogadorTestCase, cls).setUpTestData()
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets')
cls.sena = Jogador.objects.get(nick='sena')
cls.saraiva = Jogador.objects.get(nick='saraiva')
cls.tiovsky = Jogador.objects.get(nick='tiovsky')
# Personagens
criar_personagens_teste()
# Stage
cls.stage = criar_stage_teste()
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
cls.horario_mes = timezone.localtime().replace(day=15)
cls.horario_atual = cls.horario_mes + datetime.timedelta(minutes=1)
cls.mes, cls.ano = mes_ano_ant(cls.horario_mes.month,
cls.horario_mes.year)
cls.horario_historico = cls.horario_mes.replace(year=cls.ano,
month=cls.mes)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Adicionar desafios
cls.desafio_ladder = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_mes, False, cls.teets)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 1, 3, cls.horario_historico, False, cls.teets)
def setUpTestData(cls):
super(ViewListarDesafiosJogadorTestCase, cls).setUpTestData()
cls.user = User.objects.create_user('teste', '*****@*****.**', 'teste')
criar_jogadores_teste(['sena', 'teets', 'mad'])
cls.jogador_sem_desafios = Jogador.objects.get(nick='sena')
cls.jogador_com_desafios = Jogador.objects.get(nick='teets')
terceiro = Jogador.objects.get(nick='mad')
# Gerar desafios
for indice in range(7):
criar_desafio_ladder_simples_teste(terceiro, cls.jogador_com_desafios, 1, 3,
timezone.now() - datetime.timedelta(days=5*indice), False, cls.jogador_com_desafios)
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 setUpTestData(cls):
super(ViewListarDesafiaveisTestCase, cls).setUpTestData()
criar_jogadores_teste()
criar_ladder_teste()
cls.tiovsky = Jogador.objects.get(nick='tiovsky') # Posição 10
cls.rata = Jogador.objects.get(nick='rata') # Posição 9
cls.phils = Jogador.objects.get(nick='phils') # Posição 8
cls.dan = Jogador.objects.get(nick='dan') # Posição 7
cls.mad = Jogador.objects.get(nick='mad') # Posição 4
cls.desafio_pendente_vitoria = criar_desafio_ladder_simples_teste(cls.rata, cls.dan, 3, 0, timezone.localtime(), False,
cls.rata, 9, 7)
cls.desafio_pendente_derrota = criar_desafio_ladder_simples_teste(cls.tiovsky, cls.phils, 0, 3, timezone.localtime(), False,
cls.rata, 10, 8)
def setUpTestData(cls):
super(ViewRemoverJogadorLadderTestCase, cls).setUpTestData()
# Jogadores
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets') # Admin, com desafios
cls.saraiva = Jogador.objects.get(
nick='saraiva') # Admin, sem desafios
cls.sena = Jogador.objects.get(nick='sena') # Não-admin, com desafios
cls.mad = Jogador.objects.get(nick='mad') # Não-admin, sem desafios
cls.tiovsky = Jogador.objects.get(
nick='tiovsky') # Não-admin, sem desafios
# Personagens
criar_personagens_teste()
cls.fox = Personagem.objects.get(nome='Fox')
cls.marth = Personagem.objects.get(nome='Marth')
# Stage
cls.stage = criar_stage_teste()
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
cls.horario_atual = timezone.localtime()
cls.mes, cls.ano = mes_ano_ant(cls.horario_atual.month,
cls.horario_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
cls.horario_historico = cls.horario_atual.replace(year=cls.ano,
month=cls.mes)
cls.desafio_ladder = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_atual.replace(day=15),
False, cls.teets)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_historico.replace(day=15),
False, cls.sena)
def setUpTestData(cls):
super(ViewValidarDesafioLadderTestCase, cls).setUpTestData()
# Jogadores
criar_jogadores_teste()
# Personagens e estágios
criar_personagens_teste()
criar_stage_teste()
# Buscar jogadores a serem usados nos testes
cls.sena = Jogador.objects.get(nick='sena')
cls.teets = Jogador.objects.get(nick='teets')
cls.mad = Jogador.objects.get(nick='mad')
cls.saraiva = Jogador.objects.get(nick='saraiva')
cls.tiovsky = Jogador.objects.get(nick='tiovsky') # Último lugar da ladder
# Criar ladders
cls.ladder_atual = criar_ladder_teste()
# Preparar mês anterior para histórico
data_atual = timezone.now().date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
horario_atual = timezone.now().replace(day=15)
horario_historico = horario_atual.replace(year=cls.ano, month=cls.mes)
cls.desafio_ladder_simples = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(hour=6), False, cls.sena)
cls.desafio_ladder_simples_validado = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(hour=7), False, cls.sena)
cls.desafio_ladder_simples_historico = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_historico.replace(hour=6), False, cls.sena)
cls.desafio_ladder_coringa_derrota = criar_desafio_ladder_simples_teste(cls.mad, cls.teets, 2, 3,
horario_atual.replace(hour=10), True, cls.mad)
cls.desafio_ladder_coringa_vitoria = criar_desafio_ladder_simples_teste(cls.mad, cls.teets, 3, 1,
horario_atual.replace(hour=11), True, cls.mad)
# Adicionar novo entrante na ladder
cls.new = criar_jogador_teste('new')
cls.desafio_ladder_novo_entrante = criar_desafio_ladder_simples_teste(cls.new, cls.tiovsky, 3, 1,
horario_atual.replace(hour=8), False, cls.tiovsky)
# Adicionar segundo novo entrante na ladder
cls.new_2 = criar_jogador_teste('new2')
cls.desafio_ladder_novos_entrantes = criar_desafio_ladder_simples_teste(cls.new, cls.new_2, 3, 1,
horario_atual.replace(hour=9), False, cls.new_2)
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 setUpTestData(cls):
super(DesafioLadderLutaFormTestCase, cls).setUpTestData()
# Configurar jogador
criar_jogadores_teste()
cls.sena = Jogador.objects.get(user__username='******')
cls.teets = Jogador.objects.get(user__username='******')
# Stage
cls.stage = criar_stage_teste()
# Configurar stage como válida
StageValidaLadder.objects.create(stage=cls.stage)
# Personagens
criar_personagens_teste()
cls.marth = Personagem.objects.get(nome='Marth')
cls.fox = Personagem.objects.get(nome='Fox')
cls.horario_atual = timezone.localtime()
cls.desafio_ladder = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_atual, False, cls.sena)
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)