First set of test for SchemaCompareDialog (#11444)

* Add a test for SchemaCompareDialog and update the product code with deferred promise

* Update test to verify that button clicked worked

* Addressed comments

* Updated verifyButtonsState to use should instead of console.log

extensions/schema-compare/src/test/schemaCompare.test.ts

@@ -28,23 +28,6 @@ before(function (): void {
 	testContext = createContext();
 });
 
-describe('SchemaCompareDialog.openDialog', function (): void {
-	before(() => {
-		mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
-		mockExtensionContext.setup(x => x.extensionPath).returns(() => '');
-	});
-
-	it('Should be correct when created.', async function (): Promise<void> {
-		let schemaCompareResult = new SchemaCompareMainWindow(testContext.apiWrapper.object, undefined, mockExtensionContext.object);
-		let dialog = new SchemaCompareDialog(schemaCompareResult);
-		await dialog.openDialog();
-
-		should(dialog.dialog.title).equal('Schema Compare');
-		should(dialog.dialog.okButton.label).equal('OK');
-		should(dialog.dialog.okButton.enabled).equal(false); // Should be false when open
-	});
-});
-
 describe('SchemaCompareMainWindow.start', function (): void {
 	before(() => {
 		mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
@@ -162,10 +145,18 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 		await result.execute();
 
 		//Generate script button and apply button should be disabled for dacpac comparison
-		should(result.verifyButtonsState( {compareButtonState: true, optionsButtonState: true, switchButtonState: true,
-			openScmpButtonState: true, saveScmpButtonState: true, cancelCompareButtonState: false,
-			selectSourceButtonState: true, selectTargetButtonState: true, generateScriptButtonState: false,
-			applyButtonState: false} )).equal(true);
+		result.verifyButtonsState( {
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		} );
 	});
 
 	it('Should disable script button and apply button for Schema Compare service for database', async function (): Promise<void> {
@@ -183,10 +174,18 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 		await result.execute();
 
 		//Generate script button and apply button should be enabled for database comparison
-		should(result.verifyButtonsState( {compareButtonState: true, optionsButtonState: true, switchButtonState: true,
-			openScmpButtonState: true, saveScmpButtonState: true, cancelCompareButtonState: false,
-			selectSourceButtonState: true, selectTargetButtonState: true, generateScriptButtonState: true,
-			applyButtonState: true} )).equal(true);
+		result.verifyButtonsState( {
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: true,
+			applyButtonState: true
+		} );
 	});
 
 });
@@ -213,10 +212,18 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 
 		result.updateSourceAndTarget();
 
-		should(result.verifyButtonsState( {compareButtonState: false, optionsButtonState: false, switchButtonState: false,
-			openScmpButtonState: true, saveScmpButtonState: false, cancelCompareButtonState: false,
-			selectSourceButtonState: true, selectTargetButtonState: true, generateScriptButtonState: false,
-			applyButtonState: false} )).equal(true);
+		result.verifyButtonsState( {
+			compareButtonState: false,
+			optionsButtonState: false,
+			switchButtonState: false,
+			openScmpButtonState: true,
+			saveScmpButtonState: false,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		} );
 	});
 
 	it('Should set buttons appropriately when source endpoint is empty and target endpoint is populated', async function (): Promise<void> {
@@ -234,10 +241,18 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 
 		result.updateSourceAndTarget();
 
-		should(result.verifyButtonsState( {compareButtonState: false, optionsButtonState: false, switchButtonState: true,
-			openScmpButtonState: true, saveScmpButtonState: false, cancelCompareButtonState: false,
-			selectSourceButtonState: true, selectTargetButtonState: true, generateScriptButtonState: false,
-			applyButtonState: false} )).equal(true);
+		result.verifyButtonsState( {
+			compareButtonState: false,
+			optionsButtonState: false,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: false,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		} );
 	});
 
 	it('Should set buttons appropriately when source and target endpoints are populated', async function (): Promise<void> {
@@ -255,10 +270,18 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 
 		result.updateSourceAndTarget();
 
-		should(result.verifyButtonsState( {compareButtonState: true, optionsButtonState: true, switchButtonState: true,
-			openScmpButtonState: true, saveScmpButtonState: true, cancelCompareButtonState: false,
-			selectSourceButtonState: true, selectTargetButtonState: true, generateScriptButtonState: false,
-			applyButtonState: false} )).equal(true);
+		result.verifyButtonsState( {
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		} );
 	});
 
 });

