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

Swapping Record usage to Map in SQL Projects (#22758)

Browse Source 
* Changing SqlCmdVars from Record to Map

* Converting the rest

* Updating tests

* more cleanup

* Updating test to use new test creation API
This commit is contained in:
Benjin Dubishar
2023-04-17 12:56:39 -07:00
committed by GitHub
parent 4a4580e9ef
commit 02e61d1598
21 changed files with 132 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
extensions/dacpac/src/test/testDacFxService.ts
View File

@@ -39,11 +39,11 @@ export class DacFxTestService implements mssql.IDacFxService {
this.dacfxResult.operationId = importOperationId; this.dacfxResult.operationId = importOperationId;
return Promise.resolve(this.dacfxResult); return Promise.resolve(this.dacfxResult);
} }
deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>): Promise<mssql.DacFxResult> { deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>): Promise<mssql.DacFxResult> {
this.dacfxResult.operationId = deployOperationId; this.dacfxResult.operationId = deployOperationId;
return Promise.resolve(this.dacfxResult); return Promise.resolve(this.dacfxResult);
} }
generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>): Promise<mssql.DacFxResult> { generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>): Promise<mssql.DacFxResult> {
this.dacfxResult.operationId = generateScript; this.dacfxResult.operationId = generateScript;
return Promise.resolve(this.dacfxResult); return Promise.resolve(this.dacfxResult);
} }
@@ -90,7 +90,7 @@ export class DacFxTestService implements mssql.IDacFxService {
return Promise.resolve({ containsCreateTableStatement: true }); return Promise.resolve({ containsCreateTableStatement: true });
} }
savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>): Thenable<azdata.ResultStatus> { savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>): Thenable<azdata.ResultStatus> {
return Promise.resolve(this.dacfxResult); return Promise.resolve(this.dacfxResult);
} }
} }

6
extensions/mssql/src/contracts.ts
View File

