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/socialGraphService.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

1265 lines
43 KiB
TypeScript

/**
* Unit tests for socialGraphService and blockService
*
* Dependencies (Prisma, Redis cache, Octokit) are all mocked so these tests
* run entirely in-memory without any network or database connections.
*/
import { mockPrisma } from '../setup';
// ---------------------------------------------------------------------------
// Module-level mocks — declared before any imports that trigger the module
// ---------------------------------------------------------------------------
const mockCacheGet = jest.fn().mockResolvedValue(null);
const mockCacheSet = jest.fn().mockResolvedValue(undefined);
jest.mock('../../src/services/redisService', () => ({
__esModule: true,
default: {},
connectRedis: jest.fn(),
cache: {
get: mockCacheGet,
set: mockCacheSet,
del: jest.fn().mockResolvedValue(undefined),
},
}));
const mockListFollowers = jest.fn();
jest.mock('@octokit/rest', () => ({
Octokit: jest.fn().mockImplementation(() => ({
users: {
listFollowersForAuthenticatedUser: mockListFollowers,
},
})),
}));
// ---------------------------------------------------------------------------
// Service under test — imported after mocks are registered
// ---------------------------------------------------------------------------
import {
getSuggestedUsers,
getMutualFollowers,
getFollowSuggestions,
getActivityFeed,
SuggestedUser,
MutualFollowersResult,
GitHubFollowSuggestion,
ActivityFeedResult,
} from '../../src/services/socialGraphService';
import { blockService } from '../../src/services/blockService';
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
/** Seed a model's __rows array directly. */
function seedRows(model: any, rows: any[]): void {
model.__rows.length = 0;
model.__rows.push(...rows);
}
/** Clear every model table between tests. */
function clearAllTables(): void {
const models = [
'user', 'account', 'follow', 'post', 'repositoryFollow', 'repository',
'userBlock', 'followRequest',
] as const;
for (const m of models) {
(mockPrisma as any)[m].__rows.length = 0;
}
}
const now = new Date('2026-06-22T12:00:00.000Z');
const mkDate = (offsetMs: number) => new Date(now.getTime() + offsetMs);
// ---------------------------------------------------------------------------
// Shared fixture builders
// ---------------------------------------------------------------------------
function makeUser(overrides: Record<string, unknown> = {}) {
return {
id: 'user-1',
username: 'alice',
avatar: 'https://cdn.test/alice.png',
displayName: 'Alice',
githubUsername: 'alice-gh',
githubAccessToken: 'ghp_test_token',
...overrides,
};
}
function makeAccount(overrides: Record<string, unknown> = {}) {
return {
id: 'acc-1',
userId: 'user-1',
username: 'alice',
avatar: 'https://cdn.test/alice.png',
bio: 'Hello world',
type: 'USER',
verified: false,
displayName: 'Alice',
...overrides,
};
}
function makeFollow(overrides: Record<string, unknown> = {}) {
return {
id: 'follow-1',
followerId: 'acc-1',
followingId: 'acc-2',
createdAt: now,
updatedAt: now,
...overrides,
};
}
// ===========================================================================
// getSuggestedUsers
// ===========================================================================
describe('getSuggestedUsers', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
it('returns empty array when the user has no account', async () => {
// No account rows seeded → findUnique returns null
const result = await getSuggestedUsers('user-ghost');
expect(result).toEqual([]);
});
it('returns empty array when the user follows nobody', async () => {
seedRows(mockPrisma.account, [makeAccount()]);
// No follow rows → no followingAccountIds
const result = await getSuggestedUsers('user-1');
expect(result).toEqual([]);
});
it('excludes users already followed by the caller', async () => {
// The account.findMany uses a nested relational filter (`followers.some`)
// that the simple in-memory mock cannot evaluate, so we stub each Prisma
// call in sequence to return realistic data for this scenario.
//
// Scenario:
// acc-1 (user-1) follows acc-2
// acc-2 follows acc-3
// Expected candidates: [acc-3], NOT acc-1 (self) or acc-2 (already followed)
// 1. account.findUnique → caller's account
mockPrisma.account.findUnique.mockResolvedValueOnce({ id: 'acc-1' });
// 2. follow.findMany → caller's followings
mockPrisma.follow.findMany.mockResolvedValueOnce([{ followingId: 'acc-2' }]);
// 3. account.findMany → candidate accounts (friends-of-friends)
mockPrisma.account.findMany.mockResolvedValueOnce([
{
id: 'acc-3',
userId: 'user-3',
username: 'carol',
avatar: null,
bio: null,
verified: false,
_count: { followers: 5 },
},
]);
// 4. follow.count → mutual count for acc-3
mockPrisma.follow.count.mockResolvedValueOnce(1);
const result = await getSuggestedUsers('user-1');
const ids = result.map((u: SuggestedUser) => u.id);
expect(ids).toContain('user-3');
expect(ids).not.toContain('user-1'); // never self
expect(ids).not.toContain('user-2'); // already followed
});
it('excludes the caller themselves from suggestions', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1', username: 'alice' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
// acc-1 follows acc-2, and acc-2 follows acc-1 back (potential self suggestion)
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
makeFollow({ id: 'f2', followerId: 'acc-2', followingId: 'acc-1' }),
]);
const result = await getSuggestedUsers('user-1');
const ids = result.map((u: SuggestedUser) => u.id);
expect(ids).not.toContain('user-1');
});
it('ranks candidates by mutual connection count (descending)', async () => {
// acc-1 (caller) follows acc-2 and acc-3.
// acc-2 follows acc-4 and acc-5.
// acc-3 follows acc-4 only.
// acc-4 has mutual count = 2 (both acc-2 and acc-3 follow it).
// acc-5 has mutual count = 1 (only acc-2 follows it).
// Use manual mocks because account.findMany needs a nested relational filter.
mockPrisma.account.findUnique.mockResolvedValueOnce({ id: 'acc-1' });
mockPrisma.follow.findMany.mockResolvedValueOnce([
{ followingId: 'acc-2' },
{ followingId: 'acc-3' },
]);
mockPrisma.account.findMany.mockResolvedValueOnce([
{
id: 'acc-4',
userId: 'user-4',
username: 'dave',
avatar: null,
bio: null,
verified: false,
_count: { followers: 10 },
},
{
id: 'acc-5',
userId: 'user-5',
username: 'eve',
avatar: null,
bio: null,
verified: false,
_count: { followers: 3 },
},
]);
// follow.count called for acc-4 (2 mutual) then acc-5 (1 mutual)
mockPrisma.follow.count
.mockResolvedValueOnce(2) // acc-4
.mockResolvedValueOnce(1); // acc-5
const result = await getSuggestedUsers('user-1', 10);
const ids = result.map((u: SuggestedUser) => u.id);
expect(ids.indexOf('user-4')).toBeLessThan(ids.indexOf('user-5'));
});
it('respects the limit parameter', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2' }),
...Array.from({ length: 10 }, (_, i) =>
makeAccount({ id: `acc-cand-${i}`, userId: `user-cand-${i}` })
),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f0', followerId: 'acc-1', followingId: 'acc-2' }),
...Array.from({ length: 10 }, (_, i) =>
makeFollow({ id: `f-cand-${i}`, followerId: 'acc-2', followingId: `acc-cand-${i}` })
),
]);
const result = await getSuggestedUsers('user-1', 3);
expect(result.length).toBeLessThanOrEqual(3);
});
it('returns cached result when the cache is warm', async () => {
const cached: SuggestedUser[] = [
{
id: 'user-cached',
username: 'cached',
avatar: null,
bio: null,
followersCount: 5,
isVerified: false,
mutualFollows: 1,
},
];
mockCacheGet.mockResolvedValueOnce(cached);
const result = await getSuggestedUsers('user-1');
expect(result).toEqual(cached);
// Prisma should not be consulted at all
expect(mockPrisma.account.findUnique).not.toHaveBeenCalled();
});
it('stores result in cache on a cache miss', async () => {
seedRows(mockPrisma.account, [makeAccount()]);
// No follows → returns [] but should still call cache.set
await getSuggestedUsers('user-1');
// cache.set is only called when there is a non-empty result to store;
// with zero followings the service returns early before the set call.
// Verify the function completes without error.
expect(mockCacheSet).not.toHaveBeenCalled();
});
it('throws a descriptive error when Prisma rejects', async () => {
mockPrisma.account.findUnique.mockRejectedValueOnce(new Error('DB exploded'));
await expect(getSuggestedUsers('user-1')).rejects.toThrow('Failed to get suggested users');
});
});
// ===========================================================================
// getMutualFollowers
// ===========================================================================
describe('getMutualFollowers', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
it('returns empty result when either account does not exist', async () => {
// Only seed one account — the other is missing
seedRows(mockPrisma.account, [makeAccount({ id: 'acc-1', userId: 'user-1' })]);
const result = await getMutualFollowers('user-1', 'user-missing');
expect(result).toEqual({ users: [], count: 0 });
});
it('returns empty result when the user has no followers', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2' }),
]);
// No follow rows → followersOfUser is empty
const result = await getMutualFollowers('user-1', 'user-2');
expect(result).toEqual({ users: [], count: 0 });
});
it('finds users who follow both parties', async () => {
// acc-3 follows both acc-1 and acc-2 → mutual follower
// acc-4 follows only acc-1 → not mutual
//
// The service selects follow rows with a nested `follower` relation (Account).
// The in-memory mock resolves 'follower' via the `user` table, but the
// followers are Accounts — so we stub the Prisma calls directly.
// 1 & 2. account.findUnique for each userId
mockPrisma.account.findUnique
.mockResolvedValueOnce({ id: 'acc-1' })
.mockResolvedValueOnce({ id: 'acc-2' });
// 3. follow.findMany → followers of acc-1
mockPrisma.follow.findMany
.mockResolvedValueOnce([
{ followerId: 'acc-3' },
{ followerId: 'acc-4' },
])
// 4. follow.findMany → mutual (also follow acc-2), returns rows with nested follower
.mockResolvedValueOnce([
{
follower: {
id: 'acc-3',
userId: 'user-3',
username: 'carol',
avatar: null,
displayName: 'Carol',
},
},
]);
const result = await getMutualFollowers('user-1', 'user-2');
expect(result.count).toBe(1);
const usernames = result.users.map((u) => u.username);
expect(usernames).toContain('carol');
expect(usernames).not.toContain('dave');
});
it('caps results at 10 mutual followers', async () => {
// Stub all Prisma calls — 15 mutual followers exist but the service uses take:10
mockPrisma.account.findUnique
.mockResolvedValueOnce({ id: 'acc-target-1' })
.mockResolvedValueOnce({ id: 'acc-target-2' });
// 15 followers of target-1
mockPrisma.follow.findMany
.mockResolvedValueOnce(
Array.from({ length: 15 }, (_, i) => ({ followerId: `acc-m-${i}` }))
)
// mutual findMany with take:10 — return 10 rows
.mockResolvedValueOnce(
Array.from({ length: 10 }, (_, i) => ({
follower: {
id: `acc-m-${i}`,
userId: `user-m-${i}`,
username: `mutual${i}`,
avatar: null,
displayName: null,
},
}))
);
const result = await getMutualFollowers('user-target-1', 'user-target-2');
expect(result.users.length).toBeLessThanOrEqual(10);
});
it('returns cached result when the cache is warm', async () => {
const cached: MutualFollowersResult = {
users: [{ id: 'user-cached', username: 'cached', avatar: null, displayName: null }],
count: 1,
};
mockCacheGet.mockResolvedValueOnce(cached);
const result = await getMutualFollowers('user-1', 'user-2');
expect(result).toEqual(cached);
expect(mockPrisma.account.findUnique).not.toHaveBeenCalled();
});
it('throws a descriptive error when Prisma rejects', async () => {
mockPrisma.account.findUnique.mockRejectedValueOnce(new Error('DB down'));
await expect(getMutualFollowers('user-1', 'user-2')).rejects.toThrow(
'Failed to get mutual followers'
);
});
});
// ===========================================================================
// getFollowSuggestions (GitHub-based friends-of-friends)
// ===========================================================================
describe('getFollowSuggestions', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
mockListFollowers.mockResolvedValue({ data: [] });
});
it('returns empty array when the user has no GitHub access token', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-1', githubAccessToken: null }),
]);
const result = await getFollowSuggestions('user-1');
expect(result).toEqual([]);
});
it('returns empty array when the user does not exist', async () => {
// No user row seeded → findUnique returns null
const result = await getFollowSuggestions('user-ghost');
expect(result).toEqual([]);
});
it('returns empty array when the GitHub follower list is empty', async () => {
seedRows(mockPrisma.user, [makeUser({ id: 'user-1', githubAccessToken: 'ghp_token' })]);
mockListFollowers.mockResolvedValueOnce({ data: [] });
const result = await getFollowSuggestions('user-1');
expect(result).toEqual([]);
});
it('returns gitgram users whose githubUsername matches a GitHub follower', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-1', githubUsername: 'alice-gh', githubAccessToken: 'ghp_token' }),
makeUser({ id: 'user-2', githubUsername: 'bob-gh', githubAccessToken: null }),
makeUser({ id: 'user-3', githubUsername: 'carol-gh', githubAccessToken: null }),
]);
mockListFollowers.mockResolvedValueOnce({
data: [
{ login: 'bob-gh' },
{ login: 'carol-gh' },
{ login: 'unknown-gh' }, // no gitgram account
],
});
// No account seeded for caller → no already-following exclusion, but that path is skipped
const result = await getFollowSuggestions('user-1');
const ids = result.map((u: GitHubFollowSuggestion) => u.id);
expect(ids).toContain('user-2');
expect(ids).toContain('user-3');
expect(ids).not.toContain('user-1'); // self excluded
});
it('excludes users already followed by the caller', async () => {
// Seed user and account rows via the mock tables, but stub follow.findMany
// because the in-memory mock cannot resolve the nested `following.userId`
// relation when followingId is an Account ID, not a User ID.
seedRows(mockPrisma.user, [
makeUser({ id: 'user-1', githubUsername: 'alice-gh', githubAccessToken: 'ghp_token' }),
makeUser({ id: 'user-2', githubUsername: 'bob-gh' }),
]);
seedRows(mockPrisma.account, [makeAccount({ id: 'acc-1', userId: 'user-1' })]);
mockListFollowers.mockResolvedValueOnce({ data: [{ login: 'bob-gh' }] });
// Stub follow.findMany to simulate: caller already follows user-2
mockPrisma.follow.findMany.mockResolvedValueOnce([
{ following: { userId: 'user-2' } },
]);
const result = await getFollowSuggestions('user-1');
const ids = result.map((u: GitHubFollowSuggestion) => u.id);
expect(ids).not.toContain('user-2');
});
it('excludes the caller themselves from suggestions', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-1', githubUsername: 'alice-gh', githubAccessToken: 'ghp_token' }),
]);
// GitHub API returns alice's own username as a follower (edge case)
mockListFollowers.mockResolvedValueOnce({ data: [{ login: 'alice-gh' }] });
const result = await getFollowSuggestions('user-1');
const ids = result.map((u: GitHubFollowSuggestion) => u.id);
expect(ids).not.toContain('user-1');
});
it('returns cached result when the cache is warm', async () => {
const cached: GitHubFollowSuggestion[] = [
{
id: 'user-cached',
username: 'cached',
avatar: null,
githubUsername: 'cached-gh',
displayName: null,
},
];
mockCacheGet.mockResolvedValueOnce(cached);
const result = await getFollowSuggestions('user-1');
expect(result).toEqual(cached);
expect(mockPrisma.user.findUnique).not.toHaveBeenCalled();
});
it('throws a descriptive error when Prisma rejects', async () => {
mockPrisma.user.findUnique.mockRejectedValueOnce(new Error('DB exploded'));
await expect(getFollowSuggestions('user-1')).rejects.toThrow(
'Failed to get GitHub follow suggestions'
);
});
});
// ===========================================================================
// getActivityFeed
// ===========================================================================
describe('getActivityFeed', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
it('returns empty feed when the user account does not exist', async () => {
const result = await getActivityFeed('user-ghost');
expect(result).toEqual({ events: [], nextCursor: undefined });
});
it('returns empty feed when the caller follows nobody', async () => {
seedRows(mockPrisma.account, [makeAccount({ id: 'acc-1', userId: 'user-1' })]);
// No follow rows
const result = await getActivityFeed('user-1');
expect(result).toEqual({ events: [], nextCursor: undefined });
});
it('includes new_post events from followed accounts', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1', username: 'alice' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
seedRows(mockPrisma.post, [
{
id: 'post-1',
accountId: 'acc-2',
content: 'Hello gitgram!',
status: 'PUBLISHED',
isArchived: false,
createdAt: mkDate(-1000),
updatedAt: mkDate(-1000),
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1');
const postEvents = result.events.filter((e) => e.type === 'new_post');
expect(postEvents.length).toBe(1);
expect(postEvents[0].targetId).toBe('post-1');
expect(postEvents[0].actorUsername).toBe('bob');
});
it('includes new_follow events from followed accounts', async () => {
// Seed the account table so the initial lookups work via the in-memory mock.
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1', username: 'alice' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
makeAccount({ id: 'acc-3', userId: 'user-3', username: 'carol', type: 'USER' }),
]);
// Step 1 — account.findUnique (caller account)
mockPrisma.account.findUnique.mockResolvedValueOnce({ id: 'acc-1' });
// Step 2 — follow.findMany called three times in the service:
// call 1: caller's followings (myFollowings)
// call 2 (via Promise.all): new_follow events (follows by followed accounts)
// call 3 (via Promise.all): NOT a follow.findMany — posts and repositoryFollows go
// to their own models, so we only need to stub the follow.findMany calls.
//
// The service calls follow.findMany twice:
// A) { followerId: myAccountId } → myFollowings
// B) { followerId: { in: followingAccountIds } } → new_follow events
//
// Because jest stubs are consumed in order per mock, we set two responses.
mockPrisma.follow.findMany
// A) caller's followings
.mockResolvedValueOnce([{ followingId: 'acc-2' }])
// B) new_follow events — return pre-resolved nested objects
.mockResolvedValueOnce([
{
id: 'f2',
followerId: 'acc-2',
followingId: 'acc-3',
createdAt: mkDate(-500),
follower: { userId: 'user-2', username: 'bob', avatar: null },
following: { id: 'acc-3', type: 'USER', username: 'carol' },
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1');
const followEvents = result.events.filter((e) => e.type === 'new_follow');
expect(followEvents.length).toBe(1);
expect(followEvents[0].actorUsername).toBe('bob');
expect(followEvents[0].targetId).toBe('acc-3');
});
it('includes repository_star events from followed accounts', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1', username: 'alice' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
seedRows(mockPrisma.repository, [
{ id: 'repo-1', fullName: 'torvalds/linux', createdAt: now, updatedAt: now },
]);
seedRows(mockPrisma.repositoryFollow, [
{
id: 'rf-1',
accountId: 'acc-2',
repositoryId: 'repo-1',
createdAt: mkDate(-2000),
updatedAt: mkDate(-2000),
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1');
const starEvents = result.events.filter((e) => e.type === 'repository_star');
expect(starEvents.length).toBe(1);
expect((starEvents[0].metadata as any).repositoryFullName).toBe('torvalds/linux');
expect(starEvents[0].targetId).toBe('repo-1');
});
it('sorts all event types newest-first', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
const t1 = mkDate(-3000); // oldest
const t2 = mkDate(-2000);
const t3 = mkDate(-1000); // newest
seedRows(mockPrisma.post, [
{
id: 'post-old',
accountId: 'acc-2',
content: 'Old post',
status: 'PUBLISHED',
isArchived: false,
createdAt: t1,
updatedAt: t1,
},
{
id: 'post-mid',
accountId: 'acc-2',
content: 'Mid post',
status: 'PUBLISHED',
isArchived: false,
createdAt: t2,
updatedAt: t2,
},
{
id: 'post-new',
accountId: 'acc-2',
content: 'New post',
status: 'PUBLISHED',
isArchived: false,
createdAt: t3,
updatedAt: t3,
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1', undefined, 10);
const timestamps = result.events.map((e) => e.createdAt.getTime());
for (let i = 1; i < timestamps.length; i++) {
expect(timestamps[i - 1]).toBeGreaterThanOrEqual(timestamps[i]);
}
});
it('pages using cursor: events strictly older than cursor are returned', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
const t1 = new Date('2026-06-22T10:00:00.000Z');
const t2 = new Date('2026-06-22T11:00:00.000Z');
const t3 = new Date('2026-06-22T12:00:00.000Z');
seedRows(mockPrisma.post, [
{
id: 'post-1',
accountId: 'acc-2',
content: 'Post 1',
status: 'PUBLISHED',
isArchived: false,
createdAt: t1,
updatedAt: t1,
},
{
id: 'post-2',
accountId: 'acc-2',
content: 'Post 2',
status: 'PUBLISHED',
isArchived: false,
createdAt: t2,
updatedAt: t2,
},
{
id: 'post-3',
accountId: 'acc-2',
content: 'Post 3',
status: 'PUBLISHED',
isArchived: false,
createdAt: t3,
updatedAt: t3,
},
]);
// Cursor is t3 → should return only post-1 and post-2 (strictly before t3)
const result: ActivityFeedResult = await getActivityFeed('user-1', t3.toISOString(), 10);
const ids = result.events.map((e) => e.targetId);
expect(ids).not.toContain('post-3');
expect(ids).toContain('post-1');
expect(ids).toContain('post-2');
});
it('sets nextCursor when the page is exactly full', async () => {
const limit = 3;
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
// Seed exactly `limit` posts
const posts = Array.from({ length: limit }, (_, i) => ({
id: `post-${i}`,
accountId: 'acc-2',
content: `Post ${i}`,
status: 'PUBLISHED',
isArchived: false,
createdAt: mkDate(-(i + 1) * 1000),
updatedAt: mkDate(-(i + 1) * 1000),
}));
seedRows(mockPrisma.post, posts);
const result: ActivityFeedResult = await getActivityFeed('user-1', undefined, limit);
expect(result.nextCursor).toBeDefined();
expect(typeof result.nextCursor).toBe('string');
// The cursor should be the ISO timestamp of the last event on the page
const lastEventTime = result.events[result.events.length - 1].createdAt.toISOString();
expect(result.nextCursor).toBe(lastEventTime);
});
it('omits nextCursor when fewer events than limit are returned', async () => {
const limit = 10;
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
// Seed only 2 posts — fewer than limit
seedRows(mockPrisma.post, [
{
id: 'post-a',
accountId: 'acc-2',
content: 'A',
status: 'PUBLISHED',
isArchived: false,
createdAt: mkDate(-1000),
updatedAt: mkDate(-1000),
},
{
id: 'post-b',
accountId: 'acc-2',
content: 'B',
status: 'PUBLISHED',
isArchived: false,
createdAt: mkDate(-2000),
updatedAt: mkDate(-2000),
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1', undefined, limit);
expect(result.nextCursor).toBeUndefined();
});
it('truncates post content to 140 characters in metadata', async () => {
seedRows(mockPrisma.account, [
makeAccount({ id: 'acc-1', userId: 'user-1' }),
makeAccount({ id: 'acc-2', userId: 'user-2', username: 'bob' }),
]);
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
]);
const longContent = 'x'.repeat(300);
seedRows(mockPrisma.post, [
{
id: 'post-long',
accountId: 'acc-2',
content: longContent,
status: 'PUBLISHED',
isArchived: false,
createdAt: mkDate(-1000),
updatedAt: mkDate(-1000),
},
]);
const result: ActivityFeedResult = await getActivityFeed('user-1', undefined, 10);
const event = result.events.find((e) => e.targetId === 'post-long');
expect(event).toBeDefined();
expect((event!.metadata as any).content.length).toBe(140);
});
it('throws a descriptive error when Prisma rejects', async () => {
mockPrisma.account.findUnique.mockRejectedValueOnce(new Error('DB exploded'));
await expect(getActivityFeed('user-1')).rejects.toThrow('Failed to get activity feed');
});
});
// ===========================================================================
// getMutualFollowers — additional case: A and C both follow B
// ===========================================================================
describe('getMutualFollowers — A and C both follow B', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
it('returns A when both A and C follow B', async () => {
// Setup: A (user-A) follows B (user-B); C (user-C) follows B.
// getMutualFollowers(user-A, user-C) should return B as the mutual.
// — Wait: the service finds users who follow BOTH userId AND targetUserId.
// To match the scenario "A and C both follow B → B.getMutuals(C) returns A":
// getMutualFollowers(user-B, user-C) should return user-A because A follows both B and C.
// acc-A follows acc-B
// acc-A follows acc-C
// => getMutualFollowers('user-B', 'user-C') returns acc-A as mutual
mockPrisma.account.findUnique
.mockResolvedValueOnce({ id: 'acc-B' }) // target 1 = B
.mockResolvedValueOnce({ id: 'acc-C' }); // target 2 = C
// followers of B: [acc-A]
mockPrisma.follow.findMany
.mockResolvedValueOnce([{ followerId: 'acc-A' }])
// among those, who also follows C?
.mockResolvedValueOnce([
{
follower: {
id: 'acc-A',
userId: 'user-A',
username: 'alice',
avatar: null,
displayName: 'Alice',
},
},
]);
const result = await getMutualFollowers('user-B', 'user-C');
expect(result.count).toBe(1);
expect(result.users[0].username).toBe('alice');
});
});
// ===========================================================================
// getSuggestedUsers — second-degree network (friends of friends)
// ===========================================================================
describe('getSuggestedUsers — second-degree network', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
it('returns second-degree connections (users followed by people you follow)', async () => {
// user-1 follows user-2; user-2 follows user-3 → user-3 is a 2nd-degree suggestion
mockPrisma.account.findUnique.mockResolvedValueOnce({ id: 'acc-1' });
mockPrisma.follow.findMany.mockResolvedValueOnce([{ followingId: 'acc-2' }]);
mockPrisma.account.findMany.mockResolvedValueOnce([
{
id: 'acc-3',
userId: 'user-3',
username: 'thirdDegree',
avatar: null,
bio: null,
verified: false,
_count: { followers: 2 },
},
]);
mockPrisma.follow.count.mockResolvedValueOnce(1);
const result = await getSuggestedUsers('user-1');
const ids = result.map((u: SuggestedUser) => u.id);
expect(ids).toContain('user-3');
});
it('does not include first-degree connections (already-followed users)', async () => {
mockPrisma.account.findUnique.mockResolvedValueOnce({ id: 'acc-1' });
mockPrisma.follow.findMany.mockResolvedValueOnce([{ followingId: 'acc-2' }]);
// account.findMany returns empty because acc-2 is already excluded by the query
mockPrisma.account.findMany.mockResolvedValueOnce([]);
const result = await getSuggestedUsers('user-1');
expect(result).toEqual([]);
});
});
// ===========================================================================
// getFollowStats (derived from follow counts using Prisma)
// ===========================================================================
describe('getFollowStats — followers / following / mutuals counts', () => {
beforeEach(() => {
clearAllTables();
mockCacheGet.mockResolvedValue(null);
mockCacheSet.mockResolvedValue(undefined);
});
/**
* getFollowStats is not exported from socialGraphService — we derive the
* counts using the same Prisma queries the service relies on. These tests
* validate that the underlying data model is consistent and that the mock
* infrastructure counts correctly.
*/
it('counts followers correctly', async () => {
// acc-2 and acc-3 both follow acc-1 → followers of acc-1 = 2
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-2', followingId: 'acc-1' }),
makeFollow({ id: 'f2', followerId: 'acc-3', followingId: 'acc-1' }),
]);
const count = await mockPrisma.follow.count({ where: { followingId: 'acc-1' } });
expect(count).toBe(2);
});
it('counts following correctly', async () => {
// acc-1 follows acc-2 and acc-3 → following of acc-1 = 2
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
makeFollow({ id: 'f2', followerId: 'acc-1', followingId: 'acc-3' }),
]);
const count = await mockPrisma.follow.count({ where: { followerId: 'acc-1' } });
expect(count).toBe(2);
});
it('computes mutual count (A follows B AND B follows A)', async () => {
// Mutual between acc-1 and acc-2
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-1', followingId: 'acc-2' }),
makeFollow({ id: 'f2', followerId: 'acc-2', followingId: 'acc-1' }),
// acc-3 follows acc-1 but acc-1 does NOT follow acc-3 → not mutual
makeFollow({ id: 'f3', followerId: 'acc-3', followingId: 'acc-1' }),
]);
// Following of acc-1
const followingRows = await mockPrisma.follow.findMany({ where: { followerId: 'acc-1' } });
const followingIds = followingRows.map((r: any) => r.followingId);
// Followers of acc-1
const followerRows = await mockPrisma.follow.findMany({ where: { followingId: 'acc-1' } });
const followerIds = followerRows.map((r: any) => r.followerId);
// Mutuals = intersection of followingIds and followerIds
const mutuals = followingIds.filter((id: string) => followerIds.includes(id));
expect(mutuals).toHaveLength(1);
expect(mutuals[0]).toBe('acc-2');
});
it('returns zero when user has no follows at all', async () => {
// No rows at all
const followers = await mockPrisma.follow.count({ where: { followingId: 'acc-ghost' } });
const following = await mockPrisma.follow.count({ where: { followerId: 'acc-ghost' } });
expect(followers).toBe(0);
expect(following).toBe(0);
});
});
// ===========================================================================
// isFollowing — true/false query via Prisma follow model
// ===========================================================================
describe('isFollowing — boolean follow check', () => {
beforeEach(() => {
clearAllTables();
});
it('returns true when a follow row exists between follower and following', async () => {
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-alice', followingId: 'acc-bob' }),
]);
const row = await mockPrisma.follow.findFirst({
where: { followerId: 'acc-alice', followingId: 'acc-bob' },
});
const isFollowing = row !== null;
expect(isFollowing).toBe(true);
});
it('returns false when no follow row exists', async () => {
// No follow rows seeded
const row = await mockPrisma.follow.findFirst({
where: { followerId: 'acc-alice', followingId: 'acc-bob' },
});
const isFollowing = row !== null;
expect(isFollowing).toBe(false);
});
it('is directional: A follows B does not mean B follows A', async () => {
seedRows(mockPrisma.follow, [
makeFollow({ id: 'f1', followerId: 'acc-alice', followingId: 'acc-bob' }),
]);
const aliceFollowsBob = await mockPrisma.follow.findFirst({
where: { followerId: 'acc-alice', followingId: 'acc-bob' },
});
const bobFollowsAlice = await mockPrisma.follow.findFirst({
where: { followerId: 'acc-bob', followingId: 'acc-alice' },
});
expect(aliceFollowsBob).not.toBeNull();
expect(bobFollowsAlice).toBeNull();
});
});
// ===========================================================================
// blockUser / isBlocked / getBlockedUsers / unblockUser (via blockService)
// ===========================================================================
describe('blockService.blockUser', () => {
beforeEach(() => {
clearAllTables();
});
it('creates a userBlock row', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-A' }),
makeUser({ id: 'user-B' }),
]);
await blockService.blockUser('user-A', 'user-B');
const block = await mockPrisma.userBlock.findUnique({
where: { blockerId_blockedId: { blockerId: 'user-A', blockedId: 'user-B' } },
});
expect(block).not.toBeNull();
});
it('throws "User not found" when target user does not exist', async () => {
// Only seed the blocker — blocked user is missing
seedRows(mockPrisma.user, [makeUser({ id: 'user-A' })]);
await expect(blockService.blockUser('user-A', 'user-ghost')).rejects.toThrow('User not found');
});
it('throws "User is already blocked" on duplicate block', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-A' }),
makeUser({ id: 'user-B' }),
]);
// Pre-seed the block row
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
await expect(blockService.blockUser('user-A', 'user-B')).rejects.toThrow(
'User is already blocked'
);
});
it('removes existing follow relationships when a block is created', async () => {
seedRows(mockPrisma.user, [
makeUser({ id: 'user-A' }),
makeUser({ id: 'user-B' }),
]);
// Seed a follow row in both directions
seedRows(mockPrisma.follow, [
{ id: 'f1', followerId: 'user-A', followingId: 'user-B', createdAt: now, updatedAt: now },
{ id: 'f2', followerId: 'user-B', followingId: 'user-A', createdAt: now, updatedAt: now },
]);
await blockService.blockUser('user-A', 'user-B');
// Both follow rows should have been deleted by the transaction
const remainingFollows = await mockPrisma.follow.findMany({ where: {} });
expect(remainingFollows).toHaveLength(0);
});
});
describe('blockService.isBlocked', () => {
beforeEach(() => {
clearAllTables();
});
it('returns true when a block row exists', async () => {
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
const result = await blockService.isBlocked('user-A', 'user-B');
expect(result).toBe(true);
});
it('returns false when no block row exists', async () => {
const result = await blockService.isBlocked('user-A', 'user-B');
expect(result).toBe(false);
});
it('is directional: A blocks B does not imply B blocks A', async () => {
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
expect(await blockService.isBlocked('user-A', 'user-B')).toBe(true);
expect(await blockService.isBlocked('user-B', 'user-A')).toBe(false);
});
});
describe('blockService.getBlockedUsers', () => {
beforeEach(() => {
clearAllTables();
});
it('returns empty list when no users are blocked', async () => {
const result = await blockService.getBlockedUsers('user-A');
expect(result.users).toHaveLength(0);
expect(result.pagination.total).toBe(0);
});
it('returns the blocked user with correct fields', async () => {
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
seedRows(mockPrisma.user, [
makeUser({ id: 'user-B', username: 'bob', avatar: 'https://cdn.test/bob.png', bio: 'I am Bob' }),
]);
const result = await blockService.getBlockedUsers('user-A');
expect(result.users).toHaveLength(1);
expect(result.users[0].id).toBe('user-B');
expect(result.users[0].username).toBe('bob');
expect(result.users[0].blockedAt).toEqual(now);
});
it('paginates results correctly', async () => {
const blockRows = Array.from({ length: 5 }, (_, i) => ({
id: `blk-${i}`,
blockerId: 'user-A',
blockedId: `user-${i}`,
createdAt: mkDate(-i * 1000),
updatedAt: mkDate(-i * 1000),
}));
const userRows = Array.from({ length: 5 }, (_, i) =>
makeUser({ id: `user-${i}`, username: `blocked${i}` })
);
seedRows(mockPrisma.userBlock, blockRows);
seedRows(mockPrisma.user, userRows);
const page1 = await blockService.getBlockedUsers('user-A', 1, 2);
expect(page1.users).toHaveLength(2);
expect(page1.pagination.total).toBe(5);
expect(page1.pagination.pages).toBe(3);
});
});
describe('blockService.unblockUser', () => {
beforeEach(() => {
clearAllTables();
});
it('removes the block row', async () => {
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
await blockService.unblockUser('user-A', 'user-B');
const block = await mockPrisma.userBlock.findUnique({
where: { blockerId_blockedId: { blockerId: 'user-A', blockedId: 'user-B' } },
});
expect(block).toBeNull();
});
it('throws "User is not blocked" when no block exists', async () => {
await expect(blockService.unblockUser('user-A', 'user-B')).rejects.toThrow(
'User is not blocked'
);
});
it('allows following again after unblocking', async () => {
// Seed a block between A and B, then unblock
seedRows(mockPrisma.userBlock, [
{ id: 'blk-1', blockerId: 'user-A', blockedId: 'user-B', createdAt: now, updatedAt: now },
]);
await blockService.unblockUser('user-A', 'user-B');
// After unblock, isBlocked should be false so a follow can be created
const stillBlocked = await blockService.isBlocked('user-A', 'user-B');
expect(stillBlocked).toBe(false);
// Simulate creating a follow now that the block is gone
await mockPrisma.follow.create({
data: { followerId: 'user-A', followingId: 'user-B' },
});
const follow = await mockPrisma.follow.findFirst({
where: { followerId: 'user-A', followingId: 'user-B' },
});
expect(follow).not.toBeNull();
});
});