Categorías
Uncategorized

VPS cloud hosting

VPS Cloud Hosting

LightningFast

Los discos de estado sólido (SSD) están construidos para proporcionar comandos de lectura/escritura instantáneos, ya que no se ralentizan por ningún elemento mecánico en movimiento. Combinado con un puerto gigabit y una red de alto rendimiento con más de 200Gb/s de capacidad, el alojamiento de SSD VPS en la nube está construido para la velocidad.

UltimateControl

Nuestro panel de control inteligente le permite gestionar su alojamiento Cloud SSD VPS en un entorno sencillo. Puedes monitorear, reiniciar, hacer copias de seguridad y hacer cambios en tu servidor con facilidad y en tiempo real sin necesidad de llamar al soporte.

ProactiveSupport

Nuestro equipo de expertos está disponible 24 horas al día, 7 días a la semana, 365 días al año. Ya sea que necesite una respuesta a una pregunta difícil sobre alojamiento o un pequeño consejo sobre el diseño de su infraestructura, nuestro equipo puede echarle una mano.

FlexibleOS

Elija entre una variedad de sistemas operativos, incluyendo los sabores de Windows y Linux OS (Ubuntu o CentOS). Gracias a nuestro panel de control de última generación, su sistema operativo se iniciará en minutos.

  • 0. 5GB RAM
  • 25GB SSD Disco
  • 2TB Ancho de banda
  • 1 Núcleo
  • 1GB RAM
  • 50GB SSD Disco
  • 3TB Ancho de banda
  • 2 Núcleo
  • 2GB RAM
  • Disco SSD de 80 GB
  • Anchura de banda de 4 TB
  • 4 Núcleos
  • 4 GB de RAM
  • Disco SSD de 100 GB
  • 5 TB de anchura de banda
  • 4 Núcleos
  • 8 GB de RAM
  • Disco SSD de 200GB
  • 6TB Ancho de banda
  • 4 Núcleos
  • 16GB RAM
  • Disco SSD de 120GB
  • 7TB Ancho de banda
  • 4 Núcleos
  • 32GB RAM
  • Disco SSD de 250 GB
  • Ancho de banda de 8 TB
  • 8 Núcleos
  • 48 GB de RAM
  • Disco SSD de 500 GB
  • Ancho de banda de 9 TB
  • 8 Núcleos

Selecciona tu sistema operativo:

  • CentOS 6.x x64 (Gratuito)
  • CentOS 7.x x64 (Gratuito)
  • Ubuntu 16.04 x64 LTS (Gratuito)
  • Ubuntu 18. 04 x64 LTS (Gratis)
  • Windows 2012 Std Edition R2 x64 (+£15.00/mo)
  • CentOS 7.x x64 w/cPanel (Hasta 5 cuentas) (+£10.00/mo)

Nota: Windows y cPanel requieren al menos 1GB.

Nota: Windows 2012 requiere al menos 2GB de RAM

cPanel las tarifas de licencia se basan en el número de cuentas activas que tengas. Más información aquí:

Elige tu nombre de host de Internet

Introduce un nombre de host de Internet que quieras que se utilice para identificar tu VPS en Internet. Este debe estar en el formato nombre.dominio.com. Por ejemplo, esto podría ser vps.midomainname.com. Esto puede ser cambiado más tarde una vez que acceda a su servidor.

¡Uy! Este nombre de host no se ve bien. Por favor, inténtalo de nuevo.

Selecciona la ubicación

Características

Nuestros centros de datos

Activamente Protegidos

Somos propietarios, administradores y aseguramos nuestros centros de datos por completo, lo que significa que ningún tercero podría tener acceso a tu información. Los centros de datos también están equipados con sensores ópticos, de ionización y de detección de calor, junto con la detección de incendios VESDA. El personal también está in situ las 24 horas del día, garantizando la seguridad de su máquina en todo momento

Seguro

La monitorización de CCTV está siempre en acción en los centros de datos de VPS. Todas las áreas cuentan con detectores de movimiento PIR para resaltar cualquier actividad adversa. El sitio es discreto y opera un sistema de entrada biométrico de doble factor y un riguroso registro de asistencia. El perímetro del sitio está alarmado y equipado con detectores de haz.

Diseñado inteligentemente

La protección y el mantenimiento de sus datos es parte integral de nuestras operaciones; la redundancia está incorporada en nuestra infraestructura como estándar. Nuestros servidores VPS en la nube están diseñados y construidos desde el suelo para asegurar que sus datos estén en vivo y en contacto. El centro de datos tiene una fuente de alimentación de generador N+1, 15 unidades DX CRAC de 105kW, y un sistema de refrigeración inteligente para asegurar un rendimiento óptimo. Nuestros generadores excedentes pueden alimentar el sitio durante días en caso de una interrupción de energía a largo plazo.

Construido para la velocidad

Nuestra infraestructura de red está construida con hardware 100% de primera calidad, con 200Gb de conectividad y múltiples proveedores de tránsito líderes en la industria con múltiples puntos finales de fibra. Todos los equipos VPS están conectados a puertos dedicados de 1Gbps en conmutadores totalmente redundantes, lo que garantiza que el tiempo de inactividad no sea un problema.

Ubicaciones de los servidores

Beneficios del sistema operativo

Los servidores VPS con SSD en nube incluyen su elección de sistema operativo según sus necesidades. Este podría ser un entorno Windows 2012 Standard edition R2 o un sistema operativo Linux de una elección de CentOS 6 / 7 o Ubuntu 16 / 18 x64. También puede elegir cPanel, el panel de control favorito del mundo. Trabajamos para que las licencias sean asequibles y así asegurarnos de que su paquete de hosting se ajuste a su presupuesto.

Usos populares

Si has superado tu paquete de alojamiento compartido pero no necesitas el almacenamiento, el ancho de banda o el coste de un servidor dedicado, entonces el alojamiento VPS es la solución perfecta para aumentar la velocidad, la fiabilidad y el control. El acceso IPMI significa que usted decide qué hacer con su servidor privado virtual. Los SSD VPS funcionan muy bien como servidores personales, de prueba, de almacenamiento de archivos, de juegos, de copias de seguridad, o servidores de audio/medios de comunicación.

Preguntas frecuentes

Nuestros servidores privados virtuales están diseñados y construidos para mantener sus datos en línea. Si sus servidores VPS sufren una interrupción, sus datos serán transferidos instantáneamente a una máquina en vivo sin ninguna interrupción.

Simplemente seleccione sus recursos de los deslizadores de arriba – puede utilizar las guías preestablecidas recomendadas en caso de que no esté seguro de los recursos que necesitará para empezar – y haga clic en el botón «Comprar». Su máquina de alojamiento de nubes VPS estará en línea en unos pocos clics.

Acercar tus datos lo máximo posible a tus clientes aumentará tu velocidad de transferencia y reducirá la latencia, dos factores que pueden causar problemas en tu sitio o aplicación. Al alojar sus datos cerca de los usuarios finales, los coloca como una prioridad. No sólo proporcionamos servidores virtuales en el Reino Unido, sino que operamos a escala mundial.

El alojamiento compartido es exactamente como suena, compartido, lo que significa que su servidor y sus recursos son utilizados por muchas cuentas diferentes. Aunque es genial para un solo sitio web pequeño, el alojamiento compartido a menudo deja mucho que desear cuando se considera la velocidad y la seguridad. Un VPS ofrece recursos dedicados a usted y, dado que su instancia virtual no se comparte con ninguna otra cuenta, no tiene que preocuparse por los riesgos de seguridad inherentes al alojamiento compartido.

El alojamiento VPS ofrece mucho del control y el poder de un servidor dedicado sin el costo. Utiliza los recursos que se dedican exclusivamente a tu cuenta y disfruta de la mayor seguridad y fiabilidad de un servidor dedicado sin tener que pagar por un entorno más grande del que necesitas.

¡Todos los que quieras! Cloud SSD VPS crece con usted. Si en el futuro necesitas más espacio, ancho de banda o RAM en cualquier momento desde tu cuenta de alojamiento. Las soluciones VPS son ideales para sitios web que experimentan picos de tráfico estacionales o un uso intensivo basado en ventas o períodos de promoción.

Mientras que un servidor dedicado le otorga un control total y una serie de beneficios, el alojamiento de servidores privados virtuales es perfecto para aquellos que tienen un menor requerimiento de recursos para su máquina. El alojamiento de VPS es más rentable y su capacidad de ampliación y reducción según sea necesario le da más libertad para hacer crecer su sitio o aplicación sin comprometerse totalmente con el gasto de un servidor dedicado.

Categorías
Python

Versiones de ejecución de Python en acoplable: Cómo probar la última Release Python

 

Tabla de Contenidos

  • Instalación Requisitos
  • configuración de actualización de
  • modelo de datos
  • local Migración
  • remoto Migración
  • Conclusión

En esta parte vamos a establecer una base de datos PostgreSQL para almacenar los resultados de nuestras cuentas de la palabra, así como SQLAlchemy, un objeto relacional Mapper, y Alambique a las migraciones de bases de datos mango. Bono

gratuito: Haga clic aquí para obtener acceso a un tutorial de vídeo libres Frasco + Python que muestra cómo construir aplicación web Frasco, paso a paso.

Actualizaciones :

  • 22/03/2016: actualizado a la versión 3.5.1 de Python, así como las últimas versiones de psycopg2, Frasco-SQLAlchemy y matraz de migrar. Véase más abajo para más detalles.
  • 02/22/2015: Agregado Python 3 apoyo.

Recuerde: Esto es lo que estamos construyendo – Un Frasco aplicación que calcula pares de palabras de frecuencia basado en el texto de una determinada URL.

Need el código? Agarrarlo desde el repositorio.

Requerimientos de Instalación Herramientas

utilizados en esta parte:

  • PostgreSQL (9.4)
  • psycopg2 (2.6.1) – un adaptador de Python para Postgres
  • matraz de SQLAlchemy (2.1) – Frasco extensión que proporciona soporte SQLAlchemy
  • matraz de migración (1.8.0) – extensión que soporta SQLAlchemy migraciones de bases de datos a través del alambique

Para empezar, instalar Postgres en su computadora local, si no lo tiene ya. Desde Heroku utiliza PostgreSQL, que será bueno para nosotros desarrollar localmente en la misma base de datos. Si no tiene instalado Postgres, Postgres.app es una manera fácil de poner en marcha para los usuarios de Mac OS X. Consulte la página de descarga para obtener más información.

Una vez que se han instalado Postgres y funcionando, crear una base de datos llamada wordcount_dev utilizar como nuestra base de datos de desarrollo local:

$ psql
# create database wordcount_dev;
CREATE DATABASE
# \q

Para poder utilizar nuestra base de datos de nueva creación dentro de la aplicación frasco que a necesidad de instalar un par de cosas:

$ cd flask-by-example

cding en el directorio debe activar el entorno virtual y establecer las variables de entorno encontraron en el archivo .env través autoenv, que hemos creado en la parte 1.

$ pip install psycopg2==2.6.1 Flask-SQLAlchemy===2.1 Flask-Migrate==1.8.0
$ pip freeze > requirements.txt

Si estás en OS X y que tiene verificación de la instalación psycopg2 problemas a cabo este Pila Artículo desbordamiento.

configuración de actualización de

Añadir campo SQLALCHEMY_DATABASE_URI a la clase Config () en el archivo config.py a configurar su aplicación para utilizar la base de datos de nueva creación en el desarrollo (local), puesta en escena, y la producción:

import os

class Config(object):
...
SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

Su configuración archivo .py ahora debería tener este aspecto:

import os
basedir = os.path.abspath(os.path.dirname(__file__))

class Config(object):
DEBUG = False
TESTING = False
CSRF_ENABLED = True
SECRET_KEY = 'this-really-needs-to-be-changed'
SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

class ProductionConfig(Config):
DEBUG = False

