userManager.test.ts

import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
import { db, initializeDatabase } from './db';
import { userManager } from './userManager';
import { users, redeemedCodes, pendingCodes } from './schema/index';
import { isEncrypted, encrypt } from '../utils/crypto';

beforeAll(() => {
  initializeDatabase();
});

beforeEach(() => {
  // Clear in FK-safe order so the users delete never violates constraints
  db.delete(pendingCodes).run();
  db.delete(redeemedCodes).run();
  db.delete(users).run();
});



// ---------------------------------------------------------------------------
// saveCredentials
// ---------------------------------------------------------------------------
describe('saveCredentials', () => {
  test('inserts a new user', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const rows = db.select().from(users).all();
    expect(rows).toHaveLength(1);
    expect(rows[0]!.discordId).toBe('user-1');
    // Credentials are encrypted at rest — raw DB values must not be plaintext
    expect(rows[0]!.userId).not.toBe('111');
    expect(rows[0]!.userHash).not.toBe('hash-a');
    // Decrypted values match originals
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.userId).toBe('111');
    expect(creds?.userHash).toBe('hash-a');
  });

  test('upserts existing user credentials', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-1', userId: '222', userHash: 'hash-b' });
    const rows = db.select().from(users).all();
    expect(rows).toHaveLength(1);
    // Decrypted values reflect the latest upsert
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.userId).toBe('222');
    expect(creds?.userHash).toBe('hash-b');
  });

  test('stores optional server field', async () => {
    await userManager.saveCredentials({
      discordId: 'user-1',
      userId: '111',
      userHash: 'hash-a',
      server: 'server1',
    });
    const rows = db.select().from(users).all();
    expect(rows[0]!.server).toBe('server1');
  });
});

// ---------------------------------------------------------------------------
// getCredentials
// ---------------------------------------------------------------------------
describe('getCredentials', () => {
  test('returns null for an unknown discord ID', async () => {
    expect(await userManager.getCredentials('unknown')).toBeNull();
  });

  test('returns the correct credentials for a known user', async () => {
    await userManager.saveCredentials({
      discordId: 'user-1',
      userId: '111',
      userHash: 'hash-a',
      server: 'sv1',
    });
    const creds = await userManager.getCredentials('user-1');
    expect(creds).not.toBeNull();
    expect(creds?.discordId).toBe('user-1');
    expect(creds?.userId).toBe('111');
    expect(creds?.userHash).toBe('hash-a');
    expect(creds?.server).toBe('sv1');
  });
});

// ---------------------------------------------------------------------------
// hasCredentials
// ---------------------------------------------------------------------------
describe('hasCredentials', () => {
  test('returns false for an unknown discord ID', async () => {
    expect(await userManager.hasCredentials('unknown')).toBe(false);
  });

  test('returns true after saveCredentials', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    expect(await userManager.hasCredentials('user-1')).toBe(true);
  });
});

// ---------------------------------------------------------------------------
// updateServer
// ---------------------------------------------------------------------------
describe('updateServer', () => {
  test('updates the server field for an existing user', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.updateServer('user-1', 'server-new');
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.server).toBe('server-new');
  });

  test('overrides a previously stored server', async () => {
    await userManager.saveCredentials({
      discordId: 'user-1',
      userId: '111',
      userHash: 'hash-a',
      server: 'server-old',
    });
    await userManager.updateServer('user-1', 'server-new');
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.server).toBe('server-new');
  });
});

// ---------------------------------------------------------------------------
// deleteCredentials
// ---------------------------------------------------------------------------
describe('deleteCredentials', () => {
  test('removes the user row', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.deleteCredentials('user-1');
    expect(await userManager.hasCredentials('user-1')).toBe(false);
  });

  test('is a no-op for an unknown user', async () => {
    await userManager.deleteCredentials('nobody');
    expect(db.select().from(users).all()).toHaveLength(0);
  });
});

// ---------------------------------------------------------------------------
// getAllUsers
// ---------------------------------------------------------------------------
describe('getAllUsers', () => {
  test('returns empty array when no users exist', async () => {
    expect(await userManager.getAllUsers()).toEqual([]);
  });

  test('returns all stored users', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    const all = await userManager.getAllUsers();
    expect(all).toHaveLength(2);
    const ids = all.map((u) => u.discordId);
    expect(ids).toContain('user-1');
    expect(ids).toContain('user-2');
  });
});

