@smoothbricks/lmao 0.1.0

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

@@ -0,0 +1,319 @@
+/**
+ * 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']);
+    });
+  });
+});