Add comprehensive unit tests for utils and generators (208 total tests)

Author: johnbillion

src/test/suite/docblockGenerator.test.ts

@@ -0,0 +1,164 @@
+import * as assert from 'assert';
+import { generateDocblockLines } from '../../generators/docblockGenerator';
+import { Tag } from '../../types';
+
+suite('Docblock Generator Test Suite', () => {
+	suite('generateDocblockLines', () => {
+		test('Should generate basic docblock with description only', () => {
+			const description = 'My function description';
+			const params: Tag[] = [];
+
+			const lines = generateDocblockLines(description, params);
+
+			assert.ok(lines.length > 0);
+			assert.strictEqual(lines[0], '/**');
+			assert.strictEqual(lines[1], ` * ${description}`);
+			assert.strictEqual(lines[lines.length - 1], ' */');
+		});
+
+		test('Should include param tags', () => {
+			const description = 'Function with parameters';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], variable: '$content', content: 'The content' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLine = lines.find((line) => line.includes('@param'));
+			assert.ok(paramLine, 'Should have a @param line');
+			assert.ok(paramLine?.includes('string'));
+			assert.ok(paramLine?.includes('$content'));
+			assert.ok(paramLine?.includes('The content'));
+		});
+
+		test('Should include multiple param tags', () => {
+			const description = 'Function with multiple parameters';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], variable: '$content', content: 'The content' },
+				{ name: 'param', types: ['int'], variable: '$id', content: 'The ID' },
+				{ name: 'param', types: ['bool'], variable: '$force', content: 'Force update' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLines = lines.filter((line) => line.includes('@param'));
+			assert.strictEqual(paramLines.length, 3, 'Should have 3 @param lines');
+		});
+
+		test('Should handle union types in params', () => {
+			const description = 'Function with union type';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string', 'int', 'null'], variable: '$value', content: 'The value' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLine = lines.find((line) => line.includes('@param'));
+			assert.ok(paramLine);
+			assert.ok(paramLine?.includes('string|int|null'));
+		});
+
+		test('Should include return tag when provided', () => {
+			const description = 'Function with return value';
+			const params: Tag[] = [];
+			const returnParam: Tag = {
+				name: 'return',
+				types: ['bool'],
+				content: 'True on success',
+			};
+
+			const lines = generateDocblockLines(description, params, returnParam);
+
+			const returnLine = lines.find((line) => line.includes('@return'));
+			assert.ok(returnLine, 'Should have a @return line');
+			assert.ok(returnLine?.includes('bool'));
+			assert.ok(returnLine?.includes('True on success'));
+		});
+
+		test('Should align param types and names', () => {
+			const description = 'Function with aligned params';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], variable: '$a', content: 'Short' },
+				{ name: 'param', types: ['int'], variable: '$longer_name', content: 'Longer' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLines = lines.filter((line) => line.includes('@param'));
+			assert.strictEqual(paramLines.length, 2);
+
+			// Check that padding is applied (types and names should be padded)
+			assert.ok(paramLines[0].includes('string'));
+			assert.ok(paramLines[1].includes('int'));
+		});
+
+		test('Should handle params without types', () => {
+			const description = 'Function with untyped param';
+			const params: Tag[] = [
+				{ name: 'param', variable: '$value', content: 'Some value' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLine = lines.find((line) => line.includes('@param'));
+			assert.ok(paramLine);
+			assert.ok(paramLine?.includes('$value'));
+			assert.ok(paramLine?.includes('Some value'));
+		});
+
+		test('Should handle params without variable names', () => {
+			const description = 'Function with unnamed param';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], content: 'Some value' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			const paramLine = lines.find((line) => line.includes('@param'));
+			assert.ok(paramLine);
+			assert.ok(paramLine?.includes('string'));
+		});
+
+		test('Should generate complete docblock structure', () => {
+			const description = 'Complete function';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], variable: '$content', content: 'The content' },
+			];
+			const returnParam: Tag = {
+				name: 'return',
+				types: ['string'],
+				content: 'Modified content',
+			};
+
+			const lines = generateDocblockLines(description, params, returnParam);
+
+			assert.strictEqual(lines[0], '/**');
+			assert.ok(lines[1].includes('Complete function'));
+			assert.ok(lines.some((line) => line.includes('@param')));
+			assert.ok(lines.some((line) => line.includes('@return')));
+			assert.strictEqual(lines[lines.length - 1], ' */');
+		});
+
+		test('Should handle empty description', () => {
+			const description = '';
+			const params: Tag[] = [];
+
+			const lines = generateDocblockLines(description, params);
+
+			assert.strictEqual(lines[0], '/**');
+			assert.strictEqual(lines[1], ' * ');
+			assert.strictEqual(lines[lines.length - 1], ' */');
+		});
+
+		test('Should include blank line after description', () => {
+			const description = 'My function';
+			const params: Tag[] = [
+				{ name: 'param', types: ['string'], variable: '$value', content: 'Value' },
+			];
+
+			const lines = generateDocblockLines(description, params);
+
+			assert.strictEqual(lines[2], ' *', 'Third line should be blank comment line');
+		});
+	});
+});

src/test/suite/hookHelpers.test.ts

