JSPM

@qavajs/core

@qavajs/core is the core and test runner module of the qavajs automation framework.

npm install @qavajs/core

Run tests

npx qavajs --config <config> --profile <profile>

Memory value parameter type

value parameter type provides API to access memory

When('Read memory {value}', async function(memoryValue) {
    expect(memoryValue.value()).toEqual('ts');
});

When('Set memory {value} as {string}', async function(memoryKey, value) {
    memoryKey.set(value);
});

Validation parameter type

validation parameter type provides an API to verify values by a certain condition

When('I expect {string} {validation} {string}', async function(value1, validate, value2) {
    validate(value1, value2);
});

World

Module extends CucumberJS world with additional entities

Soft Validation

You can use the softly prefix before expect.

Feature: Feature

  Scenario: verify soft assert
    # first step fails, but other steps will not be skipped
    Then I expect '2' to softly equal '1'
    # pass
    And I expect '1' to softly equal '1'
    # fail
    And I expect '2' to softly equal '1'
    # skip
    And I expect '1' to softly equal '1'

Execute steps from other steps

It is possible to implement complex logic using built-in qavajs steps via executeStep world method

When('I do smth complex', async function() {
    await this.executeStep(`I type 'username' to 'Username Input'`);
    await this.executeStep(`I type 'password' to 'Password Input'`);
    await this.executeStep(`I click 'Login Button'`);
    await this.executeStep(`I fill following fields`, new DataTable([
        [ 'Order', '123' ],
        [ 'Delivery Location', 'New York' ]
    ]))
});

Execute other tests

Also, it is possible to call other test cases via executeTest world method

When('I do smth complex', async function() {
    await this.executeTest('feature/Login.feature', 'Login');
});

Override step definition

Override function provides the capability to override step implementation and avoid ambiguous exceptions

import { Override } from '@qavajs/core';

When('I do test', async function () {});

Override('I do test', async function () {
    console.log('I am overridden');
});

Fixture

Fixture provides a convenient way to prepare a test environment for specific test.

This example will open pdp page before test and clean the cart after the test

import { Fixture } from '@qavajs/core';

Fixture('pdp', async function() {
    await this.playwright.page.goto('https://my-site/pdp');
    // fixture may return function that will be executed after test
    return async function() {
        await this.playwright.page.request.get('/cleanCart');
    }
});

Feature: feature with fixture

  @pdp
  Scenario: scenario with fixture
    When I click 'qavajs T-shirt'
    And I click 'cart icon'
    Then I expect 'qavajs T-shirt cart item' to be visible

Template

Template provides a way to define step definition using Gherkin language

import { When, Template } from '@qavajs/core';

When('I click {string} and verify {string}', Template((locator, expected) => `
    I click '${locator}'
    I expect '${locator} > Value' to equal '${expected}'
`));

Test Execution Hooks

BeforeExecution and AfterExecution allow to define hooks that will be executed once before/after the whole test execution

import { BeforeExecution, AfterExecution } from '@qavajs/core';
import { Server } from './server';

const server = new Server();

BeforeExecution(async function () {
    await server.start();
});

AfterExecution(async function () {
    await server.stop();
});

Override memory values

In case if tests need to be run with updated memory value they can be passed via CLI (e.g run scenarios on some other url) It can be done by passing --memory-values parameter which is JSON with params that need to be overridden

npx qavajs --config config.ts --memory-values '{"url": "https://github.com"}'

it will override $url memory value

Pass CLI params to workers

All params that you passed to qavajs cli will be available in CLI_ARGV environment variable in all child workers.

Service

Services are entities that can execute logic before and after the whole test run.

import externalService from './externalService';

export default {
    service: [
        {
            options: {
                data: 42
            },
            before() {
                console.log(this.options.data);
            },
            after(result) {
                if (!result.success) process.exitCode = 1;
            }
        },
        {
            options: {
                data: 42
            },
            ...externalService
        }
    ]
}

There is a one-minute default timeout for the before and after test logic to prevent the entire process from freezing. To set up a custom timeout in milliseconds, use serviceTimeout property in the config file

export default {
    serviceTimeout: 1_200_000
}