Automatización de interfaz basada en Python: módulo pymysql para operar la base de datos

Tabla de contenido

introducción

Al realizar pruebas funcionales o de interfaz, a menudo es necesario conectarse a la base de datos, operar y ver datos relevantes de la tabla de datos y usarlos para generar datos de prueba, verificar funciones, verificar la coherencia de los datos y si la operación de la base de datos de la interfaz es correcta. , etc.

Por lo tanto, al realizar pruebas de automatización de interfaz, tampoco podemos evitar la interacción entre la interfaz y la base de datos. Necesitamos usar código para conectarnos a la base de datos y completar las funciones de preparación de datos, inspección del entorno y aserción de la base de datos operando la base de datos.

En python3, usar Python para operar la base de datos MySQL requiere el uso de una biblioteca de terceros: pymysql, que es esencialmente un paquete de software cliente de socket, que proporciona una serie de métodos para conectarse a bases de datos y operar tablas de bases de datos.

1. Instalación de PyMySQL

1. Instalar en entorno Windows

Dado que las versiones python3.6 y superiores vienen con pip3 después de instalar Python, si la versión de Python es inferior a 3.6, puede instalar pip manualmente, por lo que puede usar pip directamente para instalar el módulo.

pip3 install pymysql

2. Instalar en entorno Linux

Descargue e instale el paquete tar de pymysql. Después de la descompresión, ingrese al directorio de descompresión e instálelo de la siguiente manera:

[root@localhost opt]#tar -xzvf PyMySQL-0.7.11.tar.gz
[root@localhost opt]#cd PyMySQL-0.7.11
[root@localhost PyMySQL-0.7.11]#python36 setup.py install

3. Instalar en PyCharm

Recupere el módulo directamente en PyCharm e instálelo, los pasos son los siguientes:

2. Python opera la base de datos.

Para facilitar la prueba, primero creamos una tabla de prueba en la base de datos MySQL: información de usuario, la información de la tabla es la siguiente:

Después de tener la base de datos y la tabla de datos, podemos importar el módulo pymysql y usar el método encapsulado en el módulo para realizar la operación de la base de datos.

Conectividad de base de datos

Los métodos proporcionados por pymysql son los siguientes:

1. Establecer una conexión de base de datos conn = pymysql.connect()
2. Establecer un cursor de operación desde la conexión cur = conn.cursor()
3. Utilice el cursor para ejecutar sql (lectura/escritura) cur.execute(sql)
4. Obtener el resultado (leer) / Confirmar cambios (escribir) cur.fetchall() / conn.commit()
5. Cerrar el cursor y conectar cur.close();conn.close()

Ejemplo de código:

import pymysql
# 建立连接
connection = pymysql.connect(host='119.29.78.234', port=3306, user='root', password='dhcc@2020', db='test123')
cursor = connection.cursor()       # 创建游标
cursor.execute("SELECT * FROM userinfo")   #使用execute()方法执行SQL语句
data = cursor.fetchall()  #使用fetall()获取全部数据
print(data)
cursor.close()   #关闭游标和数据库的连接
connection.close()<br><br>#运行结果<br>((1, '艾佛森', '123'), (2, '科比', '123'), (3, '詹姆斯', '123'), (4, '库里', '123'))

¿Qué es un cursor? Un cursor es similar a un identificador de archivo y puede acceder a la base de datos para ejecutar el conjunto de resultados uno por uno. En pymysql, solo se pueden usar cursores para ejecutar sql y obtener resultados

Después de ejecutar el código anterior, se devuelve un tipo de datos de tupla anidada de forma predeterminada.

CRUD de base de datos

Operación de consulta:

Con cur.execute(), nada de lo que se devuelve después de ejecutar una consulta a la base de datos es el número de filas afectadas, no el resultado de la consulta. Necesitamos usar cur.fetchone()/cur.fetchmany()/cur.fetchall() para obtener el resultado de la consulta
cur.fetchone(): Obtenga un dato (al mismo tiempo, los datos se eliminarán del conjunto de resultados) y devuelve la tupla
cur.fetchmany(3): recupera múltiples datos, devuelve una tupla anidada
cur.fetchall(): recupera todos los datos, devuelve una tupla anidada

Ejemplo de código:

Consultar un solo dato:

import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "SELECT * FROM userinfo"
cursor.execute(sql)
res = cursor.fetchone()    # fetchone()第一次只能查询表中的首行数据
print(res)
res = cursor.fetchone()    # 第二次查询下一行数据
print(res)
cursor.close()
db.close()<br><br># 返回结果

((1, 'Iverson', '123'))

((2, 'Kobe', '123'))

Consultar varios datos:

