Add coverage for core utility behavior

This commit is contained in:
Mike Cao committed 2026-07-24 13:52:37 -07:00
1 parent ba741eb617
commit 65e810ec79
24 files changed
+1882 -22

No files matched your search

+54
View File
@@ -0,0 +1,54 @@
import { describe, expect, test } from 'vitest';
import { generateBackupCodes, verifyBackupCode } from './backup-codes';
describe('generateBackupCodes', () => {
test('generates 10 plaintext codes and 10 hashes', async () => {
const { plaintext, hashed } = await generateBackupCodes();
expect(plaintext).toHaveLength(10);
expect(hashed).toHaveLength(10);
});
test('formats codes as two uppercase 16-hex groups separated by a dash', async () => {
const { plaintext } = await generateBackupCodes();
for (const code of plaintext) {
expect(code).toMatch(/^[0-9A-F]{16}-[0-9A-F]{16}$/);
}
});
test('hashes are bcrypt hashes distinct from the plaintext', async () => {
const { plaintext, hashed } = await generateBackupCodes();
for (let i = 0; i < plaintext.length; i++) {
expect(hashed[i]).toMatch(/^\$2[aby]\$/);
expect(hashed[i]).not.toBe(plaintext[i]);
}
});
test('generates unique codes', async () => {
const { plaintext } = await generateBackupCodes();
expect(new Set(plaintext).size).toBe(plaintext.length);
});
});
describe('verifyBackupCode', () => {
test('returns the matching index for a valid code', async () => {
const { plaintext, hashed } = await generateBackupCodes();
expect(await verifyBackupCode(plaintext[3], hashed)).toBe(3);
});
test('is case-insensitive on input', async () => {
const { plaintext, hashed } = await generateBackupCodes();
expect(await verifyBackupCode(plaintext[0].toLowerCase(), hashed)).toBe(0);
});
test('returns null for an unknown code', async () => {
const { hashed } = await generateBackupCodes();
expect(await verifyBackupCode('DEADBEEFDEADBEEF-DEADBEEFDEADBEEF', hashed)).toBeNull();
});
});
+53
View File
@@ -0,0 +1,53 @@
import { describe, expect, test, vi } from 'vitest';
const KEY = 'a'.repeat(64);
describe('encryptSecret/decryptSecret', () => {
test('round-trips a secret with a valid key', async () => {
vi.stubEnv('TWO_FACTOR_ENCRYPTION_KEY', KEY);
vi.resetModules();
const { encryptSecret, decryptSecret } = await import('./crypto');
const plaintext = 'JBSWY3DPEHPK3PXP';
const stored = encryptSecret(plaintext);
expect(stored).not.toContain(plaintext);
expect(stored.split(':')).toHaveLength(3);
expect(decryptSecret(stored)).toBe(plaintext);
vi.unstubAllEnvs();
});
test('produces different ciphertext each call (random iv)', async () => {
vi.stubEnv('TWO_FACTOR_ENCRYPTION_KEY', KEY);
vi.resetModules();
const { encryptSecret } = await import('./crypto');
expect(encryptSecret('same')).not.toBe(encryptSecret('same'));
vi.unstubAllEnvs();
});
test('fails to decrypt tampered ciphertext', async () => {
vi.stubEnv('TWO_FACTOR_ENCRYPTION_KEY', KEY);
vi.resetModules();
const { encryptSecret, decryptSecret } = await import('./crypto');
const [ciphertext, iv, tag] = encryptSecret('secret').split(':');
const flipped = (ciphertext[0] === 'f' ? '0' : 'f') + ciphertext.slice(1);
expect(() => decryptSecret(`${flipped}:${iv}:${tag}`)).toThrow();
vi.unstubAllEnvs();
});
test('throws when the encryption key is missing or invalid', async () => {
vi.stubEnv('TWO_FACTOR_ENCRYPTION_KEY', 'too-short');
vi.resetModules();
const { encryptSecret } = await import('./crypto');
expect(() => encryptSecret('secret')).toThrow(/missing or invalid/);
vi.unstubAllEnvs();
});
});
+49
View File
@@ -0,0 +1,49 @@
import { generateSecret, generateSync } from 'otplib';
import { describe, expect, test } from 'vitest';
import { generateOtpAuthUri, generateTotpSecret, verifyTotp } from './totp';
describe('generateTotpSecret', () => {
test('returns a base32 secret string', () => {
const secret = generateTotpSecret();
expect(typeof secret).toBe('string');
expect(secret).toMatch(/^[A-Z2-7]+$/);
});
test('returns a different secret each call', () => {
expect(generateTotpSecret()).not.toBe(generateTotpSecret());
});
});
describe('generateOtpAuthUri', () => {
test('builds an otpauth uri containing issuer, label and secret', () => {
const secret = generateTotpSecret();
const uri = generateOtpAuthUri(secret, 'alice');
expect(uri).toContain('otpauth://totp/');
expect(uri).toContain('issuer=Umami');
expect(uri).toContain('alice');
expect(uri).toContain(`secret=${secret}`);
});
});
describe('verifyTotp', () => {
test('verifies a token generated for the current time step', async () => {
const secret = generateSecret();
const token = generateSync({ secret });
expect(await verifyTotp(token, secret)).toBe(true);
});
test('rejects an incorrect token', async () => {
const secret = generateSecret();
expect(await verifyTotp('000000', secret)).toBe(false);
});
test('rejects a valid token verified against a different secret', async () => {
const token = generateSync({ secret: generateSecret() });
expect(await verifyTotp(token, generateSecret())).toBe(false);
});
});