ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-11 02:32:35 -05:00
Code Issues Packages Projects Releases Wiki Activity

Removing ApiWrapper and adding sinon (#11340)

Browse Source 
* Added sinon
removed api wrapper
removed unnecesaary utils

* merged from testfix

* merged from aasim/import/downloadTestFix

* merge from aasim/import/downloadTestFix
This commit is contained in:
Aasim Khan
2020-07-14 14:53:18 -07:00
committed by GitHub
parent cabbbb56f2
commit 24f6cd2e5b
19 changed files with 212 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
extensions/import/src/test/controllers/mainController.test.ts
View File

@@ -3,42 +3,21 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as TypeMoq from 'typemoq';
import { ApiWrapper } from '../../common/apiWrapper';
import MainController from '../../controllers/mainController';
import * as constants from '../../common/constants';
import * as should from 'should';
import * as path from 'path';
import { ImportTestUtils, TestExtensionContext } from '../utils.test';
import * as should from 'should';
describe('Main Controller', function () {
let testExtensionContext: TestExtensionContext;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
let extensionPath: string;
beforeEach(async function () {
extensionPath = await ImportTestUtils.getExtensionPath();
// creating a mock Extension Context with current extensionPath
testExtensionContext = await ImportTestUtils.getTestExtensionContext();
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper);
});
it('Should download required binaries and register flatFileImportStartCommand after activate is called', async function () {
this.timeout(50000);
// using vscode and azdata APIs available during tests
mockApiWrapper.callBase = true;
let mainController = new MainController(testExtensionContext, mockApiWrapper.object);
await mainController.activate();
// verifying that the task is registered.
mockApiWrapper.verify(x => x.registerTask(constants.flatFileImportStartCommand, TypeMoq.It.isAny()), TypeMoq.Times.once());
//Checking if .net code files are downloaded
should.equal(await ImportTestUtils.checkPathExists(path.join(extensionPath, 'flatfileimportservice')), true);
it('Should register task flatFileImportStartCommand after activate is called', async function () {
let mainController = new MainController(testExtensionContext);
should.doesNotThrow(() => mainController.activate());
});
});

72
extensions/import/src/test/utils.test.ts
View File

@@ -7,7 +7,6 @@ import * as azdata from 'azdata';
import * as vscode from 'vscode';
import { ImportDataModel, ColumnMetadata } from '../wizard/api/models';
import { FlatFileProvider, PROSEDiscoveryParams, InsertDataParams, GetColumnInfoParams, ChangeColumnSettingsParams, PROSEDiscoveryResponse, InsertDataResponse, ChangeColumnSettingsResponse, GetColumnInfoResponse } from '../services/contracts';
import * as fs from 'fs';
export class ImportTestUtils {
@@ -37,12 +36,6 @@ export class ImportTestUtils {
} as azdata.connection.ConnectionProfile;
}
public static async checkPathExists(path: string): Promise<boolean> {
return fs.promises.access(path, fs.constants.F_OK)
.then(() => true)
.catch(() => false);
}
public static async getExtensionPath(): Promise<string> {
return await vscode.extensions.getExtension('Microsoft.import').extensionPath;
}
@@ -134,73 +127,10 @@ export class TestQueryProvider implements azdata.QueryProvider {
throw new Error('Method not implemented.');
}
handle?: number;
providerId: string;
providerId: string = 'testProviderId';
}
export class TestWizard implements azdata.window.Wizard {
title: string;
pages: azdata.window.WizardPage[];
currentPage: number;
doneButton: azdata.window.Button;
cancelButton: azdata.window.Button;
generateScriptButton: azdata.window.Button = azdata.window.createButton('testButton');
nextButton: azdata.window.Button;
backButton: azdata.window.Button;
customButtons: azdata.window.Button[];
displayPageTitles: boolean;
onPageChanged: vscode.Event<azdata.window.WizardPageChangeInfo> = new vscode.EventEmitter<any>().event;
addPage(page: azdata.window.WizardPage, index?: number): Thenable<void> {
throw new Error('Method not implemented.');
}
removePage(index: number): Thenable<void> {
throw new Error('Method not implemented.');
}
setCurrentPage(index: number): Thenable<void> {
throw new Error('Method not implemented.');
}
open(): Thenable<void> {
throw new Error('Method not implemented.');
}
close(): Thenable<void> {
throw new Error('Method not implemented.');
}
registerNavigationValidator(validator: (pageChangeInfo: azdata.window.WizardPageChangeInfo) => boolean | Thenable<boolean>): void {
throw new Error('Method not implemented.');
}
message: azdata.window.DialogMessage;
registerOperation(operationInfo: azdata.BackgroundOperationInfo): void {
throw new Error('Method not implemented.');
}
}
export class TestWizardPage implements azdata.window.WizardPage {
title: string;
content: string;
customButtons: azdata.window.Button[];
enabled: boolean;
description: string;
registerContent(handler: (view: azdata.ModelView) => Thenable<void>): void {
throw new Error('Method not implemented.');
}
modelView: azdata.ModelView;
valid: boolean;
onValidityChanged: vscode.Event<boolean>;
}
export class TestButton implements azdata.window.Button {
label: string;
enabled: boolean;
hidden: boolean;
focused?: boolean;
constructor(private onClickEmitter: vscode.EventEmitter<void>) {
}
onClick: vscode.Event<void> = this.onClickEmitter.event;
position?: azdata.window.DialogButtonPosition;
}
export class TestExtensionContext implements vscode.ExtensionContext {
extensionMode: vscode.ExtensionMode;
subscriptions: { dispose(): any; }[];

26
extensions/import/src/test/wizard/api/basePage.test.ts
View File

@@ -6,32 +6,34 @@
import * as TypeMoq from 'typemoq';
import * as azdata from 'azdata';
import { FlatFileWizard } from '../../../wizard/flatFileWizard';
import { ApiWrapper } from '../../../common/apiWrapper';
import { ImportDataModel } from '../../../wizard/api/models';
import { TestImportDataModel, ImportTestUtils } from '../../utils.test';
import { FileConfigPage } from '../../../wizard/pages/fileConfigPage';
import * as should from 'should';
import * as sinon from 'sinon';
describe('import extension wizard pages', function () {
describe('Base page tests', function () {
let mockFlatFileWizard: TypeMoq.IMock<FlatFileWizard>;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
let mockImportModel: TypeMoq.IMock<ImportDataModel>;
beforeEach(function () {
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny(), mockApiWrapper.object);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny());
mockImportModel = TypeMoq.Mock.ofType(TestImportDataModel, TypeMoq.MockBehavior.Loose);
});
afterEach(function (): void {
sinon.restore();
});
it('getDatabaseValue returns active database first', async function () {
// setting up the environment
let databases: string[] = ['testdb1', 'testdb2', 'testdb3'];
let activeDatabase: string = 'testdb2';
// setting up mocks
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny(), mockApiWrapper.object);
mockApiWrapper.setup(x => x.listDatabases(TypeMoq.It.isAnyString())).returns(async () => { return databases; });
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny());
sinon.stub(azdata.connection, 'listDatabases').returns(Promise.resolve(databases));
mockImportModel.object.server = {
providerName: 'MSSQL',
connectionId: 'testConnectionId',
@@ -52,10 +54,10 @@ describe('import extension wizard pages', function () {
it('getServerValue returns null on no active connection', async function () {
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny(), mockApiWrapper.object);
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny());
// mocking getActive connection to return null
mockApiWrapper.setup(x => x.getActiveConnections()).returns(async () => { return undefined; });
let getActiveConnectionStub = sinon.stub(azdata.connection, 'getActiveConnections').returns(Promise.resolve(undefined));
let serverValues = await importPage.getServerValues();
@@ -63,7 +65,7 @@ describe('import extension wizard pages', function () {
should.equal(serverValues, undefined, 'getServer should be undefined for no active connections');
// mocking getActive connection returns empty array
mockApiWrapper.setup(x => x.getActiveConnections()).returns(async () => { return [] as azdata.connection.Connection[]; });
getActiveConnectionStub.returns(Promise.resolve([] as azdata.connection.Connection[]));
serverValues = await importPage.getServerValues();
@@ -100,8 +102,8 @@ describe('import extension wizard pages', function () {
}
];
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny(), mockApiWrapper.object);
mockApiWrapper.setup(x => x.getActiveConnections()).returns(async () => { return testActiveConnections; });
let importPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny());
sinon.stub(azdata.connection, 'getActiveConnections').returns(Promise.resolve(testActiveConnections));
mockImportModel.object.server = ImportTestUtils.getTestServer();
// the second connection should be the first element in the array as it is active

61
extensions/import/src/test/wizard/flatFileWizard.test.ts
View File

@@ -6,16 +6,22 @@
import * as TypeMoq from 'typemoq';
import * as vscode from 'vscode';
import * as azdata from 'azdata';
import { ApiWrapper } from '../../common/apiWrapper';
import { FlatFileWizard } from '../../wizard/flatFileWizard';
import { ImportTestUtils, TestWizard, TestWizardPage, TestButton } from '../utils.test';
import { ImportTestUtils } from '../utils.test';
import * as should from 'should';
import * as sinon from 'sinon';
describe('import extension flat file wizard', function () {
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
this.beforeEach(function () {
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper);
let showErrorMessageSpy: sinon.SinonSpy;
this.beforeEach(function() {
showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
});
this.afterEach(function () {
sinon.restore();
});
it('opens connectionDialog when there are no active connections', async function () {
let testConnection: azdata.connection.Connection = {
providerName: 'MSSQL',
@@ -24,46 +30,43 @@ describe('import extension flat file wizard', function () {
};
// There is no current connection.
mockApiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return undefined; });
sinon.stub(azdata.connection, 'getCurrentConnection').returns(undefined);
// openConnectionDialog returns a test connection
mockApiWrapper.setup(x => x.openConnectionDialog(TypeMoq.It.isAny())).returns(async () => { return testConnection; });
let openConnectionDialogSpy = sinon.stub(azdata.connection, 'openConnectionDialog').returns(Promise.resolve(testConnection));
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny(), mockApiWrapper.object);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny());
await testFlatFileWizard.getConnectionId();
// openConnectionDialog will be called once
mockApiWrapper.verify(x => x.openConnectionDialog(TypeMoq.It.isAny()), TypeMoq.Times.once());
sinon.assert.calledOnce(openConnectionDialogSpy);
});
it('shows error message when an invalid connection is selected', async function () {
// The active connection doesn't have a valid Provider
let testConnectionProfile: azdata.connection.ConnectionProfile = ImportTestUtils.getTestConnectionProfile();
mockApiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(testConnectionProfile); });
mockApiWrapper.setup(x => x.openConnectionDialog(TypeMoq.It.isAny())).returns(() => { return undefined; });
sinon.stub(azdata.connection, 'getCurrentConnection').returns(Promise.resolve(testConnectionProfile));
sinon.stub(azdata.connection, 'openConnectionDialog').returns(undefined);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny(), mockApiWrapper.object);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny());
await testFlatFileWizard.getConnectionId();
mockApiWrapper.verify(x => x.showErrorMessage(TypeMoq.It.isAny()), TypeMoq.Times.once());
sinon.assert.calledOnce(showErrorMessageSpy);
});
it('shows error message when no connection is selected', async function () {
// The active connection doesn't have a valid Provider
mockApiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return undefined; });
mockApiWrapper.setup(x => x.openConnectionDialog(TypeMoq.It.isAny())).returns(() => { return undefined; });
sinon.stub(azdata.connection, 'getCurrentConnection').returns(Promise.resolve(undefined));
sinon.stub(azdata.connection, 'openConnectionDialog').returns(undefined);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny(), mockApiWrapper.object);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny());
await testFlatFileWizard.getConnectionId();
mockApiWrapper.verify(x => x.showErrorMessage(TypeMoq.It.isAny()), TypeMoq.Times.once());
sinon.assert.calledOnce(showErrorMessageSpy);
});
it('getConnection returns active connection', async function () {
@@ -71,9 +74,9 @@ describe('import extension flat file wizard', function () {
testConnectionProfile.providerId = 'MSSQL';
//mocking an active connection
mockApiWrapper.setup(x => x.getCurrentConnection()).returns(async () => { return testConnectionProfile; })
sinon.stub(azdata.connection, 'getCurrentConnection').returns(Promise.resolve(testConnectionProfile));
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny(), mockApiWrapper.object);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny());
//getConnectionID should return the connectionId of active connection
let connectionId = await testFlatFileWizard.getConnectionId();
@@ -83,23 +86,15 @@ describe('import extension flat file wizard', function () {
it('should initialize all pages', async function () {
let testConnectionProfile = ImportTestUtils.getTestConnectionProfile();
testConnectionProfile.providerId = 'MSSQL';
mockApiWrapper.setup(x => x.getCurrentConnection()).returns(async () => { return testConnectionProfile; });
let onClick: vscode.EventEmitter<any> = new vscode.EventEmitter<any>();
let mockWizard = TypeMoq.Mock.ofType(TestWizard);
let mockWizardPage = TypeMoq.Mock.ofType(TestWizardPage);
let mockButton = TypeMoq.Mock.ofType(TestButton, TypeMoq.MockBehavior.Loose, undefined, onClick);
sinon.stub(azdata.connection, 'getCurrentConnection').returns(Promise.resolve(testConnectionProfile));
let testProvider = {
providerId: 'testProviderId',
connectionProfile: ImportTestUtils.getTestConnectionProfile()
};
// Mocking wizard component creation
mockApiWrapper.setup(x => x.createWizard(TypeMoq.It.isAnyString())).returns(() => { return mockWizard.object; });
mockApiWrapper.setup(x => x.createWizardPage(TypeMoq.It.isAnyString())).returns(() => { return mockWizardPage.object; });
mockApiWrapper.setup(x => x.createButton(TypeMoq.It.isAnyString())).returns(() => { return mockButton.object; });
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny(), mockApiWrapper.object);
let testFlatFileWizard = new FlatFileWizard(TypeMoq.It.isAny());
await testFlatFileWizard.start(testProvider);

36
extensions/import/src/test/wizard/pages/fileConfigPage.test.ts
View File

@@ -6,18 +6,17 @@
import * as TypeMoq from 'typemoq';
import * as azdata from 'azdata';
import { FlatFileWizard } from '../../../wizard/flatFileWizard';
import { ApiWrapper } from '../../../common/apiWrapper';
import { ImportDataModel } from '../../../wizard/api/models';
import { TestImportDataModel, TestQueryProvider } from '../../utils.test';
import { FileConfigPage } from '../../../wizard/pages/fileConfigPage';
import * as should from 'should';
import * as sinon from 'sinon';
import { ImportPage } from '../../../wizard/api/importPage';
import * as constants from '../../../common/constants';
describe('File config page', function () {
let mockFlatFileWizard: TypeMoq.IMock<FlatFileWizard>;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
let mockImportModel: TypeMoq.IMock<ImportDataModel>;
let fileConfigPage: FileConfigPage;
@@ -26,15 +25,15 @@ describe('File config page', function () {
let pages: Map<number, ImportPage> = new Map<number, ImportPage>();
this.beforeEach(function () {
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny(), mockApiWrapper.object);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny());
mockImportModel = TypeMoq.Mock.ofType(TestImportDataModel, TypeMoq.MockBehavior.Loose);
// using the actual vscode and azdata apis.
mockApiWrapper.callBase = true;
wizard = azdata.window.createWizard(constants.wizardNameText);
page = azdata.window.createWizardPage(constants.page1NameText);
});
wizard = mockApiWrapper.object.createWizard(constants.wizardNameText);
page = mockApiWrapper.object.createWizardPage(constants.page1NameText);
afterEach(function (): void {
sinon.restore();
});
it('getSchema returns active schema first', async function () {
@@ -77,9 +76,9 @@ describe('File config page', function () {
// setting up mocks to return test objects created earlier
mockQueryProvider.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => { return schemaQueryResult; });
mockApiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return mockQueryProvider.object; });
sinon.stub(azdata.dataprotocol, 'getProvider' ).returns(mockQueryProvider.object);
let fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny(), mockApiWrapper.object);
let fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, TypeMoq.It.isAny(), mockImportModel.object, TypeMoq.It.isAny(), TypeMoq.It.isAny());
let actualSchemaValues = await fileConfigPage.getSchemaValues();
should(expectedSchemaValues).deepEqual(actualSchemaValues);
@@ -89,7 +88,7 @@ describe('File config page', function () {
await new Promise(function (resolve) {
page.registerContent(async (view) => {
fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, fileConfigPage);
await fileConfigPage.start();
resolve();
@@ -118,11 +117,8 @@ describe('File config page', function () {
it('Dropdown values are correctly set', async function () {
// using the actual vscode and azdata apis.
mockApiWrapper.callBase = true;
wizard = mockApiWrapper.object.createWizard(constants.wizardNameText);
page = mockApiWrapper.object.createWizardPage(constants.page1NameText);
wizard = azdata.window.createWizard(constants.wizardNameText);
page = azdata.window.createWizardPage(constants.page1NameText);
// creating mock server values
let testActiveConnections: azdata.connection.Connection[] = [
@@ -154,7 +150,7 @@ describe('File config page', function () {
}
}
];
mockApiWrapper.setup(x => x.getActiveConnections()).returns(async () => { return testActiveConnections; });
sinon.stub(azdata.connection, 'getActiveConnections').returns(Promise.resolve(testActiveConnections));
// creating a test active connection. This connection will be the first value in server dropdown array
let testServerConnection: azdata.connection.Connection = {
@@ -191,7 +187,7 @@ describe('File config page', function () {
// creating mock database values
let databases: string[] = ['testdb1', 'testdb2', 'testdb3'];
mockApiWrapper.setup(x => x.listDatabases(TypeMoq.It.isAnyString())).returns(async () => { return databases; });
sinon.stub(azdata.connection, 'listDatabases').returns(Promise.resolve(databases));
mockImportModel.object.database = 'testdb2';
// expected values for the database dropdown
@@ -236,12 +232,12 @@ describe('File config page', function () {
];
let mockQueryProvider = TypeMoq.Mock.ofType(TestQueryProvider);
mockApiWrapper.setup(x => x.getProvider(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => { return mockQueryProvider.object; });
sinon.stub(azdata.dataprotocol, 'getProvider').returns(mockQueryProvider.object);
mockQueryProvider.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => { return schemaQueryResult; });
await new Promise(function (resolve) {
page.registerContent(async (view) => {
fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
fileConfigPage = new FileConfigPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, fileConfigPage);
await fileConfigPage.start();
await fileConfigPage.setupNavigationValidator();

15
extensions/import/src/test/wizard/pages/modifyColumnsPage.test.ts
View File

@@ -5,7 +5,6 @@
import * as TypeMoq from 'typemoq';
import * as azdata from 'azdata';
import { ApiWrapper } from '../../../common/apiWrapper';
import * as constants from '../../../common/constants';
import { FlatFileWizard } from '../../../wizard/flatFileWizard';
import * as should from 'should';
@@ -21,21 +20,17 @@ describe('import extension modify Column Page', function () {
let modifyColumnsPage: ModifyColumnsPage;
let mockFlatFileWizard: TypeMoq.IMock<FlatFileWizard>;
let mockImportModel: TypeMoq.IMock<ImportDataModel>;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
let pages: Map<number, ImportPage> = new Map<number, ImportPage>();
let mockFlatFileProvider: TypeMoq.IMock<FlatFileProvider>;
beforeEach(function () {
// Keeping the original behaviour of apiWrapper until some setup is needed to mock stuff
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper, TypeMoq.MockBehavior.Loose);
mockApiWrapper.callBase = true;
mockFlatFileProvider = TypeMoq.Mock.ofType(TestFlatFileProvider);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, mockFlatFileProvider.object, mockApiWrapper.object);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, mockFlatFileProvider.object);
mockImportModel = TypeMoq.Mock.ofType(TestImportDataModel, TypeMoq.MockBehavior.Loose);
wizard = mockApiWrapper.object.createWizard(constants.wizardNameText);
page = mockApiWrapper.object.createWizardPage(constants.page3NameText);
wizard = azdata.window.createWizard(constants.wizardNameText);
page = azdata.window.createWizardPage(constants.page3NameText);
});
@@ -43,7 +38,7 @@ describe('import extension modify Column Page', function () {
await new Promise(function (resolve) {
page.registerContent(async (view) => {
modifyColumnsPage = new ModifyColumnsPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
modifyColumnsPage = new ModifyColumnsPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, modifyColumnsPage);
await modifyColumnsPage.start();
resolve();
@@ -88,7 +83,7 @@ describe('import extension modify Column Page', function () {
await new Promise(function (resolve) {
page.registerContent(async (view) => {
modifyColumnsPage = new ModifyColumnsPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
modifyColumnsPage = new ModifyColumnsPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, modifyColumnsPage);
await modifyColumnsPage.start();
resolve();

14
extensions/import/src/test/wizard/pages/prosePreviewPage.test.ts
View File

@@ -5,7 +5,6 @@
import * as TypeMoq from 'typemoq';
import * as azdata from 'azdata';
import { ApiWrapper } from '../../../common/apiWrapper';
import * as constants from '../../../common/constants';
import { FlatFileWizard } from '../../../wizard/flatFileWizard';
import * as should from 'should';
@@ -19,7 +18,6 @@ describe('import extension prose preview tests', function () {
// declaring mock variables
let mockFlatFileWizard: TypeMoq.IMock<FlatFileWizard>;
let mockImportModel: TypeMoq.IMock<ImportDataModel>;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
// declaring instance variables
let wizard: azdata.window.Wizard;
@@ -31,16 +29,12 @@ describe('import extension prose preview tests', function () {
beforeEach(async function () {
// initializing mock variables
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny(), mockApiWrapper);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, TypeMoq.It.isAny());
mockImportModel = TypeMoq.Mock.ofType(TestImportDataModel, TypeMoq.MockBehavior.Loose);
// using the actual vscode and azdata apis.
mockApiWrapper.callBase = true;
// creating a wizard and adding page that will contain the fileConfigPage
wizard = mockApiWrapper.object.createWizard(constants.wizardNameText);
page = mockApiWrapper.object.createWizardPage(constants.page2NameText);
wizard = azdata.window.createWizard(constants.wizardNameText);
page = azdata.window.createWizardPage(constants.page2NameText);
});
@@ -49,7 +43,7 @@ describe('import extension prose preview tests', function () {
// Opening the wizard and initializing the page as ProsePreviewPage
await new Promise(function (resolve) {
page.registerContent(async (view) => {
prosePreviewPage = new ProsePreviewPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
prosePreviewPage = new ProsePreviewPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, prosePreviewPage);
await prosePreviewPage.start();
await prosePreviewPage.setupNavigationValidator();

15
extensions/import/src/test/wizard/pages/summaryPage.test.ts
View File

@@ -5,7 +5,6 @@
import * as TypeMoq from 'typemoq';
import * as azdata from 'azdata';
import { ApiWrapper } from '../../../common/apiWrapper';
import * as constants from '../../../common/constants';
import { FlatFileWizard } from '../../../wizard/flatFileWizard';
import * as should from 'should';
@@ -19,7 +18,6 @@ describe('import extension summary page tests', function () {
let mockFlatFileWizard: TypeMoq.IMock<FlatFileWizard>;
let mockImportModel: TypeMoq.IMock<ImportDataModel>;
let mockApiWrapper: TypeMoq.IMock<ApiWrapper>;
let mockFlatFileProvider: TypeMoq.IMock<FlatFileProvider>;
let summaryPage: SummaryPage;
@@ -28,16 +26,13 @@ describe('import extension summary page tests', function () {
let pages: Map<number, ImportPage> = new Map<number, ImportPage>();
beforeEach(async function () {
// Keeping the original behaviour of apiWrapper until some setup is needed to mock stuff
mockApiWrapper = TypeMoq.Mock.ofType(ApiWrapper, TypeMoq.MockBehavior.Loose);
mockApiWrapper.callBase = true;
mockFlatFileProvider = TypeMoq.Mock.ofType(TestFlatFileProvider);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, mockFlatFileProvider.object, mockApiWrapper.object);
mockFlatFileWizard = TypeMoq.Mock.ofType(FlatFileWizard, TypeMoq.MockBehavior.Loose, undefined, mockFlatFileProvider.object);
mockImportModel = TypeMoq.Mock.ofType(TestImportDataModel, TypeMoq.MockBehavior.Loose);
wizard = mockApiWrapper.object.createWizard(constants.wizardNameText);
page = mockApiWrapper.object.createWizardPage(constants.page4NameText);
wizard = azdata.window.createWizard(constants.wizardNameText);
page = azdata.window.createWizardPage(constants.page4NameText);
});
@@ -45,7 +40,7 @@ describe('import extension summary page tests', function () {
await new Promise(function (resolve) {
page.registerContent(async (view) => {
summaryPage = new SummaryPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny(), mockApiWrapper.object);
summaryPage = new SummaryPage(mockFlatFileWizard.object, page, mockImportModel.object, view, TypeMoq.It.isAny());
pages.set(1, summaryPage);
await summaryPage.start();
resolve();
@@ -112,7 +107,7 @@ describe('import extension summary page tests', function () {
await new Promise(function (resolve) {
page.registerContent(async (view) => {
summaryPage = new SummaryPage(mockFlatFileWizard.object, page, mockImportModel.object, view, mockFlatFileProvider.object, mockApiWrapper.object);
summaryPage = new SummaryPage(mockFlatFileWizard.object, page, mockImportModel.object, view, mockFlatFileProvider.object);
pages.set(1, summaryPage);
await summaryPage.start();
summaryPage.setupNavigationValidator();