def setUp(self):
# Cadastra 2 problemas que serão utilizados nos testes
for i in xrange(1, 3):
#titulo = "Título do Problema {0}".format(i)
#descricao = "Descrição do Problema {0}".format(i)
#problema = Problema(titulo=titulo, descricao=descricao)
#problema.save()
novo_problema({})
self.client = Client()
def test_buscando_com_palavra_chave_repetida(self):
""" Ao buscar um problema utilizando uma palavra chave que exista
em mais de problema cadastrado deve exibir a lista de problemas encontrado """
problema1 = novo_problema({'titulo': 'Título de Problema Repetido'})
problema2 = novo_problema({'titulo': 'Outro Título Com Palavra Repetido'})
dados_busca = {'titulo': 'repetido'}
response = self.client.post(reverse('busca-problema-por-titulo'), dados_busca)
self.assertContains(response, problema1.titulo)
self.assertContains(response, problema2.titulo)
def test_nenhum_problema_utilizado(self):
"""
Se nenhum problema foi utilizado ainda, não deve exibir nenhuma
informação referente a problemas utilizados.
"""
problema1 = novo_problema({})
problema2 = novo_problema({})
client = Client()
response = client.get(reverse('inicio'))
self.assertNotContains(response, u"Os problemas deste site já foram utilizados")
def test_listagem_exibe_so_publicados(self):
"""
A listagem de problemas deve exibir somente os problemas publicados.
"""
problema1 = novo_problema({'publicado': False})
problema2 = novo_problema({'publicado': True})
response = self.client.get(reverse('todos-problemas'))
self.assertNotContains(response, problema1.titulo)
self.assertContains(response, problema2.titulo, 1)
def test_nao_deve_exibir_nao_publicado_como_aleatorio(self):
"""
Ao solicitar um problema aleatório não deve exibir os problemas não publicados
"""
Problema.objects.all().delete()
problema_publicado = novo_problema({'publicado': True})
problema_nao_publicado = novo_problema({'publicado': False})
response = self.client.get(reverse('problema-aleatorio'), follow=True)
titulo = "<title>DojoPuzzles.com - {0}</title>"
self.assertContains(response, titulo.format(problema_publicado.titulo), 1)
response = self.client.get(reverse('problema-aleatorio'), follow=True)
self.assertRedirects(response, reverse('sem-problemas-novos'))
def test_buscando_com_palavra_chave_unica(self):
""" Ao buscar um problema utilizando uma palavra chave que só exista
em um único problema cadastrado deve redirecionar diretamente para ele """
problema_unico = novo_problema({'titulo': u'Teste de Busca de Problema Único'})
dados_busca = {'titulo': 'Único'}
response = self.client.post(reverse('busca-problema-por-titulo'), dados_busca)
self.assertRedirects(response, reverse('exibe-problema', args=[problema_unico.slug]))
def test_somente_problemas_publicados_podem_ser_utilizados(self):
"""
Somente problemas publicados podem ser utilizados.
"""
problema = novo_problema({'publicado': False})
problema.utilizar()
self.assertRaises(Exception, problema.utilizar())
def test_nao_exibe_problema_nao_publicado(self):
"""
Um problema não publicado não pode ser exibido para o usuário
"""
problema = novo_problema({'publicado': False})
response = self.client.get(reverse('exibe-problema', args=[problema.slug]))
self.assertTemplateUsed(response, '404.html')
def test_buscando_problema_nao_publicado(self):
""" Ao buscar um problema utilizando uma palavra chave que só exista
em um único problema cadastrado mas não publicado deve informar que a busca
não retornou nenhum registro """
problema_nao_publicado = novo_problema({'titulo': u'Teste de Busca de Problema Não Publicado', 'publicado': False})
dados_busca = {'titulo': 'não publicado'}
response = self.client.post(reverse('busca-problema-por-titulo'), dados_busca)
self.assertContains(response, "Nenhum problema encontrado contendo 'não publicado' em seu título.")
def test_nao_exibe_solucao_se_nao_tiver_nenhuma(self):
"""
Ao exibir um problema, o botão que exibe as soluções que já estão cadastradas
não deve ser exibido, caso o problema não tenha nenhuma solução.
"""
problema = novo_problema({})
response = self.client.get(reverse('exibe-problema', args=[problema.slug]))
self.assertNotContains(response, 'id="botao_veja_solucoes"')
def test_utilizar_problema_aumenta_numero_utilizacoes(self):
"""
Se utilizarmos um problema, o contador de utilizações deve ser incrementado
"""
problema = novo_problema({})
self.assertEqual(problema.utilizacoes, 0)
problema.utilizar()
self.assertEqual(problema.utilizacoes, 1)
def teste_exibe_problemas_utilizados_em_ordem_decrescente(self):
"""
Os problemas utilizados devem ser exibidos em ordem decrescente de
utilizações.
"""
problema1 = novo_problema({})
problema2 = novo_problema({})
problema2.utilizar()
problema2.utilizar()
problema1.utilizar()
response = self.client.get(reverse('inicio'))
# Estou verificando desta maneira pois ainda não sei como testar o conteúdo do
# contexto de uma templatetag
# O título do problema2 (mais utilizado) deve aparecer antes do título do problema1 (menos utilizado)
self.assertTrue(response.content.find(problema2.titulo) < response.content.find(problema1.titulo))
def teste_existe_problema_utilizado(self):
"""
Se ao menos um problema tiver sido indicado como utilizado
deve exibir o bloca de problemas utilizados.
"""
problema = novo_problema({})
problema.utilizar()
response = self.client.get(reverse('inicio'))
self.assertContains(response, u'MAIS UTILIZADOS', 1)
def test_exibe_solucao_se_tiver_alguma(self):
"""
Ao exibir um problema, o botão que exibe as soluções que já estão cadastradas
não deve ser exibido, caso o problema não tenha nenhuma solução.
"""
problema = novo_problema({})
solucao = SolucaoProblema(problema=problema, solucao='http://teste.com/solucao')
solucao.save()
response = self.client.get(reverse('exibe-problema', args=[problema.slug]))
self.assertContains(response, 'id="botao_veja_solucoes"')
def teste_problemas_mais_recentes(self):
"""
Se dois problemas foram utilizados o mesmo número de vezes, o problema que foi utilizado mais
recentemente deve aparecer antes na listagem.
"""
problema1 = novo_problema({})
problema2 = novo_problema({})
problema2.utilizar()
problema1.utilizar()
problema2.utilizar()
problema2.utilizar()
problema1.utilizar()
problema1.utilizar()
response = self.client.get(reverse('inicio'))
# Como o problema1 foi utilizado pela última vez, ele deve aparecer antes do problema2
self.assertTrue(response.content.find(problema1.titulo) < response.content.find(problema2.titulo))
def test_exibe_numero_problemas_utilizados(self):
"""
Deve exibir na página inicial a quantidade de vezes que
algum problema foi utilizado em um Coding Dojo
"""
problema1 = novo_problema({})
problema2 = novo_problema({})
contador = 0
for utilizacao in range(1,11):
problema1.utilizar()
problema2.utilizar()
contador += 1
response = self.client.get(reverse('inicio'))
self.assertContains(response, u"Os problemas deste site já foram utilizados em 20 Coding Dojos!!!", 1)
problema2.utilizar()
response = self.client.get(reverse('inicio'))
self.assertContains(response, u"Os problemas deste site já foram utilizados em 21 Coding Dojos!!!", 1)
def teste_so_exibe_os_5_ultimos_mais_utilizados(self):
"""
Só devem ser exibidos os 5 últimos problemas mais utilizados.
"""
problema1 = novo_problema({})
problema2 = novo_problema({})
problema3 = novo_problema({})
problema4 = novo_problema({})
problema5 = novo_problema({})
problema6 = novo_problema({})
problema1.utilizar()
problema1.utilizar()
problema1.utilizar()
problema1.utilizar()
problema2.utilizar()
problema2.utilizar()
problema2.utilizar()
problema3.utilizar()
problema3.utilizar()
problema4.utilizar()
problema4.utilizar()
problema5.utilizar()
problema5.utilizar()
problema6.utilizar()
problema6.utilizar()
response = self.client.get(reverse('inicio'))
self.assertNotContains(response, problema6.titulo)
self.assertContains(response, problema1.titulo, 1)
self.assertContains(response, problema2.titulo, 1)
self.assertContains(response, problema3.titulo, 1)
self.assertContains(response, problema4.titulo, 1)
self.assertContains(response, problema5.titulo, 1)
def test_deve_exibir_o_problema_sendo_resolvido(self):
problema = novo_problema({})
url_gostei_e_vou_usar = reverse('problema-utilizado-em-dojo', args=[problema.id])
response = self.client.get(url_gostei_e_vou_usar, follow=True)
self.assertContains(response, 'Problema sendo resolvido')
def test_problema_sem_contribuidor_nao_exibe_nome(self):
""" Um problema onde o contribuidor não é indicado, não deve exibir o título 'Contribuição de:' """
problema = novo_problema({})
response = self.client.get(reverse('exibe-problema', args=[problema.slug]), follow=True)
self.assertNotContains(response, 'Contribuição de:')
def test_problema_com_contribuidor_exibe_nome(self):
""" Um problema onde o contribuidor é indicado, deve exibir o título 'Contribuição de: nome_contribuidor' """
problema = novo_problema({'nome_contribuidor': 'Eu Que Contribui'})
response = self.client.get(reverse('exibe-problema', args=[problema.slug]), follow=True)
self.assertContains(response, 'Contribuição de: Eu Que Contribui', 1)
def test_nenhum_problema_sendo_resolvido_nao_exibe_problema_sendo_resolvido(self):
problema = novo_problema({})
response = self.client.get(reverse('exibe-problema', args=[problema.slug]), follow=True)
self.assertNotContains(response, 'Problema sendo resolvido')
def setUp(self):
self.problema = novo_problema({})
self.client = Client()
def setUp(self):
# Cadastra 5 problemas que serão utilizados nos testes
for i in xrange(1,6):
novo_problema({})
self.client = Client()
