This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/gitgram/backend/tests/unit/repoInsightsService.test.ts
caelum0x 54ca6de161 feat: round-4 product build-out (50 more gaps closed, all 7 green ~94-100%)
Second deep audit→build→verify pass; all products typecheck clean.

- gitgram-web (100): fix feed pagination, reel drafts, 6 gaps
- gitgram-backend (99): add admin/moderator role checks to moderation routes;
  wire backend-e2e CI (Postgres+Redis services); 5 gaps
- gitgram-mobile (97): fix broken create-reel flow; 11 gaps
- aitm-core (98): dedupe vendored CLI command registrations; real vector search
  with local fallback; 7 gaps
- aitm-api (99): replace hash-based embeddings with real OpenAI/Voyage embeddings
  (+ checkpoints test_status migration 0008); 8 gaps
- aitm-mcp (99): add X-API-Key to workspace tool proxy calls; 8 gaps
- aitm-website (94): fix annual billing checkout; 5 gaps

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 14:44:42 +03:00

488 lines
18 KiB
TypeScript

/**
* Unit tests for repoInsightsService
*
* All Prisma calls are intercepted by the in-memory mock in tests/setup.ts.
* We populate __rows on each model directly, then call the service functions
* and assert the returned shapes, aggregation logic, and empty-data fallbacks.
*/
import { mockPrisma } from '../setup';
// getLanguages first tries GitHub for byte-level language stats and only falls
// back to the stored primary language when that fails. Mock githubService so the
// fallback path is exercised deterministically and offline.
jest.mock('../../src/services/githubService', () => ({
githubService: {
getRepositoryLanguages: jest.fn().mockRejectedValue(new Error('offline in tests')),
},
}));
import {
resolveRepoId,
getPulse,
getContributors,
getTraffic,
getCommitActivity,
getCodeFrequency,
getLanguages,
} from '../../src/services/repoInsightsService';
const REPO_ID = 'repo-001';
const MS_PER_DAY = 24 * 60 * 60 * 1000;
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
function seedRow(model: any, row: Record<string, unknown>) {
model.__rows.push(row);
}
function clearAll() {
[
mockPrisma.repository,
mockPrisma.repositoryActivity,
mockPrisma.post,
mockPrisma.postView,
].forEach((m) => m.__rows.splice(0));
}
/** Returns a Date that is `n` days before now. */
function daysBack(n: number): Date {
return new Date(Date.now() - n * MS_PER_DAY);
}
function seedRepo(overrides: Record<string, unknown> = {}) {
seedRow(mockPrisma.repository, {
id: REPO_ID,
owner: 'octocat',
name: 'hello-world',
language: 'TypeScript',
...overrides,
});
}
function seedActivity(overrides: Record<string, unknown> = {}) {
seedRow(mockPrisma.repositoryActivity, {
id: `ra-${Math.random()}`,
repositoryId: REPO_ID,
eventType: 'PUSH',
action: null,
actorLogin: 'dev1',
actorAvatar: 'https://avatars.test/dev1.png',
occurredAt: daysBack(3),
metadata: { commits: [{}] },
...overrides,
});
}
// ---------------------------------------------------------------------------
// resolveRepoId
// ---------------------------------------------------------------------------
describe('resolveRepoId', () => {
beforeEach(clearAll);
it('returns null when the repository does not exist', async () => {
const result = await resolveRepoId('nobody', 'nonexistent');
expect(result).toBeNull();
});
it('returns an object with id and language when the repo exists', async () => {
seedRepo();
const result = await resolveRepoId('octocat', 'hello-world');
expect(result).not.toBeNull();
expect(result?.id).toBe(REPO_ID);
expect(result?.language).toBe('TypeScript');
});
it('returns language as null when the repo has no language set', async () => {
seedRepo({ language: null });
const result = await resolveRepoId('octocat', 'hello-world');
expect(result?.language).toBeNull();
});
});
// ---------------------------------------------------------------------------
// getPulse
// ---------------------------------------------------------------------------
describe('getPulse', () => {
beforeEach(clearAll);
it('returns all-zero counts when there is no activity', async () => {
const pulse = await getPulse(REPO_ID, 7);
expect(pulse.commits).toBe(0);
expect(pulse.prsMerged).toBe(0);
expect(pulse.prsOpened).toBe(0);
expect(pulse.issuesClosed).toBe(0);
expect(pulse.issuesOpened).toBe(0);
expect(pulse.activeContributors).toBe(0);
});
it('counts commits from PUSH events using commitCount in metadata', async () => {
seedActivity({ eventType: 'PUSH', metadata: { commitCount: 5 }, actorLogin: 'dev1' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.commits).toBe(5);
});
it('defaults to 1 commit per PUSH when metadata has no commit info', async () => {
seedActivity({ eventType: 'PUSH', metadata: {}, actorLogin: 'dev1' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.commits).toBe(1);
});
it('counts merged PRs', async () => {
seedActivity({ eventType: 'PULL_REQUEST', action: 'merged', actorLogin: 'dev2' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.prsMerged).toBe(1);
expect(pulse.prsOpened).toBe(0);
});
it('counts opened PRs (including reopened)', async () => {
seedActivity({ eventType: 'PULL_REQUEST', action: 'opened', actorLogin: 'dev2' });
seedActivity({ eventType: 'PULL_REQUEST', action: 'reopened', actorLogin: 'dev3' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.prsOpened).toBe(2);
});
it('counts closed and opened issues', async () => {
seedActivity({ eventType: 'ISSUES', action: 'closed', actorLogin: 'dev1' });
seedActivity({ eventType: 'ISSUES', action: 'opened', actorLogin: 'dev2' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.issuesClosed).toBe(1);
expect(pulse.issuesOpened).toBe(1);
});
it('counts distinct active contributors', async () => {
seedActivity({ eventType: 'PUSH', actorLogin: 'dev1' });
seedActivity({ eventType: 'PUSH', actorLogin: 'dev1' }); // duplicate — same person
seedActivity({ eventType: 'PULL_REQUEST', action: 'merged', actorLogin: 'dev2' });
const pulse = await getPulse(REPO_ID, 30);
expect(pulse.activeContributors).toBe(2);
});
it('clamps rangeDays between 1 and 365', async () => {
const tinyPulse = await getPulse(REPO_ID, -5);
expect(tinyPulse.rangeDays).toBe(1);
const hugePulse = await getPulse(REPO_ID, 9999);
expect(hugePulse.rangeDays).toBe(365);
});
it('excludes activity older than the requested range', async () => {
seedActivity({ eventType: 'PUSH', occurredAt: daysBack(60), actorLogin: 'dev1' });
const pulse = await getPulse(REPO_ID, 7);
expect(pulse.commits).toBe(0);
});
});
// ---------------------------------------------------------------------------
// getContributors
// ---------------------------------------------------------------------------
describe('getContributors', () => {
beforeEach(clearAll);
it('returns empty array when there is no activity', async () => {
const result = await getContributors(REPO_ID);
expect(result).toEqual([]);
});
it('returns one entry per distinct actor', async () => {
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}] } });
seedActivity({ actorLogin: 'dev2', eventType: 'PUSH', metadata: { commits: [{}] } });
const result = await getContributors(REPO_ID);
expect(result).toHaveLength(2);
});
it('aggregates totalCommits for a single contributor', async () => {
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}, {}, {}] } });
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}] } });
const result = await getContributors(REPO_ID);
expect(result[0].totalCommits).toBe(4);
});
it('aggregates additions and deletions from PR events', async () => {
seedActivity({
actorLogin: 'dev1',
eventType: 'PULL_REQUEST',
action: 'merged',
metadata: { additions: 100, deletions: 40 },
});
seedActivity({
actorLogin: 'dev1',
eventType: 'PULL_REQUEST',
action: 'merged',
metadata: { additions: 50, deletions: 10 },
});
const result = await getContributors(REPO_ID);
expect(result[0].totalAdditions).toBe(150);
expect(result[0].totalDeletions).toBe(50);
});
it('sorts contributors by totalCommits descending', async () => {
seedActivity({ actorLogin: 'light', eventType: 'PUSH', metadata: { commits: [{}] } });
seedActivity({ actorLogin: 'heavy', eventType: 'PUSH', metadata: { commits: [{}, {}, {}, {}, {}] } });
const result = await getContributors(REPO_ID);
expect(result[0].login).toBe('heavy');
expect(result[1].login).toBe('light');
});
it('series entries are sorted by week ascending', async () => {
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}] }, occurredAt: daysBack(20) });
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}] }, occurredAt: daysBack(5) });
const result = await getContributors(REPO_ID);
const series = result[0].series;
for (let i = 1; i < series.length; i++) {
expect(series[i].week >= series[i - 1].week).toBe(true);
}
});
it('each ContributorInsight has the required shape fields', async () => {
seedActivity({ actorLogin: 'dev1', eventType: 'PUSH', metadata: { commits: [{}] } });
const [contributor] = await getContributors(REPO_ID);
expect(contributor).toHaveProperty('login');
expect(contributor).toHaveProperty('avatarUrl');
expect(contributor).toHaveProperty('totalCommits');
expect(contributor).toHaveProperty('totalAdditions');
expect(contributor).toHaveProperty('totalDeletions');
expect(Array.isArray(contributor.series)).toBe(true);
});
});
// ---------------------------------------------------------------------------
// getTraffic
// ---------------------------------------------------------------------------
describe('getTraffic', () => {
beforeEach(clearAll);
it('returns all-zero traffic when the repo has no posts', async () => {
const result = await getTraffic(REPO_ID, '7d');
expect(result.totalViews).toBe(0);
expect(result.totalUniques).toBe(0);
expect(result.referrers).toEqual([]);
expect(result.paths).toEqual([]);
});
it('views array has one entry per day in the period', async () => {
const result = await getTraffic(REPO_ID, '7d');
expect(result.views).toHaveLength(7);
expect(result.uniques).toHaveLength(7);
});
it('counts views from postView rows linked to repo posts', async () => {
seedRow(mockPrisma.post, { id: 'post-a', repositoryId: REPO_ID, content: 'Hello World' });
seedRow(mockPrisma.postView, {
id: 'view-1',
postId: 'post-a',
viewedAt: daysBack(1),
ipHash: 'ip-aaa',
viewerId: null,
referrer: null,
});
seedRow(mockPrisma.postView, {
id: 'view-2',
postId: 'post-a',
viewedAt: daysBack(1),
ipHash: 'ip-bbb',
viewerId: null,
referrer: null,
});
const result = await getTraffic(REPO_ID, '14d');
expect(result.totalViews).toBe(2);
expect(result.totalUniques).toBe(2);
});
it('deduplicates uniques by viewerId or ipHash', async () => {
seedRow(mockPrisma.post, { id: 'post-b', repositoryId: REPO_ID, content: 'Dup test' });
const sharedIdentity = 'ip-same';
seedRow(mockPrisma.postView, { id: 'v1', postId: 'post-b', viewedAt: daysBack(2), ipHash: sharedIdentity, viewerId: null, referrer: null });
seedRow(mockPrisma.postView, { id: 'v2', postId: 'post-b', viewedAt: daysBack(2), ipHash: sharedIdentity, viewerId: null, referrer: null });
const result = await getTraffic(REPO_ID, '14d');
expect(result.totalViews).toBe(2);
expect(result.totalUniques).toBe(1); // same ip
});
it('aggregates referrers with count and uniques', async () => {
seedRow(mockPrisma.post, { id: 'post-c', repositoryId: REPO_ID, content: 'Ref test' });
seedRow(mockPrisma.postView, { id: 'v1', postId: 'post-c', viewedAt: daysBack(1), ipHash: 'ip-1', viewerId: null, referrer: 'https://google.com' });
seedRow(mockPrisma.postView, { id: 'v2', postId: 'post-c', viewedAt: daysBack(1), ipHash: 'ip-2', viewerId: null, referrer: 'https://google.com' });
seedRow(mockPrisma.postView, { id: 'v3', postId: 'post-c', viewedAt: daysBack(1), ipHash: 'ip-3', viewerId: null, referrer: 'https://twitter.com' });
const result = await getTraffic(REPO_ID, '14d');
const google = result.referrers.find((r) => r.referrer === 'https://google.com');
expect(google?.count).toBe(2);
expect(google?.uniques).toBe(2);
});
it('uses "14d" as default period for unknown period strings', async () => {
const result = await getTraffic(REPO_ID, 'unknown');
expect(result.views).toHaveLength(14);
});
});
// ---------------------------------------------------------------------------
// getCommitActivity
// ---------------------------------------------------------------------------
describe('getCommitActivity', () => {
beforeEach(clearAll);
it('returns empty weeks array when there are no PUSH events', async () => {
const result = await getCommitActivity(REPO_ID);
expect(result.weeks).toEqual([]);
});
it('each CommitActivityWeek has a days array of length 7', async () => {
seedActivity({ eventType: 'PUSH', occurredAt: daysBack(10), metadata: { commits: [{}] } });
const result = await getCommitActivity(REPO_ID);
for (const week of result.weeks) {
expect(week.days).toHaveLength(7);
}
});
it('totals per week match the sum of days', async () => {
seedActivity({ eventType: 'PUSH', occurredAt: daysBack(5), metadata: { commits: [{}, {}] } });
const result = await getCommitActivity(REPO_ID);
for (const week of result.weeks) {
const daySum = week.days.reduce((a, b) => a + b, 0);
expect(week.total).toBe(daySum);
}
});
it('weeks are ordered ascending by week start date', async () => {
seedActivity({ eventType: 'PUSH', occurredAt: daysBack(30), metadata: { commits: [{}] } });
seedActivity({ eventType: 'PUSH', occurredAt: daysBack(10), metadata: { commits: [{}] } });
const result = await getCommitActivity(REPO_ID);
for (let i = 1; i < result.weeks.length; i++) {
expect(result.weeks[i].week >= result.weeks[i - 1].week).toBe(true);
}
});
it('places commit count in correct day-of-week bucket', async () => {
// The service buckets by ISO week starting on Sunday (UTC) and indexes days
// by getUTCDay() (0 = Sunday, 1 = Monday). Build the Monday of the CURRENT
// week (the most recent Sunday + 1 day) at UTC noon so the push deterministically
// lands in the Monday slot of the last week regardless of when the test runs.
const now = new Date();
const sundayStart = new Date(
Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - now.getUTCDay()),
);
const monday = new Date(sundayStart.getTime() + MS_PER_DAY + 12 * 60 * 60 * 1000);
seedActivity({ eventType: 'PUSH', occurredAt: monday, metadata: { commits: [{}, {}, {}] } });
const result = await getCommitActivity(REPO_ID);
// Locate the week bucket whose start is this Sunday rather than assuming it is
// necessarily the array's last element.
const weekKey = sundayStart.toISOString().slice(0, 10);
const week = result.weeks.find((w) => w.week === weekKey);
expect(week).toBeDefined();
// day index 1 = Monday
expect(week!.days[1]).toBe(3);
});
});
// ---------------------------------------------------------------------------
// getCodeFrequency
// ---------------------------------------------------------------------------
describe('getCodeFrequency', () => {
beforeEach(clearAll);
it('returns empty weeks array when there are no PR events', async () => {
const result = await getCodeFrequency(REPO_ID);
expect(result.weeks).toEqual([]);
});
it('returns empty weeks when PRs have no addition/deletion metadata', async () => {
seedActivity({ eventType: 'PULL_REQUEST', action: 'merged', metadata: {} });
const result = await getCodeFrequency(REPO_ID);
expect(result.weeks).toEqual([]);
});
it('aggregates additions and deletions per week', async () => {
seedActivity({
eventType: 'PULL_REQUEST',
action: 'merged',
occurredAt: daysBack(5),
metadata: { additions: 200, deletions: 80 },
});
seedActivity({
eventType: 'PULL_REQUEST',
action: 'merged',
occurredAt: daysBack(5),
metadata: { additions: 50, deletions: 20 },
});
const result = await getCodeFrequency(REPO_ID);
// Both events fall in the same week
const week = result.weeks.find((w) => w.additions > 0);
expect(week?.additions).toBe(250);
expect(week?.deletions).toBe(100);
});
it('weeks are ordered ascending by week start date', async () => {
seedActivity({ eventType: 'PULL_REQUEST', occurredAt: daysBack(30), metadata: { additions: 10, deletions: 5 } });
seedActivity({ eventType: 'PULL_REQUEST', occurredAt: daysBack(10), metadata: { additions: 20, deletions: 8 } });
const result = await getCodeFrequency(REPO_ID);
for (let i = 1; i < result.weeks.length; i++) {
expect(result.weeks[i].week >= result.weeks[i - 1].week).toBe(true);
}
});
});
// ---------------------------------------------------------------------------
// getLanguages
// ---------------------------------------------------------------------------
describe('getLanguages', () => {
beforeEach(clearAll);
it('returns empty breakdown when the repository does not exist', async () => {
const result = await getLanguages('nonexistent-id');
expect(result.total).toBe(0);
expect(result.languages).toEqual([]);
});
it('returns empty breakdown when the repo has no language set', async () => {
seedRepo({ language: null });
const result = await getLanguages(REPO_ID);
expect(result.total).toBe(0);
expect(result.languages).toEqual([]);
});
it('returns the primary language at 100% when set', async () => {
seedRepo({ language: 'TypeScript' });
const result = await getLanguages(REPO_ID);
// GitHub byte data is unavailable in the fallback, so total bytes is 0 by
// design (no fabricated byte counts) while the single language is 100%.
expect(result.total).toBe(0);
expect(result.languages).toHaveLength(1);
expect(result.languages[0].name).toBe('TypeScript');
expect(result.languages[0].percentage).toBe(100);
});
it('assigns a known hex color for TypeScript', async () => {
seedRepo({ language: 'TypeScript' });
const result = await getLanguages(REPO_ID);
expect(result.languages[0].color).toBe('#3178c6');
});
it('falls back to a neutral grey for an unknown language', async () => {
seedRepo({ language: 'COBOL' });
const result = await getLanguages(REPO_ID);
expect(result.languages[0].color).toBe('#8b949e');
});
it('assigns the correct color for Python', async () => {
seedRepo({ language: 'Python' });
const result = await getLanguages(REPO_ID);
expect(result.languages[0].color).toBe('#3572A5');
});
});