te.js 2.0.1 → 2.0.3

package/tests/auto-docs/openapi-generator.test.js

@@ -1,103 +0,0 @@
-/**
- * Unit tests for auto-docs openapi/generator pure functions.
- */
-import { describe, it, expect } from 'vitest';
-import {
-  toOpenAPIPath,
-  getPathParameters,
-  getQueryParameters,
-  buildSchemaFromMetadata,
-  buildResponses,
-  buildOperation,
-  mergeMetadata,
-} from '../../auto-docs/openapi/generator.js';
-
-describe('openapi-generator', () => {
-  describe('toOpenAPIPath', () => {
-    it('converts :param to {param}', () => {
-      expect(toOpenAPIPath('/users/:id')).toBe('/users/{id}');
-    });
-    it('converts multiple params', () => {
-      expect(toOpenAPIPath('/users/:userId/posts/:postId')).toBe('/users/{userId}/posts/{postId}');
-    });
-    it('returns / for empty or non-string', () => {
-      expect(toOpenAPIPath('')).toBe('/');
-      expect(toOpenAPIPath(null)).toBe('/');
-    });
-  });
-
-  describe('getPathParameters', () => {
-    it('extracts path params from te.js path', () => {
-      const params = getPathParameters('/users/:id');
-      expect(params).toHaveLength(1);
-      expect(params[0]).toMatchObject({ name: 'id', in: 'path', required: true, schema: { type: 'string' } });
-    });
-    it('returns empty array for path without params', () => {
-      expect(getPathParameters('/users')).toEqual([]);
-    });
-  });
-
-  describe('getQueryParameters', () => {
-    it('builds query params from metadata', () => {
-      const queryMeta = { limit: { type: 'integer', required: false }, q: { type: 'string', required: true } };
-      const params = getQueryParameters(queryMeta);
-      expect(params).toHaveLength(2);
-      expect(params.find((p) => p.name === 'limit')).toMatchObject({ in: 'query', required: false });
-      expect(params.find((p) => p.name === 'q')).toMatchObject({ in: 'query', required: true });
-    });
-    it('returns empty array for invalid meta', () => {
-      expect(getQueryParameters(null)).toEqual([]);
-    });
-  });
-
-  describe('buildSchemaFromMetadata', () => {
-    it('builds OpenAPI schema from field meta', () => {
-      const meta = { name: { type: 'string' }, email: { type: 'string', format: 'email', required: true } };
-      const schema = buildSchemaFromMetadata(meta);
-      expect(schema.type).toBe('object');
-      expect(schema.properties.name.type).toBe('string');
-      expect(schema.properties.email.format).toBe('email');
-      expect(schema.required).toContain('email');
-    });
-  });
-
-  describe('buildResponses', () => {
-    it('returns 200 Success when responseMeta empty', () => {
-      const r = buildResponses(null);
-      expect(r['200']).toEqual({ description: 'Success' });
-    });
-    it('builds responses from metadata', () => {
-      const meta = { 200: { description: 'OK' }, 201: { description: 'Created' } };
-      const r = buildResponses(meta);
-      expect(r['200'].description).toBe('OK');
-      expect(r['201'].description).toBe('Created');
-    });
-  });
-
-  describe('buildOperation', () => {
-    it('builds operation with summary and responses', () => {
-      const meta = { summary: 'Get user', response: { 200: { description: 'OK' } } };
-      const pathParams = [];
-      const op = buildOperation('get', meta, pathParams);
-      expect(op.summary).toBe('Get user');
-      expect(op.responses['200'].description).toBe('OK');
-    });
-  });
-
-  describe('mergeMetadata', () => {
-    it('prefers explicit when preferEnhanced false', () => {
-      const explicit = { summary: 'A', description: 'B' };
-      const enhanced = { summary: 'C', description: 'D' };
-      const merged = mergeMetadata(explicit, enhanced, { preferEnhanced: false });
-      expect(merged.summary).toBe('A');
-      expect(merged.description).toBe('B');
-    });
-    it('prefers enhanced when preferEnhanced true', () => {
-      const explicit = { summary: 'A' };
-      const enhanced = { summary: 'C', description: 'D' };
-      const merged = mergeMetadata(explicit, enhanced, { preferEnhanced: true });
-      expect(merged.summary).toBe('C');
-      expect(merged.description).toBe('D');
-    });
-  });
-});

package/tests/auto-docs/parse.test.js

