associação pythonbrasil[11] django zope/plone planet Início Logado como (Entrar)

Diferenças para "DocTest"

Diferenças entre as versões de 5 e 6
⇤ ← Revisão 5e 2004-07-19 19:07:20 →
Tamanho: 2276
Editor: RudaMoura
Comentário:
← Revisão 6e 2004-07-19 19:15:37 → ⇥
Tamanho: 2526
Editor: RudaMoura
Comentário:
Deleções são marcadas assim. Adições são marcadas assim.
Linha 3: Linha 3:
Você que é bom programador e cuidadoso, aposto que procuras documentar
direito o código que escreves. A linguagem Python é bem amiga nesse aspecto,
com a utilização de DocStrings. Por exemplo:		 Um bom programador procura documentar direito o código que escreve.
A linguagem Python é bem amiga nesse aspecto com utilização de DocStrings.
Linha 7: Linha 6:
Por exemplo:
Linha 10: Linha 10:
  >>> f(0)
  1
  >>> f(5)
  120
  """
  if x == 0:
    return 1
  else:
    return x * f(x-1)
}}}
Linha 21: Linha 11:
é uma implementação bem documentada da função fatorial dentro de um hipotético
módulo {{{minhasfuncoes.py}}}.

Uma preocupação maior seria sempre assegurar que o que escrevemos
está correto, mesmo quando procuramos melhorar ou até mesmo reescrever
a implementação de uma função ou classe em Python. Mas como certificar
que não quebramos nada enquanto mudamos?

A resposta está nos testes automatizados.
Escolher bem o que testar e como testar é uma arte em si.
Repare nos exemplos que eu escrevi para
descrever a função fatorial, que tal eu usar esses exemplos
como teste?

Eu poderia escrever a uma função test() e assim escrever
novamente esses exemplos dentro desta função e conferir
se não tem nada errado com a entrada e a saída da função.

{{{#!python
def fat(n):
  """Calcula o fatorial de n.
  >>> f(0)
  1
  >>> f(5)
  120
  """
  if x == 0:
    return 1
  else:
    return x * f(x-1)

def test():
  assert f(0) == 1
  assert f(5) == 120

if __name__ == '__main__':
  test()
}}}

Mas tem um jeito melhor e mais amigo de fazer isso, através do módulo
{{{doctest}}} do Python. Aproveitando os próprios exemplos documentados
e sem copiar tudo novamente (passível de falha isso).

{{{#!python
def fat(n):
  """Calcula o fatorial de n.
Linha 76: Linha 20:
}}}

é uma implementação bem documentada da função fatorial dentro de um
possível módulo {{{minhasfuncoes.py}}}.

Uma preocupação maior seria sempre assegurar que o que escrevemos
está correto, mesmo quando procuramos melhorar ou até mesmo reescrever
o que fizemos com a função fatorial. Mas como certificar
que não quebramos nada enquanto mudamos?

A resposta está nos testes automatizados, que vão garantir (se bem escolhido)
que não quebramos nada ou indicar quando isso acontecer.
Escolher bem o que testar e como testar é uma arte em si.

Repare nos exemplos que eu escrevi para
descrever a função fatorial, que tal se eu usar esses exemplos
como teste?

