[Curso intensivo de entrevistas sobre pruebas de software] Cómo obligarte a terminar el tutorial de ensayo de ocho partes sobre pruebas de software en una semana. Después de terminar la entrevista, estarás estable. También puedes ser un ingeniero de pruebas de software bien remunerado (pruebas automatizadas)
1. Principio de implementación simulado y mecanismo de implementación
En algún momento, cuando el backend está desarrollando la interfaz, la lógica de procesamiento es muy complicada. Al realizar la prueba, ¿cómo debería probar el backend sin completar la interfaz?
Necesitamos realizar pruebas, pero algunas solicitudes necesitan modificar los parámetros o cambiar la forma en que se implementa la solicitud, como modificar el código de estado , reemplazar las imágenes generadas o reemplazar el archivo de ejecución, etc.
Introducción a la simulación
La palabra Mock significa simulación en inglés, por lo que podemos intuir que la función principal de esta biblioteca es simular algo. Para ser precisos, Mock es una biblioteca en Python que se utiliza para admitir pruebas unitarias. Su función principal es utilizar objetos simulados para reemplazar objetos Python específicos para simular el comportamiento de los objetos.
Durante el proceso de prueba unitaria del proyecto, encontrará:
1. Dependencia de la interfaz
2. Llamada de interfaz externa
3. El entorno de prueba es muy complejo.
Las pruebas unitarias solo deben probar la unidad actual. Todas las dependencias internas o externas deben ser estables y haber sido probadas en otro lugar. Usando simulacros, puedes simular y reemplazar la implementación de componentes dependientes externos, de modo que la prueba unitaria se centre solo en la unidad actual. función unitaria.
Resolver dependencias de prueba
Por ejemplo, queremos probar el módulo A y luego el módulo A depende de la llamada del módulo B. Sin embargo, debido a cambios en el módulo B, los resultados devueltos por el módulo A cambian, lo que provoca que el caso de prueba del módulo A falle. De hecho, no hay ningún cambio para el módulo A y los casos de uso del módulo A, por lo que no debería fallar.
Aquí es cuando entra en juego la burla. Utilice simulacro para simular la parte que afecta al módulo A (módulo B). En cuanto a la parte simulada (módulo B), debería probarse en otros casos de uso.
ejemplo
import requests
from unittest import mock
def request_lemonfix():
"""
:return:
"""
res = requests.get('http://www.baidu.com')
return res.status_code.encode('utf-8')
if __name__ == '__main__':
request_lemonfix = mock.Mock(return_value="我已经替换了数据")
print(request_lemonfix())
结果：
我已经替换了数据
```
2. Implementación de caso simple de simulacro
- habilidades básicas
# function.py
def multiply(x, y):
return x * y
def add_and_multiply(x, y):
addition = x + y
multiple = multiply(x, y) # 回调函数
return (addition, multiple)- Escribir casos de prueba para la función add_and_multiply()
import mock
import requests
import unittest
url = "www.baidu.com/login"
data = {
"user_id": "001",
"password": "caichen"
}
def post_request(url, data):
"""登陆百度账号"""
res = requests.post(url, data).json()
return res
class TestLogin(unittest.TestCase):
"""单元测试"""
def setUp(self) -> None:
print("case开始执行")
def tearDown(self) -> None:
print("case执行结束")
def test_01(self):
"""模拟数据判断是否正确"""
url = "www.baidu.com/login/tieba"
data = {
"user_id": "001"
}
sucess_test = mock.Mock(return_value=data)
post_request = sucess_test
res = post_request
self.assertEqual("654321", res())
# self.assertEqual({'user_id': '001'},res())
if __name__ == '__main__':
unittest.main()
# 错误结果
F
case开始执行
======================================================================
case执行结束
FAIL: test_01 (__main__.TestLogin)
模拟数据判断是否正确
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:/Users/x1c/Desktop/untitled/mocktest.py", line 35, in test_01
self.assertEqual("654321", res())
AssertionError: '654321' != {'user_id': '001'}
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)
# 正常结果
case开始执行
.
case执行结束
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
Tres implementos simulados obtienen simulación de datos
举个例子来说：我们有一个简单的客户端实现，用来访问一个URL，当访问正常时，需要返回状态码200，不正常时，需要返回状态码404。首先，我们的客户端代码实现如下：
```
import requests
def send_request(url):
r = requests.get(url)
return r.status_code
def visit_ustack():
return send_request('http://www.ustack.com')
```
# 外部模块调用visit_ustack()来访问baidu的官网。下面我们使用mock对象在单元测试中分别测试访问正常和访问不正常的情况。
```
import unittest
import mock
import client
class TestClient(unittest.TestCase):
def test_success_request(self):
success_send = mock.Mock(return_value='200')
client.send_request = success_send
self.assertEqual(client.visit_ustack(), '200')
def test_fail_request(self):
fail_send = mock.Mock(return_value='404')
client.send_request = fail_send
self.assertEqual(client.visit_ustack(), '404')
```1. Encuentre el objeto a reemplazar: lo que debemos probar es la función visit_ustack, luego debemos reemplazar la función send_request.
2. Cree una instancia de la clase Mock para obtener un objeto simulado y establezca el comportamiento de este objeto simulado. En una prueba exitosa, establecemos el valor de retorno del objeto simulado en la cadena "200", y en una prueba fallida, establecemos el valor de retorno del objeto simulado en la cadena "404".
3. Utilice este objeto simulado para reemplazar el objeto que queremos reemplazar. Reemplazamos client.send_request
4. Escriba el código de prueba. Llamamos a client.visit_ustack() y esperamos que su valor de retorno sea el mismo que el predeterminado.
Los anteriores son los pasos básicos para usar objetos simulados. En el ejemplo anterior, reemplazamos el objeto del módulo que escribimos. De hecho, también podemos reemplazar los objetos de la biblioteca estándar y los módulos de terceros. El método es el mismo: importarlo primero y luego reemplazar el objeto especificado. .
4. La diferencia entre Mock y Mockrunner
Mockrunner se utiliza para pruebas de simulación de aplicaciones en el entorno J2EE. No solo admite acciones, servlets, filtros y clases de etiquetas de Struts, sino que también incluye un marco de prueba JDBC y JMS que se puede utilizar para probar aplicaciones basadas en EJB.
Mockrunner amplía JUnit y simula el comportamiento necesario sin llamar a la infraestructura real. No requiere un servidor de aplicaciones o una base de datos en ejecución. Además, no llama al contenedor web ni a Struts ActionServlet. Es muy rápido y permite al usuario manipular todas las clases involucradas y simular objetos durante todos los pasos de la prueba. Se puede utilizar para escribir pruebas unitarias muy complejas para aplicaciones basadas en J2EE sin incurrir en gastos generales. Mockrunner no admite ningún tipo de prueba en contenedor.
Mockrunner no lee ningún archivo de configuración como web.xml o struts-config.xml. Puede especificar todos los parámetros utilizando la API de Mockrunner. Por tanto, los servlets, filtros, etiquetas y acciones de Struts se pueden probar como componentes reutilizables, independientemente de la configuración que utilices en una u otra aplicación. No se pueden probar las definiciones en el archivo de configuración. Si desea hacer esto, puede utilizar StrutsTestCase para aplicaciones basadas en Struts o Cactus.
Mockrunner admite versiones de Java de 1.3 a 1.6, así como J2EE 1.3, J2EE 1.4 y JavaEE5. EJB 3.0 aún no es compatible. Mockrunner es compatible con las versiones 1.1, 1.2 y 1.3 de Struts.
Dirección de descarga: descarga de Mockrunner | SourceForge.net
Mockrunner debe configurar el entorno Java.
Comience a usar el comando: java -jar moco-runner-0.12.0-standalone.jar http -p 8801 -c config.json
Configure el archivo config.json para simular datos
[
{
"response" :
{
"text" : "Hello, Moco"
}
}
]
```
使用命令启动：
java -jar moco-runner-0.12.0-standalone.jar http -p 8801 -c config.json
访问http://localhost:8801
就会显示 Hello, Moco
MockRunner funciona construyendo una regla de vinculación compleja
[
{
"request":{
"uri":"/monitorApplication/alert/confirm",
"method":"PUT",
"text":"{\"id\":\"123\"}"
},
"response":{
"status":200,
"json":{
"code":"0",
"msg":"OK！",
"data":null
}
}
}
]5.Entrevista básica de prueba de interfaz
-
¿Cómo realizar pruebas de interfaz en el proyecto?
Utilice herramientas de prueba para verificar parámetros, solicitar parámetros y devolver parámetros.
-
Cómo escribir casos durante el desarrollo de la interfaz
Los documentos de reglas están familiarizados con el formato de verificación simulada.
-
Cómo entender el simulacro
Simular parámetros de retorno, simular interfaz
-
¿Correr simuladamente en el trabajo?
Ayudar al front-end a lograr un desarrollo normal
Los siguientes son materiales de apoyo para el aprendizaje. Para aquellos que están haciendo [pruebas de software], debería ser el almacén de preparación más completo y completo. Este almacén también me ha acompañado en el viaje más difícil. ¡Espero que también pueda ayudarlos a ustedes!
Subprograma de entrevista de prueba de software
¡Un banco de preguntas de prueba de software que ha sido utilizado por millones de personas! ! ! ¡Quién es quién lo sabe! ! ! El miniprograma de prueba de entrevistas más completo de Internet. Puede usar su teléfono móvil para responder preguntas, tomar el metro, el autobús y enrollarlo.
Cubre las siguientes secciones de preguntas de la entrevista:
1. Teoría básica de pruebas de software, 2. web, aplicaciones, pruebas de función de interfaz, 3. red, 4. base de datos, 5. linux
6. Web, aplicaciones, automatización de interfaces, 7. Pruebas de rendimiento, 8. Conceptos básicos de programación, 9. Preguntas de la entrevista de recursos humanos, 10. Preguntas de prueba abiertas, 11. Pruebas de seguridad, 12. Conceptos básicos de informática
Cómo obtener documentos:
Este documento debería ser el almacén de preparación más completo y completo para los amigos que quieran participar en [pruebas de software]. Este almacén también me ha acompañado en el viaje más difícil. ¡Espero que también pueda ayudarlo a usted!
