Fix/mock bridge (#22)

* test: improve missing coverage

* refactor: remove code duplication

* fix: improve coverage

* fix: intercept path error

* feat: run coverage report only on main

Author: kevinccbsg

.github/workflows/ci.yml

@@ -37,6 +37,7 @@ jobs:
 
   coverage:
     runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
     steps:
       - name: Checkout repo
         uses: actions/checkout@v5

src/cli/mock-sw.js

@@ -44,4 +44,8 @@ self.addEventListener("message", (event) => {
     rules.push(rule);
     console.log("Rule added:", rule);
   }
+  if (type === "CLEAR_RULES") {
+    rules = [];
+    console.log("All rules cleared");
+  }
 });

src/cli/utils/findRule.js

@@ -3,8 +3,10 @@
 
 export function findRule(method, url, rules) {
   return rules.find(
-    (r) =>
-      r.method === method &&
-      (typeof r.url === 'string' ? r.url === url : new RegExp(r.url).test(url))
-  );
+    (r) => {
+      const isMethodMatch = r.method.toLowerCase() === method.toLowerCase();
+      const isUrlMatch = typeof url === 'string'
+        ? r.url === url || r.url.includes(url) : new RegExp(url).test(r.url);
+      return isMethodMatch && isUrlMatch;
+  });
 }

src/commands/mockBridge.ts

@@ -19,7 +19,6 @@ export interface Options {
 }
 
 const rules: Rule[] = [];
-const waiters: Record<string, (rule: Rule) => void> = {};
 const SW_DELAY = 100;
 
 /**
@@ -36,10 +35,6 @@ export const initRequestMocking = async () => {
         if (rule) {
           rule.executed = true;
           rule.request = request;
-          if (waiters[alias]) {
-            waiters[alias](rule);
-            delete waiters[alias];
-          }
         }
       }
     });
@@ -94,9 +89,7 @@ export const waitForRequest = async (alias: string): Promise<Rule> => {
   await sleep(SW_DELAY);
   const rule = rules.find((r) => r.alias === alias && r.executed);
   if (rule) return Promise.resolve(rule);
-  return new Promise((resolve) => {
-    waiters[alias] = resolve;
-  });
+  throw new Error("Rule not found or not executed");
 };
 
 /**
@@ -109,5 +102,9 @@ export const getRequestMockRules = () => rules;
  * Clear all request mock rules.
  */
 export const clearRequestMockRules = () => {
+  // Also tell the SW
+  navigator.serviceWorker.controller?.postMessage({
+    type: "CLEAR_RULES",
+  });
   rules.length = 0;
 };

src/tests/cli/findRule.spec.js

