Josep Piguillem
50d3ffd1dd
Plan sprints with dates and a goal, run one at a time per project, and put tickets in them from the ticket page. The Sprints tab follows the one under way with its progress and a burndown in tickets or points against the ideal line. Closing a sprint sends what was left to the next one or back to the backlog; the board can be filtered by sprint. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
247 lines
7.3 KiB
TypeScript
247 lines
7.3 KiB
TypeScript
import {
|
|
IssueReadModel,
|
|
IssueTimelineEntry,
|
|
ReleaseReadModel,
|
|
ReleaseStatus,
|
|
StatusCategory as C,
|
|
SprintReadModel,
|
|
SprintStatus,
|
|
} from '@task-stream/api/tracker/domain';
|
|
import {
|
|
computeProjectAnalytics,
|
|
computeReleaseBurnup,
|
|
computeSprintBurndown,
|
|
weekOf,
|
|
} from './analytics';
|
|
|
|
const ana = { id: 'ana', name: 'Ana' };
|
|
const bob = { id: 'bob', name: 'Bob' };
|
|
|
|
const issue = (
|
|
id: string,
|
|
createdAt: string,
|
|
status: string,
|
|
category: C,
|
|
releaseId: string | null = null,
|
|
): IssueReadModel =>
|
|
({
|
|
id,
|
|
key: id,
|
|
createdAt,
|
|
status,
|
|
statusCategory: category,
|
|
reporter: ana,
|
|
assignee: bob,
|
|
release: releaseId ? { id: releaseId, name: 'v1' } : null,
|
|
}) as IssueReadModel;
|
|
|
|
let seq = 0;
|
|
const step = (
|
|
issueId: string,
|
|
at: string,
|
|
status: string,
|
|
category: C,
|
|
assigneeId: string | null = 'bob',
|
|
): IssueTimelineEntry => ({
|
|
id: `${issueId}:${++seq}`,
|
|
issueId,
|
|
projectId: 'p',
|
|
at,
|
|
kind: 'status',
|
|
status,
|
|
category,
|
|
assigneeId,
|
|
});
|
|
|
|
/*
|
|
* A: created Mon 5 Oct, started Tue 6, to QA Wed 7, QA failed Thu 8, back to QA and done Fri 9.
|
|
* B: created Mon 5 Oct, started Mon 12, QA Tue 13, done Wed 14 (by Ana).
|
|
* C: created Tue 13 Oct, still in backlog.
|
|
*/
|
|
const issues = [
|
|
issue('A', '2026-10-05T09:00:00Z', 'DONE', C.DONE, 'rel'),
|
|
issue('B', '2026-10-05T10:00:00Z', 'DONE', C.DONE, 'rel'),
|
|
issue('C', '2026-10-13T10:00:00Z', 'BACKLOG', C.TODO),
|
|
];
|
|
const timeline: IssueTimelineEntry[] = [
|
|
step('A', '2026-10-05T09:00:00Z', 'BACKLOG', C.TODO),
|
|
{
|
|
id: 'A:r',
|
|
issueId: 'A',
|
|
projectId: 'p',
|
|
at: '2026-10-05T09:00:01Z',
|
|
kind: 'release',
|
|
releaseId: 'rel',
|
|
},
|
|
step('A', '2026-10-06T09:00:00Z', 'IN_PROGRESS', C.IN_PROGRESS),
|
|
step('A', '2026-10-07T09:00:00Z', 'IN_QA', C.QA),
|
|
step('A', '2026-10-08T09:00:00Z', 'QA_FAILED', C.IN_PROGRESS),
|
|
step('A', '2026-10-09T08:00:00Z', 'IN_QA', C.QA),
|
|
step('A', '2026-10-09T09:00:00Z', 'DONE', C.DONE),
|
|
step('B', '2026-10-05T10:00:00Z', 'BACKLOG', C.TODO),
|
|
{
|
|
id: 'B:r',
|
|
issueId: 'B',
|
|
projectId: 'p',
|
|
at: '2026-10-12T08:00:00Z',
|
|
kind: 'release',
|
|
releaseId: 'rel',
|
|
},
|
|
step('B', '2026-10-12T10:00:00Z', 'IN_PROGRESS', C.IN_PROGRESS),
|
|
step('B', '2026-10-13T10:00:00Z', 'IN_QA', C.QA),
|
|
step('B', '2026-10-14T10:00:00Z', 'DONE', C.DONE, 'ana'),
|
|
];
|
|
|
|
describe('project analytics', () => {
|
|
const stats = computeProjectAnalytics({
|
|
issues,
|
|
timeline,
|
|
statusOrder: ['BACKLOG', 'IN_PROGRESS', 'IN_QA', 'QA_FAILED', 'DONE'],
|
|
from: new Date('2026-10-05T00:00:00Z'),
|
|
to: new Date('2026-10-14T23:59:59Z'),
|
|
});
|
|
|
|
it('counts created and resolved tickets per week (Monday)', () => {
|
|
expect(weekOf(Date.parse('2026-10-11T12:00:00Z'))).toBe('2026-10-05');
|
|
expect(stats.createdVsResolved).toEqual([
|
|
{ week: '2026-10-05', created: 2, resolved: 1 },
|
|
{ week: '2026-10-12', created: 1, resolved: 1 },
|
|
]);
|
|
});
|
|
|
|
it('measures cycle time (start → done) and lead time (created → done)', () => {
|
|
// A: 3 days of cycle, 4 of lead. B: 2 and 9.
|
|
expect(stats.cycleTime).toEqual({ count: 2, averageDays: 2.5, p85Days: 3 });
|
|
expect(stats.leadTime).toEqual({ count: 2, averageDays: 6.5, p85Days: 9 });
|
|
});
|
|
|
|
it('counts QA passes and failures', () => {
|
|
expect(stats.qa).toEqual({ passed: 2, failed: 1, failureRate: 0.333 });
|
|
});
|
|
|
|
it('attributes throughput to who had the ticket', () => {
|
|
expect(stats.throughput).toEqual([
|
|
{ week: '2026-10-05', user: bob, count: 1 },
|
|
{ week: '2026-10-12', user: ana, count: 1 },
|
|
]);
|
|
});
|
|
|
|
it('builds the cumulative flow day by day, in the workflow order', () => {
|
|
const flow = stats.cumulativeFlow;
|
|
expect(flow.dates).toHaveLength(10);
|
|
expect(flow.series.map((s) => s.status)).toEqual([
|
|
'BACKLOG',
|
|
'IN_PROGRESS',
|
|
'IN_QA',
|
|
'QA_FAILED',
|
|
'DONE',
|
|
]);
|
|
const at = (status: string, day: string) =>
|
|
flow.series.find((s) => s.status === status)?.counts[
|
|
flow.dates.indexOf(day)
|
|
];
|
|
expect(at('BACKLOG', '2026-10-05')).toBe(2);
|
|
expect(at('QA_FAILED', '2026-10-08')).toBe(1);
|
|
expect(at('DONE', '2026-10-14')).toBe(2);
|
|
expect(at('BACKLOG', '2026-10-14')).toBe(1); // C
|
|
});
|
|
|
|
it('falls back to creation + current status for tickets without timeline', () => {
|
|
const old = computeProjectAnalytics({
|
|
issues: [issue('OLD', '2026-10-01T00:00:00Z', 'TODO', C.TODO)],
|
|
timeline: [],
|
|
statusOrder: [],
|
|
from: new Date('2026-10-01T00:00:00Z'),
|
|
to: new Date('2026-10-02T23:00:00Z'),
|
|
});
|
|
expect(old.cumulativeFlow.series).toEqual([
|
|
{ status: 'TODO', counts: [1, 1] },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('release burnup', () => {
|
|
it('tracks scope and done tickets of the release per day', () => {
|
|
const release = {
|
|
id: 'rel',
|
|
createdAt: '2026-10-05T08:00:00Z',
|
|
releasedAt: '2026-10-14T18:00:00Z',
|
|
targetDate: '2026-10-15',
|
|
status: ReleaseStatus.RELEASED,
|
|
} as ReleaseReadModel;
|
|
const burnup = computeReleaseBurnup({
|
|
release,
|
|
issues,
|
|
timeline,
|
|
now: new Date('2026-10-20T00:00:00Z'),
|
|
});
|
|
const at = (series: number[], day: string) =>
|
|
series[burnup.dates.indexOf(day)];
|
|
expect(burnup.dates[0]).toBe('2026-10-05');
|
|
expect(burnup.dates.at(-1)).toBe('2026-10-14');
|
|
expect(at(burnup.scope, '2026-10-05')).toBe(1); // A
|
|
expect(at(burnup.scope, '2026-10-12')).toBe(2); // + B
|
|
expect(at(burnup.done, '2026-10-09')).toBe(1);
|
|
expect(at(burnup.done, '2026-10-14')).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe('sprint burndown', () => {
|
|
const sprint = {
|
|
id: 's1',
|
|
projectId: 'p',
|
|
startDate: '2026-10-12',
|
|
endDate: '2026-10-16',
|
|
status: SprintStatus.ACTIVE,
|
|
closedAt: null,
|
|
} as SprintReadModel;
|
|
const into = (issueId: string, at: string): IssueTimelineEntry => ({
|
|
id: `${issueId}:${++seq}`,
|
|
issueId,
|
|
projectId: 'p',
|
|
at,
|
|
kind: 'sprint',
|
|
sprintId: 's1',
|
|
});
|
|
// X (3 points) and Y (5) committed on Monday; Z (2) added on Tuesday.
|
|
// X done on Tuesday, Y cancelled on Wednesday. Today is Wednesday noon.
|
|
const issues = [
|
|
{ ...issue('x', '2026-10-01T09:00:00Z', 'DONE', C.DONE), storyPoints: 3 },
|
|
{
|
|
...issue('y', '2026-10-01T09:00:00Z', 'CANCELLED', C.CANCELLED),
|
|
storyPoints: 5,
|
|
},
|
|
{ ...issue('z', '2026-10-01T09:00:00Z', 'TODO', C.TODO), storyPoints: 2 },
|
|
] as IssueReadModel[];
|
|
const timeline = [
|
|
step('x', '2026-10-01T09:00:00Z', 'TODO', C.TODO),
|
|
step('y', '2026-10-01T09:00:00Z', 'TODO', C.TODO),
|
|
step('z', '2026-10-01T09:00:00Z', 'TODO', C.TODO),
|
|
into('x', '2026-10-12T08:00:00Z'),
|
|
into('y', '2026-10-12T08:00:00Z'),
|
|
into('z', '2026-10-13T10:00:00Z'),
|
|
step('x', '2026-10-13T16:00:00Z', 'DONE', C.DONE),
|
|
step('y', '2026-10-14T09:00:00Z', 'CANCELLED', C.CANCELLED),
|
|
];
|
|
|
|
it('counts open tickets and points per day, and leaves the future blank', () => {
|
|
const burndown = computeSprintBurndown({
|
|
sprint,
|
|
issues,
|
|
timeline,
|
|
now: new Date('2026-10-14T12:00:00Z'),
|
|
});
|
|
expect(burndown.dates).toEqual([
|
|
'2026-10-12',
|
|
'2026-10-13',
|
|
'2026-10-14',
|
|
'2026-10-15',
|
|
'2026-10-16',
|
|
]);
|
|
expect(burndown.scope).toEqual([2, 3, 2, null, null]);
|
|
expect(burndown.remaining).toEqual([2, 2, 1, null, null]);
|
|
expect(burndown.remainingPoints).toEqual([8, 7, 2, null, null]);
|
|
expect(burndown.ideal).toEqual([2, 1.5, 1, 0.5, 0]);
|
|
});
|
|
});
|