@@ -515,7 +515,7 @@ export interface DeployParams {
packageFilePath: string; packageFilePath: string;
databaseName: string; databaseName: string;
upgradeExisting: boolean; upgradeExisting: boolean;
sqlCommandVariableValues?: Record<string, string>; sqlCommandVariableValues?: Map<string, string>;
deploymentOptions?: mssql.DeploymentOptions; deploymentOptions?: mssql.DeploymentOptions;
ownerUri: string; ownerUri: string;
taskExecutionMode: TaskExecutionMode; taskExecutionMode: TaskExecutionMode;
@@ -524,7 +524,7 @@ export interface DeployParams {
export interface GenerateDeployScriptParams { export interface GenerateDeployScriptParams {
packageFilePath: string; packageFilePath: string;
databaseName: string; databaseName: string;
sqlCommandVariableValues?: Record<string, string>; sqlCommandVariableValues?: Map<string, string>;
deploymentOptions?: mssql.DeploymentOptions deploymentOptions?: mssql.DeploymentOptions
ownerUri: string; ownerUri: string;
taskExecutionMode: TaskExecutionMode; taskExecutionMode: TaskExecutionMode;
@@ -555,7 +555,7 @@ export interface SavePublishProfileParams {
profilePath: string; profilePath: string;
databaseName: string; databaseName: string;
connectionString: string; connectionString: string;
sqlCommandVariableValues?: Record<string, string>; sqlCommandVariableValues?: Map<string, string>;
deploymentOptions?: mssql.DeploymentOptions; deploymentOptions?: mssql.DeploymentOptions;
} }

6
extensions/mssql/src/dacfx/dacFxService.ts
View File

@@ -54,12 +54,12 @@ export class DacFxService extends BaseService implements mssql.IDacFxService {
return this.runWithErrorHandling(contracts.ExtractRequest.type, params); return this.runWithErrorHandling(contracts.ExtractRequest.type, params);
} }
public async deployDacpac(packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> { public async deployDacpac(packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
const params: contracts.DeployParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, upgradeExisting: upgradeExisting, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode }; const params: contracts.DeployParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, upgradeExisting: upgradeExisting, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
return this.runWithErrorHandling(contracts.DeployRequest.type, params); return this.runWithErrorHandling(contracts.DeployRequest.type, params);
} }
public async generateDeployScript(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> { public async generateDeployScript(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
const params: contracts.GenerateDeployScriptParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode }; const params: contracts.GenerateDeployScriptParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
return this.runWithErrorHandling(contracts.GenerateDeployScriptRequest.type, params); return this.runWithErrorHandling(contracts.GenerateDeployScriptRequest.type, params);
} }
@@ -84,7 +84,7 @@ export class DacFxService extends BaseService implements mssql.IDacFxService {
return this.runWithErrorHandling(contracts.ParseTSqlScriptRequest.type, params); return this.runWithErrorHandling(contracts.ParseTSqlScriptRequest.type, params);
} }
public async savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<azdata.ResultStatus> { public async savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<azdata.ResultStatus> {
const params: contracts.SavePublishProfileParams = { profilePath, databaseName, connectionString, sqlCommandVariableValues, deploymentOptions }; const params: contracts.SavePublishProfileParams = { profilePath, databaseName, connectionString, sqlCommandVariableValues, deploymentOptions };
return this.runWithErrorHandling(contracts.SavePublishProfileRequest.type, params); return this.runWithErrorHandling(contracts.SavePublishProfileRequest.type, params);
} }

6
extensions/mssql/src/mssql.d.ts vendored
View File

@@ -236,13 +236,13 @@ declare module 'mssql' {
importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<DacFxResult>; importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<DacFxResult>;
extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<DacFxResult>; extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<DacFxResult>;
createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode, includePermissions?: boolean): Thenable<DacFxResult>; createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode, includePermissions?: boolean): Thenable<DacFxResult>;
deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>; deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>;
generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>; generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>;
generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<GenerateDeployPlanResult>; generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<GenerateDeployPlanResult>;
getOptionsFromProfile(profilePath: string): Thenable<DacFxOptionsResult>; getOptionsFromProfile(profilePath: string): Thenable<DacFxOptionsResult>;
validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Thenable<ValidateStreamingJobResult>; validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Thenable<ValidateStreamingJobResult>;
parseTSqlScript(filePath: string, databaseSchemaProvider: string): Thenable<ParseTSqlScriptResult>; parseTSqlScript(filePath: string, databaseSchemaProvider: string): Thenable<ParseTSqlScriptResult>;
savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<azdata.ResultStatus>; savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<azdata.ResultStatus>;
} }
export interface DacFxResult extends azdata.ResultStatus { export interface DacFxResult extends azdata.ResultStatus {

8
extensions/sql-database-projects/src/common/utils.ts
View File

@@ -170,8 +170,8 @@ export function systemDatabaseToString(systemDb: mssql.SystemDatabase): string {
* @param xmlDoc xml doc to read SQLCMD variables from. Format must be the same that sqlproj and publish profiles use * @param xmlDoc xml doc to read SQLCMD variables from. Format must be the same that sqlproj and publish profiles use
* @param publishProfile true if reading from publish profile * @param publishProfile true if reading from publish profile
*/ */
export function readSqlCmdVariables(xmlDoc: Document, publishProfile: boolean): Record<string, string> { export function readSqlCmdVariables(xmlDoc: Document, publishProfile: boolean): Map<string, string> {
let sqlCmdVariables: Record<string, string> = {}; let sqlCmdVariables: Map<string, string> = new Map();
for (let i = 0; i < xmlDoc.documentElement.getElementsByTagName(constants.SqlCmdVariable)?.length; i++) { for (let i = 0; i < xmlDoc.documentElement.getElementsByTagName(constants.SqlCmdVariable)?.length; i++) {
const sqlCmdVar = xmlDoc.documentElement.getElementsByTagName(constants.SqlCmdVariable)[i]; const sqlCmdVar = xmlDoc.documentElement.getElementsByTagName(constants.SqlCmdVariable)[i];
const varName = sqlCmdVar.getAttribute(constants.Include)!; const varName = sqlCmdVar.getAttribute(constants.Include)!;
@@ -181,11 +181,11 @@ export function readSqlCmdVariables(xmlDoc: Document, publishProfile: boolean):
// are local variable values you can set in VS in the properties. Since we don't support that in ADS, only DefaultValue is supported for sqlproj. // are local variable values you can set in VS in the properties. Since we don't support that in ADS, only DefaultValue is supported for sqlproj.
if (!publishProfile && sqlCmdVar.getElementsByTagName(constants.DefaultValue)[0] !== undefined) { if (!publishProfile && sqlCmdVar.getElementsByTagName(constants.DefaultValue)[0] !== undefined) {
// project file path // project file path
sqlCmdVariables[varName] = sqlCmdVar.getElementsByTagName(constants.DefaultValue)[0].childNodes[0].nodeValue!; sqlCmdVariables.set(varName, sqlCmdVar.getElementsByTagName(constants.DefaultValue)[0].childNodes[0].nodeValue!);
} }
else { else {
// profile path // profile path
sqlCmdVariables[varName] = sqlCmdVar.getElementsByTagName(constants.Value)[0].childNodes[0].nodeValue!; sqlCmdVariables.set(varName, sqlCmdVar.getElementsByTagName(constants.Value)[0].childNodes[0].nodeValue!);
} }
} }

28
extensions/sql-database-projects/src/controllers/projectController.ts
View File

@@ -225,17 +225,17 @@ export class ProjectsController {
if (projectTypeId === constants.edgeSqlDatabaseProjectTypeId) { if (projectTypeId === constants.edgeSqlDatabaseProjectTypeId) {
const project = await Project.openProject(newProjFilePath); const project = await Project.openProject(newProjFilePath);
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.table), 'DataTable.sql', { 'OBJECT_NAME': 'DataTable' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.table), 'DataTable.sql', new Map([['OBJECT_NAME', 'DataTable']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'EdgeHubInputDataSource.sql', { 'OBJECT_NAME': 'EdgeHubInputDataSource', 'LOCATION': 'edgehub://' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'EdgeHubInputDataSource.sql', new Map([['OBJECT_NAME', 'EdgeHubInputDataSource'], ['LOCATION', 'edgehub://']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'SqlOutputDataSource.sql', { 'OBJECT_NAME': 'SqlOutputDataSource', 'LOCATION': 'sqlserver://tcp:.,1433' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'SqlOutputDataSource.sql', new Map([['OBJECT_NAME', 'SqlOutputDataSource'], ['LOCATION', 'sqlserver://tcp:.,1433']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.fileFormat), 'StreamFileFormat.sql', { 'OBJECT_NAME': 'StreamFileFormat' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.fileFormat), 'StreamFileFormat.sql', new Map([['OBJECT_NAME', 'StreamFileFormat']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStream), 'EdgeHubInputStream.sql', { 'OBJECT_NAME': 'EdgeHubInputStream', 'DATA_SOURCE_NAME': 'EdgeHubInputDataSource', 'LOCATION': 'input', 'OPTIONS': ',\n\tFILE_FORMAT = StreamFileFormat' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStream), 'EdgeHubInputStream.sql', new Map([['OBJECT_NAME', 'EdgeHubInputStream'], ['DATA_SOURCE_NAME', 'EdgeHubInputDataSource'], ['LOCATION', 'input'], ['OPTIONS', ',\n\tFILE_FORMAT = StreamFileFormat']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStream), 'SqlOutputStream.sql', { 'OBJECT_NAME': 'SqlOutputStream', 'DATA_SOURCE_NAME': 'SqlOutputDataSource', 'LOCATION': 'TSQLStreaming.dbo.DataTable', 'OPTIONS': '' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStream), 'SqlOutputStream.sql', new Map([['OBJECT_NAME', 'SqlOutputStream'], ['DATA_SOURCE_NAME', 'SqlOutputDataSource'], ['LOCATION', 'TSQLStreaming.dbo.DataTable'], ['OPTIONS', '']]));
await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStreamingJob), 'EdgeStreamingJob.sql', { 'OBJECT_NAME': 'EdgeStreamingJob' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStreamingJob), 'EdgeStreamingJob.sql', new Map([['OBJECT_NAME', 'EdgeStreamingJob']]));
} }
} }
private async addFileToProjectFromTemplate(project: ISqlProject, itemType: templates.ProjectScriptType, relativePath: string, expansionMacros: Record<string, string>): Promise<string> { private async addFileToProjectFromTemplate(project: ISqlProject, itemType: templates.ProjectScriptType, relativePath: string, expansionMacros: Map<string, string>): Promise<string> {
const newFileText = templates.macroExpansion(itemType.templateScript, expansionMacros); const newFileText = templates.macroExpansion(itemType.templateScript, expansionMacros);
const absolutePath = path.join(project.projectFolderPath, relativePath) const absolutePath = path.join(project.projectFolderPath, relativePath)
await utils.ensureFileExists(absolutePath, newFileText); await utils.ensureFileExists(absolutePath, newFileText);
@@ -587,7 +587,7 @@ export class ProjectsController {
const timeToPublish = actionEndTime - actionStartTime; const timeToPublish = actionEndTime - actionStartTime;
telemetryProps.actionDuration = timeToPublish.toString(); telemetryProps.actionDuration = timeToPublish.toString();
telemetryProps.totalDuration = (actionEndTime - buildStartTime).toString(); telemetryProps.totalDuration = (actionEndTime - buildStartTime).toString();
telemetryProps.sqlcmdVariablesCount = Object.keys(project.sqlCmdVariables).length.toString(); telemetryProps.sqlcmdVariablesCount = project.sqlCmdVariables.size.toString();
telemetryProps.projectTargetPLatform = project.getProjectTargetVersion(); telemetryProps.projectTargetPLatform = project.getProjectTargetVersion();
const currentPublishIndex = this.publishInfo.findIndex(d => d.startDate === currentPublishTimeInfo); const currentPublishIndex = this.publishInfo.findIndex(d => d.startDate === currentPublishTimeInfo);
@@ -750,7 +750,7 @@ export class ProjectsController {
} }
try { try {
const absolutePath = await this.addFileToProjectFromTemplate(project, itemType, relativeFilePath, { 'OBJECT_NAME': itemObjectName }); const absolutePath = await this.addFileToProjectFromTemplate(project, itemType, relativeFilePath, new Map([['OBJECT_NAME', itemObjectName]]));
TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addItemFromTree) TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addItemFromTree)
.withAdditionalProperties(telemetryProps) .withAdditionalProperties(telemetryProps)
@@ -957,7 +957,7 @@ export class ProjectsController {
const node = context.element as SqlCmdVariableTreeItem; const node = context.element as SqlCmdVariableTreeItem;
const project = await this.getProjectFromContext(node); const project = await this.getProjectFromContext(node);
const variableName = node.friendlyName; const variableName = node.friendlyName;
const originalValue = project.sqlCmdVariables[variableName]; const originalValue = project.sqlCmdVariables.get(variableName);
const newValue = await vscode.window.showInputBox( const newValue = await vscode.window.showInputBox(
{ {
@@ -986,7 +986,7 @@ export class ProjectsController {
title: constants.enterNewSqlCmdVariableName, title: constants.enterNewSqlCmdVariableName,
ignoreFocusOut: true, ignoreFocusOut: true,
validateInput: (value) => { validateInput: (value) => {
return this.sqlCmdVariableNameAlreadyExists(value, project) ? constants.sqlcmdVariableAlreadyExists : undefined; return project.sqlCmdVariables.has(value) ? constants.sqlcmdVariableAlreadyExists : undefined;
} }
}); });
@@ -1008,10 +1008,6 @@ export class ProjectsController {
this.refreshProjectsTree(context); this.refreshProjectsTree(context);
} }
private sqlCmdVariableNameAlreadyExists(newVariableName: string, project: Project): boolean {
return Object.keys(project.sqlCmdVariables).findIndex(v => v === newVariableName) !== -1;
}
private getDatabaseReference(project: Project, context: BaseProjectTreeItem): IDatabaseReferenceProjectEntry | undefined { private getDatabaseReference(project: Project, context: BaseProjectTreeItem): IDatabaseReferenceProjectEntry | undefined {
const databaseReference = context as DatabaseReferenceTreeItem; const databaseReference = context as DatabaseReferenceTreeItem;

34
extensions/sql-database-projects/src/dialogs/publishDatabaseDialog.ts
View File

@@ -53,7 +53,7 @@ export class PublishDatabaseDialog {
private existingServerSelected: boolean = true; private existingServerSelected: boolean = true;
private connectionId: string | undefined; private connectionId: string | undefined;
private connectionIsDataSource: boolean | undefined; private connectionIsDataSource: boolean | undefined;
private sqlCmdVars: Record<string, string> | undefined; private sqlCmdVars: Map<string, string> | undefined;
private deploymentOptions: DeploymentOptions | undefined; private deploymentOptions: DeploymentOptions | undefined;
private profileUsed: boolean = false; private profileUsed: boolean = false;
private serverName: string | undefined; private serverName: string | undefined;
@@ -70,7 +70,7 @@ export class PublishDatabaseDialog {
public publishToContainer: ((proj: Project, profile: IPublishToDockerSettings) => any) | undefined; public publishToContainer: ((proj: Project, profile: IPublishToDockerSettings) => any) | undefined;
public generateScript: ((proj: Project, profile: ISqlProjectPublishSettings) => any) | undefined; public generateScript: ((proj: Project, profile: ISqlProjectPublishSettings) => any) | undefined;
public readPublishProfile: ((profileUri: vscode.Uri) => any) | undefined; public readPublishProfile: ((profileUri: vscode.Uri) => any) | undefined;
public savePublishProfile: ((profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions) => any) | undefined; public savePublishProfile: ((profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions) => any) | undefined;
constructor(private project: Project) { constructor(private project: Project) {
this.dialog = utils.getAzdataApi()!.window.createModelViewDialog(constants.publishDialogName, 'sqlProjectPublishDialog'); this.dialog = utils.getAzdataApi()!.window.createModelViewDialog(constants.publishDialogName, 'sqlProjectPublishDialog');
@@ -190,7 +190,7 @@ export class PublishDatabaseDialog {
}); });
// add SQLCMD variables table if the project has any // add SQLCMD variables table if the project has any
if (Object.keys(this.project.sqlCmdVariables).length > 0) { if (this.project.sqlCmdVariables.size > 0) {
this.formBuilder.addFormItem(this.sqlCmdVariablesFormComponentGroup); this.formBuilder.addFormItem(this.sqlCmdVariablesFormComponentGroup);
} }
@@ -311,9 +311,9 @@ export class PublishDatabaseDialog {
return this.deploymentOptions; return this.deploymentOptions;
} }
public getSqlCmdVariablesForPublish(): Record<string, string> { public getSqlCmdVariablesForPublish(): Map<string, string> {
// get SQLCMD variables from table // get SQLCMD variables from table
let sqlCmdVariables = { ...this.sqlCmdVars }; let sqlCmdVariables = this.sqlCmdVars ?? new Map();
return sqlCmdVariables; return sqlCmdVariables;
} }
@@ -681,9 +681,9 @@ export class PublishDatabaseDialog {
}).component(); }).component();
table.onDataChanged(() => { table.onDataChanged(() => {
this.sqlCmdVars = {}; this.sqlCmdVars = new Map();
table.dataValues?.forEach((row) => { table.dataValues?.forEach((row) => {
(<Record<string, string>>this.sqlCmdVars)[<string>row[0].value] = <string>row[1].value; this.sqlCmdVars?.set(<string>row[0].value, <string>row[1].value);
}); });
this.updateRevertSqlCmdVarsButtonState(); this.updateRevertSqlCmdVarsButtonState();
@@ -708,7 +708,7 @@ export class PublishDatabaseDialog {
loadSqlCmdVarsButton.onDidClick(async () => { loadSqlCmdVarsButton.onDidClick(async () => {
for (const varName in this.sqlCmdVars) { for (const varName in this.sqlCmdVars) {
this.sqlCmdVars[varName] = this.getDefaultSqlCmdValue(varName); this.sqlCmdVars.set(varName, this.getDefaultSqlCmdValue(varName));
} }
const data = this.convertSqlCmdVarsToTableFormat(this.sqlCmdVars!); const data = this.convertSqlCmdVarsToTableFormat(this.sqlCmdVars!);
@@ -729,7 +729,7 @@ export class PublishDatabaseDialog {
* @returns value defined in the sqlproj file, or blank string if not defined * @returns value defined in the sqlproj file, or blank string if not defined
*/ */
private getDefaultSqlCmdValue(varName: string): string { private getDefaultSqlCmdValue(varName: string): string {
return Object.keys(this.project.sqlCmdVariables).includes(varName) ? this.project.sqlCmdVariables[varName] : ''; return this.project.sqlCmdVariables.get(varName) ?? '';
} }
private createSelectConnectionButton(view: azdataType.ModelView): azdataType.Component { private createSelectConnectionButton(view: azdataType.ModelView): azdataType.Component {
@@ -804,18 +804,18 @@ export class PublishDatabaseDialog {
// set options coming from the publish profiles to deployment options // set options coming from the publish profiles to deployment options
this.setDeploymentOptions(result.options); this.setDeploymentOptions(result.options);
if (Object.keys(result.sqlCmdVariables).length) { if ((<Map<string, string>>result.sqlCmdVariables).size) {
// add SQLCMD Variables table if it wasn't there before and the profile had sqlcmd variables // add SQLCMD Variables table if it wasn't there before and the profile had sqlcmd variables
if (Object.keys(this.project.sqlCmdVariables).length === 0 && Object.keys(<Record<string, string>>this.sqlCmdVars).length === 0) { if (this.project.sqlCmdVariables.size === 0 && this.sqlCmdVars?.size === 0) {
this.formBuilder?.addFormItem(<azdataType.FormComponentGroup>this.sqlCmdVariablesFormComponentGroup); this.formBuilder?.addFormItem(<azdataType.FormComponentGroup>this.sqlCmdVariablesFormComponentGroup);
} }
} else if (Object.keys(this.project.sqlCmdVariables).length === 0) { } else if (this.project.sqlCmdVariables.size === 0) {
// remove the table if there are no SQLCMD variables in the project and loaded profile // remove the table if there are no SQLCMD variables in the project and loaded profile
this.formBuilder?.removeFormItem(<azdataType.FormComponentGroup>this.sqlCmdVariablesFormComponentGroup); this.formBuilder?.removeFormItem(<azdataType.FormComponentGroup>this.sqlCmdVariablesFormComponentGroup);
} }
for (let key in result.sqlCmdVariables) { for (let key in result.sqlCmdVariables) {
(<Record<string, string>>this.sqlCmdVars)[key] = result.sqlCmdVariables[key]; this.sqlCmdVars?.set(key, result.sqlCmdVariableColumn.get(key));
} }
this.updateRevertSqlCmdVarsButtonState(); this.updateRevertSqlCmdVarsButtonState();
@@ -880,10 +880,10 @@ export class PublishDatabaseDialog {
return saveProfileAsButton; return saveProfileAsButton;
} }
private convertSqlCmdVarsToTableFormat(sqlCmdVars: Record<string, string>): azdataType.DeclarativeTableCellValue[][] { private convertSqlCmdVarsToTableFormat(sqlCmdVars: Map<string, string>): azdataType.DeclarativeTableCellValue[][] {
let data = []; let data = [];
for (let key in sqlCmdVars) { for (let key in sqlCmdVars) {
data.push([{ value: key }, { value: sqlCmdVars[key] }]); data.push([{ value: key }, { value: sqlCmdVars.get(key)! }]);
} }
return data; return data;
@@ -901,7 +901,7 @@ export class PublishDatabaseDialog {
let revertButtonEnabled = false; let revertButtonEnabled = false;
for (const varName in this.sqlCmdVars) { for (const varName in this.sqlCmdVars) {
if (this.sqlCmdVars![varName] !== this.getDefaultSqlCmdValue(varName)) { if (this.sqlCmdVars!.get(varName) !== this.getDefaultSqlCmdValue(varName)) {
revertButtonEnabled = true; revertButtonEnabled = true;
break; break;
} }
@@ -936,7 +936,7 @@ export class PublishDatabaseDialog {
private allSqlCmdVariablesFilled(): boolean { private allSqlCmdVariablesFilled(): boolean {
for (let key in this.sqlCmdVars) { for (let key in this.sqlCmdVars) {
if (this.sqlCmdVars[key] === '' || this.sqlCmdVars[key] === undefined) { if (this.sqlCmdVars.get(key) === '' || this.sqlCmdVars.get(key) === undefined) {
return false; return false;
} }
} }

8
extensions/sql-database-projects/src/dialogs/publishDatabaseQuickpick.ts
View File

@@ -163,7 +163,7 @@ export async function getPublishDatabaseSettings(project: ISqlProject, promptFor
// project file (if they exist) // project file (if they exist)
let sqlCmdVariables = Object.assign({}, project.sqlCmdVariables, publishProfile?.sqlCmdVariables); let sqlCmdVariables = Object.assign({}, project.sqlCmdVariables, publishProfile?.sqlCmdVariables);
if (Object.keys(sqlCmdVariables).length > 0) { if (sqlCmdVariables.size > 0) {
// Continually loop here, allowing the user to modify SQLCMD variables one // Continually loop here, allowing the user to modify SQLCMD variables one
// at a time until they're done (either by selecting the "Done" option or // at a time until they're done (either by selecting the "Done" option or
// escaping out of the quick pick dialog). Users can modify each variable // escaping out of the quick pick dialog). Users can modify each variable
@@ -173,7 +173,7 @@ export async function getPublishDatabaseSettings(project: ISqlProject, promptFor
const quickPickItems = Object.keys(sqlCmdVariables).map(key => { const quickPickItems = Object.keys(sqlCmdVariables).map(key => {
return { return {
label: key, label: key,
description: sqlCmdVariables[key], description: sqlCmdVariables.get(key),
key: key key: key
} as vscode.QuickPickItem & { key?: string, isResetAllVars?: boolean, isDone?: boolean }; } as vscode.QuickPickItem & { key?: string, isResetAllVars?: boolean, isDone?: boolean };
}); });
@@ -192,12 +192,12 @@ export async function getPublishDatabaseSettings(project: ISqlProject, promptFor
const newValue = await vscode.window.showInputBox( const newValue = await vscode.window.showInputBox(
{ {
title: constants.enterNewValueForVar(sqlCmd.key), title: constants.enterNewValueForVar(sqlCmd.key),
value: sqlCmdVariables[sqlCmd.key], value: sqlCmdVariables.get(sqlCmd.key),
ignoreFocusOut: true ignoreFocusOut: true
} }
); );
if (newValue) { if (newValue) {
sqlCmdVariables[sqlCmd.key] = newValue; sqlCmdVariables.set(sqlCmd.key, newValue);
} }
} else if (sqlCmd.isResetAllVars) { } else if (sqlCmd.isResetAllVars) {
sqlCmdVariables = Object.assign({}, project.sqlCmdVariables, publishProfile?.sqlCmdVariables); sqlCmdVariables = Object.assign({}, project.sqlCmdVariables, publishProfile?.sqlCmdVariables);

2
extensions/sql-database-projects/src/models/deploy/publishSettings.ts
View File

@@ -16,7 +16,7 @@ export interface ISqlProjectPublishSettings {
databaseName: string; databaseName: string;
serverName: string; serverName: string;
connectionUri: string; connectionUri: string;
sqlCmdVariables?: Record<string, string>; sqlCmdVariables?: Map<string, string>;
deploymentOptions?: DeploymentOptions; deploymentOptions?: DeploymentOptions;
profileUsed?: boolean; profileUsed?: boolean;
} }

16
extensions/sql-database-projects/src/models/project.ts
View File

@@ -44,7 +44,7 @@ export class Project implements ISqlProject {
private _folders: FileProjectEntry[] = []; private _folders: FileProjectEntry[] = [];
private _dataSources: DataSource[] = []; private _dataSources: DataSource[] = [];
private _databaseReferences: IDatabaseReferenceProjectEntry[] = []; private _databaseReferences: IDatabaseReferenceProjectEntry[] = [];
private _sqlCmdVariables: Record<string, string> = {}; private _sqlCmdVariables: Map<string, string> = new Map();
private _preDeployScripts: FileProjectEntry[] = []; private _preDeployScripts: FileProjectEntry[] = [];
private _postDeployScripts: FileProjectEntry[] = []; private _postDeployScripts: FileProjectEntry[] = [];
private _noneDeployScripts: FileProjectEntry[] = []; private _noneDeployScripts: FileProjectEntry[] = [];
@@ -97,7 +97,7 @@ export class Project implements ISqlProject {
return this._databaseReferences; return this._databaseReferences;
} }
public get sqlCmdVariables(): Record<string, string> { public get sqlCmdVariables(): Map<string, string> {
return this._sqlCmdVariables; return this._sqlCmdVariables;
} }
@@ -267,10 +267,10 @@ export class Project implements ISqlProject {
throw new Error(constants.errorReadingProject(constants.sqlCmdVariables, this.projectFilePath, sqlcmdVariablesResult.errorMessage)); throw new Error(constants.errorReadingProject(constants.sqlCmdVariables, this.projectFilePath, sqlcmdVariablesResult.errorMessage));
} }
this._sqlCmdVariables = {}; this._sqlCmdVariables = new Map();
for (const variable of sqlcmdVariablesResult.sqlCmdVariables) { for (const variable of sqlcmdVariablesResult.sqlCmdVariables) {
this._sqlCmdVariables[variable.varName] = variable.defaultValue; // store the default value that's specified in the .sqlproj this._sqlCmdVariables.set(variable.varName, variable.defaultValue); // store the default value that's specified in the .sqlproj
} }
} }
@@ -435,7 +435,7 @@ export class Project implements ISqlProject {
private resetProject(): void { private resetProject(): void {
this._files = []; this._files = [];
this._databaseReferences = []; this._databaseReferences = [];
this._sqlCmdVariables = {}; this._sqlCmdVariables = new Map();
this._preDeployScripts = []; this._preDeployScripts = [];
this._postDeployScripts = []; this._postDeployScripts = [];
this._noneDeployScripts = []; this._noneDeployScripts = [];
@@ -843,7 +843,8 @@ export class Project implements ISqlProject {
* @param defaultValue * @param defaultValue
*/ */
public async addSqlCmdVariable(name: string, defaultValue: string): Promise<void> { public async addSqlCmdVariable(name: string, defaultValue: string): Promise<void> {
await this.sqlProjService.addSqlCmdVariable(this.projectFilePath, name, defaultValue); const result = await this.sqlProjService.addSqlCmdVariable(this.projectFilePath, name, defaultValue);
this.throwIfFailed(result);
await this.readSqlCmdVariables(); await this.readSqlCmdVariables();
} }
@@ -853,7 +854,8 @@ export class Project implements ISqlProject {
* @param defaultValue * @param defaultValue
*/ */
public async updateSqlCmdVariable(name: string, defaultValue: string): Promise<void> { public async updateSqlCmdVariable(name: string, defaultValue: string): Promise<void> {
await this.sqlProjService.updateSqlCmdVariable(this.projectFilePath, name, defaultValue); const result = await this.sqlProjService.updateSqlCmdVariable(this.projectFilePath, name, defaultValue);
this.throwIfFailed(result);
await this.readSqlCmdVariables(); await this.readSqlCmdVariables();
} }

6
extensions/sql-database-projects/src/models/publishProfile/publishProfile.ts
View File

@@ -20,7 +20,7 @@ export interface PublishProfile {
serverName: string; serverName: string;
connectionId: string; connectionId: string;
connection: string; connection: string;
sqlCmdVariables: Record<string, string>; sqlCmdVariables: Map<string, string>;
options?: mssql.DeploymentOptions | vscodeMssql.DeploymentOptions; options?: mssql.DeploymentOptions | vscodeMssql.DeploymentOptions;
} }
@@ -60,7 +60,7 @@ export async function load(profileUri: vscode.Uri, dacfxService: utils.IDacFxSer
.withAdditionalProperties({ .withAdditionalProperties({
hasTargetDbName: (!!targetDbName).toString(), hasTargetDbName: (!!targetDbName).toString(),
hasConnectionString: (!!connectionInfo?.connectionId).toString(), hasConnectionString: (!!connectionInfo?.connectionId).toString(),
hasSqlCmdVariables: (Object.keys(sqlCmdVariables).length > 0).toString() hasSqlCmdVariables: (sqlCmdVariables.size > 0).toString()
}).send(); }).send();
return { return {
@@ -129,7 +129,7 @@ async function readConnectionString(xmlDoc: any): Promise<{ connectionId: string
/** /**
* saves publish settings to the specified profile file * saves publish settings to the specified profile file
*/ */
export async function savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<void> { export async function savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<void> {
const dacFxService = await utils.getDacFxService(); const dacFxService = await utils.getDacFxService();
await dacFxService.savePublishProfile(profilePath, databaseName, connectionString, sqlCommandVariableValues, deploymentOptions); await dacFxService.savePublishProfile(profilePath, databaseName, connectionString, sqlCommandVariableValues, deploymentOptions);
} }

10
extensions/sql-database-projects/src/models/tree/sqlcmdVariableTreeItem.ts
View File

@@ -23,21 +23,19 @@ export class SqlCmdVariablesTreeItem extends BaseProjectTreeItem {
* @param sqlCmdVariables Collection of SQLCMD variables in the project * @param sqlCmdVariables Collection of SQLCMD variables in the project
* @param project * @param project
*/ */
constructor(projectNodeName: string, sqlprojUri: vscode.Uri, sqlCmdVariables: Record<string, string>) { constructor(projectNodeName: string, sqlprojUri: vscode.Uri, sqlCmdVariables: Map<string, string>) {
super(vscode.Uri.file(path.join(projectNodeName, constants.sqlcmdVariablesNodeName)), sqlprojUri); super(vscode.Uri.file(path.join(projectNodeName, constants.sqlcmdVariablesNodeName)), sqlprojUri);
this.construct(sqlCmdVariables); this.construct(sqlCmdVariables);
} }
private construct(sqlCmdVariables: Record<string, string>) { private construct(sqlCmdVariables: Map<string, string>) {
if (!sqlCmdVariables) { if (!sqlCmdVariables) {
return; return;
} }
for (const sqlCmdVariable of Object.keys(sqlCmdVariables)) { for (const sqlCmdVariable of sqlCmdVariables.keys()) {
if (sqlCmdVariable) { this.sqlcmdVariableTreeItems.push(new SqlCmdVariableTreeItem(sqlCmdVariable, this.relativeProjectUri, this.projectFileUri));
this.sqlcmdVariableTreeItems.push(new SqlCmdVariableTreeItem(sqlCmdVariable, this.relativeProjectUri, this.projectFileUri));
}
} }
} }

2
extensions/sql-database-projects/src/sqldbproj.d.ts vendored
View File

@@ -248,7 +248,7 @@ declare module 'sqldbproj' {
/** /**
* SqlCmd variables and their values * SqlCmd variables and their values
*/ */
readonly sqlCmdVariables: Record<string, string>; readonly sqlCmdVariables: Map<string, string>;
/** /**
* Pre-deployment scripts in this project * Pre-deployment scripts in this project

22
extensions/sql-database-projects/src/templates/templates.ts
View File

@@ -13,14 +13,14 @@ export let newSdkSqlProjectTemplate: string;
// Object maps // Object maps
let scriptTypeMap: Record<string, ProjectScriptType> = {}; let scriptTypeMap: Map<string, ProjectScriptType> = new Map();
export function get(key: string): ProjectScriptType { export function get(key: string): ProjectScriptType {
if (Object.keys(scriptTypeMap).length === 0) { if (scriptTypeMap.size === 0) {
throw new Error('Templates must be loaded from file before attempting to use.'); throw new Error('Templates must be loaded from file before attempting to use.');
} }
return scriptTypeMap[key.toLocaleLowerCase()]; return scriptTypeMap.get(key.toLocaleLowerCase())!;
} }
let scriptTypes: ProjectScriptType[] = []; let scriptTypes: ProjectScriptType[] = [];
@@ -52,26 +52,26 @@ export async function loadTemplates(templateFolderPath: string) {
]); ]);
for (const scriptType of scriptTypes) { for (const scriptType of scriptTypes) {
if (Object.keys(scriptTypeMap).find(s => s === scriptType.type.toLocaleLowerCase() || s === scriptType.friendlyName.toLocaleLowerCase())) { if (scriptTypeMap.has(scriptType.type.toLocaleLowerCase()) || scriptTypeMap.has(scriptType.friendlyName.toLocaleLowerCase())) {
throw new Error(`Script type map already contains ${scriptType.type} or its friendlyName.`); throw new Error(`Script type map already contains ${scriptType.type} or its friendlyName.`);
} }
scriptTypeMap[scriptType.type.toLocaleLowerCase()] = scriptType; scriptTypeMap.set(scriptType.type.toLocaleLowerCase(), scriptType);
scriptTypeMap[scriptType.friendlyName.toLocaleLowerCase()] = scriptType; scriptTypeMap.set(scriptType.friendlyName.toLocaleLowerCase(), scriptType);
} }
} }
export function macroExpansion(template: string, macroDict: Record<string, string>): string { export function macroExpansion(template: string, macroDict: Map<string, string>): string {
const macroIndicator = '@@'; const macroIndicator = '@@';
let output = template; let output = template;
for (const macro in macroDict) { for (const macro in macroDict) {
// check if value contains the macroIndicator, which could break expansion for successive macros // check if value contains the macroIndicator, which could break expansion for successive macros
if (macroDict[macro].includes(macroIndicator)) { if (macroDict.get(macro)!.includes(macroIndicator)) {
throw new Error(`Macro value ${macroDict[macro]} is invalid because it contains ${macroIndicator}`); throw new Error(`Macro value ${macroDict.get(macro)} is invalid because it contains ${macroIndicator}`);
} }
output = output.replace(new RegExp(macroIndicator + macro + macroIndicator, 'g'), macroDict[macro]); output = output.replace(new RegExp(macroIndicator + macro + macroIndicator, 'g'), macroDict.get(macro)!);
} }
return output; return output;
@@ -104,6 +104,6 @@ export class ProjectScriptType {
* For testing purposes only * For testing purposes only
*/ */
export function reset() { export function reset() {
scriptTypeMap = {}; scriptTypeMap = new Map();
scriptTypes = []; scriptTypes = [];
} }

24
extensions/sql-database-projects/src/test/dialogs/publishDatabaseDialog.test.ts
View File

@@ -83,10 +83,10 @@ describe('Publish Database Dialog', () => {
databaseName: 'MockDatabaseName', databaseName: 'MockDatabaseName',
serverName: 'MockServer', serverName: 'MockServer',
connectionUri: 'Mock|Connection|Uri', connectionUri: 'Mock|Connection|Uri',
sqlCmdVariables: { sqlCmdVariables: new Map([
'ProdDatabaseName': 'MyProdDatabase', ['ProdDatabaseName', 'MyProdDatabase'],
'BackupDatabaseName': 'MyBackupDatabase' ['BackupDatabaseName', 'MyBackupDatabase']
}, ]),
deploymentOptions: mockDacFxOptionsResult.deploymentOptions, deploymentOptions: mockDacFxOptionsResult.deploymentOptions,
profileUsed: false profileUsed: false
}; };
@@ -100,10 +100,10 @@ describe('Publish Database Dialog', () => {
databaseName: 'MockDatabaseName', databaseName: 'MockDatabaseName',
serverName: 'MockServer', serverName: 'MockServer',
connectionUri: 'Mock|Connection|Uri', connectionUri: 'Mock|Connection|Uri',
sqlCmdVariables: { sqlCmdVariables: new Map([
'ProdDatabaseName': 'MyProdDatabase', ['ProdDatabaseName', 'MyProdDatabase'],
'BackupDatabaseName': 'MyBackupDatabase' ['BackupDatabaseName', 'MyBackupDatabase']
}, ]),
deploymentOptions: mockDacFxOptionsResult.deploymentOptions, deploymentOptions: mockDacFxOptionsResult.deploymentOptions,
profileUsed: false profileUsed: false
}; };
@@ -128,10 +128,10 @@ describe('Publish Database Dialog', () => {
databaseName: 'MockDatabaseName', databaseName: 'MockDatabaseName',
serverName: 'localhost', serverName: 'localhost',
connectionUri: '', connectionUri: '',
sqlCmdVariables: { sqlCmdVariables: new Map([
'ProdDatabaseName': 'MyProdDatabase', ['ProdDatabaseName', 'MyProdDatabase'],
'BackupDatabaseName': 'MyBackupDatabase' ['BackupDatabaseName', 'MyBackupDatabase']
}, ]),
deploymentOptions: mockDacFxOptionsResult.deploymentOptions, deploymentOptions: mockDacFxOptionsResult.deploymentOptions,
profileUsed: false profileUsed: false
} }

32
extensions/sql-database-projects/src/test/project.test.ts
View File

@@ -48,9 +48,9 @@ describe('Project: sqlproj content operations', function (): void {
'Views\\User']); 'Views\\User']);
// SqlCmdVariables // SqlCmdVariables
should(Object.keys(project.sqlCmdVariables).length).equal(2); should(project.sqlCmdVariables.size).equal(2);
should(project.sqlCmdVariables['ProdDatabaseName']).equal('MyProdDatabase'); should(project.sqlCmdVariables.get('ProdDatabaseName')).equal('MyProdDatabase');
should(project.sqlCmdVariables['BackupDatabaseName']).equal('MyBackupDatabase'); should(project.sqlCmdVariables.get('BackupDatabaseName')).equal('MyBackupDatabase');
// Database references // Database references
// should only have one database reference even though there are two master.dacpac references (1 for ADS and 1 for SSDT) // should only have one database reference even though there are two master.dacpac references (1 for ADS and 1 for SSDT)
@@ -647,7 +647,7 @@ describe('Project: database references', function (): void {
// add database reference to a different database on a different server // add database reference to a different database on a different server
should(project.databaseReferences.length).equal(0, 'There should be no database references to start with'); should(project.databaseReferences.length).equal(0, 'There should be no database references to start with');
should(Object.keys(project.sqlCmdVariables).length).equal(0, `There should be no sqlcmd variables to start with. Actual: ${Object.keys(project.sqlCmdVariables).length}`); should(project.sqlCmdVariables.size).equal(0, `There should be no sqlcmd variables to start with. Actual: ${project.sqlCmdVariables.size}`);
await project.addProjectReference({ await project.addProjectReference({
projectName: 'project1', projectName: 'project1',
projectGuid: '', projectGuid: '',
@@ -658,7 +658,7 @@ describe('Project: database references', function (): void {
should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1'); should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1');
should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1'); should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1');
should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false'); should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false');
should(Object.keys(project.sqlCmdVariables).length).equal(0, `There should be no sqlcmd variables added. Actual: ${Object.keys(project.sqlCmdVariables).length}`); should(project.sqlCmdVariables.size).equal(0, `There should be no sqlcmd variables added. Actual: ${project.sqlCmdVariables.size}`);
}); });
it('Should add a project reference to a different database in the same server correctly', async function (): Promise<void> { it('Should add a project reference to a different database in the same server correctly', async function (): Promise<void> {
@@ -667,7 +667,7 @@ describe('Project: database references', function (): void {
// add database reference to a different database on a different server // add database reference to a different database on a different server
should(project.databaseReferences.length).equal(0, 'There should be no database references to start with'); should(project.databaseReferences.length).equal(0, 'There should be no database references to start with');
should(Object.keys(project.sqlCmdVariables).length).equal(0, 'There should be no sqlcmd variables to start with'); should(project.sqlCmdVariables.size).equal(0, 'There should be no sqlcmd variables to start with');
await project.addProjectReference({ await project.addProjectReference({
projectName: 'project1', projectName: 'project1',
projectGuid: '', projectGuid: '',
@@ -680,7 +680,7 @@ describe('Project: database references', function (): void {
should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1'); should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1');
should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1'); should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1');
should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false'); should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false');
should(Object.keys(project.sqlCmdVariables).length).equal(1, `There should be one new sqlcmd variable added. Actual: ${Object.keys(project.sqlCmdVariables).length}`); should(project.sqlCmdVariables.size).equal(1, `There should be one new sqlcmd variable added. Actual: ${project.sqlCmdVariables.size}`);
}); });
it('Should add a project reference to a different database in a different server correctly', async function (): Promise<void> { it('Should add a project reference to a different database in a different server correctly', async function (): Promise<void> {
@@ -689,7 +689,7 @@ describe('Project: database references', function (): void {
// add database reference to a different database on a different server // add database reference to a different database on a different server
should(project.databaseReferences.length).equal(0, 'There should be no database references to start with'); should(project.databaseReferences.length).equal(0, 'There should be no database references to start with');
should(Object.keys(project.sqlCmdVariables).length).equal(0, 'There should be no sqlcmd variables to start with'); should(project.sqlCmdVariables.size).equal(0, 'There should be no sqlcmd variables to start with');
await project.addProjectReference({ await project.addProjectReference({
projectName: 'project1', projectName: 'project1',
projectGuid: '', projectGuid: '',
@@ -704,7 +704,7 @@ describe('Project: database references', function (): void {
should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1'); should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to project1');
should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1'); should(project.databaseReferences[0].referenceName).equal('project1', 'The database reference should be project1');
should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false'); should(project.databaseReferences[0].suppressMissingDependenciesErrors).equal(false, 'project.databaseReferences[0].suppressMissingDependenciesErrors should be false');
should(Object.keys(project.sqlCmdVariables).length).equal(2, `There should be two new sqlcmd variables added. Actual: ${Object.keys(project.sqlCmdVariables).length}`); should(project.sqlCmdVariables.size).equal(2, `There should be two new sqlcmd variables added. Actual: ${project.sqlCmdVariables.size}`);
}); });
it('Should not allow adding duplicate dacpac references', async function (): Promise<void> { it('Should not allow adding duplicate dacpac references', async function (): Promise<void> {
@@ -803,7 +803,7 @@ describe('Project: database references', function (): void {
}); });
should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to test3'); should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to test3');
should(project.databaseReferences[0].referenceName).equal('test3', 'The database reference should be test3'); should(project.databaseReferences[0].referenceName).equal('test3', 'The database reference should be test3');
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'There should be 2 sqlcmdvars after adding the dacpac reference'); should(project.sqlCmdVariables.size).equal(2, 'There should be 2 sqlcmdvars after adding the dacpac reference');
// make sure reference to test3.dacpac and SQLCMD variables were added // make sure reference to test3.dacpac and SQLCMD variables were added
let projFileText = (await fs.readFile(projFilePath)).toString(); let projFileText = (await fs.readFile(projFilePath)).toString();
@@ -815,7 +815,7 @@ describe('Project: database references', function (): void {
// delete reference // delete reference
await project.deleteDatabaseReferenceByEntry(project.databaseReferences[0]); await project.deleteDatabaseReferenceByEntry(project.databaseReferences[0]);
should(project.databaseReferences.length).equal(0, 'There should be no database references after deleting'); should(project.databaseReferences.length).equal(0, 'There should be no database references after deleting');
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'There should still be 2 sqlcmdvars after deleting the dacpac reference'); should(project.sqlCmdVariables.size).equal(2, 'There should still be 2 sqlcmdvars after deleting the dacpac reference');
// add reference to the same dacpac again but with different values for the sqlcmd variables // add reference to the same dacpac again but with different values for the sqlcmd variables
await project.addDatabaseReference({ await project.addDatabaseReference({
@@ -828,7 +828,7 @@ describe('Project: database references', function (): void {
}); });
should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to test3'); should(project.databaseReferences.length).equal(1, 'There should be a database reference after adding a reference to test3');
should(project.databaseReferences[0].referenceName).equal('test3', 'The database reference should be test3'); should(project.databaseReferences[0].referenceName).equal('test3', 'The database reference should be test3');
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'There should still be 2 sqlcmdvars after adding the dacpac reference again with different sqlcmdvar values'); should(project.sqlCmdVariables.size).equal(2, 'There should still be 2 sqlcmdvars after adding the dacpac reference again with different sqlcmdvar values');
projFileText = (await fs.readFile(projFilePath)).toString(); projFileText = (await fs.readFile(projFilePath)).toString();
should(projFileText).containEql('<SqlCmdVariable Include="test3Db">'); should(projFileText).containEql('<SqlCmdVariable Include="test3Db">');
@@ -850,7 +850,7 @@ describe('Project: add SQLCMD Variables', function (): void {
it('Should update .sqlproj with new sqlcmd variables', async function (): Promise<void> { it('Should update .sqlproj with new sqlcmd variables', async function (): Promise<void> {
const projFilePath = await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline); const projFilePath = await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline);
let project = await Project.openProject(projFilePath); let project = await Project.openProject(projFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should have 2 sqlcmd variables when opened'); should(project.sqlCmdVariables.size).equal(2, 'The project should have 2 sqlcmd variables when opened');
// add a new variable // add a new variable
await project.addSqlCmdVariable('TestDatabaseName', 'TestDb'); await project.addSqlCmdVariable('TestDatabaseName', 'TestDb');
@@ -858,9 +858,9 @@ describe('Project: add SQLCMD Variables', function (): void {
// update value of an existing sqlcmd variable // update value of an existing sqlcmd variable
await project.updateSqlCmdVariable('ProdDatabaseName', 'NewProdName'); await project.updateSqlCmdVariable('ProdDatabaseName', 'NewProdName');
should(Object.keys(project.sqlCmdVariables).length).equal(3, 'There should be 3 sqlcmd variables after adding TestDatabaseName'); should(project.sqlCmdVariables.size).equal(3, 'There should be 3 sqlcmd variables after adding TestDatabaseName');
should(project.sqlCmdVariables['TestDatabaseName']).equal('TestDb', 'Value of TestDatabaseName should be TestDb'); should(project.sqlCmdVariables.get('TestDatabaseName')).equal('TestDb', 'Value of TestDatabaseName should be TestDb');
should(project.sqlCmdVariables['ProdDatabaseName']).equal('NewProdName', 'ProdDatabaseName value should have been updated to the new value'); should(project.sqlCmdVariables.get('ProdDatabaseName')).equal('NewProdName', 'ProdDatabaseName value should have been updated to the new value');
}); });
}); });

26
extensions/sql-database-projects/src/test/projectController.test.ts
View File

@@ -303,7 +303,7 @@ describe('ProjectsController', function (): void {
}); });
it('Should exclude nested ProjectEntry from node', async function (): Promise<void> { it('Should exclude nested ProjectEntry from node', async function (): Promise<void> {
let proj = await testUtils.createTestProject(this.test, templates.newSqlProjectTemplate); let proj = await testUtils.createTestSqlProject(this.test);
const setupResult = await setupDeleteExcludeTest(proj); const setupResult = await setupDeleteExcludeTest(proj);
const scriptEntry = setupResult[0], projTreeRoot = setupResult[1], preDeployEntry = setupResult[2], postDeployEntry = setupResult[3], noneEntry = setupResult[4]; const scriptEntry = setupResult[0], projTreeRoot = setupResult[1], preDeployEntry = setupResult[2], postDeployEntry = setupResult[3], noneEntry = setupResult[4];
@@ -997,14 +997,14 @@ describe('ProjectsController', function (): void {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projRoot = new ProjectRootTreeItem(project); const projRoot = new ProjectRootTreeItem(project);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should start with 2 sqlcmd variables'); should(project.sqlCmdVariables.size).equal(2, 'The project should start with 2 sqlcmd variables');
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve('Cancel')); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve('Cancel'));
await projController.delete(createWorkspaceTreeItem(projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!.children[0])); await projController.delete(createWorkspaceTreeItem(projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!.children[0]));
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should still have 2 sqlcmd variables if no was selected'); should(project.sqlCmdVariables.size).equal(2, 'The project should still have 2 sqlcmd variables if no was selected');
sinon.restore(); sinon.restore();
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve('Yes')); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve('Yes'));
@@ -1012,7 +1012,7 @@ describe('ProjectsController', function (): void {
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(1, 'The project should only have 1 sqlcmd variable after deletion'); should(project.sqlCmdVariables.size).equal(1, 'The project should only have 1 sqlcmd variable after deletion');
}); });
it('Should add sqlcmd variable', async function (): Promise<void> { it('Should add sqlcmd variable', async function (): Promise<void> {
@@ -1023,7 +1023,7 @@ describe('ProjectsController', function (): void {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projRoot = new ProjectRootTreeItem(project); const projRoot = new ProjectRootTreeItem(project);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should start with 2 sqlcmd variables'); should(project.sqlCmdVariables.size).equal(2, 'The project should start with 2 sqlcmd variables');
const inputBoxStub = sinon.stub(vscode.window, 'showInputBox'); const inputBoxStub = sinon.stub(vscode.window, 'showInputBox');
inputBoxStub.resolves(''); inputBoxStub.resolves('');
@@ -1031,7 +1031,7 @@ describe('ProjectsController', function (): void {
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should still have 2 sqlcmd variables if no name was provided'); should(project.sqlCmdVariables.size).equal(2, 'The project should still have 2 sqlcmd variables if no name was provided');
inputBoxStub.reset(); inputBoxStub.reset();
inputBoxStub.onFirstCall().resolves('newVariable'); inputBoxStub.onFirstCall().resolves('newVariable');
@@ -1040,7 +1040,7 @@ describe('ProjectsController', function (): void {
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(3, 'The project should have 3 sqlcmd variable after adding a new one'); should(project.sqlCmdVariables.size).equal(3, 'The project should have 3 sqlcmd variable after adding a new one');
}); });
it('Should update sqlcmd variable', async function (): Promise<void> { it('Should update sqlcmd variable', async function (): Promise<void> {
@@ -1051,18 +1051,18 @@ describe('ProjectsController', function (): void {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projRoot = new ProjectRootTreeItem(project); const projRoot = new ProjectRootTreeItem(project);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should start with 2 sqlcmd variables'); should(project.sqlCmdVariables.size).equal(2, 'The project should start with 2 sqlcmd variables');
const inputBoxStub = sinon.stub(vscode.window, 'showInputBox'); const inputBoxStub = sinon.stub(vscode.window, 'showInputBox');
inputBoxStub.resolves(''); inputBoxStub.resolves('');
const sqlcmdVarToUpdate = projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!.children[0]; const sqlcmdVarToUpdate = projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!.children[0];
const originalValue = project.sqlCmdVariables[sqlcmdVarToUpdate.friendlyName]; const originalValue = project.sqlCmdVariables.get(sqlcmdVarToUpdate.friendlyName);
await projController.editSqlCmdVariable(createWorkspaceTreeItem(sqlcmdVarToUpdate)); await projController.editSqlCmdVariable(createWorkspaceTreeItem(sqlcmdVarToUpdate));
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should still have 2 sqlcmd variables'); should(project.sqlCmdVariables.size).equal(2, 'The project should still have 2 sqlcmd variables');
should(project.sqlCmdVariables[sqlcmdVarToUpdate.friendlyName]).equal(originalValue, 'The value of the sqlcmd variable should not have changed'); should(project.sqlCmdVariables.get(sqlcmdVarToUpdate.friendlyName)).equal(originalValue, 'The value of the sqlcmd variable should not have changed');
inputBoxStub.reset(); inputBoxStub.reset();
const updatedValue = 'newValue'; const updatedValue = 'newValue';
@@ -1071,8 +1071,8 @@ describe('ProjectsController', function (): void {
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should still have 2 sqlcmd variables'); should(project.sqlCmdVariables.size).equal(2, 'The project should still have 2 sqlcmd variables');
should(project.sqlCmdVariables[sqlcmdVarToUpdate.friendlyName]).equal(updatedValue, 'The value of the sqlcmd variable should have been updated'); should(project.sqlCmdVariables.get(sqlcmdVarToUpdate.friendlyName)).equal(updatedValue, 'The value of the sqlcmd variable should have been updated');
}); });
}); });
}); });

12
extensions/sql-database-projects/src/test/publishProfile.test.ts
View File

@@ -49,8 +49,8 @@ describe('Publish profile tests', function (): void {
const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object); const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object);
should(result.databaseName).equal('targetDb'); should(result.databaseName).equal('targetDb');
should(Object.keys(result.sqlCmdVariables).length).equal(1); should(result.sqlCmdVariables.size).equal(1);
should(result.sqlCmdVariables['ProdDatabaseName']).equal('MyProdDatabase'); should(result.sqlCmdVariables.get('ProdDatabaseName')).equal('MyProdDatabase');
should(result.connectionId).equal('connId'); should(result.connectionId).equal('connId');
should(result.connection).equal('testserver (default)'); should(result.connection).equal('testserver (default)');
should(result.options).equal(mockDacFxOptionsResult.deploymentOptions); should(result.options).equal(mockDacFxOptionsResult.deploymentOptions);
@@ -74,8 +74,8 @@ describe('Publish profile tests', function (): void {
const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object); const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object);
should(result.databaseName).equal('targetDb'); should(result.databaseName).equal('targetDb');
should(Object.keys(result.sqlCmdVariables).length).equal(1); should(result.sqlCmdVariables.size).equal(1);
should(result.sqlCmdVariables['ProdDatabaseName']).equal('MyProdDatabase'); should(result.sqlCmdVariables.get('ProdDatabaseName')).equal('MyProdDatabase');
should(result.connectionId).equal('connId'); should(result.connectionId).equal('connId');
should(result.connection).equal('testserver (testUser)'); should(result.connection).equal('testserver (testUser)');
should(result.options).equal(mockDacFxOptionsResult.deploymentOptions); should(result.options).equal(mockDacFxOptionsResult.deploymentOptions);
@@ -89,10 +89,10 @@ describe('Publish profile tests', function (): void {
}); });
const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object); const result = await load(vscode.Uri.file(profilePath), testContext.dacFxService.object);
should(Object.keys(result.sqlCmdVariables).length).equal(1); should(result.sqlCmdVariables.size).equal(1);
// the profile has both Value and DefaultValue, but Value should be the one used // the profile has both Value and DefaultValue, but Value should be the one used
should(result.sqlCmdVariables['ProdDatabaseName']).equal('MyProdDatabase'); should(result.sqlCmdVariables.get('ProdDatabaseName')).equal('MyProdDatabase');
}); });
it('Should throw error when connecting does not work', async function (): Promise<void> { it('Should throw error when connecting does not work', async function (): Promise<void> {

6
extensions/sql-database-projects/src/test/testContext.ts
View File

@@ -56,13 +56,13 @@ export class MockDacFxService implements mssql.IDacFxService {
public importBacpac(_packageFilePath: string, _databaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); } public importBacpac(_packageFilePath: string, _databaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); }
public extractDacpac(_databaseName: string, _packageFilePath: string, _applicationName: string, _applicationVersion: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); } public extractDacpac(_databaseName: string, _packageFilePath: string, _applicationName: string, _applicationVersion: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); }
public createProjectFromDatabase(_databaseName: string, _targetFilePath: string, _applicationName: string, _applicationVersion: string, _ownerUri: string, _extractTarget: mssql.ExtractTarget, _taskExecutionMode: azdata.TaskExecutionMode, _includePermissions?: boolean): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); } public createProjectFromDatabase(_databaseName: string, _targetFilePath: string, _applicationName: string, _applicationVersion: string, _ownerUri: string, _extractTarget: mssql.ExtractTarget, _taskExecutionMode: azdata.TaskExecutionMode, _includePermissions?: boolean): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); }
public deployDacpac(_packageFilePath: string, _targetDatabaseName: string, _upgradeExisting: boolean, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode, _sqlCommandVariableValues?: Record<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); } public deployDacpac(_packageFilePath: string, _targetDatabaseName: string, _upgradeExisting: boolean, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode, _sqlCommandVariableValues?: Map<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); }
public generateDeployScript(_packageFilePath: string, _targetDatabaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode, _sqlCommandVariableValues?: Record<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); } public generateDeployScript(_packageFilePath: string, _targetDatabaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode, _sqlCommandVariableValues?: Map<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<mssql.DacFxResult> { return Promise.resolve(mockDacFxResult); }
public generateDeployPlan(_packageFilePath: string, _targetDatabaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.GenerateDeployPlanResult> { return Promise.resolve(mockDacFxResult); } public generateDeployPlan(_packageFilePath: string, _targetDatabaseName: string, _ownerUri: string, _taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.GenerateDeployPlanResult> { return Promise.resolve(mockDacFxResult); }
public getOptionsFromProfile(_profilePath: string): Thenable<mssql.DacFxOptionsResult> { return Promise.resolve(mockDacFxOptionsResult); } public getOptionsFromProfile(_profilePath: string): Thenable<mssql.DacFxOptionsResult> { return Promise.resolve(mockDacFxOptionsResult); }
public validateStreamingJob(_packageFilePath: string, _createStreamingJobTsql: string): Thenable<mssql.ValidateStreamingJobResult> { return Promise.resolve(mockDacFxResult); } public validateStreamingJob(_packageFilePath: string, _createStreamingJobTsql: string): Thenable<mssql.ValidateStreamingJobResult> { return Promise.resolve(mockDacFxResult); }
public parseTSqlScript(_filePath: string, _databaseSchemaProvider: string): Thenable<mssql.ParseTSqlScriptResult> { return Promise.resolve({ containsCreateTableStatement: true }); } public parseTSqlScript(_filePath: string, _databaseSchemaProvider: string): Thenable<mssql.ParseTSqlScriptResult> { return Promise.resolve({ containsCreateTableStatement: true }); }
public savePublishProfile(_profilePath: string, _databaseName: string, _connectionString: string, _sqlCommandVariableValues?: Record<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<azdata.ResultStatus> { return Promise.resolve(mockSavePublishResult); } public savePublishProfile(_profilePath: string, _databaseName: string, _connectionString: string, _sqlCommandVariableValues?: Map<string, string>, _deploymentOptions?: mssql.DeploymentOptions): Thenable<azdata.ResultStatus> { return Promise.resolve(mockSavePublishResult); }
} }
export function createContext(): TestContext { export function createContext(): TestContext {

4
extensions/sql-database-projects/src/test/testUtils.ts
View File

@@ -43,9 +43,7 @@ export async function getTestProjectPath(test: Mocha.Runnable | undefined): Prom
export async function createTestSqlProjFile(test: Mocha.Runnable | undefined, contents: string, folderPath?: string): Promise<string> { export async function createTestSqlProjFile(test: Mocha.Runnable | undefined, contents: string, folderPath?: string): Promise<string> {
folderPath = folderPath ?? path.join(await generateTestFolderPath(test), 'TestProject'); folderPath = folderPath ?? path.join(await generateTestFolderPath(test), 'TestProject');
const macroDict: Record<string, string> = { const macroDict: Map<string, string> = new Map([['PROJECT_DSP', constants.defaultDSP]]);
'PROJECT_DSP': constants.defaultDSP
};
contents = templates.macroExpansion(contents, macroDict); contents = templates.macroExpansion(contents, macroDict);
return await createTestFile(test, contents, 'TestProject.sqlproj', folderPath); return await createTestFile(test, contents, 'TestProject.sqlproj', folderPath);
} }

6
extensions/types/vscode-mssql.d.ts vendored
View File

@@ -426,12 +426,12 @@ declare module 'vscode-mssql' {
importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>; importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>; extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: ExtractTarget, taskExecutionMode: TaskExecutionMode, includePermissions?: boolean): Thenable<DacFxResult>; createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: ExtractTarget, taskExecutionMode: TaskExecutionMode, includePermissions?: boolean): Thenable<DacFxResult>;
deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>; deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>;
generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>; generateDeployScript(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<DacFxResult>;
generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<GenerateDeployPlanResult>; generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<GenerateDeployPlanResult>;
getOptionsFromProfile(profilePath: string): Thenable<DacFxOptionsResult>; getOptionsFromProfile(profilePath: string): Thenable<DacFxOptionsResult>;
validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Thenable<ValidateStreamingJobResult>; validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Thenable<ValidateStreamingJobResult>;
savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: DeploymentOptions): Thenable<ResultStatus>; savePublishProfile(profilePath: string, databaseName: string, connectionString: string, sqlCommandVariableValues?: Map<string, string>, deploymentOptions?: DeploymentOptions): Thenable<ResultStatus>;
} }
/** /**