import { Users } from '../../../../src/db/entities/Users.entity'; import type { UsersRepository } from '../../../../src/db/repositories/Users.repository'; import { UserIdentityTakenError } from '../../../../src/db/repositories/Users.repository'; import { createSnapshotTestDb } from '../../../helpers/db-mock'; import { createUser, createAdmin, type TestUser } from '../../../helpers/factories'; import { findRow, updateRows } from '../../../helpers/factories/rows'; import { resetTestDb } from '../../../helpers/test-db'; import { createTestOrm, type TestOrm } from '../../../helpers/test-orm'; import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'; const testDb = createSnapshotTestDb(); let t: TestOrm; let users: UsersRepository; beforeAll(async () => { t = await createTestOrm(testDb); users = t.repo(Users); }); beforeEach(() => { resetTestDb(testDb); t.clear(); }); afterAll(async () => { await t.close(); testDb.close(); }); /** * Runs `fn` while counting queries MikroORM actually issues over the shared * connection — see `AppSettings.repository.test.ts` for why a value-only * assertion can't catch a regression in the `disableIdentityMap: true` * ruling (Plan 3b Task 1 fix round, `task-1-review.md` B1). */ async function withQueryCount(fn: () => Promise): Promise<{ value: T; queries: number }> { const connection = t.orm.em.getConnection(); const spy = vi.spyOn(connection, 'execute'); try { const value = await fn(); return { value, queries: spy.mock.calls.length }; } finally { spy.mockRestore(); } } describe('UsersRepository', () => { it('USERSREPO-001: getEmail reads the stored email, matching SELECT email FROM users WHERE id = ?', async () => { const { user } = createUser(testDb, { email: 'someone@example.com' }); expect(await users.getEmail(user.id)).toBe('someone@example.com'); const raw = (await findRow(t, Users, { id: user.id })) as { email: string }; expect(await users.getEmail(user.id)).toBe(raw.email); }); it('USERSREPO-002: getEmail returns null for a user id that does not exist', async () => { expect(await users.getEmail(999999)).toBeNull(); }); it('USERSREPO-003: getApiKeyColumn reads maps_api_key, matching SELECT maps_api_key FROM users WHERE id = ?', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { maps_api_key: 'encrypted-maps-key' }); expect(await users.getApiKeyColumn(user.id, 'maps_api_key')).toBe('encrypted-maps-key'); }); it('USERSREPO-004: getApiKeyColumn reads unsplash_api_key, not the other two columns', async () => { const { user } = createUser(testDb); await updateRows( t, Users, { id: user.id }, { maps_api_key: 'maps-value', unsplash_api_key: 'unsplash-value', amap_api_key: 'amap-value' }, ); expect(await users.getApiKeyColumn(user.id, 'unsplash_api_key')).toBe('unsplash-value'); }); it('USERSREPO-005: getApiKeyColumn reads amap_api_key', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { amap_api_key: 'amap-value' }); expect(await users.getApiKeyColumn(user.id, 'amap_api_key')).toBe('amap-value'); }); it('USERSREPO-006: getApiKeyColumn returns null for an unset column and for a missing user', async () => { const { user } = createUser(testDb); expect(await users.getApiKeyColumn(user.id, 'maps_api_key')).toBeNull(); expect(await users.getApiKeyColumn(999999, 'maps_api_key')).toBeNull(); }); // Plan 3b Task 1 fix round (task-1-review.md B1): getEmail/getApiKeyColumn // are primary-key findOne calls, which MikroORM would answer from the // identity map on a repeat call absent `disableIdentityMap: true` — // invisible to a raw UPDATE on the same user id inside the same request. // Pins the fix at one query each; the property is preserved (B1's fix // dropped `refresh: true`, not this guarantee). describe('getEmail/getApiKeyColumn see a raw UPDATE on the same user in the same request (disableIdentityMap regression)', () => { it('USERSREPO-007: a raw UPDATE users SET email then getEmail reads the new email, in one query', async () => { const { user } = createUser(testDb, { email: 'old@example.com' }); expect(await users.getEmail(user.id)).toBe('old@example.com'); // populate the identity map await updateRows(t, Users, { id: user.id }, { email: 'new@example.com' }); const { value, queries } = await withQueryCount(() => users.getEmail(user.id)); expect(value).toBe('new@example.com'); expect(queries).toBe(1); }); it('USERSREPO-008: a raw UPDATE users SET maps_api_key then getApiKeyColumn reads the new value, in one query', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { maps_api_key: 'old-key' }); expect(await users.getApiKeyColumn(user.id, 'maps_api_key')).toBe('old-key'); // populate the identity map await updateRows(t, Users, { id: user.id }, { maps_api_key: 'new-key' }); const { value, queries } = await withQueryCount(() => users.getApiKeyColumn(user.id, 'maps_api_key')); expect(value).toBe('new-key'); expect(queries).toBe(1); }); }); // --------------------------------------------------------------------- // Plan 3b Task 1 — every users-table method the auth/oidc/oauth/tokens // cluster needs (see Users.repository.ts for the legacy-statement mapping // per method). One `it` (or a focused group) per method, on real rows. // --------------------------------------------------------------------- it('USERSREPO-009: findByIdWithPasswordVersion (JV1) reads id/username/email/role/password_version', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { password_version: 3 }); const row = await users.findByIdWithPasswordVersion(user.id); expect(row).toEqual({ id: user.id, username: user.username, email: user.email, role: 'user', password_version: 3 }); expect(await users.findByIdWithPasswordVersion(999999)).toBeNull(); }); it('USERSREPO-009b: findForWsHandshake (Plan 4 Task 1, realtime.gateway.ts) reads id/username/email/role/mfa_enabled/password_version', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { password_version: 3, mfa_enabled: 1 }); const row = await users.findForWsHandshake(user.id); expect(row).toEqual({ id: user.id, username: user.username, email: user.email, role: 'user', mfa_enabled: 1, password_version: 3, }); expect(await users.findForWsHandshake(999999)).toBeNull(); }); it('USERSREPO-009c: findForWsHandshake reports mfa_enabled as null, not 0, for a user who never had it set (Plan 4 Task 1)', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { mfa_enabled: null }); expect((await users.findForWsHandshake(user.id))?.mfa_enabled).toBeNull(); }); it('USERSREPO-010: getPasswordVersion reads password_version, null for a missing user', async () => { const { user } = createUser(testDb); expect(await users.getPasswordVersion(user.id)).toBe(0); await updateRows(t, Users, { id: user.id }, { password_version: 7 }); expect(await users.getPasswordVersion(user.id)).toBe(7); expect(await users.getPasswordVersion(999999)).toBeNull(); }); describe('countNonGuest (AU4/AU7/O10) — is_guest is INTEGER NOT NULL DEFAULT 0, never observed NULL', () => { it('USERSREPO-011: counts only non-guest users', async () => { createUser(testDb); createUser(testDb); const { user: guest } = createUser(testDb); await updateRows(t, Users, { id: guest.id }, { is_guest: 1 }); expect(await users.countNonGuest()).toBe(2); }); it('USERSREPO-012: a NULL is_guest row cannot exist — the column is NOT NULL DEFAULT 0 (verified against the baseline + guest-members migrations), so a direct INSERT that omits the column, or an explicit NULL, both resolve to 0, never leaving a row this filter would miscount', () => { // test-sql-allow: probes the column's NOT NULL DEFAULT 0 itself, below the ORM and its entity defaults. testDb .prepare('INSERT INTO users (username, email, password_hash, role) VALUES (?, ?, ?, ?)') .run('nog', 'nog@test.example.com', 'x', 'user'); // test-sql-allow: probes the column's NOT NULL DEFAULT 0 itself, below the ORM and its entity defaults. const stored = testDb.prepare("SELECT is_guest FROM users WHERE username = 'nog'").get() as { is_guest: number }; expect(stored.is_guest).toBe(0); // the DEFAULT 0, not a nullable column silently coercing // test-sql-allow: probes the column's NOT NULL DEFAULT 0 itself, below the ORM and its entity defaults. expect(() => testDb.prepare('UPDATE users SET is_guest = NULL WHERE username = ?').run('nog')).toThrow( /NOT NULL constraint failed/, ); }); }); it('USERSREPO-013: findAdminNeedingPasswordChange finds an admin flagged must_change_password, ignores a matching non-admin or an unflagged admin', async () => { expect(await users.findAdminNeedingPasswordChange()).toBeNull(); const { user: plainAdmin } = createAdmin(testDb); expect(await users.findAdminNeedingPasswordChange()).toBeNull(); const { user: flaggedUser } = createUser(testDb); await updateRows(t, Users, { id: flaggedUser.id }, { must_change_password: 1 }); expect(await users.findAdminNeedingPasswordChange()).toBeNull(); // not an admin await updateRows(t, Users, { id: plainAdmin.id }, { must_change_password: 1 }); expect(await users.findAdminNeedingPasswordChange()).toBe(plainAdmin.id); }); describe('findIdByEmailOrUsernameCI (AU9)', () => { it('USERSREPO-014: matches by email OR username, case-insensitively, excluding guests', async () => { const { user } = createUser(testDb, { email: 'Someone@Example.com', username: 'SomeoneName' }); expect(await users.findIdByEmailOrUsernameCI('someone@example.com', 'no-match')).toBe(user.id); expect(await users.findIdByEmailOrUsernameCI('no-match@example.com', 'someonename')).toBe(user.id); expect(await users.findIdByEmailOrUsernameCI('nope@example.com', 'nope')).toBeNull(); }); it('USERSREPO-015: excludes a guest even on an exact match', async () => { const { user } = createUser(testDb, { email: 'guest1@example.com', username: 'guest1' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findIdByEmailOrUsernameCI('guest1@example.com', 'guest1')).toBeNull(); }); // Program rule 18 / Plan 3b Task 7 review H1: SQLite's LOWER() is // ASCII-only; JS's toLowerCase() is full-Unicode. Mutation-proved by // reverting the repository's `lowerParam(platform, email)` bind back to // a plain `email.toLowerCase()` — this then fails, because the column // stays folded by SQLite's LOWER() ('josÉ@x.com') while the JS-lowered // bind is 'josé@x.com'. it('USERSREPO-014b: matches the exact stored non-ASCII spelling; a JS-lowered spelling does not match', async () => { const { user } = createUser(testDb, { email: 'JOSÉ@x.com', username: 'plainname' }); expect(await users.findIdByEmailOrUsernameCI('JOSÉ@x.com', 'no-match')).toBe(user.id); expect(await users.findIdByEmailOrUsernameCI('JOSÉ@X.COM', 'no-match')).toBe(user.id); expect(await users.findIdByEmailOrUsernameCI('josé@x.com', 'no-match')).toBeNull(); }); }); describe('insertUser (AU10/O14)', () => { it('USERSREPO-016: local registration shape (AU10) — no oidc/avatar columns', async () => { const row = await users.insertUser({ username: 'localuser', email: 'local@example.com', password_hash: 'hashed', role: 'user', first_seen_version: '1.2.3', }); expect(row.username).toBe('localuser'); expect(row.email).toBe('local@example.com'); expect(row.password_hash).toBe('hashed'); expect(row.role).toBe('user'); expect(row.first_seen_version).toBe('1.2.3'); expect(row.login_count).toBe(0); expect(row.oidc_sub).toBeNull(); expect(row.oidc_issuer).toBeNull(); expect(row.avatar).toBeNull(); expect(row.created_at).not.toBeNull(); const raw = await findRow(t, Users, { id: row.id }); expect(raw).toMatchObject({ username: 'localuser', email: 'local@example.com', role: 'user', login_count: 0 }); }); it('USERSREPO-016b: the self-set email mark is 0 unless the caller names it', async () => { const base = { password_hash: 'hashed', role: 'user', first_seen_version: '1.2.3' }; const plain = await users.insertUser({ ...base, username: 'plainmark', email: 'plain@example.com' }); const own = await users.insertUser({ ...base, username: 'ownmark', email: 'own@example.com', email_self_asserted: 1, }); expect(plain.email_self_asserted).toBe(0); expect(own.email_self_asserted).toBe(1); }); it('USERSREPO-017: SSO registration shape (O14) — oidc_sub/oidc_issuer/avatar set', async () => { const row = await users.insertUser({ username: 'ssouser', email: 'sso@example.com', password_hash: 'unusable-hash', role: 'admin', first_seen_version: '1.2.3', oidc_sub: 'sub-123', oidc_issuer: 'https://idp.example.com', avatar: 'https://idp.example.com/pic.png', }); expect(row.oidc_sub).toBe('sub-123'); expect(row.oidc_issuer).toBe('https://idp.example.com'); expect(row.avatar).toBe('https://idp.example.com/pic.png'); expect(row.role).toBe('admin'); expect(row.login_count).toBe(0); }); it('USERSREPO-057: insertUser (F2) never flushes an unrelated pending entity in the same EM', async () => { // Simulate an unrelated pending change elsewhere in the request's EM — // a managed entity persist()-ed but not yet flushed by its own code // path. Before F2's fix, `insertUser`'s `persist().flush()` committed // the WHOLE unit of work, so this row would land in the DB too. const pending = t.em.create(Users, { username: 'pending-unflushed', email: 'pending@example.com', password_hash: 'x', role: 'user', first_seen_version: '9.9.9', login_count: 0, }); t.em.persist(pending); await users.insertUser({ username: 'freshuser', email: 'fresh@example.com', password_hash: 'hashed', role: 'user', first_seen_version: '1.2.3', }); // test-sql-allow: reads the table directly, so no EntityManager can flush the pending entity first. const pendingRow = testDb.prepare('SELECT * FROM users WHERE username = ?').get('pending-unflushed'); expect(pendingRow).toBeUndefined(); // insertUser must not have flushed it // test-sql-allow: reads the table directly, so no EntityManager can flush the pending entity first. const freshRow = testDb.prepare('SELECT * FROM users WHERE username = ?').get('freshuser'); expect(freshRow).toBeDefined(); // but the intended row is there t.em.clear(); // discard the still-pending unflushed entity before the next test }); it('USERSREPO-057D: throws when the read-back after insert finds no row (coverage: the guard branch)', async () => { const spy = vi.spyOn(users, 'findById').mockResolvedValueOnce(null); await expect( users.insertUser({ username: 'ghostuser', email: 'ghost@example.com', password_hash: 'hashed', role: 'user', first_seen_version: '1.2.3', }), ).rejects.toThrow('insertUser: read-back after insert found no row'); spy.mockRestore(); }); }); describe('findByEmailCI (AU12) — AuthService.loginUser', () => { it('USERSREPO-018: matches case-insensitively, excludes guests, returns the full row', async () => { const { user } = createUser(testDb, { email: 'Case.Test@Example.com' }); const row = await users.findByEmailCI('case.test@example.com'); expect(row?.id).toBe(user.id); expect(row?.username).toBe(user.username); expect(await users.findByEmailCI('nope@example.com')).toBeNull(); }); it('USERSREPO-019: a guest with a matching email is not returned', async () => { const { user } = createUser(testDb, { email: 'guest2@example.com' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findByEmailCI('guest2@example.com')).toBeNull(); }); // Program rule 18 / Plan 3b Task 7 review H1. Mutation-proved by // reverting the repository's `lowerParam(platform, email)` bind back to // `email.toLowerCase()` — then USERSREPO-018b's second assertion fails // (401 lockout reproduced at the repository level: the exact stored // spelling stops matching). it('USERSREPO-018b: matches the exact stored non-ASCII spelling; a JS-lowered spelling does not match', async () => { const { user } = createUser(testDb, { email: 'JOSÉ@x.com' }); const exact = await users.findByEmailCI('JOSÉ@x.com'); expect(exact?.id).toBe(user.id); const asciiRecase = await users.findByEmailCI('JOSÉ@X.COM'); expect(asciiRecase?.id).toBe(user.id); expect(await users.findByEmailCI('josé@x.com')).toBeNull(); }); }); describe('findByEmailLoweredBind (O4) — OidcService.findOrCreateUser, caller already JS-lowers', () => { it('USERSREPO-018c: matches an already-lowered bind against a mixed-case stored email, excludes guests', async () => { const { user } = createUser(testDb, { email: 'Case.Test@Example.com' }); const row = await users.findByEmailLoweredBind('case.test@example.com'); expect(row?.id).toBe(user.id); expect(await users.findByEmailLoweredBind('nope@example.com')).toBeNull(); }); it('USERSREPO-018d: a guest with a matching email is not returned', async () => { const { user } = createUser(testDb, { email: 'guest2b@example.com' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findByEmailLoweredBind('guest2b@example.com')).toBeNull(); }); // O4's own legacy shape: `LOWER(email) = ?` — SQLite only lowers the // COLUMN; the caller's already-lowered bind is compared as-is. A stored // non-ASCII email folds to 'josÉ@x.com' under SQLite's ASCII-only // LOWER(); a JS-lowered bind of the exact same spelling is // 'josé@x.com' — genuinely different strings, so THIS method correctly // does not match it. That is O4's real (pre-existing, unchanged) // behaviour, not a regression — findByEmailCI above is the method // OidcService's non-JS-lowered callers must use instead. it('USERSREPO-018e: a JS-lowered bind against a non-ASCII stored email does not match (this is O4 parity, not a bug)', async () => { createUser(testDb, { email: 'JOSÉ@x.com' }); expect(await users.findByEmailLoweredBind('josé@x.com')).toBeNull(); }); }); // Plan 3b Task 1 fix round item 7 — AuthService.demoLogin's exact statement // (`SELECT * FROM users WHERE email = ?`), missing from the inventory, // added now so Task 5 has it. describe('findByEmailExact (AuthService.demoLogin, inventory correction)', () => { it('USERSREPO-057B: matches only the exact case, unlike every other email lookup here', async () => { const { user } = createUser(testDb, { email: 'Demo.User@Example.com' }); const row = await users.findByEmailExact('Demo.User@Example.com'); expect(row?.id).toBe(user.id); expect(await users.findByEmailExact('demo.user@example.com')).toBeNull(); // different case — no match expect(await users.findByEmailExact('nope@example.com')).toBeNull(); }); it('USERSREPO-057C: a guest row IS returned — no guest filter, unlike findByEmailCI/findForPasswordReset', async () => { const { user } = createUser(testDb, { email: 'demoguest@example.com' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); const row = await users.findByEmailExact('demoguest@example.com'); expect(row?.id).toBe(user.id); }); }); describe('touchLastLogin (AU13/AU34/AU35/PK12/O16)', () => { it('USERSREPO-020: bumps login_count by exactly 1 and stamps last_login, in one statement', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { login_count: 5 }); await users.touchLastLogin(user.id); const row = (await findRow(t, Users, { id: user.id })) as { login_count: number; last_login: string }; expect(row.login_count).toBe(6); expect(row.last_login).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/); }); it('USERSREPO-021: two concurrent calls both land — +2, never +1 (no read-modify-write)', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { login_count: 10 }); await Promise.all([users.touchLastLogin(user.id), users.touchLastLogin(user.id)]); const row = (await findRow(t, Users, { id: user.id })) as { login_count: number }; expect(row.login_count).toBe(12); }); }); it('USERSREPO-022: findMeRow (AU14) reads the /api/auth/me projection', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { avatar: 'pic.png', mfa_enabled: 1, must_change_password: 1 }); const row = await users.findMeRow(user.id); expect(row).toMatchObject({ id: user.id, username: user.username, email: user.email, role: 'user', avatar: 'pic.png', mfa_enabled: 1, must_change_password: 1, }); expect(row?.created_at).not.toBeNull(); expect(await users.findMeRow(999999)).toBeNull(); }); it('USERSREPO-022b: findMeRow — every nullable column comes back null, not undefined, when NULL in the row (coverage: rule 16)', async () => { const { user } = createUser(testDb); await updateRows( t, Users, { id: user.id }, { avatar: null, oidc_issuer: null, created_at: null, mfa_enabled: null, must_change_password: null }, ); const row = await users.findMeRow(user.id); expect(row?.avatar).toBeNull(); expect(row?.oidc_issuer).toBeNull(); expect(row?.created_at).toBeNull(); expect(row?.mfa_enabled).toBeNull(); expect(row?.must_change_password).toBeNull(); }); it('USERSREPO-023: getPasswordHashAndVersion (AU15) reads both columns together', async () => { const { user, password: _password } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { password_version: 2 }); const row = await users.getPasswordHashAndVersion(user.id); expect(row?.password_hash).toBe(user.password_hash); expect(row?.password_version).toBe(2); }); it('USERSREPO-023b: getPasswordHashAndVersion returns null for a missing user', async () => { expect(await users.getPasswordHashAndVersion(999999)).toBeNull(); }); it('USERSREPO-024: setPassword (AU16/AU43) writes hash+version, clears must_change_password, stamps updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { must_change_password: 1 }); await users.setPassword(user.id, 'new-hash', 5); const row = (await findRow(t, Users, { id: user.id })) as { password_hash: string; password_version: number; must_change_password: number; updated_at: string; }; expect(row.password_hash).toBe('new-hash'); expect(row.password_version).toBe(5); expect(row.must_change_password).toBe(0); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); it('USERSREPO-025: countAdmins (AU19/O7) counts only role=admin', async () => { createUser(testDb); createAdmin(testDb); createAdmin(testDb); expect(await users.countAdmins()).toBe(2); }); it('USERSREPO-026: getRole (AU20/AU22) reads the role column', async () => { const { user } = createAdmin(testDb); expect(await users.getRole(user.id)).toBe('admin'); expect(await users.getRole(999999)).toBeNull(); }); describe('getMfaEnabled (AU23/AU27/MP2) — distinguishes "no row" from "row present, mfa_enabled unset"', () => { it('USERSREPO-027: returns the row wrapper when the user exists', async () => { const { user } = createUser(testDb); expect(await users.getMfaEnabled(user.id)).toEqual({ mfa_enabled: 0 }); await updateRows(t, Users, { id: user.id }, { mfa_enabled: 1 }); expect(await users.getMfaEnabled(user.id)).toEqual({ mfa_enabled: 1 }); }); it('USERSREPO-028: returns null (not a row with a null field) when the user does not exist', async () => { expect(await users.getMfaEnabled(999999)).toBeNull(); }); it('USERSREPO-028b: mfa_enabled NULL on the row comes back null on the wrapper (coverage: rule 16)', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { mfa_enabled: null }); expect(await users.getMfaEnabled(user.id)).toEqual({ mfa_enabled: null }); }); }); it('USERSREPO-029: enableMfa (AU28) sets mfa_enabled=1, writes the already-encrypted secret and codes, stamps updated_at', async () => { const { user } = createUser(testDb); await users.enableMfa(user.id, 'encrypted-secret', '["hash1","hash2"]'); const row = (await findRow(t, Users, { id: user.id })) as { mfa_enabled: number; mfa_secret: string; mfa_backup_codes: string; updated_at: string; }; expect(row.mfa_enabled).toBe(1); expect(row.mfa_secret).toBe('encrypted-secret'); expect(row.mfa_backup_codes).toBe('["hash1","hash2"]'); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); describe('findById (AU30/AU32/PK4/PK10/O15) — full row, PK-only findOne', () => { it('USERSREPO-030: reads every scalar column', async () => { const { user } = createUser(testDb); const row = await users.findById(user.id); expect(row?.id).toBe(user.id); expect(row?.username).toBe(user.username); expect(row?.password_hash).toBe(user.password_hash); expect(await users.findById(999999)).toBeNull(); }); it('USERSREPO-031: sees a raw UPDATE on the same id in the same request (disableIdentityMap regression)', async () => { const { user } = createUser(testDb, { username: 'before' }); await users.findById(user.id); // populate the identity map await updateRows(t, Users, { id: user.id }, { username: 'after' }); const { value, queries } = await withQueryCount(() => users.findById(user.id)); expect(value?.username).toBe('after'); expect(queries).toBe(1); }); }); it('USERSREPO-032: disableMfa (AU31) clears mfa_enabled/secret/codes, stamps updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { mfa_enabled: 1, mfa_secret: 's', mfa_backup_codes: 'c' }); await users.disableMfa(user.id); const row = (await findRow(t, Users, { id: user.id })) as { mfa_enabled: number; mfa_secret: string | null; mfa_backup_codes: string | null; updated_at: string; }; expect(row.mfa_enabled).toBe(0); expect(row.mfa_secret).toBeNull(); expect(row.mfa_backup_codes).toBeNull(); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); describe('setBackupCodesAndTouch (AU33) vs setBackupCodes (AU44) — one stamps updated_at, the other does not', () => { it('USERSREPO-033: setBackupCodesAndTouch writes codes and stamps updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.setBackupCodesAndTouch(user.id, '["a"]'); const row = (await findRow(t, Users, { id: user.id })) as { mfa_backup_codes: string; updated_at: string }; expect(row.mfa_backup_codes).toBe('["a"]'); expect(row.updated_at).not.toBe('2020-01-01 00:00:00'); }); it('USERSREPO-034: setBackupCodes writes codes WITHOUT touching updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.setBackupCodes(user.id, '["b"]'); const row = (await findRow(t, Users, { id: user.id })) as { mfa_backup_codes: string; updated_at: string }; expect(row.mfa_backup_codes).toBe('["b"]'); expect(row.updated_at).toBe('2020-01-01 00:00:00'); }); }); describe('findForPasswordReset (AU36): case-insensitive, like login', () => { it('USERSREPO-035: finds an address stored with capitals from the lowercased input the service passes', async () => { const { user } = createUser(testDb, { email: 'Exact@Example.com' }); expect((await users.findForPasswordReset('exact@example.com'))?.id).toBe(user.id); expect((await users.findForPasswordReset('Exact@Example.com'))?.id).toBe(user.id); expect(await users.findForPasswordReset('other@example.com')).toBeNull(); }); it('USERSREPO-036: excludes a guest', async () => { const { user } = createUser(testDb, { email: 'guest3@example.com' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findForPasswordReset('guest3@example.com')).toBeNull(); }); it('USERSREPO-036b: oidc_sub NULL on the row comes back null, not undefined (coverage: rule 16)', async () => { const { user } = createUser(testDb, { email: 'reset-null@example.com' }); await updateRows(t, Users, { id: user.id }, { oidc_sub: null }); const row = await users.findForPasswordReset('reset-null@example.com'); expect(row?.oidc_sub).toBeNull(); }); }); it('USERSREPO-037: findResetTarget (AU40) reads the reset-branch projection', async () => { const { user } = createUser(testDb); await updateRows( t, Users, { id: user.id }, { mfa_enabled: 1, mfa_secret: 's', mfa_backup_codes: 'c', password_version: 4 }, ); const row = await users.findResetTarget(user.id); expect(row).toEqual({ id: user.id, email: user.email, mfa_enabled: 1, mfa_secret: 's', mfa_backup_codes: 'c', password_version: 4, }); }); it('USERSREPO-037b: findResetTarget — mfa_enabled/mfa_secret/mfa_backup_codes NULL come back null, not undefined (coverage: rule 16)', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { mfa_enabled: null, mfa_secret: null, mfa_backup_codes: null }); const row = await users.findResetTarget(user.id); expect(row?.mfa_enabled).toBeNull(); expect(row?.mfa_secret).toBeNull(); expect(row?.mfa_backup_codes).toBeNull(); }); it('USERSREPO-037c: findResetTarget returns null for a missing user', async () => { expect(await users.findResetTarget(999999)).toBeNull(); }); it('USERSREPO-038: getPasswordHash (PK15) reads password_hash', async () => { const { user } = createUser(testDb); expect(await users.getPasswordHash(user.id)).toBe(user.password_hash); expect(await users.getPasswordHash(999999)).toBeNull(); }); it('USERSREPO-039: findIdAndEmail (PK17) reads id+email', async () => { const { user } = createUser(testDb); expect(await users.findIdAndEmail(user.id)).toEqual({ id: user.id, email: user.email }); }); describe('findByOidcIdentity (O3)', () => { it('USERSREPO-040: matches on the (sub, issuer) pair', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { oidc_sub: 'sub-1', oidc_issuer: 'https://idp.example.com' }); const row = await users.findByOidcIdentity('sub-1', 'https://idp.example.com'); expect(row?.id).toBe(user.id); expect(await users.findByOidcIdentity('sub-1', 'https://other-idp.example.com')).toBeNull(); }); }); it('USERSREPO-041: linkOidcIdentity (O5/O6) writes sub+issuer WITHOUT touching updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.linkOidcIdentity(user.id, 'sub-2', 'https://idp2.example.com'); const row = (await findRow(t, Users, { id: user.id })) as { oidc_sub: string; oidc_issuer: string; updated_at: string; }; expect(row.oidc_sub).toBe('sub-2'); expect(row.oidc_issuer).toBe('https://idp2.example.com'); expect(row.updated_at).toBe('2020-01-01 00:00:00'); }); it('USERSREPO-042: setRole (O8) writes role WITHOUT touching updated_at', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.setRole(user.id, 'admin'); const row = (await findRow(t, Users, { id: user.id })) as { role: string; updated_at: string }; expect(row.role).toBe('admin'); expect(row.updated_at).toBe('2020-01-01 00:00:00'); }); it('USERSREPO-043: setAvatarRaw (O9) writes avatar WITHOUT touching updated_at, unlike setAvatar', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.setAvatarRaw(user.id, 'https://idp.example.com/pic.png'); const row = (await findRow(t, Users, { id: user.id })) as { avatar: string; updated_at: string }; expect(row.avatar).toBe('https://idp.example.com/pic.png'); expect(row.updated_at).toBe('2020-01-01 00:00:00'); }); describe('findIdByUsernameCI (UP5) vs findIdByUsernameCIAny (O12) — different WHERE, two methods', () => { it('USERSREPO-044: findIdByUsernameCI excludes the given id and any guest', async () => { const { user: a } = createUser(testDb, { username: 'DupeName' }); const { user: b } = createUser(testDb, { username: 'other' }); expect(await users.findIdByUsernameCI('dupename', b.id)).toBe(a.id); expect(await users.findIdByUsernameCI('dupename', a.id)).toBeNull(); // excludes self await updateRows(t, Users, { id: a.id }, { is_guest: 1 }); expect(await users.findIdByUsernameCI('dupename', b.id)).toBeNull(); // guest excluded }); it('USERSREPO-045: findIdByUsernameCIAny has no exclude and no guest filter', async () => { const { user } = createUser(testDb, { username: 'AnyName' }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findIdByUsernameCIAny('anyname')).toBe(user.id); // a guest still matches here }); // Program rule 18 / Plan 3b Task 7 review H1. Mutation-proved by // reverting each method's `lowerParam(platform, username)` bind back to // `username.toLowerCase()` — the exact-spelling assertion then fails. it('USERSREPO-044b: findIdByUsernameCI matches the exact stored non-ASCII spelling; a JS-lowered spelling does not match', async () => { const { user: a } = createUser(testDb, { username: 'ÄNNA' }); const { user: b } = createUser(testDb, { username: 'other2' }); expect(await users.findIdByUsernameCI('ÄNNA', b.id)).toBe(a.id); expect(await users.findIdByUsernameCI('änna', b.id)).toBeNull(); }); it('USERSREPO-045b: findIdByUsernameCIAny matches the exact stored non-ASCII spelling; a JS-lowered spelling does not match', async () => { const { user } = createUser(testDb, { username: 'ÄNNA2' }); expect(await users.findIdByUsernameCIAny('ÄNNA2')).toBe(user.id); expect(await users.findIdByUsernameCIAny('änna2')).toBeNull(); }); }); it('USERSREPO-046: getApiKeyColumns (UP1) reads role + the four key columns', async () => { const { user } = createAdmin(testDb); await updateRows( t, Users, { id: user.id }, { maps_api_key: 'm', openweather_api_key: 'o', unsplash_api_key: 'u', amap_api_key: 'a' }, ); expect(await users.getApiKeyColumns(user.id)).toEqual({ role: 'admin', maps_api_key: 'm', openweather_api_key: 'o', unsplash_api_key: 'u', amap_api_key: 'a', }); }); it('USERSREPO-046b: getApiKeyColumns returns null for a missing user; NULL columns come back null (coverage: rule 16)', async () => { expect(await users.getApiKeyColumns(999999)).toBeNull(); const { user } = createUser(testDb); // maps_api_key/openweather_api_key/unsplash_api_key/amap_api_key are NULL by default on a fresh user. expect(await users.getApiKeyColumns(user.id)).toEqual({ role: 'user', maps_api_key: null, openweather_api_key: null, unsplash_api_key: null, amap_api_key: null, }); }); it('USERSREPO-047: updateMapsKey (UP2) writes maps_api_key + updated_at', async () => { const { user } = createUser(testDb); await users.updateMapsKey(user.id, 'encrypted'); const row = (await findRow(t, Users, { id: user.id })) as { maps_api_key: string; updated_at: string }; expect(row.maps_api_key).toBe('encrypted'); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); it('USERSREPO-048: updateApiKeys (UP3) writes all four columns + updated_at in one statement', async () => { const { user } = createUser(testDb); await users.updateApiKeys(user.id, { maps_api_key: 'm2', openweather_api_key: 'o2', unsplash_api_key: 'u2', amap_api_key: null, }); const row = (await findRow(t, Users, { id: user.id })) as Record; expect(row).toMatchObject({ maps_api_key: 'm2', openweather_api_key: 'o2', unsplash_api_key: 'u2', amap_api_key: null, }); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); it('USERSREPO-049: findProfileWithKeys (UP4/UP8) reads the profile-with-keys projection', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { maps_api_key: 'm', mfa_enabled: 1 }); const row = await users.findProfileWithKeys(user.id); expect(row).toMatchObject({ id: user.id, username: user.username, email: user.email, role: 'user', maps_api_key: 'm', mfa_enabled: 1, }); }); it('USERSREPO-049b: findProfileWithKeys returns null for a missing user; every nullable column comes back null (coverage: rule 16)', async () => { expect(await users.findProfileWithKeys(999999)).toBeNull(); const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { mfa_enabled: null }); const row = await users.findProfileWithKeys(user.id); expect(row).toMatchObject({ maps_api_key: null, openweather_api_key: null, unsplash_api_key: null, amap_api_key: null, avatar: null, mfa_enabled: null, }); }); it('USERSREPO-050: findIdByEmailCI (UP6) matches case-insensitively, excludes self and guests', async () => { const { user: a } = createUser(testDb, { email: 'Dup@Example.com' }); const { user: b } = createUser(testDb, { email: 'other@example.com' }); expect(await users.findIdByEmailCI('dup@example.com', b.id)).toBe(a.id); expect(await users.findIdByEmailCI('dup@example.com', a.id)).toBeNull(); }); // Program rule 18 / Plan 3b Task 7 review H1 (UP6 profile-rename collision // case). Mutation-proved by reverting `lowerParam(platform, email)` back // to `email.toLowerCase()` — the exact-spelling assertion then fails. it('USERSREPO-050b: findIdByEmailCI matches the exact stored non-ASCII spelling; a JS-lowered spelling does not match', async () => { const { user: a } = createUser(testDb, { email: 'JOSÉ2@x.com' }); const { user: b } = createUser(testDb, { email: 'other2@example.com' }); expect(await users.findIdByEmailCI('JOSÉ2@x.com', b.id)).toBe(a.id); expect(await users.findIdByEmailCI('josé2@x.com', b.id)).toBeNull(); }); it('USERSREPO-051: patchProfile (UP7) writes only the given bounded columns + updated_at, in one statement', async () => { const { user } = createUser(testDb, { username: 'patchme', email: 'patchme@example.com' }); await users.patchProfile(user.id, { username: 'patched', maps_api_key: 'newkey' }); const row = (await findRow(t, Users, { id: user.id })) as Record; expect(row.username).toBe('patched'); expect(row.email).toBe('patchme@example.com'); // untouched — not in `changes` expect(row.maps_api_key).toBe('newkey'); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); }); describe('getAvatar (UP9/UP12) / setAvatar (UP10/UP13)', () => { it('USERSREPO-052: getAvatar reads the avatar column', async () => { const { user } = createUser(testDb); expect(await users.getAvatar(user.id)).toBeNull(); await updateRows(t, Users, { id: user.id }, { avatar: 'pic.png' }); expect(await users.getAvatar(user.id)).toBe('pic.png'); }); it('USERSREPO-053: setAvatar writes avatar + updated_at (both a filename and NULL for delete)', async () => { const { user } = createUser(testDb); await users.setAvatar(user.id, 'new.png'); let row = (await findRow(t, Users, { id: user.id })) as { avatar: string; updated_at: string }; expect(row.avatar).toBe('new.png'); expect(row.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}/); await updateRows(t, Users, { id: user.id }, { updated_at: '2020-01-01 00:00:00' }); await users.setAvatar(user.id, null); row = (await findRow(t, Users, { id: user.id })) as { avatar: string | null; updated_at: string }; expect(row.avatar).toBeNull(); expect(row.updated_at).not.toBe('2020-01-01 00:00:00'); }); }); it('USERSREPO-054: findProfileBasic (UP11) reads id/username/email/role/avatar', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { avatar: 'a.png' }); expect(await users.findProfileBasic(user.id)).toEqual({ id: user.id, username: user.username, email: user.email, role: 'user', avatar: 'a.png', }); }); it('USERSREPO-054b: findProfileBasic returns null for a missing user; NULL avatar comes back null (coverage: rule 16)', async () => { expect(await users.findProfileBasic(999999)).toBeNull(); const { user } = createUser(testDb); expect((await users.findProfileBasic(user.id))?.avatar).toBeNull(); }); describe('listOthersNonGuest (UP14)', () => { it('USERSREPO-055: excludes the given id and every guest, ordered by username', async () => { const { user: me } = createUser(testDb, { username: 'me' }); const { user: bravo } = createUser(testDb, { username: 'bravo' }); const { user: alpha } = createUser(testDb, { username: 'alpha' }); const { user: guest } = createUser(testDb, { username: 'zzz-guest' }); await updateRows(t, Users, { id: guest.id }, { is_guest: 1 }); const rows = await users.listOthersNonGuest(me.id); expect(rows.map((r) => r.id)).toEqual([alpha.id, bravo.id]); }); }); it('USERSREPO-056: getRoleAndWeatherKey (UP15) reads role + openweather_api_key', async () => { const { user } = createAdmin(testDb); await updateRows(t, Users, { id: user.id }, { openweather_api_key: 'w' }); expect(await users.getRoleAndWeatherKey(user.id)).toEqual({ role: 'admin', openweather_api_key: 'w' }); }); it('USERSREPO-056b: getRoleAndWeatherKey returns null for a missing user; NULL key comes back null (coverage: rule 16)', async () => { expect(await users.getRoleAndWeatherKey(999999)).toBeNull(); const { user } = createUser(testDb); expect(await users.getRoleAndWeatherKey(user.id)).toEqual({ role: 'user', openweather_api_key: null }); }); it('USERSREPO-058: deleteById (UC11) deletes the row', async () => { const { user } = createUser(testDb); await users.deleteById(user.id); expect(await findRow(t, Users, { id: user.id })).toBeNull(); }); }); // --------------------------------------------------------------------------- // Plan 3c Task 6 — TripMembersService's guest lifecycle (TM3/TM4/TM10/TM16/ // TM19/TM20). Appended after the existing `describe('UsersRepository', ...)` // block per this task's file-ownership rule (additive methods only). // --------------------------------------------------------------------------- describe('UsersRepository — TripMembersService (Plan 3c Task 6)', () => { describe('findOwnerSummary (TM3)', () => { it('USERSREPO-059: prefers display_name over username, matching the legacy COALESCE', async () => { const { user } = createUser(testDb, { username: 'raw-handle' }); await updateRows(t, Users, { id: user.id }, { display_name: 'Displayed Name' }); expect(await users.findOwnerSummary(user.id)).toEqual({ id: user.id, username: 'Displayed Name', email: user.email, avatar: null, }); }); it('USERSREPO-060: falls back to username when display_name is NULL; a missing user id is null, not a throw', async () => { const { user } = createUser(testDb, { username: 'bare-handle' }); expect(await users.findOwnerSummary(user.id)).toEqual({ id: user.id, username: 'bare-handle', email: user.email, avatar: null, }); expect(await users.findOwnerSummary(999999)).toBeNull(); }); it('USERSREPO-061: a NULL avatar comes back null, not undefined (rule 16)', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { avatar: 'me.png' }); expect((await users.findOwnerSummary(user.id))?.avatar).toBe('me.png'); }); // Task 9 fix wave (B-M3): relabelled. `findOwnerSummary` is a // `qb().execute('get', false)` projection, which never hydrates an // entity into the identity map by construction, and the base default // leaves the identity map disabled for every read anyway — there is no // live identity-map entry here to bypass. This proves a DB round-trip, // not an identity-map bypass. The FIRST, wider setup read still passes // `{ disableIdentityMap: false }` explicitly per the program rule. it('USERSREPO-062 (fresh after a raw UPDATE, not D-shape): a display_name written after an unrelated identity-map read is visible in the FIRST wider projection', async () => { const { user } = createUser(testDb, { username: 'fresh-owner' }); await t.repo(Users).find({}, { disableIdentityMap: false }); // populate the identity map with an unrelated read await updateRows(t, Users, { id: user.id }, { display_name: 'Fresh Name' }); expect(await users.findOwnerSummary(user.id)).toEqual({ id: user.id, username: 'Fresh Name', email: user.email, avatar: null, }); }); }); describe('findInvitableByEmailOrUsername (TM4)', () => { // Task 9 fix wave (B-L7): the legacy statement TM4's docstring quotes, // run raw on the same fixture — `toEqual(legacy)` on the FULL key set, // so a renamed or dropped column would fail this, not just the // literal-object assertion below (rule 19; #1362 is security-relevant, // so this is one of the L7 reads the fix wave covers). const legacyInvitable = (identifier: string) => // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. testDb .prepare( 'SELECT id, username, email, avatar FROM users WHERE (email = ? OR username = ?) AND COALESCE(is_guest, 0) = 0', ) .get(identifier, identifier) ?? null; it('USERSREPO-063: matches on email OR username, case-SENSITIVE (unlike findByEmailCI/findIdByEmailCI above)', async () => { const { user: byEmail } = createUser(testDb, { email: 'invitee@example.test', username: 'invitee-handle' }); expect(await users.findInvitableByEmailOrUsername('invitee@example.test')).toEqual({ id: byEmail.id, username: 'invitee-handle', email: 'invitee@example.test', avatar: null, }); expect(await users.findInvitableByEmailOrUsername('invitee@example.test')).toEqual( legacyInvitable('invitee@example.test'), ); expect(await users.findInvitableByEmailOrUsername('invitee-handle')).toEqual({ id: byEmail.id, username: 'invitee-handle', email: 'invitee@example.test', avatar: null, }); expect(await users.findInvitableByEmailOrUsername('invitee-handle')).toEqual(legacyInvitable('invitee-handle')); // Case-sensitive: an uppercased email must NOT match (program rule 18 // only applies where the legacy statement itself folds case — TM4's does not). expect(await users.findInvitableByEmailOrUsername('INVITEE@EXAMPLE.TEST')).toBeNull(); expect(legacyInvitable('INVITEE@EXAMPLE.TEST')).toBeNull(); }); it('USERSREPO-064: excludes guests — a trip-scoped guest can never be re-invited through the box', async () => { const { user: guest } = createUser(testDb, { email: 'guest-look@example.test', username: 'guest-handle' }); await updateRows(t, Users, { id: guest.id }, { is_guest: 1 }); expect(await users.findInvitableByEmailOrUsername('guest-look@example.test')).toBeNull(); expect(await users.findInvitableByEmailOrUsername('guest-handle')).toBeNull(); }); it('USERSREPO-065: no match returns null, not a throw', async () => { expect(await users.findInvitableByEmailOrUsername('nobody@example.test')).toBeNull(); }); // Task 9 fix wave (B-M3): relabelled — this comment previously claimed // rule 20's PK-only D-shape guarantee "applies for real", but // `findInvitableByEmailOrUsername` filters `findOne` on `{$or: // [{email},{username}], is_guest}`, not the primary key (rule 20 draws // that PK-only line precisely because a non-PK filter always re-runs // the WHERE clause against the live table, so it can never serve a // stale identity-map snapshot the way a PK lookup can). What this DOES // prove, honestly: a row that flips `is_guest` after an unrelated wider // identity-map read is fresh here — the guest-exclusion guard (#1362) // sees the current value, not a cached one. it('USERSREPO-072 (fresh after a raw UPDATE, not D-shape): an is_guest flip written after an unrelated identity-map read is visible in the FIRST wider projection', async () => { const { user } = createUser(testDb, { email: 'flip@example.test', username: 'flip-handle' }); await t.repo(Users).find({}, { disableIdentityMap: false }); // populate the identity map with an unrelated read await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findInvitableByEmailOrUsername('flip@example.test')).toBeNull(); }); }); describe('findIdEmailGuest (TM10)', () => { it('USERSREPO-066: reads id/email/is_guest; a missing user is null', async () => { const { user } = createUser(testDb, { email: 'target@example.test' }); expect(await users.findIdEmailGuest(user.id)).toEqual({ id: user.id, email: 'target@example.test', is_guest: 0 }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); expect(await users.findIdEmailGuest(user.id)).toEqual({ id: user.id, email: 'target@example.test', is_guest: 1 }); expect(await users.findIdEmailGuest(999999)).toBeNull(); }); // Task 9 fix wave (B-M3): `findIdEmailGuest` is the third PK-only // `findOne` this plan added (`{ id }` alone, nothing else) — a genuine // rule 20/21 D-shape case, the TM10 guest gate. USERSREPO-066 above // already catches the M7 identity-map-default mutation (it re-reads // after a raw UPDATE without an intervening wider read), but the review // asked for the explicit labelled case anyway. it('USERSREPO-073 (D-shape): an is_guest flip written after an unrelated identity-map read is visible in the next findIdEmailGuest call, in one query (disableIdentityMap regression)', async () => { const { user } = createUser(testDb, { email: 'guest-gate@example.test' }); // rule 20: the FIRST, wider setup read passes `disableIdentityMap: // false` explicitly and carries the column the later write targets // (`is_guest`) — a PK-only `findOne` on `id` alone, the exact shape // `findIdEmailGuest` itself uses. await t.repo(Users).findOne({ id: user.id }, { disableIdentityMap: false }); await updateRows(t, Users, { id: user.id }, { is_guest: 1 }); const { value, queries } = await withQueryCount(() => users.findIdEmailGuest(user.id)); expect(value).toEqual({ id: user.id, email: 'guest-gate@example.test', is_guest: 1 }); expect(queries).toBe(1); }); }); describe('insertGuest (TM16, security-sensitive)', () => { it('USERSREPO-067: writes the fixed literal columns and the given display_name; returns the generated id', async () => { const id = await users.insertGuest({ username: 'guest-abc', email: 'guest-abc@guests.invalid', display_name: 'Ida', }); const row = await findRow(t, Users, { id }); expect(row).toMatchObject({ username: 'guest-abc', email: 'guest-abc@guests.invalid', password_hash: '', role: 'user', is_guest: 1, display_name: 'Ida', }); }); }); describe('renameGuest / deleteGuest (TM19/TM20, security-sensitive, belt-and-braces is_guest = 1)', () => { it('USERSREPO-068: renameGuest updates display_name + updated_at only for an is_guest = 1 row', async () => { const id = await users.insertGuest({ username: 'guest-rn', email: 'guest-rn@guests.invalid', display_name: 'Old', }); await users.renameGuest(id, 'New Name'); const row = (await findRow(t, Users, { id })) as { display_name: string; updated_at: string | null }; expect(row.display_name).toBe('New Name'); expect(row.updated_at).not.toBeNull(); }); it('USERSREPO-069: renameGuest is a no-op on a real (non-guest) user id — the belt-and-braces predicate, pinned', async () => { const { user } = createUser(testDb, { username: 'real-user' }); await updateRows(t, Users, { id: user.id }, { display_name: 'Untouched' }); await users.renameGuest(user.id, 'Attempted Rename'); expect(((await findRow(t, Users, { id: user.id })) as { display_name: string }).display_name).toBe('Untouched'); }); it('USERSREPO-070: deleteGuest removes only an is_guest = 1 row', async () => { const id = await users.insertGuest({ username: 'guest-del', email: 'guest-del@guests.invalid', display_name: 'Gone', }); await users.deleteGuest(id); expect(await findRow(t, Users, { id })).toBeNull(); }); it('USERSREPO-071: deleteGuest is a no-op on a real (non-guest) user id — the belt-and-braces predicate, pinned', async () => { const { user } = createUser(testDb, { username: 'real-user-2' }); await users.deleteGuest(user.id); expect(await findRow(t, Users, { id: user.id })).not.toBeNull(); }); }); }); // ── Plan 3d Task 5 (FeedsService) — additive: FD5-FD8/FD10, the all-trips ICS // feed token's `users` half. Each `toEqual` pins full parity against the // legacy statement run raw on the same row, per the task's own ruling. describe('UsersRepository — feed tokens (Plan 3d Task 5, FD5-FD8/FD10)', () => { it('USERSREPO-072: getFeedToken reads the stored token, matching SELECT feed_token FROM users WHERE id = ?', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { feed_token: 'tok-abc' }); const legacy = (await findRow(t, Users, { id: user.id })) as { feed_token: string | null }; expect(await users.getFeedToken(user.id)).toBe(legacy.feed_token); expect(await users.getFeedToken(user.id)).toBe('tok-abc'); }); it('USERSREPO-073: getFeedToken returns null both when the column is NULL and when the user does not exist', async () => { const { user } = createUser(testDb); // feed_token NULL by default expect(await users.getFeedToken(user.id)).toBeNull(); expect(await users.getFeedToken(999999)).toBeNull(); }); it('USERSREPO-074: setFeedToken (FD6/FD7) writes a fresh token verbatim', async () => { const { user } = createUser(testDb); await users.setFeedToken(user.id, 'tok-fresh'); expect(((await findRow(t, Users, { id: user.id })) as { feed_token: string }).feed_token).toBe('tok-fresh'); }); it('USERSREPO-075: setFeedToken (FD8) clears the column to NULL when the token is null', async () => { const { user } = createUser(testDb); await updateRows(t, Users, { id: user.id }, { feed_token: 'tok-old' }); await users.setFeedToken(user.id, null); expect(((await findRow(t, Users, { id: user.id })) as { feed_token: string | null }).feed_token).toBeNull(); }); it('USERSREPO-076: findIdAndUsernameByFeedToken (FD10) — the anonymous credential lookup, exact projection', async () => { const { user } = createUser(testDb, { username: 'feed-holder' }); await updateRows(t, Users, { id: user.id }, { feed_token: 'tok-holder' }); // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. const legacy = testDb.prepare('SELECT id, username FROM users WHERE feed_token = ?').get('tok-holder'); expect(await users.findIdAndUsernameByFeedToken('tok-holder')).toEqual(legacy); expect(await users.findIdAndUsernameByFeedToken('tok-holder')).toEqual({ id: user.id, username: 'feed-holder' }); }); it('USERSREPO-077: findIdAndUsernameByFeedToken returns undefined for an unknown token — a NULL column never matches (the partial UNIQUE index semantics)', async () => { createUser(testDb); // feed_token NULL expect(await users.findIdAndUsernameByFeedToken('does-not-exist')).toBeUndefined(); // Belt-and-braces: an empty-string lookup must not accidentally coerce to // an `IS NULL` match against the many NULL-token rows in the DB. expect(await users.findIdAndUsernameByFeedToken('')).toBeUndefined(); }); it('M1: findUsernameEmail returns its columns, and the missing-user branch, honestly', async () => { const { user } = createUser(testDb, { username: 'imm-user', email: 'imm@example.com' }); expect(await users.findUsernameEmail(user.id)).toEqual({ username: 'imm-user', email: 'imm@example.com' }); expect(await users.findUsernameEmail(999999)).toBeUndefined(); }); }); // Plan 3i Task 4 fix wave (should-land 5): admin's AD1-AD17 read methods // (listForAdmin, findAdminSummary, findIdEmailMfaEnabled, and the four // exact/excluding uniqueness lookups) shipped in Task 1 (862799062) with no // repository-level parity test of their own — only the live HTTP surface was // checked. One seeded world (an admin, a plain user and a guest, so the // `is_guest` exclusion has something to exclude), one full-key `toEqual` // test per read method against the exact legacy projection named in each // method's own docstring. describe('UsersRepository — admin (AD1-AD17) read methods, full-key parity', () => { let admin: TestUser; let plain: TestUser; let guest: TestUser; beforeEach(async () => { admin = createAdmin(testDb, { username: 'ad-admin', email: 'ad-admin@example.com' }).user; plain = createUser(testDb, { username: 'ad-plain', email: 'ad-plain@example.com' }).user; const { user: guestRow } = createUser(testDb, { username: 'ad-guest', email: 'ad-guest@example.com' }); await updateRows(t, Users, { id: guestRow.id }, { is_guest: 1 }); guest = { ...guestRow } as TestUser; }); it('USERSREPO-078 (AD1): listForAdmin matches SELECT id, username, email, role, avatar, created_at, updated_at, last_login FROM users WHERE COALESCE(is_guest, 0) = 0 ORDER BY created_at DESC, and excludes the guest row', async () => { const legacy = testDb // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. .prepare( 'SELECT id, username, email, role, avatar, created_at, updated_at, last_login FROM users WHERE COALESCE(is_guest, 0) = 0 ORDER BY created_at DESC', ) .all(); const rows = await users.listForAdmin(); expect(rows).toEqual(legacy); expect(rows.map((r) => r.id)).not.toContain(guest.id); expect(rows.map((r) => r.id)).toEqual(expect.arrayContaining([admin.id, plain.id])); }); it('USERSREPO-079 (AD2/AD3): findIdByUsernameExact is case-sensitive, the email check is not, and both exclude guests', async () => { expect(await users.findIdByUsernameExact('ad-admin')).toBe(admin.id); expect(await users.findIdByUsernameExact('AD-ADMIN')).toBeNull(); // case-sensitive, unlike findIdByUsernameCIAny expect(await users.findIdByUsernameExact('ad-guest')).toBeNull(); // guest excluded expect(await users.findIdByEmailCI('ad-plain@example.com')).toBe(plain.id); expect(await users.findIdByEmailCI('AD-PLAIN@EXAMPLE.COM')).toBe(plain.id); expect(await users.findIdByEmailCI('ad-guest@example.com')).toBeNull(); }); it('USERSREPO-080 (AD4/AD5): insertAdminCreatedUser stores exactly the four named columns, every other column left to the entity default, then findAdminSummary re-selects it', async () => { const id = await users.insertAdminCreatedUser({ username: 'ad-new', email: 'ad-new@example.com', password_hash: 'hash-x', role: 'user', }); const legacyRow = (await findRow(t, Users, { id })) as Record; expect(legacyRow.username).toBe('ad-new'); expect(legacyRow.email).toBe('ad-new@example.com'); expect(legacyRow.password_hash).toBe('hash-x'); expect(legacyRow.role).toBe('user'); // Every column the legacy INSERT omitted falls back to the schema DEFAULT // — the AUDIT for the 3i review's own "INSERT entity defaults" pass. expect(legacyRow.mfa_enabled).toBe(0); expect(legacyRow.first_seen_version).toBe('0.0.0'); expect(legacyRow.login_count).toBe(0); expect(legacyRow.is_guest).toBe(0); // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. const legacySummary = testDb .prepare('SELECT id, username, email, role, created_at, updated_at FROM users WHERE id = ?') .get(id); expect(await users.findAdminSummary(id)).toEqual(legacySummary); }); it('USERSREPO-081 (AD14): findAdminSummary matches the byte-identical re-select text on an EXISTING (updated) row too', async () => { await updateRows(t, Users, { id: plain.id }, { username: 'ad-plain-renamed', role: 'admin' }); // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. const legacy = testDb .prepare('SELECT id, username, email, role, created_at, updated_at FROM users WHERE id = ?') .get(plain.id); expect(await users.findAdminSummary(plain.id)).toEqual(legacy); expect(await users.findAdminSummary(999999)).toBeNull(); }); it("USERSREPO-082 (AD7/AD8): findIdByUsernameExactExcluding/findIdByEmailCI exclude the caller's own row and guests", async () => { // Renaming plain to admin's own username, excluding plain's own id, must // still find admin's row — that's the whole point of the check. expect(await users.findIdByUsernameExactExcluding('ad-admin', plain.id)).toBe(admin.id); expect(await users.findIdByUsernameExactExcluding('ad-plain', plain.id)).toBeNull(); // excludes self expect(await users.findIdByUsernameExactExcluding('ad-guest', plain.id)).toBeNull(); // guest excluded expect(await users.findIdByEmailCI('ad-admin@example.com', plain.id)).toBe(admin.id); expect(await users.findIdByEmailCI('AD-ADMIN@example.com', plain.id)).toBe(admin.id); expect(await users.findIdByEmailCI('ad-plain@example.com', plain.id)).toBeNull(); }); it('USERSREPO-083 (AD11): applyAdminEdit only touches the keys supplied (coalesceParam semantics) and always stamps updated_at', async () => { const before = (await findRow(t, Users, { id: plain.id })) as { email: string; updated_at: string }; // CURRENT_TIMESTAMP has 1-second resolution — wait past a tick so a // genuine "always stamped" pass is distinguishable from a no-op. await new Promise((r) => setTimeout(r, 1100)); await users.applyAdminEdit(plain.id, { username: 'ad-plain-2' }); const after = (await findRow(t, Users, { id: plain.id })) as { username: string; email: string; updated_at: string; }; expect(after.username).toBe('ad-plain-2'); // email was NOT in the patch, so it is unchanged — the coalesceParam // "new value wins when supplied, existing column wins when omitted" shape. expect(after.email).toBe(before.email); // updated_at is stamped unconditionally, even though only username changed. expect(after.updated_at).not.toBe(before.updated_at); }); it('USERSREPO-084 (AD16): findIdEmailMfaEnabled matches SELECT id, email, mfa_enabled FROM users WHERE id = ?', async () => { await updateRows(t, Users, { id: admin.id }, { mfa_enabled: 1 }); // test-sql-allow: legacy statement run raw as the parity oracle for the repository read. const legacy = testDb.prepare('SELECT id, email, mfa_enabled FROM users WHERE id = ?').get(admin.id); expect(await users.findIdEmailMfaEnabled(admin.id)).toEqual(legacy); expect(await users.findIdEmailMfaEnabled(999999)).toBeNull(); }); }); describe('a users write the unique indexes refuse', () => { const row = (username: string, email: string) => ({ username, email, password_hash: 'hashed', role: 'user', first_seen_version: '1.0.0', }); it('USERSREPO-IDENT-001: an email another account holds in different case is refused as the email', async () => { createUser(testDb, { username: 'anna', email: 'anna@example.com' }); const refused = users.insertUser(row('anna2', 'ANNA@Example.com')); await expect(refused).rejects.toBeInstanceOf(UserIdentityTakenError); await expect(refused).rejects.toMatchObject({ field: 'email' }); }); it('USERSREPO-IDENT-002: a taken username is refused as the username, on insert and on update', async () => { createUser(testDb, { username: 'anna', email: 'anna@example.com' }); const { user } = createUser(testDb, { username: 'carl', email: 'carl@example.com' }); await expect( users.insertAdminCreatedUser({ username: 'anna', email: 'new@example.com', password_hash: 'x', role: 'user' }), ).rejects.toMatchObject({ field: 'username' }); await expect(users.patchProfile(user.id, { email: 'Anna@example.com' })).rejects.toMatchObject({ field: 'email' }); await expect(users.applyAdminEdit(user.id, { username: 'anna' })).rejects.toMatchObject({ field: 'username' }); }); });