extensions/schema-compare/src/test/schemaCompareDialog.test.ts

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as vscode from 'vscode';
+import * as TypeMoq from 'typemoq';
+import * as loc from '../localizedConstants';
+import 'mocha';
+import { SchemaCompareDialog } from './../dialogs/schemaCompareDialog';
+import { SchemaCompareMainWindow } from '../schemaCompareMainWindow';
+import { createContext, TestContext } from './testContext';
+import { setDacpacEndpointInfo } from './testUtils';
+import { SchemaCompareMainWindowTest } from './testSchemaCompareMainWindow';
+
+// Mock test data
+const mocksource: string = 'source.dacpac';
+const mocktarget: string = 'target.dacpac';
+
+let mockExtensionContext: TypeMoq.IMock<vscode.ExtensionContext>;
+let testContext: TestContext;
+
+before(function (): void {
+	testContext = createContext();
+});
+
+describe('SchemaCompareDialog.openDialog', function (): void {
+	before(() => {
+		mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
+		mockExtensionContext.setup(x => x.extensionPath).returns(() => '');
+	});
+
+	it('Should be correct when created.', async function (): Promise<void> {
+		let schemaCompareResult = new SchemaCompareMainWindow(testContext.apiWrapper.object, undefined, mockExtensionContext.object);
+		let dialog = new SchemaCompareDialog(schemaCompareResult);
+		await dialog.openDialog();
+
+		should(dialog.dialog.title).equal(loc.SchemaCompareLabel);
+		should(dialog.dialog.okButton.label).equal(loc.OkButtonText);
+		should(dialog.dialog.okButton.enabled).equal(false); // Should be false when open
+	});
+
+	it('Simulate ok button- with both endpoints set to dacpac', async function (): Promise<void> {
+		let schemaCompareResult = new SchemaCompareMainWindowTest(testContext.apiWrapper.object, undefined, mockExtensionContext.object);
+		await schemaCompareResult.start(undefined);
+		schemaCompareResult.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		schemaCompareResult.targetEndpointInfo = setDacpacEndpointInfo(mocktarget);
+
+		let dialog = new SchemaCompareDialog(schemaCompareResult);
+		await dialog.openDialog();
+
+		await dialog.execute();
+
+		// Confirm that ok button got clicked
+		schemaCompareResult.verifyButtonsState( {
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		} );
+	});
+});

extensions/schema-compare/src/test/testSchemaCompareMainWindow.ts

@@ -5,6 +5,7 @@
 
 import * as vscode from 'vscode';
 import * as mssql from '../../../mssql';
+import * as should from 'should';
 import { SchemaCompareMainWindow } from '../schemaCompareMainWindow';
 import { ApiWrapper } from '../common/apiWrapper';
 
@@ -34,26 +35,7 @@ export class SchemaCompareMainWindowTest extends SchemaCompareMainWindow {
 		return this.comparisonResult;
 	}
 
-	// only for test
-	public getButtonsState(): ButtonState {
-
-		let buttonObject: ButtonState = {
-			compareButtonState: this.compareButton.enabled,
-			optionsButtonState: this.optionsButton.enabled,
-			switchButtonState: this.switchButton.enabled,
-			openScmpButtonState: this.openScmpButton.enabled,
-			saveScmpButtonState: this.saveScmpButton.enabled,
-			cancelCompareButtonState: this.cancelCompareButton.enabled,
-			selectSourceButtonState: this.selectSourceButton.enabled,
-			selectTargetButtonState: this.selectTargetButton.enabled,
-			generateScriptButtonState: this.generateScriptButton.enabled,
-			applyButtonState: this.applyButton.enabled
-		};
-
-		return buttonObject;
-	}
-
-	public verifyButtonsState(buttonState: ButtonState): boolean {
+	public verifyButtonsState(buttonState: ButtonState): void {
 		let result: boolean = false;
 
 		if (this.compareButton.enabled === buttonState.compareButtonState &&
@@ -69,6 +51,15 @@ export class SchemaCompareMainWindowTest extends SchemaCompareMainWindow {
 			result = true;
 		}
 
-		return result;
+		should(result).equal(true, `CompareButton: (Actual) ${this.compareButton.enabled} (Expected) ${buttonState.compareButtonState}
+		OptionsButton: (Actual) ${this.optionsButton.enabled} (Expected) ${buttonState.optionsButtonState}
+		SwitchButton: (Actual) ${this.switchButton.enabled} (Expected) ${buttonState.switchButtonState}
+		OpenScmpButton: (Actual) ${this.openScmpButton.enabled} (Expected) ${buttonState.openScmpButtonState}
+		SaveScmpButton: (Actual) ${this.saveScmpButton.enabled} (Expected) ${buttonState.saveScmpButtonState}
+		CancelCompareButton: (Actual) ${this.cancelCompareButton.enabled} (Expected) ${buttonState.cancelCompareButtonState}
+		SelectSourceButton: (Actual) ${this.selectSourceButton.enabled} (Expected) ${buttonState.selectSourceButtonState}
+		SelectTargetButton: (Actual) ${this.selectTargetButton.enabled} (Expected) ${buttonState.selectTargetButtonState}
+		GenerateScriptButton: (Actual) ${this.generateScriptButton.enabled} (Expected) ${buttonState.generateScriptButtonState}
+		ApplyButton: (Actual) ${this.applyButton.enabled} (Expected) ${buttonState.applyButtonState}`);
 	}
 }

extensions/schema-compare/src/test/utils.test.ts

@@ -8,8 +8,12 @@ import * as azdata from 'azdata';
 import * as mssql from '../../../mssql';
 import * as loc from '../localizedConstants';
 import * as TypeMoq from 'typemoq';
-import {getEndpointName, verifyConnectionAndGetOwnerUri } from '../utils';
-import {mockDacpacEndpoint, mockDatabaseEndpoint, mockFilePath, mockConnectionInfo, shouldThrowSpecificError, mockConnectionResult, mockConnectionProfile} from './testUtils';
+import * as path from 'path';
+import * as uuid from 'uuid';
+import * as os from 'os';
+import { promises as fs } from 'fs';
+import { getEndpointName, verifyConnectionAndGetOwnerUri, exists } from '../utils';
+import { mockDacpacEndpoint, mockDatabaseEndpoint, mockFilePath, mockConnectionInfo, shouldThrowSpecificError, mockConnectionResult, mockConnectionProfile } from './testUtils';
 import { createContext, TestContext } from './testContext';
 
 let testContext: TestContext;
@@ -24,8 +28,8 @@ describe('utils: Tests to verify getEndpointName', function (): void {
 	});
 
 	it('Should get endpoint information from ConnectionInfo', () => {
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
-		testDatabaseEndpoint.connectionDetails = {...mockConnectionInfo};
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
+		testDatabaseEndpoint.connectionDetails = { ...mockConnectionInfo };
 
 		should(getEndpointName(testDatabaseEndpoint)).equal('My Server.My Database');
 	});
@@ -33,7 +37,7 @@ describe('utils: Tests to verify getEndpointName', function (): void {
 	it('Should get correct endpoint information from SchemaCompareEndpointInfo', () => {
 		let dbName = 'My Database';
 		let serverName = 'My Server';
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
 		testDatabaseEndpoint.databaseName = dbName;
 		testDatabaseEndpoint.serverName = serverName;
 
@@ -55,7 +59,7 @@ describe('utils: Basic tests to verify verifyConnectionAndGetOwnerUri', function
 
 	it('Should return undefined for endpoint as database and no ConnectionInfo', async function (): Promise<void> {
 		let ownerUri = undefined;
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
 		testDatabaseEndpoint.connectionDetails = undefined;
 
 		ownerUri = await verifyConnectionAndGetOwnerUri(testDatabaseEndpoint, 'test', testContext.apiWrapper.object);
@@ -71,9 +75,9 @@ describe('utils: In-depth tests to verify verifyConnectionAndGetOwnerUri', funct
 
 	it('Should throw an error asking to make a connection', async function (): Promise<void> {
 		let getConnectionsResults: azdata.connection.ConnectionProfile[] = [];
-		let connection  = {...mockConnectionResult};
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
-		testDatabaseEndpoint.connectionDetails = {...mockConnectionInfo};
+		let connection = { ...mockConnectionResult };
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
+		testDatabaseEndpoint.connectionDetails = { ...mockConnectionInfo };
 		const getConnectionString = loc.getConnectionString('test');
 
 		testContext.apiWrapper.setup(x => x.connect(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return Promise.resolve(connection); });
@@ -85,10 +89,10 @@ describe('utils: In-depth tests to verify verifyConnectionAndGetOwnerUri', funct
 	});
 
 	it('Should throw an error for login failure', async function (): Promise<void> {
-		let getConnectionsResults: azdata.connection.ConnectionProfile[] = [{...mockConnectionProfile}];
-		let connection  = {...mockConnectionResult};
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
-		testDatabaseEndpoint.connectionDetails = {...mockConnectionInfo};
+		let getConnectionsResults: azdata.connection.ConnectionProfile[] = [{ ...mockConnectionProfile }];
+		let connection = { ...mockConnectionResult };
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
+		testDatabaseEndpoint.connectionDetails = { ...mockConnectionInfo };
 
 		testContext.apiWrapper.setup(x => x.connect(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return Promise.resolve(connection); });
 		testContext.apiWrapper.setup(x => x.getUriForConnection(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(undefined); });
@@ -100,9 +104,9 @@ describe('utils: In-depth tests to verify verifyConnectionAndGetOwnerUri', funct
 
 	it('Should throw an error for login failure with openConnectionDialog but no ownerUri', async function (): Promise<void> {
 		let getConnectionsResults: azdata.connection.ConnectionProfile[] = [];
-		let connection  = {...mockConnectionResult};
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
-		testDatabaseEndpoint.connectionDetails = {...mockConnectionInfo};
+		let connection = { ...mockConnectionResult };
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
+		testDatabaseEndpoint.connectionDetails = { ...mockConnectionInfo };
 
 		testContext.apiWrapper.setup(x => x.connect(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return Promise.resolve(connection); });
 		testContext.apiWrapper.setup(x => x.getUriForConnection(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(undefined); });
@@ -115,10 +119,10 @@ describe('utils: In-depth tests to verify verifyConnectionAndGetOwnerUri', funct
 
 	it('Should not throw an error and set ownerUri appropriately', async function (): Promise<void> {
 		let ownerUri = undefined;
-		let connection  = {...mockConnectionResult};
-		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = {...mockDatabaseEndpoint};
+		let connection = { ...mockConnectionResult };
+		let testDatabaseEndpoint: mssql.SchemaCompareEndpointInfo = { ...mockDatabaseEndpoint };
 		let expectedOwnerUri: string = 'providerName:MSSQL|authenticationType:SqlLogin|database:My Database|server:My Server|user:My User|databaseDisplayName:My Database';
-		testDatabaseEndpoint.connectionDetails = {...mockConnectionInfo};
+		testDatabaseEndpoint.connectionDetails = { ...mockConnectionInfo };
 
 		testContext.apiWrapper.setup(x => x.connect(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return Promise.resolve(connection); });
 		testContext.apiWrapper.setup(x => x.getUriForConnection(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(expectedOwnerUri); });
@@ -128,3 +132,18 @@ describe('utils: In-depth tests to verify verifyConnectionAndGetOwnerUri', funct
 		should(ownerUri).equal(expectedOwnerUri);
 	});
 });
+
+describe('utils: Test to verify exists method', () => {
+	it('Should run as expected', async () => {
+		const filename = path.join(os.tmpdir(), `SchemaCompareUtilsTest_${uuid.v4()}`);
+		try {
+			should(await exists(filename)).be.false();
+			await fs.writeFile(filename, '');
+			should(await exists(filename)).be.true();
+		} finally {
+			try {
+				await fs.unlink(filename);
+			} catch { /* no-op */ }
+		}
+	});
+});