Merge pull request #48 from AsenaJs/feature-asena-test

Feature: Asena test utilities

Author: LibirSoft

CHANGELOG.md

@@ -1,5 +1,11 @@
 # @asenajs/asena
 
+## 0.6.2
+
+### Patch Changes
+
+- Added testing utilities with `mockComponent` and `mockComponentAsync` functions for automated dependency mocking in component tests.
+
 ## 0.6.1
 
 ### Patch Changes

README.md

@@ -4,7 +4,7 @@
 
 # Asena
 
-[![Version](https://img.shields.io/badge/version-0.6.1-blue.svg)](https://asena.sh)
+[![Version](https://img.shields.io/badge/version-0.6.2-blue.svg)](https://asena.sh)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Bun Version](https://img.shields.io/badge/Bun-1.3.2%2B-blueviolet)](https://bun.sh)
 

bun.lock

@@ -0,0 +1,117 @@
+import { mock } from 'bun:test';
+
+/**
+ * Detects all methods in a class (excluding constructor)
+ *
+ * @param classType - Class to inspect
+ * @returns Array of method names
+ *
+ * @internal
+ */
+function detectClassMethods(classType: any): string[] {
+  if (!classType?.prototype) {
+    return [];
+  }
+
+  const methods: string[] = [];
+  const prototype = classType.prototype;
+
+  // Get all property names from prototype
+  const propertyNames = Object.getOwnPropertyNames(prototype);
+
+  for (const name of propertyNames) {
+    // Skip constructor
+    if (name === 'constructor') {
+      continue;
+    }
+
+    // Check if it's a function
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    if (descriptor && typeof descriptor.value === 'function') {
+      methods.push(name);
+    }
+  }
+
+  return methods;
+}
+
+/**
+ * Checks if a value is mockable (is a class with prototype)
+ *
+ * @param classType - Value to check
+ * @returns True if value is a class
+ *
+ * @internal
+ */
+function isMockable(classType: any): boolean {
+  return (
+    classType !== null &&
+    classType !== undefined &&
+    typeof classType === 'function' &&
+    classType.prototype !== undefined
+  );
+}
+
+/**
+ * Creates a mock object from a class type
+ * Automatically generates Bun mock functions for all class methods
+ *
+ * @param classType - Class to create mock from
+ * @returns Mock object with all methods mocked
+ *
+ * @example
+ * ```typescript
+ * const UserServiceMock = createMockFromClass(UserService);
+ * // Returns:
+ * // {
+ * //   createUser: mock(async () => null),
+ * //   findByEmail: mock(async () => null),
+ * //   findById: mock(async () => null),
+ * // }
+ *
+ * // Can configure mocks:
+ * UserServiceMock.createUser.mockResolvedValue({ id: '123', name: 'John' });
+ * ```
+ */
+export function createMockFromClass(classType: any): any {
+  // Handle non-mockable types - return empty object as placeholder
+  if (!isMockable(classType)) {
+    return {};
+  }
+
+  // Detect all methods in the class
+  const methods = detectClassMethods(classType);
+
+  // Create mock object
+  const mockObject: Record<string, any> = {};
+
+  // Create Bun mock for each method
+  for (const methodName of methods) {
+    // Check if method is async by inspecting the original
+    const originalMethod = classType.prototype[methodName];
+    const isAsync = originalMethod?.constructor?.name === 'AsyncFunction';
+
+    // Create mock with appropriate default return value
+    if (isAsync) {
+      // Async methods return Promise.resolve(null) by default
+      mockObject[methodName] = mock(async () => null);
+    } else {
+      // Sync methods return undefined by default
+      mockObject[methodName] = mock(() => undefined);
+    }
+  }
+
+  return mockObject;
+}
+
+/**
+ * Creates a simple spy that tracks calls without mocking behavior
+ * Useful for partial mocking scenarios
+ *
+ * @returns Mock function that returns undefined
+ *
+ * @internal
+ */
+export function createSimpleSpy(): any {
+  return mock(() => undefined);
+}

lib/test/factory/mockFactory.ts

@@ -0,0 +1,3 @@
+export { mockComponent, mockComponentAsync } from './mockComponent';
+export type { MockComponentOptions, MockedComponent } from './types';
+export { createMockFromClass } from './factory/mockFactory';

lib/test/index.ts

@@ -0,0 +1,113 @@
+import type { Dependencies, Expressions } from '../../ioc';
+import type { FieldMetadata } from '../types';
+import { ComponentConstants } from '../../ioc';
+import { getTypedMetadata, getOwnTypedMetadata } from '../../utils';
+
+/**
+ * Discovers all fields with @Inject decorator in a component
+ * Traverses prototype chain to support inheritance
+ *
+ * @param instance - Component instance to inspect
+ * @returns Array of field metadata containing field names, service names, and expressions
+ *
+ * @example
+ * ```typescript
+ * const fields = discoverInjectedFields(new AuthService());
+ * // Returns: [
+ * //   { fieldName: 'userService', serviceName: 'UserService', expression: undefined },
+ * //   { fieldName: 'loginService', serviceName: 'LoginService', expression: (s) => s.login() }
+ * // ]
+ * ```
+ */
+export function discoverInjectedFields(instance: any): FieldMetadata[] {
+  const fields: FieldMetadata[] = [];
+  const processedFields = new Set<string>();
+
+  // Traverse prototype chain (similar to how Container does it)
+  let currentPrototype = Object.getPrototypeOf(instance);
+
+  while (currentPrototype && currentPrototype !== Object.prototype) {
+    const constructor = currentPrototype.constructor;
+
+    // Get dependencies metadata for this level
+    const dependencies = getOwnTypedMetadata<Dependencies>(ComponentConstants.DependencyKey, constructor);
+
+    // Get expressions metadata for this level
+    const expressions = getOwnTypedMetadata<Expressions>(ComponentConstants.ExpressionKey, constructor);
+
+    if (dependencies) {
+      // Process each dependency field
+      for (const [fieldName, serviceName] of Object.entries(dependencies)) {
+        // Skip if already processed (child class overrides)
+        if (processedFields.has(fieldName)) {
+          continue;
+        }
+
+        processedFields.add(fieldName);
+
+        fields.push({
+          fieldName,
+          serviceName,
+          expression: expressions?.[fieldName],
+        });
+      }
+    }
+
+    // Move up the prototype chain
+    currentPrototype = Object.getPrototypeOf(currentPrototype);
+  }
+
+  return fields;
+}
+
+/**
+ * Checks if a component has any injected dependencies
+ *
+ * @param ComponentClass - Component class to check
+ * @returns True if component has @Inject decorated fields
+ *
+ * @example
+ * ```typescript
+ * if (hasInjectedFields(AuthService)) {
+ *   console.log('AuthService has dependencies');
+ * }
+ * ```
+ */
+export function hasInjectedFields(ComponentClass: new (...args: any[]) => any): boolean {
+  const dependencies = getTypedMetadata<Dependencies>(ComponentConstants.DependencyKey, ComponentClass);
+  return dependencies !== undefined && Object.keys(dependencies).length > 0;
+}
+
+/**
+ * Gets the service name for a specific field
+ *
+ * @param ComponentClass - Component class
+ * @param fieldName - Name of the field
+ * @returns Service name if field is injected, undefined otherwise
+ *
+ * @internal
+ */
+export function getFieldServiceName(
+  ComponentClass: new (...args: any[]) => any,
+  fieldName: string,
+): string | undefined {
+  const dependencies = getTypedMetadata<Dependencies>(ComponentConstants.DependencyKey, ComponentClass);
+  return dependencies?.[fieldName];
+}
+
+/**
+ * Gets the expression function for a specific field
+ *
+ * @param ComponentClass - Component class
+ * @param fieldName - Name of the field
+ * @returns Expression function if defined, undefined otherwise
+ *
+ * @internal
+ */
+export function getFieldExpression(
+  ComponentClass: new (...args: any[]) => any,
+  fieldName: string,
+): ((service: any) => any) | undefined {
+  const expressions = getTypedMetadata<Expressions>(ComponentConstants.ExpressionKey, ComponentClass);
+  return expressions?.[fieldName];
+}