// ---------------------------------------------------------------------------
// autoRedeem default
// ---------------------------------------------------------------------------
describe('autoRedeem default', () => {
  test('is true after saveCredentials without explicit value', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.autoRedeem).toBe(true);
  });
});

// ---------------------------------------------------------------------------
// setAutoRedeem
// ---------------------------------------------------------------------------
describe('setAutoRedeem', () => {
  test('disables auto-redeem for a user', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setAutoRedeem('user-1', false);
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.autoRedeem).toBe(false);
  });

  test('re-enables auto-redeem after disabling', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setAutoRedeem('user-1', false);
    await userManager.setAutoRedeem('user-1', true);
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.autoRedeem).toBe(true);
  });
});

// ---------------------------------------------------------------------------
// getAllUsersWithAutoRedeem
// ---------------------------------------------------------------------------
describe('getAllUsersWithAutoRedeem', () => {
  test('returns empty array when no users exist', async () => {
    expect(await userManager.getAllUsersWithAutoRedeem()).toEqual([]);
  });

  test('returns only users with auto-redeem enabled', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    await userManager.saveCredentials({ discordId: 'user-3', userId: '333', userHash: 'hash-c' });
    await userManager.setAutoRedeem('user-2', false);

    const enabled = await userManager.getAllUsersWithAutoRedeem();
    expect(enabled).toHaveLength(2);
    const ids = enabled.map((u) => u.discordId);
    expect(ids).toContain('user-1');
    expect(ids).toContain('user-3');
    expect(ids).not.toContain('user-2');
  });

  test('returns all users when none have disabled auto-redeem', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    const enabled = await userManager.getAllUsersWithAutoRedeem();
    expect(enabled).toHaveLength(2);
  });

  test('returns empty when all users have disabled auto-redeem', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    await userManager.setAutoRedeem('user-1', false);
    await userManager.setAutoRedeem('user-2', false);
    expect(await userManager.getAllUsersWithAutoRedeem()).toEqual([]);
  });
});

// ---------------------------------------------------------------------------
// migratePlaintextCredentials
// ---------------------------------------------------------------------------
describe('migratePlaintextCredentials', () => {
  test('is a no-op when the table is empty', async () => {
    await userManager.migratePlaintextCredentials();
    expect(db.select().from(users).all()).toHaveLength(0);
  });

  test('encrypts plaintext userId and userHash, preserving decrypted values', async () => {
    // Seed a row with plaintext credentials directly (bypassing saveCredentials)
    db.insert(users).values({ discordId: 'user-1', userId: '111', userHash: 'hash-a' }).run();

    await userManager.migratePlaintextCredentials();

    const row = db.select().from(users).get();
    // Both fields must now be in encrypted format
    expect(isEncrypted(row!.userId)).toBe(true);
    expect(isEncrypted(row!.userHash)).toBe(true);
    // Decrypted values must match the original plaintext
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.userId).toBe('111');
    expect(creds?.userHash).toBe('hash-a');
  });

  test('migrates multiple plaintext rows independently', async () => {
    db.insert(users).values([
      { discordId: 'user-1', userId: '111', userHash: 'hash-a' },
      { discordId: 'user-2', userId: '222', userHash: 'hash-b' },
    ]).run();

    await userManager.migratePlaintextCredentials();

    const creds1 = await userManager.getCredentials('user-1');
    const creds2 = await userManager.getCredentials('user-2');
    expect(creds1?.userId).toBe('111');
    expect(creds1?.userHash).toBe('hash-a');
    expect(creds2?.userId).toBe('222');
    expect(creds2?.userHash).toBe('hash-b');
  });

  test('leaves already-encrypted rows unchanged (no double-encryption)', async () => {
    // Seed via saveCredentials so the row is already encrypted
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const before = db.select().from(users).get();

    await userManager.migratePlaintextCredentials();

    const after = db.select().from(users).get();
    // Raw stored values must be identical — no re-encryption occurred
    expect(after!.userId).toBe(before!.userId);
    expect(after!.userHash).toBe(before!.userHash);
    // Decrypted values still correct
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.userId).toBe('111');
    expect(creds?.userHash).toBe('hash-a');
  });

  test('encrypts only the plaintext field in a mixed-state row', async () => {
    // Seed a row where userId is already encrypted but userHash is still plaintext
    const encryptedUserId = encrypt('111');
    db.insert(users).values({ discordId: 'user-1', userId: encryptedUserId, userHash: 'hash-a' }).run();

    await userManager.migratePlaintextCredentials();

    const row = db.select().from(users).get();
    // userId must be the same encrypted value (not double-encrypted)
    expect(row!.userId).toBe(encryptedUserId);
    // userHash must now be encrypted
    expect(isEncrypted(row!.userHash)).toBe(true);
    // Both decrypt correctly
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.userId).toBe('111');
    expect(creds?.userHash).toBe('hash-a');
  });
});

