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

651 lines
22 KiB
TypeScript

/**
* Unit tests for feedTuner.ts
*
* Covers:
* - Empty feed handling
* - MAX_AUTHOR_RUN enforcement (default = 2, configurable)
* - Content-type interleaving (post/snippet vs repo/reel)
* - Sponsored item injection every N posts
* - Trending boost score adjustment
* - Diversity penalty for repeat authors
* - Deduplication by id
* - FeedTuner class construction and tune() method
* - tuneFeed() functional API
*
* Strategy: all tests operate purely on in-memory data — no Prisma or Redis
* calls. `trendingAlgorithmService` is mocked so trending score computation
* is deterministic.
*/
// ---------------------------------------------------------------------------
// Module mocks — declared before any imports that touch these modules
// ---------------------------------------------------------------------------
jest.mock('../../src/services/trendingAlgorithmService', () => ({
computeTrendingScore: jest.fn(() => 0),
}));
// ---------------------------------------------------------------------------
// Imports
// ---------------------------------------------------------------------------
import { computeTrendingScore } from '../../src/services/trendingAlgorithmService';
import {
FeedTuner,
tuneFeed,
type TunableFeedItem,
type SponsoredItem,
type FeedTunerOptions,
} from '../../src/services/feedTuner';
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
const mockedComputeTrendingScore = computeTrendingScore as jest.MockedFunction<
typeof computeTrendingScore
>;
function makePost(
id: string,
authorId: string | null,
score: number,
overrides: Partial<TunableFeedItem> = {}
): TunableFeedItem {
return {
id,
type: 'post',
authorId,
score,
likesCount: 0,
commentsCount: 0,
sharesCount: 0,
savesCount: 0,
createdAt: new Date('2026-06-20T12:00:00Z'),
...overrides,
};
}
function makeRepo(
id: string,
authorId: string | null,
score: number
): TunableFeedItem {
return makePost(id, authorId, score, { type: 'repo' });
}
function makeReel(
id: string,
authorId: string | null,
score: number
): TunableFeedItem {
return makePost(id, authorId, score, { type: 'reel' });
}
function makeSnippet(
id: string,
authorId: string | null,
score: number
): TunableFeedItem {
return makePost(id, authorId, score, { type: 'snippet' });
}
function makeSponsored(id: string): SponsoredItem {
return {
id,
type: 'post',
authorId: null,
score: 0,
isSponsored: true,
adId: `ad-${id}`,
title: 'Test Ad',
content: 'Buy our product',
targetUrl: 'https://example.com',
mediaUrl: null,
};
}
/** Extract the authorId sequence from a result array for easy assertion. */
function authorSequence(items: TunableFeedItem[]): Array<string | null> {
return items.map(i => i.authorId);
}
/** Count how many times authorId appears consecutively — returns max run length. */
function maxConsecutiveAuthorRun(items: TunableFeedItem[]): number {
let maxRun = 0;
let currentRun = 1;
for (let i = 1; i < items.length; i++) {
const prev = items[i - 1];
const curr = items[i];
if (
curr.authorId !== null &&
prev.authorId !== null &&
curr.authorId === prev.authorId &&
!curr.isSponsored &&
!prev.isSponsored
) {
currentRun++;
maxRun = Math.max(maxRun, currentRun);
} else {
currentRun = 1;
}
}
return maxRun;
}
// ---------------------------------------------------------------------------
// Test suite
// ---------------------------------------------------------------------------
beforeEach(() => {
jest.clearAllMocks();
mockedComputeTrendingScore.mockReturnValue(0);
});
// ── Empty feed ───────────────────────────────────────────────────────────────
describe('empty feed handling', () => {
it('tuneFeed returns [] for an empty array', () => {
expect(tuneFeed([])).toEqual([]);
});
it('FeedTuner#tune returns [] for an empty array', () => {
const tuner = new FeedTuner();
expect(tuner.tune([])).toEqual([]);
});
it('returns [] when options are provided but array is empty', () => {
expect(tuneFeed([], { maxAuthorRun: 1, boostTrending: true })).toEqual([]);
});
});
// ── MAX_AUTHOR_RUN enforcement ───────────────────────────────────────────────
describe('MAX_AUTHOR_RUN enforcement', () => {
it('does not reorder when no author appears more than maxAuthorRun times consecutively', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 90),
makePost('p3', 'bob', 80),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
// alice appears twice in a row — that is exactly the default limit
expect(maxConsecutiveAuthorRun(result.filter(i => !i.isSponsored))).toBeLessThanOrEqual(2);
});
it('enforces default MAX_AUTHOR_RUN=2: a third consecutive post from same author is deferred', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 99),
makePost('p3', 'alice', 98), // third consecutive — should be deferred
makePost('p4', 'bob', 50),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
const nonSponsored = result.filter(i => !i.isSponsored);
expect(maxConsecutiveAuthorRun(nonSponsored)).toBeLessThanOrEqual(2);
// All original items should still be present
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'p3', 'p4'].sort());
});
it('enforces maxAuthorRun=1 when there are sufficient interleaving items', () => {
// With 2 alice and 2 bob posts, maxAuthorRun=1 can be fully satisfied
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 90),
makePost('p3', 'bob', 80),
makePost('p4', 'bob', 70),
];
const result = tuneFeed(feed, {
maxAuthorRun: 1,
sponsoredInterval: 0,
boostTrending: false,
});
const nonSponsored = result.filter(i => !i.isSponsored);
expect(maxConsecutiveAuthorRun(nonSponsored)).toBeLessThanOrEqual(1);
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'p3', 'p4'].sort());
});
it('defers same-author excess and interleaves when possible, appending remainder', () => {
// 3 alice posts + 1 bob: the tuner can interleave 1 bob, then 2 alices must
// appear consecutively at the tail (no other authors available to break the run).
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 90),
makePost('p3', 'alice', 80),
makePost('p4', 'bob', 50),
];
const result = tuneFeed(feed, {
maxAuthorRun: 1,
sponsoredInterval: 0,
boostTrending: false,
});
const nonSponsored = result.filter(i => !i.isSponsored);
// All items must be preserved
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'p3', 'p4'].sort());
// The leading portion (before we run out of breaker items) must respect the limit
// alice, bob, alice is the best the algorithm can achieve; last alice-alice run
// is unavoidable with only one non-alice item
expect(nonSponsored[0].authorId).toBe('alice');
expect(nonSponsored[1].authorId).toBe('bob');
});
it('preserves all items even when every post is from the same author', () => {
// When only one author exists, the run limit cannot be enforced — but all items
// must still be present in the output.
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 90),
makePost('p3', 'alice', 80),
makePost('p4', 'alice', 70),
makePost('p5', 'alice', 60),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
const nonSponsored = result.filter(i => !i.isSponsored);
// All items present — that is the hard guarantee
expect(nonSponsored).toHaveLength(5);
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'p3', 'p4', 'p5'].sort());
});
it('treats null authorId items as always safe to insert consecutively', () => {
const feed = [
makePost('p1', null, 100),
makePost('p2', null, 90),
makePost('p3', null, 80),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
// null authorId should not trigger author run limits
expect(result.filter(i => !i.isSponsored)).toHaveLength(3);
});
});
// ── Content-type interleaving ────────────────────────────────────────────────
describe('content type interleaving', () => {
it('interleaves repo items into a post-heavy feed', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 90),
makePost('p3', 'bob', 80),
makePost('p4', 'charlie', 70),
makePost('p5', 'dave', 60),
makePost('p6', 'eve', 50),
makeRepo('r1', 'org1', 40),
makeRepo('r2', 'org2', 30),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
// The two repos should appear somewhere in the middle of the feed, not both
// clumped at the very end
const repoIndices = result
.filter(i => !i.isSponsored)
.map((item, idx) => ({ idx, type: item.type }))
.filter(entry => entry.type === 'repo')
.map(entry => entry.idx);
// At least one repo should appear before the last position
const lastIndex = result.filter(i => !i.isSponsored).length - 1;
expect(repoIndices.some(i => i < lastIndex)).toBe(true);
});
it('preserves all items through interleaving', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'bob', 80),
makeRepo('r1', 'org', 60),
makeReel('v1', 'charlie', 50),
makeSnippet('s1', 'dave', 40),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
const nonSponsored = result.filter(i => !i.isSponsored);
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'r1', 's1', 'v1'].sort());
});
it('handles a feed with only repos and reels', () => {
const feed = [
makeRepo('r1', 'org1', 100),
makeReel('v1', 'alice', 90),
makeRepo('r2', 'org2', 80),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
expect(result.filter(i => !i.isSponsored)).toHaveLength(3);
});
it('handles a feed with only posts', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'bob', 90),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
expect(result.filter(i => !i.isSponsored)).toHaveLength(2);
});
});
// ── Sponsored content injection ──────────────────────────────────────────────
describe('sponsored content injection', () => {
it('injects a sponsored item every 10 posts by default', () => {
const feed = Array.from({ length: 20 }, (_, i) =>
makePost(`p${i}`, `user${i}`, 100 - i)
);
const sponsored = [makeSponsored('ad1'), makeSponsored('ad2')];
const result = tuneFeed(feed, { boostTrending: false, sponsoredItems: sponsored });
const sponsoredInResult = result.filter(i => i.isSponsored);
// 20 posts → 2 insertion points (at position 10 and 20)
expect(sponsoredInResult.length).toBeGreaterThanOrEqual(2);
});
it('injects no sponsored content when sponsoredItems is empty', () => {
const feed = Array.from({ length: 20 }, (_, i) =>
makePost(`p${i}`, `user${i}`, 100 - i)
);
const result = tuneFeed(feed, { boostTrending: false, sponsoredItems: [] });
expect(result.filter(i => i.isSponsored)).toHaveLength(0);
});
it('injects no sponsored content when sponsoredInterval is 0', () => {
const feed = Array.from({ length: 15 }, (_, i) =>
makePost(`p${i}`, `user${i}`, 100 - i)
);
const sponsored = [makeSponsored('ad1')];
const result = tuneFeed(feed, {
boostTrending: false,
sponsoredInterval: 0,
sponsoredItems: sponsored,
});
expect(result.filter(i => i.isSponsored)).toHaveLength(0);
});
it('cycles through sponsored items round-robin when there are more slots than ads', () => {
const feed = Array.from({ length: 30 }, (_, i) =>
makePost(`p${i}`, `user${i}`, 100 - i)
);
const sponsored = [makeSponsored('ad1')];
const result = tuneFeed(feed, {
boostTrending: false,
sponsoredInterval: 10,
sponsoredItems: sponsored,
});
const sponsoredInResult = result.filter(i => i.isSponsored);
// 30 posts / interval 10 = 3 slots; all should be 'ad1'
expect(sponsoredInResult.length).toBeGreaterThanOrEqual(3);
sponsoredInResult.forEach(item => expect(item.id).toBe('ad1'));
});
it('sponsored item appears at the correct position', () => {
const feed = Array.from({ length: 10 }, (_, i) =>
makePost(`p${i}`, `user${i}`, 100 - i)
);
const sponsored = [makeSponsored('ad1')];
const result = tuneFeed(feed, {
boostTrending: false,
sponsoredInterval: 10,
sponsoredItems: sponsored,
});
// After 10 non-sponsored items the ad should appear
const nonSponsoredBeforeAd = result
.slice(0, result.findIndex(i => i.isSponsored))
.filter(i => !i.isSponsored).length;
expect(nonSponsoredBeforeAd).toBe(10);
});
});
// ── Trending boost ───────────────────────────────────────────────────────────
describe('trending boost', () => {
it('boosts items with a high trendingScore so they rank earlier', () => {
// Low base score but high explicit trendingScore
const lowScoreHighTrend = makePost('p-trend', 'bob', 10, {
trendingScore: 200,
});
// High base score but no trending
const highScoreLowTrend = makePost('p-normal', 'alice', 100, {
trendingScore: 0,
});
const feed = [highScoreLowTrend, lowScoreHighTrend];
const result = tuneFeed(feed, {
boostTrending: true,
trendingBoostThreshold: 50,
trendingBoostMultiplier: 20, // large multiplier to guarantee re-ordering
sponsoredInterval: 0,
});
const nonSponsored = result.filter(i => !i.isSponsored);
expect(nonSponsored[0].id).toBe('p-trend');
});
it('does not boost items below the trendingBoostThreshold', () => {
const feed = [
makePost('p-normal', 'alice', 100, { trendingScore: 10 }),
makePost('p-low', 'bob', 50, { trendingScore: 5 }),
];
const result = tuneFeed(feed, {
boostTrending: true,
trendingBoostThreshold: 50,
trendingBoostMultiplier: 5,
sponsoredInterval: 0,
});
const nonSponsored = result.filter(i => !i.isSponsored);
// Neither crosses the threshold; order should remain by original score
expect(nonSponsored[0].id).toBe('p-normal');
});
it('calls computeTrendingScore when trendingScore field is absent', () => {
mockedComputeTrendingScore.mockReturnValue(100);
const feed = [
makePost('p1', 'alice', 80),
makePost('p2', 'bob', 60),
];
tuneFeed(feed, {
boostTrending: true,
trendingBoostThreshold: 50,
trendingBoostMultiplier: 2,
sponsoredInterval: 0,
});
expect(mockedComputeTrendingScore).toHaveBeenCalled();
});
it('skips trending computation entirely when boostTrending=false', () => {
const feed = [
makePost('p1', 'alice', 80),
makePost('p2', 'bob', 60),
];
tuneFeed(feed, { boostTrending: false, sponsoredInterval: 0 });
expect(mockedComputeTrendingScore).not.toHaveBeenCalled();
});
});
// ── Diversity penalty ────────────────────────────────────────────────────────
describe('diversity penalty', () => {
it('applies score penalty to authors appearing more than diversityPenaltyAfter times', () => {
// alice appears 4 times with high scores; without penalty she would dominate.
// diversityPenaltyAfter=2 means the 3rd and 4th occurrences are penalised
// (seenBefore >= 2 when processing p3 and p4).
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 99),
makePost('p3', 'alice', 98), // 3rd — seenBefore=2 → penalty
makePost('p4', 'alice', 97), // 4th — seenBefore=3 → penalty
makePost('p5', 'bob', 60),
makePost('p6', 'charlie', 50),
];
const result = tuneFeed(feed, {
boostTrending: false,
sponsoredInterval: 0,
diversityPenaltyAfter: 2,
diversityPenaltyMultiplier: 0.1, // very aggressive: 98*0.1=9.8, 97*0.1=9.7
maxAuthorRun: 10, // disable author-run so we see pure score effect
});
const nonSponsored = result.filter(i => !i.isSponsored);
// alice's 3rd and 4th posts (penalised to ~9.8, 9.7) should appear after
// bob (60) and charlie (50)
const aliceIndices = nonSponsored
.map((item, idx) => ({ idx, id: item.id }))
.filter(e => e.id === 'p3' || e.id === 'p4')
.map(e => e.idx);
const bobIdx = nonSponsored.findIndex(i => i.id === 'p5');
const charlieIdx = nonSponsored.findIndex(i => i.id === 'p6');
expect(aliceIndices.every(i => i > bobIdx && i > charlieIdx)).toBe(true);
});
it('does not penalise authors appearing at or under diversityPenaltyAfter times', () => {
// diversityPenaltyAfter=3: seenBefore must reach 3 before penalty triggers,
// so the 1st (seenBefore=0), 2nd (1), and 3rd (2) appearances are safe.
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 99), // 2nd appearance — seenBefore=1, no penalty
makePost('p3', 'alice', 98), // 3rd appearance — seenBefore=2, no penalty
makePost('p4', 'bob', 50),
];
const result = tuneFeed(feed, {
boostTrending: false,
sponsoredInterval: 0,
diversityPenaltyAfter: 3,
diversityPenaltyMultiplier: 0.1,
maxAuthorRun: 10,
});
const nonSponsored = result.filter(i => !i.isSponsored);
// alice's 2nd and 3rd posts still outscore bob, so should appear before bob
const aliceP2Idx = nonSponsored.findIndex(i => i.id === 'p2');
const aliceP3Idx = nonSponsored.findIndex(i => i.id === 'p3');
const bobIdx = nonSponsored.findIndex(i => i.id === 'p4');
expect(aliceP2Idx).toBeLessThan(bobIdx);
expect(aliceP3Idx).toBeLessThan(bobIdx);
});
});
// ── Deduplication ────────────────────────────────────────────────────────────
describe('deduplication', () => {
it('removes duplicate ids, keeping the first occurrence', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p1', 'alice', 100), // exact duplicate
makePost('p2', 'bob', 80),
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
const nonSponsored = result.filter(i => !i.isSponsored);
expect(nonSponsored).toHaveLength(2);
expect(nonSponsored.map(i => i.id)).toEqual(['p1', 'p2']);
});
});
// ── FeedTuner class API ──────────────────────────────────────────────────────
describe('FeedTuner class', () => {
it('tune() returns a new array and does not mutate input', () => {
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'bob', 80),
];
const original = [...feed];
const tuner = new FeedTuner({ sponsoredInterval: 0, boostTrending: false });
const result = tuner.tune(feed);
expect(result).not.toBe(feed);
expect(feed).toEqual(original); // original unchanged
});
it('respects constructor options', () => {
// Equal number of alice and bob posts so maxAuthorRun=1 can be fully satisfied
const feed = [
makePost('p1', 'alice', 100),
makePost('p2', 'alice', 99),
makePost('p3', 'bob', 80),
makePost('p4', 'bob', 70),
];
const tuner = new FeedTuner({
maxAuthorRun: 1,
sponsoredInterval: 0,
boostTrending: false,
});
const result = tuner.tune(feed);
const nonSponsored = result.filter(i => !i.isSponsored);
expect(maxConsecutiveAuthorRun(nonSponsored)).toBeLessThanOrEqual(1);
expect(nonSponsored.map(i => i.id).sort()).toEqual(['p1', 'p2', 'p3', 'p4'].sort());
});
it('can be re-used across multiple tune() calls without state leakage', () => {
const tuner = new FeedTuner({ sponsoredInterval: 0, boostTrending: false });
const feedA = [makePost('a1', 'alice', 100), makePost('a2', 'bob', 80)];
const feedB = [makePost('b1', 'charlie', 100), makePost('b2', 'dave', 80)];
const resultA = tuner.tune(feedA);
const resultB = tuner.tune(feedB);
expect(resultA.map(i => i.id)).not.toEqual(expect.arrayContaining(['b1', 'b2']));
expect(resultB.map(i => i.id)).not.toEqual(expect.arrayContaining(['a1', 'a2']));
});
});
// ── tuneFeed functional API ──────────────────────────────────────────────────
describe('tuneFeed functional API', () => {
it('returns a new array', () => {
const feed = [makePost('p1', 'alice', 100)];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
expect(result).not.toBe(feed);
});
it('works without options argument', () => {
const feed = [makePost('p1', 'alice', 100), makePost('p2', 'bob', 80)];
expect(() => tuneFeed(feed)).not.toThrow();
});
it('preserves extra fields on items', () => {
const feed = [
{ ...makePost('p1', 'alice', 100), customField: 'hello' },
];
const result = tuneFeed(feed, { sponsoredInterval: 0, boostTrending: false });
expect((result[0] as TunableFeedItem & { customField: string }).customField).toBe('hello');
});
});