Postman API Pruebas

"Clase de la hoja"

########################################################################################################################################################################################################################################################## Copiar todos los comandos

########################################################################################################################################################################################################################################################## Generar PDF seleccionado/button

■/div titulada

Atajos y flujos de trabajo completos de Postman para el desarrollo y pruebas de API.

Navegación básica

Shortcut	Description
Ctrl+N	New Request
Ctrl+Shift+N	New Collection
Ctrl+O	Open
Ctrl+S	Save
Ctrl+Shift+S	Save As
Ctrl+Enter	Send Request
Ctrl+R	Reload
Ctrl+W	Close Tab
Ctrl+Shift+W	Close All Tabs
Ctrl+T	New Tab
Ctrl+Shift+T	Reopen Closed Tab

Solicitud de gestión

Shortcut	Description
Ctrl+L	Focus URL Bar
Ctrl+M	Change HTTP Method
Ctrl+Shift+P	Open Command Palette
Ctrl+K	Search Collections
Ctrl+H	Show/Hide Sidebar
Ctrl+Alt+C	Open Console
Ctrl+Alt+E	Open Environment Quick Look

Edición de texto

Shortcut	Description
Ctrl+A	Select All
Ctrl+C	Copy
Ctrl+V	Paste
Ctrl+X	Cut
Ctrl+Z	Undo
Ctrl+Y	Redo
Ctrl+F	Find
Ctrl+G	Find Next
Ctrl+Shift+G	Find Previous
F3	Find Next
Shift+F3	Find Previous

Medio ambiente y variables

Shortcut	Description
Ctrl+Alt+E	Environment Quick Look
Ctrl+Shift+E	Manage Environments
\\{\\{variable\\}\\}	Variable Syntax
pm.environment.get("var")	Get Environment Variable
pm.environment.set("var", "value")	Set Environment Variable
pm.globals.get("var")	Get Global Variable
pm.globals.set("var", "value")	Set Global Variable

HTTP Métodos y Códigos de Estado

HTTP común Métodos

Method	Purpose	Example
GET	Retrieve data	Get user profile
POST	Create new resource	Create new user
PUT	Update entire resource	Update user profile
PATCH	Partial update	Update user email
DELETE	Remove resource	Delete user account
HEAD	Get headers only	Check if resource exists
OPTIONS	Get allowed methods	CORS preflight

HTTP Status Codes

Code Range	Type	Common Codes
2xx	Success	200 OK, 201 Created, 204 No Content
3xx	Redirection	301 Moved, 302 Found, 304 Not Modified
4xx	Client Error	400 Bad Request, 401 Unauthorized, 404 Not Found
5xx	Server Error	500 Internal Error, 502 Bad Gateway, 503 Unavailable

Pre-request Scripts

Ejemplos comunes de script de Pre-request

// Set timestamp
pm.environment.set("timestamp", Date.now());

// Generate random data
pm.environment.set("randomEmail",
  "user" + Math.random().toString(36).substring(7) + "@example.com");

// Set authentication token
const token = pm.environment.get("auth_token");
pm.request.headers.add(\\\\{
  key: "Authorization",
  value: "Bearer " + token
\\\\});

// Generate UUID
const uuid = require('uuid');
pm.environment.set("requestId", uuid.v4());

// Base64 encode credentials
const username = pm.environment.get("username");
const password = pm.environment.get("password");
const credentials = btoa(username + ":" + password);
pm.environment.set("basicAuth", credentials);

Scripts de prueba

Aserciones básicas

// Status code tests
pm.test("Status code is 200", function () \\\\{
    pm.response.to.have.status(200);
\\\\});

pm.test("Status code name has string", function () \\\\{
    pm.response.to.have.status("OK");
\\\\});

// Response time test
pm.test("Response time is less than 200ms", function () \\\\{
    pm.expect(pm.response.responseTime).to.be.below(200);
\\\\});

// Header tests
pm.test("Content-Type is present", function () \\\\{
    pm.response.to.have.header("Content-Type");
\\\\});

pm.test("Content-Type is application/json", function () \\\\{
    pm.expect(pm.response.headers.get("Content-Type")).to.include("application/json");
\\\\});

JSON Pruebas de respuesta

// Parse JSON response
const responseJson = pm.response.json();

// Test JSON structure
pm.test("Response has required fields", function () \\\\{
    pm.expect(responseJson).to.have.property("id");
    pm.expect(responseJson).to.have.property("name");
    pm.expect(responseJson).to.have.property("email");
\\\\});

// Test specific values
pm.test("User ID is correct", function () \\\\{
    pm.expect(responseJson.id).to.eql(123);
\\\\});

pm.test("Email format is valid", function () \\\\{
    pm.expect(responseJson.email).to.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
\\\\});

// Test array responses
pm.test("Response is an array", function () \\\\{
    pm.expect(responseJson).to.be.an('array');
\\\\});

pm.test("Array has correct length", function () \\\\{
    pm.expect(responseJson).to.have.lengthOf(5);
\\\\});

