@mmapp/react-compiler 0.1.0-alpha.1

package/src/__tests__/context-extractor.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Context Extractor Tests — validates createContext → workflow derivation.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { transformSync } from '@babel/core';
+import babelPlugin from '../babel';
+import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
+
+function compile(code: string, filename = 'contexts/ChatContext.tsx'): IRWorkflowDefinition {
+  const result = transformSync(code, {
+    filename,
+    plugins: [[babelPlugin]],
+    parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
+  });
+  return (result as any)?.metadata?.mindmatrixIR;
+}
+
+describe('Context Extractor', () => {
+  it('should extract createContext as context workflow metadata', () => {
+    const ir = compile(`
+      import { createContext } from 'react';
+
+      interface ChatState {
+        messages: string[];
+        channel: string;
+      }
+
+      const ChatContext = createContext<ChatState>({ messages: [], channel: '' });
+
+      export function ChatProvider({ children }: { children: React.ReactNode }) {
+        return <ChatContext.Provider value={{ messages: [], channel: '' }}>{children}</ChatContext.Provider>;
+      }
+    `);
+
+    // Context workflows are stored in metadata
+    expect(ir.metadata?.contextWorkflows).toBeDefined();
+    const workflows = (ir.metadata as any).contextWorkflows;
+    expect(workflows).toHaveLength(1);
+    expect(workflows[0].name).toBe('ChatContext');
+  });
+
+  it('should extract interface fields', () => {
+    const ir = compile(`
+      import { createContext } from 'react';
+
+      interface AppState {
+        count: number;
+        name: string;
+        active: boolean;
+      }
+
+      const AppContext = createContext<AppState>({ count: 0, name: '', active: false });
+      export default AppContext;
+    `);
+
+    const workflow = (ir.metadata as any).contextWorkflows[0];
+    expect(workflow.fields).toHaveLength(3);
+    expect(workflow.fields.find((f: any) => f.name === 'count')?.type).toBe('number');
+    expect(workflow.fields.find((f: any) => f.name === 'name')?.type).toBe('string');
+    expect(workflow.fields.find((f: any) => f.name === 'active')?.type).toBe('boolean');
+  });
+
+  it('should extract initial state from createContext default', () => {
+    const ir = compile(`
+      import { createContext } from 'react';
+
+      const AppContext = createContext({ count: 0, name: 'default', active: true });
+      export default AppContext;
+    `);
+
+    const workflow = (ir.metadata as any).contextWorkflows[0];
+    expect(workflow.initialState).toBeDefined();
+    expect(workflow.initialState.count).toBe(0);
+    expect(workflow.initialState.name).toBe('default');
+    expect(workflow.initialState.active).toBe(true);
+  });
+
+  it('should extract reducer actions as transitions', () => {
+    const ir = compile(`
+      import { createContext, useReducer } from 'react';
+
+      interface State { count: number; }
+
+      function counterReducer(state: State, action: { type: string }) {
+        switch (action.type) {
+          case 'INCREMENT': return { ...state, count: state.count + 1 };
+          case 'DECREMENT': return { ...state, count: state.count - 1 };
+          case 'RESET': return { count: 0 };
+          default: return state;
+        }
+      }
+
+      const CounterContext = createContext<State>({ count: 0 });
+
+      export function CounterProvider({ children }: any) {
+        const [state, dispatch] = useReducer(counterReducer, { count: 0 });
+        return <CounterContext.Provider value={state}>{children}</CounterContext.Provider>;
+      }
+    `);
+
+    const workflow = (ir.metadata as any).contextWorkflows[0];
+    expect(workflow.reducerActions).toHaveLength(3);
+    expect(workflow.reducerActions.map((a: any) => a.type)).toContain('INCREMENT');
+    expect(workflow.reducerActions.map((a: any) => a.type)).toContain('DECREMENT');
+    expect(workflow.reducerActions.map((a: any) => a.type)).toContain('RESET');
+    expect(workflow.reducerName).toBe('counterReducer');
+  });
+
+  it('should handle multiple contexts in one file', () => {
+    const ir = compile(`
+      import { createContext } from 'react';
+
+      const ThemeContext = createContext({ dark: false });
+      const AuthContext = createContext({ user: null });
+      export { ThemeContext, AuthContext };
+    `);
+
+    const workflows = (ir.metadata as any).contextWorkflows;
+    expect(workflows).toHaveLength(2);
+    expect(workflows[0].name).toBe('ThemeContext');
+    expect(workflows[1].name).toBe('AuthContext');
+  });
+
+  it('should handle optional fields', () => {
+    const ir = compile(`
+      import { createContext } from 'react';
+
+      interface Config {
+        name: string;
+        description?: string;
+        count: number;
+      }
+
+      const ConfigContext = createContext<Config>({ name: '', count: 0 });
+      export default ConfigContext;
+    `);
+
+    const workflow = (ir.metadata as any).contextWorkflows[0];
+    const descField = workflow.fields.find((f: any) => f.name === 'description');
+    expect(descField?.optional).toBe(true);
+    const nameField = workflow.fields.find((f: any) => f.name === 'name');
+    expect(nameField?.optional).toBe(false);
+  });
+});