FUSETOOLS2-737 - Adding tests to validate action results from demo tutorial (#410)

* new test to validate action results

- fixing broken tests and rebasing
- fixing completion test failure
- using cursorEnd command
- inserting additional delays to help finish command processing
- updating terminal tests
- addressing PR feedback
- addressing PR comments round 2
- increasing timeout to help with windows failure

Signed-off-by: Brian Fitzpatrick <[email protected]>

Author: bfitzpat

src/test/suite/completions.test.ts

@@ -20,6 +20,7 @@ import { expect } from 'chai';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { removeFilesAndFolders } from '../../utils';
+import { Position, Range, TextEditor } from "vscode";
 
 const testWorkspace = path.resolve(__dirname, '..', '..', '..', './test Fixture with speci@l chars');
 const foldersAndFilesToRemove: string[] = [
@@ -49,7 +50,7 @@ suite("New Didact URI completion provider tests", function () {
 		const expected = "[My Link](didact://?commandId=";
 
 		suite('walk through a list of command completions', () => {
-			listOfCompletions.forEach(function(stringToTest: string){
+			listOfCompletions.forEach(function(stringToTest: string) {
 				test(`test provided completion "${stringToTest}"`, async () => {
 					await testWeGetExpectedResult(stringToTest, expected);
 				});
@@ -61,18 +62,33 @@ suite("New Didact URI completion provider tests", function () {
 
 async function testWeGetExpectedResult(textToInsert : string, expectedResult: string) {
 	const editor = await createTestEditor(testDocumentUri);
-	await vscode.commands.executeCommand('editor.action.selectAll');
-	await vscode.commands.executeCommand('type', {"text": textToInsert});
+	await delay(100);
+	await initializeTextEditor(editor, textToInsert);
+	await delay(100);
+	await vscode.commands.executeCommand("cursorEnd");
+	await delay(100);
 	await vscode.commands.executeCommand("editor.action.triggerSuggest");
-	await delay(1000);
+	await delay(100);
 	await vscode.commands.executeCommand("acceptSelectedSuggestion");
+	await delay(100);
 	expect(editor.document.getText()).to.include(expectedResult);
 }
 
 function delay(ms: number) {
 	return new Promise( resolve => setTimeout(resolve, ms) );
 }
 
+async function initializeTextEditor(textEditor: TextEditor, initializeWith = "") {
+	const doc = textEditor.document;
+	await textEditor.edit((editBuilder) => {
+	  editBuilder.delete(new Range(new Position(0, 0), doc.positionAt(doc.getText().length)));
+	});
+	await textEditor.edit((editBuilder) => {
+	  editBuilder.insert(new Position(0, 0), initializeWith);
+	});
+	expect(doc.getText()).to.be.equal(initializeWith);
+}
+
 async function createTestEditor(uri: vscode.Uri) : Promise<vscode.TextEditor> {
 	await vscode.workspace.fs.writeFile(testDocumentUri, Buffer.from(''));
 	const document = await vscode.workspace.openTextDocument(uri);

src/test/suite/stubDemoTutorial.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect } from 'chai';
+import { window, commands, env, Uri, Terminal, Pseudoterminal, Event, TerminalDimensions, EventEmitter } from 'vscode';
+import { START_DIDACT_COMMAND, sendTerminalText, gatherAllCommandsLinks, getContext, findTerminal } from '../../extensionFunctions';
+import { didactManager } from '../../didactManager';
+import { DidactUri } from '../../didactUri';
+import { handleText } from '../../commandHandler';
+
+const testMD = Uri.parse('vscode://redhat.vscode-didact?extension=demos/markdown/didact-demo.didact.md');
+
+const delayTime = 1000;
+
+suite('stub out a tutorial', () => {
+
+	test('that we can send an echo command to the terminal and get the response', async () => {
+		const name = 'echoTerminal';
+		const text = `echo Hello World ${name}`;
+		const result = `Hello World echoTerminal`;
+		await validateTerminalResponse(name, text, result);
+	});
+
+	test('that we can get a response from each command in the demo tutorial', async () => {
+		await commands.executeCommand(START_DIDACT_COMMAND, testMD).then( async () => {
+			if (didactManager.active()) {
+
+				suite('walk through all the sendNamedTerminalAString commands in the demo', () => {
+					const commands : any[] = gatherAllCommandsLinks().filter( (href) => href.match(/=vscode.didact.sendNamedTerminalAString&/g));
+					expect(commands).to.not.be.empty;
+					commands.forEach(function(href: string) {
+						test(`test terminal command "${href}"`, async () => {
+							const ctxt = getContext();
+							if (ctxt) {
+								const testUri = new DidactUri(href, ctxt);
+								const textToParse = testUri.getText();
+								const userToParse = testUri.getUser();
+								let outputs : string[] = [];
+								if (textToParse) {
+									handleText(textToParse, outputs);
+								} else if (userToParse) {
+									handleText(userToParse, outputs);
+								}
+								expect(outputs).length.to.be.at.least(2);
+								const terminalName = outputs[0];
+								const terminalString = outputs[1];
+								await validateSimpleTerminalResponse(terminalName, terminalString);
+							}
+						});
+					});
+				});				
+			}
+		});
+	});
+
+});
+
+async function validateSimpleTerminalResponse(terminalName : string, terminalText : string) {
+	console.log(`validateSimpleTerminalResponse terminal ${terminalName} executing text ${terminalText}`);
+	const term = window.createTerminal(terminalName);
+	expect(term).to.not.be.null;
+	if (term) {
+		console.log(`-current terminal = ${term?.name}`);
+		await sendTerminalText(terminalName, terminalText);
+		await delay(delayTime);
+		const term2 = focusOnNamedTerminal(terminalName);
+		await delay(delayTime);
+		let result = await getTerminalOutput(terminalName);
+		console.log(`-validateSimpleTerminalResponse terminal output = ${result}`);
+
+		// we're just making sure we get something back and can see the text we put into the terminal
+		expect(result).to.include(terminalText);
+		findAndDisposeTerminal(terminalName);
+	}
+}
+
+async function validateTerminalResponse(terminalName : string, terminalText : string, terminalResponse : string) {
+	console.log(`validateTerminalResponse terminal ${terminalName} executing text ${terminalText} and looking for response ${terminalResponse}`);
+	const term = window.createTerminal(terminalName);
+	expect(term).to.not.be.null;
+	if (term) {
+		console.log(`-current terminal = ${term?.name}`);
+		await sendTerminalText(terminalName, terminalText);
+		await delay(delayTime);
+		const term2 = focusOnNamedTerminal(terminalName);
+		await delay(delayTime);
+		let result = await getTerminalOutput(terminalName);
+		console.log(`-validateTerminalResponse terminal output = ${result}`);
+		expect(result).to.include(terminalResponse);
+		findAndDisposeTerminal(terminalName);
+	}
+}
+
+async function getTerminalOutput(terminalName : string) : Promise<string> {
+	const terminal = getNamedTerminal(terminalName);
+	expect(terminal).to.not.be.undefined;
+	expect(terminal?.name).to.equal(terminalName);
+	focusOnNamedTerminal(terminalName);
+	const term = window.activeTerminal;
+	console.log(`-current terminal = ${term?.name}`);
+	await executeAndWait('workbench.action.terminal.selectAll');
+	await delay(delayTime);
+	await executeAndWait('workbench.action.terminal.copySelection');
+	await executeAndWait('workbench.action.terminal.clearSelection');	
+	const clipboard_content = await env.clipboard.readText();
+	return clipboard_content.trim();;
+}
+
+function delay(ms: number) {
+	return new Promise( resolve => setTimeout(resolve, ms) );
+}
+
+async function executeAndWait(command: string): Promise<void> {
+	await commands.executeCommand(command);
+	delay(100);
+}
+
+function getNamedTerminal(terminalName : string): Terminal | undefined {
+	return window.terminals.filter(term => term.name === terminalName)[0];
+}
+
+function findAndDisposeTerminal(terminalName: string) : void {
+	const term = getNamedTerminal(terminalName);
+	if (term) {
+		term.dispose();
+	}
+}
+
+async function focusOnNamedTerminal(terminalName : string) : Promise<void> {
+	let term = window.activeTerminal;
+	while (term?.name != terminalName) {
+		await commands.executeCommand('workbench.action.terminal.focusNext');
+		term = window.activeTerminal;
+	}
+}