test: add test for navigation codegen

Author: hurali97

packages/cli/src/navigation/__tests__/generators.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { generateKotlinDelegate, generateKotlinModule } from '../generators/android.js';
+import { generateObjCImplementation, generateSwiftDelegate } from '../generators/ios.js';
+import {
+  generateIndexDts,
+  generateIndexTs,
+  generateTurboModuleSpec,
+} from '../generators/ts.js';
+import type { MethodSignature } from '../types.js';
+
+const methods: MethodSignature[] = [
+  {
+    name: 'openScreen',
+    params: [
+      { name: 'route', type: 'string', optional: false },
+      { name: 'params', type: 'Object', optional: true },
+    ],
+    returnType: 'void',
+    isAsync: false,
+  },
+];
+
+describe('navigation code generators', () => {
+  it('generates TurboModule spec and index files', () => {
+    const turboModuleSpec = generateTurboModuleSpec(methods);
+    const indexTs = generateIndexTs(methods);
+    const indexDts = generateIndexDts(methods);
+
+    expect(turboModuleSpec).toContain('export interface Spec extends TurboModule');
+    expect(turboModuleSpec).toContain('openScreen(route: string, params?: Object): void;');
+
+    expect(indexTs).toContain('openScreen: (route: string, params?: Object)');
+    expect(indexTs).toContain('NativeBrownfieldNavigation.openScreen(route, params)');
+
+    expect(indexDts).toContain('openScreen: (route: string, params?: Object) => void;');
+  });
+
+  it('generates iOS bindings for sync methods', () => {
+    const swiftDelegate = generateSwiftDelegate(methods);
+    const objcImplementation = generateObjCImplementation(methods);
+
+    expect(swiftDelegate).toContain('@objc public protocol BrownfieldNavigationDelegate');
+    expect(swiftDelegate).toContain('@objc func openScreen(_ route: String, params params: [String: Any]?)');
+
+    expect(objcImplementation).toContain('- (void)openScreen:(NSString *)route params:(NSDictionary * _Nullable)params');
+    expect(objcImplementation).toContain(
+      '[[[BrownfieldNavigationManager shared] getDelegate] openScreen:route params:params];'
+    );
+  });
+
+  it('generates Android bindings for sync methods', () => {
+    const kotlinPackageName = 'com.callstack.nativebrownfieldnavigation';
+    const kotlinDelegate = generateKotlinDelegate(methods, kotlinPackageName);
+    const kotlinModule = generateKotlinModule(methods, kotlinPackageName);
+
+    expect(kotlinDelegate).toContain(`package ${kotlinPackageName}`);
+    expect(kotlinDelegate).toContain('fun openScreen(route: String, params: ReadableMap?)');
+
+    expect(kotlinModule).toContain('import com.facebook.react.bridge.ReadableMap');
+    expect(kotlinModule).toContain(
+      'override fun openScreen(route: String, params: ReadableMap?)'
+    );
+    expect(kotlinModule).toContain(
+      'BrownfieldNavigationManager.getDelegate().openScreen(route, params)'
+    );
+  });
+});
+
+describe('transpileWithConsumerBabel dependency errors', () => {
+  afterEach(() => {
+    vi.resetModules();
+    vi.unmock('node:module');
+  });
+
+  it('throws a clear error when @babel/core cannot be resolved', async () => {
+    vi.doMock('node:module', () => ({
+      createRequire: () => ({
+        resolve: () => {
+          throw new Error('module not found');
+        },
+      }),
+    }));
+
+    const { transpileWithConsumerBabel } = await import('../generators/ts.js');
+
+    expect(() =>
+      transpileWithConsumerBabel(
+        'const value: string = "hello"; export default value;',
+        '/tmp/project',
+        '/tmp/package'
+      )
+    ).toThrow('Could not resolve "@babel/core". Install it in your app devDependencies.');
+  });
+});

