test(test-setup): simplify custom matchers

hanna-skryl · hanna-skryl · commit 7a49e36166fb · 2025-01-17T15:38:03.000-05:00
diff --git a/testing/test-setup/src/lib/extend/ui-logger.matcher.ts b/testing/test-setup/src/lib/extend/ui-logger.matcher.ts
@@ -2,151 +2,66 @@ import { cliui } from '@poppinss/cliui';
 import type { SyncExpectationResult } from '@vitest/expect';
 import { expect } from 'vitest';
 import {
+  type ExpectedMessage,
   type LogLevel,
-  extractLevel,
-  extractMessage,
+  extractLogDetails,
   hasExpectedMessage,
-  messageContains,
 } from './ui-logger.matcher.utils';
 
 type CliUi = ReturnType<typeof cliui>;
 
 export type CustomUiLoggerMatchers = {
-  toHaveLoggedMessage: (expected: string) => void;
-  toHaveLoggedNthMessage: (nth: number, expected: string) => void;
-  toHaveLoggedLevel: (expected: LogLevel) => void;
-  toHaveLoggedNthLevel: (nth: number, expected: LogLevel) => void;
-  toHaveLoggedMessageContaining: (expected: string) => void;
-  toHaveLoggedNthMessageContaining: (nth: number, expected: string) => void;
-  toHaveLogged: () => void;
+  toHaveLogged: (level: LogLevel, message: ExpectedMessage) => void;
+  toHaveNthLogged: (
+    nth: number,
+    level: LogLevel,
+    message: ExpectedMessage,
+  ) => void;
   toHaveLoggedTimes: (times: number) => void;
+  toHaveLogs: () => void;
 };
 
 expect.extend({
-  toHaveLoggedMessage: assertMessageLogged,
-  toHaveLoggedNthMessage: assertNthMessageLogged,
-  toHaveLoggedLevel: assertLevelLogged,
-  toHaveLoggedNthLevel: assertNthLevelLogged,
-  toHaveLoggedMessageContaining: assertMessageContaining,
-  toHaveLoggedNthMessageContaining: assertNthMessageContaining,
-  toHaveLogged: assertLogs,
+  toHaveLogged: assertLogged,
+  toHaveNthLogged: assertNthLogged,
   toHaveLoggedTimes: assertLogCount,
+  toHaveLogs: assertLogs,
 });
 
-function assertMessageLogged(
+function assertLogged(
   actual: CliUi,
-  expected: string,
+  level: LogLevel,
+  message: ExpectedMessage,
 ): SyncExpectationResult {
-  const messages = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractMessage(message));
+  const logs = extractLogDetails(actual.logger);
 
-  const pass = messages.some(msg => hasExpectedMessage(expected, msg));
+  const pass = logs.some(
+    log => log.level === level && hasExpectedMessage(message, log.message),
+  );
   return {
     pass,
     message: () =>
       pass
-        ? `Expected not to have logged: ${expected}`
-        : `Expected to have logged: ${expected}}`,
+        ? `Expected not to find a log with level "${level}" and message matching: ${message}`
+        : `Expected a log with level "${level}" and message matching: ${message}`,
   };
 }
 
