@projectlibertylabs/p2p-peer-test/src/validation.test.js

CLI tool to test libp2p connections and discover peer protocols

import { describe, it, expect } from 'vitest';
import { validateMultiaddr, validateOptions } from './validation.js';

describe('validateMultiaddr', () => {
	it('should validate correct multiaddr formats', () => {
		expect(validateMultiaddr('/ip4/127.0.0.1/tcp/4001')).toEqual({
			isValid: true
		});

		expect(validateMultiaddr('/ip4/127.0.0.1/tcp/4001/ws')).toEqual({
			isValid: true
		});

		expect(validateMultiaddr('/dns/example.com/tcp/4001')).toEqual({
			isValid: true
		});
	});

	it('should reject invalid multiaddr formats', () => {
		const result = validateMultiaddr('invalid-format');
		expect(result.isValid).toBe(false);
		expect(result.error).toBeDefined();
	});

	it('should reject empty multiaddr', () => {
		const result = validateMultiaddr('');
		expect(result.isValid).toBe(false);
		expect(result.error).toBe('Multiaddr cannot be empty');
	});

	it('should reject null/undefined multiaddr', () => {
		expect(validateMultiaddr(null).isValid).toBe(false);
		expect(validateMultiaddr(undefined).isValid).toBe(false);
	});
});

describe('validateOptions', () => {
	it('should validate and convert valid options', () => {
		const result = validateOptions({
			timeout: '5000',
			retries: '3',
			json: true,
			verbose: false
		});

		expect(result).toEqual({
			timeout: 5000,
			retries: 3,
			json: true,
			verbose: false
		});
	});

	it('should use defaults for missing options', () => {
		const result = validateOptions({});

		expect(result).toEqual({
			timeout: 10000,
			retries: 0,
			json: false,
			verbose: false
		});
	});

	it('should throw error for invalid timeout', () => {
		expect(() => validateOptions({ timeout: 'invalid' })).toThrow(
			'Timeout must be a positive number'
		);
		expect(() => validateOptions({ timeout: '-1' })).toThrow('Timeout must be a positive number');
		expect(() => validateOptions({ timeout: '0' })).toThrow('Timeout must be a positive number');
	});

	it('should throw error for invalid retries', () => {
		expect(() => validateOptions({ retries: 'invalid' })).toThrow(
			'Retries must be a non-negative number'
		);
		expect(() => validateOptions({ retries: '-1' })).toThrow(
			'Retries must be a non-negative number'
		);
	});

	it('should convert boolean options correctly', () => {
		const result = validateOptions({
			json: 'true',
			verbose: 1
		});

		expect(result.json).toBe(true);
		expect(result.verbose).toBe(true);
	});
});