@frontmcp/testing 0.6.1 → 0.6.2

package/esm/matchers/index.mjs

@@ -0,0 +1,646 @@
+// libs/testing/src/platform/platform-types.ts
+function getPlatformMimeType(platform) {
+  return platform === "openai" ? "text/html+skybridge" : "text/html+mcp";
+}
+function getToolCallMetaPrefixes(platform) {
+  switch (platform) {
+    case "openai":
+      return ["openai/"];
+    case "ext-apps":
+      return ["ui/"];
+    default:
+      return ["frontmcp/", "ui/"];
+  }
+}
+function getForbiddenMetaPrefixes(platform) {
+  switch (platform) {
+    case "openai":
+      return ["ui/", "frontmcp/"];
+    case "ext-apps":
+      return ["openai/", "frontmcp/"];
+    default:
+      return ["openai/"];
+  }
+}
+
+// libs/testing/src/ui/ui-matchers.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractUiHtml(received) {
+  if (typeof received === "string") {
+    return received;
+  }
+  const wrapper = received;
+  const meta = wrapper?.raw?._meta || wrapper?._meta;
+  if (meta && typeof meta === "object") {
+    const uiHtml = meta["ui/html"];
+    if (typeof uiHtml === "string") {
+      return uiHtml;
+    }
+  }
+  return void 0;
+}
+function extractMeta(received) {
+  const wrapper = received;
+  const meta = wrapper?.raw?._meta || wrapper?._meta;
+  if (meta && typeof meta === "object") {
+    return meta;
+  }
+  return void 0;
+}
+var toHaveRenderedHtml = function(received) {
+  const html = extractUiHtml(received);
+  const hasHtml = html !== void 0 && html.length > 0;
+  const isFallback = hasHtml && html.includes("mdx-fallback");
+  const pass = hasHtml && !isFallback;
+  return {
+    pass,
+    message: () => {
+      if (isFallback) {
+        return "Expected rendered HTML but got mdx-fallback (raw escaped content). MDX rendering may have failed.";
+      }
+      if (!hasHtml) {
+        return "Expected _meta to have ui/html property with rendered HTML";
+      }
+      return "Expected result not to have rendered HTML";
+    }
+  };
+};
+var toContainHtmlElement = function(received, tag) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected to find <${tag}> element, but no HTML content found`
+    };
+  }
+  const regex = new RegExp(`<${escapeRegex(tag)}[\\s>]`, "i");
+  const pass = regex.test(html);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to contain <${tag}> element` : `Expected HTML to contain <${tag}> element`
+  };
+};
+var toContainBoundValue = function(received, value) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected HTML to contain bound value "${value}", but no HTML content found`
+    };
+  }
+  const stringValue = String(value);
+  const pass = html.includes(stringValue);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to contain bound value "${stringValue}"` : `Expected HTML to contain bound value "${stringValue}"`
+  };
+};
+var toBeXssSafe = function(received) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: true,
+      message: () => "Expected HTML to be XSS unsafe (no HTML found)"
+    };
+  }
+  const hasScript = /<script[\s>]/i.test(html);
+  const hasOnHandler = /\son\w+\s*=/i.test(html);
+  const hasJavascriptUri = /javascript:/i.test(html);
+  const issues = [];
+  if (hasScript) issues.push("<script> tag");
+  if (hasOnHandler) issues.push("inline event handler (onclick, etc.)");
+  if (hasJavascriptUri) issues.push("javascript: URI");
+  const pass = !hasScript && !hasOnHandler && !hasJavascriptUri;
+  return {
+    pass,
+    message: () => pass ? "Expected HTML not to be XSS safe" : `Expected HTML to be XSS safe, but found: ${issues.join(", ")}`
+  };
+};
+var toHaveWidgetMetadata = function(received) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => "Expected _meta to have widget metadata, but no _meta found"
+    };
+  }
+  const hasUiHtml = Boolean(meta["ui/html"]);
+  const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
+  const hasMimeType = Boolean(meta["ui/mimeType"]);
+  const pass = hasUiHtml || hasOutputTemplate || hasMimeType;
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)"
+  };
+};
+var toHaveCssClass = function(received, className) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected HTML to have CSS class "${className}", but no HTML content found`
+    };
+  }
+  const classRegex = new RegExp(`class(?:Name)?\\s*=\\s*["'][^"']*\\b${escapeRegex(className)}\\b[^"']*["']`, "i");
+  const pass = classRegex.test(html);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to have CSS class "${className}"` : `Expected HTML to have CSS class "${className}"`
+  };
+};
+var toNotContainRawContent = function(received, content) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: true,
+      message: () => `Expected HTML to contain raw content "${content}", but no HTML found`
+    };
+  }
+  const pass = !html.includes(content);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML to contain raw content "${content}"` : `Expected HTML not to contain raw content "${content}" (may indicate rendering failure)`
+  };
+};
+var toHaveProperHtmlStructure = function(received) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => "Expected proper HTML structure, but no HTML content found"
+    };
+  }
+  const hasEscapedTags = html.includes("&lt;") && html.includes("&gt;");
+  const hasHtmlTags = /<[a-z]/i.test(html);
+  const pass = hasHtmlTags && !hasEscapedTags;
+  return {
+    pass,
+    message: () => {
+      if (hasEscapedTags) {
+        return "Expected proper HTML structure, but found escaped HTML entities - content may not have been rendered";
+      }
+      if (!hasHtmlTags) {
+        return "Expected proper HTML structure, but found no HTML tags";
+      }
+      return "Expected result not to have proper HTML structure";
+    }
+  };
+};
+var toHavePlatformMeta = function(received, platform) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have platform meta for "${platform}", but no _meta found`
+    };
+  }
+  const expectedPrefixes = getToolCallMetaPrefixes(platform);
+  const forbiddenPrefixes = getForbiddenMetaPrefixes(platform);
+  const metaKeys = Object.keys(meta);
+  const hasExpectedPrefix = metaKeys.some((key) => expectedPrefixes.some((prefix) => key.startsWith(prefix)));
+  const forbiddenKeys = metaKeys.filter((key) => forbiddenPrefixes.some((prefix) => key.startsWith(prefix)));
+  const pass = hasExpectedPrefix && forbiddenKeys.length === 0;
+  return {
+    pass,
+    message: () => {
+      if (!hasExpectedPrefix) {
+        return `Expected _meta to have keys with prefixes [${expectedPrefixes.join(
+          ", "
+        )}] for platform "${platform}", but found: [${metaKeys.join(", ")}]`;
+      }
+      if (forbiddenKeys.length > 0) {
+        return `Expected _meta NOT to have keys [${forbiddenKeys.join(
+          ", "
+        )}] for platform "${platform}" (forbidden prefixes: [${forbiddenPrefixes.join(", ")}])`;
+      }
+      return `Expected result not to have platform meta for "${platform}"`;
+    }
+  };
+};
+var toHaveMetaKey = function(received, key) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have key "${key}", but no _meta found`
+    };
+  }
+  const pass = key in meta;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta not to have key "${key}"` : `Expected _meta to have key "${key}"`
+  };
+};
+var toHaveMetaValue = function(received, key, value) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta["${key}"] to equal ${JSON.stringify(value)}, but no _meta found`
+    };
+  }
+  const actualValue = meta[key];
+  const pass = JSON.stringify(actualValue) === JSON.stringify(value);
+  return {
+    pass,
+    message: () => pass ? `Expected _meta["${key}"] not to equal ${JSON.stringify(value)}` : `Expected _meta["${key}"] to equal ${JSON.stringify(value)}, but got ${JSON.stringify(actualValue)}`
+  };
+};
+var toNotHaveMetaKey = function(received, key) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: true,
+      message: () => `Expected _meta to have key "${key}", but no _meta found`
+    };
+  }
+  const pass = !(key in meta);
+  return {
+    pass,
+    message: () => pass ? `Expected _meta to have key "${key}"` : `Expected _meta not to have key "${key}"`
+  };
+};
+var toHaveOnlyNamespacedMeta = function(received, namespace) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have keys with namespace "${namespace}", but no _meta found`
+    };
+  }
+  const metaKeys = Object.keys(meta);
+  const wrongKeys = metaKeys.filter((key) => !key.startsWith(namespace));
+  const pass = wrongKeys.length === 0 && metaKeys.length > 0;
+  return {
+    pass,
+    message: () => {
+      if (metaKeys.length === 0) {
+        return `Expected _meta to have keys with namespace "${namespace}", but _meta is empty`;
+      }
+      if (wrongKeys.length > 0) {
+        return `Expected _meta to ONLY have keys with namespace "${namespace}", but found: [${wrongKeys.join(", ")}]`;
+      }
+      return `Expected _meta not to have only keys with namespace "${namespace}"`;
+    }
+  };
+};
+var toHavePlatformMimeType = function(received, platform) {
+  const meta = extractMeta(received);
+  const expectedMimeType = getPlatformMimeType(platform);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have MIME type "${expectedMimeType}" for platform "${platform}", but no _meta found`
+    };
+  }
+  let mimeTypeKey;
+  switch (platform) {
+    case "openai":
+      mimeTypeKey = "openai/mimeType";
+      break;
+    case "ext-apps":
+      mimeTypeKey = "ui/mimeType";
+      break;
+    default:
+      mimeTypeKey = "frontmcp/mimeType";
+  }
+  const actualMimeType = meta[mimeTypeKey];
+  const pass = actualMimeType === expectedMimeType;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta["${mimeTypeKey}"] not to be "${expectedMimeType}"` : `Expected _meta["${mimeTypeKey}"] to be "${expectedMimeType}" for platform "${platform}", but got "${actualMimeType}"`
+  };
+};
+var toHavePlatformHtml = function(received, platform) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have platform HTML for "${platform}", but no _meta found`
+    };
+  }
+  let htmlKey;
+  switch (platform) {
+    case "openai":
+      htmlKey = "openai/html";
+      break;
+    case "ext-apps":
+      htmlKey = "ui/html";
+      break;
+    default:
+      htmlKey = "frontmcp/html";
+  }
+  const html = meta[htmlKey];
+  const pass = typeof html === "string" && html.length > 0;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta not to have platform HTML in "${htmlKey}"` : `Expected _meta["${htmlKey}"] to contain HTML for platform "${platform}", but ${html === void 0 ? "key not found" : `got ${typeof html}`}`
+  };
+};
+var uiMatchers = {
+  // Existing HTML matchers
+  toHaveRenderedHtml,
+  toContainHtmlElement,
+  toContainBoundValue,
+  toBeXssSafe,
+  toHaveWidgetMetadata,
+  toHaveCssClass,
+  toNotContainRawContent,
+  toHaveProperHtmlStructure,
+  // Platform meta matchers
+  toHavePlatformMeta,
+  toHaveMetaKey,
+  toHaveMetaValue,
+  toNotHaveMetaKey,
+  toHaveOnlyNamespacedMeta,
+  toHavePlatformMimeType,
+  toHavePlatformHtml
+};
+
+// libs/testing/src/matchers/mcp-matchers.ts
+var toContainTool = function(received, toolName) {
+  const tools = received;
+  if (!Array.isArray(tools)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of tools, but received ${typeof received}`
+    };
+  }
+  const pass = tools.some((t) => t.name === toolName);
+  const availableTools = tools.map((t) => t.name).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected tools not to contain "${toolName}"` : `Expected tools to contain "${toolName}", but got: [${availableTools}]`
+  };
+};
+var toBeSuccessful = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("isSuccess" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a result wrapper object with isSuccess property`
+    };
+  }
+  const pass = result.isSuccess;
+  return {
+    pass,
+    message: () => pass ? "Expected result not to be successful" : `Expected result to be successful, but got error: ${result.error?.message ?? "unknown error"}`
+  };
+};
+var toBeError = function(received, expectedCode) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("isError" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a result wrapper object with isError property`
+    };
+  }
+  let pass = result.isError;
+  if (pass && expectedCode !== void 0) {
+    pass = result.error?.code === expectedCode;
+  }
+  return {
+    pass,
+    message: () => {
+      if (!result.isError) {
+        return "Expected result to be an error, but it was successful";
+      }
+      if (expectedCode !== void 0 && result.error?.code !== expectedCode) {
+        return `Expected error code ${expectedCode}, but got ${result.error?.code}`;
+      }
+      return "Expected result not to be an error";
+    }
+  };
+};
+var toHaveTextContent = function(received, expectedText) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("text" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper or ResourceContentWrapper object with text method`
+    };
+  }
+  const text = result.text();
+  const hasText = "hasTextContent" in result ? result.hasTextContent() : text !== void 0;
+  let pass = hasText;
+  if (pass && expectedText !== void 0) {
+    pass = text?.includes(expectedText) ?? false;
+  }
+  return {
+    pass,
+    message: () => {
+      if (!hasText) {
+        return "Expected result to have text content";
+      }
+      if (expectedText !== void 0 && !text?.includes(expectedText)) {
+        return `Expected text to contain "${expectedText}", but got: "${text}"`;
+      }
+      return "Expected result not to have text content";
+    }
+  };
+};
+var toHaveImageContent = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasImageContent" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper object with hasImageContent method`
+    };
+  }
+  const pass = result.hasImageContent();
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have image content" : "Expected result to have image content"
+  };
+};
+var toHaveResourceContent = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasResourceContent" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper object with hasResourceContent method`
+    };
+  }
+  const pass = result.hasResourceContent();
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have resource content" : "Expected result to have resource content"
+  };
+};
+var toContainResource = function(received, uri) {
+  const resources = received;
+  if (!Array.isArray(resources)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of resources, but received ${typeof received}`
+    };
+  }
+  const pass = resources.some((r) => r.uri === uri);
+  const availableUris = resources.map((r) => r.uri).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected resources not to contain "${uri}"` : `Expected resources to contain "${uri}", but got: [${availableUris}]`
+  };
+};
+var toContainResourceTemplate = function(received, uriTemplate) {
+  const templates = received;
+  if (!Array.isArray(templates)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of resource templates, but received ${typeof received}`
+    };
+  }
+  const pass = templates.some((t) => t.uriTemplate === uriTemplate);
+  const availableTemplates = templates.map((t) => t.uriTemplate).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected templates not to contain "${uriTemplate}"` : `Expected templates to contain "${uriTemplate}", but got: [${availableTemplates}]`
+  };
+};
+var toHaveMimeType = function(received, mimeType) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasMimeType" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ResourceContentWrapper object with hasMimeType method`
+    };
+  }
+  const pass = result.hasMimeType(mimeType);
+  const actualMimeType = result.mimeType();
+  return {
+    pass,
+    message: () => pass ? `Expected content not to have MIME type "${mimeType}"` : `Expected MIME type "${mimeType}", but got "${actualMimeType}"`
+  };
+};
+var toContainPrompt = function(received, name) {
+  const prompts = received;
+  if (!Array.isArray(prompts)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of prompts, but received ${typeof received}`
+    };
+  }
+  const pass = prompts.some((p) => p.name === name);
+  const availablePrompts = prompts.map((p) => p.name).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected prompts not to contain "${name}"` : `Expected prompts to contain "${name}", but got: [${availablePrompts}]`
+  };
+};
+var toHaveMessages = function(received, count) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("messages" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a PromptResultWrapper object with messages property`
+    };
+  }
+  const actualCount = result.messages?.length ?? 0;
+  const pass = actualCount === count;
+  return {
+    pass,
+    message: () => pass ? `Expected prompt not to have ${count} messages` : `Expected prompt to have ${count} messages, but got ${actualCount}`
+  };
+};
+var toBeValidJsonRpc = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const hasJsonRpc = response["jsonrpc"] === "2.0";
+  const hasId = "id" in response;
+  const hasResult = "result" in response;
+  const hasError = "error" in response;
+  const hasExactlyOneResultOrError = (hasResult || hasError) && !(hasResult && hasError);
+  const pass = hasJsonRpc && hasId && hasExactlyOneResultOrError;
+  return {
+    pass,
+    message: () => {
+      if (pass) {
+        return "Expected response not to be valid JSON-RPC";
+      }
+      const issues = [];
+      if (!hasJsonRpc) issues.push('missing or invalid "jsonrpc": "2.0"');
+      if (!hasId) issues.push('missing "id" field');
+      if (!hasExactlyOneResultOrError) {
+        if (!hasResult && !hasError) issues.push('missing "result" or "error"');
+        else issues.push('cannot have both "result" and "error"');
+      }
+      return `Expected valid JSON-RPC 2.0 response: ${issues.join(", ")}`;
+    }
+  };
+};
+var toHaveResult = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const pass = "result" in response;
+  return {
+    pass,
+    message: () => pass ? "Expected response not to have result" : "Expected response to have result"
+  };
+};
+var toHaveError = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const pass = "error" in response;
+  return {
+    pass,
+    message: () => pass ? "Expected response not to have error" : "Expected response to have error"
+  };
+};
+var toHaveErrorCode = function(received, code) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const actualCode = response.error?.code;
+  const pass = actualCode === code;
+  return {
+    pass,
+    message: () => pass ? `Expected response not to have error code ${code}` : `Expected error code ${code}, but got ${actualCode ?? "no error"}`
+  };
+};
+var mcpMatchers = {
+  // Tool matchers
+  toContainTool,
+  toBeSuccessful,
+  toBeError,
+  toHaveTextContent,
+  toHaveImageContent,
+  toHaveResourceContent,
+  // Resource matchers
+  toContainResource,
+  toContainResourceTemplate,
+  toHaveMimeType,
+  // Prompt matchers
+  toContainPrompt,
+  toHaveMessages,
+  // Protocol matchers
+  toBeValidJsonRpc,
+  toHaveResult,
+  toHaveError,
+  toHaveErrorCode,
+  // UI matchers (for testing tool UI responses)
+  ...uiMatchers
+};
+export {
+  mcpMatchers
+};