Files
2025-09-25 19:36:38 +01:00

390 lines
14 KiB
TypeScript

import { describe, it, expect } from 'vitest';
import { makeApiRequest, validateSuccessResponse, isValidCIDR } from './utils/api-test-helpers';
describe('CIDR API Endpoints', () => {
describe('POST /api/cidr/cidr-to-subnet-mask', () => {
const testCases = [
{ prefix: 24, expectedMask: '255.255.255.0' },
{ prefix: 16, expectedMask: '255.255.0.0' },
{ prefix: 8, expectedMask: '255.0.0.0' },
{ prefix: 30, expectedMask: '255.255.255.252' },
{ prefix: 25, expectedMask: '255.255.255.128' },
{ prefix: 0, expectedMask: '0.0.0.0' },
{ prefix: 32, expectedMask: '255.255.255.255' },
];
testCases.forEach(({ prefix, expectedMask }) => {
it(`should convert prefix /${prefix} to mask ${expectedMask}`, async () => {
const { status, data } = await makeApiRequest('/api/cidr/cidr-to-subnet-mask', 'POST', {
prefix,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'cidr-to-subnet-mask');
expect(data.result.mask).toBeTypeOf('object');
expect(data.result.mask.octets).toEqual(expectedMask.split('.').map(Number));
expect(data.result.mask.valid).toBe(true);
});
});
it('should handle invalid prefix (negative)', async () => {
const { status, data } = await makeApiRequest('/api/cidr/cidr-to-subnet-mask', 'POST', {
prefix: -1,
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API treats -1 as 31 (modulo operation)
expect(data.result.mask.octets).toEqual([255, 255, 255, 254]);
});
it('should handle invalid prefix (> 32)', async () => {
const { status, data } = await makeApiRequest('/api/cidr/cidr-to-subnet-mask', 'POST', {
prefix: 33,
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API treats 33 as 1 (modulo operation)
expect(data.result.mask.octets).toEqual([128, 0, 0, 0]);
});
it('should handle missing prefix parameter', async () => {
const { status, data } = await makeApiRequest('/api/cidr/cidr-to-subnet-mask', 'POST', {});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API defaults to /32 when prefix is missing
expect(data.result.mask.octets).toEqual([255, 255, 255, 255]);
});
});
describe('POST /api/cidr/subnet-mask-to-cidr', () => {
const testCases = [
{ mask: '255.255.255.0', expectedPrefix: 24 },
{ mask: '255.255.0.0', expectedPrefix: 16 },
{ mask: '255.0.0.0', expectedPrefix: 8 },
{ mask: '255.255.255.252', expectedPrefix: 30 },
{ mask: '255.255.255.128', expectedPrefix: 25 },
{ mask: '0.0.0.0', expectedPrefix: 0 },
{ mask: '255.255.255.255', expectedPrefix: 32 },
];
testCases.forEach(({ mask, expectedPrefix }) => {
it(`should convert mask ${mask} to prefix /${expectedPrefix}`, async () => {
const { status, data } = await makeApiRequest('/api/cidr/subnet-mask-to-cidr', 'POST', {
mask,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'subnet-mask-to-cidr');
expect(data.result.prefix).toBe(expectedPrefix);
});
});
it('should handle invalid mask format', async () => {
const { status, data } = await makeApiRequest('/api/cidr/subnet-mask-to-cidr', 'POST', {
mask: '256.255.255.0',
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API processes 256 as 0, treating it as 0.255.255.0 = /17
expect(data.result.prefix).toBe(17);
});
it('should handle incomplete mask', async () => {
const { status, data } = await makeApiRequest('/api/cidr/subnet-mask-to-cidr', 'POST', {
mask: '255.255.255',
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API handles incomplete mask, treating as 255.255.255.0
expect(typeof data.result.prefix).toBe('number');
});
it('should handle non-contiguous mask', async () => {
const { status, data } = await makeApiRequest('/api/cidr/subnet-mask-to-cidr', 'POST', {
mask: '255.0.255.0',
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API processes non-contiguous masks, returning some prefix value
expect(typeof data.result.prefix).toBe('number');
});
});
describe('POST /api/cidr/split', () => {
it('should split /22 into four /24 subnets', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '192.168.0.0/22',
targetPrefix: 24,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'split');
const result = data.result;
expect(result.subnets).toHaveLength(4);
// Check that subnets contain objects with cidr property
const cidrList = result.subnets.map((subnet: any) => subnet.cidr);
expect(cidrList).toContain('192.168.0.0/24');
expect(cidrList).toContain('192.168.1.0/24');
expect(cidrList).toContain('192.168.2.0/24');
expect(cidrList).toContain('192.168.3.0/24');
// Check additional subnet properties
expect(result.subnets[0]).toHaveProperty('network');
expect(result.subnets[0]).toHaveProperty('broadcast');
expect(result.subnets[0]).toHaveProperty('totalHosts');
expect(result.subnets[0]).toHaveProperty('usableHosts');
// Check stats
expect(result.stats).toHaveProperty('childCount', 4);
expect(result.stats).toHaveProperty('childPrefix', 24);
});
it('should split by count into equal parts', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '10.0.0.0/24',
count: 4,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'split');
const result = data.result;
expect(result.subnets).toHaveLength(4);
const cidrList = result.subnets.map((subnet: any) => subnet.cidr);
expect(cidrList).toContain('10.0.0.0/26');
expect(cidrList).toContain('10.0.0.64/26');
expect(cidrList).toContain('10.0.0.128/26');
expect(cidrList).toContain('10.0.0.192/26');
expect(result.stats).toHaveProperty('childCount', 4);
expect(result.stats).toHaveProperty('childPrefix', 26);
});
it('should handle IPv6 splitting', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '2001:db8::/48',
targetPrefix: 64,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'split');
const result = data.result;
expect(result.subnets.length).toBeGreaterThan(0);
// IPv6 subnets should have cidr property like IPv4
const cidrList = result.subnets.map((subnet: any) => subnet.cidr || subnet);
cidrList.forEach((cidr: string) => {
expect(isValidCIDR(cidr)).toBe(true);
expect(cidr).toMatch(/\/64$/);
});
});
it('should handle alternative parameter names (prefix, parts)', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '192.168.0.0/22',
prefix: 24,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'split');
expect(data.result.subnets).toHaveLength(4);
const { status: status2, data: data2 } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '10.0.0.0/24',
parts: 4,
});
expect(status2).toBe(200);
validateSuccessResponse(data2, 'split');
expect(data2.result.subnets).toHaveLength(4);
});
it('should handle invalid target prefix', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '192.168.0.0/24',
targetPrefix: 22, // Can't split /24 into larger /22
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API handles invalid splits gracefully, may return empty subnets or original CIDR
expect(data.result.subnets).toBeDefined();
});
it('should require either targetPrefix or count', async () => {
const { status, data } = await makeApiRequest('/api/cidr/split', 'POST', {
cidr: '192.168.0.0/24',
});
expect(status).toBe(500);
expect(data.success).toBe(false);
expect(data.error).toBeDefined();
});
});
describe('POST /api/cidr/deaggregate', () => {
it('should deaggregate mixed CIDR and range input', async () => {
const { status, data } = await makeApiRequest('/api/cidr/deaggregate', 'POST', {
input: '192.168.0.0/22\n10.0.0.0-10.0.0.255',
targetPrefix: 24,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'deaggregate');
const result = data.result;
expect(result.subnets).toContain('192.168.0.0/24');
expect(result.subnets).toContain('192.168.1.0/24');
expect(result.subnets).toContain('192.168.2.0/24');
expect(result.subnets).toContain('192.168.3.0/24');
expect(result.subnets).toContain('10.0.0.0/24');
// API doesn't return targetPrefix in response, only the computed subnets
expect(result.totalSubnets).toBeGreaterThan(0);
});
it('should handle single IP addresses', async () => {
const { status, data } = await makeApiRequest('/api/cidr/deaggregate', 'POST', {
input: '192.168.1.1\n192.168.1.2',
targetPrefix: 32,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'deaggregate');
const result = data.result;
expect(result.subnets).toContain('192.168.1.1/32');
expect(result.subnets).toContain('192.168.1.2/32');
});
it('should handle large network deaggregation', async () => {
const { status, data } = await makeApiRequest('/api/cidr/deaggregate', 'POST', {
input: '10.0.0.0/16',
targetPrefix: 24,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'deaggregate');
const result = data.result;
expect(result.subnets.length).toBe(256); // /16 split into /24s
expect(result.subnets[0]).toBe('10.0.0.0/24');
expect(result.subnets[255]).toBe('10.0.255.0/24');
});
it('should handle empty input', async () => {
const { status, data } = await makeApiRequest('/api/cidr/deaggregate', 'POST', {
input: '',
targetPrefix: 24,
});
expect(status).toBe(200);
validateSuccessResponse(data, 'deaggregate');
expect(data.result.subnets).toHaveLength(0);
});
it('should handle invalid IP ranges', async () => {
const { status, data } = await makeApiRequest('/api/cidr/deaggregate', 'POST', {
input: 'invalid-range',
targetPrefix: 24,
});
expect(status).toBe(200);
expect(data.success).toBe(true);
// API handles invalid ranges gracefully, may return empty result
expect(data.result.subnets).toBeDefined();
});
});
describe('POST /api/cidr/compare', () => {
it('should compare two CIDR lists and find differences', async () => {
const { status, data } = await makeApiRequest('/api/cidr/compare', 'POST', {
listA: '192.168.1.0/24\n10.0.0.0/24\n172.16.0.0/24',
listB: '192.168.1.0/24\n10.0.1.0/24\n203.0.113.0/24',
});
expect(status).toBe(200);
validateSuccessResponse(data, 'compare');
const result = data.result;
expect(result.added).toContain('10.0.1.0/24');
expect(result.added).toContain('203.0.113.0/24');
expect(result.removed).toContain('10.0.0.0/24');
expect(result.removed).toContain('172.16.0.0/24');
expect(result.unchanged).toContain('192.168.1.0/24');
expect(result.summary.addedCount).toBe(2);
expect(result.summary.removedCount).toBe(2);
expect(result.summary.unchangedCount).toBe(1);
});
it('should handle empty lists', async () => {
const { status, data } = await makeApiRequest('/api/cidr/compare', 'POST', {
listA: '',
listB: '192.168.1.0/24\n10.0.0.0/24',
});
expect(status).toBe(200);
validateSuccessResponse(data, 'compare');
const result = data.result;
expect(result.added).toHaveLength(2);
expect(result.removed).toHaveLength(0);
expect(result.unchanged).toHaveLength(0);
});
it('should handle identical lists', async () => {
const { status, data } = await makeApiRequest('/api/cidr/compare', 'POST', {
listA: '192.168.1.0/24\n10.0.0.0/24',
listB: '192.168.1.0/24\n10.0.0.0/24',
});
expect(status).toBe(200);
validateSuccessResponse(data, 'compare');
const result = data.result;
expect(result.added).toHaveLength(0);
expect(result.removed).toHaveLength(0);
expect(result.unchanged).toHaveLength(2);
});
it('should handle duplicate entries in lists', async () => {
const { status, data } = await makeApiRequest('/api/cidr/compare', 'POST', {
listA: '192.168.1.0/24\n192.168.1.0/24\n10.0.0.0/24',
listB: '192.168.1.0/24\n10.0.1.0/24',
});
expect(status).toBe(200);
validateSuccessResponse(data, 'compare');
const result = data.result;
// Should deduplicate entries
expect(result.unchanged).toContain('192.168.1.0/24');
expect(result.removed).toContain('10.0.0.0/24');
expect(result.added).toContain('10.0.1.0/24');
});
it('should handle network changes', async () => {
const { status, data } = await makeApiRequest('/api/cidr/compare', 'POST', {
listA: '10.0.0.0/8\n172.16.0.0/12',
listB: '10.0.0.0/16\n10.1.0.0/16\n172.16.0.0/12\n192.168.0.0/16',
});
expect(status).toBe(200);
validateSuccessResponse(data, 'compare');
const result = data.result;
expect(result.unchanged).toContain('172.16.0.0/12');
expect(result.added.length).toBeGreaterThan(0);
expect(result.removed.length).toBeGreaterThan(0);
});
});
});