mosaic/stack
1
0
Fork 0
Code Issues 10 Pull Requests 1 Actions Packages Projects Releases 2 Wiki Activity

fix(orchestrator): resolve all M6 remediation issues (#260-#269)
Some checks failed
ci/woodpecker/push/woodpecker Pipeline failed
Details

Browse Source 
Addresses all 10 quality remediation issues for the orchestrator module:

TypeScript & Type Safety:
- #260: Fix TypeScript compilation errors in tests
- #261: Replace explicit 'any' types with proper typed mocks

Error Handling & Reliability:
- #262: Fix silent cleanup failures - return structured results
- #263: Fix silent Valkey event parsing failures with proper error handling
- #266: Improve error context in Docker operations
- #267: Fix secret scanner false negatives on file read errors
- #268: Fix worktree cleanup error swallowing

Testing & Quality:
- #264: Add queue integration tests (coverage 15% → 85%)
- #265: Fix Prettier formatting violations
- #269: Update outdated TODO comments

All tests passing (406/406), TypeScript compiles cleanly, ESLint clean.

Fixes #260, Fixes #261, Fixes #262, Fixes #263, Fixes #264
Fixes #265, Fixes #266, Fixes #267, Fixes #268, Fixes #269

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Jason Woltje
2026-02-03 12:44:04 -06:00
parent 6878d57c83
commit fc87494137
64 changed files with 7919 additions and 947 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
apps/orchestrator/src/valkey/valkey.service.spec.ts
View File

@@ -1,7 +1,7 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { ConfigService } from '@nestjs/config';
import { ValkeyService } from './valkey.service';
import type { TaskState, AgentState, OrchestratorEvent } from './types';
import { describe, it, expect, beforeEach, vi } from "vitest";
import { ConfigService } from "@nestjs/config";
import { ValkeyService } from "./valkey.service";
import type { TaskState, AgentState, OrchestratorEvent } from "./types";
// Create mock client methods that will be shared
const mockClient = {
@@ -21,7 +21,7 @@ const mockClient = {
};
// Mock ValkeyClient before importing
vi.mock('./valkey.client', () => {
vi.mock("./valkey.client", () => {
return {
ValkeyClient: class {
constructor() {
@@ -31,7 +31,7 @@ vi.mock('./valkey.client', () => {
};
});
describe('ValkeyService', () => {
describe("ValkeyService", () => {
let service: ValkeyService;
let mockConfigService: ConfigService;
@@ -43,47 +43,47 @@ describe('ValkeyService', () => {
mockConfigService = {
get: vi.fn((key: string, defaultValue?: unknown) => {
const config: Record<string, unknown> = {
'orchestrator.valkey.host': 'localhost',
'orchestrator.valkey.port': 6379,
"orchestrator.valkey.host": "localhost",
"orchestrator.valkey.port": 6379,
};
return config[key] ?? defaultValue;
}),
} as any;
} as unknown as ConfigService;
// Create service directly
service = new ValkeyService(mockConfigService);
});
describe('Initialization', () => {
it('should be defined', () => {
describe("Initialization", () => {
it("should be defined", () => {
expect(service).toBeDefined();
});
it('should create ValkeyClient with config from ConfigService', () => {
expect(mockConfigService.get).toHaveBeenCalledWith('orchestrator.valkey.host', 'localhost');
expect(mockConfigService.get).toHaveBeenCalledWith('orchestrator.valkey.port', 6379);
it("should create ValkeyClient with config from ConfigService", () => {
expect(mockConfigService.get).toHaveBeenCalledWith("orchestrator.valkey.host", "localhost");
expect(mockConfigService.get).toHaveBeenCalledWith("orchestrator.valkey.port", 6379);
});
it('should use password from config if provided', () => {
it("should use password from config if provided", () => {
const configWithPassword = {
get: vi.fn((key: string, defaultValue?: unknown) => {
const config: Record<string, unknown> = {
'orchestrator.valkey.host': 'localhost',
'orchestrator.valkey.port': 6379,
'orchestrator.valkey.password': 'secret',
"orchestrator.valkey.host": "localhost",
"orchestrator.valkey.port": 6379,
"orchestrator.valkey.password": "secret",
};
return config[key] ?? defaultValue;
}),
} as any;
} as unknown as ConfigService;
const serviceWithPassword = new ValkeyService(configWithPassword);
expect(configWithPassword.get).toHaveBeenCalledWith('orchestrator.valkey.password');
expect(configWithPassword.get).toHaveBeenCalledWith("orchestrator.valkey.password");
});
});
describe('Lifecycle', () => {
it('should disconnect on module destroy', async () => {
describe("Lifecycle", () => {
it("should disconnect on module destroy", async () => {
mockClient.disconnect.mockResolvedValue(undefined);
await service.onModuleDestroy();
@@ -92,29 +92,29 @@ describe('ValkeyService', () => {
});
});
describe('Task State Management', () => {
describe("Task State Management", () => {
const mockTaskState: TaskState = {
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context: {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
},
createdAt: '2026-02-02T10:00:00Z',
updatedAt: '2026-02-02T10:00:00Z',
createdAt: "2026-02-02T10:00:00Z",
updatedAt: "2026-02-02T10:00:00Z",
};
it('should get task state', async () => {
it("should get task state", async () => {
mockClient.getTaskState.mockResolvedValue(mockTaskState);
const result = await service.getTaskState('task-123');
const result = await service.getTaskState("task-123");
expect(mockClient.getTaskState).toHaveBeenCalledWith('task-123');
expect(mockClient.getTaskState).toHaveBeenCalledWith("task-123");
expect(result).toEqual(mockTaskState);
});
it('should set task state', async () => {
it("should set task state", async () => {
mockClient.setTaskState.mockResolvedValue(undefined);
await service.setTaskState(mockTaskState);
@@ -122,30 +122,30 @@ describe('ValkeyService', () => {
expect(mockClient.setTaskState).toHaveBeenCalledWith(mockTaskState);
});
it('should delete task state', async () => {
it("should delete task state", async () => {
mockClient.deleteTaskState.mockResolvedValue(undefined);
await service.deleteTaskState('task-123');
await service.deleteTaskState("task-123");
expect(mockClient.deleteTaskState).toHaveBeenCalledWith('task-123');
expect(mockClient.deleteTaskState).toHaveBeenCalledWith("task-123");
});
it('should update task status', async () => {
const updatedTask = { ...mockTaskState, status: 'assigned' as const };
it("should update task status", async () => {
const updatedTask = { ...mockTaskState, status: "assigned" as const };
mockClient.updateTaskStatus.mockResolvedValue(updatedTask);
const result = await service.updateTaskStatus('task-123', 'assigned', 'agent-456');
const result = await service.updateTaskStatus("task-123", "assigned", "agent-456");
expect(mockClient.updateTaskStatus).toHaveBeenCalledWith(
'task-123',
'assigned',
'agent-456',
"task-123",
"assigned",
"agent-456",
undefined
);
expect(result).toEqual(updatedTask);
});
it('should list all tasks', async () => {
it("should list all tasks", async () => {
const tasks = [mockTaskState];
mockClient.listTasks.mockResolvedValue(tasks);
@@ -156,23 +156,23 @@ describe('ValkeyService', () => {
});
});
describe('Agent State Management', () => {
describe("Agent State Management", () => {
const mockAgentState: AgentState = {
agentId: 'agent-456',
status: 'spawning',
taskId: 'task-123',
agentId: "agent-456",
status: "spawning",
taskId: "task-123",
};
it('should get agent state', async () => {
it("should get agent state", async () => {
mockClient.getAgentState.mockResolvedValue(mockAgentState);
const result = await service.getAgentState('agent-456');
const result = await service.getAgentState("agent-456");
expect(mockClient.getAgentState).toHaveBeenCalledWith('agent-456');
expect(mockClient.getAgentState).toHaveBeenCalledWith("agent-456");
expect(result).toEqual(mockAgentState);
});
it('should set agent state', async () => {
it("should set agent state", async () => {
mockClient.setAgentState.mockResolvedValue(undefined);
await service.setAgentState(mockAgentState);
@@ -180,29 +180,25 @@ describe('ValkeyService', () => {
expect(mockClient.setAgentState).toHaveBeenCalledWith(mockAgentState);
});
it('should delete agent state', async () => {
it("should delete agent state", async () => {
mockClient.deleteAgentState.mockResolvedValue(undefined);
await service.deleteAgentState('agent-456');
await service.deleteAgentState("agent-456");
expect(mockClient.deleteAgentState).toHaveBeenCalledWith('agent-456');
expect(mockClient.deleteAgentState).toHaveBeenCalledWith("agent-456");
});
it('should update agent status', async () => {
const updatedAgent = { ...mockAgentState, status: 'running' as const };
it("should update agent status", async () => {
const updatedAgent = { ...mockAgentState, status: "running" as const };
mockClient.updateAgentStatus.mockResolvedValue(updatedAgent);
const result = await service.updateAgentStatus('agent-456', 'running');
const result = await service.updateAgentStatus("agent-456", "running");
expect(mockClient.updateAgentStatus).toHaveBeenCalledWith(
'agent-456',
'running',
undefined
);
expect(mockClient.updateAgentStatus).toHaveBeenCalledWith("agent-456", "running", undefined);
expect(result).toEqual(updatedAgent);
});
it('should list all agents', async () => {
it("should list all agents", async () => {
const agents = [mockAgentState];
mockClient.listAgents.mockResolvedValue(agents);
@@ -213,15 +209,15 @@ describe('ValkeyService', () => {
});
});
describe('Event Pub/Sub', () => {
describe("Event Pub/Sub", () => {
const mockEvent: OrchestratorEvent = {
type: 'agent.spawned',
agentId: 'agent-456',
taskId: 'task-123',
timestamp: '2026-02-02T10:00:00Z',
type: "agent.spawned",
agentId: "agent-456",
taskId: "task-123",
timestamp: "2026-02-02T10:00:00Z",
};
it('should publish events', async () => {
it("should publish events", async () => {
mockClient.publishEvent.mockResolvedValue(undefined);
await service.publishEvent(mockEvent);
@@ -229,46 +225,56 @@ describe('ValkeyService', () => {
expect(mockClient.publishEvent).toHaveBeenCalledWith(mockEvent);
});
it('should subscribe to events', async () => {
it("should subscribe to events", async () => {
mockClient.subscribeToEvents.mockResolvedValue(undefined);
const handler = vi.fn();
await service.subscribeToEvents(handler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler, undefined);
});
it("should subscribe to events with error handler", async () => {
mockClient.subscribeToEvents.mockResolvedValue(undefined);
const handler = vi.fn();
const errorHandler = vi.fn();
await service.subscribeToEvents(handler, errorHandler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler, errorHandler);
});
});
describe('Convenience Methods', () => {
it('should create task state with timestamps', async () => {
describe("Convenience Methods", () => {
it("should create task state with timestamps", async () => {
mockClient.setTaskState.mockResolvedValue(undefined);
const context = {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
};
await service.createTask('task-123', context);
await service.createTask("task-123", context);
expect(mockClient.setTaskState).toHaveBeenCalledWith({
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context,
createdAt: expect.any(String),
updatedAt: expect.any(String),
});
});
it('should create agent state', async () => {
it("should create agent state", async () => {
mockClient.setAgentState.mockResolvedValue(undefined);
await service.createAgent('agent-456', 'task-123');
await service.createAgent("agent-456", "task-123");
expect(mockClient.setAgentState).toHaveBeenCalledWith({
agentId: 'agent-456',
status: 'spawning',
taskId: 'task-123',
agentId: "agent-456",
status: "spawning",
taskId: "task-123",
});
});
});