@@ -0,0 +1,206 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { getHook, getHookSlug, getHookDescription, getHookCompletion } from '../../utils/hookHelpers';
+
+suite('Hook Helpers Test Suite', () => {
+	suite('getHook', () => {
+		test('Should find common action hooks', () => {
+			const knownActions = ['init', 'wp_head', 'admin_init', 'wp_footer'];
+
+			knownActions.forEach((hookName) => {
+				const hook = getHook(hookName);
+				assert.ok(hook, `Should find action: ${hookName}`);
+				assert.strictEqual(hook.name, hookName);
+			});
+		});
+
+		test('Should find common filter hooks', () => {
+			const knownFilters = ['the_content', 'the_title', 'body_class'];
+
+			knownFilters.forEach((hookName) => {
+				const hook = getHook(hookName);
+				assert.ok(hook, `Should find filter: ${hookName}`);
+				assert.strictEqual(hook.name, hookName);
+			});
+		});
+
+		test('Should return undefined for non-existent hooks', () => {
+			const nonExistent = getHook('non_existent_hook_12345');
+			assert.strictEqual(nonExistent, undefined);
+		});
+
+		test('Should find hooks by alias if they exist', () => {
+			// Try to find any hook with aliases and test it
+			const hook = getHook('init');
+			if (hook && hook.aliases && hook.aliases.length > 0) {
+				const aliasHook = getHook(hook.aliases[0]);
+				assert.ok(aliasHook, 'Should find hook by alias');
+			}
+		});
+
+		test('Should have required properties', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+			assert.ok(hook.name);
+			assert.ok(hook.doc);
+			assert.ok(hook.doc.description);
+		});
+
+		test('Should check filters before actions', () => {
+			// If a name exists in both, should return the filter
+			const hook = getHook('the_content');
+			assert.ok(hook);
+			// the_content is a filter, so it should be found first
+			assert.strictEqual(hook.name, 'the_content');
+		});
+	});
+
+	suite('getHookSlug', () => {
+		test('Should convert hook name to slug', () => {
+			const tests = [
+				{ hook: { name: 'init', doc: {} } as any, expected: 'init' },
+				{ hook: { name: 'wp_head', doc: {} } as any, expected: 'wp_head' },
+				{ hook: { name: 'the_content', doc: {} } as any, expected: 'the_content' },
+			];
+
+			tests.forEach(({ hook, expected }) => {
+				const slug = getHookSlug(hook);
+				assert.strictEqual(slug, expected);
+			});
+		});
+
+		test('Should remove invalid characters', () => {
+			const tests = [
+				{ hook: { name: 'hook@123', doc: {} } as any, expected: 'hook' },
+				{ hook: { name: 'hook#name', doc: {} } as any, expected: 'hookname' },
+				{ hook: { name: 'hook name', doc: {} } as any, expected: 'hookname' },
+			];
+
+			tests.forEach(({ hook, expected }) => {
+				const slug = getHookSlug(hook);
+				assert.strictEqual(slug, expected);
+			});
+		});
+
+		test('Should preserve underscores and hyphens', () => {
+			const hook = { name: 'my-hook_name', doc: {} } as any;
+			const slug = getHookSlug(hook);
+			assert.strictEqual(slug, 'my-hook_name');
+		});
+
+		test('Should convert to lowercase', () => {
+			const hook = { name: 'MyHook', doc: {} } as any;
+			const slug = getHookSlug(hook);
+			assert.strictEqual(slug, 'myhook');
+		});
+	});
+
+	suite('getHookDescription', () => {
+		test('Should return MarkdownString', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const description = getHookDescription(hook);
+			assert.ok(description instanceof vscode.MarkdownString);
+		});
+
+		test('Should include long description', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const description = getHookDescription(hook);
+			const value = description.value;
+
+			assert.ok(value.length > 0);
+			assert.ok(value.includes(hook.doc.long_description || hook.doc.description));
+		});
+
+		test('Should include developer.wordpress.org link', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const description = getHookDescription(hook);
+			assert.ok(description.value.includes('developer.wordpress.org'));
+			assert.ok(description.value.includes('/reference/hooks/'));
+		});
+
+		test('Should include param tags if present', () => {
+			const hook = getHook('the_content');
+			assert.ok(hook);
+
+			const description = getHookDescription(hook);
+			const params = hook.doc.tags?.filter((tag) => tag.name === 'param');
+
+			if (params && params.length > 0) {
+				assert.ok(description.value.includes('@param'));
+			}
+		});
+
+		test('Should format param tags with types and variables', () => {
+			const hook = getHook('the_content');
+			assert.ok(hook);
+
+			const description = getHookDescription(hook);
+			const params = hook.doc.tags?.filter((tag) => tag.name === 'param');
+
+			if (params && params.length > 0 && params[0].variable) {
+				assert.ok(description.value.includes(params[0].variable));
+			}
+		});
+	});
+
+	suite('getHookCompletion', () => {
+		test('Should return CompletionItem', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+			assert.ok(completion instanceof vscode.CompletionItem);
+		});
+
+		test('Should set label to hook name', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+			assert.strictEqual(completion.label, 'init');
+		});
+
+		test('Should set detail to description', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+			assert.strictEqual(completion.detail, hook.doc.description);
+		});
+
+		test('Should set documentation to formatted description', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+			assert.ok(completion.documentation instanceof vscode.MarkdownString);
+		});
+
+		test('Should set filterText to aliases if present', () => {
+			// Find a hook with aliases
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+
+			if (hook.aliases && hook.aliases.length > 0) {
+				assert.ok(completion.filterText);
+				assert.ok(completion.filterText?.includes(hook.aliases[0]));
+			}
+		});
+
+		test('Should set kind to Value', () => {
+			const hook = getHook('init');
+			assert.ok(hook);
+
+			const completion = getHookCompletion(hook);
+			assert.strictEqual(completion.kind, vscode.CompletionItemKind.Value);
+		});
+	});
+});