class StagingConfig(Config):
DEVELOPMENT = True
DEBUG = True

class DevelopmentConfig(Config):
DEVELOPMENT = True
DEBUG = True

class TestingConfig(Config):
TESTING = True

ahora, cuando nuestra configuración se carga en nuestra aplicación de la base de datos correspondiente se conectará a él también.

Similar a como hemos añadido una variable de entorno en el último post, vamos a añadir una variable DATABASE_URL. Ejecutar este en el terminal:

$ export DATABASE_URL="postgresql://localhost/wordcount_dev"

Y luego añadir que la línea en el archivo su .env.

En su app.py archivo de importación SQLAlchemy y de conexión a la base de datos:

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
import os

app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from models import Result

@app.route('/')
def hello():
return "Hello World!"

@app.route('/')
def hello_name(name):
return "Hello {}!".format(name)

if __name__ == '__main__':
app.run()

modelo de datos

Conjunto de un modelo de base, añadiendo un archivo models.py :

from app import db
from sqlalchemy.dialects.postgresql import JSON

class Result(db.Model):
__tablename__ = 'results'

id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String())
result_all = db.Column(JSON)
result_no_stop_words = db.Column(JSON)

def __init__(self, url, result_all, result_no_stop_words):
self.url = url
self.result_all = result_all
self.result_no_stop_words = result_no_stop_words

def __repr__(self):
return ''.format(self.id)

Aquí hemos creado una tabla para almacenar los resultados de las palabra cuenta.

Primero importar la conexión de base de datos que hemos creado en nuestro archivo app.py , así como JSON de dialectos de PostgreSQL SQLAlchemy. JSON columnas son bastante nuevo en Postgres y no están disponibles en cada base de datos soportado por SQLAlchemy por lo que necesitamos para importar específicamente.

A continuación creamos una clase Resultado () y le asignó el nombre de una tabla de resultados. A continuación, establecemos los atributos que queremos almacenar para un result-

  • el identificador del resultado que nos guardaron
  • la url que contamos con las palabras de
  • una lista completa de palabras que contamos
  • una lista de palabras que contamos con las palabras vacías menos (más sobre esto más adelante)

a continuación, creamos un () método __init __ que se ejecutará la primera vez que creamos un nuevo resultado y el método, por último, una __repr __ () para representar el objeto cuando nos consulta para ello.

local Migración

Vamos a utilizar Alambique, que forma parte del matraz de Migración, para gestionar las migraciones de bases de datos para actualizar el esquema de una base de datos.

Crear un nuevo archivo llamado manage.py :

import os
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand

from app import app, db

app.config.from_object(os.environ['APP_SETTINGS'])

migrate = Migrate(app, db)
manager = Manager(app)

manager.add_command('db', MigrateCommand)

if __name__ == '__main__':
manager.run()

Para utilizar matraz de Migración nos importó Gestor, así como migrar y MigrateCommand a nuestro archivo manage.py . También hemos importado aplicación y db por lo que tenemos acceso a ellos desde dentro del script.

En primer lugar, hemos establecido nuestra config para conseguir nuestro medio ambiente – en base a la variable de entorno – creado una instancia de migración, la aplicación y el PP como los argumentos, y estableció un comando encargado de inicializar una instancia de Manager para nuestra aplicación. Por último, agregamos el comando db con el gerente para que podamos ejecutar las migraciones desde la línea de comandos.

Con el fin de ejecutar las migraciones inicializar Alambique:

$ python manage.py db init
Creating directory /flask-by-example/migrations ... done
Creating directory /flask-by-example/migrations/versions ... done
Generating /flask-by-example/migrations/alembic.ini ... done
Generating /flask-by-example/migrations/env.py ... done
Generating /flask-by-example/migrations/README ... done
Generating /flask-by-example/migrations/script.py.mako ... done
Please edit configuration/connection/logging settings in
'/flask-by-example/migrations/alembic.ini' before proceeding.

Después de ejecutar la base de datos de inicialización, verá una nueva carpeta llamada “migraciones” en el proyecto. Esto es necesario para la configuración del alambique a las migraciones dirigidas contra el proyecto. Dentro de las “migraciones” verá que tiene una carpeta llamada “versiones”, que contendrá los scripts de migración a medida que se crean.

Vamos a crear nuestra primera migración mediante la ejecución del comando migrate.

$ python manage.py db migrate
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.autogenerate.compare] Detected added table 'results'
Generating /flask-by-example/migrations/versions/63dba2060f71_.py
... done

Ahora se dará cuenta de sus “versiones” carpeta hay un archivo de migración. Este archivo es por Alambique basado en el modelo de auto-generado. Se podría generar (o editar) este archivo usted mismo; Sin embargo, para la mayoría de los casos va a hacer el archivo generado automáticamente.

Ahora vamos a aplicar las mejoras a la base de datos utilizando el comando de actualización db:

$ python manage.py db upgrade
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.runtime.migration] Running upgrade -> 63dba2060f71, empty message

La base de datos está ahora lista para usarla en nuestra aplicación:

$ psql
# \c wordcount_dev
You are now connected to database "wordcount_dev" as user "michaelherman".
# \dt

List of relations
Schema | Name | Type | Owner
--------+-----------------+-------+---------------
public | alembic_version | table | michaelherman
public | results | table | michaelherman
(2 rows)

# \d results
Table "public.results"
Column | Type | Modifiers
----------------------+-------------------+------------------------------------------------------
id | integer | not null default nextval('results_id_seq'::regclass)
url | character varying |
result_all | json |
result_no_stop_words | json |
Indexes:
"results_pkey" PRIMARY KEY, btree (id)

remoto Migración

Por último, vamos a aplicar las migraciones a las bases de datos en Heroku. En primer lugar, sin embargo, tenemos que añadir los detalles de las bases de datos de ensayo y producción en el fichero de config.py . cheque

Para si tenemos una base de datos creada en la carrera servidor de ensayo:

$ heroku config --app wordcount-stage
=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig

Asegúrese de reemplazar wordcount-escenario con el nombre de su aplicación puesta en escena.

Dado que no vemos una variable de entorno de base de datos, tenemos que añadir el complemento de Postgres para el servidor de ensayo. Para ello, ejecute el siguiente comando:

$ heroku addons:create heroku-postgresql:hobby-dev --app wordcount-stage
Creating postgresql-cubic-86416... done, (free)
Adding postgresql-cubic-86416 to wordcount-stage... done
Setting DATABASE_URL and restarting wordcount-stage... done, v8
Database has been created and is available
! This database is empty. If upgrading, you can transfer
! data from another database with pg:copy
Use `heroku addons:docs heroku-postgresql` to view documentation.

manía-dev es la capa gratuita del complemento Heroku Postgres.

Ahora, cuando se corre heroku config –app wordcount-escenario de nuevo hay que ver los ajustes de conexión para la base de datos:

=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig
DATABASE_URL: postgres://azrqiefezenfrg:Zti5fjSyeyFgoc-U-yXnPrXHQv@ec2-54-225-151-64.compute-1.amazonaws.com:5432/d2kio2ubc804p7

siguiente que necesitamos para confirmar los cambios que ha realizado en Git y empuje para el servidor de transición:

$ git push stage master

Ejecutar las migraciones que hemos creado para migrar nuestra base de datos provisional mediante el comando de ejecución heroku:

$ heroku run python manage.py db upgrade --app wordcount-stage
Running python manage.py db upgrade on wordcount-stage... up, run.5677
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.runtime.migration] Running upgrade -> 63dba2060f71, empty message

Aviso la forma en que sólo salía de la actualización, no es el init o comandos migran como antes. Ya hemos establecido nuestro archivo de migración y listo para funcionar; sólo tenemos que aplicarlo contra la base de datos Heroku.

Vamos ahora a hacer lo mismo para la producción.

Ahora, tanto nuestros sitios de ensayo y producción han establecido sus bases de datos y se migran – y listo para ir!

Cuando se aplica una nueva migración de la base de datos de producción, no podría ser el tiempo de inactividad. Si esto es un problema, puede configurar la replicación de bases de datos mediante la adición de un “seguidor” (comúnmente conocido como esclavo) de base de datos. Para más información sobre esto, echa un vistazo a la documentación oficial Heroku.

Conclusión

Eso es todo por parte 2. Si desea profundizar en el frasco, visita nuestra serie de videos que acompaña: Bonus

gratuito: Haga clic aquí para obtener acceso a un vídeo gratuito + Frasco Python tutorial que le muestra cómo construir aplicación web Frasco, paso a paso.

En la parte 3 vamos a construir la funcionalidad de conteo de palabras y lo han enviado a una cola de tareas para tratar con el procesamiento de recuento de palabras ya en funcionamiento.

Nos vemos la próxima vez. ¡Salud!

Esta es una pieza colaboración entre la leva Linke, co-fundador de inicio Edmonton, y la gente en el Real Python.

Categorías
Python

