mirror of
https://github.com/lissy93/networking-toolbox.git
synced 2026-11-21 05:24:09 +03:00
390 lines
14 KiB
TypeScript
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);
|
|
});
|
|
});
|
|
}); |