@skillsmith/core 0.5.6 → 0.5.8

package/dist/analysis/adapters/__tests__/python.test.js

@@ -1,669 +0,0 @@
-/**
- * SMI-1304: Python Language Adapter Tests
- *
- * Comprehensive test suite for the PythonAdapter class.
- * Tests cover import/export extraction, function detection,
- * and framework detection rules.
- *
- * @see docs/internal/architecture/multi-language-analysis.md
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { PythonAdapter } from '../python.js';
-describe('PythonAdapter', () => {
-    let adapter;
-    beforeEach(() => {
-        adapter = new PythonAdapter();
-    });
-    afterEach(() => {
-        adapter.dispose();
-    });
-    // ============================================================
-    // canHandle Tests
-    // ============================================================
-    describe('canHandle', () => {
-        it('handles .py files', () => {
-            expect(adapter.canHandle('main.py')).toBe(true);
-            expect(adapter.canHandle('/path/to/script.py')).toBe(true);
-        });
-        it('handles .pyi stub files', () => {
-            expect(adapter.canHandle('types.pyi')).toBe(true);
-            expect(adapter.canHandle('/path/to/stubs.pyi')).toBe(true);
-        });
-        it('handles .pyw Windows files', () => {
-            expect(adapter.canHandle('gui_app.pyw')).toBe(true);
-        });
-        it('does not handle other file types', () => {
-            expect(adapter.canHandle('main.ts')).toBe(false);
-            expect(adapter.canHandle('main.js')).toBe(false);
-            expect(adapter.canHandle('main.go')).toBe(false);
-            expect(adapter.canHandle('main.rs')).toBe(false);
-            expect(adapter.canHandle('main.java')).toBe(false);
-            expect(adapter.canHandle('main.txt')).toBe(false);
-        });
-        it('handles case insensitively (for cross-platform compatibility)', () => {
-            // Extensions are normalized to lowercase for cross-platform support
-            expect(adapter.canHandle('main.PY')).toBe(true);
-            expect(adapter.canHandle('main.Py')).toBe(true);
-            expect(adapter.canHandle('main.PYI')).toBe(true);
-        });
-    });
-    // ============================================================
-    // parseFile - Import Extraction Tests
-    // ============================================================
-    describe('parseFile - imports', () => {
-        it('extracts simple import statements', () => {
-            const content = `
-import os
-import sys
-import json
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(3);
-            expect(result.imports[0]).toMatchObject({
-                module: 'os',
-                namedImports: [],
-                isTypeOnly: false,
-                sourceFile: 'test.py',
-            });
-            expect(result.imports[1]).toMatchObject({
-                module: 'sys',
-                namedImports: [],
-            });
-            expect(result.imports[2]).toMatchObject({
-                module: 'json',
-                namedImports: [],
-            });
-        });
-        it('extracts import with alias', () => {
-            const content = `
-import numpy as np
-import pandas as pd
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(2);
-            expect(result.imports[0]).toMatchObject({
-                module: 'numpy',
-                defaultImport: 'np',
-            });
-            expect(result.imports[1]).toMatchObject({
-                module: 'pandas',
-                defaultImport: 'pd',
-            });
-        });
-        it('extracts from imports with named imports', () => {
-            const content = `
-from typing import List, Optional, Dict
-from collections import defaultdict
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(2);
-            expect(result.imports[0]).toMatchObject({
-                module: 'typing',
-                namedImports: ['List', 'Optional', 'Dict'],
-            });
-            expect(result.imports[1]).toMatchObject({
-                module: 'collections',
-                namedImports: ['defaultdict'],
-            });
-        });
-        it('extracts from imports with aliases', () => {
-            const content = `
-from os.path import join as path_join, exists as path_exists
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(1);
-            expect(result.imports[0]).toMatchObject({
-                module: 'os.path',
-                namedImports: ['join', 'exists'],
-            });
-        });
-        it('extracts wildcard imports', () => {
-            const content = `
-from os import *
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(1);
-            expect(result.imports[0]).toMatchObject({
-                module: 'os',
-                namedImports: [],
-                namespaceImport: '*',
-            });
-        });
-        it('extracts multi-line imports with parentheses', () => {
-            const content = `
-from django.http import (
-    HttpResponse,
-    HttpResponseRedirect,
-    JsonResponse,
-)
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(1);
-            expect(result.imports[0].module).toBe('django.http');
-            expect(result.imports[0].namedImports).toContain('HttpResponse');
-            expect(result.imports[0].namedImports).toContain('HttpResponseRedirect');
-            expect(result.imports[0].namedImports).toContain('JsonResponse');
-        });
-        it('extracts dotted module names', () => {
-            const content = `
-import os.path
-from django.db.models import Model
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(2);
-            expect(result.imports[0].module).toBe('os.path');
-            expect(result.imports[1].module).toBe('django.db.models');
-        });
-        it('skips comments and empty lines', () => {
-            const content = `
-# This is a comment
-import os
-
-# Another comment
-import sys
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports).toHaveLength(2);
-        });
-        it('includes line numbers', () => {
-            const content = `import os
-import sys
-from typing import List
-`;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.imports[0].line).toBe(1);
-            expect(result.imports[1].line).toBe(2);
-            expect(result.imports[2].line).toBe(3);
-        });
-    });
-    // ============================================================
-    // parseFile - Export Extraction Tests
-    // ============================================================
-    describe('parseFile - exports', () => {
-        it('extracts __all__ explicit exports', () => {
-            const content = `
-__all__ = ['public_func', 'PublicClass', 'CONSTANT']
-
-def public_func():
-    pass
-
-def _private_func():
-    pass
-
-class PublicClass:
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // Should have __all__ exports plus top-level public definitions
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).toContain('public_func');
-            expect(exportNames).toContain('PublicClass');
-            expect(exportNames).toContain('CONSTANT');
-            // Private functions should not be in exports
-            expect(exportNames).not.toContain('_private_func');
-        });
-        it('extracts top-level function exports', () => {
-            const content = `
-def public_function():
-    pass
-
-def another_public():
-    pass
-
-def _private():
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).toContain('public_function');
-            expect(exportNames).toContain('another_public');
-            expect(exportNames).not.toContain('_private');
-        });
-        it('extracts top-level class exports', () => {
-            const content = `
-class PublicClass:
-    pass
-
-class AnotherPublic:
-    pass
-
-class _PrivateClass:
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).toContain('PublicClass');
-            expect(exportNames).toContain('AnotherPublic');
-            expect(exportNames).not.toContain('_PrivateClass');
-        });
-        it('identifies export kinds correctly', () => {
-            const content = `
-def my_function():
-    pass
-
-class MyClass:
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const funcExport = result.exports.find((e) => e.name === 'my_function');
-            const classExport = result.exports.find((e) => e.name === 'MyClass');
-            expect(funcExport?.kind).toBe('function');
-            expect(classExport?.kind).toBe('class');
-        });
-        it('does not export methods (indented functions)', () => {
-            const content = `
-class MyClass:
-    def method(self):
-        pass
-
-    def _private_method(self):
-        pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).not.toContain('method');
-            expect(exportNames).not.toContain('_private_method');
-        });
-        it('handles async function exports', () => {
-            const content = `
-async def async_handler():
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).toContain('async_handler');
-        });
-    });
-    // ============================================================
-    // parseFile - Function Extraction Tests
-    // ============================================================
-    describe('parseFile - functions', () => {
-        it('extracts sync function definitions', () => {
-            const content = `
-def sync_function(a, b, c):
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions).toHaveLength(1);
-            expect(result.functions[0]).toMatchObject({
-                name: 'sync_function',
-                parameterCount: 3,
-                isAsync: false,
-                isExported: true,
-                sourceFile: 'test.py',
-            });
-        });
-        it('extracts async function definitions', () => {
-            const content = `
-async def async_function(x):
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions).toHaveLength(1);
-            expect(result.functions[0]).toMatchObject({
-                name: 'async_function',
-                parameterCount: 1,
-                isAsync: true,
-                isExported: true,
-            });
-        });
-        it('excludes self and cls from parameter count', () => {
-            const content = `
-class MyClass:
-    def instance_method(self, a, b):
-        pass
-
-    @classmethod
-    def class_method(cls, x):
-        pass
-
-    @staticmethod
-    def static_method(y, z):
-        pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const instanceMethod = result.functions.find((f) => f.name === 'instance_method');
-            const classMethod = result.functions.find((f) => f.name === 'class_method');
-            const staticMethod = result.functions.find((f) => f.name === 'static_method');
-            expect(instanceMethod?.parameterCount).toBe(2); // a, b (not self)
-            expect(classMethod?.parameterCount).toBe(1); // x (not cls)
-            expect(staticMethod?.parameterCount).toBe(2); // y, z
-        });
-        it('marks top-level functions as exported', () => {
-            const content = `
-def top_level():
-    pass
-
-class MyClass:
-    def method(self):
-        pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const topLevel = result.functions.find((f) => f.name === 'top_level');
-            const method = result.functions.find((f) => f.name === 'method');
-            expect(topLevel?.isExported).toBe(true);
-            expect(method?.isExported).toBe(false);
-        });
-        it('marks private functions as not exported', () => {
-            const content = `
-def _private_function():
-    pass
-
-def __dunder_function__():
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            const privateFunc = result.functions.find((f) => f.name === '_private_function');
-            const dunderFunc = result.functions.find((f) => f.name === '__dunder_function__');
-            expect(privateFunc?.isExported).toBe(false);
-            expect(dunderFunc?.isExported).toBe(false);
-        });
-        it('handles functions with no parameters', () => {
-            const content = `
-def no_params():
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions[0].parameterCount).toBe(0);
-        });
-        it('includes line numbers', () => {
-            const content = `def first():
-    pass
-
-def second():
-    pass
-`;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions[0].line).toBe(1);
-            expect(result.functions[1].line).toBe(4);
-        });
-        it('handles functions with default parameters', () => {
-            const content = `
-def with_defaults(a, b=10, c="hello"):
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // Parameter count includes all params, regardless of defaults
-            expect(result.functions[0].parameterCount).toBe(3);
-        });
-        it('handles functions with *args and **kwargs', () => {
-            const content = `
-def with_varargs(a, *args, **kwargs):
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // *args and **kwargs are counted as parameters
-            expect(result.functions[0].parameterCount).toBe(3);
-        });
-    });
-    // ============================================================
-    // parseFile - Combined Tests
-    // ============================================================
-    describe('parseFile - complete parsing', () => {
-        it('parses a complete Django view file', () => {
-            const content = `
-from django.http import HttpResponse, JsonResponse
-from django.views import View
-from .models import User
-
-class UserView(View):
-    def get(self, request, user_id):
-        user = User.objects.get(id=user_id)
-        return JsonResponse({'name': user.name})
-
-    def post(self, request):
-        pass
-
-def index(request):
-    return HttpResponse("Hello")
-      `;
-            const result = adapter.parseFile(content, 'views.py');
-            // Check imports
-            expect(result.imports).toHaveLength(3);
-            expect(result.imports[0].namedImports).toContain('HttpResponse');
-            expect(result.imports[0].namedImports).toContain('JsonResponse');
-            // Check exports
-            const exportNames = result.exports.map((e) => e.name);
-            expect(exportNames).toContain('UserView');
-            expect(exportNames).toContain('index');
-            // Check functions
-            expect(result.functions.length).toBeGreaterThanOrEqual(3);
-        });
-        it('parses a FastAPI application', () => {
-            const content = `
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-
-app = FastAPI()
-
-class Item(BaseModel):
-    name: str
-    price: float
-
-@app.get("/")
-async def root():
-    return {"message": "Hello World"}
-
-@app.post("/items/")
-async def create_item(item: Item):
-    return item
-      `;
-            const result = adapter.parseFile(content, 'main.py');
-            // Check imports
-            expect(result.imports.some((i) => i.module === 'fastapi')).toBe(true);
-            expect(result.imports.some((i) => i.module === 'pydantic')).toBe(true);
-            // Check async functions
-            const asyncFuncs = result.functions.filter((f) => f.isAsync);
-            expect(asyncFuncs.length).toBe(2);
-            expect(asyncFuncs.map((f) => f.name)).toContain('root');
-            expect(asyncFuncs.map((f) => f.name)).toContain('create_item');
-        });
-        it('returns empty arrays for empty file', () => {
-            const result = adapter.parseFile('', 'empty.py');
-            expect(result.imports).toEqual([]);
-            expect(result.exports).toEqual([]);
-            expect(result.functions).toEqual([]);
-        });
-        it('handles file with only comments', () => {
-            const content = `
-# This is a comment
-# Another comment
-"""
-This is a docstring-style comment
-"""
-      `;
-            const result = adapter.parseFile(content, 'comments.py');
-            expect(result.imports).toEqual([]);
-            expect(result.exports).toEqual([]);
-            expect(result.functions).toEqual([]);
-        });
-    });
-    // ============================================================
-    // getFrameworkRules Tests
-    // ============================================================
-    describe('getFrameworkRules', () => {
-        it('includes Django detection rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const django = rules.find((r) => r.name === 'Django');
-            expect(django).toBeDefined();
-            expect(django?.depIndicators).toContain('django');
-            expect(django?.importIndicators).toContain('django');
-            expect(django?.importIndicators).toContain('django.http');
-        });
-        it('includes FastAPI detection rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const fastapi = rules.find((r) => r.name === 'FastAPI');
-            expect(fastapi).toBeDefined();
-            expect(fastapi?.depIndicators).toContain('fastapi');
-            expect(fastapi?.importIndicators).toContain('fastapi');
-            expect(fastapi?.importIndicators).toContain('starlette');
-        });
-        it('includes Flask detection rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const flask = rules.find((r) => r.name === 'Flask');
-            expect(flask).toBeDefined();
-            expect(flask?.depIndicators).toContain('flask');
-        });
-        it('includes pytest detection rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const pytest = rules.find((r) => r.name === 'pytest');
-            expect(pytest).toBeDefined();
-            expect(pytest?.depIndicators).toContain('pytest');
-        });
-        it('includes data science library rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const pandas = rules.find((r) => r.name === 'pandas');
-            const numpy = rules.find((r) => r.name === 'numpy');
-            expect(pandas).toBeDefined();
-            expect(numpy).toBeDefined();
-            expect(pandas?.importIndicators).toContain('pd');
-            expect(numpy?.importIndicators).toContain('np');
-        });
-        it('includes ML framework rules', () => {
-            const rules = adapter.getFrameworkRules();
-            const tensorflow = rules.find((r) => r.name === 'TensorFlow');
-            const pytorch = rules.find((r) => r.name === 'PyTorch');
-            expect(tensorflow).toBeDefined();
-            expect(pytorch).toBeDefined();
-        });
-        it('returns non-empty array', () => {
-            const rules = adapter.getFrameworkRules();
-            expect(rules.length).toBeGreaterThan(0);
-        });
-    });
-    // ============================================================
-    // parseIncremental Tests
-    // ============================================================
-    describe('parseIncremental', () => {
-        it('falls back to full parsing without previous tree', () => {
-            const content = `
-def my_function():
-    pass
-      `;
-            const result = adapter.parseIncremental(content, 'test.py');
-            expect(result.functions).toHaveLength(1);
-            expect(result.functions[0].name).toBe('my_function');
-        });
-        it('handles incremental updates', () => {
-            const content1 = `
-def original():
-    pass
-      `;
-            const content2 = `
-def original():
-    pass
-
-def new_function():
-    pass
-      `;
-            const result1 = adapter.parseIncremental(content1, 'test.py');
-            const result2 = adapter.parseIncremental(content2, 'test.py');
-            expect(result1.functions).toHaveLength(1);
-            expect(result2.functions).toHaveLength(2);
-        });
-    });
-    // ============================================================
-    // dispose Tests
-    // ============================================================
-    describe('dispose', () => {
-        it('can be called multiple times without error', () => {
-            adapter.dispose();
-            adapter.dispose();
-            adapter.dispose();
-            // Should not throw
-            expect(true).toBe(true);
-        });
-        it('cleans up parser resources', () => {
-            // Parse something to initialize any internal state
-            adapter.parseFile('import os', 'test.py');
-            // Dispose should clean up
-            adapter.dispose();
-            // Should still be able to parse after dispose
-            const result = adapter.parseFile('import sys', 'test.py');
-            expect(result.imports).toHaveLength(1);
-        });
-    });
-    // ============================================================
-    // Language and Extensions Properties Tests
-    // ============================================================
-    describe('properties', () => {
-        it('has correct language identifier', () => {
-            expect(adapter.language).toBe('python');
-        });
-        it('has correct extensions', () => {
-            expect(adapter.extensions).toContain('.py');
-            expect(adapter.extensions).toContain('.pyi');
-            expect(adapter.extensions).toContain('.pyw');
-            expect(adapter.extensions).toHaveLength(3);
-        });
-    });
-    // ============================================================
-    // Edge Cases
-    // ============================================================
-    describe('edge cases', () => {
-        it('handles deeply nested functions', () => {
-            const content = `
-def outer():
-    def middle():
-        def inner():
-            pass
-        return inner
-    return middle
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // Should find all functions (including nested)
-            const funcNames = result.functions.map((f) => f.name);
-            expect(funcNames).toContain('outer');
-            expect(funcNames).toContain('middle');
-            expect(funcNames).toContain('inner');
-        });
-        it('handles decorators before functions', () => {
-            const content = `
-@decorator
-def decorated():
-    pass
-
-@decorator1
-@decorator2
-def multi_decorated():
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions).toHaveLength(2);
-        });
-        it('handles type hints in function signatures', () => {
-            const content = `
-def typed_function(a: int, b: str, c: Optional[List[int]]) -> Dict[str, Any]:
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            expect(result.functions).toHaveLength(1);
-            expect(result.functions[0].parameterCount).toBe(3);
-        });
-        it('handles multiline function signatures', () => {
-            const content = `
-def long_function(
-    param1,
-    param2,
-    param3
-):
-    pass
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // Note: Current regex implementation may not handle this perfectly
-            // but should at least find the function
-            expect(result.functions.length).toBeGreaterThanOrEqual(0);
-        });
-        it('handles relative imports', () => {
-            const content = `
-from . import module
-from .. import parent_module
-from .sibling import function
-      `;
-            const result = adapter.parseFile(content, 'test.py');
-            // Current implementation may handle this differently
-            expect(result.imports.length).toBeGreaterThanOrEqual(0);
-        });
-    });
-});
-//# sourceMappingURL=python.test.js.map