nativeproof 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to NativeProof are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/) and the project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## 0.9.0
+
+Regex frame matching — `expect(mock)` matches traffic by pattern.
+
+**Added**
+
+- **`toHaveSent` / `toHaveReceived` (and `FrameMatch`) accept a `RegExp`** for `path`, `type`, and any
+  payload field — `expect(mock).toHaveSent({ path: /\/users/, type: "request" })` matches a
+  query-suffixed or otherwise variable path, mirroring regex selectors on the locator side. A string
+  stays an exact match (deep equality for payload objects); a RegExp tests the actual string value.
+
 ## 0.8.0
 
 Relative locators — `Locator.near` scopes to the match nearest an anchor.

package/README.md

@@ -555,7 +555,8 @@ test.describe("chat room", "member", () => {
 - `mock.route(path).reject({ code })` — fail it (HTTP status, or WebSocket close code 3000–4999).
 - `mock.route(path).abort()` — drop the connect/request entirely.
 - `expect(mock).toHaveSent(match)` / `toHaveReceived(match)` — `match` is a partial frame:
-  `path` / `type` plus any payload fields.
+  `path` / `type` plus any payload fields. Each field is a string (exact / deep-equal) **or a `RegExp`**
+  (`toHaveSent({ path: /\/users/, type: "request" })`) to match a query-suffixed or variable path.
 
 **Frame types** — real protocol messages keep their own `type` (a WS JSON message's `type`); the
 server also synthesises types for primitives so you can assert on them:

package/dist/mock.d.ts

@@ -18,8 +18,8 @@ export interface MockFrame {
 }
 /** A partial frame to match against: `path` / `type` plus any payload fields. */
 export interface FrameMatch {
-    path?: string;
-    type?: string;
+    path?: string | RegExp;
+    type?: string | RegExp;
     [key: string]: unknown;
 }
 /** Controls how an intercepted path replies — the Playwright `Route` equivalent. */

package/dist/mock.js

@@ -1,23 +1,33 @@
 import { isDeepStrictEqual } from "node:util";
+/**
+ * Match one field of an observed frame against an expected value: a `RegExp` tests the
+ * actual string (so paths with query/suffix match — `toHaveSent({ path: /\/users/ })`),
+ * anything else is deep structural equality.
+ */
+function fieldMatches(actual, expected) {
+    if (expected instanceof RegExp)
+        return typeof actual === "string" && expected.test(actual);
+    return isDeepStrictEqual(actual, expected);
+}
 /**
  * True if `frame` satisfies every field of `match`: `path` / `type` at the top level,
  * every other key against the frame's payload.
  */
 export function matchesFrame(frame, match) {
-    if (match.path !== undefined && frame.path !== match.path)
+    if (match.path !== undefined && !fieldMatches(frame.path, match.path))
         return false;
-    if (match.type !== undefined && frame.type !== match.type)
+    if (match.type !== undefined && !fieldMatches(frame.type, match.type))
         return false;
     for (const [key, value] of Object.entries(match)) {
         if (key === "path" || key === "type")
             continue;
-        if (!isDeepStrictEqual(frame.payload?.[key], value))
+        if (!fieldMatches(frame.payload?.[key], value))
             return false;
     }
     return true;
 }
 export function describeMatch(match) {
-    return JSON.stringify(match);
+    return JSON.stringify(match, (_key, value) => (value instanceof RegExp ? String(value) : value));
 }
 /** Single-shot check: does any observed frame match `match` in `direction`? */
 export async function frameExists(source, direction, match) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nativeproof",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "license": "MIT",
   "type": "module",
   "description": "Native Mobile E2E test framework inspired by Playwright (fixtures, locators, expect, route-style mocking) on Appium/WebdriverIO.",