test: unit tests for babel plugin helpers

Author: artus9033

packages/instrumentation-react/tests/utils/getLocationDescription.test.ts

@@ -0,0 +1,44 @@
+import { getLocationDescription } from '../../src/utils/getLocationDescription';
+
+describe('getLocationDescription', () => {
+  it('returns correct location for NodePath with loc', () => {
+    const path = {
+      node: {
+        loc: {
+          start: { line: 1, column: 2 },
+          end: { line: 3, column: 4 },
+        },
+      },
+      type: 'NodePath',
+    } as any;
+    const pluginPass = { filename: 'file.ts' } as any;
+    expect(getLocationDescription(path, pluginPass)).toBe(
+      'file.ts:1:2 through 3:4'
+    );
+  });
+
+  it('returns correct location for ClassMethod', () => {
+    const classMethod = {
+      type: 'ClassMethod',
+      loc: {
+        start: { line: 10, column: 20 },
+        end: { line: 30, column: 40 },
+      },
+    } as any;
+    const pluginPass = { filename: 'class.ts' } as any;
+    expect(getLocationDescription(classMethod, pluginPass)).toBe(
+      'class.ts:10:20 through 30:40'
+    );
+  });
+
+  it('handles missing loc gracefully', () => {
+    const path = {
+      node: {},
+      type: 'NodePath',
+    } as any;
+    const pluginPass = { filename: 'nofile.ts' } as any;
+    expect(getLocationDescription(path, pluginPass)).toBe(
+      'nofile.ts:undefined:undefined through undefined:undefined'
+    );
+  });
+});

packages/instrumentation-react/tests/utils.test.ts renamed to packages/instrumentation-react/tests/utils/misc.test.ts

@@ -1,4 +1,4 @@
-import { uniqueVarName } from '../src/utils';
+import { uniqueVarName } from '../../src/utils/misc';
 
 describe('Utils', () => {
   describe('uniqueVarName', () => {

packages/instrumentation-react/tests/utils/parseDirective.test.ts

@@ -0,0 +1,119 @@
+import * as t from '@babel/types';
+
+import { parseDirective } from '../../src/utils/parseDirective';
+
+describe('parseDirective', () => {
+  const makePath = (node: any, parent: any = {}) => ({ node, parent });
+  const makeDirective = (value: string) =>
+    ({ value: { value } }) as t.Directive;
+
+  it('parses use trace dev', () => {
+    const path = makePath({ id: { name: 'MyComponent' } });
+    const directive = makeDirective('use trace dev');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result).toEqual({
+      componentName: 'MyComponent',
+      isFunctionComponent: true,
+      apiToUse: 'dev',
+    });
+  });
+
+  it('parses use trace otel', () => {
+    const path = makePath({ id: { name: 'MyComponent' } });
+    const directive = makeDirective('use trace otel');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.apiToUse).toBe('otel');
+    expect(result.componentName).toBe('MyComponent');
+    expect(result.isFunctionComponent).toBe(true);
+  });
+
+  it('parses use trace dev MyComponent', () => {
+    const path = makePath({ id: { name: 'OtherComponent' } });
+    const directive = makeDirective('use trace dev MyComponent');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.apiToUse).toBe('dev');
+    expect(result.componentName).toBe('MyComponent');
+    expect(result.isFunctionComponent).toBe(true);
+  });
+
+  it('parses use trace otel MyComponent', () => {
+    const path = makePath({ id: { name: 'OtherComponent' } });
+    const directive = makeDirective('use trace otel MyComponent');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.apiToUse).toBe('otel');
+    expect(result.componentName).toBe('MyComponent');
+    expect(result.isFunctionComponent).toBe(true);
+  });
+
+  it('parses use trace MyComponent', () => {
+    const path = makePath({ id: { name: 'OtherComponent' } });
+    const directive = makeDirective('use trace MyComponent');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.apiToUse).toBe('dev');
+    expect(result.componentName).toBe('MyComponent');
+    expect(result.isFunctionComponent).toBe(true);
+  });
+
+  it('throws on invalid API', () => {
+    const path = makePath({ id: { name: 'OtherComponent' } });
+    const directive = makeDirective('use trace invalidAPI MyComponent');
+    expect(() => parseDirective(path as any, directive, 'loc')).toThrow(
+      /Invalid tracing API specified/
+    );
+  });
+
+  it('throws on anonymous export default', () => {
+    const path = makePath({}, { type: 'ExportDefaultDeclaration' });
+    const directive = makeDirective('use trace dev');
+    expect(() => parseDirective(path as any, directive, 'loc')).toThrow(
+      /anonymous default export/
+    );
+  });
+
+  it('infers name from variable assignment', () => {
+    const path = makePath(
+      {},
+      {
+        type: 'VariableDeclarator',
+        id: { type: 'Identifier', name: 'VarComponent' },
+      }
+    );
+    const directive = makeDirective('use trace dev');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.componentName).toBe('VarComponent');
+  });
+
+  it('infers name from object property', () => {
+    const path = makePath(
+      {},
+      {
+        type: 'ObjectProperty',
+        key: { type: 'Identifier', name: 'ObjComponent' },
+      }
+    );
+    const directive = makeDirective('use trace dev');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.componentName).toBe('ObjComponent');
+  });
+
+  it('infers name from class method and sets isFunctionComponent false', () => {
+    const path = makePath(
+      {},
+      {
+        type: 'ClassMethod',
+        key: { type: 'Identifier', name: 'MethodComponent' },
+      }
+    );
+    const directive = makeDirective('use trace dev');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.componentName).toBe('MethodComponent');
+    expect(result.isFunctionComponent).toBe(false);
+  });
+
+  it('returns unknown if no name found', () => {
+    const path = makePath({});
+    const directive = makeDirective('use trace dev');
+    const result = parseDirective(path as any, directive, 'loc');
+    expect(result.componentName).toBe('unknown');
+  });
+});