import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "SELECT * FROM userinfo"
cursor.execute(sql)
res = cursor.fetchmany(3)   # 第一次查询表中的前3行数据
print(res)
res = cursor.fetchmany(3)    # 第二次查询下一个3行的数据
print(res)
cursor.close()
db.close()<br>
#返回结果
((1, '艾佛森', '123'), (2, '科比', '123'), (3, '詹姆斯', '123'))
((4, '库里', '123'),)

Consulta todos los datos:

import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "SELECT * FROM userinfo"
cursor.execute(sql)
res = cursor.fetchall()   # 第一次查询表中的所有数据
print(res)
res = cursor.fetchall()    # 第二次查询无数据
print(res)
cursor.close()
db.close()<br>
#返回结果
((1, '艾佛森', '123'), (2, '科比', '123'), (3, '詹姆斯', '123'), (4, '库里', '123'))
()

　El valor predeterminado es devolver el tipo de datos de tupla, lo que parece poco intuitivo, por lo que el cursor se puede configurar de la siguiente manera al crear una instancia y se pueden devolver datos de tipo diccionario

cursor = db.cursor(cursor=pymysql.cursors.DictCursor)<br><br>#返回结果

[{'nombre de usuario': 'Iverson', 'id': 1, 'contraseña': '123'}, {'nombre de usuario': 'Kobe', 'id': 2, 'contraseña': '123'}, { 'nombre de usuario': 'James', 'id': 3, 'contraseña': '123'}, {'nombre de usuario': 'Curry', 'id': 4, 'contraseña': '123'}]

Operaciones de adición, eliminación y modificación:

Las adiciones, eliminaciones y modificaciones de la base de datos no tienen efecto inmediato. Solo entran en vigor después de enviarse mediante la conexión conn.commit(). Se admiten cosas y reversiones.

Ejemplo de código:

import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "INSERT INTO userinfo(username,passwd) VALUES('克莱','123')"
#sql = "UPDATE userinfo SET username = '奥尼尔' WHERE username = '科比'"  # 修改数据
#sql = "DELETE FROM username WHERE username ='奥尼尔'"                    # 删除数据
try:
    cursor.execute(sql)
    db.commit()
except Exception as e :   # 执行异常回滚
    db.rollback()
cursor.close()
db.close()
#或者在execute提供需要插入的数据
import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "INSERT INTO userinfo(username,passwd) VALUES(%s,%s)"
try:
    cursor.execute(sql,("克莱","123"))
    db.commit()
except Exception as e :
    db.rollback()
cursor.close()
db.close()
#批量插入数据
import pymysql
db_config = {
      "host":"119.29.78.234",
       "port":3306,
       "user":"root",
       "password":"dhcc@2020",
       "db":"test123"
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
sql = "INSERT INTO userinfo(username,passwd) VALUES(%s,%s)"
try:
    cursor.executemany(sql,[("韦德","123"),("字母哥","123")])
    db.commit()
except Exception as e :
    db.rollback()
cursor.close()
db.close()

Encapsular operaciones de base de datos

Dado que las operaciones de bases de datos se utilizan con frecuencia, se recomienda encapsular todas las operaciones de bases de datos en un módulo de base de datos común.

El ejemplo de código encapsulado es el siguiente:

import pymysql.cursors
 
class Operation_mysql(object):
    def __init__(self):
        # 建立连接
        db_config = {
            "host": "119.29.78.234",
            "port": 3306,
            "user": "root",
            "password": "dhcc@2020",
            "db": "test123"
        }
        self.connection = pymysql.connect(**db_config)
        # 创建游标
        self.cursor = self.connection.cursor()
 
    def execute_sql(self, sql):
        try:
            self.cursor.execute(sql)
            self.connection.commit()
        except Exception as e:  # 执行异常回滚
            db.rollback()
 
    def get_data(self):
        data = self.cursor.fetchone()
        #data = self.cursor.fetchall() # 查询所有数据
        return data
 
    def close_mysql(self):
        # 关闭游标
        self.cursor.close()
        # 关闭数据库连接
        self.connection.close()

De esta manera, cuando los casos de prueba de interfaz posteriores necesitan operar la base de datos después de la encapsulación, se puede introducir el módulo y el objeto instanciado llama al método bajo el módulo.

escribe al final

Esta publicación termina aquí y, finalmente, espero que los amigos que lean esta publicación puedan ganar algo.

Está todo aquí, recuerda apoyar a Sanlian.

-------------------------------------------------

Cómo descargar la versión completa del documento:

Estos materiales deberían ser el almacén de preparación más completo y completo para los amigos que se dedican a [las pruebas de software]. ¡Este almacén también me ha acompañado en el viaje más difícil y espero que pueda ayudarlo a usted también! Todo lo anterior se puede compartir.

Interactúa conmigo en el área de comentarios o en privado ❤ conmigo [Prueba y aprendizaje de software] para obtenerlo, no gracias por quitármelo.