Categorías
Python

Python puro vs vs NumPy TensorFlow Comparación de Rendimiento

 

Tabla de Contenidos

  • Introducción a Pruebas en DjangoTypes de paquetes practicesStructureThird partes testsBest
  • Tipos de pruebas
  • Mejor practica paquetes Estructura
  • de terceros
  • ExamplesSetupTesting ModelsTesting ViewsTesting FormsTesting la API
  • Configuración
  • Prueba

  • modelos
  • Prueba

  • Vistas
  • Prueba

  • Formularios
  • Prueba

  • las API
  • la próxima vez
  • Tipos de pruebas de paquetes
  • de terceros
  • mejores prácticas
  • Estructura del setup
  • modelos
  • Testing

  • Testing

  • vistas
  • Prueba

  • Formularios
  • Prueba

  • la API

Prueba

es vital. Sin probar correctamente su código, que nunca se sabe si el código funciona como debería, ahora o en el futuro, cuando los cambios de código base. Incontables horas se pueden perder la solución de problemas causados ​​por cambios en el código base. Lo que es peor, puede que ni siquiera sabe que hay problemas en absoluto hasta los usuarios finales se quejan de ello, que obviamente no es la forma en que desea averiguar sobre descansos de código.

Tener pruebas en lugar será ayuda asegurar que si se rompe una función específica va a saber de él. Las pruebas también hacen que la depuración se rompe en el código mucho más fácil, lo que ahorra tiempo y dinero.

He perdido literalmente conciertos en el pasado de no probar nuevas funciones adecuadamente contra el antiguo código base. No dejes que esto te pase. Tome la prueba en serio. Va a tener más confianza en su código, y su empleador tendrá más confianza en usted. Básicamente se trata de una póliza de seguro.

Prueba ayuda estruturas buen código, encontrar errores y documentación de escritura.

En este post, vamos a estar mirando primero una introducción breve que incluye las mejores prácticas antes de mirar algunos ejemplos. Bono

gratuito: Haga clic aquí para obtener acceso a una guía gratuita Django Recursos de Aprendizaje (PDF) que le muestra sugerencias y trucos, así como los errores comunes a evitar al crear aplicaciones web Python + Django.

Introducción a Prueba de Django

Tipos de pruebas Unidad