packages/cli/src/navigation/__tests__/models.test.ts

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const { addSourceMock, quicktypeMock } = vi.hoisted(() => ({
+  addSourceMock: vi.fn(async (_source: unknown) => undefined),
+  quicktypeMock: vi.fn(async ({ lang }: { lang: 'swift' | 'kotlin' }) => ({
+    lines:
+      lang === 'swift'
+        ? ['public struct UserProfile {}', 'public struct SessionResult {}']
+        : ['data class UserProfile()', 'data class SessionResult()'],
+  })),
+}));
+
+vi.mock('quicktype-core', () => ({
+  FetchingJSONSchemaStore: class {},
+  InputData: class {
+    addInput(): void {}
+  },
+  JSONSchemaInput: class {
+    async addSource(source: unknown): Promise<void> {
+      await addSourceMock(source);
+    }
+  },
+  quicktype: quicktypeMock,
+}));
+
+vi.mock('quicktype-typescript-input', () => ({
+  schemaForTypeScriptSources: () => ({
+    schema: JSON.stringify({
+      definitions: {
+        UserProfile: { type: 'object' },
+        SessionResult: { type: 'object' },
+        InternalOnly: { type: 'object' },
+      },
+    }),
+  }),
+}));
+
+import { generateNavigationModels } from '../generators/models.js';
+import type { MethodSignature } from '../types.js';
+
+function createTempSpecFile(contents: string): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'navigation-models-'));
+  const specPath = path.join(tempDir, 'brownfield.navigation.ts');
+  fs.writeFileSync(specPath, contents);
+  return specPath;
+}
+
+function cleanupTempSpecFile(specPath: string): void {
+  fs.rmSync(path.dirname(specPath), { recursive: true, force: true });
+}
+
+describe('generateNavigationModels', () => {
+  const tempSpecFiles: string[] = [];
+
+  afterEach(() => {
+    for (const specPath of tempSpecFiles) {
+      cleanupTempSpecFile(specPath);
+    }
+    tempSpecFiles.length = 0;
+    vi.clearAllMocks();
+  });
+
+  it('generates models for complex referenced types', async () => {
+    const specPath = createTempSpecFile(`
+      export interface BrownfieldNavigationSpec {
+        openProfile(profile: UserProfile): void;
+      }
+
+      export interface UserProfile {}
+    `);
+    tempSpecFiles.push(specPath);
+
+    const methods: MethodSignature[] = [
+      {
+        name: 'openProfile',
+        params: [{ name: 'profile', type: 'UserProfile', optional: false }],
+        returnType: 'void',
+        isAsync: false,
+      },
+    ];
+
+    const models = await generateNavigationModels({
+      specPath,
+      methods,
+      kotlinPackageName: 'com.callstack.nativebrownfieldnavigation',
+    });
+
+    expect(models.modelTypeNames).toEqual(['UserProfile']);
+    expect(models.swiftModels).toContain('public struct UserProfile');
+    expect(models.kotlinModels).toContain('data class UserProfile');
+    expect(addSourceMock).toHaveBeenCalled();
+    expect(quicktypeMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('skips model generation when no complex types are referenced', async () => {
+    const specPath = createTempSpecFile(`
+      export interface BrownfieldNavigationSpec {
+        open(route: string): void;
+      }
+    `);
+    tempSpecFiles.push(specPath);
+
+    const methods: MethodSignature[] = [
+      {
+        name: 'open',
+        params: [{ name: 'route', type: 'string', optional: false }],
+        returnType: 'void',
+        isAsync: false,
+      },
+    ];
+
+    const models = await generateNavigationModels({
+      specPath,
+      methods,
+      kotlinPackageName: 'com.callstack.nativebrownfieldnavigation',
+    });
+
+    expect(models).toEqual({ modelTypeNames: [] });
+    expect(quicktypeMock).not.toHaveBeenCalled();
+  });
+});

packages/cli/src/navigation/__tests__/parser.test.ts

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { parseNavigationSpec } from '../parser.js';
+
+function createTempSpecFile(contents: string): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'navigation-parser-'));
+  const specPath = path.join(tempDir, 'brownfield.navigation.ts');
+  fs.writeFileSync(specPath, contents);
+  return specPath;
+}
+
+function cleanupTempSpecFile(specPath: string): void {
+  fs.rmSync(path.dirname(specPath), { recursive: true, force: true });
+}
+
+describe('parseNavigationSpec', () => {
+  const tempSpecFiles: string[] = [];
+
+  afterEach(() => {
+    for (const specPath of tempSpecFiles) {
+      cleanupTempSpecFile(specPath);
+    }
+    tempSpecFiles.length = 0;
+  });
+
+  it('parses methods from BrownfieldNavigationSpec interface', () => {
+    const specPath = createTempSpecFile(`
+      export interface BrownfieldNavigationSpec {
+        openScreen(route: string, params?: Object): void;
+      }
+    `);
+    tempSpecFiles.push(specPath);
+
+    const methods = parseNavigationSpec(specPath);
+
+    expect(methods).toEqual([
+      {
+        name: 'openScreen',
+        params: [
+          { name: 'route', type: 'string', optional: false },
+          { name: 'params', type: 'Object', optional: true },
+        ],
+        returnType: 'void',
+        isAsync: false,
+      },
+    ]);
+  });
+
+  it('falls back to Spec interface when BrownfieldNavigationSpec is absent', () => {
+    const specPath = createTempSpecFile(`
+      export interface Spec {
+        presentModal(id: string): number;
+      }
+    `);
+    tempSpecFiles.push(specPath);
+
+    const methods = parseNavigationSpec(specPath);
+
+    expect(methods).toEqual([
+      {
+        name: 'presentModal',
+        params: [{ name: 'id', type: 'string', optional: false }],
+        returnType: 'number',
+        isAsync: false,
+      },
+    ]);
+  });
+
+  it('throws when no valid spec interface is present', () => {
+    const specPath = createTempSpecFile(`
+      export interface NavigationSpec {
+        noOp(): void;
+      }
+    `);
+    tempSpecFiles.push(specPath);
+
+    expect(() => parseNavigationSpec(specPath)).toThrow(
+      'Could not find BrownfieldNavigationSpec or Spec interface in spec file'
+    );
+  });
+
+  it('throws when spec file does not exist', () => {
+    expect(() => parseNavigationSpec('/tmp/non-existent-navigation-spec.ts')).toThrow(
+      'Spec file not found: /tmp/non-existent-navigation-spec.ts'
+    );
+  });
+});