Model

Generated on 2026-10-03 from docs/api/model.md in the repository (commit f26b8022e0f8 of 2026-10-03) by tools/build-api-v3.py. The text is the repository's, not edited here. The samples with imports type-check against the published package 3.3.1; no known deviations.

The model module defines the core interfaces and classes that represent tables, test case definitions, and directives. Every table type (decision, matrix, specification) implements these interfaces, and every processor operates on them.

import {
  DirectiveBase,
  StaticDirective,
  GeneratorDirective,
  ReferenceDirective,
  FieldDirective,
  PREFIX_GENERATOR,
  PREFIX_REFERENCE
} from '@xhubio/nanook-table'
import type {
  TableInterface,
  TestcaseDefinitionInterface,
  TestcaseDirectivesInterface,
  MetaTable,
  MetaTestcase,
  FilterInterface
} from '@xhubio/nanook-table'

TableInterface

Common interface implemented by all table models (TableDecision, TableMatrix). The processor operates on this interface without knowing the concrete table type.

Properties

Methods

getTestcaseForName(testcaseName: string): TestcaseDefinitionInterface

Returns the test case definition with the given name. Throws an error if no test case with that name exists in the table.

const table: TableInterface = // ... loaded table
const tc = table.getTestcaseForName('tc1')
console.log(tc.testcaseMeta.testcaseName, tc.execute)

getTestcasesForExecution(): Generator<TestcaseDefinitionInterface>

A generator function that yields all test case definitions that should be executed. In a decision table these are the columns with a true Execute value, each once per Multiplicity (named <column>.1, <column>.2, …); NeverExecute only takes effect when another test case references the column.

for (const tc of table.getTestcasesForExecution()) {
  console.log(tc.testcaseMeta.testcaseName)
}

processRanges(testcaseName: string): string[]

Parses a test case name that may contain a range expression and returns an array of individual test case names. A range is written in square brackets, with comma-separated elements: '[tc12-14]' expands to ['tc12', 'tc13', 'tc14'], '[1,5]' to ['1', '5']. A name without brackets returns a single-element array.

const names = table.processRanges('[tc3-5]')
// ['tc3', 'tc4', 'tc5']

TestcaseDefinitionInterface

Interface for a single test case definition within a table. Each column in a decision table or each combination in a matrix table produces one test case definition.

Properties

Methods

createDirectives(): TestcaseDirectivesInterface

Analyzes the test case data and creates all directives needed to generate this test case. This is the primary method that translates spreadsheet cell values into actionable generation instructions.

const directives = testcase.createDirectives()

for (const sd of directives.static) {
  console.log(`Static: ${sd.fieldName} = ${sd.value}`)
}

for (const gd of directives.generator) {
  console.log(`Generator: ${gd.fieldName} -> ${gd.generatorName}`)
}

for (const rd of directives.reference) {
  console.log(`Reference: ${rd.fieldName} -> ${rd.targetTableName}.${rd.targetFieldName}`)
}

createTags(): string[]

Returns all tags defined for this test case. Tags come from TagSection rows in the table and are used for filtering.

const tags = testcase.createTags()
// ['smoke', 'regression', 'login']

createFilter(): FilterInterface[]

Returns all filter definitions for this test case. Each filter names a filter processor and an expression.

const filters = testcase.createFilter()
for (const f of filters) {
  console.log(`Filter: ${f.filterProcessorName} = ${f.expression}`)
}

createGeneratorSwitches(): string[]

Returns a list of generator names that should be switched off (not executed) for this test case.

const switches = testcase.createGeneratorSwitches()
// ['generatorPassword'] -- this generator will be skipped

TestcaseDirectivesInterface

The return type of createDirectives(). Groups all directives by type.

interface TestcaseDirectivesInterface {
  generator: GeneratorDirectiveInterface[]
  static: StaticDirectiveInterface[]
  reference: ReferenceDirectiveInterface[]
  field: FieldDirectiveInterface[]
}

DirectiveBase

Abstract base class for all directive types. Contains the metadata common to every directive.

Properties

StaticDirective

Extends DirectiveBase. Represents a literal value that should be written directly to the test case output without calling a generator.

Properties

In the spreadsheet, any cell value in the generator column that does not start with a recognized prefix (gen: or ref:) is treated as static data.

GeneratorDirective

Extends DirectiveBase. Represents a call to a named data generator. Created when a cell value starts with the gen: prefix.

Properties

Spreadsheet Syntax

gen:<instanceIdSuffix>:<generatorName>:<config>

Examples:

• gen::faker:person.firstName -- call the generator registered as faker with the config person.firstName
• gen:pwd:password:8 -- call the generator registered as password with the config 8; instance ID suffix pwd

Full description: docs/guide/directives.md.

ReferenceDirective

Extends DirectiveBase. Represents a reference to data generated by another table and test case. Created when a cell value starts with the ref: prefix.

Properties

Spreadsheet Syntax

ref:<instanceIdSuffix>:<targetTableName>:<targetFieldName>:<targetTestcaseName>

The instance ID suffix is the second part, not a trailing parenthesis: the implementation reads parts[1] for it (see createReferenceDirective). Full description with examples: docs/guide/directives.md.

FieldDirective

Extends DirectiveBase. Represents a marked row of a MultiRowSection (for example an Expected Result row). Each one becomes an entry { key, comment, other } in the array the field holds in the test case data.

Properties

FilterInterface

Defines a filter that can be applied to test cases during processing.

Properties

MetaTable

Metadata about a table's origin.

Properties

MetaTestcase

Metadata about a specific test case. Extends the table metadata with test case identification.

Properties

Constants