y la integración son los dos principales tipos de pruebas: pruebas unitarias

    • están aislados pruebas que ponen a prueba una función específica. Las pruebas
    • de integración, por su parte, son las pruebas más grandes que se centran en el comportamiento del usuario y probar aplicaciones enteras. Dicho de otra manera, las pruebas de integración combina diferentes piezas de funcionalidad código para asegurarse de que se comportan correctamente.

    Centrarse en las pruebas unitarias. Escribir un montón de éstos. Estas pruebas son mucho más fáciles de escribir y pruebas de integración de depuración frente, y cuanto más se tenga, menos pruebas de integración que va a necesitar. Las pruebas unitarias deben ser rápidos. Vamos a ver algunas técnicas para acelerar las pruebas.

    Dicho esto, las pruebas de integración son a veces todavía necesario incluso si tiene cobertura con pruebas unitarias, ya que las pruebas de integración pueden ayudar a regresiones código de captura.

    En general, las pruebas de resultado ya sea en un éxito (resultados esperados), insuficiencia (resultados inesperados), o un error. No sólo es necesario para la prueba de los resultados esperados, sino también qué tan bien su código controla resultados inesperados.

    Mejor practica

    • actualizar localmente,
    • ejecutar el conjunto de pruebas, arreglar errores
    • , PUSH
    • al repositorio y puesta en escena, y luego prueba
    • de nuevo en la organización antes de enviar el código. Estructura

    Estructura

    sus pruebas para adaptarse a su proyecto. Me inclino a favor de poner todas las pruebas para cada aplicación en el archivo tests.py y agrupar las pruebas por lo que estoy probando – por ejemplo, modelos, vistas, formularios, etc.

    También se puede derivar (eliminar) las pruebas archivo .py por completo y estructurar sus pruebas de esta manera dentro de cada aplicación:

    └── app_name
    └── tests
    ├── __init__.py
    ├── test_forms.py
    ├── test_models.py
    └── test_views.py

    por último, se podría crear una carpeta de prueba independiente, que refleja toda la estructura del proyecto, la colocación de un archivo tests.py en cada carpeta de aplicación.

    proyectos más grandes deben utilizar una de las últimas estructuras. Si sabe que su proyecto más pequeño con el tiempo se escala en algo mucho más grande, lo mejor es utilizar una de las dos últimas estructuras también. Estoy a favor de la primera y la tercera estructuras, ya que me resulta más fácil diseñar pruebas para cada aplicación cuando todos ellos son visibles en una secuencia de comandos. Los paquetes de terceros

    Use los siguientes paquetes y bibliotecas para ayudar con la escritura y el funcionamiento de su banco de pruebas:

    • django-webtest: hace que sea mucho más fácil de escribir pruebas funcionales y afirmaciones que coinciden con la experiencia del usuario final. La combinación de estas pruebas con las pruebas de Selenium para una cobertura total en las plantillas y puntos de vista. la cobertura
    • : se utiliza para medir la efectividad de las pruebas, que muestra el porcentaje de su base de código cubierto por las pruebas. Si usted apenas está comenzando a establecer las pruebas de unidad, la cobertura puede ayudar a ofrecer sugerencias sobre lo que debe ser probado. La cobertura también se puede utilizar para convertir la prueba en un juego: Trato de aumentar el porcentaje de código cubierto por las pruebas de cada día, por ejemplo.
    • django-descubrir-corredor: ayuda a localizar las pruebas si se organizan de una manera diferente (por ejemplo, fuera del tests.py). Así que si a organizar sus pruebas en carpetas separadas, como en el ejemplo anterior, puede utilizar descubrir favorito para localizar las pruebas. factory_boy
    • , model_mommy, y mock: todo se utilizan en lugar de los accesorios o la ORM para poblar los datos necesarios para la prueba. Ambas instalaciones y el ORM puede ser lento y necesitan ser actualizados cada vez que cambia su modelo.

    Ejemplos

    En este ejemplo básico, que estarán probando: modelos

    • , vistas
    • , formas
    • , y
    • la API.

    Descargar el Github repo aquí para seguir a lo largo. Configuración

    Instalar cobertura y agregarlo a su INSTALLED_APPS: cobertura

    $ pip install coverage==3.6

    Run:

    $ coverage run manage.py test whatever -v 2

    uso nivel de verbosidad 2, -v 2, para más detalles. También puede probar su proyecto Django a la vez con este comando: cobertura de ejecutar la prueba manage.py -v 2.

    elaborar su propio informe para ver dónde debe comenzar la prueba:

    $ coverage html

    abierto django15 / htmlcov / index.html a ver los resultados de su informe. Desplazarse hasta la parte inferior del informe. Puede omitir todas las filas de la carpeta virtualenv. Nunca prueba de cualquier cosa que es una función integrada de Python o biblioteca ya los que ya se ponen a prueba. Puede mover su virtualenv fuera de la carpeta para hacer que el limpiador de informe después de que corrió. inicio de

    Let probando los modelos. Modelos de prueba

    Dentro del informe de cobertura, haga clic en el enlace para “Lo / modelos”. Usted debe ver esta pantalla:

    En esencia, este informe se indica que hay que probar el título de una entrada. Sencillo.

    abierto tests.py y agregue el siguiente código:

    from django.test import TestCase
    from whatever.models import Whatever
    from django.utils import timezone
    from django.core.urlresolvers import reverse
    from whatever.forms import WhateverForm

    # models test
    class WhateverTest(TestCase):

    def create_whatever(self, title="only a test", body="yes, this is only a test"):
    return Whatever.objects.create(title=title, body=body, created_at=timezone.now())

    def test_whatever_creation(self):
    w = self.create_whatever()
    self.assertTrue(isinstance(w, Whatever))
    self.assertEqual(w.__unicode__(), w.title)

    lo que está pasando aquí? Hemos creado esencialmente un objeto cualquiera y probó si el título creado emparejado el título de esperar – lo que hizo.

    Nota: asegúrese de que sus nombres de función comience con test, que no sólo es una convención común sino también para que Django-descubrir-corredor puede localizar la prueba. Además, las pruebas de escritura para todos de los métodos que se suman a su modelo. la cobertura de gestión Re

    :

    $ coverage run manage.py test whatever -v 2

    debería ver los siguientes resultados, indicando la prueba se ha superado:

    test_whatever_creation (whatever.tests.WhateverTest) ... ok

    ----------------------------------------------------------------------
    Ran 1 test in 0.002s

    OK

    Entonces, si nos fijamos en el informe de la cobertura de nuevo, los modelos debe ahora estar al 100%.

    Prueba

    Vistas Vistas

    Testing

    a veces puede ser difícil. Yo generalmente uso unidad de pruebas para comprobar los códigos de estado, así como selenio WebDriver para probar AJAX, Javascript, etc.

    Agregue el código siguiente a la clase WhateverTest en tests.py :

    # views (uses reverse)

    def test_whatever_list_view(self):
    w = self.create_whatever()
    url = reverse("whatever.views.whatever")
    resp = self.client.get(url)

    self.assertEqual(resp.status_code, 200)
    self.assertIn(w.title, resp.content)

    Aquí buscamos a la URL del cliente , almacenar los resultados en la variable resp y luego probar nuestras afirmaciones. En primer lugar, comprobamos si el código de respuesta es 200, y luego probamos la parte posterior de respuesta real. Usted debe obtener resultados thefollowing:

    test_whatever_creation (whatever.tests.WhateverTest) ... ok
    test_whatever_list_view (whatever.tests.WhateverTest) ... ok

    ----------------------------------------------------------------------
    Ran 2 tests in 0.052s

    OK

    Ejecutar el informe de nuevo. Ahora debería ver un enlace para “Lo / puntos de vista”, que muestra los siguientes resultados:

    Puede también pruebas de escritura para asegurarse de que algo falla. Por ejemplo, si un usuario necesita que estar conectado para crear un nuevo objeto, la prueba tendría éxito si en realidad no puede crear el objeto. La mirada de

    Veamos una prueba rápida de selenio:

    # views (uses selenium)

    import unittest
    from selenium import webdriver

    class TestSignup(unittest.TestCase):

    def setUp(self):
    self.driver = webdriver.Firefox()

    def test_signup_fire(self):
    self.driver.get("http://localhost:8000/add/")
    self.driver.find_element_by_id('id_title').send_keys("test title")
    self.driver.find_element_by_id('id_body').send_keys("test body")
    self.driver.find_element_by_id('submit').click()
    self.assertIn("http://localhost:8000/", self.driver.current_url)

    def tearDown(self):
    self.driver.quit

    if __name__ == '__main__':
    unittest.main()

    Instalar el selenio:

    $ pip install selenium==2.33.0

    Ejecutar las pruebas. Firefox se debe cargar (si lo tienes instalado) y ejecute la prueba. a continuación, afirmamos que la página se carga correcta tras la presentación. También puede comprobar para asegurarse de que el nuevo objeto se agrega a la base de datos.

    Prueba

    Formularios

    Añadir los siguientes métodos:

    def test_valid_form(self):
    w = Whatever.objects.create(title='Foo', body='Bar')
    data = {'title': w.title, 'body': w.body,}
    form = WhateverForm(data=data)
    self.assertTrue(form.is_valid())

    def test_invalid_form(self):
    w = Whatever.objects.create(title='Foo', body='')
    data = {'title': w.title, 'body': w.body,}
    form = WhateverForm(data=data)
    self.assertFalse(form.is_valid())

    Aviso la forma en que están generando los datos de la forma de JSON. Este es un accesorio.

    Ahora debe tener 5 pruebas que pasan:

    test_signup_fire (whatever.tests.TestSignup) ... ok
    test_invalid_form (whatever.tests.WhateverTest) ... ok
    test_valid_form (whatever.tests.WhateverTest) ... ok
    test_whatever_creation (whatever.tests.WhateverTest) ... ok
    test_whatever_list_view (whatever.tests.WhateverTest) ... ok

    ----------------------------------------------------------------------
    Ran 5 tests in 12.753s

    OK

    Usted podría también pruebas de escritura que afirmar si se muestra un mensaje de error determinado en base a los validadores en el propio formulario.

    Prueba

    la API

    En primer lugar, se puede acceder a la API desde esta dirección: http: // localhost: 8000 / api lo / formato / = JSON. Esta es una configuración sencilla, por lo que las pruebas serán bastante simple también.

    Instalar lxml y XML desactivado:

    $ pip install lxml==3.2.3
    $ pip install defusedxml==0.4.1

    Añadir los siguientes casos de prueba:

    from tastypie.test import ResourceTestCase

    class EntryResourceTest(ResourceTestCase):

    def test_get_api_json(self):
    resp = self.api_client.get('/api/whatever/', format='json')
    self.assertValidJSONResponse(resp)

    def test_get_api_xml(self):
    resp = self.api_client.get('/api/whatever/', format='xml')
    self.assertValidXMLResponse(resp)

    Simplemente estamos afirmando que obtenemos una respuesta en cada caso.

    la próxima vez

    En el siguiente tutorial, vamos a encontrar un ejemplo más complicado, así como el uso de model_mommy para la generación de datos de prueba. Una vez más, se puede agarrar el código desde el repositorio. Bono

    gratuito: Haga clic aquí para obtener acceso a una guía gratuita Django Recursos de Aprendizaje (PDF) que le muestra sugerencias y trucos, así como los errores comunes a evitar al crear aplicaciones web Python + Django.

    Tienes algo que añadir? Deja un comentario más abajo.

  • Deja un comentario

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *