Sakshis/scmp test (#13904)

* Fixed a few await issues

* Introduced ModelView as a class member in schemaCompareMainWindow

* Added a few button tests

* Fixed tests

* Add a missing await

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

@@ -40,7 +40,7 @@ describe('SchemaCompareMainWindow.start @DacFx@', function (): void {
 	it('Should be correct when created.', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService();
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 		await result.start(undefined);
 
 		should(result.getComparisonResult() === undefined);
@@ -56,7 +56,7 @@ describe('SchemaCompareMainWindow.start @DacFx@', function (): void {
 	it('Should start with the source as undefined', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService();
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 		await result.start(undefined);
 
 		should.equal(result.sourceEndpointInfo, undefined);
@@ -66,8 +66,8 @@ describe('SchemaCompareMainWindow.start @DacFx@', function (): void {
 	it('Should start with the source as database', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService();
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
-		await result.start({ connectionProfile: mockIConnectionProfile });
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
+		await result.start({connectionProfile: mockIConnectionProfile});
 
 		should.notEqual(result.sourceEndpointInfo, undefined);
 		should.equal(result.sourceEndpointInfo.endpointType, mssql.SchemaCompareEndpointType.Database);
@@ -79,7 +79,7 @@ describe('SchemaCompareMainWindow.start @DacFx@', function (): void {
 	it('Should start with the source as dacpac.', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService();
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 		const dacpacPath = mockFilePath;
 		await result.start(dacpacPath);
 
@@ -392,7 +392,7 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 			throw new Error(message);
 		});
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 		await result.start(undefined);
 
 		should(result.getComparisonResult() === undefined);
@@ -406,7 +406,7 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 	it('Should exit for failing Schema Compare service', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService(testStateScmp.FAILURE);
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -421,7 +421,7 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 	it('Should disable script button and apply button for Schema Compare service for dacpac', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService(testStateScmp.SUCCESS_NOT_EQUAL);
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -447,10 +447,10 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 		});
 	});
 
-	it('Should disable script button and apply button for Schema Compare service for database', async function (): Promise<void> {
+	it('Should enable script button and apply button for Schema Compare service for database', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService(testStateScmp.SUCCESS_NOT_EQUAL);
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -476,6 +476,35 @@ describe('SchemaCompareMainWindow.execute', function (): void {
 		});
 	});
 
+	it('Should enable script button and apply button for Schema Compare service for database, using button onClick fire event', async function (): Promise<void> {
+		let sc = new SchemaCompareTestService(testStateScmp.SUCCESS_NOT_EQUAL);
+
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, testContext.viewContext.view);
+
+		await result.start(undefined);
+
+		should(result.getComparisonResult() === undefined);
+
+		result.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		result.targetEndpointInfo = setDatabaseEndpointInfo();
+
+		testContext.viewContext.compareButtonOnClick.fire(undefined);
+		await result.promise;
+
+		//Generate script button and apply button should be enabled for database comparison
+		result.verifyButtonsState({
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: true,
+			applyButtonState: true} );
+	});
+
 });
 
 describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
@@ -489,7 +518,7 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 		let sc = new SchemaCompareTestService();
 		let endpointInfo: mssql.SchemaCompareEndpointInfo;
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -518,7 +547,7 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 		let sc = new SchemaCompareTestService();
 		let endpointInfo: mssql.SchemaCompareEndpointInfo;
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -545,9 +574,8 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 
 	it('Should set buttons appropriately when source and target endpoints are populated', async function (): Promise<void> {
 		let sc = new SchemaCompareTestService();
-		let endpointInfo: mssql.SchemaCompareEndpointInfo;
 
-		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object);
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, null);
 
 		await result.start(undefined);
 
@@ -573,3 +601,146 @@ describe('SchemaCompareMainWindow.updateSourceAndTarget', function (): void {
 	});
 
 });
+
+describe('SchemaCompareMainWindow: Button clicks', function (): void {
+	before(() => {
+		mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
+		mockExtensionContext.setup(x => x.extensionPath).returns(() => '');
+		testContext = createContext();
+	});
+	this.beforeEach(() => {
+		sinon.restore();
+		showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
+	});
+	this.afterEach(() => {
+		sinon.restore();
+	});
+
+	it('createSwitchButton click to start schema comparison', async function (): Promise<void> {
+		let sc = new SchemaCompareTestService();
+
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, testContext.viewContext.view);
+
+		await result.start(undefined);
+
+		should(result.getComparisonResult() === undefined);
+
+		result.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		result.targetEndpointInfo = setDatabaseEndpointInfo();
+
+		testContext.viewContext.switchDirectionButtonOnClick.fire(undefined);
+		await result.promise;
+
+		//Verify that switch actually happened
+		should.notEqual(result.sourceEndpointInfo, undefined);
+		should.equal(result.sourceEndpointInfo.endpointType, mssql.SchemaCompareEndpointType.Database);
+		should.equal(result.sourceEndpointInfo.serverName, 'My Server');
+		should.equal(result.sourceEndpointInfo.databaseName, 'My Database');
+		should.notEqual(result.targetEndpointInfo, undefined);
+		should.equal(result.targetEndpointInfo.endpointType, mssql.SchemaCompareEndpointType.Dacpac);
+		should.equal(result.targetEndpointInfo.packageFilePath, 'source.dacpac');
+
+		//Generate script button and apply button should be disabled for database to dacpac comparison
+		result.verifyButtonsState({
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		});
+	});
+
+	it('SourceAndTarget selection should open schemaCompareDialog', async function (): Promise<void> {
+		let sc = new SchemaCompareTestService();
+
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, testContext.viewContext.view);
+
+		await result.start(undefined);
+
+		should(result.getComparisonResult() === undefined);
+
+		result.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		result.targetEndpointInfo = setDatabaseEndpointInfo();
+
+		testContext.viewContext.selectButtonOnClick.fire(undefined);
+		await result.promise;
+
+		//Verify that Select button click opened a Schema Compare dialog
+		should.notEqual(result.schemaCompareDialog, undefined);
+		should.notEqual(result.schemaCompareDialog.dialog, undefined);
+		should(result.schemaCompareDialog.dialog.title).equal(loc.SchemaCompareLabel);
+		should(result.schemaCompareDialog.dialog.okButton.label).equal(loc.OkButtonText);
+		should(result.schemaCompareDialog.dialog.okButton.enabled).equal(false); // Should be false when open
+	});
+
+	it('cancelCompare click to cancel schema comparison', async function (): Promise<void> {
+		let sc = new SchemaCompareTestService();
+
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, testContext.viewContext.view);
+
+		await result.start(undefined);
+
+		should(result.getComparisonResult() === undefined);
+
+		result.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		result.targetEndpointInfo = setDatabaseEndpointInfo();
+		await result.execute();
+
+		testContext.viewContext.cancelCompareButtonOnClick.fire(undefined);
+
+		//Verify no error message was thrown
+		should(showErrorMessageSpy.notCalled).be.true();
+
+		//Generate script button and apply button should be enabled for database comparison
+		result.verifyButtonsState({
+			compareButtonState: true,
+			optionsButtonState: true,
+			switchButtonState: true,
+			openScmpButtonState: true,
+			saveScmpButtonState: true,
+			cancelCompareButtonState: false,
+			selectSourceButtonState: true,
+			selectTargetButtonState: true,
+			generateScriptButtonState: false,
+			applyButtonState: false
+		});
+	});
+
+	it('generateScript click to generate script for schema comparison', async function (): Promise<void> {
+		let sc = new SchemaCompareTestService();
+
+		let result = new SchemaCompareMainWindowTest(sc, mockExtensionContext.object, testContext.viewContext.view);
+
+		await result.start(undefined);
+
+		should(result.getComparisonResult() === undefined);
+
+		result.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
+		result.targetEndpointInfo = setDatabaseEndpointInfo();
+		await result.execute();
+
+		testContext.viewContext.generateScriptButtonOnClick.fire(undefined);
+
+		//Verify no error message was thrown
+		should(showErrorMessageSpy.notCalled).be.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

@@ -42,7 +42,7 @@ describe('SchemaCompareDialog.openDialog @DacFx@', function (): void {
 	});
 
 	it('Simulate ok button- with both endpoints set to dacpac', async function (): Promise<void> {
-		let schemaCompareResult = new SchemaCompareMainWindowTest(undefined, mockExtensionContext.object);
+		let schemaCompareResult = new SchemaCompareMainWindowTest(undefined, mockExtensionContext.object, undefined);
 		await schemaCompareResult.start(undefined);
 		schemaCompareResult.sourceEndpointInfo = setDacpacEndpointInfo(mocksource);
 		schemaCompareResult.targetEndpointInfo = setDacpacEndpointInfo(mocktarget);

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

@@ -3,16 +3,21 @@
  *  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';
 import * as path from 'path';
+import * as loc from './../localizedConstants';
 
 export interface TestContext {
 	context: vscode.ExtensionContext;
+	viewContext: ViewTestContext;
 }
 
 export function createContext(): TestContext {
 	let extensionPath = path.join(__dirname, '..', '..');
 
+	let viewContext = createViewContext();
+
 	return {
 		context: {
 			subscriptions: [],
@@ -36,5 +41,327 @@ export function createContext(): TestContext {
 			logUri: undefined,
 			storageUri: undefined
 		},
+		viewContext: viewContext
+	};
+}
+
+export interface ViewTestContext {
+	view: azdata.ModelView;
+	onClick: vscode.EventEmitter<any>;
+	onTextChanged: vscode.EventEmitter<any>;
+	onValueChanged: vscode.EventEmitter<any>;
+	compareButtonOnClick: vscode.EventEmitter<any>;
+	selectButtonOnClick: vscode.EventEmitter<any>;
+	switchDirectionButtonOnClick: vscode.EventEmitter<any>;
+	cancelCompareButtonOnClick: vscode.EventEmitter<any>;
+	generateScriptButtonOnClick: vscode.EventEmitter<any>;
+}
+
+export function createViewContext(): ViewTestContext {
+	let onClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let onTextChanged: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let onValueChanged: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let compareButtonOnClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let selectButtonOnClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let switchDirectionButtonOnClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let cancelCompareButtonOnClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+	let generateScriptButtonOnClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
+
+	let componentBase: azdata.Component = {
+		id: '',
+		updateProperties: () => Promise.resolve(),
+		updateProperty: () => Promise.resolve(),
+		updateCssStyles: undefined!,
+		onValidityChanged: undefined!,
+		valid: true,
+		validate: undefined!,
+		focus: () => Promise.resolve()
+	};
+
+	let container = {
+		clearItems: () => { },
+		addItems: () => { },
+		addItem: () => { },
+		removeItem: () => true,
+		insertItem: () => { },
+		items: [] as any[],
+		setLayout: () => { },
+		setItemLayout: () => { }
+	};
+
+	let button = () => {
+		let button: azdata.ButtonComponent = Object.assign({}, componentBase, {
+			name: '',
+			label: '',
+			onDidClick: onClick.event
+		});
+		return button;
+	};
+	let buttonBuilder = () => {
+		let b = button();
+		let builder: azdata.ComponentBuilder<azdata.ButtonComponent, azdata.ButtonProperties> = {
+			component: () => b,
+			withProperties: (properties: any) => {
+				if ((properties as any).label === loc.compare) {
+					b.label = loc.compare;
+					b.onDidClick = compareButtonOnClick.event;
+				} else if ((properties as any).label === '•••') {
+					b.label = '•••';
+					b.onDidClick = selectButtonOnClick.event;
+				} else if ((properties as any).label === loc.switchDirection) {
+					b.label = loc.switchDirection;
+					b.onDidClick = switchDirectionButtonOnClick.event;
+				} else if ((properties as any).label === loc.stop) {
+					b.label = loc.stop;
+					b.onDidClick = cancelCompareButtonOnClick.event;
+				} else if ((properties as any).label === loc.generateScript) {
+					b.label = loc.generateScript;
+					b.onDidClick = generateScriptButtonOnClick.event;
+				}
+				return builder;
+			},
+			withProps: (properties) => {
+				if ((properties as any).label === loc.compare) {
+					b.label = loc.compare;
+					b.onDidClick = compareButtonOnClick.event;
+				} else if ((properties as any).label === '•••') {
+					b.label = '•••';
+					b.onDidClick = selectButtonOnClick.event;
+				} else if ((properties as any).label === loc.switchDirection) {
+					b.label = loc.switchDirection;
+					b.onDidClick = switchDirectionButtonOnClick.event;
+				} else if ((properties as any).label === loc.stop) {
+					b.label = loc.stop;
+					b.onDidClick = cancelCompareButtonOnClick.event;
+				} else if ((properties as any).label === loc.generateScript) {
+					b.label = loc.generateScript;
+					b.onDidClick = generateScriptButtonOnClick.event;
+				}
+				return builder;
+			},
+			withValidation: () => builder
+		};
+		return builder;
+	};
+
+	let radioButton: azdata.RadioButtonComponent = Object.assign({}, componentBase, {
+		checked: false,
+		onDidClick: onClick.event,
+	});
+	let radioButtonBuilder: azdata.ComponentBuilder<azdata.ButtonComponent, azdata.ButtonProperties> = {
+		component: () => radioButton,
+		withProperties: () => radioButtonBuilder,
+		withProps: () => radioButtonBuilder,
+		withValidation: () => radioButtonBuilder
+	};
+
+	let checkbox: azdata.CheckBoxComponent = Object.assign({}, componentBase, {
+		checked: true,
+		onChanged: onClick.event
+	});
+	let checkBoxBuilder: azdata.ComponentBuilder<azdata.CheckBoxComponent, azdata.CheckBoxProperties> = {
+		component: () => checkbox,
+		withProperties: () => checkBoxBuilder,
+		withProps: () => checkBoxBuilder,
+		withValidation: () => checkBoxBuilder
+	};
+
+	let form: azdata.FormContainer = Object.assign({}, componentBase, container, {
+	});
+	let formBuilder: azdata.FormBuilder = Object.assign({}, {
+		component: () => form,
+		addFormItem: () => { },
+		insertFormItem: () => { },
+		removeFormItem: () => true,
+		addFormItems: () => { },
+		withFormItems: () => formBuilder,
+		withProperties: () => formBuilder,
+		withValidation: () => formBuilder,
+		withItems: () => formBuilder,
+		withLayout: () => formBuilder,
+		withProps: () => formBuilder
+	});
+
+	let toolbar: azdata.ToolbarContainer = Object.assign({}, componentBase, container, {
+	});
+	let toolbarBuilder: azdata.ToolbarBuilder = Object.assign({}, {
+		component: () => toolbar,
+		withToolbarItems: () => toolbarBuilder,
+		addToolbarItems: () => { },
+		addToolbarItem: () => { },
+		withProperties: () => toolbarBuilder,
+		withValidation: () => toolbarBuilder,
+		withItems: () => toolbarBuilder,
+		withLayout: () => toolbarBuilder,
+		withProps: () => toolbarBuilder
+	});
+
+	let flex: azdata.FlexContainer = Object.assign({}, componentBase, container, {
+	});
+	let flexBuilder: azdata.FlexBuilder = Object.assign({}, {
+		component: () => flex,
+		withProperties: () => flexBuilder,
+		withValidation: () => flexBuilder,
+		withItems: () => flexBuilder,
+		withLayout: () => flexBuilder,
+		withProps: () => flexBuilder
+	});
+
+	let div: azdata.DivContainer = Object.assign({}, componentBase, container, {
+		onDidClick: onClick.event
+	});
+	let divBuilder: azdata.DivBuilder = Object.assign({}, {
+		component: () => div,
+		withProperties: () => divBuilder,
+		withValidation: () => divBuilder,
+		withItems: () => divBuilder,
+		withLayout: () => divBuilder,
+		withProps: () => divBuilder
+	});
+
+	let splitView: azdata.SplitViewContainer = Object.assign({}, componentBase, container, {
+		onDidClick: onClick.event
+	});
+	let splitViewBuilder: azdata.SplitViewBuilder = Object.assign({}, {
+		component: () => splitView,
+		withProperties: () => splitViewBuilder,
+		withValidation: () => splitViewBuilder,
+		withItems: () => splitViewBuilder,
+		withLayout: () => splitViewBuilder,
+		withProps: () => splitViewBuilder
+	});
+
+	let diffEditor: () => azdata.DiffEditorComponent = () => Object.assign({}, componentBase, {
+		contentLeft: '',
+		contentRight: '',
+		languageMode: '',
+		editorUriLeft: '',
+		editorUriRight: '',
+		onContentChanged: onClick.event,
+		onEditorCreated: onClick.event,
+		isAutoResizable: false,
+		minimumHeight: 0,
+		title: ''
+	});
+	let diffEditorBuilder: azdata.ComponentBuilder<azdata.DiffEditorComponent, azdata.DiffEditorComponent> = {
+		component: () => diffEditor(),
+		withProperties: () => diffEditorBuilder,
+		withValidation: () => diffEditorBuilder,
+		withProps: () => diffEditorBuilder
+	};
+
+	let inputBox: () => azdata.InputBoxComponent = () => Object.assign({}, componentBase, {
+		onTextChanged: onTextChanged.event,
+		onEnterKeyPressed: onClick.event,
+		value: ''
+	});
+	let inputBoxBuilder: azdata.ComponentBuilder<azdata.InputBoxComponent, azdata.InputBoxProperties> = {
+		component: () => {
+			let r = inputBox();
+			return r;
+		},
+		withProperties: () => inputBoxBuilder,
+		withProps: () => inputBoxBuilder,
+		withValidation: () => inputBoxBuilder
+	};
+
+	let dropdown: () => azdata.DropDownComponent = () => Object.assign({}, componentBase, {
+		onValueChanged: onValueChanged.event,
+		value: {
+			name: '',
+			displayName: ''
+		},
+		values: []
+	});
+	let dropdownBuilder: azdata.ComponentBuilder<azdata.DropDownComponent, azdata.DropDownProperties> = {
+		component: () => {
+			let r = dropdown();
+			return r;
+		},
+		withProperties: () => dropdownBuilder,
+		withProps: () => dropdownBuilder,
+		withValidation: () => dropdownBuilder
+	};
+
+	let table: () => azdata.TableComponent = () => Object.assign({}, componentBase, {
+		data: [] as any[][],
+		columns: [] as string[],
+		onRowSelected: onClick.event,
+		onCellAction: onClick.event,
+		appendData: (data: any[][]) => undefined
+	});
+	let tableBuilder: azdata.ComponentBuilder<azdata.TableComponent, azdata.TableComponentProperties> = {
+		component: () => table(),
+		withProperties: () => tableBuilder,
+		withProps: () => tableBuilder,
+		withValidation: () => tableBuilder
+	};
+
+	let loadingComponent: () => azdata.LoadingComponent = () => Object.assign({}, componentBase, {
+		loading: false,
+		component: undefined!
+	});
+	let loadingBuilder: azdata.LoadingComponentBuilder = {
+		component: () => loadingComponent(),
+		withProperties: () => loadingBuilder,
+		withProps: () => loadingBuilder,
+		withValidation: () => loadingBuilder,
+		withItem: () => loadingBuilder
+	};
+
+	let view: azdata.ModelView = {
+		onClosed: undefined!,
+		connection: undefined!,
+		serverInfo: undefined!,
+		valid: true,
+		onValidityChanged: undefined!,
+		validate: undefined!,
+		initializeModel: () => { return Promise.resolve(); },
+		modelBuilder: {
+			listView: undefined!,
+			radioCardGroup: undefined!,
+			navContainer: undefined!,
+			divContainer: () => divBuilder,
+			flexContainer: () => flexBuilder,
+			splitViewContainer: () => splitViewBuilder,
+			dom: undefined!,
+			card: () => undefined!,
+			inputBox: () => inputBoxBuilder,
+			checkBox: () => checkBoxBuilder!,
+			radioButton: () => radioButtonBuilder,
+			webView: undefined!,
+			editor: undefined!,
+			diffeditor: () => diffEditorBuilder,
+			text: () => inputBoxBuilder,
+			image: () => undefined!,
+			button: () => buttonBuilder(),
+			dropDown: () => dropdownBuilder,
+			tree: undefined!,
+			listBox: undefined!,
+			table: () => tableBuilder,
+			declarativeTable: () => undefined!,
+			dashboardWidget: undefined!,
+			dashboardWebview: undefined!,
+			formContainer: () => formBuilder,
+			groupContainer: () => undefined!,
+			toolbarContainer: () => toolbarBuilder,
+			loadingComponent: () => loadingBuilder,
+			fileBrowserTree: undefined!,
+			hyperlink: () => undefined!,
+			tabbedPanel: undefined!,
+			separator: undefined!,
+			propertiesContainer: undefined!
+		}
+	};
+	return {
+		view: view,
+		onClick: onClick,
+		onTextChanged: onTextChanged,
+		onValueChanged: onValueChanged,
+		compareButtonOnClick: compareButtonOnClick,
+		selectButtonOnClick: selectButtonOnClick,
+		switchDirectionButtonOnClick: switchDirectionButtonOnClick,
+		cancelCompareButtonOnClick: cancelCompareButtonOnClick,
+		generateScriptButtonOnClick: generateScriptButtonOnClick,
 	};
 }

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

@@ -3,6 +3,7 @@
  *  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';
 import * as mssql from '../../../mssql';
 import * as should from 'should';
@@ -24,8 +25,9 @@ export class SchemaCompareMainWindowTest extends SchemaCompareMainWindow {
 
 	constructor(
 		schemaCompareService: mssql.ISchemaCompareService,
-		extensionContext: vscode.ExtensionContext) {
-		super(schemaCompareService, extensionContext);
+		extensionContext: vscode.ExtensionContext,
+		view: azdata.ModelView) {
+		super(schemaCompareService, extensionContext, view);
 	}
 
 	// only for test

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

@@ -103,11 +103,39 @@ export class SchemaCompareTestService implements mssql.ISchemaCompareService {
 	}
 
 	schemaCompareGenerateScript(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> {
-		return undefined;
+		let result: azdata.ResultStatus;
+		if (this.testState === testStateScmp.FAILURE) {
+			result = {
+				success: false,
+				errorMessage: 'Test failure'
+			};
+		}
+		else {
+			result = {
+				success: true,
+				errorMessage: ''
+			};
+		}
+
+		return Promise.resolve(result);
 	}
 
 	schemaCompareCancel(operationId: string): Thenable<azdata.ResultStatus> {
-		return undefined;
+		let result: azdata.ResultStatus;
+		if (this.testState === testStateScmp.FAILURE) {
+			result = {
+				success: false,
+				errorMessage: 'Test failure'
+			};
+		}
+		else {
+			result = {
+				success: true,
+				errorMessage: ''
+			};
+		}
+
+		return Promise.resolve(result);
 	}
 
 	handle?: number;