ros/automaker
1
0
Fork 0
mirror of https://github.com/AutoMaker-Org/automaker.git synced 2026-02-02 20:43:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: update unit tests to use secureFs for file existence checks

Browse Source 
This commit modifies the unit tests in dev-server-service.test.ts to replace the usage of the native fs.existsSync method with secureFs.access for improved security and consistency in file handling. Key changes include:

- Updated all instances of existsSync to utilize secureFs.access, ensuring that file existence checks are performed using the secure file system operations.
- Adjusted mock implementations to reflect the new secureFs methods, enhancing the reliability of the tests.

These changes aim to align the testing strategy with the recent refactor for enhanced security in file operations.
This commit is contained in:
Test User
2025-12-21 01:40:41 -05:00
parent 077a63b03b
commit ab65d46d08
1 changed files with 119 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

289
apps/server/tests/unit/services/dev-server-service.test.ts
View File

@@ -1,37 +1,33 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { EventEmitter } from "events"; import { EventEmitter } from 'events';
import path from "path"; import path from 'path';
import os from "os"; import os from 'os';
import fs from "fs/promises"; import fs from 'fs/promises';
// Mock child_process // Mock child_process
vi.mock("child_process", () => ({ vi.mock('child_process', () => ({
spawn: vi.fn(), spawn: vi.fn(),
execSync: vi.fn(), execSync: vi.fn(),
})); }));
// Mock fs existsSync // Mock secure-fs
vi.mock("fs", async (importOriginal) => { vi.mock('@/lib/secure-fs.js', () => ({
const actual = await importOriginal<typeof import("fs")>(); access: vi.fn(),
return { }));
...actual,
existsSync: vi.fn(),
};
});
// Mock net // Mock net
vi.mock("net", () => ({ vi.mock('net', () => ({
default: { default: {
createServer: vi.fn(), createServer: vi.fn(),
}, },
createServer: vi.fn(), createServer: vi.fn(),
})); }));
import { spawn, execSync } from "child_process"; import { spawn, execSync } from 'child_process';
import { existsSync } from "fs"; import * as secureFs from '@/lib/secure-fs.js';
import net from "net"; import net from 'net';
describe("dev-server-service.ts", () => { describe('dev-server-service.ts', () => {
let testDir: string; let testDir: string;
beforeEach(async () => { beforeEach(async () => {
@@ -41,20 +37,20 @@ describe("dev-server-service.ts", () => {
testDir = path.join(os.tmpdir(), `dev-server-test-${Date.now()}`); testDir = path.join(os.tmpdir(), `dev-server-test-${Date.now()}`);
await fs.mkdir(testDir, { recursive: true }); await fs.mkdir(testDir, { recursive: true });
// Default mock for existsSync - return true // Default mock for secureFs.access - return resolved (file exists)
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
// Default mock for net.createServer - port available // Default mock for net.createServer - port available
const mockServer = new EventEmitter() as any; const mockServer = new EventEmitter() as any;
mockServer.listen = vi.fn().mockImplementation((port: number, host: string) => { mockServer.listen = vi.fn().mockImplementation((port: number, host: string) => {
process.nextTick(() => mockServer.emit("listening")); process.nextTick(() => mockServer.emit('listening'));
}); });
mockServer.close = vi.fn(); mockServer.close = vi.fn();
vi.mocked(net.createServer).mockReturnValue(mockServer); vi.mocked(net.createServer).mockReturnValue(mockServer);
// Default mock for execSync - no process on port // Default mock for execSync - no process on port
vi.mocked(execSync).mockImplementation(() => { vi.mocked(execSync).mockImplementation(() => {
throw new Error("No process found"); throw new Error('No process found');
}); });
}); });
@@ -66,11 +62,9 @@ describe("dev-server-service.ts", () => {
} }
}); });
describe("getDevServerService", () => { describe('getDevServerService', () => {
it("should return a singleton instance", async () => { it('should return a singleton instance', async () => {
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const instance1 = getDevServerService(); const instance1 = getDevServerService();
const instance2 = getDevServerService(); const instance2 = getDevServerService();
@@ -79,148 +73,125 @@ describe("dev-server-service.ts", () => {
}); });
}); });
describe("startDevServer", () => { describe('startDevServer', () => {
it("should return error if worktree path does not exist", async () => { it('should return error if worktree path does not exist', async () => {
vi.mocked(existsSync).mockReturnValue(false); vi.mocked(secureFs.access).mockRejectedValueOnce(new Error('File not found'));
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
const result = await service.startDevServer( const result = await service.startDevServer('/project', '/nonexistent/worktree');
"/project",
"/nonexistent/worktree"
);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toContain("does not exist"); expect(result.error).toContain('does not exist');
}); });
it("should return error if no package.json found", async () => { it('should return error if no package.json found', async () => {
vi.mocked(existsSync).mockImplementation((p: any) => { vi.mocked(secureFs.access).mockImplementation(async (p: any) => {
if (p.includes("package.json")) return false; if (typeof p === 'string' && p.includes('package.json')) {
return true; throw new Error('File not found');
}
return undefined;
}); });
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
const result = await service.startDevServer(testDir, testDir); const result = await service.startDevServer(testDir, testDir);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toContain("No package.json found"); expect(result.error).toContain('No package.json found');
}); });
it("should detect npm as package manager with package-lock.json", async () => { it('should detect npm as package manager with package-lock.json', async () => {
vi.mocked(existsSync).mockImplementation((p: any) => { vi.mocked(secureFs.access).mockImplementation(async (p: any) => {
if (p.includes("bun.lockb")) return false; const pathStr = typeof p === 'string' ? p : '';
if (p.includes("pnpm-lock.yaml")) return false; if (pathStr.includes('bun.lockb')) throw new Error('Not found');
if (p.includes("yarn.lock")) return false; if (pathStr.includes('pnpm-lock.yaml')) throw new Error('Not found');
if (p.includes("package-lock.json")) return true; if (pathStr.includes('yarn.lock')) throw new Error('Not found');
if (p.includes("package.json")) return true; if (pathStr.includes('package-lock.json')) return undefined;
return true; if (pathStr.includes('package.json')) return undefined;
return undefined;
}); });
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
expect(spawn).toHaveBeenCalledWith( expect(spawn).toHaveBeenCalledWith('npm', ['run', 'dev'], expect.any(Object));
"npm",
["run", "dev"],
expect.any(Object)
);
}); });
it("should detect yarn as package manager with yarn.lock", async () => { it('should detect yarn as package manager with yarn.lock', async () => {
vi.mocked(existsSync).mockImplementation((p: any) => { vi.mocked(secureFs.access).mockImplementation(async (p: any) => {
if (p.includes("bun.lockb")) return false; const pathStr = typeof p === 'string' ? p : '';
if (p.includes("pnpm-lock.yaml")) return false; if (pathStr.includes('bun.lockb')) throw new Error('Not found');
if (p.includes("yarn.lock")) return true; if (pathStr.includes('pnpm-lock.yaml')) throw new Error('Not found');
if (p.includes("package.json")) return true; if (pathStr.includes('yarn.lock')) return undefined;
return true; if (pathStr.includes('package.json')) return undefined;
return undefined;
}); });
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
expect(spawn).toHaveBeenCalledWith("yarn", ["dev"], expect.any(Object)); expect(spawn).toHaveBeenCalledWith('yarn', ['dev'], expect.any(Object));
}); });
it("should detect pnpm as package manager with pnpm-lock.yaml", async () => { it('should detect pnpm as package manager with pnpm-lock.yaml', async () => {
vi.mocked(existsSync).mockImplementation((p: any) => { vi.mocked(secureFs.access).mockImplementation(async (p: any) => {
if (p.includes("bun.lockb")) return false; const pathStr = typeof p === 'string' ? p : '';
if (p.includes("pnpm-lock.yaml")) return true; if (pathStr.includes('bun.lockb')) throw new Error('Not found');
if (p.includes("package.json")) return true; if (pathStr.includes('pnpm-lock.yaml')) return undefined;
return true; if (pathStr.includes('package.json')) return undefined;
return undefined;
}); });
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
expect(spawn).toHaveBeenCalledWith( expect(spawn).toHaveBeenCalledWith('pnpm', ['run', 'dev'], expect.any(Object));
"pnpm",
["run", "dev"],
expect.any(Object)
);
}); });
it("should detect bun as package manager with bun.lockb", async () => { it('should detect bun as package manager with bun.lockb', async () => {
vi.mocked(existsSync).mockImplementation((p: any) => { vi.mocked(secureFs.access).mockImplementation(async (p: any) => {
if (p.includes("bun.lockb")) return true; const pathStr = typeof p === 'string' ? p : '';
if (p.includes("package.json")) return true; if (pathStr.includes('bun.lockb')) return undefined;
return true; if (pathStr.includes('package.json')) return undefined;
return undefined;
}); });
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
expect(spawn).toHaveBeenCalledWith( expect(spawn).toHaveBeenCalledWith('bun', ['run', 'dev'], expect.any(Object));
"bun",
["run", "dev"],
expect.any(Object)
);
}); });
it("should return existing server info if already running", async () => { it('should return existing server info if already running', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
// Start first server // Start first server
@@ -230,18 +201,16 @@ describe("dev-server-service.ts", () => {
// Try to start again - should return existing // Try to start again - should return existing
const result2 = await service.startDevServer(testDir, testDir); const result2 = await service.startDevServer(testDir, testDir);
expect(result2.success).toBe(true); expect(result2.success).toBe(true);
expect(result2.result?.message).toContain("already running"); expect(result2.result?.message).toContain('already running');
}); });
it("should start dev server successfully", async () => { it('should start dev server successfully', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
const result = await service.startDevServer(testDir, testDir); const result = await service.startDevServer(testDir, testDir);
@@ -249,32 +218,28 @@ describe("dev-server-service.ts", () => {
expect(result.success).toBe(true); expect(result.success).toBe(true);
expect(result.result).toBeDefined(); expect(result.result).toBeDefined();
expect(result.result?.port).toBeGreaterThanOrEqual(3001); expect(result.result?.port).toBeGreaterThanOrEqual(3001);
expect(result.result?.url).toContain("http://localhost:"); expect(result.result?.url).toContain('http://localhost:');
}); });
}); });
describe("stopDevServer", () => { describe('stopDevServer', () => {
it("should return success if server not found", async () => { it('should return success if server not found', async () => {
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
const result = await service.stopDevServer("/nonexistent/path"); const result = await service.stopDevServer('/nonexistent/path');
expect(result.success).toBe(true); expect(result.success).toBe(true);
expect(result.result?.message).toContain("already stopped"); expect(result.result?.message).toContain('already stopped');
}); });
it("should stop a running server", async () => { it('should stop a running server', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
// Start server // Start server
@@ -284,15 +249,13 @@ describe("dev-server-service.ts", () => {
const result = await service.stopDevServer(testDir); const result = await service.stopDevServer(testDir);
expect(result.success).toBe(true); expect(result.success).toBe(true);
expect(mockProcess.kill).toHaveBeenCalledWith("SIGTERM"); expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
}); });
}); });
describe("listDevServers", () => { describe('listDevServers', () => {
it("should return empty list when no servers running", async () => { it('should return empty list when no servers running', async () => {
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
const result = service.listDevServers(); const result = service.listDevServers();
@@ -301,15 +264,13 @@ describe("dev-server-service.ts", () => {
expect(result.result.servers).toEqual([]); expect(result.result.servers).toEqual([]);
}); });
it("should list running servers", async () => { it('should list running servers', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
@@ -322,25 +283,21 @@ describe("dev-server-service.ts", () => {
}); });
}); });
describe("isRunning", () => { describe('isRunning', () => {
it("should return false for non-running server", async () => { it('should return false for non-running server', async () => {
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
expect(service.isRunning("/some/path")).toBe(false); expect(service.isRunning('/some/path')).toBe(false);
}); });
it("should return true for running server", async () => { it('should return true for running server', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
@@ -349,25 +306,21 @@ describe("dev-server-service.ts", () => {
}); });
}); });
describe("getServerInfo", () => { describe('getServerInfo', () => {
it("should return undefined for non-running server", async () => { it('should return undefined for non-running server', async () => {
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
expect(service.getServerInfo("/some/path")).toBeUndefined(); expect(service.getServerInfo('/some/path')).toBeUndefined();
}); });
it("should return info for running server", async () => { it('should return info for running server', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
@@ -379,16 +332,14 @@ describe("dev-server-service.ts", () => {
}); });
}); });
describe("getAllocatedPorts", () => { describe('getAllocatedPorts', () => {
it("should return allocated ports", async () => { it('should return allocated ports', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);
@@ -399,16 +350,14 @@ describe("dev-server-service.ts", () => {
}); });
}); });
describe("stopAll", () => { describe('stopAll', () => {
it("should stop all running servers", async () => { it('should stop all running servers', async () => {
vi.mocked(existsSync).mockReturnValue(true); vi.mocked(secureFs.access).mockResolvedValue(undefined);
const mockProcess = createMockProcess(); const mockProcess = createMockProcess();
vi.mocked(spawn).mockReturnValue(mockProcess as any); vi.mocked(spawn).mockReturnValue(mockProcess as any);
const { getDevServerService } = await import( const { getDevServerService } = await import('@/services/dev-server-service.js');
"@/services/dev-server-service.js"
);
const service = getDevServerService(); const service = getDevServerService();
await service.startDevServer(testDir, testDir); await service.startDevServer(testDir, testDir);