@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/__tests__/remapped-buffer-view-integration.test.ts

@@ -1,319 +0,0 @@
-/**
- * Integration tests for RemappedBufferView registration with prefixed modules
- *
- * Per specs/lmao/01e_library_integration_pattern.md and 01c_context_flow_and_op_wrappers.md:
- * - RemappedBufferView class is generated once when prefix() is called (cold path)
- * - Op._invoke() creates instances when registering child spans with parent buffers
- * - Root spans don't create RemappedBufferView (no parent to register with)
- *
- * Note: These tests verify the Op-centric API's span hierarchy handling.
- */
-
-import { describe, expect, it } from 'bun:test';
-// Must import test-helpers first to initialize timestamp implementation
-import './test-helpers.js';
-import { convertSpanTreeToArrowTable } from '../convertToArrow.js';
-import { defineOpContext } from '../defineOpContext.js';
-import { S } from '../schema/builder.js';
-import { defineLogSchema } from '../schema/defineLogSchema.js';
-import { TestTracer } from '../tracers/TestTracer.js';
-import type { AnySpanBuffer } from '../types.js';
-import { createTestTracerOptions } from './test-helpers.js';
-
-function extractRows(
-  table: ReturnType<typeof convertSpanTreeToArrowTable>,
-  columns: readonly string[],
-): Array<Record<string, unknown>> {
-  return Array.from({ length: table.numRows }, (_, rowIndex) => {
-    const row: Record<string, unknown> = {};
-    for (const columnName of columns) {
-      const column = table.getChild(columnName);
-      if (column) {
-        row[columnName] = column.get(rowIndex) as unknown;
-      }
-    }
-    return row;
-  });
-}
-
-describe('RemappedBufferView Integration', () => {
-  describe('basic span execution', () => {
-    it('should execute parent and child ops correctly', async () => {
-      const appSchema = defineLogSchema({
-        userId: S.category(),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: appSchema,
-      });
-
-      const { defineOp } = opContext;
-
-      let parentExecuted = false;
-      let childExecuted = false;
-
-      const childOp = defineOp('child-op', async (ctx) => {
-        childExecuted = true;
-        ctx.tag.userId('child-user');
-        return ctx.ok({ child: true });
-      });
-
-      const parentOp = defineOp('parent-op', async (ctx) => {
-        parentExecuted = true;
-        const childResult = await ctx.span('child-span', childOp);
-        return ctx.ok({ parent: true, childResult });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      const result = await trace('parent-span', parentOp);
-
-      expect(parentExecuted).toBe(true);
-      expect(childExecuted).toBe(true);
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('Arrow conversion with unprefixed schemas', () => {
-    it('should write to buffer correctly', async () => {
-      const appSchema = defineLogSchema({
-        userId: S.category(),
-        action: S.enum(['create', 'read', 'update', 'delete']),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: appSchema,
-      });
-
-      const { defineOp } = opContext;
-
-      let rootBuffer: AnySpanBuffer | undefined;
-
-      const parentOp = defineOp('parent-op', async (ctx) => {
-        rootBuffer = ctx.buffer;
-        ctx.tag.userId('test-user').action('create');
-        ctx.log.info('Test log message');
-        return ctx.ok({ success: true });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      await trace('parent-span', parentOp);
-
-      expect(rootBuffer).toBeDefined();
-      if (!rootBuffer) throw new Error('rootBuffer is undefined');
-
-      // Verify buffer has rows written
-      expect(rootBuffer._writeIndex).toBeGreaterThan(0);
-
-      // Convert to Arrow table and verify schema
-      const table = convertSpanTreeToArrowTable(rootBuffer);
-
-      // Should have rows
-      expect(table.numRows).toBeGreaterThan(0);
-
-      // Verify user attribute columns exist in schema
-      const fieldNames = table.schema.fields.map((f) => f.name);
-      expect(fieldNames).toContain('userId');
-      expect(fieldNames).toContain('action');
-
-      // Verify system columns exist
-      expect(fieldNames).toContain('timestamp');
-      expect(fieldNames).toContain('trace_id');
-      expect(fieldNames).toContain('span_id');
-      expect(fieldNames).toContain('entry_type');
-      expect(fieldNames).toContain('package_name');
-      expect(fieldNames).toContain('message');
-
-      // Verify actual data values in rows
-      // Collect all rows for easier debugging
-      const rows = extractRows(table, ['userId', 'action', 'message', 'entry_type']);
-
-      // Find the row with our userId (should be the tag row or span-start row)
-      const userIdRow = rows.find((r) => r.userId === 'test-user');
-      expect(userIdRow).toBeDefined();
-      expect(userIdRow?.userId).toBe('test-user');
-      expect(userIdRow?.action).toBe('create');
-
-      // Find the log message row
-      const logRow = rows.find((r) => r.message === 'Test log message');
-      expect(logRow).toBeDefined();
-      expect(logRow?.message).toBe('Test log message');
-
-      // Verify entry types are present (span-start, info log, span-ok)
-      const entryTypes = rows.map((r) => r.entry_type);
-      expect(entryTypes).toContain('span-start');
-      expect(entryTypes).toContain('info');
-      expect(entryTypes).toContain('span-ok');
-    });
-  });
-
-  describe('nested spans execution', () => {
-    it('should execute deeply nested spans', async () => {
-      const schema = defineLogSchema({
-        level: S.category(),
-        data: S.text(),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: schema,
-      });
-
-      const { defineOp } = opContext;
-
-      const executionOrder: number[] = [];
-
-      const level3Op = defineOp('level3', async (ctx) => {
-        executionOrder.push(3);
-        ctx.tag.level('3').data('level 3 data');
-        return ctx.ok({ level: 3 });
-      });
-
-      const level2Op = defineOp('level2', async (ctx) => {
-        executionOrder.push(2);
-        ctx.tag.level('2').data('level 2 data');
-        await ctx.span('level3-span', level3Op);
-        return ctx.ok({ level: 2 });
-      });
-
-      const level1Op = defineOp('level1', async (ctx) => {
-        executionOrder.push(1);
-        ctx.tag.level('1').data('level 1 data');
-        await ctx.span('level2-span', level2Op);
-        return ctx.ok({ level: 1 });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      const result = await trace('level1-span', level1Op);
-
-      expect(result.success).toBe(true);
-      expect(executionOrder).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('parallel child spans', () => {
-    it('should execute multiple sequential child spans', async () => {
-      const schema = defineLogSchema({
-        taskId: S.category(),
-        taskStatus: S.enum(['pending', 'done']),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: schema,
-      });
-
-      const { defineOp } = opContext;
-
-      const taskResults: number[] = [];
-
-      const task1Op = defineOp('task1', async (ctx) => {
-        ctx.tag.taskId('task-1').taskStatus('done');
-        taskResults.push(1);
-        return ctx.ok({ task: 1 });
-      });
-
-      const task2Op = defineOp('task2', async (ctx) => {
-        ctx.tag.taskId('task-2').taskStatus('done');
-        taskResults.push(2);
-        return ctx.ok({ task: 2 });
-      });
-
-      const task3Op = defineOp('task3', async (ctx) => {
-        ctx.tag.taskId('task-3').taskStatus('done');
-        taskResults.push(3);
-        return ctx.ok({ task: 3 });
-      });
-
-      const parentOp = defineOp('parent', async (ctx) => {
-        ctx.tag.taskId('parent').taskStatus('pending');
-
-        // Run child tasks sequentially
-        await ctx.span('task1-span', task1Op);
-        await ctx.span('task2-span', task2Op);
-        await ctx.span('task3-span', task3Op);
-
-        ctx.tag.taskStatus('done');
-        return ctx.ok({ done: true });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      const result = await trace('parent-span', parentOp);
-
-      expect(result.success).toBe(true);
-      expect(taskResults).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('same factory for all ops', () => {
-    it('should handle all ops from the same factory', async () => {
-      // All ops use the same factory/schema for consistent behavior
-      const schema = defineLogSchema({
-        userId: S.category(),
-        status: S.number(),
-        method: S.category(),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: schema,
-      });
-
-      const { defineOp } = opContext;
-
-      let appExecuted = false;
-      let httpExecuted = false;
-
-      const httpOp = defineOp('http-request', async (ctx) => {
-        httpExecuted = true;
-        ctx.tag.status(200).method('GET');
-        return ctx.ok({ http: true });
-      });
-
-      const appOp = defineOp('app-handler', async (ctx) => {
-        appExecuted = true;
-        ctx.tag.userId('user-123');
-        await ctx.span('http-span', httpOp);
-        return ctx.ok({ app: true });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      const result = await trace('app-span', appOp);
-
-      expect(result.success).toBe(true);
-      expect(appExecuted).toBe(true);
-      expect(httpExecuted).toBe(true);
-    });
-  });
-
-  describe('inline closure spans', () => {
-    it('should handle inline closure spans', async () => {
-      const schema = defineLogSchema({
-        step: S.category(),
-      });
-
-      const opContext = defineOpContext({
-        logSchema: schema,
-      });
-
-      const { defineOp } = opContext;
-
-      const executedSteps: string[] = [];
-
-      const parentOp = defineOp('parent', async (ctx) => {
-        executedSteps.push('parent-start');
-
-        await ctx.span('inline-child', async (childCtx) => {
-          executedSteps.push('child');
-          childCtx.tag.step('inline-step');
-          return childCtx.ok({ inline: true });
-        });
-
-        executedSteps.push('parent-end');
-        return ctx.ok({ done: true });
-      });
-
-      const { trace } = new TestTracer(opContext, { ...createTestTracerOptions() });
-      const result = await trace('parent-span', parentOp);
-
-      expect(result.success).toBe(true);
-      expect(executedSteps).toEqual(['parent-start', 'child', 'parent-end']);
-    });
-  });
-});