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/trending.integration.test.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

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

585 lines
22 KiB
TypeScript

/**
* Trending API — Integration Tests
*
* Tests all public trending endpoints via supertest against the real Express
* app. Prisma is mocked by tests/setup.ts (applied globally via
* jest.config.js setupFilesAfterEnv). The `cache` object exported from
* redisService wraps the real redis client internally so it must also be
* mocked here — the global setup only stubs `redisClient` itself, not the
* higher-level cache wrapper that the trendingRankingService imports.
*/
// ─── Mock the cache layer BEFORE any module imports ─────────────────────────
// setup.ts mocks `redisClient` but trendingRankingService imports `cache`
// (a wrapper object) which closes over the real client. We override the whole
// redisService module so `cache.get` / `cache.set` never touch a real socket.
const mockCache = {
get: jest.fn().mockResolvedValue(null),
set: jest.fn().mockResolvedValue(undefined),
del: jest.fn().mockResolvedValue(undefined),
clear: jest.fn().mockResolvedValue(undefined),
};
const mockRedisClientFull = {
get: jest.fn().mockResolvedValue(null),
set: jest.fn().mockResolvedValue('OK'),
setEx: jest.fn().mockResolvedValue('OK'),
del: jest.fn().mockResolvedValue(1),
exists: jest.fn().mockResolvedValue(0),
expire: jest.fn().mockResolvedValue(1),
ttl: jest.fn().mockResolvedValue(-1),
keys: jest.fn().mockResolvedValue([]),
scan: jest.fn().mockResolvedValue({ cursor: 0, keys: [] }),
incr: jest.fn().mockResolvedValue(1),
decr: jest.fn().mockResolvedValue(0),
connect: jest.fn().mockResolvedValue(undefined),
disconnect: jest.fn().mockResolvedValue(undefined),
quit: jest.fn().mockResolvedValue(undefined),
on: jest.fn(),
isOpen: true,
isReady: true,
};
jest.mock('../src/services/redisService', () => ({
__esModule: true,
default: mockRedisClientFull,
redisClient: mockRedisClientFull,
connectRedis: jest.fn().mockResolvedValue(undefined),
getRedisClient: jest.fn().mockReturnValue(mockRedisClientFull),
cache: mockCache,
}));
import request from 'supertest';
import type { Express } from 'express';
import { createApp } from '../src/index';
import { mockPrisma } from './setup';
// ─── helpers ────────────────────────────────────────────────────────────────
function makeTrendingEntry(overrides: Partial<Record<string, unknown>> = {}) {
return {
id: `entry-${Math.random().toString(36).slice(2)}`,
entityType: 'POST',
entityId: `post-${Math.random().toString(36).slice(2)}`,
tier: 'TRENDING_TODAY',
score: 42.5,
rawScore: 50.0,
gamingPenalty: 0,
language: null,
topic: null,
rank: 1,
metadata: {},
periodStart: new Date(),
periodEnd: new Date(),
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
function makePost(overrides: Partial<Record<string, unknown>> = {}) {
return {
id: `post-${Math.random().toString(36).slice(2)}`,
content: 'Sample trending post',
type: 'POST',
status: 'PUBLISHED',
isArchived: false,
likesCount: 10,
commentsCount: 3,
sharesCount: 1,
viewsCount: 100,
userId: 'user-1',
accountId: 'account-1',
repositoryId: null,
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
function makeRepo(overrides: Partial<Record<string, unknown>> = {}) {
return {
id: `repo-${Math.random().toString(36).slice(2)}`,
fullName: 'owner/sample-repo',
owner: 'owner',
name: 'sample-repo',
language: 'TypeScript',
topics: ['typescript'],
stars: 120,
forks: 15,
description: 'A sample repository',
claimedBy: null,
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
function makeUser(overrides: Partial<Record<string, unknown>> = {}) {
return {
id: `user-${Math.random().toString(36).slice(2)}`,
username: 'trendingdev',
avatar: null,
bio: 'Developer',
verified: false,
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
function makeHashtag(overrides: Partial<Record<string, unknown>> = {}) {
return {
id: `tag-${Math.random().toString(36).slice(2)}`,
name: 'typescript',
count: 50,
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
// ─── test suite ─────────────────────────────────────────────────────────────
describe('Trending API Integration', () => {
let app: Express;
beforeAll(() => {
app = createApp();
});
afterAll(async () => {
// Mocked prisma — no real connection to close
await mockPrisma.$disconnect();
});
// ── GET /api/v1/trending/posts ───────────────────────────────────────────
describe('GET /api/v1/trending/posts', () => {
it('returns 200 with an array of posts in data.posts', async () => {
const postId = 'post-trending-1';
const entry = makeTrendingEntry({ entityType: 'POST', entityId: postId, rank: 1 });
const post = makePost({ id: postId });
mockPrisma.trendingEntry.__rows.push(entry);
mockPrisma.post.__rows.push(post);
const response = await request(app).get('/api/v1/trending/posts');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toBeDefined();
expect(Array.isArray(response.body.data.posts)).toBe(true);
});
it('returns 200 with empty posts array when no trending entries exist', async () => {
// Rows cleared by beforeEach in setup.ts via jest.clearAllMocks — rows
// are NOT cleared between tests, so we rely on fresh mocked findMany.
// Re-configure the findMany mock to return empty for this test.
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app).get('/api/v1/trending/posts');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.posts)).toBe(true);
});
it('accepts language query param and returns 200', async () => {
const postId = 'post-ts-1';
const entry = makeTrendingEntry({ entityType: 'POST', entityId: postId, language: 'TypeScript' });
const post = makePost({ id: postId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(1);
mockPrisma.post.findMany.mockResolvedValueOnce([post]);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ language: 'TypeScript' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.posts)).toBe(true);
});
it('rejects an invalid tier value with 400', async () => {
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'invalid_tier' });
expect(response.status).toBe(400);
});
it('accepts valid tier=hot and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'hot' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
});
it('accepts period=day via tier alias and returns 200', async () => {
// The validator accepts tier values: hot | today | week | rising.
// "period" is not a query param; the closest equivalent is tier=today.
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'today' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
// tier is reflected back in response data
expect(response.body.data.tier).toBe('TRENDING_TODAY');
});
it('respects limit and offset query params', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ limit: '5', offset: '0' });
expect(response.status).toBe(200);
});
});
// ── GET /api/v1/trending/repos ───────────────────────────────────────────
describe('GET /api/v1/trending/repos', () => {
it('returns 200 with an array in data.repos', async () => {
const repoId = 'repo-trending-1';
const entry = makeTrendingEntry({ entityType: 'REPOSITORY', entityId: repoId, rank: 1 });
const repo = makeRepo({ id: repoId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(1);
mockPrisma.repository.findMany.mockResolvedValueOnce([repo]);
const response = await request(app).get('/api/v1/trending/repos');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.repos)).toBe(true);
});
it('returns 200 with empty repos when no entries exist', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app).get('/api/v1/trending/repos');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.repos)).toBe(true);
expect(response.body.data.repos).toHaveLength(0);
});
it('accepts language filter and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/repos')
.query({ language: 'Go' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
});
it('includes hasMore and total in the response', async () => {
const repoId = 'repo-hm-1';
const entry = makeTrendingEntry({ entityType: 'REPOSITORY', entityId: repoId });
const repo = makeRepo({ id: repoId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(5);
mockPrisma.repository.findMany.mockResolvedValueOnce([repo]);
const response = await request(app)
.get('/api/v1/trending/repos')
.query({ limit: '1', offset: '0' });
expect(response.status).toBe(200);
expect(typeof response.body.data.total).toBe('number');
expect(typeof response.body.data.hasMore).toBe('boolean');
});
});
// ── GET /api/v1/trending/tags ────────────────────────────────────────────
describe('GET /api/v1/trending/tags', () => {
it('returns 200 with an array in data.tags', async () => {
const tag = makeHashtag({ id: 'tag-1' });
mockPrisma.postHashtag.groupBy.mockResolvedValueOnce([
{ hashtagId: tag.id, _count: { hashtagId: 12 } },
]);
mockPrisma.hashtag.findMany.mockResolvedValueOnce([tag]);
const response = await request(app).get('/api/v1/trending/tags');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.tags)).toBe(true);
});
it('returns 200 with empty tags array when no post hashtags exist', async () => {
mockPrisma.postHashtag.groupBy.mockResolvedValueOnce([]);
mockPrisma.hashtag.findMany.mockResolvedValueOnce([]);
const response = await request(app).get('/api/v1/trending/tags');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(response.body.data.tags).toHaveLength(0);
});
it('includes windowHours in the response', async () => {
mockPrisma.postHashtag.groupBy.mockResolvedValueOnce([]);
mockPrisma.hashtag.findMany.mockResolvedValueOnce([]);
const response = await request(app).get('/api/v1/trending/tags');
expect(response.status).toBe(200);
expect(typeof response.body.data.windowHours).toBe('number');
});
it('returns tag objects with id, name, totalCount, recentPostCount', async () => {
const tag = makeHashtag({ id: 'tag-shape-1', name: 'typescript', count: 99 });
mockPrisma.postHashtag.groupBy.mockResolvedValueOnce([
{ hashtagId: tag.id, _count: { hashtagId: 7 } },
]);
mockPrisma.hashtag.findMany.mockResolvedValueOnce([tag]);
const response = await request(app).get('/api/v1/trending/tags');
expect(response.status).toBe(200);
const first = response.body.data.tags[0];
expect(first).toHaveProperty('id');
expect(first).toHaveProperty('name');
expect(first).toHaveProperty('totalCount');
expect(first).toHaveProperty('recentPostCount');
});
});
// ── GET /api/v1/trending/users ───────────────────────────────────────────
describe('GET /api/v1/trending/users', () => {
it('returns 200 with an array in data.users', async () => {
const userId = 'user-trending-1';
const entry = makeTrendingEntry({ entityType: 'USER', entityId: userId, rank: 1 });
const user = makeUser({ id: userId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(1);
mockPrisma.user.findMany.mockResolvedValueOnce([user]);
const response = await request(app).get('/api/v1/trending/users');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.users)).toBe(true);
});
it('returns 200 with empty users when no trending user entries exist', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
mockPrisma.user.findMany.mockResolvedValueOnce([]);
const response = await request(app).get('/api/v1/trending/users');
expect(response.status).toBe(200);
expect(Array.isArray(response.body.data.users)).toBe(true);
expect(response.body.data.users).toHaveLength(0);
});
it('accepts tier=rising query param and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
mockPrisma.user.findMany.mockResolvedValueOnce([]);
const response = await request(app)
.get('/api/v1/trending/users')
.query({ tier: 'rising' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
});
it('includes tier and hasMore in the response', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
mockPrisma.user.findMany.mockResolvedValueOnce([]);
const response = await request(app).get('/api/v1/trending/users');
expect(response.status).toBe(200);
expect(response.body.data).toHaveProperty('tier');
expect(response.body.data).toHaveProperty('hasMore');
expect(response.body.data).toHaveProperty('total');
});
});
// ── GET /api/v1/trending/posts?language=TypeScript ───────────────────────
describe('GET /api/v1/trending/posts?language=TypeScript', () => {
it('passes language filter to the ranking query and returns 200', async () => {
const postId = 'post-ts-filter-1';
const entry = makeTrendingEntry({ entityType: 'POST', entityId: postId, language: 'TypeScript' });
const post = makePost({ id: postId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(1);
mockPrisma.post.findMany.mockResolvedValueOnce([post]);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ language: 'TypeScript' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(Array.isArray(response.body.data.posts)).toBe(true);
// Verify the trending entry query was called with the language filter
const findManyCallArgs = mockPrisma.trendingEntry.findMany.mock.calls;
const lastCall = findManyCallArgs[findManyCallArgs.length - 1]?.[0];
if (lastCall?.where) {
expect(lastCall.where.language).toBe('TypeScript');
}
});
it('rejects a language value exceeding 50 characters with 400', async () => {
const longLanguage = 'A'.repeat(51);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ language: longLanguage });
expect(response.status).toBe(400);
});
it('returns only posts with matching language when entries have language set', async () => {
const postId = 'post-rust-1';
const entry = makeTrendingEntry({ entityType: 'POST', entityId: postId, language: 'Rust' });
const post = makePost({ id: postId });
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([entry]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(1);
mockPrisma.post.findMany.mockResolvedValueOnce([post]);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ language: 'Rust' });
expect(response.status).toBe(200);
expect(Array.isArray(response.body.data.posts)).toBe(true);
});
});
// ── GET /api/v1/trending/posts?period=day ───────────────────────────────
describe('GET /api/v1/trending/posts?period=day (tier alias)', () => {
it('tier=today maps to TRENDING_TODAY and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'today' });
expect(response.status).toBe(200);
expect(response.body.data.tier).toBe('TRENDING_TODAY');
});
it('tier=week maps to THIS_WEEK and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'week' });
expect(response.status).toBe(200);
expect(response.body.data.tier).toBe('THIS_WEEK');
});
it('tier=hot maps to HOT_NOW and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'hot' });
expect(response.status).toBe(200);
expect(response.body.data.tier).toBe('HOT_NOW');
});
it('tier=rising maps to RISING_STARS and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'rising' });
expect(response.status).toBe(200);
expect(response.body.data.tier).toBe('RISING_STARS');
});
it('unknown tier value is rejected with 400', async () => {
const response = await request(app)
.get('/api/v1/trending/posts')
.query({ tier: 'day' });
// "day" is not in the allowed list so the validator returns 400
expect(response.status).toBe(400);
});
});
// ── GET /api/v1/trending (general endpoint) ──────────────────────────────
describe('GET /api/v1/trending', () => {
it('returns 200 with success flag and data', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app).get('/api/v1/trending');
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toBeDefined();
});
it('filters by type=post and returns 200', async () => {
mockPrisma.trendingEntry.findMany.mockResolvedValueOnce([]);
mockPrisma.trendingEntry.count.mockResolvedValueOnce(0);
const response = await request(app)
.get('/api/v1/trending')
.query({ type: 'post' });
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
});
it('rejects invalid type value with 400', async () => {
const response = await request(app)
.get('/api/v1/trending')
.query({ type: 'unknown_type' });
expect(response.status).toBe(400);
});
});
});