Data workspace projects changes (#13466)

* Fix project context menu actions (#12541)

* delete works again

* make fewer changes

* update all sql db project commands

* cleanup

* Remove old projects view (#12563)

* remove old projects view from file explorer view

* fix tests failing

* remove projects in open folder opening up in old view

* Update db reference dialog to show projects in the workspace (#12580)

* update database reference dialog to show projects in the workspace in the project dropdown

* remove workspace stuff from sql projects extension

* undo change

* add class that implements IExtension

* undo a change

* update DataWorkspaceExtension to take workspaceService as a parameter

* add type

* Update sql database project commands (#12595)

* remove sql proj's open and create new project from comman palette

* hook up create project from database to data workspace

* rename the remaining import databases to create project from database

* remove open, new, and close commands

* expose addProjectsToWorkspace() in IExtension instead of calling command

* Addressing comments

* fix failing sql project tests (#12651)

* update SSDT projects opened in projects viewlet (#12669)

* fix action not refreshing the tree issue (#12692)

* fix adding project references in new projects viewlet (#12688)

* Remove old projects tree provider (#12702)

* Remove old projects tree provider and fix tests

* formatting

* update refreshProjectsTree() to accept workspaceTreeItem()

* Cleanup ProjectsController (#12718)

* remove openProject from ProjectController and some cleanup

* rename

* add project and open project dialogs (#12729)

* empty dialogs

* wip

* new project dialog implementation

* revert gitattributes

* open project dialog

* implement add project

* remove icon helper

* refactor

* revert script change

* adjust views

* more updates

* make data-workspace a builtin extension

* show the view only when project provider is detected (#12819)

* only show the view when proj provider is available

* update

* fix sql project tests after merge (#12793)

* Update dialogs to be closer to mockups (#12879)

* small UI changes to dialogs

* center radio card group text

* Create workspace if needed when opening/new project (#12930)

* empty dialogs

* wip

* new project dialog implementation

* revert gitattributes

* open project dialog

* implement add project

* remove icon helper

* refactor

* revert script change

* create workspace

* initial changes

* create new workspace working

* fix tests

* cleanup

* remove showWorkspaceRequiredNotification()

* Add test for no workspace open

* update blue buttons

* move loading temp project to activate() instead of workspaceService constructor

* move workspace creation warning message to before project is created

* pass uri to createWorkspace

* add tests

Co-authored-by: Alan Ren <alanren@microsoft.com>

* Additional create workspace changes (#13004)

* Dialogs workspace updates (#13010)

* adding workspace text boxes

* match new project dialog to mockups

* Add validation error message for workspace file

* add enterWorkspace api

* add warning message for opening workspace

* cleanup

* update commands to remove project so they're more generic

* remove 'empty' from string

* Move default project location setting to data workspace extension (#13022)

* remove project location setting and notification from sql database projects extension

* add default project location setting to data workspace extension

* fix typo

* Add back project name incrementing

* other merge fixes

* fix strings from other PR

* default to last opened directory instead of home directory if no specified default location

* A few small updates (#13092)

* fix build error

* update title for inputboxes

* add missing file

* Add tests for data workspace dialogs (#13324)

* add tests for dialogs

* create helper functions

* New project dialog workspace inputbox fixes (#13407)

* workspace inputbox fixes

* fix folder icons

* Update package.jsons and readme (#13451)

* update package.jsons

* update readme

* add workspace information to open existing dialog (#13455)

Co-authored-by: Alan Ren <alanren@microsoft.com>
This commit is contained in:
Kim Santiago
2020-11-18 16:13:43 -08:00
committed by GitHub
parent 34170e7741
commit ddc8c00090
63 changed files with 1835 additions and 931 deletions

View File

@@ -10,6 +10,7 @@ import * as azdata from 'azdata';
import * as vscode from 'vscode';
import * as TypeMoq from 'typemoq';
import * as sinon from 'sinon';
import * as dataworkspace from 'dataworkspace';
import * as baselines from './baselines/baselines';
import * as templates from '../templates/templates';
import * as testUtils from './testUtils';
@@ -65,7 +66,7 @@ describe('ProjectsController', function (): void {
describe('project controller operations', function (): void {
describe('Project file operations and prompting', function (): void {
it('Should create new sqlproj file with correct values', async function (): Promise<void> {
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const projFileDir = path.join(os.tmpdir(), `TestProject_${new Date().getTime()}`);
const projFilePath = await projController.createNewProject('TestProjectName', vscode.Uri.file(projFileDir), false, 'BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575');
@@ -75,54 +76,11 @@ describe('ProjectsController', function (): void {
should(projFileText).equal(baselines.newProjectFileBaseline);
});
it('Should load Project and associated DataSources', async function (): Promise<void> {
// setup test files
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline, folderPath);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
should(project.files.length).equal(10); // detailed sqlproj tests in their own test file
should(project.dataSources.length).equal(3); // detailed datasources tests in their own test file
});
it('Should load both project and referenced project', async function (): Promise<void> {
// setup test projects
const folderPath = await testUtils.generateTestFolderPath();
await fs.mkdir(path.join(folderPath, 'proj1'));
await fs.mkdir(path.join(folderPath, 'ReferencedProject'));
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.openProjectWithProjectReferencesBaseline, path.join(folderPath, 'proj1'));
await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline, path.join(folderPath, 'ReferencedProject'));
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.openProject(vscode.Uri.file(sqlProjPath));
should(projController.projects.length).equal(2, 'Referenced project should have been opened when the project referencing it was opened');
});
it('Should not keep failed to load project in project list.', async function (): Promise<void> {
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile('empty file with no valid xml', folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
try {
await projController.openProject(vscode.Uri.file(sqlProjPath));
should.fail(null, null, 'The given project not expected to open');
}
catch {
should(projController.projects.length).equal(0, 'The added project should be removed');
}
});
it('Should return silently when no SQL object name provided in prompts', async function (): Promise<void> {
for (const name of ['', ' ', undefined]) {
const showInputBoxStub = sinon.stub(vscode.window, 'showInputBox').resolves(name);
const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project = new Project('FakePath');
should(project.files.length).equal(0);
@@ -138,7 +96,7 @@ describe('ProjectsController', function (): void {
const tableName = 'table1';
sinon.stub(vscode.window, 'showInputBox').resolves(tableName);
const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline);
should(project.files.length).equal(0, 'There should be no files');
@@ -154,14 +112,13 @@ describe('ProjectsController', function (): void {
const folderName = 'folder1';
const stub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline);
const projectRoot = new ProjectRootTreeItem(project);
should(project.files.length).equal(0, 'There should be no other folders');
await projController.addFolderPrompt(projectRoot);
await projController.addFolderPrompt(createWorkspaceTreeItem(projectRoot));
should(project.files.length).equal(1, 'Folder should be successfully added');
projController.refreshProjectsTree();
stub.restore();
await verifyFolderNotAdded(folderName, projController, project, projectRoot);
@@ -175,7 +132,7 @@ describe('ProjectsController', function (): void {
const folderName = 'folder1';
const stub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project = await testUtils.createTestProject(baselines.openProjectFileBaseline);
const projectRoot = new ProjectRootTreeItem(project);
@@ -190,7 +147,7 @@ describe('ProjectsController', function (): void {
async function verifyFolderAdded(folderName: string, projController: ProjectsController, project: Project, node: BaseProjectTreeItem): Promise<void> {
const beforeFileCount = project.files.length;
const stub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
await projController.addFolderPrompt(node);
await projController.addFolderPrompt(createWorkspaceTreeItem(node));
should(project.files.length).equal(beforeFileCount + 1, `File count should be increased by one after adding the folder ${folderName}`);
stub.restore();
}
@@ -199,7 +156,7 @@ describe('ProjectsController', function (): void {
const beforeFileCount = project.files.length;
const showInputBoxStub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
await projController.addFolderPrompt(node);
await projController.addFolderPrompt(createWorkspaceTreeItem(node));
should(showErrorMessageSpy.calledOnce).be.true('showErrorMessage should have been called exactly once');
const msg = constants.folderAlreadyExists(folderName);
should(showErrorMessageSpy.calledWith(msg)).be.true(`showErrorMessage not called with expected message '${msg}' Actual '${showErrorMessageSpy.getCall(0).args[0]}'`);
@@ -213,13 +170,13 @@ describe('ProjectsController', function (): void {
const setupResult = await setupDeleteExcludeTest(proj);
const scriptEntry = setupResult[0], projTreeRoot = setupResult[1], preDeployEntry = setupResult[2], postDeployEntry = setupResult[3], noneEntry = setupResult[4];
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
await projController.delete(projTreeRoot.children.find(x => x.friendlyName === 'UpperFolder')!.children[0] /* LowerFolder */);
await projController.delete(projTreeRoot.children.find(x => x.friendlyName === 'anotherScript.sql')!);
await projController.delete(projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment1.sql')!);
await projController.delete(projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment2.sql')!);
await projController.delete(projTreeRoot.children.find(x => x.friendlyName === 'Script.PostDeployment1.sql')!);
await projController.delete(createWorkspaceTreeItem(projTreeRoot.children.find(x => x.friendlyName === 'UpperFolder')!.children[0]) /* LowerFolder */);
await projController.delete(createWorkspaceTreeItem(projTreeRoot.children.find(x => x.friendlyName === 'anotherScript.sql')!));
await projController.delete(createWorkspaceTreeItem(projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment1.sql')!));
await projController.delete(createWorkspaceTreeItem(projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment2.sql')!));
await projController.delete(createWorkspaceTreeItem(projTreeRoot.children.find(x => x.friendlyName === 'Script.PostDeployment1.sql')!));
proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk
@@ -239,7 +196,7 @@ describe('ProjectsController', function (): void {
it('Should delete database references', async function (): Promise<void> {
// setup - openProject baseline has a system db reference to master
const proj = await testUtils.createTestProject(baselines.openProjectFileBaseline);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString));
// add dacpac reference
@@ -261,9 +218,9 @@ describe('ProjectsController', function (): void {
should(proj.databaseReferences.length).equal(3, 'Should start with 3 database references');
const databaseReferenceNodeChildren = projTreeRoot.children.find(x => x.friendlyName === constants.databaseReferencesNodeName)?.children;
await projController.delete(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'master')!); // system db reference
await projController.delete(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'test2')!); // dacpac reference
await projController.delete(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'project1')!); // project reference
await projController.delete(createWorkspaceTreeItem(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'master')!)); // system db reference
await projController.delete(createWorkspaceTreeItem(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'test2')!)); // dacpac reference
await projController.delete(createWorkspaceTreeItem(databaseReferenceNodeChildren?.find(x => x.friendlyName === 'project1')!)); // project reference
// confirm result
should(proj.databaseReferences.length).equal(0, 'All database references should have been deleted');
@@ -274,13 +231,13 @@ describe('ProjectsController', function (): void {
const setupResult = await setupDeleteExcludeTest(proj);
const scriptEntry = setupResult[0], projTreeRoot = setupResult[1], preDeployEntry = setupResult[2], postDeployEntry = setupResult[3], noneEntry = setupResult[4];
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
await projController.exclude(<FolderNode>projTreeRoot.children.find(x => x.friendlyName === 'UpperFolder')!.children[0] /* LowerFolder */);
await projController.exclude(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'anotherScript.sql')!);
await projController.exclude(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment1.sql')!);
await projController.exclude(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment2.sql')!);
await projController.exclude(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PostDeployment1.sql')!);
await projController.exclude(createWorkspaceTreeItem(<FolderNode>projTreeRoot.children.find(x => x.friendlyName === 'UpperFolder')!.children[0]) /* LowerFolder */);
await projController.exclude(createWorkspaceTreeItem(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'anotherScript.sql')!));
await projController.exclude(createWorkspaceTreeItem(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment1.sql')!));
await projController.exclude(createWorkspaceTreeItem(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PreDeployment2.sql')!));
await projController.exclude(createWorkspaceTreeItem(<FileNode>projTreeRoot.children.find(x => x.friendlyName === 'Script.PostDeployment1.sql')!));
proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk
@@ -302,18 +259,22 @@ describe('ProjectsController', function (): void {
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline, folderPath);
const treeProvider = new SqlDatabaseProjectTreeViewProvider();
const projController = new ProjectsController(treeProvider);
const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
const projController = new ProjectsController();
const project = await Project.openProject(vscode.Uri.file(sqlProjPath).fsPath);
treeProvider.load([project]);
// change the sql project file
await fs.writeFile(sqlProjPath, baselines.newProjectFileWithScriptBaseline);
should(project.files.length).equal(0);
// call reload project
await projController.reloadProject(vscode.Uri.file(project.projectFilePath));
should(project.files.length).equal(1);
await projController.reloadProject({ treeDataProvider: treeProvider, element: { root: { project: project } } });
// calling this because this gets called in the projectProvider.getProjectTreeDataProvider(), which is called by workspaceTreeDataProvider
// when notifyTreeDataChanged() happens
treeProvider.load([project]);
// check that the new project is in the tree
should(project.files.length).equal(1);
should(treeProvider.getChildren()[0].children.find(c => c.friendlyName === 'Script1.sql')).not.equal(undefined);
});
@@ -321,7 +282,7 @@ describe('ProjectsController', function (): void {
const preDeployScriptName = 'PreDeployScript1.sql';
const postDeployScriptName = 'PostDeployScript1.sql';
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline);
sinon.stub(vscode.window, 'showInputBox').resolves(preDeployScriptName);
@@ -339,9 +300,9 @@ describe('ProjectsController', function (): void {
it('Should change target platform', async function (): Promise<void> {
sinon.stub(vscode.window, 'showQuickPick').resolves({ label: constants.sqlAzure });
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline);
const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
const project = await Project.openProject(sqlProjPath);
should(project.getProjectTargetVersion()).equal(constants.targetPlatformToVersion.get(constants.sqlServer2019));
should(project.databaseReferences.length).equal(1, 'Project should have one database reference to master');
should(project.databaseReferences[0].fsUri.fsPath).containEql(constants.targetPlatformToVersion.get(constants.sqlServer2019));
@@ -387,12 +348,12 @@ describe('ProjectsController', function (): void {
let projController = TypeMoq.Mock.ofType(ProjectsController);
projController.callBase = true;
projController.setup(x => x.getPublishDialog(TypeMoq.It.isAny())).returns(() => publishDialog.object);
projController.setup(x => x.executionCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IPublishSettings => true))).returns(() => {
projController.setup(x => x.publishProjectCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IPublishSettings => true))).returns(() => {
holler = publishHoller;
return Promise.resolve(undefined);
});
projController.setup(x => x.executionCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IGenerateScriptSettings => true))).returns(() => {
projController.setup(x => x.publishProjectCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IGenerateScriptSettings => true))).returns(() => {
holler = generateHoller;
return Promise.resolve(undefined);
});
@@ -430,7 +391,7 @@ describe('ProjectsController', function (): void {
projController.setup(x => x.getDaxFxService()).returns(() => Promise.resolve(testContext.dacFxService.object));
await projController.object.executionCallback(new Project(''), { connectionUri: '', databaseName: '' });
await projController.object.publishProjectCallback(new Project(''), { connectionUri: '', databaseName: '' });
should(builtDacpacPath).not.equal('', 'built dacpac path should be set');
should(publishedDacpacPath).not.equal('', 'published dacpac path should be set');
@@ -440,11 +401,15 @@ describe('ProjectsController', function (): void {
});
});
describe('import operations', function (): void {
describe('Create project from database', function (): void {
afterEach(() => {
sinon.restore();
});
it('Should create list of all files and folders correctly', async function (): Promise<void> {
const testFolderPath = await testUtils.createDummyFileStructure();
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const fileList = await projController.generateList(testFolderPath);
should(fileList.length).equal(15); // Parent folder + 2 files under parent folder + 2 directories with 5 files each
@@ -456,7 +421,7 @@ describe('ProjectsController', function (): void {
let testFolderPath = await testUtils.generateTestFolderPath();
testFolderPath += '_nonexistentFolder'; // Modify folder path to point to a nonexistent location
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
await projController.generateList(testFolderPath);
should(spy.calledOnce).be.true('showErrorMessage should have been called');
@@ -466,11 +431,16 @@ describe('ProjectsController', function (): void {
it('Should show error when no project name provided', async function (): Promise<void> {
for (const name of ['', ' ', undefined]) {
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => []);
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file('/test/folder'));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object});
sinon.stub(vscode.workspace, 'workspaceFile').value(vscode.Uri.file('/test/folder/ws.code-workspace'));
sinon.stub(vscode.window, 'showInputBox').resolves(name);
const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
const projController = new ProjectsController();
await projController.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(spy.calledOnce).be.true('showErrorMessage should have been called');
should(spy.calledWith(constants.projectNameRequired)).be.true(`showErrorMessage not called with expected message '${constants.projectNameRequired}' Actual '${spy.getCall(0).args[0]}'`);
sinon.restore();
@@ -478,37 +448,52 @@ describe('ProjectsController', function (): void {
});
it('Should show error when no target information provided', async function (): Promise<void> {
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => []);
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file('/test/folder'));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object});
sinon.stub(vscode.workspace, 'workspaceFile').value(vscode.Uri.file('/test/folder/ws.code-workspace'));
sinon.stub(vscode.window, 'showInputBox').resolves('MyProjectName');
sinon.stub(vscode.window, 'showQuickPick').resolves(undefined);
sinon.stub(vscode.window, 'showOpenDialog').resolves([vscode.Uri.file('fakePath')]);
const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
const projController = new ProjectsController();
await projController.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(spy.calledOnce).be.true('showErrorMessage should have been called');
should(spy.calledWith(constants.extractTargetRequired)).be.true(`showErrorMessage not called with expected message '${constants.extractTargetRequired}' Actual '${spy.getCall(0).args[0]}'`);
});
it('Should show error when no location provided with ExtractTarget = File', async function (): Promise<void> {
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => []);
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file('/test/folder'));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object});
sinon.stub(vscode.workspace, 'workspaceFile').value(vscode.Uri.file('/test/folder/ws.code-workspace'));
sinon.stub(vscode.window, 'showInputBox').resolves('MyProjectName');
sinon.stub(vscode.window, 'showOpenDialog').resolves(undefined);
sinon.stub(vscode.window, 'showQuickPick').resolves({ label: constants.file });
const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
const projController = new ProjectsController();
await projController.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(spy.calledOnce).be.true('showErrorMessage should have been called');
should(spy.calledWith(constants.projectLocationRequired)).be.true(`showErrorMessage not called with expected message '${constants.projectLocationRequired}' Actual '${spy.getCall(0).args[0]}'`);
});
it('Should show error when no location provided with ExtractTarget = SchemaObjectType', async function (): Promise<void> {
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => []);
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file('/test/folder'));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object});
sinon.stub(vscode.workspace, 'workspaceFile').value(vscode.Uri.file('/test/folder/ws.code-workspace'));
sinon.stub(vscode.window, 'showInputBox').resolves('MyProjectName');
sinon.stub(vscode.window, 'showQuickPick').resolves({ label: constants.schemaObjectType });
sinon.stub(vscode.window, 'showOpenDialog').resolves(undefined);
const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
const projController = new ProjectsController();
await projController.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(spy.calledOnce).be.true('showErrorMessage should have been called');
should(spy.calledWith(constants.projectLocationRequired)).be.true(`showErrorMessage not called with expected message '${constants.projectLocationRequired}' Actual '${spy.getCall(0).args[0]}'`);
});
@@ -517,6 +502,11 @@ describe('ProjectsController', function (): void {
const projectName = 'MyProjectName';
let folderPath = await testUtils.generateTestFolderPath();
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file('/test/folder'));
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => []);
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object});
sinon.stub(vscode.workspace, 'workspaceFile').value(vscode.Uri.file('/test/folder/ws.code-workspace'));
sinon.stub(vscode.window, 'showInputBox').resolves(projectName);
const showQuickPickStub = sinon.stub(vscode.window, 'showQuickPick').resolves({ label: constants.file });
sinon.stub(vscode.window, 'showOpenDialog').callsFake(() => Promise.resolve([vscode.Uri.file(folderPath)]));
@@ -526,9 +516,9 @@ describe('ProjectsController', function (): void {
let projController = TypeMoq.Mock.ofType(ProjectsController, undefined, undefined, new SqlDatabaseProjectTreeViewProvider());
projController.callBase = true;
projController.setup(x => x.importApiCall(TypeMoq.It.isAny())).returns(async (model) => { importPath = model.filePath; });
projController.setup(x => x.createProjectFromDatabaseApiCall(TypeMoq.It.isAny())).returns(async (model) => { importPath = model.filePath; });
await projController.object.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
await projController.object.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(importPath).equal(vscode.Uri.file(path.join(folderPath, projectName, projectName + '.sql')).fsPath, `model.filePath should be set to a specific file for ExtractTarget === file, but was ${importPath}`);
// reset for counter-test
@@ -536,7 +526,7 @@ describe('ProjectsController', function (): void {
folderPath = await testUtils.generateTestFolderPath();
showQuickPickStub.resolves({ label: constants.schemaObjectType });
await projController.object.importNewDatabaseProject({ connectionProfile: mockConnectionProfile });
await projController.object.createProjectFromDatabase({ connectionProfile: mockConnectionProfile });
should(importPath).equal(vscode.Uri.file(path.join(folderPath, projectName)).fsPath, `model.filePath should be set to a folder for ExtractTarget !== file, but was ${importPath}`);
});
@@ -552,7 +542,7 @@ describe('ProjectsController', function (): void {
options: {}
});
let projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
let projController = new ProjectsController();
let result = await projController.getModelFromContext(undefined);
@@ -590,14 +580,16 @@ describe('ProjectsController', function (): void {
const addDbReferenceDialog = TypeMoq.Mock.ofType(AddDatabaseReferenceDialog, undefined, undefined, proj);
addDbReferenceDialog.callBase = true;
addDbReferenceDialog.setup(x => x.addReferenceClick()).returns(() => {
projController.object.addDatabaseReferenceCallback(proj, { systemDb: SystemDatabase.master, databaseName: 'master', suppressMissingDependenciesErrors: false });
projController.object.addDatabaseReferenceCallback(proj,
{ systemDb: SystemDatabase.master, databaseName: 'master', suppressMissingDependenciesErrors: false },
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
return Promise.resolve(undefined);
});
const projController = TypeMoq.Mock.ofType(ProjectsController);
projController.callBase = true;
projController.setup(x => x.getAddDatabaseReferenceDialog(TypeMoq.It.isAny())).returns(() => addDbReferenceDialog.object);
projController.setup(x => x.addDatabaseReferenceCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IDacpacReferenceSettings => true))).returns(() => {
projController.setup(x => x.addDatabaseReferenceCallback(TypeMoq.It.isAny(), TypeMoq.It.is((_): _ is IDacpacReferenceSettings => true), TypeMoq.It.isAny())).returns(() => {
holler = addDbRefHoller;
return Promise.resolve(undefined);
});
@@ -609,14 +601,16 @@ describe('ProjectsController', function (): void {
});
it('Should not allow adding circular project references', async function (): Promise<void> {
const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
const projPath1 = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline);
const projPath2 = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const projController = new ProjectsController();
const project1 = await projController.openProject(vscode.Uri.file(projPath1));
const project2 = await projController.openProject(vscode.Uri.file(projPath2));
const project1 = await Project.openProject(vscode.Uri.file(projPath1).fsPath);
const project2 = await Project.openProject(vscode.Uri.file(projPath2).fsPath);
const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace()).returns(() => [vscode.Uri.file(project1.projectFilePath), vscode.Uri.file(project2.projectFilePath)]);
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object });
// add project reference from project1 to project2
await projController.addDatabaseReferenceCallback(project1, {
@@ -624,7 +618,8 @@ describe('ProjectsController', function (): void {
projectName: 'TestProject',
projectRelativePath: undefined,
suppressMissingDependenciesErrors: false
});
},
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called');
// try to add circular reference
@@ -633,75 +628,14 @@ describe('ProjectsController', function (): void {
projectName: 'TestProjectName',
projectRelativePath: undefined,
suppressMissingDependenciesErrors: false
});
},
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
should(showErrorMessageSpy.called).be.true('showErrorMessage should have been called');
});
});
});
describe.skip('ProjectsController: round trip feature with SSDT', function (): void {
it('Should show warning message for SSDT project opened in Azure Data Studio', async function (): Promise<void> {
const stub = sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.noString));
// setup test files
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.SSDTProjectFileBaseline, folderPath);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
await projController.openProject(vscode.Uri.file(sqlProjPath));
should(stub.calledOnce).be.true('showWarningMessage should have been called exactly once');
should(stub.calledWith(constants.updateProjectForRoundTrip)).be.true(`showWarningMessage not called with expected message '${constants.updateProjectForRoundTrip}' Actual '${stub.getCall(0).args[0]}'`);
});
it('Should not show warning message for non-SSDT projects that have the additional information for Build', async function (): Promise<void> {
// setup test files
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline, folderPath);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const project = await projController.openProject(vscode.Uri.file(sqlProjPath)); // no error thrown
should(project.importedTargets.length).equal(3); // additional target should exist by default
});
it('Should not update project and no backup file should be created when update to project is rejected', async function (): Promise<void> {
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.noString));
// setup test files
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.SSDTProjectFileBaseline, folderPath);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
should(await exists(sqlProjPath + '_backup')).equal(false); // backup file should not be generated
should(project.importedTargets.length).equal(2); // additional target should not be added by updateProjectForRoundTrip method
});
it('Should load Project and associated import targets when update to project is accepted', async function (): Promise<void> {
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString));
// setup test files
const folderPath = await testUtils.generateTestFolderPath();
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.SSDTProjectFileBaseline, folderPath);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
should(await exists(sqlProjPath + '_backup')).equal(true); // backup file should be generated before the project is updated
should(project.importedTargets.length).equal(3); // additional target added by updateProjectForRoundTrip method
});
});
async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry, ProjectRootTreeItem, FileProjectEntry, FileProjectEntry, FileProjectEntry]> {
await proj.addFolderItem('UpperFolder');
await proj.addFolderItem('UpperFolder/LowerFolder');
@@ -725,3 +659,10 @@ async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry,
return [scriptEntry, projTreeRoot, preDeployEntry, postDeployEntry, noneEntry];
}
function createWorkspaceTreeItem(node: BaseProjectTreeItem): dataworkspace.WorkspaceTreeItem {
return {
element: node,
treeDataProvider: new SqlDatabaseProjectTreeViewProvider()
};
}