-function assertNthMessageLogged(
+function assertNthLogged(
   actual: CliUi,
   nth: number,
-  expected: string,
+  level: LogLevel,
+  message: ExpectedMessage,
 ): SyncExpectationResult {
-  const messages = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractMessage(message));
+  const log = extractLogDetails(actual.logger)[nth - 1];
 
-  const pass = hasExpectedMessage(expected, messages[nth - 1]);
+  const pass = log?.level === level && hasExpectedMessage(message, log.message);
   return {
     pass,
     message: () =>
       pass
-        ? `Expected not to have logged at position ${nth}: ${expected}`
-        : `Expected to have logged at position ${nth}: ${expected}`,
-  };
-}
-
-function assertLevelLogged(
-  actual: CliUi,
-  expected: LogLevel,
-): SyncExpectationResult {
-  const levels = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractLevel(message));
-
-  const pass = levels.includes(expected);
-  return {
-    pass,
-    message: () =>
-      pass
-        ? `Expected not to have ${expected} log level`
-        : `Expected to have ${expected} log level`,
-  };
-}
-
-function assertNthLevelLogged(
-  actual: CliUi,
-  nth: number,
-  expected: LogLevel,
-): SyncExpectationResult {
-  const levels = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractLevel(message));
-
-  const pass = levels[nth - 1] === expected;
-  return {
-    pass,
-    message: () =>
-      pass
-        ? `Expected not to have log level at position ${nth}: ${expected}`
-        : `Expected to have log level at position ${nth}: ${expected}`,
-  };
-}
-
-function assertMessageContaining(
-  actual: CliUi,
-  expected: string,
-): SyncExpectationResult {
-  const messages = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractMessage(message));
-
-  const pass = messages.some(msg => messageContains(expected, msg));
-  return {
-    pass,
-    message: () =>
-      pass
-        ? `Expected not to find a message containing: ${expected}`
-        : `Expected to find a message containing: ${expected}, but none matched.`,
-  };
-}
-
-function assertNthMessageContaining(
-  actual: CliUi,
-  nth: number,
-  expected: string,
-): SyncExpectationResult {
-  const messages = actual.logger
-    .getRenderer()
-    .getLogs()
-    .map(({ message }) => extractMessage(message));
-
-  const pass = messageContains(expected, messages[nth - 1]);
-  return {
-    pass,
-    message: () =>
-      pass
-        ? `Expected not to find the fragment "${expected}" in the message at position ${nth}`
-        : `Expected to find the fragment "${expected}" in the message at position ${nth}, but it was not found.`,
+        ? `Expected not to find a log at position ${nth} with level "${level}" and message matching: ${message}`
+        : `Expected a log at position ${nth} with level "${level}" and message matching: ${message}`,
   };
 }
 
@@ -158,8 +73,8 @@ function assertLogs(actual: CliUi): SyncExpectationResult {
     pass,
     message: () =>
       pass
-        ? `Expected not to have any logs`
-        : `Expected to have some logs, but no logs were produced`,
+        ? `Expected no logs, but found ${logs.length}`
+        : `Expected some logs, but no logs were produced`,
   };
 }
 
@@ -174,7 +89,7 @@ function assertLogCount(
     pass,
     message: () =>
       pass
-        ? `Expected not to have exactly ${expected} logs`
-        : `Expected to have ${expected} logs, but got ${logs.length}`,
+        ? `Expected not to find exactly ${expected} logs, but found ${logs.length}`
+        : `Expected exactly ${expected} logs, but found ${logs.length}`,
   };
 }
diff --git a/testing/test-setup/src/lib/extend/ui-logger.matcher.utils.ts b/testing/test-setup/src/lib/extend/ui-logger.matcher.utils.ts
@@ -1,7 +1,22 @@
+import type { Logger } from '@poppinss/cliui';
 import type { LoggingTypes } from '@poppinss/cliui/build/src/types';
 import { removeColorCodes } from '@code-pushup/test-utils';
 
