nativeproof 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@ 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.10.0
+
+Element enabled-state assertions.
+
+**Added**
+
+- **`Locator.isEnabled()` / `isDisabled()` and `expect(locator).toBeEnabled()` / `toBeDisabled()`** —
+  read the matched element's `enabled` attribute (present and not `enabled="false"` is enabled, matching
+  Playwright's default-enabled semantics). Auto-waiting, `.not` inverts. For asserting a button/control
+  flips between enabled and disabled as a form validates.
+
+## 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

@@ -489,6 +489,7 @@ await expect(member.spinner).not.toBeVisible({ timeout: 5_000 });
 - `toShow(text, opts?)` — the selector is present **and** `text` appears in the source.
 - `toHaveText(text, opts?)` — the matched node's **own** text contains / matches `text`.
 - `toBeChecked(opts?)` — the matched checkbox / switch is checked (`checked="true"`).
+- `toBeEnabled(opts?)` / `toBeDisabled(opts?)` — the matched element's `enabled` state.
 - `toHaveCount(n, opts?)` — exactly `n` elements match the selector.
 - `opts` is `{ timeout?, interval? }` (ms).
 
@@ -555,7 +556,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/expect.d.ts

@@ -16,6 +16,10 @@ export interface LocatorAssertions {
     toHaveText(text: string | RegExp, options?: WaitOptions): Promise<void>;
     /** The matched checkbox/switch is checked (`checked="true"`). */
     toBeChecked(options?: WaitOptions): Promise<void>;
+    /** The matched element is enabled (present and not `enabled="false"`). */
+    toBeEnabled(options?: WaitOptions): Promise<void>;
+    /** The matched element is present and `enabled="false"`. */
+    toBeDisabled(options?: WaitOptions): Promise<void>;
     /** Exactly `count` elements match the selector. */
     toHaveCount(count: number, options?: WaitOptions): Promise<void>;
 }

package/dist/expect.js

@@ -28,6 +28,12 @@ class LocatorExpectation {
     toBeChecked(options = {}) {
         return this.check(() => this.locator.isChecked(), "be checked", options);
     }
+    toBeEnabled(options = {}) {
+        return this.check(() => this.locator.isEnabled(), "be enabled", options);
+    }
+    toBeDisabled(options = {}) {
+        return this.check(() => this.locator.isDisabled(), "be disabled", options);
+    }
     toHaveCount(count, options = {}) {
         return this.check(async () => (await this.locator.count()) === count, `have count ${count}`, options);
     }

package/dist/locator.d.ts

@@ -130,6 +130,10 @@ export declare class Locator {
     fill(text: string, options?: WaitOptions): Promise<void>;
     /** True if the matched node is a checked checkbox/switch (`checked="true"`). */
     isChecked(): Promise<boolean>;
+    /** True if the matched node is present and not `enabled="false"` (matches Playwright's default-enabled). */
+    isEnabled(): Promise<boolean>;
+    /** True if the matched node is present and explicitly `enabled="false"`. */
+    isDisabled(): Promise<boolean>;
     /** Tap to bring a checkbox/switch to checked; a no-op if it already is. */
     check(options?: WaitOptions): Promise<void>;
     /** Tap to bring a checkbox/switch to unchecked; a no-op if it already is. */

package/dist/locator.js

@@ -212,6 +212,16 @@ export class Locator {
         const node = this.pick(await this.matchedNodes());
         return node !== null && /\bchecked="true"/.test(node);
     }
+    /** True if the matched node is present and not `enabled="false"` (matches Playwright's default-enabled). */
+    async isEnabled() {
+        const node = this.pick(await this.matchedNodes());
+        return node !== null && !/\benabled="false"/.test(node);
+    }
+    /** True if the matched node is present and explicitly `enabled="false"`. */
+    async isDisabled() {
+        const node = this.pick(await this.matchedNodes());
+        return node !== null && /\benabled="false"/.test(node);
+    }
     /** Tap to bring a checkbox/switch to checked; a no-op if it already is. */
     async check(options = {}) {
         await this.setChecked(true, options);

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.10.0",
   "license": "MIT",
   "type": "module",
   "description": "Native Mobile E2E test framework inspired by Playwright (fixtures, locators, expect, route-style mocking) on Appium/WebdriverIO.",