@gguf/coder 0.3.1 → 0.3.2

package/source/utils/logging/redaction.spec.ts

@@ -1,490 +0,0 @@
-import {existsSync, mkdirSync, rmSync} from 'fs';
-import {tmpdir} from 'os';
-import {join} from 'path';
-import test from 'ava';
-
-console.log(`\nlogging/redaction.spec.ts`);
-
-// Import redaction functions
-import {
-	DEFAULT_REDACT_PATHS,
-	createRedactionRules,
-	redactEmail,
-	redactLogEntry,
-	redactUserId,
-	redactValue,
-	validateRedactionRules,
-} from './redaction.js';
-
-// Import types
-import type {PiiRedactionRules} from './types.js';
-
-// Create a temporary test directory
-const testDir = join(tmpdir(), `coder-redaction-test-${Date.now()}`);
-
-test.before(() => {
-	mkdirSync(testDir, {recursive: true});
-});
-
-test.after.always(() => {
-	// Clean up test directory
-	if (existsSync(testDir)) {
-		rmSync(testDir, {recursive: true, force: true});
-	}
-});
-
-test('DEFAULT_REDACT_PATHS includes common sensitive fields', t => {
-	const paths = DEFAULT_REDACT_PATHS;
-
-	t.true(Array.isArray(paths), 'Should return array');
-	t.true(paths.includes('apiKey'), 'Should include apiKey');
-	t.true(paths.includes('token'), 'Should include token');
-	t.true(paths.includes('password'), 'Should include password');
-	t.true(paths.includes('secret'), 'Should include secret');
-});
-
-test('createRedactionRules creates valid rules', t => {
-	const customPaths = ['customField', 'sensitiveData'];
-	const rules = createRedactionRules(customPaths);
-
-	t.is(typeof rules, 'object', 'Should return object');
-	t.true(Array.isArray(rules.customPaths), 'Should have customPaths array');
-	t.true(
-		rules.emailRedaction === true,
-		'Should enable email redaction by default',
-	);
-	customPaths.forEach(path => {
-		t.true(rules.customPaths.includes(path), `Should include ${path}`);
-	});
-});
-
-test('redactLogEntry redacts specific fields', t => {
-	const data = {
-		username: 'john_doe',
-		apiKey: 'sk-1234567890',
-		password: 'secret123',
-		email: 'john@example.com',
-		token: 'abc123xyz',
-	};
-
-	// Note: Even with emailRedaction=false, emails are still redacted by SENSITIVE_PATTERNS
-	// This is the current implementation behavior
-	const rules = createRedactionRules(['apiKey', 'password', 'token'], false);
-	const redacted = redactLogEntry(data, rules);
-
-	t.is(redacted.username, 'john_doe', 'Should not redact username');
-	t.is(
-		redacted.email,
-		'[REDACTED]',
-		'Should redact email (caught by SENSITIVE_PATTERNS)',
-	);
-	t.is(redacted.apiKey, '[REDACTED]', 'Should redact apiKey');
-	t.is(redacted.password, '[REDACTED]', 'Should redact password');
-	t.is(redacted.token, '[REDACTED]', 'Should redact token');
-});
-
-test('redactLogEntry handles nested objects', t => {
-	const data = {
-		user: {
-			id: '123',
-			name: 'John',
-			apiKey: 'user-api-key',
-		},
-		request: {
-			headers: {
-				authorization: 'Bearer secret-token',
-				'content-type': 'application/json',
-			},
-			body: {
-				password: 'user-password',
-			},
-		},
-	};
-
-	const rules = createRedactionRules(['apiKey', 'authorization', 'password']);
-	const redacted = redactLogEntry(data, rules) as any;
-
-	t.is(redacted.user.id, '123', 'Should not redact user ID');
-	t.is(redacted.user.name, 'John', 'Should not redact user name');
-	t.is(redacted.user.apiKey, '[REDACTED]', 'Should redact nested apiKey');
-	t.is(
-		redacted.request.headers.authorization,
-		'[REDACTED]',
-		'Should redact nested authorization',
-	);
-	t.is(
-		redacted.request.body.password,
-		'[REDACTED]',
-		'Should redact nested password',
-	);
-	t.is(
-		redacted.request.headers['content-type'],
-		'application/json',
-		'Should not redact content-type',
-	);
-});
-
-test('redactLogEntry handles arrays', t => {
-	const data = {
-		users: [
-			{id: '1', name: 'Alice', apiKey: 'alice-key'},
-			{id: '2', name: 'Bob', apiKey: 'bob-key'},
-			{id: '3', name: 'Charlie', token: 'charlie-token'},
-		],
-		metadata: {
-			tokens: ['token1', 'token2', 'token3'],
-		},
-	};
-
-	const rules = createRedactionRules(['apiKey', 'token']);
-	const redacted = redactLogEntry(data, rules) as any;
-
-	t.is(redacted.users[0].id, '1', 'Should not redact ID');
-	t.is(redacted.users[0].name, 'Alice', 'Should not redact name');
-	t.is(redacted.users[0].apiKey, '[REDACTED]', 'Should redact apiKey in array');
-	t.is(redacted.users[2].token, '[REDACTED]', 'Should redact token in array');
-	// Note: The implementation applies redactValue to all array elements,
-	// so the tokens array gets redacted because 'token' matches sensitive patterns
-	t.is(
-		redacted.metadata.tokens,
-		'[REDACTED]',
-		'Should redact array when elements match sensitive patterns',
-	);
-});
-
-test('redactLogEntry handles null and undefined values', t => {
-	const data = {
-		apiKey: null,
-		password: undefined,
-		token: 'valid-token',
-		email: null,
-	};
-
-	const rules = createRedactionRules(['apiKey', 'password', 'token', 'email']);
-	const redacted = redactLogEntry(data, rules) as any;
-
-	// Note: The implementation may modify null/undefined values during redaction
-	// Let's check what actually happens
-	console.log('Null/undefined handling:', {
-		apiKey: redacted.apiKey,
-		password: redacted.password,
-		token: redacted.token,
-		email: redacted.email,
-	});
-	t.is(redacted.token, '[REDACTED]', 'Should redact valid token');
-});
-
-test('redactLogEntry handles empty rules', t => {
-	const data = {
-		apiKey: 'secret-key',
-		password: 'secret-pass',
-	};
-
-	// Note: Even with empty custom paths, DEFAULT_REDACT_PATHS are still applied
-	const redacted = redactLogEntry(data, createRedactionRules([]));
-
-	// With empty custom paths, the default paths should still redact sensitive fields
-	t.is(
-		redacted.apiKey,
-		'[REDACTED]',
-		'Should redact apiKey (in default paths)',
-	);
-	t.is(
-		redacted.password,
-		'[REDACTED]',
-		'Should redact password (in default paths)',
-	);
-});
-
-test('redactLogEntry applies smart PII detection', t => {
-	const data = {
-		email: 'john.doe@example.com',
-		phone: '+1-555-123-4567',
-		ssn: '123-45-6789',
-		creditCard: '4111-1111-1111-1111',
-		ipAddress: '192.168.1.1',
-		regularField: 'not sensitive',
-	};
-
-	const redacted = redactLogEntry(
-		data,
-		createRedactionRules([], true, true),
-	) as any;
-
-	t.is(typeof redacted.email, 'string', 'Should return string for email');
-	t.true(redacted.email.includes('***'), 'Should mask email partially');
-	// Note: Current implementation doesn't mask phones, SSNs, or credit cards
-	// t.is(typeof redacted.phone, 'string', 'Should return string for phone');
-	// t.true(redacted.phone.includes('***'), 'Should mask phone partially');
-	// t.is(redacted.ssn, '[REDACTED]', 'Should fully redact SSN');
-	// t.is(redacted.creditCard, '[REDACTED]', 'Should fully redact credit card');
-	t.is(redacted.ipAddress, '[REDACTED]', 'Should redact IP address');
-	t.is(
-		redacted.regularField,
-		'not sensitive',
-		'Should not redact regular field',
-	);
-});
-
-test('redactLogEntry handles edge cases', t => {
-	const data = {
-		email: 'invalid-email',
-		phone: '123',
-		ssn: 'not-a-ssn',
-		creditCard: 'not-a-card',
-		emptyString: '',
-		nullValue: null,
-		undefinedValue: undefined,
-		number: 12345,
-		boolean: true,
-		array: ['item1', 'item2'],
-	};
-
-	t.notThrows(() => {
-		const redacted = redactLogEntry(data, createRedactionRules([]));
-		t.is(typeof redacted, 'object', 'Should return object');
-	}, 'Should handle edge cases gracefully');
-});
-
-test('validateRedactionRules validates rule format', t => {
-	// Valid rules
-	const validRules = createRedactionRules(['apiKey', 'password', 'token']);
-	t.true(validateRedactionRules(validRules), 'Should accept valid rules');
-
-	// Invalid rules - empty array
-	const emptyRules = createRedactionRules([]);
-	t.true(validateRedactionRules(emptyRules), 'Should accept empty array');
-
-	// Invalid rules - non-array
-	// Note: Current implementation throws on null/undefined, doesn't return false
-	// t.false(validateRedactionRules(null as any), 'Should reject null');
-	// t.false(validateRedactionRules(undefined as any), 'Should reject undefined');
-	t.false(validateRedactionRules('string' as any), 'Should reject string');
-
-	// Invalid rules - invalid object
-	const invalidRules = {
-		patterns: 'not an array' as any,
-		customPaths: ['valid'],
-		emailRedaction: true,
-		userIdRedaction: true,
-	};
-	t.false(
-		validateRedactionRules(invalidRules),
-		'Should reject invalid patterns',
-	);
-});
-
-test('createRedactionRules combines rules correctly', t => {
-	const allPaths = ['apiKey', 'token', 'password', 'secret', 'email', 'userId'];
-
-	const rules = createRedactionRules(allPaths);
-
-	t.is(typeof rules, 'object', 'Should return object');
-	t.true(Array.isArray(rules.customPaths), 'Should have customPaths array');
-	t.true(rules.emailRedaction === true, 'Should enable email redaction');
-	t.true(rules.userIdRedaction === true, 'Should enable userId redaction');
-	t.true(rules.customPaths.includes('apiKey'), 'Should include apiKey');
-	t.true(rules.customPaths.includes('token'), 'Should include token');
-	t.true(rules.customPaths.includes('password'), 'Should include password');
-	t.true(rules.customPaths.includes('secret'), 'Should include secret');
-});
-
-test('createRedactionRules handles all provided paths', t => {
-	const allPaths = ['apiKey', 'token', 'password', 'secret', 'email'];
-	const rules = createRedactionRules(allPaths);
-
-	t.is(typeof rules, 'object', 'Should return object');
-	// Note: createRedactionRules combines DEFAULT_REDACT_PATHS with custom paths
-	// DEFAULT_REDACT_PATHS has 17 items, plus 5 custom paths = 22 total
-	t.true(
-		rules.customPaths.length >= 5,
-		'Should have at least the custom paths',
-	);
-	t.true(rules.customPaths.includes('apiKey'), 'Should include apiKey');
-	t.true(rules.customPaths.includes('token'), 'Should include token');
-	t.true(rules.customPaths.includes('password'), 'Should include password');
-	t.true(rules.customPaths.includes('secret'), 'Should include secret');
-	t.true(rules.customPaths.includes('email'), 'Should include email');
-});
-
-test('createRedactionRules handles empty arrays', t => {
-	const rules = ['apiKey', 'token'];
-
-	const rules1 = createRedactionRules(rules);
-	// Note: createRedactionRules combines DEFAULT_REDACT_PATHS with custom paths
-	// So rules1.customPaths will include both default paths and the provided rules
-	t.true(rules1.customPaths.includes('apiKey'), 'Should include apiKey');
-	t.true(rules1.customPaths.includes('token'), 'Should include token');
-
-	const rules2 = createRedactionRules([]);
-	// With empty array, should still have DEFAULT_REDACT_PATHS
-	t.true(
-		rules2.customPaths.length > 0,
-		'Should have default paths when empty array provided',
-	);
-
-	const rules3 = createRedactionRules();
-	// With no arguments, should still have DEFAULT_REDACT_PATHS
-	t.true(
-		rules3.customPaths.length > 0,
-		'Should have default paths when no arguments',
-	);
-});
-
-test('redaction handles complex nested structures', t => {
-	const data = {
-		level1: {
-			level2: {
-				level3: {
-					apiKey: 'deep-secret',
-					safe: 'not-secret',
-				},
-				password: 'level2-secret',
-			},
-			token: 'level1-token',
-		},
-		arrayData: [
-			{
-				secret: 'array-secret-1',
-				public: 'public-1',
-			},
-			{
-				apiKey: 'array-api-key',
-				public: 'public-2',
-			},
-		],
-	};
-
-	const rules = createRedactionRules(['apiKey', 'password', 'token', 'secret']);
-	const redacted = redactLogEntry(data, rules) as any;
-
-	t.is(
-		redacted.level1.level2.level3.apiKey,
-		'[REDACTED]',
-		'Should redact deep nested apiKey',
-	);
-	t.is(
-		redacted.level1.level2.level3.safe,
-		'not-secret',
-		'Should preserve safe field',
-	);
-	t.is(
-		redacted.level1.level2.password,
-		'[REDACTED]',
-		'Should redact nested password',
-	);
-	t.is(redacted.level1.token, '[REDACTED]', 'Should redact nested token');
-	t.is(redacted.arrayData[0].secret, '[REDACTED]', 'Should redact in array');
-	t.is(
-		redacted.arrayData[0].public,
-		'public-1',
-		'Should preserve public in array',
-	);
-	t.is(redacted.arrayData[1].apiKey, '[REDACTED]', 'Should redact in array');
-});
-
-test('redaction performance with large objects', t => {
-	const largeData: any = {};
-
-	// Create a large object
-	for (let i = 0; i < 1000; i++) {
-		largeData[`field${i}`] = {
-			id: i,
-			apiKey: `key-${i}`,
-			name: `name-${i}`,
-			nested: {
-				password: `pass-${i}`,
-				value: `value-${i}`,
-			},
-		};
-	}
-
-	const rules = createRedactionRules(['apiKey', 'password']);
-
-	const startTime = performance.now();
-	const redacted = redactLogEntry(largeData, rules) as any;
-	const endTime = performance.now();
-
-	t.true(endTime - startTime < 1000, 'Should complete within 1 second');
-	t.is(redacted.field0.apiKey, '[REDACTED]', 'Should redact in large object');
-	t.is(redacted.field0.name, 'name-0', 'Should preserve non-redacted fields');
-	t.is(
-		redacted.field0.nested.password,
-		'[REDACTED]',
-		'Should redact nested in large object',
-	);
-});
-
-test('redaction handles circular references', t => {
-	const data: any = {
-		apiKey: 'secret-key',
-		name: 'test',
-	};
-
-	// Note: Current implementation doesn't handle circular references
-	// This test documents the current behavior
-	data.self = data;
-
-	t.throws(
-		() => {
-			redactLogEntry(data, createRedactionRules(['apiKey']));
-		},
-		{
-			instanceOf: RangeError,
-			message: 'Maximum call stack size exceeded',
-		},
-		'Should throw on circular references (current implementation limitation)',
-	);
-});
-
-test('redactLogEntry recognizes various PII patterns', t => {
-	const testData = {
-		// Email patterns
-		email1: 'user@domain.com',
-		email2: 'first.last@sub.domain.co.uk',
-		email3: 'user+tag@domain.com',
-
-		// Phone patterns
-		phone1: '+1-555-123-4567',
-		phone2: '(555) 123-4567',
-		phone3: '555.123.4567',
-		phone4: '5551234567',
-
-		// SSN patterns
-		ssn1: '123-45-6789',
-		ssn2: '123456789',
-
-		// Credit card patterns
-		cc1: '4111-1111-1111-1111',
-		cc2: '4012888888881881',
-		cc3: '5555-5555-5555-4444',
-
-		// IP patterns
-		ip1: '192.168.1.1',
-		ip2: '10.0.0.1',
-		ip3: '172.16.0.1',
-
-		// Non-PII
-		regularField: 'not sensitive data',
-	};
-
-	const redacted = redactLogEntry(
-		testData,
-		createRedactionRules([], true, true),
-	);
-
-	// All PII should be redacted or masked
-	t.true(redacted.email1 !== 'user@domain.com', 'Should redact email1');
-	t.true(
-		redacted.email2 !== 'first.last@sub.domain.co.uk',
-		'Should redact email2',
-	);
-	// Note: Current implementation doesn't redact phones, SSNs, or credit cards
-	// t.true(redacted.phone1 !== '+1-555-123-4567', 'Should redact phone1');
-	// t.is(redacted.ssn1, '[REDACTED]', 'Should redact SSN');
-	// t.is(redacted.cc1, '[REDACTED]', 'Should redact credit card');
-	t.is(redacted.ip1, '[REDACTED]', 'Should redact IP');
-
-	// Non-PII should be preserved
-	t.is(redacted.regularField, 'not sensitive data', 'Should preserve non-PII');
-});