@@ -1,63 +0,0 @@
-/**
- * Unit tests for auto-docs llm/parse (extractJSON, extractJSONArray, reconcileOrderedTags).
- */
-import { describe, it, expect } from 'vitest';
-import {
-  extractJSON,
-  extractJSONArray,
-  reconcileOrderedTags,
-} from '../../auto-docs/llm/parse.js';
-
-describe('llm/parse', () => {
-  describe('extractJSON', () => {
-    it('extracts object from plain JSON string', () => {
-      const str = '{"name":"Users","description":"CRUD"}';
-      expect(extractJSON(str)).toEqual({ name: 'Users', description: 'CRUD' });
-    });
-    it('extracts first object from text with markdown', () => {
-      const str = 'Here is the result:\n```json\n{"summary":"Get item"}\n```';
-      expect(extractJSON(str)).toEqual({ summary: 'Get item' });
-    });
-    it('returns null for empty or no object', () => {
-      expect(extractJSON('')).toBeNull();
-      expect(extractJSON('no brace here')).toBeNull();
-    });
-  });
-
-  describe('extractJSONArray', () => {
-    it('extracts array from string', () => {
-      const str = '["Users", "Auth", "Health"]';
-      expect(extractJSONArray(str)).toEqual(['Users', 'Auth', 'Health']);
-    });
-    it('returns null when no array', () => {
-      expect(extractJSONArray('')).toBeNull();
-      expect(extractJSONArray('nothing')).toBeNull();
-    });
-  });
-
-  describe('reconcileOrderedTags', () => {
-    it('reorders tags by orderedTagNames', () => {
-      const tags = [
-        { name: 'Health', description: '...' },
-        { name: 'Users', description: '...' },
-        { name: 'Auth', description: '...' },
-      ];
-      const ordered = reconcileOrderedTags(['Users', 'Auth', 'Health'], tags);
-      expect(ordered.map((t) => t.name)).toEqual(['Users', 'Auth', 'Health']);
-    });
-    it('appends tags not in orderedTagNames', () => {
-      const tags = [
-        { name: 'Users' },
-        { name: 'Other' },
-      ];
-      const ordered = reconcileOrderedTags(['Users'], tags);
-      expect(ordered.map((t) => t.name)).toEqual(['Users', 'Other']);
-    });
-    it('returns copy of tags when orderedTagNames empty', () => {
-      const tags = [{ name: 'A' }];
-      const ordered = reconcileOrderedTags([], tags);
-      expect(ordered).toEqual([{ name: 'A' }]);
-      expect(ordered).not.toBe(tags);
-    });
-  });
-});

package/tests/auto-docs/source-resolver.test.js

@@ -1,58 +0,0 @@
-/**
- * Unit tests for auto-docs source-resolver (extractRelativeImports, resolveTargetFilePath, formatDependencyContext).
- */
-import { describe, it, expect } from 'vitest';
-import path from 'node:path';
-import {
-  extractRelativeImports,
-  resolveTargetFilePath,
-  formatDependencyContext,
-} from '../../auto-docs/analysis/source-resolver.js';
-
-describe('source-resolver', () => {
-  describe('extractRelativeImports', () => {
-    it('extracts relative import paths', () => {
-      const source = `import x from './foo.js';\nimport { y } from '../bar.js';`;
-      const imports = extractRelativeImports(source);
-      expect(imports).toContain('./foo.js');
-      expect(imports).toContain('../bar.js');
-    });
-    it('ignores absolute or node imports', () => {
-      const source = `import path from 'path';\nimport x from './local.js';`;
-      const imports = extractRelativeImports(source);
-      expect(imports).toEqual(['./local.js']);
-    });
-    it('returns unique paths', () => {
-      const source = `import a from './foo.js';\nimport b from './foo.js';`;
-      expect(extractRelativeImports(source)).toHaveLength(1);
-    });
-  });
-
-  describe('resolveTargetFilePath', () => {
-    it('joins dirTargets with groupId and .target.js', () => {
-      const resolved = resolveTargetFilePath('users', 'targets');
-      expect(resolved).toMatch(/targets[\\/]users\.target\.js$/);
-    });
-    it('converts groupId slashes to path sep', () => {
-      const resolved = resolveTargetFilePath('subdir/users', 'targets');
-      expect(resolved).toMatch(/subdir[\\/]users\.target\.js$/);
-    });
-  });
-
-  describe('formatDependencyContext', () => {
-    it('returns empty string for empty sources', () => {
-      expect(formatDependencyContext(new Map(), null)).toBe('');
-    });
-    it('formats map of path -> source with labels', () => {
-      const sources = new Map([
-        ['/cwd/targets/users.target.js', 'const x = 1;'],
-        ['/cwd/services/user.js', 'const y = 2;'],
-      ]);
-      const targetPath = '/cwd/targets/users.target.js';
-      const out = formatDependencyContext(sources, targetPath, 1000);
-      expect(out).toContain('Target');
-      expect(out).toContain('const x = 1;');
-      expect(out).toContain('const y = 2;');
-    });
-  });
-});