-export type LogLevel = Exclude<LoggingTypes, 'warning'> | 'warn';
+export type LogLevel = Exclude<LoggingTypes, 'warning'> | 'warn' | 'log';
+
+export type ExpectedMessage =
+  | string
+  | { asymmetricMatch: (value: string) => boolean };
+
+type ExtractedMessage = {
+  styledMessage: string;
+  unstyledMessage: string;
+};
+
+type LogDetails = {
+  level: LogLevel;
+  message: ExtractedMessage;
+};
 
 const LOG_LEVELS = new Set<LogLevel>([
   'success',
@@ -11,17 +26,25 @@ const LOG_LEVELS = new Set<LogLevel>([
   'debug',
   'await',
   'warn',
+  'log',
 ]);
 
-type ExtractedMessage = {
-  styledMessage: string;
-  unstyledMessage: string;
-};
+export function extractLogDetails(logger: Logger): LogDetails[] {
+  return logger
+    .getRenderer()
+    .getLogs()
+    .map(
+      ({ message }): LogDetails => ({
+        level: extractLevel(message),
+        message: extractMessage(message),
+      }),
+    );
+}
 
-export function extractLevel(log: string): LogLevel | null {
+export function extractLevel(log: string): LogLevel {
   const match = removeColorCodes(log).match(/^\[\s*\w+\((?<level>\w+)\)\s*]/);
   const level = match?.groups?.['level'] as LogLevel | undefined;
-  return level && LOG_LEVELS.has(level) ? level : null;
+  return level && LOG_LEVELS.has(level) ? level : 'log';
 }
 
 export function extractMessage(log: string): ExtractedMessage {
@@ -34,26 +57,27 @@ export function extractMessage(log: string): ExtractedMessage {
 }
 
 export function hasExpectedMessage(
-  expected: string,
+  expected: ExpectedMessage,
   message: ExtractedMessage | undefined,
 ): boolean {
   if (!message) {
     return false;
   }
+  if (isAsymmetricMatcher(expected)) {
+    return (
+      expected.asymmetricMatch(message.styledMessage) ||
+      expected.asymmetricMatch(message.unstyledMessage)
+    );
+  }
   return (
     message.styledMessage === expected || message.unstyledMessage === expected
   );
 }
 
-export function messageContains(
-  expected: string,
-  message: ExtractedMessage | undefined,
-): boolean {
-  if (!message) {
-    return false;
-  }
+function isAsymmetricMatcher(
+  value: unknown,
+): value is { asymmetricMatch: (input: string) => boolean } {
   return (
-    message.styledMessage.includes(expected) ||
-    message.unstyledMessage.includes(expected)
+    typeof value === 'object' && value != null && 'asymmetricMatch' in value
   );
 }
diff --git a/testing/test-setup/src/lib/extend/ui-logger.matcher.utils.unit.test.ts b/testing/test-setup/src/lib/extend/ui-logger.matcher.utils.unit.test.ts
@@ -3,7 +3,6 @@ import {
   extractLevel,
   extractMessage,
   hasExpectedMessage,
-  messageContains,
 } from './ui-logger.matcher.utils';
 
 describe('extractLevel', () => {
@@ -15,12 +14,12 @@ describe('extractLevel', () => {
     expect(extractLevel('[ yellow(warn) ] Warning message')).toBe('warn');
   });
 
-  it('should return null for a log without a level', () => {
-    expect(extractLevel('Message without level')).toBeNull();
+  it('should fall back to a default log level for a log without a level', () => {
+    expect(extractLevel('Message without level')).toBe('log');
   });
 
-  it('should return null for an invalid log level', () => {
-    expect(extractLevel('[ unknown ] Message with invalid level')).toBeNull();
+  it('should fall back to a default log level for an invalid log level', () => {
+    expect(extractLevel('[ unknown ] Message with invalid level')).toBe('log');
   });
 });
 
@@ -40,13 +39,6 @@ describe('extractMessage', () => {
     expect(styledMessage).toBe('Warning message without styles.');
     expect(unstyledMessage).toBe('Warning message without styles.');
   });
-
-  it('should return raw log for unmatchable logs', () => {
-    const log = 'Unmatchable log format';
-    const { styledMessage, unstyledMessage } = extractMessage(log);
-    expect(styledMessage).toBe(log);
-    expect(unstyledMessage).toBe(log);
-  });
 });
 
 describe('hasExpectedMessage', () => {
@@ -78,37 +70,13 @@ describe('hasExpectedMessage', () => {
     const result = hasExpectedMessage('Expected message', undefined);
     expect(result).toBe(false);
   });
-});
-
-describe('messageContains', () => {
-  it('should return true when styled message contains the substring', () => {
-    expect(
-      messageContains('message', {
-        styledMessage: 'Styled message content',
-        unstyledMessage: 'Plain message content',
-      }),
-    ).toBe(true);
-  });
-
-  it('should return true when unstyled message contains the substring', () => {
-    expect(
-      messageContains('Plain', {
-        styledMessage: 'Styled message content',
-        unstyledMessage: 'Plain message content',
-      }),
-    ).toBe(true);
-  });
 
-  it('should return false when neither message contains the substring', () => {
-    expect(
-      messageContains('Non-existent', {
-        styledMessage: 'Styled message content',
-        unstyledMessage: 'Plain message content',
-      }),
-    ).toBe(false);
-  });
-
-  it('should return false for undefined message', () => {
-    expect(messageContains('Expected substring', undefined)).toBe(false);
+  it('should handle asymmetric matchers', () => {
+    const asymmetricMatcher = expect.stringContaining('Styled');
+    const result = hasExpectedMessage(asymmetricMatcher, {
+      styledMessage: 'Styled message',
+      unstyledMessage: 'Plain message',
+    });
+    expect(result).toBe(true);
   });
 });