Leer y escribir archivos CSV

 

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.

  • 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.

  • Categorías
    Python

    Estructura Python Programa léxico

     

    Tabla de Contenidos

    • Qué KeyError Python generalmente significa
    • ¿Dónde más puede ver un KeyError Python en la librería estándar
    • cuando se necesita para criar a un KeyError Python en su propio código
    • Cómo manejar un KeyError Python Cuando You See ItThe solución habitual: .get () La solución Raras: Comprobación de KeysThe Solución general: try excepto
    • La solución habitual: .get ()
    • La solución Raras: Comprobación de llaves
    • la solución general: try excepto
    • Conclusión

    • The usual Solución: .get ()
    • la solución Raras: Comprobación de llaves
    • la solución general: try excepto

    Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del real Python . Mira que junto con el tutorial escrito para profundizar su comprensión: Excepciones Python KeyError y forma de abordarlos excepción KeyError de

    Python es una excepción común encontrado por los principiantes. Saber por qué un KeyError se puede subir y algunas soluciones para evitar que se detenga su programa son pasos esenciales para mejorar como programador de Python.

    Al final de este tutorial, usted sabrá:

    • Qué KeyError Python normalmente significa
    • Dónde más puede ver un KeyError en la biblioteca estándar
    • Como manejar un KeyError cuando lo ves
    • Bono

    gratuito: Haga clic aquí para obtener nuestro libre Hoja de trucos Python que le muestra los conceptos básicos de Python 3, como trabajar con tipos de datos, diccionarios, listas y funciones de Python.

    Qué excepción Python KeyError por lo general significa

    Un KeyError Python es lo que se genera cuando se intenta acceder a una clave que no se encuentra en un diccionario (dict). documentación oficial de Python

    dice que el KeyError se eleva cuando se accede a una asignación de teclas y no se encuentra en el mapeo. Un mapeo es una estructura de datos que se asigna un conjunto de valores a otro. El mapeo más común en Python es el diccionario.

    El KeyError Python es un tipo de excepción y LookupError denota que no era una cuestión de recuperar la clave que estaba buscando. Cuando vea un KeyError, el significado semántico es que la clave se buscó no se pudo encontrar.

    En el siguiente ejemplo, se puede ver un diccionario (edades) se define con las edades de tres personas. Al intentar acceder a una clave que no está en el diccionario, un KeyError se eleva:

    >>> ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    >>> ages['Michael']
    Traceback (most recent call last):
    File "", line 1, in
    KeyError: 'Michael'

    Aquí, el intento de acceder a la clave ‘Michael’ en las edades resultados del diccionario en un KeyError siendo criados. En la parte inferior del rastreo, se obtiene la información relevante:

    • El hecho de que un KeyError se elevó
    • La llave que no se pudo encontrar, que era ‘Michael’

    La segunda a la última línea dice que la línea que produce la excepción. Esta información es más útil cuando se ejecuta el código Python desde un archivo.

    Nota: Cuando se produce una excepción en Python, que se realiza con un rastreo . El rastreo le da toda la información relevante para poder determinar por qué la excepción fue levantado y lo que lo causó.

    aprender a leer una retraza de Python y la comprensión de lo que está diciendo es crucial para mejorar como programador de Python.

    En el siguiente programa, se puede ver las edades diccionario definido de nuevo. Esta vez, se le pedirá que proporcione el nombre de la persona para recuperar la edad para:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5 print(f'{person} is {ages[person]} years old.')

    Este código se tome el nombre que proporciona en el indicador y el intento de recuperar la edad para esa persona. Lo que se teclea en el indicador de se utilizará como clave para las edades de diccionario, en la línea 4.

    Repitiendo el ejemplo no desde arriba, obtenemos otra de rastreo, esta vez con información acerca de la línea en el archivo que el KeyError es resucitado de entre:

    $ python ages.py
    Get age for: Michael
    Traceback (most recent call last):
    File "ages.py", line 4, in
    print(f'{person} is {ages[person]} years old.')
    KeyError: 'Michael'

    el programa falla cuando se le da una llave que no está en el diccionario. Aquí, últimas líneas del rastreo apuntan al problema. Archivo «ages.py», línea 4, en le indica qué línea de qué archivo produce la excepción KeyError resultante. A continuación, se muestran esa línea. Por último, la excepción KeyError proporciona la clave que falta.

    Así se puede ver que la última línea del rastreo KeyError no le da suficiente información sobre su cuenta, pero las líneas antes de que se puede obtener mucho más cerca de la comprensión de lo que salió mal.

    Nota: Al igual que el ejemplo anterior, la mayoría de los otros ejemplos en este tutorial de hacer uso de aviones F-cuerdas, que se introdujeron en Python 3.6.

    ¿Dónde más puede ver un KeyError Python en la Norma Biblioteca

    La gran mayoría de las veces, un KeyError Python se eleva debido a una clave no se encuentra en un diccionario o una subclase diccionario (como os.environ).

    En casos raros, también se puede ver que se crió en otros lugares en la biblioteca estándar de Python, como en el módulo de archivo zip, si un artículo no se encuentra en un archivo ZIP. Sin embargo, estos lugares conservan el mismo significado semántico de la KeyError Python, que no está encontrando la clave solicitada.

    En el siguiente ejemplo, se puede ver utilizando la clase zipfile.ZipFile para extraer información acerca de un archivo ZIP usando .getinfo ():

    >>> from zipfile import ZipFile
    >>> zip_file = ZipFile('the_zip_file.zip')
    >>> zip_file.getinfo('something')
    Traceback (most recent call last):
    File "", line 1, in
    File "/patho/python/installation/zipfile.py", line 1304, in getinfo
    'There is no item named %r in the archive' % name)
    KeyError: "There is no item named 'something' in the archive"

    Esto no parece realmente una búsqueda clave de diccionario. En su lugar, se trata de una llamada a zipfile.ZipFile.getinfo () que plantea la excepción.

    El rastreo también se ve un poco diferente con un poco más de información dado que sólo la clave que falta: KeyError: «No hay ningún elemento denominado ‘algo’ en el archivo».

    La última cosa a tener en cuenta es que la línea que planteó la KeyError no está en su código. Es en el código zip, pero las líneas anteriores del rastreo indica qué líneas en el código de la causa del problema.

    cuando se necesita para criar a un KeyError Python en su propio código

    Puede haber momentos en los que tiene sentido traer a colación una excepción de Python KeyError en su propio código. Esto se puede hacer mediante el uso de la palabra clave aumento y llamando la excepción KeyError:

    raise KeyError(message)

    Por lo general, el mensaje sería la clave que falta. Sin embargo, como en el caso del paquete zip, se puede optar por darle un poco más de información para ayudar a la próxima desarrollador a entender mejor lo que salió mal.

    Si deciden criar a un KeyError Pitón en su propio código, simplemente asegúrese de que su caso de uso coincide con el significado semántico detrás de la excepción. Cabe indicar que la clave se buscó no se pudo encontrar.

    Cómo manejar un KeyError Python cuando lo ves

    cuando se encuentra con un KeyError, hay algunas formas estándar para manejarlo. Dependiendo de su caso de uso, algunas de estas soluciones podría ser mejor que los demás. El objetivo final es dejar de excepciones KeyError inesperados de ser levantada.

    La solución habitual: .get ()

    Si el KeyError se eleva desde una búsqueda de claves diccionario fracasado en su propio código, se puede utilizar .get () para devolver el valor ya sea encontrar en la clave especificada o un valor predeterminado.

    Al igual que el ejemplo de recuperación de la edad de antes, el siguiente ejemplo muestra una mejor manera de obtener la edad del diccionario utilizando la clave proporcionada en el indicador:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5 age = ages.get(person)
    6
    7 if age:
    8 print(f'{person} is {age} years old.')
    9 else:
    10 print(f"{person}'s age is unknown.")

    Aquí, la línea 5 muestra cómo se puede obtener el valor de la edad de las edades usando .get (). Esto dará lugar a la variable edad que tenga el valor de edad encontrado en el diccionario de la llave suministrada o un valor predeterminado, Nada en este caso.

    Esta vez, no se obtiene una excepción KeyError elevada debido a la utilización del método más seguro .get () para obtener la edad en lugar de intentar acceder a la clave directamente:

    $ python ages.py
    Get age for: Michael
    Michael's age is unknown.

    En la ejecución ejemplo anterior, el KeyError está ya no se levantó cuando se proporciona una mala llave. La clave ‘Michael’ no se encuentra en el diccionario, pero mediante el uso de .get (), obtenemos una Ninguno regresó en lugar de un KeyError elevada.

    La variable edad, o bien tener la edad de la persona encontraron en el diccionario o el valor por defecto (por defecto ninguno). También puede especificar un valor predeterminado diferente en la llamada .get () pasando un segundo argumento.

    Se trata de la línea 5 del ejemplo anterior con una edad predeterminada diferente especificado utilizando .get ():

    age = ages.get(person, 0)

    Aquí, en lugar de ‘Michael’ Ninguno de regresar, volvería 0 porque no se encuentra la clave y el valor predeterminado valor de retorno es 0. ahora

    la solución Raras: Comprobación de llaves

    Hay momentos en que es necesario determinar la existencia de una clave en un diccionario. En estos casos, el uso de .get () no le puede dar la información correcta. Conseguir una Ninguno de regresar de una llamada a .get () podría significar que la clave no se ha encontrado o que el valor encontrado en la clave del diccionario es en realidad Ninguno.

    Con un diccionario o un diccionario-como objeto, puede utilizar el operador in para determinar si una llave está en la asignación. Este operador devuelve un valor booleano (verdadero o falso) que indica si la clave se encuentra en el diccionario.

    En este ejemplo, que está recibiendo un diccionario respuesta de llamar a una API. Esta respuesta podría tener un valor de clave de error definido en la respuesta, lo que indicaría que la respuesta está en un estado de error:

    1 # parse_api_response.py
    2 ...
    3 # Assuming you got a `response` from calling an API that might
    4 # have an error key in the `response` if something went wrong
    5
    6 if 'error' in response:
    7 ... # Parse the error state
    8 else:
    9 ... # Parse the success state

    Aquí, hay una diferencia en la comprobación para ver si existe la clave de error en la respuesta y la obtención de un valor predeterminado el valor de la clave. Este es un caso raro donde lo que en realidad se está buscando es si la clave está en el diccionario y no lo que el valor en esa clave es.

    la solución general: try excepto

    Al igual que con alguna excepción, siempre se puede utilizar la prueba, excepto el bloque para aislar el código de excepción potencial de sensibilización y proporcionar una solución de copia de seguridad.

    Puede utilizar el intento, excepto bloque en un ejemplo similar al anterior, pero esta vez proporcionar un mensaje predeterminado a imprimir se debe levantar un KeyError en el caso normal:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5
    6 try:
    7 print(f'{person} is {ages[person]} years old.')
    8 except KeyError:
    9 print(f"{person}'s age is unknown.")

    Aquí, se puede ver el caso normal en el intento bloquear la impresión del nombre y la edad de la persona. El caso de copia de seguridad se encuentra en el bloque de excepción, en el que si un KeyError se eleva en el caso normal, entonces el caso de copia de seguridad es imprimir un mensaje diferente.

    El intento excepto solución de bloqueo es también una gran solución para otros lugares que no sean compatibles con .get () o el operador in. También es la mejor solución si el KeyError está siendo levantado de código de otra persona.

    Aquí hay un ejemplo usando el paquete zip de nuevo. Esta vez, el intento excepto bloque nos da una manera de detener la excepción KeyError de detener el programa:

    >>> from zipfile import ZipFile
    >>> zip = ZipFile('the_zip_file.zip')
    >>> try:
    ... zip.getinfo('something')
    ... except KeyError:
    ... print('Can not find "something"')
    ...
    Can not find "something"

    Puesto que la clase ZipFile no proporciona .get (), al igual que lo hace el diccionario, es necesario utilizar el try excepto solución. En este caso, usted no tiene que saber de antemano qué valores son válidos para pasar a .getinfo ().

    Conclusión

    Ahora ya sabe algunos lugares comunes donde excepción KeyError de Python podría elevarse y algunos grandes soluciones que puede utilizar para evitar que se detenga su programa.

    Ahora, la próxima vez que vea un KeyError levantó, se sabrá que es probable que sea sólo un mal diccionario de búsqueda de claves. También podrá encontrar toda la información que necesita para determinar dónde viene el error de mirar las últimas líneas de la traza.

    Si el problema es una búsqueda de clave de diccionario en su propio código, a continuación, puede cambiar el acceso a la clave directamente en el diccionario a usar el método más seguro .get () con un valor de retorno por defecto. Si el problema no viene de su propio código, a continuación, utilizando la prueba, excepto bloque es la mejor opción para controlar el flujo de su código. Excepciones

    no tienen que dar miedo. Una vez que sepa cómo entender la información proporcionada a usted en sus rastreos y la causa de la excepción, entonces usted puede utilizar estas soluciones para hacer sus programas de flujo más predecible.

    Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Excepciones Python KeyError y forma de abordarlos

    Categorías
    Python

    Automatización web moderna con Python y selenio

     

    Tabla de Contenidos

    • Qué KeyError Python generalmente significa
    • ¿Dónde más puede ver un KeyError Python en la librería estándar
    • cuando se necesita para criar a un KeyError Python en su propio código
    • Cómo manejar un KeyError Python Cuando You See ItThe solución habitual: .get () La solución Raras: Comprobación de KeysThe Solución general: try excepto
    • La solución habitual: .get ()
    • La solución Raras: Comprobación de llaves
    • la solución general: try excepto
    • Conclusión

    • The usual Solución: .get ()
    • la solución Raras: Comprobación de llaves
    • la solución general: try excepto

    Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del real Python . Mira que junto con el tutorial escrito para profundizar su comprensión: Excepciones Python KeyError y forma de abordarlos excepción KeyError de

    Python es una excepción común encontrado por los principiantes. Saber por qué un KeyError se puede subir y algunas soluciones para evitar que se detenga su programa son pasos esenciales para mejorar como programador de Python.

    Al final de este tutorial, usted sabrá:

    • Qué KeyError Python normalmente significa
    • Dónde más puede ver un KeyError en la biblioteca estándar
    • Como manejar un KeyError cuando lo ves
    • Bono

    gratuito: Haga clic aquí para obtener nuestro libre Hoja de trucos Python que le muestra los conceptos básicos de Python 3, como trabajar con tipos de datos, diccionarios, listas y funciones de Python.

    Qué excepción Python KeyError por lo general significa

    Un KeyError Python es lo que se genera cuando se intenta acceder a una clave que no se encuentra en un diccionario (dict). documentación oficial de Python

    dice que el KeyError se eleva cuando se accede a una asignación de teclas y no se encuentra en el mapeo. Un mapeo es una estructura de datos que se asigna un conjunto de valores a otro. El mapeo más común en Python es el diccionario.

    El KeyError Python es un tipo de excepción y LookupError denota que no era una cuestión de recuperar la clave que estaba buscando. Cuando vea un KeyError, el significado semántico es que la clave se buscó no se pudo encontrar.

    En el siguiente ejemplo, se puede ver un diccionario (edades) se define con las edades de tres personas. Al intentar acceder a una clave que no está en el diccionario, un KeyError se eleva:

    >>> ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    >>> ages['Michael']
    Traceback (most recent call last):
    File "", line 1, in
    KeyError: 'Michael'

    Aquí, el intento de acceder a la clave ‘Michael’ en las edades resultados del diccionario en un KeyError siendo criados. En la parte inferior del rastreo, se obtiene la información relevante:

    • El hecho de que un KeyError se elevó
    • La llave que no se pudo encontrar, que era ‘Michael’

    La segunda a la última línea dice que la línea que produce la excepción. Esta información es más útil cuando se ejecuta el código Python desde un archivo.

    Nota: Cuando se produce una excepción en Python, que se realiza con un rastreo . El rastreo le da toda la información relevante para poder determinar por qué la excepción fue levantado y lo que lo causó.

    aprender a leer una retraza de Python y la comprensión de lo que está diciendo es crucial para mejorar como programador de Python.

    En el siguiente programa, se puede ver las edades diccionario definido de nuevo. Esta vez, se le pedirá que proporcione el nombre de la persona para recuperar la edad para:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5 print(f'{person} is {ages[person]} years old.')

    Este código se tome el nombre que proporciona en el indicador y el intento de recuperar la edad para esa persona. Lo que se teclea en el indicador de se utilizará como clave para las edades de diccionario, en la línea 4.

    Repitiendo el ejemplo no desde arriba, obtenemos otra de rastreo, esta vez con información acerca de la línea en el archivo que el KeyError es resucitado de entre:

    $ python ages.py
    Get age for: Michael
    Traceback (most recent call last):
    File "ages.py", line 4, in
    print(f'{person} is {ages[person]} years old.')
    KeyError: 'Michael'

    el programa falla cuando se le da una llave que no está en el diccionario. Aquí, últimas líneas del rastreo apuntan al problema. Archivo «ages.py», línea 4, en le indica qué línea de qué archivo produce la excepción KeyError resultante. A continuación, se muestran esa línea. Por último, la excepción KeyError proporciona la clave que falta.

    Así se puede ver que la última línea del rastreo KeyError no le da suficiente información sobre su cuenta, pero las líneas antes de que se puede obtener mucho más cerca de la comprensión de lo que salió mal.

    Nota: Al igual que el ejemplo anterior, la mayoría de los otros ejemplos en este tutorial de hacer uso de aviones F-cuerdas, que se introdujeron en Python 3.6.

    ¿Dónde más puede ver un KeyError Python en la Norma Biblioteca

    La gran mayoría de las veces, un KeyError Python se eleva debido a una clave no se encuentra en un diccionario o una subclase diccionario (como os.environ).

    En casos raros, también se puede ver que se crió en otros lugares en la biblioteca estándar de Python, como en el módulo de archivo zip, si un artículo no se encuentra en un archivo ZIP. Sin embargo, estos lugares conservan el mismo significado semántico de la KeyError Python, que no está encontrando la clave solicitada.

    En el siguiente ejemplo, se puede ver utilizando la clase zipfile.ZipFile para extraer información acerca de un archivo ZIP usando .getinfo ():

    >>> from zipfile import ZipFile
    >>> zip_file = ZipFile('the_zip_file.zip')
    >>> zip_file.getinfo('something')
    Traceback (most recent call last):
    File "", line 1, in
    File "/patho/python/installation/zipfile.py", line 1304, in getinfo
    'There is no item named %r in the archive' % name)
    KeyError: "There is no item named 'something' in the archive"

    Esto no parece realmente una búsqueda clave de diccionario. En su lugar, se trata de una llamada a zipfile.ZipFile.getinfo () que plantea la excepción.

    El rastreo también se ve un poco diferente con un poco más de información dado que sólo la clave que falta: KeyError: «No hay ningún elemento denominado ‘algo’ en el archivo».

    La última cosa a tener en cuenta es que la línea que planteó la KeyError no está en su código. Es en el código zip, pero las líneas anteriores del rastreo indica qué líneas en el código de la causa del problema.

    cuando se necesita para criar a un KeyError Python en su propio código

    Puede haber momentos en los que tiene sentido traer a colación una excepción de Python KeyError en su propio código. Esto se puede hacer mediante el uso de la palabra clave aumento y llamando la excepción KeyError:

    raise KeyError(message)

    Por lo general, el mensaje sería la clave que falta. Sin embargo, como en el caso del paquete zip, se puede optar por darle un poco más de información para ayudar a la próxima desarrollador a entender mejor lo que salió mal.

    Si deciden criar a un KeyError Pitón en su propio código, simplemente asegúrese de que su caso de uso coincide con el significado semántico detrás de la excepción. Cabe indicar que la clave se buscó no se pudo encontrar.

    Cómo manejar un KeyError Python cuando lo ves

    cuando se encuentra con un KeyError, hay algunas formas estándar para manejarlo. Dependiendo de su caso de uso, algunas de estas soluciones podría ser mejor que los demás. El objetivo final es dejar de excepciones KeyError inesperados de ser levantada.

    La solución habitual: .get ()

    Si el KeyError se eleva desde una búsqueda de claves diccionario fracasado en su propio código, se puede utilizar .get () para devolver el valor ya sea encontrar en la clave especificada o un valor predeterminado.

    Al igual que el ejemplo de recuperación de la edad de antes, el siguiente ejemplo muestra una mejor manera de obtener la edad del diccionario utilizando la clave proporcionada en el indicador:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5 age = ages.get(person)
    6
    7 if age:
    8 print(f'{person} is {age} years old.')
    9 else:
    10 print(f"{person}'s age is unknown.")

    Aquí, la línea 5 muestra cómo se puede obtener el valor de la edad de las edades usando .get (). Esto dará lugar a la variable edad que tenga el valor de edad encontrado en el diccionario de la llave suministrada o un valor predeterminado, Nada en este caso.

    Esta vez, no se obtiene una excepción KeyError elevada debido a la utilización del método más seguro .get () para obtener la edad en lugar de intentar acceder a la clave directamente:

    $ python ages.py
    Get age for: Michael
    Michael's age is unknown.

    En la ejecución ejemplo anterior, el KeyError está ya no se levantó cuando se proporciona una mala llave. La clave ‘Michael’ no se encuentra en el diccionario, pero mediante el uso de .get (), obtenemos una Ninguno regresó en lugar de un KeyError elevada.

    La variable edad, o bien tener la edad de la persona encontraron en el diccionario o el valor por defecto (por defecto ninguno). También puede especificar un valor predeterminado diferente en la llamada .get () pasando un segundo argumento.

    Se trata de la línea 5 del ejemplo anterior con una edad predeterminada diferente especificado utilizando .get ():

    age = ages.get(person, 0)

    Aquí, en lugar de ‘Michael’ Ninguno de regresar, volvería 0 porque no se encuentra la clave y el valor predeterminado valor de retorno es 0. ahora

    la solución Raras: Comprobación de llaves

    Hay momentos en que es necesario determinar la existencia de una clave en un diccionario. En estos casos, el uso de .get () no le puede dar la información correcta. Conseguir una Ninguno de regresar de una llamada a .get () podría significar que la clave no se ha encontrado o que el valor encontrado en la clave del diccionario es en realidad Ninguno.

    Con un diccionario o un diccionario-como objeto, puede utilizar el operador in para determinar si una llave está en la asignación. Este operador devuelve un valor booleano (verdadero o falso) que indica si la clave se encuentra en el diccionario.

    En este ejemplo, que está recibiendo un diccionario respuesta de llamar a una API. Esta respuesta podría tener un valor de clave de error definido en la respuesta, lo que indicaría que la respuesta está en un estado de error:

    1 # parse_api_response.py
    2 ...
    3 # Assuming you got a `response` from calling an API that might
    4 # have an error key in the `response` if something went wrong
    5
    6 if 'error' in response:
    7 ... # Parse the error state
    8 else:
    9 ... # Parse the success state

    Aquí, hay una diferencia en la comprobación para ver si existe la clave de error en la respuesta y la obtención de un valor predeterminado el valor de la clave. Este es un caso raro donde lo que en realidad se está buscando es si la clave está en el diccionario y no lo que el valor en esa clave es.

    la solución general: try excepto

    Al igual que con alguna excepción, siempre se puede utilizar la prueba, excepto el bloque para aislar el código de excepción potencial de sensibilización y proporcionar una solución de copia de seguridad.

    Puede utilizar el intento, excepto bloque en un ejemplo similar al anterior, pero esta vez proporcionar un mensaje predeterminado a imprimir se debe levantar un KeyError en el caso normal:

    1 # ages.py
    2
    3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
    4 person = input('Get age for: ')
    5
    6 try:
    7 print(f'{person} is {ages[person]} years old.')
    8 except KeyError:
    9 print(f"{person}'s age is unknown.")

    Aquí, se puede ver el caso normal en el intento bloquear la impresión del nombre y la edad de la persona. El caso de copia de seguridad se encuentra en el bloque de excepción, en el que si un KeyError se eleva en el caso normal, entonces el caso de copia de seguridad es imprimir un mensaje diferente.

    El intento excepto solución de bloqueo es también una gran solución para otros lugares que no sean compatibles con .get () o el operador in. También es la mejor solución si el KeyError está siendo levantado de código de otra persona.

    Aquí hay un ejemplo usando el paquete zip de nuevo. Esta vez, el intento excepto bloque nos da una manera de detener la excepción KeyError de detener el programa:

    >>> from zipfile import ZipFile
    >>> zip = ZipFile('the_zip_file.zip')
    >>> try:
    ... zip.getinfo('something')
    ... except KeyError:
    ... print('Can not find "something"')
    ...
    Can not find "something"

    Puesto que la clase ZipFile no proporciona .get (), al igual que lo hace el diccionario, es necesario utilizar el try excepto solución. En este caso, usted no tiene que saber de antemano qué valores son válidos para pasar a .getinfo ().

    Conclusión

    Ahora ya sabe algunos lugares comunes donde excepción KeyError de Python podría elevarse y algunos grandes soluciones que puede utilizar para evitar que se detenga su programa.

    Ahora, la próxima vez que vea un KeyError levantó, se sabrá que es probable que sea sólo un mal diccionario de búsqueda de claves. También podrá encontrar toda la información que necesita para determinar dónde viene el error de mirar las últimas líneas de la traza.

    Si el problema es una búsqueda de clave de diccionario en su propio código, a continuación, puede cambiar el acceso a la clave directamente en el diccionario a usar el método más seguro .get () con un valor de retorno por defecto. Si el problema no viene de su propio código, a continuación, utilizando la prueba, excepto bloque es la mejor opción para controlar el flujo de su código. Excepciones

    no tienen que dar miedo. Una vez que sepa cómo entender la información proporcionada a usted en sus rastreos y la causa de la excepción, entonces usted puede utilizar estas soluciones para hacer sus programas de flujo más predecible.

    Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Excepciones Python KeyError y forma de abordarlos

    Categorías
    Python

    Sin cabeza Pruebas de selenio con Python y PhantomJS

     

    Esta semana, me acompañan Bob Belderbos y Julián Sequeira de PyBites fama. Bob es un desarrollador de software de Oracle, España. Julian es un Centro de Datos Technician en Amazon Web Services, en Australia.

    Únase a nosotros para discutir cómo PyBites se inició y lo que tienen en el almacén para su futuro. También veremos en el amor secreto de Bob del dibujo y el amor no tan secreto de Julian de una buena pinta.

    Ricky: Bienvenido, Bob y Julian! O se trata de Julian y Bob? En cualquier caso, gracias por acompañarme en esta entrevista. Vamos a empezar con las primeras preguntas habituales. ¿Cómo se obtiene en la programación? ¿Cuándo comenzó a usar Python?

    Julian: preferimos ir por “booleano”. En realidad no, pero vamos a hacer que se pegue.

    Me picaron por primera vez por el error de programación (nunca mejor dicho!) En la secundaria, pero en realidad se sumergió en la codificación a finales de 2015.

    que necesitaba una manera de rastrear las horas extraordinarias que estaba en la hora en mi papel de Ingeniero de Campo en Oracle a asegurarse de que estaba siendo pagado correctamente. Introduzca Python (en la recomendación de Bob).

    Me hice un tiempo extra de seguimiento de la CLI que formaba parte de un sistema de menús rudimentaria con opciones simples para calcular mi después de impuestos pago de horas extras. Era básico, funcionaba un lujo, y me enganchó en Python.

    Consejo: Son los casos de uso del mundo real que hacen que el palo de aprendizaje!

    La velocidad y simplicidad de Python en comparación con mis días de escuela secundaria usando C ++ me enganchó. Entonces empezamos PyBites y el pitón conseguimos real. ( real del pitón , lo consigue?)

    Bob: Para mí, todo comenzó en Sun Microsystems en 2009. Me movió en el grupo de apoyo Sistemas y encontró un nicho para desarrollar una aplicación web para analizar salidas de diagnóstico, de los que estaban recibiendo miles de personas cada mes. Esto se convirtió en una herramienta de primera necesidad para la organización de soporte, ahorrando muchas horas de trabajo tedioso cada día.

    Esta herramienta de diagnóstico era una mezcla salvaje de scripting shell (bash / sed / awk), Perl, PHP, y algunos jQuery. La empresa decidió pasar a la automatización completa de las solicitudes de servicio, para el que escribió un nuevo marco en Perl, que pronto se convirtió en una pesadilla para el mantenimiento, así que empecé a buscar otras soluciones.

    Esto fue en 2012. Me encontré con Python y empecé a aprenderlo. Fue amor a primera vista: con su diseño limpio y elegante (tipo de importación esto en su REPL ), la falta de aparatos ortopédicos y otros C-como sintaxis, sólo se lee como Inglés! Es muy sencillo de aprender los conceptos básicos de Python, sin embargo, bajo las sábanas, es muy versátil.

    Hay un gran artículo de Eric Raymond en Linux Journal titulado Por qué Python? , que describe su revelación cuando él cambió de Perl a Python.

    he experimentado algo similar. Después de una reescritura rápida de la estructura de automatización en Python, se hizo relativamente “fácil” de hacer cambios, y lo amplió con muchas nuevas e interesantes características, todo ello sin grandes dolores de cabeza. A pesar de que la transición en otro papel, la solución todavía se mantiene activa. Desde entonces, he tenido la suerte de usar Python para casi todo mi trabajo.

    Ricky: que ambos estén más famoso (para mejor o peor) por ser los co-fundadores de PyBites. Para aquellos que no saben acerca de PyBites, lo que es, y cómo se empezar?

    de Boole: PyBites simplemente comenzó como un simple blog para compartir lo que estábamos aprendiendo en el espacio de Python. (Se utiliza un generador de sitio estático llamado Pelican). Estábamos dispuestos a empujar a nosotros mismos más allá de simplemente leer libros y ver vídeos. Escribir entradas de blog que nos hizo muy profunda de buceo para asegurarse de que estábamos comunicando los conceptos adecuados.

    Poco después de su creación, que comenzó a probar algunas ideas. Una era la de retarnos a nosotros mismos, como inspirados por el desafío de café de Noé Kagan. Así que un día Bob se acercó con un ejercicio de Python para que resolvamos por el final de la semana.

    Encontramos una página del curso JavaScript en mm: ss tiempos por vídeo, pero no la duración total. La tarea consistía en raspar el sitio y sumar todas las marcas de tiempo de vídeo, el cálculo de la duración total del curso.

    Al final de la semana (Sprint), comparamos nuestras soluciones y retrospected en nuestros aprendizajes. Hemos tenido este “club de la lucha momento” (quizás no tan violenta …) de “debemos hacer esto de nuevo en algún momento”, y así es como nuestro código blog / comunidad desafía línea nació.

    Nos miramos a GitHub, configure una Repo retos para nosotros publicamos nuestros retos y soluciones para, y luego creó una rama separada de la comunidad que los demás tirar de solicitar a su trabajo.

    La tracción que ganamos de esta provocó la idea de que se convirtió en nuestra plataforma de codificación: CodeChalleng.es. Se compone de una creciente colección de casi 200 ejercicios de Python (llamado mordeduras de Py ), que se puede codificar en la comodidad de su navegador.

    Otra gran cosa para nosotros estaba completando el # 100DaysOfCode desafío, que compartimos activamente en nuestro blog y las redes sociales. Esto hizo que nos entrevistamos en el podcast Talk Python y, a su vez, nos llevó a producir el # 100DaysOfCode en Python por supuesto, junto con Michael Kennedy.

    Una lección importante para nosotros aquí es que sólo tiene que empezar y perfeccionismo gota. Un montón de cosas increíbles que sucedió no fue planeado, pero vino a nosotros porque hemos puesto algo por ahí que el interés generado, y actuamos sobre la valiosa información que recibimos en el proceso!

    Ricky: Julian, usted no es un programador de día, y que funciona como un centro de datos de Técnico en Servicios Web de Amazon. ¿Cómo ha estado aprendiendo a código junto a alguien tan logrado como Bob? Yo supongo que ayudaría tener a alguien más experimentado como su socio de negocios? ¿Hay algo que usted fue sorprendido por o que se encuentran difícil como usted aprendió a código?

    Julian: brecha El Pythonic entre Bob y me ha sido la piedra angular de PyBites. De hecho, es lo que nos dimos daría a nuestro blog un giro único!

    A tal fin, ha sido un poco de una mezcla. Cuando el código junto a alguien tan capaz como Bob, la primera sensación es la de asombro. Usted ve la elegancia de su código y su capacidad para resolver problemas que ha pasado horas en adelante, en cuestión de momentos. Es realmente inspirador!

    Pero no siempre. Se hace más fácil caer en la trampa síndrome impostor:

    • “Es mi código cada vez va a ser tan bueno?”
    • “¿Por qué me molesto?”
    • “Sólo está siempre va a ser mejor!”

    La realidad es que siempre va a haber alguien mejor cuando se trata de código, y la vida en general! Aprendí rápidamente que en lugar de centrarse en el vacío de habilidades, que debería estar centrado en mi propio código, siendo orgulloso de mis logros, y abrazando lo que aportan a la mesa.

    suficiente Curiosamente, y esto se aplica a ambos, las dificultades que golpeó con el aprendizaje y la gestión de código eran insignificantes. Es decir, lo aceptamos y nos encanta. (Digo esto ahora, pero nunca en el momento!)

    La parte difícil es sorprendente ha sido el lado del negocio real de PyBites! También voy a añadir que mis días de no ser un codificador profesional puede estar llegando a su fin! ( Shhh !)

    Ricky: Bob, en sus propias palabras, cuando se está “no esta trabajando duro para el hombre” en su trabajo diario, que amas a proyectos pequeños ajustes y construir en su tiempo libre. ¿Qué tipo de proyectos tiene usted sobre la marcha actualmente?

    Bob: Actualmente, casi todo mi tiempo se va a producir el contenido del curso y la mejora de nuestra plataforma mediante la adición de más ejercicios y características. Con un mayor uso, hay más preguntas y comentarios / solicitudes, pero disfrutar de cada minuto de ella, ya que proporciona una gran manera de enseñar y guiar a Python otros desarrolladores, algo que realmente disfruto.

    También estoy tomando la especialización Coursera Ciencias Aplicadas de datos porque amo datos y desea integrar esta más en mi trabajo del día a día.

    Cuando esto y nuestro próximo curso ( suspenso … ) se lleva a cabo, mi flujo de trabajo predeterminado seguirá siendo similar:

    Es lo que me apasiona y se suma a PyBites’ creciente cuerpo de contenido.

    Esto es realmente algo que recomiendo para cualquier programador / dev. CV son legado. Comience a construir su blog / GitHub / marca para que tenga una cartera puede mostrar. También le permite a la reutilización lo que se genera para los proyectos futuros, y es una gran manera de la red / colaborar con los demás.

    Ricky: obvio que tanto la parte del Es el gen empresarial. (Usted sólo tiene que mirar en el estante de Bob para ver la evidencia.) ¿Cuál ha sido la parte más difícil o más difícil para usted con iniciar su propio negocio / lateral prisa (PyBites)? ¿Se encuentra sus respectivos talentos se compensan entre sí?

    booleanas: Sin duda la parte más difícil ha estado manejando nuestras prioridades.

    Las prioridades clave tanto de nuestras vidas resultan ser muy similares:

    • Familia / niños
    • completa Tiempo trabajos del día
    • aprendizaje
    • PyBites

    Como PyBites crece, también lo hace la inversión de tiempo requerido. No podemos tomar ese tiempo lejos de nuestros trabajos del día o nuestras familias, por lo que definitivamente ha sido el mayor obstáculo tratando de encontrar un equilibrio aceptable.

    La perspectiva que hemos adoptado es que “si tenemos tiempo para ver Netflix, entonces tenemos tiempo para trabajar en PyBites.”

    Con ese fin, más a menudo que no, que conscientemente tomar la decisión de no ver la televisión, jugar juegos, o salir, y hacer que el tiempo nuestro tiempo PyBites. No suena como mucho, pero después de un largo día de trabajo y llevar a los niños a la cama, vuelve a ponerse en las herramientas para trabajar en PyBites puede ser extremadamente difícil!

    Dicho esto, decimos abiertamente a quien quiera oírla que no estaríamos donde estamos sin nuestro apoyo mutuo de unos a otros.

    Si usted está tomando en todo lo que vale la pena, entonces se consigue un socio de la responsabilidad. Llevamos a cabo mutuamente responsables de los artículos que adquieren y construir uno al otro cuando las cosas no salen exactamente nuestro camino.

    Nuestros diferentes talentos más definitivamente se compensan entre sí. Julian tiende a ser más del escritor, narrador, vendedor, gerente de negocios, y “boca”, mientras que Bob empuja profundamente en código, construye y mantiene las herramientas, tiene ideas increíbles, y apoya a la comunidad técnica. La combinación de estos dos conjuntos de talento, y tiene una máquina bien engrasada PyBites.

    La mejor parte (y siendo fiel a nuestra creencia fundamental de que se aprende haciendo) es que aprender unos de otros. Empujamos mutuamente para mejorar de forma continua, a vivir fuera de la caja, y siempre probar algo nuevo.

    Ricky: Ahora para mi última pregunta. ¿Qué más se puede conseguir hasta en su tiempo libre? ¿Qué otras aficiones e intereses tiene usted, aparte de Python y codificación?

    Bob: Jaja Python y la codificación es una gran parte, pero fuera de eso me encanta cada minuto que puedo pasar con mi esposa y dos hijos.

    También estoy interesado en seguir una rutina de ejercicios diaria, especialmente en lo que nuestro trabajo requiere mucho tiempo de estar y la pantalla! Me encanta leer libros y consumir podcasts. Cuando más tiempo libre, el aprendizaje de idiomas y el dibujo son otras dos cosas que realmente me gustan.

    Julian: bien, cortar la codificación y Python, uf!

    Al igual que Bob, la prioridad es pasar tiempo con mi esposa y dos niños también. Cualquier persona con niños pequeños sabrá que realmente no tiene mucho tiempo después de que haya terminado quitar el polvo, así que el tiempo manía se limita en estos días.

    Cuando hago tomar unos minutos raras, no PyBites, me encanta tocar la guitarra eléctrica, juego videojuegos, leer y jugar con mi Frambuesa Pi y domótica.

    Además, siendo la mariposa social que soy, me encanta pasar el rato con amigos y disfrutar de unas cervezas. Me llegar a un pub, me gritar un buen Pilsner, y voy a ser su mejor amigo!

    (Espera un segundo. Did Bob acaba de decir que le gusta dibujar?)

    Ricky ¿Hay proyectos que desea compartir con nuestros lectores? ¿Dónde podemos encontrar más información acerca de ustedes y lo que está haciendo?

    de Boole: Aparte del blog, nuestro orgullo y alegría es nuestra actual plataforma de Python ejercicios de codificación en línea.

    También creó el # 100DaysOfCode en el curso de Python con Michael Kennedy y se han convertido en formadores en el Talk Python plataforma de formación a mí . Una vez más, algo que estamos muy orgullosos. (Más por venir en este espacio!)

    Puede encontrar y seguir Julian en los lugares oscuros a continuación:

    • Twitter: @_juliansequeira
    • LinkedIn: https://www.linkedin.com/in/juliansequeira/
    • Udemy: yo también creó un frasco curso de introducción en Udemy! el blog
    • personal: https://www.techmoneykids.com/

    Bob:

    • Twitter: @bbelderbos
    • LinkedIn: https://www.linkedin.com/in/bbelderbos/
    • Personal blog: https://bobbelderbos.com

    Gracias Julian y Bob para una entrevista el entretenimiento. Si usted no ha obtenido PyBites últimamente, a continuación, le animo a hacerlo. Si tienes a alguien que le gustaría que yo entrevista como parte de esta serie, a continuación, dejar un comentario más abajo. codificación feliz!

    Categorías
    Python

    Entrevista comunidad Python con Mike Driscoll

     

    Tabla de Contenidos

    • Introducción
    • Prueba del Mock API
    • Prueba

    • un servicio que llega a las API Pruebas
    • Skipping que afectó a la real API
    • próximos pasos

    A pesar de ser tan útil, APIs externas pueden ser un dolor de prueba. Al llegar a una API real, las pruebas están a merced del servidor externo, lo que puede dar lugar a los siguientes puntos de dolor:

    • El ciclo de solicitud-respuesta puede tardar varios segundos. Esto puede no parecer mucho al principio, pero los compuestos de tiempo con cada prueba. Imagínese llamar a una API 10, 50, o incluso 100 veces cuando se prueba toda su aplicación.
    • La API puede haber límites de ritmo establecido.
    • El servidor API puede ser inalcanzable. Puede que el servidor está en mantenimiento? Tal vez con un error y el equipo de desarrollo está trabajando para conseguir de nuevo funcional> ¿Realmente desea el éxito de sus pruebas a depender de la salud de un servidor que no controlas?

    Sus pruebas no deben evaluar si un servidor API se está ejecutando; deberían probar si su código está funcionando como se esperaba.

    En el tutorial anterior, se introdujo el concepto de objetos simulados, demostró cómo se podía utilizar para el código de prueba que interactúa con las API externas. Este tutorial se basa en los mismos temas, pero aquí se puede caminar a través de la forma de construir realmente un servidor simulacro en lugar de burlarse de las API. Con un servidor maqueta en su lugar, se pueden realizar pruebas de extremo a extremo. Puede utilizar la aplicación y obtener retroalimentación real desde el servidor simulacro en tiempo real.

    Cuando termine de trabajar a través de los siguientes ejemplos, se han programado un simulacro de servidor básico y dos pruebas – uno que utiliza el servidor API real y uno que utiliza el servidor simulado. Ambas pruebas tendrán acceso al mismo servicio, una API que recupera una lista de usuarios.

    NOTA: Este tutorial usa Python v3.5.1.

    Introducción

    Inicio siguiendo la sección de primeros pasos de la entrada anterior. O agarrar el código desde el repositorio. Asegúrese de que los pases de prueba antes de pasar:

    $ nosetests --verbosity=2 project
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 1 test in 1.029s

    OK
    Prueba

    el Mock API

    Con la puesta en marcha completa, puede programar su servidor simulado. Escribir una prueba que describe el comportamiento: Proyecto

    / pruebas / test_mock_server.py

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    def test_request_response():
    url = 'http://localhost:{port}/users'.format(port=mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    assert_true(response.ok)

    Aviso que comienza mirando casi idéntica a la prueba API real. La URL ha cambiado y ahora está apuntando a un punto final de la API en localhost donde el servidor simulacro se ejecutará.

    Aquí es cómo crear un servidor de simulacro en Python: Proyecto

    / pruebas / test_mock_server.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import socket
    from threading import Thread

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
    # Process an HTTP GET request and return a response with an HTTP 200 status.
    self.send_response(requests.codes.ok)
    self.end_headers()
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    # Configure mock server.
    cls.mock_server_port = get_free_port()
    cls.mock_server = HTTPServer(('localhost', cls.mock_server_port), MockServerRequestHandler)

    # Start running mock server in a separate thread.
    # Daemon threads automatically shut down when the main process exits.
    cls.mock_server_thread = Thread(target=cls.mock_server.serve_forever)
    cls.mock_server_thread.setDaemon(True)
    cls.mock_server_thread.start()

    def test_request_response(self):
    url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    print(response)
    assert_true(response.ok)

    En primer lugar, crear una subclase de BaseHTTPRequestHandler. Esta clase captura la petición y construye la respuesta al cambio. Reemplazar la función do_GET () para elaborar la respuesta para una solicitud HTTP GET. En este caso, basta con devolver un estado OK. A continuación, escribir una función para obtener un número de puerto disponible para el servidor simulacro de uso.

    El siguiente bloque de código en realidad configura el servidor. Aviso cómo el código crea una instancia HTTPServer y lo pasa un número de puerto y un controlador. A continuación, crear un hilo, para que el servidor se puede ejecutar de forma asincrónica y el hilo principal del programa puede comunicarse con él. Hacer que el hilo de un demonio, que le dice al hilo de parada cuando las principales salidas del programa. Por último, iniciar el hilo para servir al servidor de simulacro para siempre (hasta que terminen las pruebas).

    Crear una clase de prueba y mover la función de prueba a la misma. Debe añadir un método adicional para garantizar que el servidor simulacro se puso en marcha antes que cualquiera de las pruebas realizadas. Tenga en cuenta que este nuevo código vive dentro de una función especial a nivel de clase, setup_class ().

    Ejecute las pruebas y verlos pasar:

    $ nosetests --verbosity=2 project

    a probar un servicio que llega a la API

    Es posible que desee llamar a más de un punto final de la API en su código. A medida que el diseño de su aplicación, es probable que crear funciones de servicio para enviar peticiones a una API y luego procesar las respuestas de alguna manera. Tal vez va a almacenar los datos de respuesta en una base de datos. O se pasa los datos a una interfaz de usuario.

    Refactor su código para tirar de la URL base API hardcoded en una constante. Añadir esta variable a un archivo constants.py : Proyecto

    / constants.py

    BASE_URL = 'http://jsonplaceholder.typicode.com'

    A continuación, encapsulan la lógica para recuperar los usuarios de la API en una función. Aviso cómo las nuevas direcciones URL puede ser creado por unirse a una ruta URL a la base.

    proyecto / services.py

    # Standard library imports...
    from urllib.parse import urljoin

    # Third-party imports...
    import requests

    # Local imports...
    from project.constants import BASE_URL

    USERS_URL = urljoin(BASE_URL, 'users')

    def get_users():
    response = requests.get(USERS_URL)
    if response.ok:
    return response
    else:
    return None

    Mover el código del servidor maqueta del archivo de función para un nuevo archivo de Python, por lo que fácilmente se puede reutilizar. Añadir lógica condicional para el controlador de solicitudes para comprobar qué API punto final de la petición HTTP es la orientación. Reforzar la respuesta mediante la adición de un poco de información de cabecera y una carga útil sencilla respuesta básica. La creación del servidor y puntapié inicial de código se pueden encapsular en un método de conveniencia, start_mock_server (). proyecto

    / pruebas / mocks.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import json
    import re
    import socket
    from threading import Thread

    # Third-party imports...
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    USERS_PATTERN = re.compile(r'/users')

    def do_GET(self):
    if re.search(self.USERS_PATTERN, self.path):
    # Add response status code.
    self.send_response(requests.codes.ok)

    # Add response headers.
    self.send_header('Content-Type', 'application/json; charset=utf-8')
    self.end_headers()

    # Add response content.
    response_content = json.dumps([])
    self.wfile.write(response_content.encode('utf-8'))
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    def start_mock_server(port):
    mock_server = HTTPServer(('localhost', port), MockServerRequestHandler)
    mock_server_thread = Thread(target=mock_server.serve_forever)
    mock_server_thread.setDaemon(True)
    mock_server_thread.start()

    Con los cambios en la lógica completado, alteran las pruebas a utilizar la nueva función de servicio. Actualizar las pruebas para comprobar el aumento de la información que se pasa de nuevo desde el servidor. proyecto

    / pruebas / test_real_server.py proyecto

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.services import get_users

    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    / pruebas / test_mock_server.py

    # Third-party imports...
    from unittest.mock import patch
    from nose.tools import assert_dict_contains_subset, assert_list_equal, assert_true

    # Local imports...
    from project.services import get_users
    from project.tests.mocks import get_free_port, start_mock_server

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    cls.mock_server_port = get_free_port()
    start_mock_server(cls.mock_server_port)

    def test_request_response(self):
    mock_users_url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Patch USERS_URL so that the service uses the mock server URL instead of the real URL.
    with patch.dict('project.services.__dict__', {'USERS_URL': mock_users_url}):
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_list_equal(response.json(), [])

    Aviso una nueva técnica que se utiliza en el test_ simulacro _server.py código. La línea de respuesta = get_users () se envuelve con una función patch.dict () de la biblioteca mock .

    ¿Qué hace esta afirmación?

    Recuerde, ha movido la función requests.get () de la lógica de función para los get_users función de servicio (). Internamente, get_users () llama requests.get () utilizando la variable USERS_URL. La función patch.dict () reemplaza temporalmente el valor de la variable USERS_URL. De hecho, lo hace sólo en el ámbito de la sentencia with. Después de que las carreras de código, la variable USERS_URL se restaura a su valor original. Este código parches la URL a utilizar la dirección del servidor simulado.

    Ejecutar las pruebas y los ven pasar.

    $ nosetests --verbosity=2
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:45:30] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... ok
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 0.871s

    OK

    Saltarse Pruebas de que afectó a la API real

    Comenzamos este tutorial que describe los méritos de la prueba de un servidor de simulacro en lugar de uno real, sin embargo, su código prueba actualmente ambos. ¿Cómo se configura las pruebas de ignorar el servidor real? La biblioteca de Python ‘unittest’ ofrece varias funciones que le permiten saltarse las pruebas. Puede utilizar la función de salto condicional ‘skipIf’ junto con una variable de entorno para alternar las pruebas de servidores reales dentro y fuera. En el siguiente ejemplo, se pasa un nombre de etiqueta que debe ser ignorado:

    $ export SKIP_TAGS=real

    proyecto / constants.py proyecto

    # Standard-library imports...
    import os

    BASE_URL = 'http://jsonplaceholder.typicode.com'
    SKIP_TAGS = os.getenv('SKIP_TAGS', '').split()

    / pruebas / test_real_server.py

    # Standard library imports...
    from unittest import skipIf

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.constants import SKIP_TAGS
    from project.services import get_users

    @skipIf('real' in SKIP_TAGS, 'Skipping tests that hit the real API server.')
    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    ejecutar las pruebas y prestar atención a cómo el verdadero prueba del servidor se ignora:

    $ nosetests --verbosity=2 project
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:52:18] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... SKIP: Skipping tests that hit the real API server.
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 1.196s

    OK (SKIP=1)

    próximos pasos

    Ahora que ha creado un servidor de simulacro para probar sus llamadas a la API externos, puede aplicar este conocimiento a sus propios proyectos. Construir sobre las pruebas simples creadas aquí. Ampliar la funcionalidad del controlador para imitar el comportamiento de la API reales más de cerca.

    Pruebe los siguientes ejercicios para subir de nivel:

    • devolver una respuesta con un estado de HTTP 404 (no encontrado) si se envía una petición con una ruta desconocida.
    • devolver una respuesta con un estado de HTTP 405 (Método no permitido) si se envía una solicitud con un método que no está permitido (POST, DELETE, UPDATE). datos de usuario real
    • cambio de una solicitud válida a / usuarios.
    • escribir pruebas para capturar esos escenarios.

    Coge el código desde el repositorio.

    Categorías
    Python

    Generación de datos aleatorios en Python (Guía)

     

    Tabla de Contenidos

    • Introducción
    • Prueba del Mock API
    • Prueba

    • un servicio que llega a las API Pruebas
    • Skipping que afectó a la real API
    • próximos pasos

    A pesar de ser tan útil, APIs externas pueden ser un dolor de prueba. Al llegar a una API real, las pruebas están a merced del servidor externo, lo que puede dar lugar a los siguientes puntos de dolor:

    • El ciclo de solicitud-respuesta puede tardar varios segundos. Esto puede no parecer mucho al principio, pero los compuestos de tiempo con cada prueba. Imagínese llamar a una API 10, 50, o incluso 100 veces cuando se prueba toda su aplicación.
    • La API puede haber límites de ritmo establecido.
    • El servidor API puede ser inalcanzable. Puede que el servidor está en mantenimiento? Tal vez con un error y el equipo de desarrollo está trabajando para conseguir de nuevo funcional> ¿Realmente desea el éxito de sus pruebas a depender de la salud de un servidor que no controlas?

    Sus pruebas no deben evaluar si un servidor API se está ejecutando; deberían probar si su código está funcionando como se esperaba.

    En el tutorial anterior, se introdujo el concepto de objetos simulados, demostró cómo se podía utilizar para el código de prueba que interactúa con las API externas. Este tutorial se basa en los mismos temas, pero aquí se puede caminar a través de la forma de construir realmente un servidor simulacro en lugar de burlarse de las API. Con un servidor maqueta en su lugar, se pueden realizar pruebas de extremo a extremo. Puede utilizar la aplicación y obtener retroalimentación real desde el servidor simulacro en tiempo real.

    Cuando termine de trabajar a través de los siguientes ejemplos, se han programado un simulacro de servidor básico y dos pruebas – uno que utiliza el servidor API real y uno que utiliza el servidor simulado. Ambas pruebas tendrán acceso al mismo servicio, una API que recupera una lista de usuarios.

    NOTA: Este tutorial usa Python v3.5.1.

    Introducción

    Inicio siguiendo la sección de primeros pasos de la entrada anterior. O agarrar el código desde el repositorio. Asegúrese de que los pases de prueba antes de pasar:

    $ nosetests --verbosity=2 project
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 1 test in 1.029s

    OK
    Prueba

    el Mock API

    Con la puesta en marcha completa, puede programar su servidor simulado. Escribir una prueba que describe el comportamiento: Proyecto

    / pruebas / test_mock_server.py

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    def test_request_response():
    url = 'http://localhost:{port}/users'.format(port=mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    assert_true(response.ok)

    Aviso que comienza mirando casi idéntica a la prueba API real. La URL ha cambiado y ahora está apuntando a un punto final de la API en localhost donde el servidor simulacro se ejecutará.

    Aquí es cómo crear un servidor de simulacro en Python: Proyecto

    / pruebas / test_mock_server.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import socket
    from threading import Thread

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
    # Process an HTTP GET request and return a response with an HTTP 200 status.
    self.send_response(requests.codes.ok)
    self.end_headers()
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    # Configure mock server.
    cls.mock_server_port = get_free_port()
    cls.mock_server = HTTPServer(('localhost', cls.mock_server_port), MockServerRequestHandler)

    # Start running mock server in a separate thread.
    # Daemon threads automatically shut down when the main process exits.
    cls.mock_server_thread = Thread(target=cls.mock_server.serve_forever)
    cls.mock_server_thread.setDaemon(True)
    cls.mock_server_thread.start()

    def test_request_response(self):
    url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    print(response)
    assert_true(response.ok)

    En primer lugar, crear una subclase de BaseHTTPRequestHandler. Esta clase captura la petición y construye la respuesta al cambio. Reemplazar la función do_GET () para elaborar la respuesta para una solicitud HTTP GET. En este caso, basta con devolver un estado OK. A continuación, escribir una función para obtener un número de puerto disponible para el servidor simulacro de uso.

    El siguiente bloque de código en realidad configura el servidor. Aviso cómo el código crea una instancia HTTPServer y lo pasa un número de puerto y un controlador. A continuación, crear un hilo, para que el servidor se puede ejecutar de forma asincrónica y el hilo principal del programa puede comunicarse con él. Hacer que el hilo de un demonio, que le dice al hilo de parada cuando las principales salidas del programa. Por último, iniciar el hilo para servir al servidor de simulacro para siempre (hasta que terminen las pruebas).

    Crear una clase de prueba y mover la función de prueba a la misma. Debe añadir un método adicional para garantizar que el servidor simulacro se puso en marcha antes que cualquiera de las pruebas realizadas. Tenga en cuenta que este nuevo código vive dentro de una función especial a nivel de clase, setup_class ().

    Ejecute las pruebas y verlos pasar:

    $ nosetests --verbosity=2 project

    a probar un servicio que llega a la API

    Es posible que desee llamar a más de un punto final de la API en su código. A medida que el diseño de su aplicación, es probable que crear funciones de servicio para enviar peticiones a una API y luego procesar las respuestas de alguna manera. Tal vez va a almacenar los datos de respuesta en una base de datos. O se pasa los datos a una interfaz de usuario.

    Refactor su código para tirar de la URL base API hardcoded en una constante. Añadir esta variable a un archivo constants.py : Proyecto

    / constants.py

    BASE_URL = 'http://jsonplaceholder.typicode.com'

    A continuación, encapsulan la lógica para recuperar los usuarios de la API en una función. Aviso cómo las nuevas direcciones URL puede ser creado por unirse a una ruta URL a la base.

    proyecto / services.py

    # Standard library imports...
    from urllib.parse import urljoin

    # Third-party imports...
    import requests

    # Local imports...
    from project.constants import BASE_URL

    USERS_URL = urljoin(BASE_URL, 'users')

    def get_users():
    response = requests.get(USERS_URL)
    if response.ok:
    return response
    else:
    return None

    Mover el código del servidor maqueta del archivo de función para un nuevo archivo de Python, por lo que fácilmente se puede reutilizar. Añadir lógica condicional para el controlador de solicitudes para comprobar qué API punto final de la petición HTTP es la orientación. Reforzar la respuesta mediante la adición de un poco de información de cabecera y una carga útil sencilla respuesta básica. La creación del servidor y puntapié inicial de código se pueden encapsular en un método de conveniencia, start_mock_server (). proyecto

    / pruebas / mocks.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import json
    import re
    import socket
    from threading import Thread

    # Third-party imports...
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    USERS_PATTERN = re.compile(r'/users')

    def do_GET(self):
    if re.search(self.USERS_PATTERN, self.path):
    # Add response status code.
    self.send_response(requests.codes.ok)

    # Add response headers.
    self.send_header('Content-Type', 'application/json; charset=utf-8')
    self.end_headers()

    # Add response content.
    response_content = json.dumps([])
    self.wfile.write(response_content.encode('utf-8'))
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    def start_mock_server(port):
    mock_server = HTTPServer(('localhost', port), MockServerRequestHandler)
    mock_server_thread = Thread(target=mock_server.serve_forever)
    mock_server_thread.setDaemon(True)
    mock_server_thread.start()

    Con los cambios en la lógica completado, alteran las pruebas a utilizar la nueva función de servicio. Actualizar las pruebas para comprobar el aumento de la información que se pasa de nuevo desde el servidor. proyecto

    / pruebas / test_real_server.py proyecto

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.services import get_users

    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    / pruebas / test_mock_server.py

    # Third-party imports...
    from unittest.mock import patch
    from nose.tools import assert_dict_contains_subset, assert_list_equal, assert_true

    # Local imports...
    from project.services import get_users
    from project.tests.mocks import get_free_port, start_mock_server

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    cls.mock_server_port = get_free_port()
    start_mock_server(cls.mock_server_port)

    def test_request_response(self):
    mock_users_url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Patch USERS_URL so that the service uses the mock server URL instead of the real URL.
    with patch.dict('project.services.__dict__', {'USERS_URL': mock_users_url}):
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_list_equal(response.json(), [])

    Aviso una nueva técnica que se utiliza en el test_ simulacro _server.py código. La línea de respuesta = get_users () se envuelve con una función patch.dict () de la biblioteca mock .

    ¿Qué hace esta afirmación?

    Recuerde, ha movido la función requests.get () de la lógica de función para los get_users función de servicio (). Internamente, get_users () llama requests.get () utilizando la variable USERS_URL. La función patch.dict () reemplaza temporalmente el valor de la variable USERS_URL. De hecho, lo hace sólo en el ámbito de la sentencia with. Después de que las carreras de código, la variable USERS_URL se restaura a su valor original. Este código parches la URL a utilizar la dirección del servidor simulado.

    Ejecutar las pruebas y los ven pasar.

    $ nosetests --verbosity=2
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:45:30] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... ok
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 0.871s

    OK

    Saltarse Pruebas de que afectó a la API real

    Comenzamos este tutorial que describe los méritos de la prueba de un servidor de simulacro en lugar de uno real, sin embargo, su código prueba actualmente ambos. ¿Cómo se configura las pruebas de ignorar el servidor real? La biblioteca de Python ‘unittest’ ofrece varias funciones que le permiten saltarse las pruebas. Puede utilizar la función de salto condicional ‘skipIf’ junto con una variable de entorno para alternar las pruebas de servidores reales dentro y fuera. En el siguiente ejemplo, se pasa un nombre de etiqueta que debe ser ignorado:

    $ export SKIP_TAGS=real

    proyecto / constants.py proyecto

    # Standard-library imports...
    import os

    BASE_URL = 'http://jsonplaceholder.typicode.com'
    SKIP_TAGS = os.getenv('SKIP_TAGS', '').split()

    / pruebas / test_real_server.py

    # Standard library imports...
    from unittest import skipIf

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.constants import SKIP_TAGS
    from project.services import get_users

    @skipIf('real' in SKIP_TAGS, 'Skipping tests that hit the real API server.')
    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    ejecutar las pruebas y prestar atención a cómo el verdadero prueba del servidor se ignora:

    $ nosetests --verbosity=2 project
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:52:18] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... SKIP: Skipping tests that hit the real API server.
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 1.196s

    OK (SKIP=1)

    próximos pasos

    Ahora que ha creado un servidor de simulacro para probar sus llamadas a la API externos, puede aplicar este conocimiento a sus propios proyectos. Construir sobre las pruebas simples creadas aquí. Ampliar la funcionalidad del controlador para imitar el comportamiento de la API reales más de cerca.

    Pruebe los siguientes ejercicios para subir de nivel:

    • devolver una respuesta con un estado de HTTP 404 (no encontrado) si se envía una petición con una ruta desconocida.
    • devolver una respuesta con un estado de HTTP 405 (Método no permitido) si se envía una solicitud con un método que no está permitido (POST, DELETE, UPDATE). datos de usuario real
    • cambio de una solicitud válida a / usuarios.
    • escribir pruebas para capturar esos escenarios.

    Coge el código desde el repositorio.

    Categorías
    Python

    Django marco Resto – Introducción

     

    Tabla de Contenidos

    • Introducción
    • Prueba del Mock API
    • Prueba

    • un servicio que llega a las API Pruebas
    • Skipping que afectó a la real API
    • próximos pasos

    A pesar de ser tan útil, APIs externas pueden ser un dolor de prueba. Al llegar a una API real, las pruebas están a merced del servidor externo, lo que puede dar lugar a los siguientes puntos de dolor:

    • El ciclo de solicitud-respuesta puede tardar varios segundos. Esto puede no parecer mucho al principio, pero los compuestos de tiempo con cada prueba. Imagínese llamar a una API 10, 50, o incluso 100 veces cuando se prueba toda su aplicación.
    • La API puede haber límites de ritmo establecido.
    • El servidor API puede ser inalcanzable. Puede que el servidor está en mantenimiento? Tal vez con un error y el equipo de desarrollo está trabajando para conseguir de nuevo funcional> ¿Realmente desea el éxito de sus pruebas a depender de la salud de un servidor que no controlas?

    Sus pruebas no deben evaluar si un servidor API se está ejecutando; deberían probar si su código está funcionando como se esperaba.

    En el tutorial anterior, se introdujo el concepto de objetos simulados, demostró cómo se podía utilizar para el código de prueba que interactúa con las API externas. Este tutorial se basa en los mismos temas, pero aquí se puede caminar a través de la forma de construir realmente un servidor simulacro en lugar de burlarse de las API. Con un servidor maqueta en su lugar, se pueden realizar pruebas de extremo a extremo. Puede utilizar la aplicación y obtener retroalimentación real desde el servidor simulacro en tiempo real.

    Cuando termine de trabajar a través de los siguientes ejemplos, se han programado un simulacro de servidor básico y dos pruebas – uno que utiliza el servidor API real y uno que utiliza el servidor simulado. Ambas pruebas tendrán acceso al mismo servicio, una API que recupera una lista de usuarios.

    NOTA: Este tutorial usa Python v3.5.1.

    Introducción

    Inicio siguiendo la sección de primeros pasos de la entrada anterior. O agarrar el código desde el repositorio. Asegúrese de que los pases de prueba antes de pasar:

    $ nosetests --verbosity=2 project
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 1 test in 1.029s

    OK
    Prueba

    el Mock API

    Con la puesta en marcha completa, puede programar su servidor simulado. Escribir una prueba que describe el comportamiento: Proyecto

    / pruebas / test_mock_server.py

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    def test_request_response():
    url = 'http://localhost:{port}/users'.format(port=mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    assert_true(response.ok)

    Aviso que comienza mirando casi idéntica a la prueba API real. La URL ha cambiado y ahora está apuntando a un punto final de la API en localhost donde el servidor simulacro se ejecutará.

    Aquí es cómo crear un servidor de simulacro en Python: Proyecto

    / pruebas / test_mock_server.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import socket
    from threading import Thread

    # Third-party imports...
    from nose.tools import assert_true
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
    # Process an HTTP GET request and return a response with an HTTP 200 status.
    self.send_response(requests.codes.ok)
    self.end_headers()
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    # Configure mock server.
    cls.mock_server_port = get_free_port()
    cls.mock_server = HTTPServer(('localhost', cls.mock_server_port), MockServerRequestHandler)

    # Start running mock server in a separate thread.
    # Daemon threads automatically shut down when the main process exits.
    cls.mock_server_thread = Thread(target=cls.mock_server.serve_forever)
    cls.mock_server_thread.setDaemon(True)
    cls.mock_server_thread.start()

    def test_request_response(self):
    url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Send a request to the mock API server and store the response.
    response = requests.get(url)

    # Confirm that the request-response cycle completed successfully.
    print(response)
    assert_true(response.ok)

    En primer lugar, crear una subclase de BaseHTTPRequestHandler. Esta clase captura la petición y construye la respuesta al cambio. Reemplazar la función do_GET () para elaborar la respuesta para una solicitud HTTP GET. En este caso, basta con devolver un estado OK. A continuación, escribir una función para obtener un número de puerto disponible para el servidor simulacro de uso.

    El siguiente bloque de código en realidad configura el servidor. Aviso cómo el código crea una instancia HTTPServer y lo pasa un número de puerto y un controlador. A continuación, crear un hilo, para que el servidor se puede ejecutar de forma asincrónica y el hilo principal del programa puede comunicarse con él. Hacer que el hilo de un demonio, que le dice al hilo de parada cuando las principales salidas del programa. Por último, iniciar el hilo para servir al servidor de simulacro para siempre (hasta que terminen las pruebas).

    Crear una clase de prueba y mover la función de prueba a la misma. Debe añadir un método adicional para garantizar que el servidor simulacro se puso en marcha antes que cualquiera de las pruebas realizadas. Tenga en cuenta que este nuevo código vive dentro de una función especial a nivel de clase, setup_class ().

    Ejecute las pruebas y verlos pasar:

    $ nosetests --verbosity=2 project

    a probar un servicio que llega a la API

    Es posible que desee llamar a más de un punto final de la API en su código. A medida que el diseño de su aplicación, es probable que crear funciones de servicio para enviar peticiones a una API y luego procesar las respuestas de alguna manera. Tal vez va a almacenar los datos de respuesta en una base de datos. O se pasa los datos a una interfaz de usuario.

    Refactor su código para tirar de la URL base API hardcoded en una constante. Añadir esta variable a un archivo constants.py : Proyecto

    / constants.py

    BASE_URL = 'http://jsonplaceholder.typicode.com'

    A continuación, encapsulan la lógica para recuperar los usuarios de la API en una función. Aviso cómo las nuevas direcciones URL puede ser creado por unirse a una ruta URL a la base.

    proyecto / services.py

    # Standard library imports...
    from urllib.parse import urljoin

    # Third-party imports...
    import requests

    # Local imports...
    from project.constants import BASE_URL

    USERS_URL = urljoin(BASE_URL, 'users')

    def get_users():
    response = requests.get(USERS_URL)
    if response.ok:
    return response
    else:
    return None

    Mover el código del servidor maqueta del archivo de función para un nuevo archivo de Python, por lo que fácilmente se puede reutilizar. Añadir lógica condicional para el controlador de solicitudes para comprobar qué API punto final de la petición HTTP es la orientación. Reforzar la respuesta mediante la adición de un poco de información de cabecera y una carga útil sencilla respuesta básica. La creación del servidor y puntapié inicial de código se pueden encapsular en un método de conveniencia, start_mock_server (). proyecto

    / pruebas / mocks.py

    # Standard library imports...
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import json
    import re
    import socket
    from threading import Thread

    # Third-party imports...
    import requests

    class MockServerRequestHandler(BaseHTTPRequestHandler):
    USERS_PATTERN = re.compile(r'/users')

    def do_GET(self):
    if re.search(self.USERS_PATTERN, self.path):
    # Add response status code.
    self.send_response(requests.codes.ok)

    # Add response headers.
    self.send_header('Content-Type', 'application/json; charset=utf-8')
    self.end_headers()

    # Add response content.
    response_content = json.dumps([])
    self.wfile.write(response_content.encode('utf-8'))
    return

    def get_free_port():
    s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
    s.bind(('localhost', 0))
    address, port = s.getsockname()
    s.close()
    return port

    def start_mock_server(port):
    mock_server = HTTPServer(('localhost', port), MockServerRequestHandler)
    mock_server_thread = Thread(target=mock_server.serve_forever)
    mock_server_thread.setDaemon(True)
    mock_server_thread.start()

    Con los cambios en la lógica completado, alteran las pruebas a utilizar la nueva función de servicio. Actualizar las pruebas para comprobar el aumento de la información que se pasa de nuevo desde el servidor. proyecto

    / pruebas / test_real_server.py proyecto

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.services import get_users

    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    / pruebas / test_mock_server.py

    # Third-party imports...
    from unittest.mock import patch
    from nose.tools import assert_dict_contains_subset, assert_list_equal, assert_true

    # Local imports...
    from project.services import get_users
    from project.tests.mocks import get_free_port, start_mock_server

    class TestMockServer(object):
    @classmethod
    def setup_class(cls):
    cls.mock_server_port = get_free_port()
    start_mock_server(cls.mock_server_port)

    def test_request_response(self):
    mock_users_url = 'http://localhost:{port}/users'.format(port=self.mock_server_port)

    # Patch USERS_URL so that the service uses the mock server URL instead of the real URL.
    with patch.dict('project.services.__dict__', {'USERS_URL': mock_users_url}):
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_list_equal(response.json(), [])

    Aviso una nueva técnica que se utiliza en el test_ simulacro _server.py código. La línea de respuesta = get_users () se envuelve con una función patch.dict () de la biblioteca mock .

    ¿Qué hace esta afirmación?

    Recuerde, ha movido la función requests.get () de la lógica de función para los get_users función de servicio (). Internamente, get_users () llama requests.get () utilizando la variable USERS_URL. La función patch.dict () reemplaza temporalmente el valor de la variable USERS_URL. De hecho, lo hace sólo en el ámbito de la sentencia with. Después de que las carreras de código, la variable USERS_URL se restaura a su valor original. Este código parches la URL a utilizar la dirección del servidor simulado.

    Ejecutar las pruebas y los ven pasar.

    $ nosetests --verbosity=2
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:45:30] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... ok
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 0.871s

    OK

    Saltarse Pruebas de que afectó a la API real

    Comenzamos este tutorial que describe los méritos de la prueba de un servidor de simulacro en lugar de uno real, sin embargo, su código prueba actualmente ambos. ¿Cómo se configura las pruebas de ignorar el servidor real? La biblioteca de Python ‘unittest’ ofrece varias funciones que le permiten saltarse las pruebas. Puede utilizar la función de salto condicional ‘skipIf’ junto con una variable de entorno para alternar las pruebas de servidores reales dentro y fuera. En el siguiente ejemplo, se pasa un nombre de etiqueta que debe ser ignorado:

    $ export SKIP_TAGS=real

    proyecto / constants.py proyecto

    # Standard-library imports...
    import os

    BASE_URL = 'http://jsonplaceholder.typicode.com'
    SKIP_TAGS = os.getenv('SKIP_TAGS', '').split()

    / pruebas / test_real_server.py

    # Standard library imports...
    from unittest import skipIf

    # Third-party imports...
    from nose.tools import assert_dict_contains_subset, assert_is_instance, assert_true

    # Local imports...
    from project.constants import SKIP_TAGS
    from project.services import get_users

    @skipIf('real' in SKIP_TAGS, 'Skipping tests that hit the real API server.')
    def test_request_response():
    response = get_users()

    assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers)
    assert_true(response.ok)
    assert_is_instance(response.json(), list)

    ejecutar las pruebas y prestar atención a cómo el verdadero prueba del servidor se ignora:

    $ nosetests --verbosity=2 project
    test_mock_server.TestMockServer.test_request_response ... 127.0.0.1 - - [05/Jul/2016 20:52:18] "GET /users HTTP/1.1" 200 -
    ok
    test_real_server.test_request_response ... SKIP: Skipping tests that hit the real API server.
    test_todos.test_request_response ... ok

    ----------------------------------------------------------------------
    Ran 3 tests in 1.196s

    OK (SKIP=1)

    próximos pasos

    Ahora que ha creado un servidor de simulacro para probar sus llamadas a la API externos, puede aplicar este conocimiento a sus propios proyectos. Construir sobre las pruebas simples creadas aquí. Ampliar la funcionalidad del controlador para imitar el comportamiento de la API reales más de cerca.

    Pruebe los siguientes ejercicios para subir de nivel:

    • devolver una respuesta con un estado de HTTP 404 (no encontrado) si se envía una petición con una ruta desconocida.
    • devolver una respuesta con un estado de HTTP 405 (Método no permitido) si se envía una solicitud con un método que no está permitido (POST, DELETE, UPDATE). datos de usuario real
    • cambio de una solicitud válida a / usuarios.
    • escribir pruebas para capturar esos escenarios.

    Coge el código desde el repositorio.