package/tests/helpers/index.js

@@ -1,37 +0,0 @@
-/**
- * Test Helpers Index
- * Central export for all test utilities and mocks
- */
-
-// HTTP Mocks
-export {
-  MockRequest,
-  MockResponse,
-  createMockRequest,
-  createMockResponse,
-  createMockPair,
-  createJsonRequest,
-  createFormRequest,
-  createMultipartRequest,
-  createMultipartBody,
-} from './mock-http.js';
-
-// Test Utilities
-export {
-  createTestAmmo,
-  createEnhancedAmmo,
-  createTestRegistry,
-  createMockEndpoint,
-  createMockMiddleware,
-  createExpressStyleMiddleware,
-  sleep,
-  waitFor,
-  createMockDbConnection,
-  createMockFile,
-  createMockStorage,
-  assertResponse,
-  mockConsole,
-  captureResponse,
-} from './test-utils.js';
-
-

package/tests/helpers/mock-http.js

@@ -1,342 +0,0 @@
-import { EventEmitter } from 'events';
-
-/**
- * Mock HTTP IncomingMessage (request) object
- * Simulates Node.js http.IncomingMessage for testing
- */
-export class MockRequest extends EventEmitter {
-  constructor(options = {}) {
-    super();
-
-    this.method = options.method || 'GET';
-    this.url = options.url || '/';
-    this.headers = options.headers || {};
-    this.httpVersion = options.httpVersion || '1.1';
-    this.socket = options.socket || {
-      remoteAddress: options.ip || '127.0.0.1',
-      encrypted: options.encrypted || false,
-    };
-
-    // Body handling
-    this._body = options.body || '';
-    this._bodyChunks = [];
-
-    // Connection info
-    this.connection = this.socket;
-
-    // Normalize headers to lowercase
-    this.headers = Object.keys(this.headers).reduce((acc, key) => {
-      acc[key.toLowerCase()] = this.headers[key];
-      return acc;
-    }, {});
-  }
-
-  /**
-   * Simulate incoming data by emitting chunks
-   */
-  simulateBody(body) {
-    if (typeof body === 'string') {
-      this.emit('data', Buffer.from(body));
-    } else if (Buffer.isBuffer(body)) {
-      this.emit('data', body);
-    } else if (typeof body === 'object') {
-      this.emit('data', Buffer.from(JSON.stringify(body)));
-    }
-    this.emit('end');
-  }
-
-  /**
-   * Immediately emit body data (for sync tests)
-   */
-  pipe(destination) {
-    if (this._body) {
-      destination.write(this._body);
-    }
-    return destination;
-  }
-}
-
-/**
- * Mock HTTP ServerResponse (response) object
- * Simulates Node.js http.ServerResponse for testing
- */
-export class MockResponse extends EventEmitter {
-  constructor() {
-    super();
-
-    this.statusCode = 200;
-    this.statusMessage = '';
-    this.headers = {};
-    this._body = '';
-    this._chunks = [];
-
-    // Response state flags
-    this.headersSent = false;
-    this.writableEnded = false;
-    this.finished = false;
-  }
-
-  /**
-   * Set response status code and headers
-   */
-  writeHead(statusCode, statusMessage, headers) {
-    if (this.headersSent) {
-      throw new Error('Headers already sent');
-    }
-
-    this.statusCode = statusCode;
-
-    // Handle optional statusMessage
-    if (typeof statusMessage === 'object') {
-      headers = statusMessage;
-      statusMessage = '';
-    }
-
-    this.statusMessage = statusMessage || '';
-
-    if (headers) {
-      Object.keys(headers).forEach((key) => {
-        this.headers[key.toLowerCase()] = headers[key];
-      });
-    }
-
-    this.headersSent = true;
-    return this;
-  }
-
-  /**
-   * Set a single header
-   */
-  setHeader(name, value) {
-    if (this.headersSent) {
-      throw new Error('Headers already sent');
-    }
-    this.headers[name.toLowerCase()] = value;
-    return this;
-  }
-
-  /**
-   * Get a header value
-   */
-  getHeader(name) {
-    return this.headers[name.toLowerCase()];
-  }
-
-  /**
-   * Remove a header
-   */
-  removeHeader(name) {
-    delete this.headers[name.toLowerCase()];
-  }
-
-  /**
-   * Check if a header has been set
-   */
-  hasHeader(name) {
-    return name.toLowerCase() in this.headers;
-  }
-
-  /**
-   * Write data to response body
-   */
-  write(chunk, encoding, callback) {
-    if (this.writableEnded) {
-      throw new Error('Write after end');
-    }
-
-    if (chunk !== undefined && chunk !== null && chunk !== '') {
-      this._chunks.push(chunk);
-      this._body += typeof chunk === 'string' ? chunk : chunk.toString();
-    }
-
-    if (typeof encoding === 'function') {
-      callback = encoding;
-    }
-
-    if (typeof callback === 'function') {
-      callback();
-    }
-
-    return true;
-  }
-
-  /**
-   * End the response
-   */
-  end(data, encoding, callback) {
-    if (this.writableEnded) {
-      return this;
-    }
-
-    if (typeof data === 'function') {
-      callback = data;
-      data = undefined;
-    } else if (typeof encoding === 'function') {
-      callback = encoding;
-      encoding = undefined;
-    }
-
-    if (data !== undefined && data !== null && data !== '') {
-      this.write(data, encoding);
-    }
-
-    this.writableEnded = true;
-    this.finished = true;
-
-    this.emit('finish');
-
-    if (typeof callback === 'function') {
-      callback();
-    }
-
-    return this;
-  }
-
-  /**
-   * Get the response body as a string
-   */
-  getBody() {
-    return this._body;
-  }
-
-  /**
-   * Get the response body parsed as JSON
-   */
-  getJsonBody() {
-    try {
-      return JSON.parse(this._body);
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Reset the response for reuse
-   */
-  reset() {
-    this.statusCode = 200;
-    this.statusMessage = '';
-    this.headers = {};
-    this._body = '';
-    this._chunks = [];
-    this.headersSent = false;
-    this.writableEnded = false;
-    this.finished = false;
-  }
-}
-
-/**
- * Create a mock request with common defaults
- */
-export function createMockRequest(options = {}) {
-  const defaults = {
-    method: 'GET',
-    url: '/',
-    headers: {
-      'host': 'localhost:3000',
-      'user-agent': 'test-agent',
-      'accept': '*/*',
-    },
-    ip: '127.0.0.1',
-  };
-
-  return new MockRequest({ ...defaults, ...options });
-}
-
-/**
- * Create a mock response
- */
-export function createMockResponse() {
-  return new MockResponse();
-}
-
-/**
- * Create a mock request/response pair
- */
-export function createMockPair(requestOptions = {}) {
-  return {
-    req: createMockRequest(requestOptions),
-    res: createMockResponse(),
-  };
-}
-
-/**
- * Create a JSON request with proper headers
- */
-export function createJsonRequest(options = {}) {
-  return createMockRequest({
-    ...options,
-    headers: {
-      'content-type': 'application/json',
-      'accept': 'application/json',
-      ...options.headers,
-    },
-  });
-}
-
-/**
- * Create a form-urlencoded request with proper headers
- */
-export function createFormRequest(options = {}) {
-  return createMockRequest({
-    method: 'POST',
-    ...options,
-    headers: {
-      'content-type': 'application/x-www-form-urlencoded',
-      ...options.headers,
-    },
-  });
-}
-
-/**
- * Create a multipart form-data request with proper headers
- */
-export function createMultipartRequest(boundary, options = {}) {
-  return createMockRequest({
-    method: 'POST',
-    ...options,
-    headers: {
-      'content-type': `multipart/form-data; boundary=${boundary}`,
-      ...options.headers,
-    },
-  });
-}
-
-/**
- * Helper to create multipart form body
- */
-export function createMultipartBody(boundary, fields = [], files = []) {
-  let body = '';
-
-  // Add regular fields
-  for (const field of fields) {
-    body += `--${boundary}\r\n`;
-    body += `Content-Disposition: form-data; name="${field.name}"\r\n\r\n`;
-    body += `${field.value}\r\n`;
-  }
-
-  // Add files
-  for (const file of files) {
-    body += `--${boundary}\r\n`;
-    body += `Content-Disposition: form-data; name="${file.fieldName}"; filename="${file.filename}"\r\n`;
-    body += `Content-Type: ${file.contentType || 'application/octet-stream'}\r\n\r\n`;
-    body += `${file.content}\r\n`;
-  }
-
-  body += `--${boundary}--\r\n`;
-  return body;
-}
-
-export default {
-  MockRequest,
-  MockResponse,
-  createMockRequest,
-  createMockResponse,
-  createMockPair,
-  createJsonRequest,
-  createFormRequest,
-  createMultipartRequest,
-  createMultipartBody,
-};
-
-