Artillery + Playwright: Login once using before

[sthavamani-ut]

Hi, all! It's me again, your novice who is trying to use artillery + playwright.

I am using the Playwright engine with artillery and I am running into a scenario where I want to authenticate just once and then have all the vusers share that authenticated session. I tried a before but that did not seem to work.

I also have my Playwright code using a setup method.

Any help would be much appreciated. I think I am missing something obvious.

Thank you for the help!

[angelo-loria]

I'm also confused on how before/beforeScenario works with the Playwright engine. This starts executing testFunction, skipping the beforeScenario:

scenarios:
    - engine: playwright
      beforeScenario: "login"
      testFunction: "testFunction"

[angelo-loria]

Alright figured this out, although there might be a cleaner way to do it. I'm using a before section with a function that POSTs to a login API and then writes the response token I need to a JSON file (emulating the storageState function in Playwright.) This JSON file is then specified in the Playwright contextOptions.

My Artillery config:

config:
    target: https://siteUnderTest.com/
    engines:
        playwright: {
                contextOptions: { storageState: "state.json" },
            }
    processor: "./processors/playwright-flows.js"

before:
    flow:
        - function: postLogin

scenarios:
    - name: playwright flow
      engine: playwright
      testFunction: playwrightFlow

My JS script:

module.exports = { playwrightFlow, postLogin };
const playwright = require("playwright");

async function postLogin(context, ee, next) {
    const apiContext = await playwright.request.newContext({
        storageState: undefined,
    });
    const response = await apiContext.post(
        "https://siteUnderTest.com/api/v1/sign-in",
        {
            data: {
                username: "userName",
                password: "password",
            },
        }
    );
    const loginResponse = await response.json();
    var stateJson = {
        cookies: [
            {
                name: "token",
                value: loginResponse.user.token,
                domain: "https//www.siteUnderTest.com",
                path: "/",
                expires: -1,
                httpOnly: false,
                sameSite: "Lax",
                secure: true,
            },
        ],
    };
    const fs = require("fs");
    fs.writeFile(
        "state.json",
        JSON.stringify(stateJson, null, 2),
        function (err) {
            if (err) throw err;
        }
    );
    next();
}

async function playwrightFlow(page) {
    await page.goto(
        "https://siteUnderTest.com/home"
    );
    ...

[bernardobridge]

👋 You can now use engine: playwright correctly in before/after, since Artillery v2.0.4: https://github.com/artilleryio/artillery/releases/tag/artillery-2.0.4

Example of reusing authentication with storageState: https://github.com/artilleryio/artillery/tree/main/examples/browser-playwright-reuse-authentication

Note: beforeScenario is still not supported in the Playwright engine, but I believe a before hook better suits what was being attempted in this topic!

[bernardobridge]

@alexandre-embie, to use this with Artillery, an empty object in the specified storage.json file needs to exist before running the test ({}), as mentioned here: https://github.com/artilleryio/artillery/tree/main/examples/browser-playwright-reuse-authentication#example

That should be the issue. 🤞

---

P.S. I also noticed includeFiles is on the root, rather than under config in your example. If you're doing this using Fargate, you'll need to set that correctly config.includeFiles).

[alexandre-embie]

@bernardobridge I have the file in my load dir as can be seen here 🤔

[bernardobridge]

@alexandre-embie looks like it might be a bug on our side, I can reproduce it. We will tackle this soon . Thanks! 🙇

[priyankshivhare-mb]

Do you happen to have any updates on this? I'm facing similar issues when I run Artillery inside ADO pipeline, it works locally.

[bernardobridge]

Hi @priyankshivhare-mb , yes, planning on providing a workaround with updated example for the next release (should be May 13th - we release every 2 weeks).

[bernardobridge]

Hello @priyankshivhare-mb , @alexandre-embie and others 👋 . This should now be fixed in Artillery v2.0.12.

The example has been updated with the needed changes: https://github.com/artilleryio/artillery/tree/main/examples/browser-playwright-reuse-authentication

[HugoImaios]

Helllo @bernardobridge 👋
By any chance, is there another example (somewhere hidden or in draft?) with reusing authentication per VU instead of one auth for all of them ?
I'm currently putting it together but it's not that simple 😄

[bernardobridge]

Hey @HugoImaios 👋 What would it mean to reuse authentication per VU though? Wouldn't a single VU already be logging into the app itself each time the VU executes?

[HugoImaios]

yes you right I failed to explain. I confused VU and the users I have in my CSV file.
My use case would be to be able to run a login load test which only login (and maybe a few expects) but stores the storage state per user.
Then in other tests, with the same users, I could reuse the storage state to load test only the features needed, with no need for login each user again

[HugoImaios]

I made some abstraction in my playwright fixtures which already have a similar usage (except they are based on the parallelIndex provided by test info), and it works :)

[HugoImaios]

but my dream is still having fields from csv as variables available in the config, allowing for something like :

config:
    target: 'https://www.domain.com'
    engines:
        playwright:
            contextOptions:
                storageState: "{{ $dirname }}/storageState/{{ username }}.json"
    payload:
        -   path: 'users.csv'
            fields:
                - "username"
                - "password"
            order: sequence

😍

(currently username is undefined, breaking this poc and forcing me to create a new context/page with the user-dependant storagePath at runtime)