Isto é possível através do módulo {{{doctest}}} do Python. vejamos
como utilizar
{{{#!python
def fat(n):
  """Calcula o fatorial de n.

  >>> fat(0)
  1
  >>> fat(5)
  120
  """
  if n == 0:
    return 1
  else:
    return n * fat(n-1)
Linha 85: Linha 62:
Observe que o que eu quero testar eu formato igualzinho
como eu usaria no modo interativo do Python (repare nos >>>).
O que eu quero executar, eu ponho como >>> na frente,
a saída esperada eu acrescento na linha a baixo,
conforme deveria ser.		 O que eu quero executar e testar eu formato igualzinho
como eu usaria no modo interativo do Python (repare nos >>> antes).
a saída esperada eu acrescento na linha logo a baixo,
conforme deveria ser numa seção interativa.
Linha 91: Linha 67:
Pra testar é simples, {{{$ python minhasfuncoes.py}}}. Se nenhum
erro acontecer, a saída é muda, nada aparece na tela.		 Para rodar o teste é simples, {{{$ python minhasfuncoes.py}}}. Se nenhum
erro acontecer a saída é muda, nada aparece na tela. Digamos
que eu mude o {{{if x == 0: return 1}}} para {{{if x == 0: return 0}}},
A execução do teste me dirá que

{{{
$ python minhasfuncoes.py
*****************************************************************
Failure in example: fat(0)
from line #1 of minhasfuncoes.fat
Expected: 1
Got: 0
*****************************************************************
Failure in example: fat(5)
from line #3 of minhasfuncoes.fat
Expected: 120
Got: 0
*****************************************************************
1 items had failures:
   2 of 2 in minhasfuncoes.fat
***Test Failed*** 2 failures.
}}}

fat(0) era esperado o valor 1, veio 0. fat(5) era esperado 120, veio 0 também.
Dois erros foram indicados através da própria documentação da função.

doctest: teste automatizado utilizando DocStrings

Um bom programador procura documentar direito o código que escreve. A linguagem Python é bem amiga nesse aspecto com utilização de DocStrings.

Por exemplo: 

   1 def fat(n):
   2   """Calcula o fatorial de n.
   3 
   4   >>> fat(0)
   5   1
   6   >>> fat(5)
   7   120
   8   """
   9   if x == 0:
  10     return 1
  11   else:
  12     return x * fat(x-1)

é uma implementação bem documentada da função fatorial dentro de um possível módulo minhasfuncoes.py.

Uma preocupação maior seria sempre assegurar que o que escrevemos está correto, mesmo quando procuramos melhorar ou até mesmo reescrever o que fizemos com a função fatorial. Mas como certificar que não quebramos nada enquanto mudamos?

A resposta está nos testes automatizados, que vão garantir (se bem escolhido) que não quebramos nada ou indicar quando isso acontecer. Escolher bem o que testar e como testar é uma arte em si.

Repare nos exemplos que eu escrevi para descrever a função fatorial, que tal se eu usar esses exemplos como teste?

Isto é possível através do módulo doctest do Python. vejamos como utilizar 

   1 def fat(n):
   2   """Calcula o fatorial de n.
   3 
   4   >>> fat(0)
   5   1
   6   >>> fat(5)
   7   120
   8   """
   9   if n == 0:
  10     return 1
  11   else:
  12     return n * fat(n-1)
  13 
  14 def _test():
  15   import doctest, minhasfuncoes
  16   return doctest.testmod(minhasfuncoes)
  17 
  18 if __name__ == '__main__':
  19   _test()

O que eu quero executar e testar eu formato igualzinho como eu usaria no modo interativo do Python (repare nos >>> antes). a saída esperada eu acrescento na linha logo a baixo, conforme deveria ser numa seção interativa.

Para rodar o teste é simples, $ python minhasfuncoes.py. Se nenhum erro acontecer a saída é muda, nada aparece na tela. Digamos que eu mude o if x == 0: return 1 para if x == 0: return 0, A execução do teste me dirá que 

$ python minhasfuncoes.py
*****************************************************************
Failure in example: fat(0)
from line #1 of minhasfuncoes.fat
Expected: 1
Got: 0
*****************************************************************
Failure in example: fat(5)
from line #3 of minhasfuncoes.fat
Expected: 120
Got: 0
*****************************************************************
1 items had failures:
   2 of   2 in minhasfuncoes.fat
***Test Failed*** 2 failures.

fat(0) era esperado o valor 1, veio 0. fat(5) era esperado 120, veio 0 também. Dois erros foram indicados através da própria documentação da função.