OpenParable
Skip to content
← Back to skills

Add Test

Testing & Quality
add-test

Add Test is an Agent Skill for testing & quality published in the gitkraken/vscode-gitlens repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Generate unit or E2E test files for existing code

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/gitkraken/vscode-gitlens/blob/HEAD/.claude/skills/add-test/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/add-test, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

/add-test - Generate Tests

Usage

/add-test [type] [target]
  • type — unit (default) or e2e
  • target — File path or feature name to test

Unit Test Template

Creates src/path/__tests__/file.test.ts:

import * as assert from 'assert';
import { functionToTest } from '../file.js';

suite('FeatureName Test Suite', () => {
	suite('functionName', () => {
		test('should handle normal input', () => {
			const result = functionToTest('input');
			assert.strictEqual(result, 'expected');
		});

		test('should handle edge case', () => {
			const result = functionToTest('');
			assert.strictEqual(result, undefined);
		});

		test('should throw on invalid input', () => {
			assert.throws(() => functionToTest(null), /error message/);
		});
	});

	suite('async function', () => {
		test('should resolve with data', async () => {
			const result = await asyncFunction();
			assert.deepStrictEqual(result, { key: 'value' });
		});
	});
});

When mocking is needed, use sinon:

import * as sinon from 'sinon';

let sandbox: sinon.SinonSandbox;
setup(() => {
	sandbox = sinon.createSandbox();
});
teardown(() => {
	sandbox.restore();
});

E2E Test Template

Creates tests/e2e/specs/feature.test.ts:

import { test as base, createTmpDir, expect, GitFixture, MaxTimeout } from '../baseTest.js';

const test = base.extend({
	vscodeOptions: [
		{
			vscodeVersion: process.env.VSCODE_VERSION ?? 'stable',
			setup: async () => {
				const repoDir = await createTmpDir();
				const git = new GitFixture(repoDir);
				await git.init();
				await git.commit('Initial commit', 'README.md', '# Test');
				return repoDir;
			},
		},
		{ scope: 'worker' },
	],
});

test.describe('Feature Name', () => {
	test.describe.configure({ mode: 'serial' });

	test.afterEach(async ({ vscode }) => {
		await vscode.gitlens.resetUI();
	});

	test('should display feature correctly', async ({ vscode }) => {
		await vscode.gitlens.openGitLensSidebar();
		await expect(vscode.page.getByRole('heading')).toContainText('Expected');
	});
});

Instructions

Unit Tests

  1. Read target file to understand exports
  2. Create __tests__/ directory if needed
  3. Cover: normal paths, edge cases (empty/null/undefined), error conditions, async operations
  4. Assertions: assert.strictEqual(), assert.deepStrictEqual(), assert.ok(), assert.throws()

E2E Tests

Use the MCP server to explore, then write the test. Don't guess at selectors — verify them live.

  1. Explore with MCP first — Use /live-inspect to launch VS Code and discover the right selectors:
    launch {}
    execute_command { command: "gitlens.showHomeView" }
    aria_snapshot {}                              # See all UI elements and roles
    inspect_dom { selector: "h1", in_webview: true }  # Find webview content
    screenshot {}                                 # Visual verification
    
  2. Determine Git state needed — what commits, branches, tags does the test need?
  3. Create GitFixture setup — use the methods below
  4. Write the test using selectors discovered via MCP
  5. Validate with MCP — run the test scenario manually through MCP tools to confirm assertions before finalizing:
    • Use inspect_dom to verify element text/visibility
    • Use evaluate to check extension runtime state
    • Use screenshot to visually confirm UI state
  6. Cover: UI presence, user interactions, navigation, error states, Pro vs Community gating
  7. Assertions: expect(locator).toBeVisible(), .toContainText(), .toHaveCount()

E2E Webview Content

Use getGitLensWebview(title, purpose) to get a FrameLocator for webview content:

const webview = await vscode.gitlens.getGitLensWebview('Home', 'webviewView');
await expect(webview!.locator('h1')).toContainText('Expected heading');
await expect(webview!.getByRole('button', { name: /Try Pro/i })).toBeVisible();

Available webviews: Home, Graph, Graph Details, Inspect, Visual File History, Interactive Rebase. Purpose is webviewView (sidebar/panel) or webviewPanel (editor tab) or customEditor.

E2E Pro Feature Gating

// Simulate Pro subscription for the test
using _ = await vscode.gitlens.startSubscriptionSimulation({
	state: 6 /* SubscriptionState.Paid */,
	planId: 'pro',
});
// Pro features now accessible — auto-reverts when scope exits

GitFixture Methods

await git.init()
await git.commit(message, fileName, content)
await git.branch(name)
await git.checkout(name, create?)
await git.tag(name, { message?, ref? })
await git.stash(message?)
await git.worktree(path, branch)
await git.addRemote(name, url)
await git.merge(branch, message?)

Running Tests

pnpm run test -- --grep "FeatureName"           # Unit
pnpm run test:e2e -- tests/e2e/specs/file.test.ts  # E2E

For detailed test running patterns, output interpretation, and debugging: see docs/testing.md.