@qavajs/memory

Unified test data storage for the @qavajs framework. Provides a singleton memory store with support for constants, computed values, string interpolation, and parallel test data assignment.

npm install @qavajs/memory

Usage

Import the singleton and use getValue/setValue in your step definitions:

import memory from '@qavajs/memory';

When(/^save variable as '(.+)'$/, async function (key) {
  memory.setValue(key, 42);
});

Then(/^value '(.+)' should be equal to '(.+)'$/, async function (variable1, variable2) {
  const val = memory.getValue(variable1);
  expect(val).to.equal(variable2);
});

When save variable as 'variable'
Then value of '$variable' should be equal to '42'

getValue passes non-string values through unchanged, so it is safe to call on any step parameter.

Register constants and computed values

Define a memory map with constants and computed functions, then register it before your tests run:

// memoryMap.ts
export default {
  constant: 42,
  baseUrl: 'https://example.com',
  now: function () {
    return Date.now();
  },
  uuid: function () {
    return crypto.randomUUID();
  },
};

// hooks.ts
import memory from '@qavajs/memory';
import memoryMap from './memoryMap.js';

Before(async function () {
  memory.register(memoryMap);
});

Plain properties are constants; function properties are computed — they are evaluated each time getValue resolves them.

Value resolution syntax

Simple key lookup

Prefix a key with $ to look it up in memory:

Then value of '$variable' should equal '42'

Property access

Dot notation and bracket notation both work:

Then value of '$user.name' should equal 'Alice'
Then value of '$items[0]' should equal 'first'

Calling computed functions with arguments

Then value of '$add(1, 2)' should equal '3'

String interpolation

Wrap $key references in {...} to embed memory values inside a larger string:

Then endpoint '{$baseUrl}/api/users/{$userId}' should return 200

Built-in $js() computed

Evaluate arbitrary JavaScript expressions against the current memory storage:

Then value of '$js($counter + 1)' should equal '6'
Then value of '$js(JSON.stringify($user))' should be valid JSON

Escaping $

Prefix $ with a double backslash to treat it as a literal character:

When I expect text of 'Currency Label' to equal '\\$42'

API

memory.getValue(str)

Resolves a value from memory. Returns the input unchanged if it is not a string or contains no $ references.

| Parameter | Type | Description | |-----------|-------|--------------------------------------------| | str | any | String to resolve, or a pass-through value |

Returns any.

memory.setValue(key, value)

Stores a value in memory under key.

| Parameter | Type | Description | |-----------|----------|----------------| | key | string | Storage key | | value | any | Value to store |

memory.register(memoryMap)

Registers a memory map object as the backing storage. Call this once before your tests run. All keys from the map become resolvable via $key syntax.

| Parameter | Type | Description | |-------------|----------|-------------------------------| | memoryMap | object | Object of constants/computeds |

memory.setLogger(logger)

Attach a logger to trace value resolution. The logger receives a formatted string for each getValue call that transforms the input.

import memory from '@qavajs/memory';

memory.setLogger({ log: (msg) => console.log('[memory]', msg) });
// Output: [memory] $username -> alice
//         [memory] $counter <- 5

| Parameter | Type | Description | |-----------|---------------------------------|-----------------| | logger | { log: (value: any) => void } | Logger instance |

memory.convertToString(value)

Converts a value to a string for logging. Override this method to customize serialization (e.g. use util.inspect instead of JSON.stringify):

import util from 'util';
import memory from '@qavajs/memory';

memory.convertToString = function (value) {
  return util.inspect(value);
};

Parallel test data

When running Cucumber in parallel mode or using qavajs shards, use parallel to assign unique data per thread:

import { parallel } from '@qavajs/memory/utils';

export default class Memory {
  // Assigns by CUCUMBER_WORKER_ID (0-based)
  user = parallel([
    { username: 'user1', password: 'password' },
    { username: 'user2', password: 'password' },
  ]);

  // Assigns by worker + shard offset (requires SHARD env var)
  shardUser = parallel(
    [
      { username: 'user1', password: 'password' },
      { username: 'user2', password: 'password' },
      { username: 'user3', password: 'password' },
      { username: 'user4', password: 'password' },
    ],
    { shard: true }
  );
}

parallel reads CUCUMBER_WORKER_ID (default 0) and CUCUMBER_TOTAL_WORKERS from the environment. In shard mode it also reads SHARD (1-based) and multiplies across workers to produce a globally unique index.

License

MIT