@@ -14,10 +14,51 @@ describe('findRule', () => {
 
   it('matches by regex url', () => {
     const rules = [
-      { method: 'GET', url: /^https:\/\/foo\..+/, alias: 'a' },
+      { method: 'GET', url: 'https://foo.com', alias: 'a' },
     ];
-    expect(findRule('GET', 'https://foo.com', rules)).toEqual(rules[0]);
-    expect(findRule('GET', 'https://foo.org', rules)).toEqual(rules[0]);
+    expect(findRule('GET', /^https:\/\/foo\..+/, rules)).toEqual(rules[0]);
     expect(findRule('GET', 'https://bar.com', rules)).toBeUndefined();
   });
+
+  it('returns the first matching rule', () => {
+    const rules = [
+      { method: 'GET', url: 'https://foo.com', alias: 'first' },
+      { method: 'GET', url: 'https://foo.com', alias: 'second' },
+    ];
+    expect(findRule('GET', 'https://foo.com', rules)).toEqual(rules[0]);
+  });
+
+  it('should match by contains url', () => {
+    const rules = [
+      { method: 'GET', url: 'https://foo.com/api', alias: 'a' },
+    ];
+    expect(findRule('GET', 'https://foo.com/api', rules)).toEqual(rules[0]);
+    expect(findRule('GET', 'https://foo.com/api/users', rules)).toBeUndefined();
+    expect(findRule('GET', 'https://foo.com/home', rules)).toBeUndefined();
+  });
+
+  it('should match by regex', () => {
+    const rules = [
+      { method: 'GET', url: 'https://foo.com/api/users/preferences', alias: 'a' },
+    ];
+    expect(findRule('GET', /\/users\/*/, rules)).toEqual(rules[0]);
+  });
+
+  it('should match by contains some path of the url', () => {
+    const rules = [
+      { method: 'GET', url: 'https://foo.com/api', alias: 'a' },
+    ];
+    expect(findRule('GET', '/api', rules)).toEqual(rules[0]);
+    expect(findRule('GET', '/api/users', rules)).toBeUndefined();
+    expect(findRule('GET', 'https://foo.com/home', rules)).toBeUndefined();
+  });
+
+  it('is case-insensitive for method', () => {
+    const rules = [
+      { method: 'get', url: 'https://foo.com', alias: 'a' },
+    ];
+    expect(findRule('GET', 'https://foo.com', rules)).toEqual(rules[0]);
+    expect(findRule('get', 'https://foo.com', rules)).toEqual(rules[0]);
+    expect(findRule('Get', 'https://foo.com', rules)).toEqual(rules[0]);
+  });
 });

src/tests/commands/mockBridge/initMocking.spec.ts

@@ -1,7 +1,35 @@
-import { describe, it, expect, vi } from 'vitest';
-import { initRequestMocking } from '../../../commands/mockBridge';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { clearRequestMockRules, getRequestMockRules, initRequestMocking, mockRequest, waitForRequest } from '../../../commands/mockBridge';
+
+// Fake service worker API
+class FakeServiceWorker {
+  listeners: Record<string, Function[]> = {};
+  controller = { postMessage: vi.fn() };
+
+  addEventListener(type: string, cb: Function) {
+    this.listeners[type] ??= [];
+    this.listeners[type].push(cb);
+  }
+
+  dispatchMessage(data: any) {
+    this.listeners["message"]?.forEach((cb) => cb({ data }));
+  }
+
+  async register() {
+    return Promise.resolve();
+  }
+}
 
 describe('initRequestMocking', () => {
+  let fakeSW: FakeServiceWorker;
+
+  beforeEach(() => {
+    fakeSW = new FakeServiceWorker();
+    // @ts-ignore
+    navigator.serviceWorker = fakeSW;
+    clearRequestMockRules();
+  });
+
   it('registers the service worker and sets up message listener', async () => {
     // Mock navigator.serviceWorker
     const registerMock = vi.fn().mockResolvedValue({});
@@ -25,4 +53,52 @@ describe('initRequestMocking', () => {
       value: originalSW,
     });
   });
+
+  it("should mark rule as executed and update request when EXECUTED message is received", async () => {
+    await initRequestMocking();
+
+    await mockRequest("getUser", {
+      method: "GET",
+      url: "/api/user/1",
+      response: { id: 1, name: "Kevin" },
+    });
+
+    // Initially not executed
+    let rule = getRequestMockRules()[0];
+    expect(rule.executed).toBe(false);
+
+    // Fire EXECUTED message
+    fakeSW.dispatchMessage({
+      type: "EXECUTED",
+      alias: "getUser",
+      request: { headers: { foo: "bar" } },
+    });
+
+    rule = getRequestMockRules()[0];
+    expect(rule.executed).toBe(true);
+    expect(rule.request).toEqual({ headers: { foo: "bar" } });
+  });
+
+  it("should resolve waitForRequest when EXECUTED arrives", async () => {
+    await initRequestMocking();
+
+    await mockRequest("createUser", {
+      method: "POST",
+      url: "/api/user",
+      response: { ok: true },
+    });
+
+    // Trigger EXECUTED asynchronously
+    setTimeout(() => {
+      fakeSW.dispatchMessage({
+        type: "EXECUTED",
+        alias: "createUser",
+        request: { body: { name: "Alice" } },
+      });
+    }, 50);
+
+    const rule = await waitForRequest("createUser");
+    expect(rule.executed).toBe(true);
+    expect(rule.request).toEqual({ body: { name: "Alice" } });
+  });
 });

src/tests/commands/mockBridge/mockRequest.spec.ts

@@ -1,7 +1,11 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { clearRequestMockRules, getRequestMockRules, mockRequest } from '../../../commands/mockBridge';
 
 describe('mockBridge mock request methods', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it('should send mock rules to the service worker', async () => {
     const mockUrl = 'https://api.example.com/data';
     const alias = 'getData';
@@ -41,7 +45,7 @@ describe('mockBridge mock request methods', () => {
       headers: { 'Content-Type': 'application/json' },
     });
 
-    expect(postMessageMock).toHaveBeenCalledWith({
+    expect(postMessageMock).toHaveBeenNthCalledWith(1, {
       type: 'ADD_RULE',
       rule: expect.objectContaining({
         alias,
@@ -54,17 +58,19 @@ describe('mockBridge mock request methods', () => {
       }),
     });
 
-    // Restore original controller
-    Object.defineProperty(navigator.serviceWorker, 'controller', {
-      configurable: true,
-      get: () => originalController,
-    });
-
     expect(getRequestMockRules().length).toBe(1);
     expect(getRequestMockRules()[0].alias).toBe(alias);
 
     // clear rules
     clearRequestMockRules();
     expect(getRequestMockRules().length).toBe(0);
+    expect(postMessageMock).toHaveBeenCalledTimes(3);
+    expect(postMessageMock).toHaveBeenNthCalledWith(3, { type: "CLEAR_RULES" });
+
+    // Restore original controller
+    Object.defineProperty(navigator.serviceWorker, 'controller', {
+      configurable: true,
+      get: () => originalController,
+    });
   });
 });

src/tests/commands/mockBridge/waitFor.spec.ts

@@ -3,7 +3,6 @@ import { waitForRequest, mockRequest, clearRequestMockRules, getRequestMockRules
 
 describe('waitForRequest', () => {
   beforeEach(() => {
-    clearRequestMockRules();
     // Ensure navigator.serviceWorker exists
     if (!('serviceWorker' in navigator)) {
       Object.defineProperty(navigator, 'serviceWorker', {
@@ -20,6 +19,7 @@ describe('waitForRequest', () => {
       configurable: true,
       get: () => ({ postMessage: postMessageMock }),
     });
+    clearRequestMockRules();
   });
 
   it('resolves when the rule is executed', async () => {
@@ -46,12 +46,17 @@ describe('waitForRequest', () => {
       const rules = getRequestMockRules();
       rules[0].executed = true;
       rules[0].request = { delayed: true };
-  // Simulate waiter callback (directly resolve the promise by marking executed)
-  // The waitFor promise will resolve on next tick after executed is set
+      // Simulate waiter callback (directly resolve the promise by marking executed)
+      // The waitFor promise will resolve on next tick after executed is set
     }, 50);
     const result = await rulePromise;
     expect(result.alias).toBe(alias);
     expect(result.executed).toBe(true);
     expect(result.request).toEqual({ delayed: true });
   });
+
+  it('throws if the rule is not found or not executed', async () => {
+    const alias = 'nonExistentAlias';
+    await expect(waitForRequest(alias)).rejects.toThrow('Rule not found or not executed');
+  });
 });

src/tests/e2e/api/text.spec.ts

@@ -139,20 +139,6 @@ export interface TWDElemAPI {
    * 
    */
   type: (text: string) => HTMLInputElement | HTMLTextAreaElement;
-  /**
-   * Gets the text content of the element.
-   * @returns The text content.
-   * 
-   * @example
-   * ```ts
-   * const para = await twd.get("p");
-   * const content = para.text();
-   * console.log(content);
-   * 
-   * ```
-   * 
-   */
-  text: () => string;
   /**
    * Asserts something about the element.
    * @param name The name of the assertion.