1093 lines
34 KiB
JavaScript
1093 lines
34 KiB
JavaScript
/**
|
|
* Tests for FeedbackManager - Generic feedback operations for PRD/Epic crowdsourcing
|
|
*
|
|
* Tests cover:
|
|
* - Constants and type definitions
|
|
* - Feedback creation with proper label generation
|
|
* - Feedback querying with various filters
|
|
* - Grouping by section and type
|
|
* - Conflict detection
|
|
* - Status updates and issue closing
|
|
* - Statistics generation
|
|
*/
|
|
|
|
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
import {
|
|
FeedbackManager,
|
|
FEEDBACK_TYPES,
|
|
FEEDBACK_STATUS,
|
|
PRIORITY_LEVELS
|
|
} from '../../../src/modules/bmm/lib/crowdsource/feedback-manager.js';
|
|
|
|
// Create a testable subclass that allows injecting mock implementations
|
|
class TestableFeedbackManager extends FeedbackManager {
|
|
constructor(githubConfig, mocks = {}) {
|
|
super(githubConfig);
|
|
this.mocks = mocks;
|
|
}
|
|
|
|
async _createIssue(params) {
|
|
if (this.mocks.createIssue) {
|
|
return this.mocks.createIssue(params);
|
|
}
|
|
throw new Error('Mock not provided for _createIssue');
|
|
}
|
|
|
|
async _getIssue(issueNumber) {
|
|
if (this.mocks.getIssue) {
|
|
return this.mocks.getIssue(issueNumber);
|
|
}
|
|
throw new Error('Mock not provided for _getIssue');
|
|
}
|
|
|
|
async _updateIssue(issueNumber, updates) {
|
|
if (this.mocks.updateIssue) {
|
|
return this.mocks.updateIssue(issueNumber, updates);
|
|
}
|
|
throw new Error('Mock not provided for _updateIssue');
|
|
}
|
|
|
|
async _closeIssue(issueNumber, reason) {
|
|
if (this.mocks.closeIssue) {
|
|
return this.mocks.closeIssue(issueNumber, reason);
|
|
}
|
|
throw new Error('Mock not provided for _closeIssue');
|
|
}
|
|
|
|
async _addComment(issueNumber, body) {
|
|
if (this.mocks.addComment) {
|
|
return this.mocks.addComment(issueNumber, body);
|
|
}
|
|
throw new Error('Mock not provided for _addComment');
|
|
}
|
|
|
|
async _searchIssues(query) {
|
|
if (this.mocks.searchIssues) {
|
|
return this.mocks.searchIssues(query);
|
|
}
|
|
throw new Error('Mock not provided for _searchIssues');
|
|
}
|
|
}
|
|
|
|
describe('FeedbackManager', () => {
|
|
// ============ Constants Tests ============
|
|
|
|
describe('FEEDBACK_TYPES', () => {
|
|
it('should define all standard feedback types', () => {
|
|
const expectedTypes = [
|
|
'clarification',
|
|
'concern',
|
|
'suggestion',
|
|
'addition',
|
|
'priority'
|
|
];
|
|
|
|
for (const type of expectedTypes) {
|
|
expect(FEEDBACK_TYPES[type]).toBeDefined();
|
|
expect(FEEDBACK_TYPES[type].label).toMatch(/^feedback-type:/);
|
|
expect(FEEDBACK_TYPES[type].emoji).toBeTruthy();
|
|
expect(FEEDBACK_TYPES[type].description).toBeTruthy();
|
|
}
|
|
});
|
|
|
|
it('should define epic-specific feedback types', () => {
|
|
const epicTypes = ['scope', 'dependency', 'technical_risk', 'story_split'];
|
|
|
|
for (const type of epicTypes) {
|
|
expect(FEEDBACK_TYPES[type]).toBeDefined();
|
|
expect(FEEDBACK_TYPES[type].label).toMatch(/^feedback-type:/);
|
|
}
|
|
});
|
|
|
|
it('should have correct label formats', () => {
|
|
expect(FEEDBACK_TYPES.clarification.label).toBe('feedback-type:clarification');
|
|
expect(FEEDBACK_TYPES.concern.label).toBe('feedback-type:concern');
|
|
expect(FEEDBACK_TYPES.technical_risk.label).toBe('feedback-type:technical-risk');
|
|
expect(FEEDBACK_TYPES.story_split.label).toBe('feedback-type:story-split');
|
|
});
|
|
|
|
it('should have descriptive emojis for visual identification', () => {
|
|
expect(FEEDBACK_TYPES.clarification.emoji).toBe('📋');
|
|
expect(FEEDBACK_TYPES.concern.emoji).toBe('⚠️');
|
|
expect(FEEDBACK_TYPES.suggestion.emoji).toBe('💡');
|
|
expect(FEEDBACK_TYPES.scope.emoji).toBe('📐');
|
|
});
|
|
});
|
|
|
|
describe('FEEDBACK_STATUS', () => {
|
|
it('should define all status values', () => {
|
|
expect(FEEDBACK_STATUS.new).toBe('feedback-status:new');
|
|
expect(FEEDBACK_STATUS.reviewed).toBe('feedback-status:reviewed');
|
|
expect(FEEDBACK_STATUS.incorporated).toBe('feedback-status:incorporated');
|
|
expect(FEEDBACK_STATUS.deferred).toBe('feedback-status:deferred');
|
|
});
|
|
});
|
|
|
|
describe('PRIORITY_LEVELS', () => {
|
|
it('should define all priority levels', () => {
|
|
expect(PRIORITY_LEVELS.high).toBe('priority:high');
|
|
expect(PRIORITY_LEVELS.medium).toBe('priority:medium');
|
|
expect(PRIORITY_LEVELS.low).toBe('priority:low');
|
|
});
|
|
});
|
|
|
|
// ============ Constructor Tests ============
|
|
|
|
describe('constructor', () => {
|
|
it('should initialize with github config', () => {
|
|
const manager = new FeedbackManager({
|
|
owner: 'test-org',
|
|
repo: 'test-repo'
|
|
});
|
|
|
|
expect(manager.owner).toBe('test-org');
|
|
expect(manager.repo).toBe('test-repo');
|
|
});
|
|
});
|
|
|
|
// ============ createFeedback Tests ============
|
|
|
|
describe('createFeedback', () => {
|
|
let manager;
|
|
let mockCreateIssue;
|
|
let mockAddComment;
|
|
|
|
beforeEach(() => {
|
|
mockCreateIssue = vi.fn().mockResolvedValue({
|
|
number: 42,
|
|
html_url: 'https://github.com/test-org/test-repo/issues/42'
|
|
});
|
|
mockAddComment = vi.fn().mockResolvedValue({});
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ createIssue: mockCreateIssue, addComment: mockAddComment }
|
|
);
|
|
});
|
|
|
|
it('should create feedback with correct labels for PRD', async () => {
|
|
const result = await manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:user-auth',
|
|
documentType: 'prd',
|
|
section: 'User Stories',
|
|
feedbackType: 'clarification',
|
|
priority: 'high',
|
|
title: 'Unclear login flow',
|
|
content: 'The login flow description is ambiguous',
|
|
submittedBy: 'alice'
|
|
});
|
|
|
|
expect(mockCreateIssue).toHaveBeenCalledTimes(1);
|
|
const createCall = mockCreateIssue.mock.calls[0][0];
|
|
|
|
expect(createCall.title).toBe('📋 Feedback: Unclear login flow');
|
|
expect(createCall.labels).toContain('type:prd-feedback');
|
|
expect(createCall.labels).toContain('prd:user-auth');
|
|
expect(createCall.labels).toContain('linked-review:100');
|
|
expect(createCall.labels).toContain('feedback-section:user-stories');
|
|
expect(createCall.labels).toContain('feedback-type:clarification');
|
|
expect(createCall.labels).toContain('feedback-status:new');
|
|
expect(createCall.labels).toContain('priority:high');
|
|
|
|
expect(result.feedbackId).toBe(42);
|
|
expect(result.status).toBe('new');
|
|
});
|
|
|
|
it('should create feedback with correct labels for Epic', async () => {
|
|
const result = await manager.createFeedback({
|
|
reviewIssueNumber: 200,
|
|
documentKey: 'epic:2',
|
|
documentType: 'epic',
|
|
section: 'Story Breakdown',
|
|
feedbackType: 'scope',
|
|
priority: 'medium',
|
|
title: 'Epic too large',
|
|
content: 'Should be split into smaller epics',
|
|
submittedBy: 'bob'
|
|
});
|
|
|
|
const createCall = mockCreateIssue.mock.calls[0][0];
|
|
|
|
expect(createCall.title).toBe('📐 Feedback: Epic too large');
|
|
expect(createCall.labels).toContain('type:epic-feedback');
|
|
expect(createCall.labels).toContain('epic:2');
|
|
expect(createCall.labels).toContain('feedback-type:scope');
|
|
});
|
|
|
|
it('should add link comment to review issue', async () => {
|
|
await manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:user-auth',
|
|
documentType: 'prd',
|
|
section: 'User Stories',
|
|
feedbackType: 'concern',
|
|
priority: 'high',
|
|
title: 'Security risk',
|
|
content: 'Missing security consideration',
|
|
submittedBy: 'security-team'
|
|
});
|
|
|
|
expect(mockAddComment).toHaveBeenCalledTimes(1);
|
|
const commentCall = mockAddComment.mock.calls[0];
|
|
|
|
expect(commentCall[0]).toBe(100); // review issue number
|
|
expect(commentCall[1]).toContain('@security-team');
|
|
expect(commentCall[1]).toContain('Security risk');
|
|
expect(commentCall[1]).toContain('#42'); // feedback issue number
|
|
});
|
|
|
|
it('should include suggested change and rationale in body when provided', async () => {
|
|
await manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:payments',
|
|
documentType: 'prd',
|
|
section: 'FR-3',
|
|
feedbackType: 'suggestion',
|
|
priority: 'medium',
|
|
title: 'Better error handling',
|
|
content: 'Need better error messages',
|
|
suggestedChange: 'Add user-friendly error codes',
|
|
rationale: 'Improves debugging for support team',
|
|
submittedBy: 'dev-lead'
|
|
});
|
|
|
|
const createCall = mockCreateIssue.mock.calls[0][0];
|
|
|
|
expect(createCall.body).toContain('## Suggested Change');
|
|
expect(createCall.body).toContain('Add user-friendly error codes');
|
|
expect(createCall.body).toContain('## Context/Rationale');
|
|
expect(createCall.body).toContain('Improves debugging for support team');
|
|
});
|
|
|
|
it('should throw error for unknown feedback type', async () => {
|
|
await expect(manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
documentType: 'prd',
|
|
section: 'Test',
|
|
feedbackType: 'invalid-type',
|
|
priority: 'medium',
|
|
title: 'Test',
|
|
content: 'Test',
|
|
submittedBy: 'user'
|
|
})).rejects.toThrow('Unknown feedback type: invalid-type');
|
|
});
|
|
|
|
it('should default to medium priority when invalid priority provided', async () => {
|
|
await manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
documentType: 'prd',
|
|
section: 'Test',
|
|
feedbackType: 'clarification',
|
|
priority: 'invalid',
|
|
title: 'Test',
|
|
content: 'Test',
|
|
submittedBy: 'user'
|
|
});
|
|
|
|
const createCall = mockCreateIssue.mock.calls[0][0];
|
|
expect(createCall.labels).toContain('priority:medium');
|
|
});
|
|
|
|
it('should normalize section name for labels', async () => {
|
|
await manager.createFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
documentType: 'prd',
|
|
section: 'Non Functional Requirements',
|
|
feedbackType: 'clarification',
|
|
priority: 'low',
|
|
title: 'Test',
|
|
content: 'Test',
|
|
submittedBy: 'user'
|
|
});
|
|
|
|
const createCall = mockCreateIssue.mock.calls[0][0];
|
|
expect(createCall.labels).toContain('feedback-section:non-functional-requirements');
|
|
});
|
|
});
|
|
|
|
// ============ getFeedback Tests ============
|
|
|
|
describe('getFeedback', () => {
|
|
let manager;
|
|
let mockSearchIssues;
|
|
|
|
beforeEach(() => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'https://github.com/test/repo/issues/1',
|
|
title: '📋 Feedback: Test feedback',
|
|
labels: [
|
|
{ name: 'type:prd-feedback' },
|
|
{ name: 'prd:user-auth' },
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'alice' },
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
updated_at: '2026-01-02T00:00:00Z',
|
|
body: 'Test body'
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
});
|
|
|
|
it('should query feedback with document key filter', async () => {
|
|
await manager.getFeedback({
|
|
documentKey: 'prd:user-auth',
|
|
documentType: 'prd'
|
|
});
|
|
|
|
expect(mockSearchIssues).toHaveBeenCalledTimes(1);
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
|
|
expect(query).toContain('repo:test-org/test-repo');
|
|
expect(query).toContain('type:issue');
|
|
expect(query).toContain('is:open');
|
|
expect(query).toContain('label:type:prd-feedback');
|
|
expect(query).toContain('label:prd:user-auth');
|
|
});
|
|
|
|
it('should query feedback with review issue filter', async () => {
|
|
await manager.getFeedback({
|
|
reviewIssueNumber: 100,
|
|
documentType: 'prd'
|
|
});
|
|
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
expect(query).toContain('label:linked-review:100');
|
|
});
|
|
|
|
it('should query feedback with status filter', async () => {
|
|
await manager.getFeedback({
|
|
documentType: 'prd',
|
|
status: 'incorporated'
|
|
});
|
|
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
expect(query).toContain('label:feedback-status:incorporated');
|
|
});
|
|
|
|
it('should query feedback with section filter', async () => {
|
|
await manager.getFeedback({
|
|
documentType: 'epic',
|
|
section: 'Story Breakdown'
|
|
});
|
|
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
expect(query).toContain('label:feedback-section:story-breakdown');
|
|
});
|
|
|
|
it('should query feedback with type filter', async () => {
|
|
await manager.getFeedback({
|
|
documentType: 'prd',
|
|
feedbackType: 'concern'
|
|
});
|
|
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
expect(query).toContain('label:feedback-type:concern');
|
|
});
|
|
|
|
it('should parse feedback issues correctly', async () => {
|
|
const results = await manager.getFeedback({
|
|
documentType: 'prd',
|
|
documentKey: 'prd:user-auth'
|
|
});
|
|
|
|
expect(results).toHaveLength(1);
|
|
expect(results[0]).toMatchObject({
|
|
id: 1,
|
|
url: 'https://github.com/test/repo/issues/1',
|
|
title: 'Test feedback',
|
|
section: 'user-stories',
|
|
feedbackType: 'clarification',
|
|
status: 'new',
|
|
priority: 'high',
|
|
submittedBy: 'alice'
|
|
});
|
|
});
|
|
|
|
it('should handle document key with colon', async () => {
|
|
await manager.getFeedback({
|
|
documentKey: 'prd:complex-key',
|
|
documentType: 'prd'
|
|
});
|
|
|
|
const query = mockSearchIssues.mock.calls[0][0];
|
|
expect(query).toContain('label:prd:complex-key');
|
|
});
|
|
});
|
|
|
|
// ============ getFeedbackBySection Tests ============
|
|
|
|
describe('getFeedbackBySection', () => {
|
|
let manager;
|
|
let mockSearchIssues;
|
|
|
|
beforeEach(() => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '📋 Feedback: FB1',
|
|
labels: [
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'alice' },
|
|
created_at: '2026-01-01',
|
|
updated_at: '2026-01-01'
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '💡 Feedback: FB2',
|
|
labels: [
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:suggestion' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'bob' },
|
|
created_at: '2026-01-01',
|
|
updated_at: '2026-01-01'
|
|
},
|
|
{
|
|
number: 3,
|
|
html_url: 'url3',
|
|
title: '⚠️ Feedback: FB3',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-3' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'charlie' },
|
|
created_at: '2026-01-01',
|
|
updated_at: '2026-01-01'
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
});
|
|
|
|
it('should group feedback by section', async () => {
|
|
const bySection = await manager.getFeedbackBySection('prd:user-auth', 'prd');
|
|
|
|
expect(Object.keys(bySection)).toHaveLength(2);
|
|
expect(bySection['user-stories']).toHaveLength(2);
|
|
expect(bySection['fr-3']).toHaveLength(1);
|
|
});
|
|
|
|
it('should preserve feedback details in grouped results', async () => {
|
|
const bySection = await manager.getFeedbackBySection('prd:user-auth', 'prd');
|
|
|
|
expect(bySection['user-stories'][0].submittedBy).toBe('alice');
|
|
expect(bySection['user-stories'][1].submittedBy).toBe('bob');
|
|
});
|
|
});
|
|
|
|
// ============ getFeedbackByType Tests ============
|
|
|
|
describe('getFeedbackByType', () => {
|
|
let manager;
|
|
let mockSearchIssues;
|
|
|
|
beforeEach(() => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '📋 Feedback: FB1',
|
|
labels: [
|
|
{ name: 'feedback-section:test' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'alice' }
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '📋 Feedback: FB2',
|
|
labels: [
|
|
{ name: 'feedback-section:test2' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'bob' }
|
|
},
|
|
{
|
|
number: 3,
|
|
html_url: 'url3',
|
|
title: '⚠️ Feedback: FB3',
|
|
labels: [
|
|
{ name: 'feedback-section:test' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'charlie' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
});
|
|
|
|
it('should group feedback by type', async () => {
|
|
const byType = await manager.getFeedbackByType('prd:user-auth', 'prd');
|
|
|
|
expect(Object.keys(byType)).toHaveLength(2);
|
|
expect(byType['clarification']).toHaveLength(2);
|
|
expect(byType['concern']).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
// ============ detectConflicts Tests ============
|
|
|
|
describe('detectConflicts', () => {
|
|
let manager;
|
|
let mockSearchIssues;
|
|
|
|
it('should detect conflicts when multiple concerns on same section', async () => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '⚠️ Feedback: Timeout too short',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-5' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'security' }
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '⚠️ Feedback: Timeout too long',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-5' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'ux-team' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
|
|
const conflicts = await manager.detectConflicts('prd:user-auth', 'prd');
|
|
|
|
expect(conflicts).toHaveLength(1);
|
|
expect(conflicts[0].section).toBe('fr-5');
|
|
expect(conflicts[0].conflictType).toBe('multiple_opinions');
|
|
expect(conflicts[0].feedbackItems).toHaveLength(2);
|
|
});
|
|
|
|
it('should detect conflicts when concern and suggestion on same section', async () => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '⚠️ Feedback: Risk',
|
|
labels: [
|
|
{ name: 'feedback-section:security' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'security' }
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '💡 Feedback: Improvement',
|
|
labels: [
|
|
{ name: 'feedback-section:security' },
|
|
{ name: 'feedback-type:suggestion' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'dev' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
|
|
const conflicts = await manager.detectConflicts('prd:test', 'prd');
|
|
|
|
expect(conflicts).toHaveLength(1);
|
|
expect(conflicts[0].section).toBe('security');
|
|
});
|
|
|
|
it('should not detect conflicts for single feedback on section', async () => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '⚠️ Feedback: Single concern',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-1' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'user1' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
|
|
const conflicts = await manager.detectConflicts('prd:test', 'prd');
|
|
|
|
expect(conflicts).toHaveLength(0);
|
|
});
|
|
|
|
it('should not detect conflicts for multiple clarifications (not opposing)', async () => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '📋 Feedback: Question 1',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-1' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'user1' }
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '📋 Feedback: Question 2',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-1' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:low' }
|
|
],
|
|
user: { login: 'user2' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
|
|
const conflicts = await manager.detectConflicts('prd:test', 'prd');
|
|
|
|
expect(conflicts).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
// ============ updateFeedbackStatus Tests ============
|
|
|
|
describe('updateFeedbackStatus', () => {
|
|
let manager;
|
|
let mockGetIssue;
|
|
let mockUpdateIssue;
|
|
let mockAddComment;
|
|
let mockCloseIssue;
|
|
|
|
beforeEach(() => {
|
|
mockGetIssue = vi.fn().mockResolvedValue({
|
|
number: 42,
|
|
labels: [
|
|
{ name: 'type:prd-feedback' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
]
|
|
});
|
|
mockUpdateIssue = vi.fn().mockResolvedValue({});
|
|
mockAddComment = vi.fn().mockResolvedValue({});
|
|
mockCloseIssue = vi.fn().mockResolvedValue({});
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{
|
|
getIssue: mockGetIssue,
|
|
updateIssue: mockUpdateIssue,
|
|
addComment: mockAddComment,
|
|
closeIssue: mockCloseIssue
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should update status labels correctly', async () => {
|
|
await manager.updateFeedbackStatus(42, 'reviewed');
|
|
|
|
expect(mockUpdateIssue).toHaveBeenCalledTimes(1);
|
|
const updateCall = mockUpdateIssue.mock.calls[0];
|
|
|
|
expect(updateCall[0]).toBe(42);
|
|
expect(updateCall[1].labels).toContain('feedback-status:reviewed');
|
|
expect(updateCall[1].labels).not.toContain('feedback-status:new');
|
|
expect(updateCall[1].labels).toContain('type:prd-feedback');
|
|
expect(updateCall[1].labels).toContain('priority:high');
|
|
});
|
|
|
|
it('should add resolution comment when provided', async () => {
|
|
await manager.updateFeedbackStatus(42, 'incorporated', 'Added to PRD v2');
|
|
|
|
expect(mockAddComment).toHaveBeenCalledTimes(1);
|
|
expect(mockAddComment.mock.calls[0][0]).toBe(42);
|
|
expect(mockAddComment.mock.calls[0][1]).toContain('incorporated');
|
|
expect(mockAddComment.mock.calls[0][1]).toContain('Added to PRD v2');
|
|
});
|
|
|
|
it('should close issue when status is incorporated', async () => {
|
|
await manager.updateFeedbackStatus(42, 'incorporated');
|
|
|
|
expect(mockCloseIssue).toHaveBeenCalledTimes(1);
|
|
expect(mockCloseIssue.mock.calls[0][0]).toBe(42);
|
|
expect(mockCloseIssue.mock.calls[0][1]).toBe('completed');
|
|
});
|
|
|
|
it('should close issue when status is deferred', async () => {
|
|
await manager.updateFeedbackStatus(42, 'deferred');
|
|
|
|
expect(mockCloseIssue).toHaveBeenCalledTimes(1);
|
|
expect(mockCloseIssue.mock.calls[0][0]).toBe(42);
|
|
expect(mockCloseIssue.mock.calls[0][1]).toBe('not_planned');
|
|
});
|
|
|
|
it('should not close issue for reviewed status', async () => {
|
|
await manager.updateFeedbackStatus(42, 'reviewed');
|
|
|
|
expect(mockCloseIssue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should throw error for unknown status', async () => {
|
|
await expect(
|
|
manager.updateFeedbackStatus(42, 'invalid-status')
|
|
).rejects.toThrow('Unknown status: invalid-status');
|
|
});
|
|
|
|
it('should return updated status info', async () => {
|
|
const result = await manager.updateFeedbackStatus(42, 'reviewed');
|
|
|
|
expect(result).toEqual({
|
|
feedbackId: 42,
|
|
status: 'reviewed'
|
|
});
|
|
});
|
|
});
|
|
|
|
// ============ getStats Tests ============
|
|
|
|
describe('getStats', () => {
|
|
let manager;
|
|
let mockSearchIssues;
|
|
|
|
beforeEach(() => {
|
|
mockSearchIssues = vi.fn().mockResolvedValue([
|
|
{
|
|
number: 1,
|
|
html_url: 'url1',
|
|
title: '📋 Feedback: FB1',
|
|
labels: [
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'alice' }
|
|
},
|
|
{
|
|
number: 2,
|
|
html_url: 'url2',
|
|
title: '⚠️ Feedback: FB2',
|
|
labels: [
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:concern' },
|
|
{ name: 'feedback-status:reviewed' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'bob' }
|
|
},
|
|
{
|
|
number: 3,
|
|
html_url: 'url3',
|
|
title: '💡 Feedback: FB3',
|
|
labels: [
|
|
{ name: 'feedback-section:fr-3' },
|
|
{ name: 'feedback-type:suggestion' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:medium' }
|
|
],
|
|
user: { login: 'alice' }
|
|
}
|
|
]);
|
|
|
|
manager = new TestableFeedbackManager(
|
|
{ owner: 'test-org', repo: 'test-repo' },
|
|
{ searchIssues: mockSearchIssues }
|
|
);
|
|
});
|
|
|
|
it('should calculate total feedback count', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.total).toBe(3);
|
|
});
|
|
|
|
it('should group stats by type', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.byType).toEqual({
|
|
clarification: 1,
|
|
concern: 1,
|
|
suggestion: 1
|
|
});
|
|
});
|
|
|
|
it('should group stats by status', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.byStatus).toEqual({
|
|
new: 2,
|
|
reviewed: 1
|
|
});
|
|
});
|
|
|
|
it('should group stats by section', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.bySection).toEqual({
|
|
'user-stories': 2,
|
|
'fr-3': 1
|
|
});
|
|
});
|
|
|
|
it('should group stats by priority', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.byPriority).toEqual({
|
|
high: 2,
|
|
medium: 1
|
|
});
|
|
});
|
|
|
|
it('should count unique submitters', async () => {
|
|
const stats = await manager.getStats('prd:user-auth', 'prd');
|
|
|
|
expect(stats.submitterCount).toBe(2);
|
|
expect(stats.submitters).toContain('alice');
|
|
expect(stats.submitters).toContain('bob');
|
|
});
|
|
});
|
|
|
|
// ============ Private Method Tests ============
|
|
|
|
describe('_formatFeedbackBody', () => {
|
|
let manager;
|
|
|
|
beforeEach(() => {
|
|
manager = new FeedbackManager({ owner: 'test', repo: 'test' });
|
|
});
|
|
|
|
it('should format body with all required sections', () => {
|
|
const body = manager._formatFeedbackBody({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
section: 'User Stories',
|
|
feedbackType: 'clarification',
|
|
typeConfig: FEEDBACK_TYPES.clarification,
|
|
priority: 'high',
|
|
content: 'This is unclear',
|
|
submittedBy: 'alice'
|
|
});
|
|
|
|
expect(body).toContain('# 📋 Feedback: Clarification');
|
|
expect(body).toContain('**Review:** #100');
|
|
expect(body).toContain('**Document:** `prd:test`');
|
|
expect(body).toContain('**Section:** User Stories');
|
|
expect(body).toContain('**Priority:** high');
|
|
expect(body).toContain('## Feedback');
|
|
expect(body).toContain('This is unclear');
|
|
expect(body).toContain('@alice');
|
|
});
|
|
|
|
it('should include suggested change when provided', () => {
|
|
const body = manager._formatFeedbackBody({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
section: 'FR-1',
|
|
feedbackType: 'suggestion',
|
|
typeConfig: FEEDBACK_TYPES.suggestion,
|
|
priority: 'medium',
|
|
content: 'Could be improved',
|
|
suggestedChange: 'Use async/await pattern',
|
|
submittedBy: 'bob'
|
|
});
|
|
|
|
expect(body).toContain('## Suggested Change');
|
|
expect(body).toContain('Use async/await pattern');
|
|
});
|
|
|
|
it('should include rationale when provided', () => {
|
|
const body = manager._formatFeedbackBody({
|
|
reviewIssueNumber: 100,
|
|
documentKey: 'prd:test',
|
|
section: 'NFR-1',
|
|
feedbackType: 'concern',
|
|
typeConfig: FEEDBACK_TYPES.concern,
|
|
priority: 'high',
|
|
content: 'Security risk',
|
|
rationale: 'OWASP Top 10 vulnerability',
|
|
submittedBy: 'security'
|
|
});
|
|
|
|
expect(body).toContain('## Context/Rationale');
|
|
expect(body).toContain('OWASP Top 10 vulnerability');
|
|
});
|
|
});
|
|
|
|
describe('_parseFeedbackIssue', () => {
|
|
let manager;
|
|
|
|
beforeEach(() => {
|
|
manager = new FeedbackManager({ owner: 'test', repo: 'test' });
|
|
});
|
|
|
|
it('should parse issue into feedback object', () => {
|
|
const issue = {
|
|
number: 42,
|
|
html_url: 'https://github.com/test/repo/issues/42',
|
|
title: '📋 Feedback: Test feedback title',
|
|
labels: [
|
|
{ name: 'feedback-section:user-stories' },
|
|
{ name: 'feedback-type:clarification' },
|
|
{ name: 'feedback-status:new' },
|
|
{ name: 'priority:high' }
|
|
],
|
|
user: { login: 'alice' },
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
updated_at: '2026-01-02T00:00:00Z',
|
|
body: 'Test body content'
|
|
};
|
|
|
|
const parsed = manager._parseFeedbackIssue(issue);
|
|
|
|
expect(parsed).toEqual({
|
|
id: 42,
|
|
url: 'https://github.com/test/repo/issues/42',
|
|
title: 'Test feedback title',
|
|
section: 'user-stories',
|
|
feedbackType: 'clarification',
|
|
status: 'new',
|
|
priority: 'high',
|
|
submittedBy: 'alice',
|
|
createdAt: '2026-01-01T00:00:00Z',
|
|
updatedAt: '2026-01-02T00:00:00Z',
|
|
body: 'Test body content'
|
|
});
|
|
});
|
|
|
|
it('should strip emoji prefix from title', () => {
|
|
const issue = {
|
|
number: 1,
|
|
html_url: 'url',
|
|
title: '⚠️ Feedback: Important concern',
|
|
labels: [],
|
|
user: null
|
|
};
|
|
|
|
const parsed = manager._parseFeedbackIssue(issue);
|
|
expect(parsed.title).toBe('Important concern');
|
|
});
|
|
|
|
it('should handle missing labels gracefully', () => {
|
|
const issue = {
|
|
number: 1,
|
|
html_url: 'url',
|
|
title: 'Feedback: Missing labels',
|
|
labels: [],
|
|
user: { login: 'user' }
|
|
};
|
|
|
|
const parsed = manager._parseFeedbackIssue(issue);
|
|
|
|
expect(parsed.section).toBeNull();
|
|
expect(parsed.feedbackType).toBeNull();
|
|
expect(parsed.status).toBeNull();
|
|
expect(parsed.priority).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('_extractLabel', () => {
|
|
let manager;
|
|
|
|
beforeEach(() => {
|
|
manager = new FeedbackManager({ owner: 'test', repo: 'test' });
|
|
});
|
|
|
|
it('should extract value from label with prefix', () => {
|
|
const labels = ['type:prd-feedback', 'feedback-type:concern', 'priority:high'];
|
|
|
|
expect(manager._extractLabel(labels, 'feedback-type:')).toBe('concern');
|
|
expect(manager._extractLabel(labels, 'priority:')).toBe('high');
|
|
});
|
|
|
|
it('should return null when label not found', () => {
|
|
const labels = ['type:prd-feedback'];
|
|
|
|
expect(manager._extractLabel(labels, 'feedback-type:')).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ============ Error Handling Tests ============
|
|
|
|
describe('error handling', () => {
|
|
it('should throw when GitHub methods not implemented', async () => {
|
|
const manager = new FeedbackManager({ owner: 'test', repo: 'test' });
|
|
|
|
await expect(manager._createIssue({})).rejects.toThrow(
|
|
'_createIssue must be implemented by caller via GitHub MCP'
|
|
);
|
|
|
|
await expect(manager._getIssue(1)).rejects.toThrow(
|
|
'_getIssue must be implemented by caller via GitHub MCP'
|
|
);
|
|
|
|
await expect(manager._searchIssues('')).rejects.toThrow(
|
|
'_searchIssues must be implemented by caller via GitHub MCP'
|
|
);
|
|
});
|
|
});
|
|
});
|