// ---------------------------------------------------------------------------
// notification preference defaults
// ---------------------------------------------------------------------------
describe('notification preference defaults', () => {
  test('dmOnCode defaults to false after saveCredentials', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnCode).toBe(false);
  });

  test('dmOnSuccess defaults to true after saveCredentials', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnSuccess).toBe(true);
  });

  test('dmOnFailure defaults to false after saveCredentials', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnFailure).toBe(false);
  });
});

// ---------------------------------------------------------------------------
// setNotificationPreferences
// ---------------------------------------------------------------------------
describe('setNotificationPreferences', () => {
  test('enables dmOnCode', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setNotificationPreferences('user-1', { dmOnCode: true });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnCode).toBe(true);
  });

  test('disables dmOnSuccess', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setNotificationPreferences('user-1', { dmOnSuccess: false });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnSuccess).toBe(false);
  });

  test('enables dmOnFailure', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setNotificationPreferences('user-1', { dmOnFailure: true });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnFailure).toBe(true);
  });

  test('updates multiple prefs at once', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setNotificationPreferences('user-1', {
      dmOnCode: true,
      dmOnSuccess: false,
      dmOnFailure: true,
    });
    const creds = await userManager.getCredentials('user-1');
    expect(creds?.dmOnCode).toBe(true);
    expect(creds?.dmOnSuccess).toBe(false);
    expect(creds?.dmOnFailure).toBe(true);
  });

  test('does not affect unspecified prefs', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.setNotificationPreferences('user-1', { dmOnCode: true });
    const creds = await userManager.getCredentials('user-1');
    // dmOnSuccess and dmOnFailure must remain at their defaults
    expect(creds?.dmOnSuccess).toBe(true);
    expect(creds?.dmOnFailure).toBe(false);
  });
});

// ---------------------------------------------------------------------------
// getDiscordIdsWithDmOnCode
// ---------------------------------------------------------------------------
describe('getDiscordIdsWithDmOnCode', () => {
  test('returns empty array when no users exist', async () => {
    expect(await userManager.getDiscordIdsWithDmOnCode()).toEqual([]);
  });

  test('returns only discord IDs of users with dmOnCode enabled', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    await userManager.saveCredentials({ discordId: 'user-3', userId: '333', userHash: 'hash-c' });
    await userManager.setNotificationPreferences('user-1', { dmOnCode: true });
    await userManager.setNotificationPreferences('user-3', { dmOnCode: true });

    const ids = await userManager.getDiscordIdsWithDmOnCode();
    expect(ids).toHaveLength(2);
    expect(ids).toContain('user-1');
    expect(ids).toContain('user-3');
    expect(ids).not.toContain('user-2');
  });

  test('returns empty when no users have dmOnCode enabled', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    expect(await userManager.getDiscordIdsWithDmOnCode()).toEqual([]);
  });
});

// ---------------------------------------------------------------------------
// getUserCount
// ---------------------------------------------------------------------------
describe('getUserCount', () => {
  test('returns 0 when no users exist', async () => {
    expect(await userManager.getUserCount()).toBe(0);
  });

  test('returns 1 after one user is saved', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    expect(await userManager.getUserCount()).toBe(1);
  });

  test('counts multiple users', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    expect(await userManager.getUserCount()).toBe(2);
  });

  test('decreases after a user is deleted', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-2', userId: '222', userHash: 'hash-b' });
    await userManager.deleteCredentials('user-1');
    expect(await userManager.getUserCount()).toBe(1);
  });

  test('upsert does not increase the count', async () => {
    await userManager.saveCredentials({ discordId: 'user-1', userId: '111', userHash: 'hash-a' });
    await userManager.saveCredentials({ discordId: 'user-1', userId: '222', userHash: 'hash-b' });
    expect(await userManager.getUserCount()).toBe(1);
  });
});