archsync 1.0.0

package/src/__tests__/parsers.test.js

@@ -0,0 +1,496 @@
+/**
+ * Unit tests for CLI parsers:
+ *   - reactParser (parseReactFile)
+ *   - nodeParser  (parseNodeFile)
+ *   - smartComment (parseSmartComments)
+ *
+ * All tests use vi.mock to intercept fs.readFileSync so no real files are
+ * needed on disk.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseReactFile } from '../parsers/reactParser.js';
+import { parseNodeFile } from '../parsers/nodeParser.js';
+import { parseSmartComments } from '../parsers/smartComment.js';
+
+// ─── Mock fs module ──────────────────────────────────────────
+// The parsers use `import fs from 'fs'` (default import), so the mock must
+// replace readFileSync on the default export as well as the named one.
+vi.mock('fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    const readFileSync = vi.fn();
+    return {
+        ...actual,
+        readFileSync,
+        default: { ...actual.default, readFileSync },
+    };
+});
+
+import fs from 'fs';
+
+function setFileContent(content) {
+    fs.readFileSync.mockReturnValue(content);
+}
+
+// ─── reactParser ─────────────────────────────────────────────
+
+describe('reactParser — parseReactFile', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('extracts a React functional component by name', () => {
+        setFileContent(`
+export default function HomePage() {
+    return <div>Home</div>;
+}
+`);
+        const result = parseReactFile('/web/pages/HomePage.jsx');
+        expect(result.entities.length).toBeGreaterThan(0);
+        const comp = result.entities.find(e => e.name === 'HomePage');
+        expect(comp).toBeDefined();
+        expect(comp.entityType).toBe('screen');
+    });
+
+    it('extracts a named export component', () => {
+        setFileContent(`
+export function UserCard() {
+    return <div />;
+}
+`);
+        const result = parseReactFile('/web/components/UserCard.jsx');
+        const comp = result.entities.find(e => e.name === 'UserCard');
+        expect(comp).toBeDefined();
+    });
+
+    it('classifies "page"-named components as screen entityType', () => {
+        setFileContent(`
+export function DashboardPage() {
+    return <div />;
+}
+`);
+        const result = parseReactFile('/web/pages/DashboardPage.jsx');
+        const comp = result.entities.find(e => e.name === 'DashboardPage');
+        expect(comp.entityType).toBe('screen');
+    });
+
+    it('extracts a custom hook as a service entity', () => {
+        setFileContent(`
+export function useAuthState() {
+    const [user, setUser] = useState(null);
+    return user;
+}
+`);
+        const result = parseReactFile('/web/hooks/useAuthState.js');
+        const hook = result.entities.find(e => e.name === 'useAuthState');
+        expect(hook).toBeDefined();
+        expect(hook.entityType).toBe('service');
+        expect(hook.data.type).toBe('hook');
+    });
+
+    it('extracts a fetch() API call as an api entity', () => {
+        setFileContent(`
+export function ProfilePage() {
+    useEffect(() => {
+        fetch('/api/users/me').then(r => r.json());
+    }, []);
+    return <div />;
+}
+`);
+        const result = parseReactFile('/web/pages/ProfilePage.jsx');
+        const apiEntity = result.entities.find(e => e.entityType === 'api');
+        expect(apiEntity).toBeDefined();
+        expect(apiEntity.data.path).toBe('/api/users/me');
+    });
+
+    it('extracts an axios API call as an api entity', () => {
+        setFileContent(`
+export function OrdersPage() {
+    useEffect(() => {
+        axios.post('/api/orders', payload);
+    }, []);
+    return <div />;
+}
+`);
+        const result = parseReactFile('/web/pages/OrdersPage.jsx');
+        const apiEntity = result.entities.find(e => e.entityType === 'api' && e.data.method === 'POST');
+        expect(apiEntity).toBeDefined();
+        expect(apiEntity.data.path).toBe('/api/orders');
+    });
+
+    it('does not extract lowercase utility functions as components', () => {
+        setFileContent(`
+function formatDate(d) { return d.toISOString(); }
+export function Header() { return <header />; }
+`);
+        const result = parseReactFile('/web/components/Header.jsx');
+        const utils = result.entities.filter(e => e.name === 'formatDate');
+        expect(utils).toHaveLength(0);
+    });
+
+    it('sets system to "admin" for files inside /admin/ paths', () => {
+        setFileContent(`
+export function AdminDashboard() { return <div />; }
+`);
+        const result = parseReactFile('/admin/pages/AdminDashboard.jsx');
+        const comp = result.entities.find(e => e.name === 'AdminDashboard');
+        expect(comp?.system).toBe('admin');
+    });
+
+    it('does not extract built-in hooks (useState, useEffect, useContext)', () => {
+        setFileContent(`
+export function Counter() {
+    const [n, setN] = useState(0);
+    useEffect(() => {}, []);
+    return <div />;
+}
+`);
+        const result = parseReactFile('/web/Counter.jsx');
+        const builtins = result.entities.filter(e =>
+            ['useState', 'useEffect', 'useContext'].includes(e.name)
+        );
+        expect(builtins).toHaveLength(0);
+    });
+
+    it('creates import relations for relative component imports', () => {
+        setFileContent(`
+import Button from './Button';
+export function LoginPage() {
+    return <Button />;
+}
+`);
+        const result = parseReactFile('/web/pages/LoginPage.jsx');
+        // LoginPage should exist and have a relation pointing to Button
+        expect(result.relations.length).toBeGreaterThan(0);
+        expect(result.relations[0].target).toBe('Button');
+    });
+
+    it('returns empty entities for empty file', () => {
+        setFileContent('');
+        const result = parseReactFile('/web/empty.jsx');
+        expect(result.entities).toHaveLength(0);
+        expect(result.relations).toHaveLength(0);
+    });
+
+    it('handles syntax that looks like a component but is a variable assignment', () => {
+        setFileContent(`
+const config = { theme: 'dark' };
+export default config;
+`);
+        const result = parseReactFile('/web/config.js');
+        // No PascalCase function component should be found
+        const comps = result.entities.filter(e => e.entityType === 'screen');
+        expect(comps).toHaveLength(0);
+    });
+});
+
+// ─── nodeParser ──────────────────────────────────────────────
+
+describe('nodeParser — parseNodeFile', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('extracts Express GET routes', () => {
+        setFileContent(`
+const router = express.Router();
+router.get('/users', getUsers);
+router.get('/users/:id', getUserById);
+`);
+        const result = parseNodeFile('/backend/routes/userRoutes.js');
+        const routes = result.entities.filter(e => e.entityType === 'route');
+        expect(routes).toHaveLength(2);
+        expect(routes[0].data.method).toBe('GET');
+    });
+
+    it('extracts POST, PUT, DELETE routes', () => {
+        setFileContent(`
+router.post('/items', createItem);
+router.put('/items/:id', updateItem);
+router.delete('/items/:id', deleteItem);
+`);
+        const result = parseNodeFile('/backend/routes/itemRoutes.js');
+        const routes = result.entities.filter(e => e.entityType === 'route');
+        expect(routes.map(r => r.data.method).sort()).toEqual(['DELETE', 'POST', 'PUT']);
+    });
+
+    it('extracts route names with full path', () => {
+        setFileContent(`router.get('/health', healthCheck);`);
+        const result = parseNodeFile('/backend/routes/health.js');
+        const route = result.entities.find(e => e.entityType === 'route');
+        expect(route.name).toBe('GET /health');
+    });
+
+    it('extracts Mongoose models', () => {
+        setFileContent(`
+const User = mongoose.model('User', userSchema);
+const Post = mongoose.model('Post', postSchema);
+`);
+        const result = parseNodeFile('/backend/models/User.model.js');
+        const models = result.entities.filter(e => e.entityType === 'model' && e.data.orm === 'mongoose');
+        expect(models).toHaveLength(2);
+        expect(models.map(m => m.name)).toContain('User');
+    });
+
+    it('extracts Sequelize models', () => {
+        setFileContent(`const Order = sequelize.define('Order', {});`);
+        const result = parseNodeFile('/backend/models/Order.js');
+        const model = result.entities.find(e => e.data.orm === 'sequelize');
+        expect(model).toBeDefined();
+        expect(model.name).toBe('Order');
+    });
+
+    it('extracts Firestore collection references', () => {
+        setFileContent(`
+db.collection('users').get();
+db.collection('products').where('active', '==', true);
+`);
+        const result = parseNodeFile('/backend/services/db.js');
+        const dbs = result.entities.filter(e => e.entityType === 'database');
+        expect(dbs).toHaveLength(2);
+        expect(dbs.map(d => d.data.collection)).toContain('users');
+    });
+
+    it('deduplicates Firestore collections referenced multiple times', () => {
+        setFileContent(`
+db.collection('users').get();
+db.collection('users').where('active', '==', true);
+`);
+        const result = parseNodeFile('/backend/services/userService.js');
+        const dbs = result.entities.filter(e => e.entityType === 'database');
+        expect(dbs).toHaveLength(1);
+    });
+
+    it('extracts class-based controllers', () => {
+        setFileContent(`
+class UserController {
+    async getUser(req, res) {}
+    async createUser(req, res) {}
+}
+`);
+        const result = parseNodeFile('/backend/controllers/userController.js');
+        const ctrl = result.entities.find(e => e.name === 'UserController');
+        expect(ctrl).toBeDefined();
+        expect(ctrl.entityType).toBe('controller');
+    });
+
+    it('extracts exported arrow functions from controller files', () => {
+        setFileContent(`
+export const getUser = async (req, res) => {
+    res.json({});
+};
+export const createUser = async (req, res) => {
+    res.json({});
+};
+`);
+        const result = parseNodeFile('/backend/controllers/userController.js');
+        const controllers = result.entities.filter(e => e.entityType === 'controller');
+        expect(controllers.length).toBeGreaterThanOrEqual(2);
+        expect(controllers.map(c => c.name)).toContain('getUser');
+    });
+
+    it('extracts mount points from app.use()', () => {
+        setFileContent(`
+app.use('/api/v1/users', userRoutes);
+app.use('/api/v1/orders', orderRoutes);
+`);
+        const result = parseNodeFile('/backend/app.js');
+        const mounts = result.entities.filter(e => e.entityType === 'mount');
+        expect(mounts).toHaveLength(2);
+        expect(mounts[0].data.prefix).toBe('/api/v1/users');
+    });
+
+    it('extracts custom middleware references (non-built-in)', () => {
+        setFileContent(`
+app.use(authMiddleware);
+app.use(rateLimiter);
+app.use(cors);
+`);
+        const result = parseNodeFile('/backend/app.js');
+        const mws = result.entities.filter(e => e.entityType === 'middleware');
+        // cors is in the built-in skip list; authMiddleware and rateLimiter should be extracted
+        const names = mws.map(m => m.name);
+        expect(names).toContain('authMiddleware');
+        expect(names).toContain('rateLimiter');
+        expect(names).not.toContain('cors');
+    });
+
+    it('returns empty entities for an empty file', () => {
+        setFileContent('');
+        const result = parseNodeFile('/backend/empty.js');
+        expect(result.entities).toHaveLength(0);
+    });
+
+    it('does not throw on unusual but valid JavaScript patterns', () => {
+        setFileContent(`
+const obj = { nested: { deep: true } };
+module.exports = obj;
+`);
+        expect(() => parseNodeFile('/backend/misc.js')).not.toThrow();
+    });
+
+    it('creates parent-class relations for classes that extend a base', () => {
+        setFileContent(`
+class AdminController extends BaseController {
+    async list(req, res) {}
+}
+`);
+        const result = parseNodeFile('/backend/controllers/adminController.js');
+        const rel = result.relations.find(r => r.relation === 'extends');
+        expect(rel).toBeDefined();
+        expect(rel.source).toBe('AdminController');
+        expect(rel.target).toBe('BaseController');
+    });
+});
+
+// ─── smartComment parser ──────────────────────────────────────
+
+describe('smartComment — parseSmartComments', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('extracts an @archsync:entity directive', () => {
+        setFileContent(`
+// @archsync:entity service AuthService
+function doSomething() {}
+`);
+        const result = parseSmartComments('/backend/auth.js');
+        expect(result.entities).toHaveLength(1);
+        expect(result.entities[0].name).toBe('AuthService');
+        expect(result.entities[0].entityType).toBe('service');
+    });
+
+    it('extracts an @archsync:api directive', () => {
+        setFileContent(`
+// @archsync:api POST /api/auth/login
+router.post('/login', loginHandler);
+`);
+        const result = parseSmartComments('/backend/routes/auth.js');
+        expect(result.entities).toHaveLength(1);
+        expect(result.entities[0].entityType).toBe('api');
+        expect(result.entities[0].data.method).toBe('POST');
+        expect(result.entities[0].data.path).toBe('/api/auth/login');
+    });
+
+    it('extracts a @archsync:model directive with a name', () => {
+        setFileContent(`
+// @archsync:model UserProfile
+class UserProfile {}
+`);
+        const result = parseSmartComments('/backend/models/userProfile.js');
+        expect(result.entities).toHaveLength(1);
+        expect(result.entities[0].entityType).toBe('model');
+        expect(result.entities[0].name).toBe('UserProfile');
+    });
+
+    it('extracts @archsync:relation directive', () => {
+        setFileContent(`
+// @archsync:relation AuthService -> UserModel queries
+`);
+        const result = parseSmartComments('/backend/auth.js');
+        expect(result.relations).toHaveLength(1);
+        expect(result.relations[0].source).toBe('AuthService');
+        expect(result.relations[0].target).toBe('UserModel');
+        expect(result.relations[0].relation).toBe('queries');
+    });
+
+    it('uses "uses" as default relation when none is specified', () => {
+        setFileContent(`
+// @archsync:relation ServiceA -> ServiceB
+`);
+        const result = parseSmartComments('/backend/foo.js');
+        expect(result.relations[0].relation).toBe('uses');
+    });
+
+    it('handles @archsync:system directive and applies it to subsequent entities', () => {
+        setFileContent(`
+// @archsync:system web
+// @archsync:entity screen LandingPage
+`);
+        const result = parseSmartComments('/web/landing.js');
+        expect(result.entities[0].system).toBe('web');
+    });
+
+    it('attaches @archsync:tag values to the current entity metadata', () => {
+        setFileContent(`
+// @archsync:entity service NotificationService
+// @archsync:tag notifications email push
+`);
+        const result = parseSmartComments('/backend/notif.js');
+        expect(result.entities[0].metadata.tags).toContain('notifications');
+        expect(result.entities[0].metadata.tags).toContain('email');
+        expect(result.entities[0].metadata.tags).toContain('push');
+    });
+
+    it('attaches @archsync:description to the current entity', () => {
+        setFileContent(`
+// @archsync:entity service PaymentService
+// @archsync:description Handles Stripe payments
+`);
+        const result = parseSmartComments('/backend/payment.js');
+        expect(result.entities[0].description).toBe('Handles Stripe payments');
+    });
+
+    it('returns empty entities and relations for @archsync:ignore', () => {
+        setFileContent(`
+// @archsync:ignore
+// @archsync:entity service ShouldNotAppear
+`);
+        const result = parseSmartComments('/backend/ignored.js');
+        expect(result.entities).toHaveLength(0);
+        expect(result.relations).toHaveLength(0);
+    });
+
+    it('returns empty results for an empty file', () => {
+        setFileContent('');
+        const result = parseSmartComments('/backend/empty.js');
+        expect(result.entities).toHaveLength(0);
+        expect(result.relations).toHaveLength(0);
+    });
+
+    it('ignores lines that are not @archsync comments', () => {
+        setFileContent(`
+// This is a regular comment
+const x = 1;
+/* Another comment */
+`);
+        const result = parseSmartComments('/backend/plain.js');
+        expect(result.entities).toHaveLength(0);
+    });
+
+    it('extracts multiple entities from a single file', () => {
+        setFileContent(`
+// @archsync:entity service UserService
+// @archsync:entity service OrderService
+// @archsync:entity model UserModel
+`);
+        const result = parseSmartComments('/backend/multi.js');
+        expect(result.entities).toHaveLength(3);
+    });
+
+    it('records the source line number in entity metadata', () => {
+        setFileContent(`
+// @archsync:entity service LineTracked
+`);
+        const result = parseSmartComments('/backend/lineno.js');
+        expect(result.entities[0].metadata.sourceLine).toBe(2);
+    });
+
+    it('extracts @archsync:api with default path "/" when path is missing', () => {
+        setFileContent(`
+// @archsync:api GET
+`);
+        const result = parseSmartComments('/backend/route.js');
+        expect(result.entities[0].data.path).toBe('/');
+    });
+
+    it('sets scope via @archsync:scope directive on current entity', () => {
+        setFileContent(`
+// @archsync:entity api PublicEndpoint
+// @archsync:scope public
+`);
+        const result = parseSmartComments('/backend/endpoints.js');
+        expect(result.entities[0].data.scope).toBe('public');
+    });
+});