FUSETOOLS2-1165 - set focus only when creating through UI

it avoids that the focus is set on the extension every time external
extension are contributing tutorials (such as VS Code Camel K)

Signed-off-by: Aurélien Pupier <[email protected]>

Author: apupier

src/extension.ts

@@ -36,7 +36,7 @@ export const DEFAULT_TUTORIAL_CATEGORY = "Didact";
 export const DEFAULT_TUTORIAL_NAME = "Didact Demo";
 
 export const didactTutorialsProvider = new DidactNodeProvider();
-let didactTreeView : vscode.TreeView<SimpleNode>;
+export let didactTreeView : vscode.TreeView<SimpleNode>;
 let didactTelemetry: DidactTelemetry;
 
 export async function activate(context: vscode.ExtensionContext): Promise<any> {

src/test/suite/extension.test.ts

@@ -45,7 +45,7 @@ suite('Extension Test Suite', () => {
 					}
 				}
 			}
-			expect(match).to.be.true;
+			expect(match, `Tutorial ${tutorialName} not found in registry. It contains ${existingRegistry}`).to.be.true;
 		}
 	});
 

src/test/suite/nodeProvider.test.ts

@@ -32,7 +32,7 @@
 
 	before('set up the registry tests', async () => {
 		// make sure that the HelloWorld tutorial is registered if it's been cleared
-		await registerTutorialWithCategory(tutorialName, tutorialUri.fsPath, tutorialCategory);
+		await registerTutorialWithCategory(tutorialName, tutorialUri.fsPath, tutorialCategory, true);
 	});
 
 	test('Verify that we get null as the parent of the category', async () => {

src/test/suite/registry.test.ts

@@ -3,41 +3,64 @@ import {getRegisteredTutorials, getDidactCategories, getTutorialsForCategory, ge
 import {before} from 'mocha';
 import * as vscode from 'vscode';
 import { ADD_TUTORIAL_TO_REGISTRY, getContext, REGISTER_TUTORIAL } from '../../extensionFunctions';
-import { DEFAULT_TUTORIAL_CATEGORY, DEFAULT_TUTORIAL_NAME } from '../../extension';
+import { DEFAULT_TUTORIAL_CATEGORY, DEFAULT_TUTORIAL_NAME, didactTreeView, didactTutorialsProvider } from '../../extension';
+import { waitUntil } from 'async-wait-until';
 
 const name = 'new-tutorial';
 const category = 'some-category';
 const source = 'my-uri';
 const name2 = 'new-tutorial-2';
 const category2 = 'some-category-2';
 const source2 = 'my-uri-2';
+const name3 = 'new-tutorial-3';
+const category3 = 'some-category-3';
+const source3 = 'my-uri-3';
 
 suite('Didact registry test suite', () => {
 
-	before('set up the registry tests', async () => {
+	before('Clear the registry tests', async () => {
 		await clearRegisteredTutorials(false);
 	});
 
 	test('assert that clearing the registry made it empty', async () => {
 		const registry = getRegisteredTutorials();
-		assert.strictEqual(registry, undefined);
+		assert.strictEqual(registry, undefined, `Registry was expected undefined but got ${registry}`);
 
 		// clean up and add one demo tutorial back in
 		const tutorialUri = vscode.Uri.file(getContext().asAbsolutePath('./demos/markdown/didact-demo.didact.md'));
-		await registerTutorialWithCategory(DEFAULT_TUTORIAL_NAME, tutorialUri.fsPath, DEFAULT_TUTORIAL_CATEGORY);
+		await registerTutorialWithCategory(DEFAULT_TUTORIAL_NAME, tutorialUri.fsPath, DEFAULT_TUTORIAL_CATEGORY, true);
 
 		const addRegistry = getRegisteredTutorials();
-		assert.notStrictEqual(addRegistry, undefined);
+		assert.notStrictEqual(addRegistry, undefined, `Registry was expected not to be undefined`);
 	});
 
+	test('Add to registry without setting focus', async() => {
+		await clearRegisteredTutorials(false);
+		const selectedTutorialsBeforeTest = didactTreeView.selection;
+		assert.strictEqual(selectedTutorialsBeforeTest.length, 0, `There are unexpected selected Tutorials before test: ${selectedTutorialsBeforeTest}`);
+		
+		try {
+			await registerTutorialWithArgs(name3, source3, category3);
+		} catch(error) {
+			assert.fail('We failed to create the new didact registry entry');
+		}
+		
+		const selectedTutorials = didactTreeView.selection;
+		assert.strictEqual(selectedTutorials.length, 0, `There are unexpected selected Tutorials: ${selectedTutorials}`);
+	});
+	
 	test('add to registry', async () => {
 		try {
-			await registerTutorialWithArgs(name, source, category).then( () => {
+			await registerTutorialWithArgs(name, source, category, true).then( () => {
 				assert.ok('No errors thrown while creating new didact registry entry');
 			});
 		} catch (error) {
 			assert.fail('We failed to create the new didact registry entry');
 		}
+		
+		const selectedTutorials = didactTreeView.selection;
+		assert.strictEqual(selectedTutorials.length, 1, `There are unexpected selected Tutorials: ${selectedTutorials}`);
+		assert.strictEqual(selectedTutorials[0].label, name);
 
 		try {
 			await registerTutorialWithCategory(name, source, category);

src/utils.ts

@@ -140,7 +140,7 @@ export async function registerTutorialWithJSON( jsonObject: any) {
 	return registerTutorialWithClass(newTutorial);
 }
 
-export async function registerTutorialWithClass(newDidact: Tutorial): Promise<void> {
+export async function registerTutorialWithClass(newDidact: Tutorial, setFocusInTreeView = false): Promise<void> {
 	const newDidactAsString = JSON.stringify(newDidact);
 	let existingRegistry : string[] | undefined = getRegisteredTutorials();
 	if(!existingRegistry) {
@@ -165,6 +165,12 @@ export async function registerTutorialWithClass(newDidact: Tutorial): Promise<vo
 			extensionFunctions.sendTextToOutputChannel(`Didact tutorial with name ${newDidact.name} and category ${newDidact.category} already exists`);
 		}
 	}
+	if (setFocusInTreeView) {
+		await focusInTreeView(existingRegistry, newDidact);
+	}	
+}
+
+async function focusInTreeView(existingRegistry: string[], newDidact: Tutorial) {
 	await commands.executeCommand('didact.tutorials.focus'); // open the tutorials view
 	await extensionFunctions.getContext().workspaceState.update(DIDACT_REGISTERED_SETTING, existingRegistry);
 	refreshTreeview();
@@ -175,13 +181,13 @@ export async function registerTutorialWithClass(newDidact: Tutorial): Promise<vo
 	}
 }
 
-export async function registerTutorialWithArgs(name : string, sourceUri : string, category : string ): Promise<void> {
+export async function registerTutorialWithArgs(name : string, sourceUri : string, category : string, setFocusInTreeView = false ): Promise<void> {
 	const newTutorial = new Tutorial(name, sourceUri, category);
-	return registerTutorialWithClass(newTutorial);
+	return registerTutorialWithClass(newTutorial, setFocusInTreeView);
 }
 
-export async function registerTutorialWithCategory(name : string, sourceUri : string, category : string ): Promise<void> {
-	return registerTutorialWithArgs(name, sourceUri, category);
+export async function registerTutorialWithCategory(name : string, sourceUri : string, category : string, setFocusInTreeView = false ): Promise<void> {
+	return registerTutorialWithArgs(name, sourceUri, category, setFocusInTreeView);
 }
 
 export async function registerEmbeddedTutorials(context: ExtensionContext, name: string, pathInExtension: string): Promise<void> {
@@ -351,9 +357,9 @@ export async function addNewTutorialWithNameAndCategoryForDidactUri(uri: Uri, na
 	}
 	if (tutorialName && tutorialCategory) {
 		if (uri.scheme.toLowerCase() === 'file') {
-			await registerTutorialWithArgs(tutorialName, uri.fsPath, tutorialCategory);
+			await registerTutorialWithArgs(tutorialName, uri.fsPath, tutorialCategory, true);
 		} else {
-			await registerTutorialWithArgs(tutorialName, uri.toString(), tutorialCategory);
+			await registerTutorialWithArgs(tutorialName, uri.toString(), tutorialCategory, true);
 		}
 	}
 }