Skip to content

Commit 2e53c07

Browse files
feggeclaude
fegge
and
claude
committed
test: improve extension test reliability and assertions
- Fix state sharing between tests by adding suiteTeardown cleanup - Restore original weaudit file content after tests complete - Fix addPartiallyAudited test to handle file already being fully audited - Replace showInputBox mocking (doesn't work across extension host) with VS Code commands (acceptSelectedQuickOpenItem, closeQuickOpen) - Improve showMarkedFilesDayLog test to verify actual document content - All tests now have meaningful assertions that can fail 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <[email protected]>
1 parent c184c78 commit 2e53c07

File tree

3 files changed

+167
-116
lines changed

3 files changed

+167
-116
lines changed

‎test/extension/suite/commands.test.ts‎

Lines changed: 126 additions & 105 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@ suite("Command Execution", () => {
3636
const extensionId = "trailofbits.weaudit";
3737
let testFileUri: vscode.Uri;
3838
let workspaceFolder: vscode.WorkspaceFolder;
39+
let originalWeauditContent: string | null = null;
40+
let weauditFilePath: string;
3941

4042
suiteSetup(async () => {
4143
// Ensure extension is activated
@@ -47,6 +49,26 @@ suite("Command Execution", () => {
4749
if (workspaceFolders && workspaceFolders.length > 0) {
4850
workspaceFolder = workspaceFolders[0];
4951
testFileUri = vscode.Uri.file(path.join(workspaceFolder.uri.fsPath, "src", "sample.ts"));
52+
53+
// Save original weaudit file content for restoration after tests
54+
weauditFilePath = getWeauditFilePath(workspaceFolder);
55+
if (fs.existsSync(weauditFilePath)) {
56+
originalWeauditContent = fs.readFileSync(weauditFilePath, "utf-8");
57+
}
58+
}
59+
});
60+
61+
suiteTeardown(async () => {
62+
// Restore original weaudit file content
63+
if (weauditFilePath) {
64+
if (originalWeauditContent !== null) {
65+
fs.writeFileSync(weauditFilePath, originalWeauditContent);
66+
} else if (fs.existsSync(weauditFilePath)) {
67+
// If there was no original file, delete the one created by tests
68+
fs.unlinkSync(weauditFilePath);
69+
}
70+
// Reload the extension's data
71+
await vscode.commands.executeCommand("weAudit.findAndLoadConfigurationFiles");
5072
}
5173
});
5274

@@ -62,7 +84,7 @@ suite("Command Execution", () => {
6284
}
6385

6486
test("weAudit.addFinding creates a new finding entry", async function () {
65-
this.timeout(10000);
87+
this.timeout(15000);
6688

6789
const editor = await openTestFile();
6890
await selectLines(editor, 5, 6);
@@ -71,70 +93,35 @@ suite("Command Execution", () => {
7193
const dataBefore = readWeauditData(workspaceFolder);
7294
const entriesBefore = dataBefore?.treeEntries.length ?? 0;
7395

74-
// Mock the input box to return a label
75-
const originalShowInputBox = vscode.window.showInputBox;
76-
const testLabel = `Test Finding ${Date.now()}`;
77-
(vscode.window as any).showInputBox = async () => testLabel;
96+
// Start the command (this will show the input box)
97+
const commandPromise = vscode.commands.executeCommand("weAudit.addFinding");
7898

79-
try {
80-
await vscode.commands.executeCommand("weAudit.addFinding");
81-
// Wait for data to be persisted
82-
await new Promise((resolve) => setTimeout(resolve, 500));
99+
// Wait for input box to appear
100+
await new Promise((resolve) => setTimeout(resolve, 300));
83101

84-
// Verify that a new entry was added
85-
const dataAfter = readWeauditData(workspaceFolder);
86-
assert.ok(dataAfter, "Data file should exist after adding finding");
87-
assert.ok(dataAfter.treeEntries.length > entriesBefore, "A new entry should be added");
88-
89-
// Verify the entry has the correct label and type
90-
const newEntry = dataAfter.treeEntries.find((e) => e.label === testLabel);
91-
assert.ok(newEntry, "New entry should have the provided label");
92-
assert.strictEqual(newEntry.entryType, 0, "Entry type should be Finding (0)");
93-
assert.ok(
94-
newEntry.locations.some((loc) => loc.startLine === 5 && loc.endLine === 6),
95-
"Entry should have correct line range",
96-
);
97-
} finally {
98-
(vscode.window as any).showInputBox = originalShowInputBox;
99-
}
100-
});
102+
// Accept the input box with empty label (VS Code's type command doesn't work with QuickInput)
103+
// Note: We can't programmatically type into VS Code's QuickInput widget in extension tests
104+
await vscode.commands.executeCommand("workbench.action.acceptSelectedQuickOpenItem");
101105

102-
test("weAudit.addFinding prompts for label and creates entry", async function () {
103-
this.timeout(10000);
106+
// Wait for command to complete and data to be persisted
107+
await commandPromise;
108+
await new Promise((resolve) => setTimeout(resolve, 1000));
104109

105-
const editor = await openTestFile();
106-
await selectLines(editor, 10, 12);
110+
// Verify that a new entry was added
111+
const dataAfter = readWeauditData(workspaceFolder);
112+
assert.ok(dataAfter, "Data file should exist after adding finding");
113+
assert.ok(dataAfter.treeEntries.length > entriesBefore, "A new entry should be added");
107114

108-
const dataBefore = readWeauditData(workspaceFolder);
109-
const entriesBefore = dataBefore?.treeEntries.length ?? 0;
110-
111-
let inputBoxCalled = false;
112-
const originalShowInputBox = vscode.window.showInputBox;
113-
const promptedLabel = `Prompted Label ${Date.now()}`;
114-
(vscode.window as any).showInputBox = async () => {
115-
inputBoxCalled = true;
116-
return promptedLabel;
117-
};
118-
119-
try {
120-
await vscode.commands.executeCommand("weAudit.addFinding");
121-
await new Promise((resolve) => setTimeout(resolve, 500));
122-
123-
assert.ok(inputBoxCalled, "Input box should be shown for label");
124-
125-
// Verify the entry was created with the prompted label
126-
const dataAfter = readWeauditData(workspaceFolder);
127-
assert.ok(dataAfter, "Data file should exist");
128-
assert.ok(dataAfter.treeEntries.length > entriesBefore, "A new entry should be added");
129-
130-
const newEntry = dataAfter.treeEntries.find((e) => e.label === promptedLabel);
131-
assert.ok(newEntry, "Entry should have the prompted label");
132-
} finally {
133-
(vscode.window as any).showInputBox = originalShowInputBox;
134-
}
115+
// Verify the entry has the correct type and location
116+
const newEntry = dataAfter.treeEntries[dataAfter.treeEntries.length - 1];
117+
assert.strictEqual(newEntry.entryType, 0, "Entry type should be Finding (0)");
118+
assert.ok(
119+
newEntry.locations.some((loc) => loc.startLine === 5 && loc.endLine === 6),
120+
"Entry should have correct line range",
121+
);
135122
});
136123

137-
test("weAudit.addFinding handles cancellation gracefully without adding entry", async function () {
124+
test("weAudit.addFinding handles cancellation gracefully", async function () {
138125
this.timeout(10000);
139126

140127
const editor = await openTestFile();
@@ -143,78 +130,112 @@ suite("Command Execution", () => {
143130
const dataBefore = readWeauditData(workspaceFolder);
144131
const entriesBefore = dataBefore?.treeEntries.length ?? 0;
145132

146-
const originalShowInputBox = vscode.window.showInputBox;
147-
(vscode.window as any).showInputBox = async () => undefined; // Simulates escape
133+
// Start the command (this will show the input box)
134+
const commandPromise = vscode.commands.executeCommand("weAudit.addFinding");
148135

149-
try {
150-
// Cancellation should not throw an error
151-
await vscode.commands.executeCommand("weAudit.addFinding");
152-
await new Promise((resolve) => setTimeout(resolve, 200));
136+
// Wait for input box to appear
137+
await new Promise((resolve) => setTimeout(resolve, 300));
153138

154-
// Verify no new entry was added
155-
const dataAfter = readWeauditData(workspaceFolder);
156-
const entriesAfter = dataAfter?.treeEntries.length ?? 0;
157-
assert.strictEqual(entriesAfter, entriesBefore, "No entry should be added when cancelled");
158-
} finally {
159-
(vscode.window as any).showInputBox = originalShowInputBox;
160-
}
139+
// Cancel by pressing Escape
140+
await vscode.commands.executeCommand("type", { text: "\u001b" }); // Escape character
141+
142+
// If that didn't work, try closing quick open
143+
await new Promise((resolve) => setTimeout(resolve, 100));
144+
await vscode.commands.executeCommand("workbench.action.closeQuickOpen");
145+
146+
// Wait for command to complete
147+
await commandPromise;
148+
await new Promise((resolve) => setTimeout(resolve, 500));
149+
150+
// Verify no new entry was added
151+
const dataAfter = readWeauditData(workspaceFolder);
152+
const entriesAfter = dataAfter?.treeEntries.length ?? 0;
153+
assert.strictEqual(entriesAfter, entriesBefore, "No entry should be added when cancelled");
161154
});
162155

163156
test("weAudit.addNote creates a new note entry", async function () {
164-
this.timeout(10000);
157+
this.timeout(15000);
165158

166159
const editor = await openTestFile();
167160
await selectLines(editor, 20, 22);
168161

169162
const dataBefore = readWeauditData(workspaceFolder);
170163
const entriesBefore = dataBefore?.treeEntries.length ?? 0;
171164

172-
const originalShowInputBox = vscode.window.showInputBox;
173-
const noteLabel = `Test Note ${Date.now()}`;
174-
(vscode.window as any).showInputBox = async () => noteLabel;
165+
// Start the command (this will show the input box)
166+
const commandPromise = vscode.commands.executeCommand("weAudit.addNote");
175167

176-
try {
177-
await vscode.commands.executeCommand("weAudit.addNote");
178-
await new Promise((resolve) => setTimeout(resolve, 500));
168+
// Wait for input box to appear
169+
await new Promise((resolve) => setTimeout(resolve, 300));
179170

180-
// Verify that a new entry was added
181-
const dataAfter = readWeauditData(workspaceFolder);
182-
assert.ok(dataAfter, "Data file should exist after adding note");
183-
assert.ok(dataAfter.treeEntries.length > entriesBefore, "A new entry should be added");
184-
185-
// Verify the entry has the correct label and type (Note = 1)
186-
const newEntry = dataAfter.treeEntries.find((e) => e.label === noteLabel);
187-
assert.ok(newEntry, "New entry should have the provided label");
188-
assert.strictEqual(newEntry.entryType, 1, "Entry type should be Note (1)");
189-
assert.ok(
190-
newEntry.locations.some((loc) => loc.startLine === 20 && loc.endLine === 22),
191-
"Entry should have correct line range",
192-
);
193-
} finally {
194-
(vscode.window as any).showInputBox = originalShowInputBox;
195-
}
171+
// Accept the input box with empty label (VS Code's type command doesn't work with QuickInput)
172+
// Note: We can't programmatically type into VS Code's QuickInput widget in extension tests
173+
await vscode.commands.executeCommand("workbench.action.acceptSelectedQuickOpenItem");
174+
175+
// Wait for command to complete and data to be persisted
176+
await commandPromise;
177+
await new Promise((resolve) => setTimeout(resolve, 1000));
178+
179+
// Verify that a new entry was added
180+
const dataAfter = readWeauditData(workspaceFolder);
181+
assert.ok(dataAfter, "Data file should exist after adding note");
182+
assert.ok(dataAfter.treeEntries.length > entriesBefore, "A new entry should be added");
183+
184+
// Verify the entry has the correct type and location (Note = 1)
185+
const newEntry = dataAfter.treeEntries[dataAfter.treeEntries.length - 1];
186+
assert.strictEqual(newEntry.entryType, 1, "Entry type should be Note (1)");
187+
assert.ok(
188+
newEntry.locations.some((loc) => loc.startLine === 20 && loc.endLine === 22),
189+
"Entry should have correct line range",
190+
);
196191
});
197192

198193
// NOTE: toggleAudited and addPartiallyAudited are tested in decorations.test.ts
199194
// NOTE: toggleTreeViewMode is tested in treeViews.test.ts
200195

201-
test("weAudit.showMarkedFilesDayLog opens a document or shows info message", async function () {
202-
this.timeout(10000);
196+
test("weAudit.showMarkedFilesDayLog shows day log after marking a file as audited", async function () {
197+
this.timeout(15000);
198+
199+
// First, mark a file as audited to ensure there's content in the day log
200+
await openTestFile();
201+
const relativePath = "src/sample.ts";
202+
203+
// Check if file is already audited
204+
const dataBefore = readWeauditData(workspaceFolder);
205+
const wasAudited = dataBefore?.auditedFiles.some((f) => f.path === relativePath) ?? false;
206+
207+
// If not audited, mark it as audited
208+
if (!wasAudited) {
209+
await vscode.commands.executeCommand("weAudit.toggleAudited");
210+
await new Promise((resolve) => setTimeout(resolve, 500));
211+
}
212+
213+
// Close all editors first to get a clean slate
214+
await vscode.commands.executeCommand("workbench.action.closeAllEditors");
215+
await new Promise((resolve) => setTimeout(resolve, 200));
203216

204217
const editorsBefore = vscode.window.visibleTextEditors.length;
205218

206-
// Command should execute without throwing and either open a document or show an info message
219+
// Now call the day log command - it should open a markdown document
207220
await vscode.commands.executeCommand("weAudit.showMarkedFilesDayLog");
208221
await new Promise((resolve) => setTimeout(resolve, 500));
209222

210-
// The command either opens a new markdown document (if there's a day log)
211-
// or shows an information message (if no files have been marked)
212-
// We can verify by checking if a new editor was opened or not
213223
const editorsAfter = vscode.window.visibleTextEditors.length;
214-
215-
// If the day log has content, a new document should be opened
216-
// If not, the editor count should stay the same (info message shown)
217-
// Both outcomes are valid - we just verify the command completed
218-
assert.ok(editorsAfter >= editorsBefore, "Command should complete without error");
224+
assert.ok(editorsAfter > editorsBefore, "A new document should be opened with the day log");
225+
226+
// Verify the opened document contains expected content
227+
const activeEditor = vscode.window.activeTextEditor;
228+
assert.ok(activeEditor, "There should be an active editor");
229+
const content = activeEditor.document.getText();
230+
assert.ok(content.includes("LOC"), "Day log should contain LOC information");
231+
232+
// Clean up: restore the file's audited state if we changed it
233+
if (!wasAudited) {
234+
// Close the day log first
235+
await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
236+
await openTestFile();
237+
await vscode.commands.executeCommand("weAudit.toggleAudited");
238+
await new Promise((resolve) => setTimeout(resolve, 500));
239+
}
219240
});
220241
});

‎test/extension/suite/decorations.test.ts‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,8 @@ suite("Editor Decorations", () => {
2929
const extensionId = "trailofbits.weaudit";
3030
let testFileUri: vscode.Uri;
3131
let workspaceFolder: vscode.WorkspaceFolder;
32+
let originalWeauditContent: string | null = null;
33+
let weauditFilePath: string;
3234

3335
suiteSetup(async () => {
3436
const extension = vscode.extensions.getExtension(extensionId);
@@ -38,6 +40,26 @@ suite("Editor Decorations", () => {
3840
if (workspaceFolders && workspaceFolders.length > 0) {
3941
workspaceFolder = workspaceFolders[0];
4042
testFileUri = vscode.Uri.file(path.join(workspaceFolder.uri.fsPath, "src", "sample.ts"));
43+
44+
// Save original weaudit file content for restoration after tests
45+
weauditFilePath = getWeauditFilePath(workspaceFolder);
46+
if (fs.existsSync(weauditFilePath)) {
47+
originalWeauditContent = fs.readFileSync(weauditFilePath, "utf-8");
48+
}
49+
}
50+
});
51+
52+
suiteTeardown(async () => {
53+
// Restore original weaudit file content
54+
if (weauditFilePath) {
55+
if (originalWeauditContent !== null) {
56+
fs.writeFileSync(weauditFilePath, originalWeauditContent);
57+
} else if (fs.existsSync(weauditFilePath)) {
58+
// If there was no original file, delete the one created by tests
59+
fs.unlinkSync(weauditFilePath);
60+
}
61+
// Reload the extension's data
62+
await vscode.commands.executeCommand("weAudit.findAndLoadConfigurationFiles");
4163
}
4264
});
4365

@@ -73,6 +95,14 @@ suite("Editor Decorations", () => {
7395
const editor = await openTestFile();
7496
const relativePath = "src/sample.ts";
7597

98+
// Ensure the file is not fully audited (which would prevent partial auditing)
99+
// The previous test may have marked it as fully audited
100+
const dataCheck = readWeauditData(workspaceFolder);
101+
if (dataCheck?.auditedFiles.some((f) => f.path === relativePath)) {
102+
await vscode.commands.executeCommand("weAudit.toggleAudited");
103+
await new Promise((resolve) => setTimeout(resolve, 500));
104+
}
105+
76106
// Use lines that are not already partially audited
77107
// Note: When selection ends at character 0, the extension decrements endLine by 1
78108
// So we set the end position with a non-zero character to preserve the exact line

‎test/extension/suite/performance.test.ts‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ suite("Performance", () => {
110110
}
111111
});
112112

113-
test("Adding finding completes within reasonable time", async function () {
113+
test("Adding finding command responds within reasonable time", async function () {
114114
this.timeout(10000);
115115

116116
const document = await vscode.workspace.openTextDocument(testFileUri);
@@ -122,18 +122,18 @@ suite("Performance", () => {
122122
const end = new vscode.Position(1, 0);
123123
editor.selection = new vscode.Selection(start, end);
124124

125-
const originalShowInputBox = vscode.window.showInputBox;
126-
(vscode.window as any).showInputBox = async () => "Perf Test Finding";
125+
// Start the command (shows input box)
126+
const commandPromise = vscode.commands.executeCommand("weAudit.addFinding");
127127

128-
try {
129-
await vscode.commands.executeCommand("weAudit.addFinding");
130-
const operationTime = Date.now() - startTime;
128+
// Wait briefly for input box to appear, then dismiss it
129+
await new Promise((resolve) => setTimeout(resolve, 100));
130+
await vscode.commands.executeCommand("workbench.action.closeQuickOpen");
131131

132-
// Should complete within 2 seconds even in CI environments
133-
assert.ok(operationTime < 2000, `Adding finding took ${operationTime}ms, should be under 2000ms`);
134-
} finally {
135-
(vscode.window as any).showInputBox = originalShowInputBox;
136-
}
132+
await commandPromise;
133+
const operationTime = Date.now() - startTime;
134+
135+
// Command should respond within 2 seconds even in CI environments
136+
assert.ok(operationTime < 2000, `Adding finding took ${operationTime}ms, should be under 2000ms`);
137137
});
138138

139139
test("Large .weaudit file (1000 entries) loads within reasonable time", async function () {

0 commit comments

Comments
 (0)