Classes for adding kube config and kube cluster picker to Controller connection dialog (#13479)

extensions/arc/src/test/common/kubeUtils.test.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'mocha';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import * as yamljs from 'yamljs';
+import { getDefaultKubeConfigPath, getKubeConfigClusterContexts, KubeClusterContext } from '../../common/kubeUtils';
+import { tryExecuteAction } from '../../common/utils';
+
+const kubeConfig =
+{
+	'contexts': [
+		{
+			'context': {
+				'cluster': 'docker-desktop',
+				'user': 'docker-desktop'
+			},
+			'name': 'docker-for-desktop'
+		},
+		{
+			'context': {
+				'cluster': 'kubernetes',
+				'user': 'kubernetes-admin'
+			},
+			'name': 'kubernetes-admin@kubernetes'
+		}
+	],
+	'current-context': 'docker-for-desktop'
+};
+describe('KubeUtils', function (): void {
+	const configFile = 'kubeConfig';
+
+	afterEach('KubeUtils cleanup', () => {
+		sinon.restore();
+	});
+
+	it('getDefaultKubeConfigPath', async () => {
+		getDefaultKubeConfigPath().should.endWith(path.join('.kube', 'config'));
+	});
+
+	describe('get Kube Config Cluster Contexts', () => {
+		it('success', async () => {
+			sinon.stub(yamljs, 'load').returns(<any>kubeConfig);
+			const verifyContexts = (contexts: KubeClusterContext[], testName: string) => {
+				contexts.length.should.equal(2, `test: ${testName} failed`);
+				contexts[0].name.should.equal('docker-for-desktop', `test: ${testName} failed`);
+				contexts[0].isCurrentContext.should.be.true(`test: ${testName} failed`);
+				contexts[1].name.should.equal('kubernetes-admin@kubernetes', `test: ${testName} failed`);
+				contexts[1].isCurrentContext.should.be.false(`test: ${testName} failed`);
+			};
+			verifyContexts(await getKubeConfigClusterContexts(configFile), 'getKubeConfigClusterContexts');
+		});
+		it('throws error when unable to load config file', async () => {
+			const error = new Error('unknown error accessing file');
+			sinon.stub(yamljs, 'load').throws(error); //erroring config file load
+			((await tryExecuteAction(() => getKubeConfigClusterContexts(configFile))).error).should.equal(error, `test: getKubeConfigClusterContexts failed`);
+		});
+	});
+});

extensions/arc/src/test/mocks/fakeRadioButton.ts

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdata from 'azdata';
+import * as vscode from 'vscode';
+
+export class FakeRadioButton implements azdata.RadioButtonComponent {
+
+	private _onDidClickEmitter = new vscode.EventEmitter<any>();
+
+	onDidClick = this._onDidClickEmitter.event;
+
+	constructor(props: azdata.RadioButtonProperties) {
+		this.label = props.label;
+		this.value = props.value;
+		this.checked = props.checked;
+		this.enabled = props.enabled;
+	}
+
+	//#region RadioButtonProperties implementation
+	label?: string;
+	value?: string;
+	checked?: boolean;
+	//#endregion
+
+	click() {
+		this.checked = true;
+		this._onDidClickEmitter.fire(this);
+	}
+	//#region Component Implementation
+	id: string = '';
+	updateProperties(_properties: { [key: string]: any; }): Thenable<void> {
+		throw new Error('Method not implemented.');
+	}
+	updateProperty(_key: string, _value: any): Thenable<void> {
+		throw new Error('Method not implemented.');
+	}
+	updateCssStyles(_cssStyles: { [key: string]: string; }): Thenable<void> {
+		throw new Error('Method not implemented.');
+	}
+	onValidityChanged: vscode.Event<boolean> = <vscode.Event<boolean>>{};
+	valid: boolean = false;
+	validate(): Thenable<boolean> {
+		throw new Error('Method not implemented.');
+	}
+	focus(): Thenable<void> {
+		throw new Error('Method not implemented.');
+	}
+	ariaHidden?: boolean | undefined;
+	//#endregion
+
+	//#region ComponentProperties Implementation
+	height?: number | string;
+	width?: number | string;
+	/**
+	 * The position CSS property. Empty by default.
+	 * This is particularly useful if laying out components inside a FlexContainer and
+	 * the size of the component is meant to be a fixed size. In this case the position must be
+	 * set to 'absolute', with the parent FlexContainer having 'relative' position.
+	 * Without this the component will fail to correctly size itself
+	 */
+	position?: azdata.PositionType;
+	/**
+	 * Whether the component is enabled in the DOM
+	 */
+	enabled?: boolean;
+	/**
+	 * Corresponds to the display CSS property for the element
+	 */
+	display?: azdata.DisplayType;
+	/**
+	 * Corresponds to the aria-label accessibility attribute for this component
+	 */
+	ariaLabel?: string;
+	/**
+	 * Corresponds to the role accessibility attribute for this component
+	 */
+	ariaRole?: string;
+	/**
+	 * Corresponds to the aria-selected accessibility attribute for this component
+	 */
+	ariaSelected?: boolean;
+	/**
+	 * Matches the CSS style key and its available values.
+	 */
+	CSSStyles?: { [key: string]: string };
+	//#endregion
+
+}

extensions/arc/src/test/stubs.ts

@@ -3,8 +3,66 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import * as azdata from 'azdata';
+import * as TypeMoq from 'typemoq';
 import * as vscode from 'vscode';
 
+export function createModelViewMock() {
+	const mockModelBuilder = TypeMoq.Mock.ofType<azdata.ModelBuilder>();
+	const mockTextBuilder = setupMockComponentBuilder<azdata.TextComponent, azdata.TextComponentProperties>();
+	const mockInputBoxBuilder = setupMockComponentBuilder<azdata.InputBoxComponent, azdata.InputBoxProperties>();
+	const mockRadioButtonBuilder = setupMockComponentBuilder<azdata.RadioButtonComponent, azdata.RadioButtonProperties>();
+	const mockDivBuilder = setupMockContainerBuilder<azdata.DivContainer, azdata.DivContainerProperties, azdata.DivBuilder>();
+	const mockLoadingBuilder = setupMockLoadingBuilder();
+	mockModelBuilder.setup(b => b.loadingComponent()).returns(() => mockLoadingBuilder.object);
+	mockModelBuilder.setup(b => b.text()).returns(() => mockTextBuilder.object);
+	mockModelBuilder.setup(b => b.inputBox()).returns(() => mockInputBoxBuilder.object);
+	mockModelBuilder.setup(b => b.radioButton()).returns(() => mockRadioButtonBuilder.object);
+	mockModelBuilder.setup(b => b.divContainer()).returns(() => mockDivBuilder.object);
+	const mockModelView = TypeMoq.Mock.ofType<azdata.ModelView>();
+	mockModelView.setup(mv => mv.modelBuilder).returns(() => mockModelBuilder.object);
+	return { mockModelView, mockModelBuilder, mockTextBuilder, mockInputBoxBuilder, mockRadioButtonBuilder, mockDivBuilder };
+}
+
+function setupMockLoadingBuilder(
+	loadingBuilderGetter?: (item: azdata.Component) => azdata.LoadingComponentBuilder,
+	mockLoadingBuilder?: TypeMoq.IMock<azdata.LoadingComponentBuilder>
+): TypeMoq.IMock<azdata.LoadingComponentBuilder> {
+	mockLoadingBuilder = mockLoadingBuilder ?? setupMockComponentBuilder<azdata.LoadingComponent, azdata.LoadingComponentProperties, azdata.LoadingComponentBuilder>();
+	let item: azdata.Component;
+	mockLoadingBuilder.setup(b => b.withItem(TypeMoq.It.isAny())).callback((_item) => item = _item).returns(() => loadingBuilderGetter ? loadingBuilderGetter(item) : mockLoadingBuilder!.object);
+	return mockLoadingBuilder;
+}
+
+export function setupMockComponentBuilder<T extends azdata.Component, P extends azdata.ComponentProperties, B extends azdata.ComponentBuilder<T, P> = azdata.ComponentBuilder<T, P>>(
+	componentGetter?: (props: P) => T,
+	mockComponentBuilder?: TypeMoq.IMock<B>,
+): TypeMoq.IMock<B> {
+	mockComponentBuilder = mockComponentBuilder ?? TypeMoq.Mock.ofType<B>();
+	const returnComponent = TypeMoq.Mock.ofType<T>();
+	// Need to setup 'then' for when a mocked object is resolved otherwise the test will hang : https://github.com/florinn/typemoq/issues/66
+	returnComponent.setup((x: any) => x.then).returns(() => { });
+	let compProps: P;
+	mockComponentBuilder.setup(b => b.withProperties(TypeMoq.It.isAny())).callback((props: P) => compProps = props).returns(() => mockComponentBuilder!.object);
+	mockComponentBuilder.setup(b => b.component()).returns(() => {
+		return componentGetter ? componentGetter(compProps) : Object.assign<T, P>(Object.assign({}, returnComponent.object), compProps);
+	});
+
+	// For now just have these be passthrough - can hook up additional functionality later if needed
+	mockComponentBuilder.setup(b => b.withValidation(TypeMoq.It.isAny())).returns(() => mockComponentBuilder!.object);
+	return mockComponentBuilder;
+}
+
+export function setupMockContainerBuilder<T extends azdata.Container<any, any>, P extends azdata.ComponentProperties, B extends azdata.ContainerBuilder<T, any, any, any> = azdata.ContainerBuilder<T, any, any, any>>(
+	mockContainerBuilder?: TypeMoq.IMock<B>
+): TypeMoq.IMock<B> {
+	mockContainerBuilder = mockContainerBuilder ?? setupMockComponentBuilder<T, P, B>();
+	// For now just have these be passthrough - can hook up additional functionality later if needed
+	mockContainerBuilder.setup(b => b.withItems(TypeMoq.It.isAny(), undefined)).returns(() => mockContainerBuilder!.object);
+	mockContainerBuilder.setup(b => b.withLayout(TypeMoq.It.isAny())).returns(() => mockContainerBuilder!.object);
+	return mockContainerBuilder;
+}
+
 export class MockInputBox implements vscode.InputBox {
 	private _value: string = '';
 	public get value(): string {

extensions/arc/src/test/ui/components/radioOptionsGroup.test.ts

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdata from 'azdata';
+import * as should from 'should';
+import { getErrorMessage } from '../../../common/utils';
+import { RadioOptionsGroup, RadioOptionsInfo } from '../../../ui/components/radioOptionsGroup';
+import { FakeRadioButton } from '../../mocks/fakeRadioButton';
+import { setupMockComponentBuilder, createModelViewMock } from '../../stubs';
+
+
+const loadingError = new Error('Error loading options');
+const radioOptionsInfo = <RadioOptionsInfo>{
+	values: [
+		'value1',
+		'value2'
+	],
+	defaultValue: 'value2'
+};
+const divItems: azdata.Component[] = [];
+let radioOptionsGroup: RadioOptionsGroup;
+
+
+describe('radioOptionsGroup', function (): void {
+	beforeEach(async () => {
+		const { mockModelView, mockRadioButtonBuilder, mockDivBuilder } = createModelViewMock();
+		mockRadioButtonBuilder.reset(); // reset any previous mock so that we can set our own.
+		setupMockComponentBuilder<azdata.RadioButtonComponent, azdata.RadioButtonProperties>(
+			(props) => new FakeRadioButton(props),
+			mockRadioButtonBuilder,
+		);
+		mockDivBuilder.reset(); // reset previous setups so new setups we are about to create will replace the setups instead creating a recording chain
+		// create new setups for the DivContainer with custom behavior
+		setupMockComponentBuilder<azdata.DivContainer, azdata.DivContainerProperties, azdata.DivBuilder>(
+			() => <azdata.DivContainer>{
+				addItem: (item) => { divItems.push(item); },
+				clearItems: () => { divItems.length = 0; },
+				get items() { return divItems; },
+			},
+			mockDivBuilder
+		);
+		radioOptionsGroup = new RadioOptionsGroup(mockModelView.object, (_disposable) => { });
+		await radioOptionsGroup.load(async () => radioOptionsInfo);
+	});
+
+	it('verify construction and load', async () => {
+		should(radioOptionsGroup).not.be.undefined();
+		should(radioOptionsGroup.value).not.be.undefined();
+		radioOptionsGroup.value!.should.equal('value2', 'radio options group should be the default checked value');
+		// verify all the radioButtons created in the group
+		verifyRadioGroup();
+	});
+
+	it('onClick', async () => {
+		// click the radioButton corresponding to 'value1'
+		(divItems as FakeRadioButton[]).filter(r => r.value === 'value1').pop()!.click();
+		radioOptionsGroup.value!.should.equal('value1', 'radio options group should correspond to the radioButton that we clicked');
+		// verify all the radioButtons created in the group
+		verifyRadioGroup();
+	});
+
+	it('load throws', async () => {
+		radioOptionsGroup.load(() => { throw loadingError; });
+		//in error case radioButtons array wont hold radioButtons but holds a TextComponent with value equal to error string
+		divItems.length.should.equal(1, 'There is should be only one element in the divContainer when loading error happens');
+		const label = divItems[0] as azdata.TextComponent;
+		should(label.value).not.be.undefined();
+		label.value!.should.deepEqual(getErrorMessage(loadingError));
+		should(label.CSSStyles).not.be.undefined();
+		should(label.CSSStyles!.color).not.be.undefined();
+		label.CSSStyles!.color.should.equal('Red');
+	});
+});
+
+function verifyRadioGroup() {
+	const radioButtons = divItems as FakeRadioButton[];
+	radioButtons.length.should.equal(radioOptionsInfo.values!.length);
+	radioButtons.forEach(rb => {
+		should(rb.label).not.be.undefined();
+		should(rb.value).not.be.undefined();
+		should(rb.enabled).not.be.undefined();
+		rb.label!.should.equal(rb.value);
+		rb.enabled!.should.be.true();
+	});
+}
+