No results for

Powered byAlgolia

Las cookies HTTP son utilizadas por los sitios web y las aplicaciones para almacenar piezas de información de estado en el dispositivo del usuario. Un servidor indica al cliente, a través de una cabecera HTTP Set-Cookie, qué información quiere que se almacene en la máquina del usuario.

El navegador del usuario almacenará los datos de la cookie y los asociará con el nombre de host del servidor, y para cada solicitud posterior a ese nombre de host, incluirá los datos de la cookie almacenados en una cabecera Cookie.

A continuación, puede controlar reglas más específicas sobre cuándo deben enviarse o no los datos de la cookie, incluyendo la limitación a subdominios específicos del dominio o a una ruta específica. También es posible establecer una fecha de caducidad en la cookie y decirle al navegador que sólo la envíe a través de conexiones cifradas (SSL/TLS).

Cookies en k6

En la mayoría de los casos, k6 gestionará de forma transparente la recepción, el almacenamiento y el envío de cookies, tal y como se ha descrito anteriormente, de modo que las pruebas de su sitio web o aplicación basados en cookies funcionarán sin que usted tenga que hacer nada especial.

En algunos casos de uso, puede desear un mayor control sobre las cookies. En k6 tienes dos opciones, o bien manipular directamente las cabeceras HTTP, o utilizar la más ergonómica API de cookies. A continuación veremos esto último.

Simple configuración de las cookies

Para simular que una cookie ha sido previamente establecida por un navegador y ahora se supone que se incluye en una solicitud posterior al servidor, incluimos la cookie en el parámetro de solicitud de cookies:

1import http from 'k6/http';
2
3export default function () {
4 http.get('https://httpbin.org/cookies', {
5 cookies: {
6 my_cookie: 'hello world',
7 },
8 });
9}

Esto sólo aplicará la cookie para la solicitud en cuestión, pero no se enviará para las solicitudes posteriores. Si quieres hacer esto tienes que añadir la cookie a un cookies jar, y por defecto hay un cookies jar por VU, con el que podemos interactuar para establecer e inspeccionar las cookies:

1import http from 'k6/http';
2
3export default function () {
4 const jar = http.cookieJar();
5 jar.set('https://httpbin.org/cookies', 'my_cookie', 'hello world');
6 http.get('https://httpbin.org/cookies');
7}

El cookies jar por VU almacena todas las cookies recibidas del servidor en una cabecera Set-Cookie. También puede crear "cookies jar locales" que anulen el cookies jar por VU, pero puede encontrar más sobre esto más adelante.

También se puede especificar que una cookie debe ser anulada si ya forma parte del cookie jar por VU:

1import http from 'k6/http';
2import { check } from 'k6';
3
4export default function () {
5 const jar = http.cookieJar();
6 jar.set('https://httpbin.org/cookies', 'my_cookie', 'hello world');
7
8 const cookies = {
9 my_cookie: {
10 value: 'hello world 2',
11 replace: true,
12 },
13 };
14
15 const res = http.get('https://httpbin.org/cookies', {
16 cookies,
17 });
18
19 check(res, {
20 'cookie has correct value': (r) =>
21 r.cookies.my_cookie[0].value === 'hello world 2',
22 });
23}

Accediendo a las cookies

Para ver qué cookies se establecieron para una respuesta en particular podemos mirar en la propiedad cookies del objeto respuesta:

1import http from 'k6/http';
2import { check } from 'k6';
3
4export default function () {
5 const res = http.get(
6 'https://httpbin.org/cookies/set?my_cookie=hello%20world',
7 { redirects: 0 },
8 );
9 check(res, {
10 "has cookie 'my_cookie'": (r) => r.cookies.my_cookie.length > 0,
11 'cookie has correct value': (r) =>
12 r.cookies.my_cookie[0].value === 'hello world',
13 });
14}

La propiedad cookies del objeto de respuesta es un mapa en el que la clave es el nombre de la cookie y el valor es un array de objetos cookie de respuesta (ver más abajo la descripción). Es un array para soportar múltiples cookies que tengan el mismo nombre (pero diferentes atributos domain y/o path), lo cual es parte de la RFC6265.

Un objeto cookie de respuesta contiene las siguientes propiedades:

PropiedadTipoDescripción
namestringel nombre de la cookie
valuestringel valor de la cookie
domainstringdominio que decide a qué nombres de host debe enviarse esta cookie
pathstringlimitar el envío de la cookie sólo si la ruta de la solicitud coincide con este valor
expiresstringcuando la cookie expira, esto tiene que estar en el formato RFC1123 con un aspecto similar: Lun, 02 Ene 2006 15:04:05 MST
max_agenumberse utiliza para el mismo propósito que expira pero se define como el número de segundos que una cookie será válida
securebooleansi es verdadero, la cookie sólo se enviará a través de una conexión cifrada (SSL/TLS)
http_onlybooleansi es verdadero, la cookie no se expondrá a JavaScript en un entorno de navegador

Para ver qué cookies están establecidas, y almacenadas en el cookies jar, para una URL en particular podemos utilizar el método cookieForURL() del objeto cookies jar:

1import http from 'k6/http';
2import { check } from 'k6';
3
4export default function () {
5 let res = http.get(
6 'https://httpbin.org/cookies/set?my_cookie=hello%20world',
7 { redirects: 0 },
8 );
9 let jar = http.cookieJar();
10 let cookies = jar.cookiesForURL('http://httpbin.org/');
11 check(res, {
12 "has cookie 'my_cookie'": (r) => cookies.my_cookie.length > 0,
13 'cookie has correct value': (r) => cookies.my_cookie[0] === 'hello world',
14 });
15}

El objeto cookies devuelto por el método cookiesForURL() del jar es un mapa donde la clave es el nombre de la cookie y el valor es un array de valores de cookies (strings). Es un array para soportar múltiples cookies que tengan el mismo nombre (pero diferentes atributos domain y/o path), lo cual es parte de la RFC6265.

Configurando las cookies avanzadas con los atributos

Para establecer cookies que controlen de forma más estricta el comportamiento de la cookie debemos añadir la cookie a un cookies jar. Un ejemplo:

1import http from 'k6/http';
2import { check } from 'k6';
3
4export default function () {
5 let jar = http.cookieJar();
6 jar.set('https://httpbin.org/cookies', 'my_cookie', 'hello world', {
7 domain: 'httpbin.org',
8 path: '/cookies',
9 secure: true,
10 max_age: 600,
11 });
12 let res = http.get('https://httpbin.org/cookies');
13 check(res, {
14 'has status 200': (r) => r.status === 200,
15 "has cookie 'my_cookie'": (r) => r.cookies.my_cookie[0] !== null,
16 'cookie has correct value': (r) =>
17 r.cookies.my_cookie[0].value == 'hello world',
18 });
19}

Jar de cookies local

Además del cookies jar por VU, también puede crear el jar de cookies locales que pueden anular el jar de cookies de VU por solicitud. Un ejemplo:

1import http from 'k6/http';
2import { check } from 'k6';
3
4export default function () {
5 const jar = new http.CookieJar();
6
7 // Add cookie to local jar
8 const cookieOptions = {
9 domain: 'httpbin.org',
10 path: '/cookies',
11 secure: true,
12 max_age: 600,
13 };
14 jar.set(
15 'https://httpbin.org/cookies',
16 'my_cookie',
17 'hello world',
18 cookieOptions,
19 );
20
21 // Override per-VU jar with local jar for the following request
22 let res = http.get('https://httpbin.org/cookies', { jar });
23 check(res, {
24 'has status 200': (r) => r.status === 200,
25 "has cookie 'my_cookie'": (r) => r.cookies.my_cookie[0] !== null,
26 'cookie has correct value': (r) =>
27 r.cookies.my_cookie[0].value == 'hello world',
28 });
29}

Ejemplos

1// Example showing two methods how to log all cookies (with attributes) from a HTTP response.
2import http from 'k6/http';
3
4function logCookie(c) {
5 // Here we log the name and value of the cookie along with additional attributes.
6 // For full list of attributes see:
7 // https://k6.io/docs/using-k6/cookies#properties-of-a-response-cookie-object
8 const output = `
9 ${c.name}: ${c.value}
10 tdomain: ${c.domain}
11 tpath: ${c.path}
12 texpires: ${c.expires}
13 thttpOnly: ${c.http_only}
14 `;
15 console.log(output);
16}
17export default function () {
18 let res = http.get('https://www.google.com/');
19
20 // Method 1: Use for-loop and check for non-inherited properties
21 for (var name in res.cookies) {
22 if (res.cookies.hasOwnProperty(name) !== undefined) {
23 logCookie(res.cookies[name][0]);
24 }
25 }
26
27 // Method 2: Use ES6 Map to loop over Object entries
28 new Map(Object.entries(res.cookies)).forEach((v, k) => {
29 logCookie(v[0]);
30 });
31}