Extracción variable

// Extract data from response
const responseJson = pm.response.json();

// Set environment variables
pm.environment.set("userId", responseJson.id);
pm.environment.set("userToken", responseJson.token);

// Extract from headers
const location = pm.response.headers.get("Location");
pm.environment.set("resourceUrl", location);

// Extract using regex
const responseText = pm.response.text();
const match = responseText.match(/token:\s*"([^"]+)"/);
if (match) \\\\{
    pm.environment.set("extractedToken", match[1]);
\\\\}

Colección Runner

Running Collections

// Collection variables
pm.collectionVariables.set("baseUrl", "https://api.example.com");
pm.collectionVariables.get("baseUrl");

// Data-driven testing
// Use CSV or JSON files for test data
// Access data using pm.iterationData.get("fieldName")

// Workflow control
postman.setNextRequest("Request Name");
postman.setNextRequest(null); // Stop execution

Autenticación Flujos de trabajo

Token del portador

// Pre-request script for login
pm.sendRequest(\\\\{
    url: pm.environment.get("baseUrl") + "/auth/login",
    method: "POST",
    header: \\\\{
        "Content-Type": "application/json"
    \\\\},
    body: \\\\{
        mode: "raw",
        raw: JSON.stringify(\\\\{
            username: pm.environment.get("username"),
            password: pm.environment.get("password")
        \\\\})
    \\\\}
\\\\}, function (err, response) \\\\{
    if (response.code === 200) \\\\{
        const token = response.json().token;
        pm.environment.set("authToken", token);
    \\\\}
\\\\});

OAuth 2.0

// OAuth 2.0 configuration
const clientId = pm.environment.get("clientId");
const clientSecret = pm.environment.get("clientSecret");
const tokenUrl = pm.environment.get("tokenUrl");

pm.sendRequest(\\\\{
    url: tokenUrl,
    method: "POST",
    header: \\\\{
        "Content-Type": "application/x-www-form-urlencoded"
    \\\\},
    body: \\\\{
        mode: "urlencoded",
        urlencoded: [
            \\\\{key: "grant_type", value: "client_credentials"\\\\},
            \\\\{key: "client_id", value: clientId\\\\},
            \\\\{key: "client_secret", value: clientSecret\\\\}
        ]
    \\\\}
\\\\}, function (err, response) \\\\{
    if (response.code === 200) \\\\{
        const accessToken = response.json().access_token;
        pm.environment.set("accessToken", accessToken);
    \\\\}
\\\\});

API Testing Workflows

Pruebas de operaciones de CRUD

// 1. Create Resource (POST)
pm.test("Create user successfully", function () \\\\{
    pm.response.to.have.status(201);
    const user = pm.response.json();
    pm.environment.set("createdUserId", user.id);
\\\\});

// 2. Read Resource (GET)
pm.test("Get user successfully", function () \\\\{
    pm.response.to.have.status(200);
    const user = pm.response.json();
    pm.expect(user.id).to.eql(pm.environment.get("createdUserId"));
\\\\});

// 3. Update Resource (PUT/PATCH)
pm.test("Update user successfully", function () \\\\{
    pm.response.to.have.status(200);
\\\\});

// 4. Delete Resource (DELETE)
pm.test("Delete user successfully", function () \\\\{
    pm.response.to.have.status(204);
\\\\});

Pruebas de manipulación de errores

// Test error responses
pm.test("Returns 400 for invalid data", function () \\\\{
    pm.response.to.have.status(400);
    const error = pm.response.json();
    pm.expect(error).to.have.property("message");
\\\\});

pm.test("Returns 401 for unauthorized access", function () \\\\{
    pm.response.to.have.status(401);
\\\\});

pm.test("Returns 404 for non-existent resource", function () \\\\{
    pm.response.to.have.status(404);
\\\\});

Buenas prácticas

Organización

• Utilizar colecciones para solicitudes relacionadas con grupos
• Crear carpetas dentro de colecciones para agrupación lógica
• Usar nombres descriptivos para solicitudes y colecciones
• Document APIs utilizando descripciones de la colección
• Use variables de entorno para diferentes etapas (dev, estadificación, prod)

Estrategia de ensayo

• Escribe scripts de prueba completos
• Prueba tanto escenarios positivos como negativos
• Estructura de respuesta validada y tipos de datos
• Compruebe los tiempos de respuesta y el rendimiento
• Prueba de errores de manejo y casos de borde

Gestión de datos

• Utilice variables de entorno para la configuración
• Realizar pruebas basadas en datos con archivos CSV/JSON
• Limpiar los datos de prueba después de la ejecución de pruebas
• Utilice variables dinámicas para datos de prueba únicos
• Datos de prueba separados de los datos de producción

Colaboración

• Compartir colecciones con miembros del equipo
• Control de versiones para las exportaciones de colecciones
• Cambios en la API de documentos y actualizaciones de pruebas
• Crear scripts de prueba reutilizables y snippets
• Establecer convenciones y normas para nombrar nombres