serverless-ircd 0.1.0 → 0.2.0

package/packages/irc-core/tests/config.test.ts

@@ -0,0 +1,646 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_SERVER_CONFIG, ServerConfigSchema, parseServerConfig } from '../src/config';
+
+// ============================================================================
+// ServerConfigSchema — valid inputs
+// ============================================================================
+
+describe('ServerConfigSchema — valid inputs', () => {
+  it('parses a complete valid config', () => {
+    const cfg = parseServerConfig({
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      motdLines: ['Welcome.', 'Have fun.'],
+      channelPrefixes: '#&+',
+      maxClients: 5000,
+      operCreds: [{ user: 'admin', password: 's3cret' }],
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    });
+    expect(cfg.serverName).toBe('irc.example.com');
+    expect(cfg.networkName).toBe('ExampleNet');
+    expect(cfg.motdLines).toEqual(['Welcome.', 'Have fun.']);
+    expect(cfg.channelPrefixes).toBe('#&+');
+    expect(cfg.maxClients).toBe(5000);
+    expect(cfg.operCreds).toEqual([{ user: 'admin', password: 's3cret' }]);
+    expect(cfg.maxChannelsPerUser).toBe(30);
+    expect(cfg.maxTargetsPerCommand).toBe(10);
+    expect(cfg.maxListEntries).toBe(50);
+    expect(cfg.nickLen).toBe(30);
+    expect(cfg.channelLen).toBe(50);
+    expect(cfg.topicLen).toBe(390);
+    expect(cfg.quitMessage).toBe('Client Quit');
+  });
+
+  it('parses a minimal config (serverName + networkName), applying defaults', () => {
+    const cfg = parseServerConfig({
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+    });
+    expect(cfg.motdLines).toEqual([]);
+    expect(cfg.channelPrefixes).toBe('#');
+    expect(cfg.maxClients).toBeGreaterThan(0);
+    expect(cfg.operCreds).toEqual([]);
+    expect(cfg.maxChannelsPerUser).toBeGreaterThan(0);
+    expect(cfg.maxTargetsPerCommand).toBeGreaterThan(0);
+    expect(cfg.maxListEntries).toBeGreaterThanOrEqual(0);
+    expect(cfg.nickLen).toBeGreaterThan(0);
+    expect(cfg.channelLen).toBeGreaterThan(0);
+    expect(cfg.topicLen).toBeGreaterThanOrEqual(0);
+    expect(cfg.quitMessage.length).toBeGreaterThan(0);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — required fields
+// ============================================================================
+
+describe('ServerConfigSchema — required fields', () => {
+  it('rejects a config missing serverName', () => {
+    expect(() => parseServerConfig({ networkName: 'ExampleNet' })).toThrowError(/serverName/u);
+  });
+
+  it('rejects a config missing networkName', () => {
+    expect(() => parseServerConfig({ serverName: 'irc.example.com' })).toThrowError(/networkName/u);
+  });
+
+  it('rejects an empty serverName', () => {
+    expect(() => parseServerConfig({ serverName: '', networkName: 'ExampleNet' })).toThrowError(
+      /serverName/u,
+    );
+  });
+
+  it('rejects an empty networkName', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 'irc.example.com', networkName: '' }),
+    ).toThrowError(/networkName/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — MOTD
+// ============================================================================
+
+describe('ServerConfigSchema — MOTD', () => {
+  it('accepts a non-empty motdLines array', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      motdLines: ['line 1', 'line 2', ''],
+    });
+    expect(cfg.motdLines).toEqual(['line 1', 'line 2', '']);
+  });
+
+  it('defaults motdLines to an empty array when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.motdLines).toEqual([]);
+  });
+
+  it('rejects a non-array motdLines', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        motdLines: 'welcome',
+      }),
+    ).toThrowError(/motdLines/u);
+  });
+
+  it('rejects motdLines with non-string entries', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        motdLines: ['ok', 42],
+      }),
+    ).toThrowError(/motdLines/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — channel prefixes
+// ============================================================================
+
+describe('ServerConfigSchema — channel prefixes', () => {
+  it('accepts a non-empty channelPrefixes string', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      channelPrefixes: '#&',
+    });
+    expect(cfg.channelPrefixes).toBe('#&');
+  });
+
+  it('defaults channelPrefixes to "#" when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.channelPrefixes).toBe('#');
+  });
+
+  it('rejects an empty channelPrefixes string', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        channelPrefixes: '',
+      }),
+    ).toThrowError(/channelPrefixes/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — maxClients
+// ============================================================================
+
+describe('ServerConfigSchema — maxClients', () => {
+  it('accepts a positive integer', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      maxClients: 12345,
+    });
+    expect(cfg.maxClients).toBe(12345);
+  });
+
+  it('defaults maxClients when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.maxClients).toBeGreaterThan(0);
+    expect(Number.isInteger(cfg.maxClients)).toBe(true);
+  });
+
+  it('rejects zero', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxClients: 0,
+      }),
+    ).toThrowError(/maxClients/u);
+  });
+
+  it('rejects a negative value', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxClients: -1,
+      }),
+    ).toThrowError(/maxClients/u);
+  });
+
+  it('rejects a non-integer', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxClients: 1.5,
+      }),
+    ).toThrowError(/maxClients/u);
+  });
+
+  it('rejects a non-number', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxClients: 'many',
+      }),
+    ).toThrowError(/maxClients/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — operCreds
+// ============================================================================
+
+describe('ServerConfigSchema — operCreds', () => {
+  it('accepts an array of {user,password} entries', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      operCreds: [
+        { user: 'op1', password: 'p1' },
+        { user: 'op2', password: 'p2' },
+      ],
+    });
+    expect(cfg.operCreds).toHaveLength(2);
+    expect(cfg.operCreds[0]?.user).toBe('op1');
+    expect(cfg.operCreds[1]?.password).toBe('p2');
+  });
+
+  it('defaults operCreds to an empty array when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.operCreds).toEqual([]);
+  });
+
+  it('rejects operCreds entries missing user', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        operCreds: [{ password: 'p' }],
+      }),
+    ).toThrowError(/user/u);
+  });
+
+  it('rejects operCreds entries missing password', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        operCreds: [{ user: 'op' }],
+      }),
+    ).toThrowError(/password/u);
+  });
+
+  it('rejects operCreds entries with empty user', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        operCreds: [{ user: '', password: 'p' }],
+      }),
+    ).toThrowError(/user/u);
+  });
+
+  it('rejects operCreds entries with empty password', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        operCreds: [{ user: 'op', password: '' }],
+      }),
+    ).toThrowError(/password/u);
+  });
+
+  it('rejects a non-array operCreds', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        operCreds: { user: 'op', password: 'p' },
+      }),
+    ).toThrowError(/operCreds/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — limit knobs
+// ============================================================================
+
+describe('ServerConfigSchema — limit knobs', () => {
+  it('rejects non-positive maxChannelsPerUser', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxChannelsPerUser: 0,
+      }),
+    ).toThrowError(/maxChannelsPerUser/u);
+  });
+
+  it('rejects non-positive nickLen', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        nickLen: 0,
+      }),
+    ).toThrowError(/nickLen/u);
+  });
+
+  it('rejects negative maxListEntries', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxListEntries: -1,
+      }),
+    ).toThrowError(/maxListEntries/u);
+  });
+
+  it('accepts zero maxListEntries (disable list entirely)', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      maxListEntries: 0,
+    });
+    expect(cfg.maxListEntries).toBe(0);
+  });
+
+  it('rejects negative topicLen', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        topicLen: -5,
+      }),
+    ).toThrowError(/topicLen/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — failure diagnostics
+// ============================================================================
+
+describe('ServerConfigSchema — failure diagnostics', () => {
+  it('fails fast at boot with a readable Error mentioning the field', () => {
+    try {
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxClients: 'oops',
+      });
+      expect.fail('expected parseServerConfig to throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      const msg = (err as Error).message;
+      expect(msg).toMatch(/invalid server config/iu);
+      expect(msg).toMatch(/maxClients/u);
+    }
+  });
+
+  it('aggregates multiple errors into a single readable message', () => {
+    try {
+      parseServerConfig({
+        serverName: '',
+        networkName: '',
+        maxClients: -3,
+        nickLen: 0,
+      });
+      expect.fail('expected parseServerConfig to throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      const msg = (err as Error).message;
+      // At least two of the bad fields are surfaced.
+      const hits = ['serverName', 'networkName', 'maxClients', 'nickLen'].filter((f) =>
+        msg.includes(f),
+      ).length;
+      expect(hits).toBeGreaterThanOrEqual(2);
+    }
+  });
+
+  it('rejects a non-object root input', () => {
+    expect(() => parseServerConfig('hello')).toThrowError(/invalid server config/iu);
+  });
+
+  it('rejects null', () => {
+    expect(() => parseServerConfig(null)).toThrowError(/invalid server config/iu);
+  });
+
+  it('rejects an array as the root config', () => {
+    expect(() => parseServerConfig([])).toThrowError(/invalid server config/iu);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — defaults
+// ============================================================================
+
+describe('ServerConfigSchema — DEFAULT_SERVER_CONFIG', () => {
+  it('is a valid parsed config', () => {
+    expect(DEFAULT_SERVER_CONFIG.serverName.length).toBeGreaterThan(0);
+    expect(DEFAULT_SERVER_CONFIG.networkName.length).toBeGreaterThan(0);
+    expect(Array.isArray(DEFAULT_SERVER_CONFIG.motdLines)).toBe(true);
+    expect(DEFAULT_SERVER_CONFIG.channelPrefixes.length).toBeGreaterThan(0);
+    expect(DEFAULT_SERVER_CONFIG.maxClients).toBeGreaterThan(0);
+    expect(Array.isArray(DEFAULT_SERVER_CONFIG.operCreds)).toBe(true);
+  });
+
+  it('round-trips through the schema unchanged', () => {
+    const reparsed = parseServerConfig(DEFAULT_SERVER_CONFIG);
+    expect(reparsed).toEqual(DEFAULT_SERVER_CONFIG);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — direct schema usage
+// ============================================================================
+
+describe('ServerConfigSchema — direct usage', () => {
+  it('safeParse returns {success:true} for a valid input', () => {
+    const result = ServerConfigSchema.safeParse({
+      serverName: 's',
+      networkName: 'n',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('safeParse returns {success:false} for an invalid input', () => {
+    const result = ServerConfigSchema.safeParse({ serverName: 1 });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — serverPassword
+// ============================================================================
+
+describe('ServerConfigSchema — serverPassword', () => {
+  it('defaults serverPassword to undefined when omitted (no password required)', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.serverPassword).toBeUndefined();
+  });
+
+  it('accepts a non-empty serverPassword', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      serverPassword: 's3cret',
+    });
+    expect(cfg.serverPassword).toBe('s3cret');
+  });
+
+  it('accepts an empty-string serverPassword as "disabled"', () => {
+    // Operators set "" to explicitly disable; matches the default.
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      serverPassword: '',
+    });
+    expect(cfg.serverPassword).toBe('');
+  });
+
+  it('rejects a non-string serverPassword', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        serverPassword: 42,
+      }),
+    ).toThrowError(/serverPassword/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — cloaking
+// ============================================================================
+
+describe('ServerConfigSchema — cloaking', () => {
+  it('defaults cloaking to undefined when omitted (no cloaking)', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.cloaking).toBeUndefined();
+  });
+
+  it('accepts a valid cloaking config with enabled + secret', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      cloaking: { enabled: true, secret: 'hunter2' },
+    });
+    expect(cfg.cloaking).toEqual({ enabled: true, secret: 'hunter2' });
+  });
+
+  it('accepts a custom cloakedSuffix', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      cloaking: { enabled: true, secret: 'k', cloakedSuffix: 'hidden.lan' },
+    });
+    expect(cfg.cloaking?.cloakedSuffix).toBe('hidden.lan');
+  });
+
+  it('rejects a cloaking config missing secret', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        cloaking: { enabled: true },
+      }),
+    ).toThrowError(/secret/u);
+  });
+
+  it('rejects a cloaking config with empty secret when enabled', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        cloaking: { enabled: true, secret: '' },
+      }),
+    ).toThrowError(/secret/u);
+  });
+
+  it('rejects a non-object cloaking value', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        cloaking: 'yes',
+      }),
+    ).toThrowError(/cloaking/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — maxConnectionsPerIp / maxConnectionsPerUser
+// ============================================================================
+
+describe('ServerConfigSchema — per-IP / per-user connection caps', () => {
+  it('defaults maxConnectionsPerIp to a positive integer when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.maxConnectionsPerIp).toBeGreaterThan(0);
+    expect(Number.isInteger(cfg.maxConnectionsPerIp)).toBe(true);
+  });
+
+  it('defaults maxConnectionsPerUser to a positive integer when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.maxConnectionsPerUser).toBeGreaterThan(0);
+    expect(Number.isInteger(cfg.maxConnectionsPerUser)).toBe(true);
+  });
+
+  it('accepts explicit positive integers for both', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      maxConnectionsPerIp: 5,
+      maxConnectionsPerUser: 10,
+    });
+    expect(cfg.maxConnectionsPerIp).toBe(5);
+    expect(cfg.maxConnectionsPerUser).toBe(10);
+  });
+
+  it('rejects zero maxConnectionsPerIp', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxConnectionsPerIp: 0,
+      }),
+    ).toThrowError(/maxConnectionsPerIp/u);
+  });
+
+  it('rejects negative maxConnectionsPerIp', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxConnectionsPerIp: -1,
+      }),
+    ).toThrowError(/maxConnectionsPerIp/u);
+  });
+
+  it('rejects zero maxConnectionsPerUser', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        maxConnectionsPerUser: 0,
+      }),
+    ).toThrowError(/maxConnectionsPerUser/u);
+  });
+});
+
+// ============================================================================
+// ServerConfigSchema — per-IP connection-rate limit
+// ============================================================================
+
+describe('ServerConfigSchema — perIpConnectionRate', () => {
+  it('defaults to a positive rate cap when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.perIpConnectionRate.max).toBeGreaterThan(0);
+    expect(cfg.perIpConnectionRate.windowMs).toBeGreaterThan(0);
+  });
+
+  it('accepts a valid rate limit', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      perIpConnectionRate: { max: 3, windowMs: 10_000 },
+    });
+    expect(cfg.perIpConnectionRate).toEqual({ max: 3, windowMs: 10_000 });
+  });
+
+  it('rejects zero max', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        perIpConnectionRate: { max: 0, windowMs: 10_000 },
+      }),
+    ).toThrowError(/max/u);
+  });
+
+  it('rejects zero windowMs', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        perIpConnectionRate: { max: 3, windowMs: 0 },
+      }),
+    ).toThrowError(/windowMs/u);
+  });
+
+  it('rejects a non-object value', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        perIpConnectionRate: 'fast',
+      }),
+    ).toThrowError(/perIpConnectionRate/u);
+  });
+});