feat(#82): add prompt formatter service to personality module

- Add PromptFormatterService for formatting system prompts based on personality
- Support context variable interpolation (userName, workspaceName, etc.)
- Add formality level modifiers (VERY_CASUAL to VERY_FORMAL)
- Add template validation for custom variables
- Add preview endpoint for formatted prompts
- Fix UpdatePersonalityDto to avoid @nestjs/mapped-types dependency
- Update PersonalitiesController with new endpoints
- Add comprehensive tests (33 passing tests)

Closes #82
This commit is contained in:
Jason Woltje
2026-01-29 19:38:18 -06:00
parent 1cb54b56b0
commit 8383a98070
7 changed files with 374 additions and 99 deletions

View File

@@ -2,29 +2,24 @@ import { describe, it, expect, beforeEach, vi } from "vitest";
import { Test, TestingModule } from "@nestjs/testing";
import { PersonalitiesController } from "./personalities.controller";
import { PersonalitiesService } from "./personalities.service";
import { PromptFormatterService } from "./services/prompt-formatter.service";
import { AuthGuard } from "../auth/guards/auth.guard";
import { CreatePersonalityDto, UpdatePersonalityDto } from "./dto";
describe("PersonalitiesController", () => {
let controller: PersonalitiesController;
let service: PersonalitiesService;
let promptFormatter: PromptFormatterService;
const mockWorkspaceId = "workspace-123";
const mockUserId = "user-123";
const mockPersonalityId = "personality-123";
const mockRequest = {
user: { id: mockUserId },
workspaceId: mockWorkspaceId,
};
const mockRequest = { user: { id: "user-123" }, workspaceId: mockWorkspaceId };
const mockPersonality = {
id: mockPersonalityId,
workspaceId: mockWorkspaceId,
name: "Professional",
description: "Professional communication style",
tone: "professional",
formalityLevel: "FORMAL" as const,
formalityLevel: "FORMAL",
systemPromptTemplate: "You are a professional assistant.",
isDefault: true,
isActive: true,
@@ -41,105 +36,82 @@ describe("PersonalitiesController", () => {
remove: vi.fn(),
};
const mockAuthGuard = {
canActivate: vi.fn().mockReturnValue(true),
const mockPromptFormatterService = {
formatPrompt: vi.fn(),
getFormalityLevels: vi.fn(),
};
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
controllers: [PersonalitiesController],
providers: [
{
provide: PersonalitiesService,
useValue: mockPersonalitiesService,
},
{ provide: PersonalitiesService, useValue: mockPersonalitiesService },
{ provide: PromptFormatterService, useValue: mockPromptFormatterService },
],
})
.overrideGuard(AuthGuard)
.useValue(mockAuthGuard)
.useValue({ canActivate: () => true })
.compile();
controller = module.get<PersonalitiesController>(PersonalitiesController);
service = module.get<PersonalitiesService>(PersonalitiesService);
// Reset mocks
promptFormatter = module.get<PromptFormatterService>(PromptFormatterService);
vi.clearAllMocks();
});
describe("findAll", () => {
it("should return all personalities", async () => {
const mockPersonalities = [mockPersonality];
mockPersonalitiesService.findAll.mockResolvedValue(mockPersonalities);
const result = await controller.findAll(mockRequest as any);
expect(result).toEqual(mockPersonalities);
expect(service.findAll).toHaveBeenCalledWith(mockWorkspaceId, true);
});
it("should filter by active status", async () => {
mockPersonalitiesService.findAll.mockResolvedValue([mockPersonality]);
await controller.findAll(mockRequest as any, false);
expect(service.findAll).toHaveBeenCalledWith(mockWorkspaceId, false);
const result = await controller.findAll(mockRequest);
expect(result).toEqual([mockPersonality]);
expect(service.findAll).toHaveBeenCalledWith(mockWorkspaceId, undefined);
});
});
describe("findOne", () => {
it("should return a personality by id", async () => {
mockPersonalitiesService.findOne.mockResolvedValue(mockPersonality);
const result = await controller.findOne(mockRequest as any, mockPersonalityId);
const result = await controller.findOne(mockRequest, mockPersonalityId);
expect(result).toEqual(mockPersonality);
expect(service.findOne).toHaveBeenCalledWith(mockWorkspaceId, mockPersonalityId);
});
});
describe("findDefault", () => {
it("should return the default personality", async () => {
mockPersonalitiesService.findDefault.mockResolvedValue(mockPersonality);
const result = await controller.findDefault(mockRequest as any);
const result = await controller.findDefault(mockRequest);
expect(result).toEqual(mockPersonality);
expect(service.findDefault).toHaveBeenCalledWith(mockWorkspaceId);
});
});
describe("getFormalityLevels", () => {
it("should return formality levels", () => {
const levels = [{ level: "FORMAL", description: "Professional" }];
mockPromptFormatterService.getFormalityLevels.mockReturnValue(levels);
const result = controller.getFormalityLevels();
expect(result).toEqual(levels);
});
});
describe("create", () => {
const createDto: CreatePersonalityDto = {
name: "Casual",
description: "Casual communication style",
tone: "casual",
formalityLevel: "CASUAL",
systemPromptTemplate: "You are a casual assistant.",
};
it("should create a new personality", async () => {
const newPersonality = { ...mockPersonality, ...createDto, id: "new-id" };
mockPersonalitiesService.create.mockResolvedValue(newPersonality);
const result = await controller.create(mockRequest as any, createDto);
expect(result).toEqual(newPersonality);
const createDto = {
name: "Casual",
tone: "casual",
formalityLevel: "CASUAL" as const,
systemPromptTemplate: "You are a casual assistant.",
};
mockPersonalitiesService.create.mockResolvedValue({ ...mockPersonality, ...createDto });
await controller.create(mockRequest, createDto);
expect(service.create).toHaveBeenCalledWith(mockWorkspaceId, createDto);
});
});
describe("update", () => {
const updateDto: UpdatePersonalityDto = {
description: "Updated description",
};
it("should update a personality", async () => {
const updatedPersonality = { ...mockPersonality, ...updateDto };
mockPersonalitiesService.update.mockResolvedValue(updatedPersonality);
const result = await controller.update(mockRequest as any, mockPersonalityId, updateDto);
expect(result).toEqual(updatedPersonality);
const updateDto = { description: "Updated" };
mockPersonalitiesService.update.mockResolvedValue({ ...mockPersonality, ...updateDto });
await controller.update(mockRequest, mockPersonalityId, updateDto);
expect(service.update).toHaveBeenCalledWith(mockWorkspaceId, mockPersonalityId, updateDto);
});
});
@@ -147,11 +119,21 @@ describe("PersonalitiesController", () => {
describe("remove", () => {
it("should delete a personality", async () => {
mockPersonalitiesService.remove.mockResolvedValue(mockPersonality);
const result = await controller.remove(mockRequest as any, mockPersonalityId);
expect(result).toEqual(mockPersonality);
await controller.remove(mockRequest, mockPersonalityId);
expect(service.remove).toHaveBeenCalledWith(mockWorkspaceId, mockPersonalityId);
});
});
describe("previewPrompt", () => {
it("should return formatted system prompt", async () => {
const context = { userName: "John" };
mockPersonalitiesService.findOne.mockResolvedValue(mockPersonality);
mockPromptFormatterService.formatPrompt.mockReturnValue({
systemPrompt: "Formatted prompt",
metadata: {},
});
const result = await controller.previewPrompt(mockRequest, mockPersonalityId, context);
expect(result.systemPrompt).toBe("Formatted prompt");
});
});
});