Which built-in helper functions can the `Scenario` name of a Karate mock feature call, and what do you do when none of them expresses the match you need?

## The helpers in scope The mock handler puts a fixed set of functions into the engine before it evaluates any scenario name, so they are available both in the name (to route) and in the steps below it (to process): | Helper | Answers | Returns | |---|---|---| | `pathMatches(pattern)` | does the path fit this shape, with `{name}` placeholders | boolean, and fills `pathParams` | | `methodIs(name)` | is this the HTTP method — case-insensitive, so `'get'` is fine | boolean | | `typeContains(text)` | does the `Content-Type` header contain this substring | boolean | | `acceptContains(text)` | does the `Accept` header contain this substring | boolean | | `headerContains(name, value)` | does any value of this header contain this substring | boolean | | `paramExists(name)` | is this query or form parameter present | boolean | | `paramValue(name)` | the first value of that parameter, or `null` | string | | `bodyPath(expr)` | a value from the request body by JsonPath, or XPath when the expression starts with `/` | any, `null` on failure | `pathParams` sits alongside them as a **map, not a function** — it is the output of a successful `pathMatches()` call, not something you call yourself. ## Composition, not configuration Every one of those is an ordinary function call inside an ordinary JavaScript expression, which is the whole point of the design. There is no matcher object to build and nothing to register, so routing conditions are assembled with the operators the language already has: ```gherkin Scenario: pathMatches('/cats/{id}') && methodIs('get') && acceptContains('json') * def response = cats[pathParams.id] Scenario: pathMatches('/cats') && methodIs('post') && bodyPath('$.name') == 'Billie' * def response = { id: 1, name: 'Billie' } * def responseStatus = 201 ``` Two of the helpers return values rather than booleans — `paramValue()` and `bodyPath()` — so they belong in a **comparison**, never on their own. A name ending in `&& paramValue('type')` yields a string, and a string is not a match. ## When no helper fits The escape hatch is the language, not a plugin. The request is already in scope as variables, so anything you can express in JavaScript is a legal matcher: - `requestPath.startsWith('/legacy/')` — a prefix, which `pathMatches()` cannot do; - `requestPath.split('/').length > 4` — depth; - `requestUri.indexOf('debug') != -1` — anything in the path *or* the query string, since `requestUri` keeps the query string and `requestPath` does not; - `requestHeaders['x-tenant'][0] == 'acme'` — an exact header value rather than a substring; - `request.type == 'cat' && request.tags.length > 2` — the parsed body directly, which is usually clearer than `bodyPath()` for JSON; - `!pathMatches('/health')` — negation, to keep one probe path out of a broad stub. The variables available to a name in both released lines are `request` (the parsed body), `requestBytes`, `requestUrlBase`, `requestPath`, `requestUri`, `requestMethod`, `requestHeaders`, `requestParams` and `requestParts`. ## The version split to keep straight `headerValue(name)` — returning one header's value as a string instead of a substring test — is a **Karate 2.x** helper. It is not registered in 1.5.2, and a scenario name that calls it there throws while being evaluated, which the handler treats as *did not match*, so the stub simply never fires. On 1.5.2 the equivalents are `headerContains('authorization', 'Bearer ')` for a substring test or reaching into `requestHeaders` for an exact one. ## A note on what the helpers do not do Each helper is deliberately shallow, and knowing where each one stops saves an afternoon: - `typeContains('json')` is a **substring** test, so it also matches `application/ld+json` and any charset suffix — convenient, and occasionally too generous; - `headerContains(name, value)` is a substring test too, across **any** value of a repeated header, so it cannot express "this header equals exactly this"; - `paramValue()` returns only the **first** value of a repeated parameter, and `null` when it is absent; - `bodyPath()` swallows its own failures and returns `null` rather than throwing, so a wrong path looks the same as a missing field; - `methodIs()` compares case-insensitively, which is why `methodIs('get')` and `methodIs('GET')` are equivalent. ## Interview framing Nobody is checking whether you can recite eight names. What the question is really probing is whether you understand that Karate's mock has **no matcher DSL at all** — it hands you a handful of convenience functions over a JavaScript expression, and everything beyond them is code you write in place. Candidates who have used stub-server products often look for the equivalent of a matcher plugin; the honest answer is that there is nothing to plug in, and that this is a deliberate trade: complete flexibility, no schema, and no tooling that can tell you a condition is unreachable.