ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 18:46:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

SQL Database Projects backend swap to DacFx/Tools Service (#22451)

Browse Source 
* Move call to STS move api into project.ts (#22071)

* move call to STS move api into project.ts

* remove undefined

* Remove convert to sdk style code (#22081)

* remove convert to sdk style code

* remove from package.json

* Merging latest from main (#22097)

* [SQL-Migration] Login migrations telemetry (#22038)

This PR enhances telemetry for login migrations (and in the following ways:

Add details for starting migration (number of logins migrating, type of logins)
Log Migration result (number of errors per step, duration of each step, type of logins, if system error occurred)
Add sql-migration extension to our telemetry
Adds details when trying to connect to target
Tracks clicking "done" from the wizard
Fixes bucketizing for navigating telemetry in the login migration wizard
Sample usage of kusto query for new telemetry:
RawEventsADS
| where EventName contains 'sql-migration'
| extend view = tostring(Properties['view'])
| extend action = tostring(Properties['action'])
| extend buttonPressed = tostring(Properties['buttonpressed'])
| extend pageTitle = tostring(Properties['pagetitle'])
| extend adsVersion = tostring(Properties['common.adsversion'])
| extend targetType = tostring(Properties['targettype'])
| extend tenantId = tostring(Properties['tenantid'])
| extend subscriptionId = tostring(Properties['subscriptionid'])
| where view contains "login"
//| where adsVersion contains "1.42.0-insider"
| where ClientTimestamp >= ago(18h)
| project EventName, ClientTimestamp, SessionId, view, pageTitle, action, buttonPressed, targetType
, tenantId, subscriptionId
, adsVersion, OSVersion, Properties

* Add Secure Enclaves dropdown with customizable Advanced options (#22019)

* Update extension READMEs (#22079)

* Fix query-history README images (#22084)

* [Loc] update to mssql and sql-migration xlf files (#22087)

* [Loc] small fix to Portuguese lcl file (#22088)

* [Loc] small fix to Portuguese lcl file

* remove newline

* Adding None bindings to the sqlProjects service (#22085)

* Adding None bindings

* updating names of None bindings

---------

Co-authored-by: AkshayMata <akam520@gmail.com>
Co-authored-by: Cheena Malhotra <13396919+cheenamalhotra@users.noreply.github.com>
Co-authored-by: Charles Gagnon <chgagnon@microsoft.com>
Co-authored-by: Alex Ma <alma1@microsoft.com>

* Swap add and update sqlcmd variables in sql projects to use STS apis (#22086)

* delete sqlcmd variable working

* undo add

* remove variable from add and update sqlcmd variable apis

* hookup add and edit sqlcmd variable

* update vscode-mssql.d.ts

* move add and edit to project.ts

* update STS and tests

* move delete sqlcmd variable to project.ts (#22104)

* add test for add and edit sqlcmd variable (#22107)

* Swapping property access to STS (#22115)

* checkpoint

* Adding sqlproj property bindings

* Swapping out property loading and setting

* consolidating to this.sqlProjService

* Update dacpac reference to use STS api (#22116)

* Update add dacpac reference to use STS api

* remove changes for project ref

* validate unset settings from add database reference dialog

* update one more place getting sqlprojservice

* addressing comments

* fix path for dacpac reference (#22143)

* Swap add project reference to call STS (#22148)

* initial changes for swapping add project reference

* fix include path

* move common logic to helper function

* read sqlcmd variables from STS (#22147)

* Swapping .sqlproj- and crossplat compatibility-related functions to use STS (#22146)

* Supporting roundtrip

* Updating sqlproj style checks and cross-platform compatibility to use STS

* removing unnecessary awaits

* Fixing assertions

* Adding roundtrip update confirmations

* test cleanup

* cleaning up comment; localizing error

* Swap add system db reference (#22171)

* swap adding system database references

* fix tests

* remove only in test

* Read database references from STS (#22179)

* Read database references from STS

* fix system dacpac names

* fix project reference name

* Swap changeTargetPlatform to call STS (#22172)

* swap changeTargetPlatform to call STS

* Address comments

* De-duplicating enum for SystemDatabase (#22196)

* Deudping SystemDatabase enum

* simplifying enum refs

* Removing the now-unused imports code from SqlProjects (#22199)

* Removing unused importTargets entries

* whitespace; also to retrigger github checks on correct branch

* Hooking in Move() for Nones and PublishProfiles (#22200)

* Swap delete database reference to call STS (#22215)

* initial changes

* update contracts

* remove unnecessary info from SystemDatabaseReferenceProjectEntry

* uppercase master and msdb

* cleanup

* update test

* update comment

* undo change in projectController.ts

* remove unused system dacpac helper functions (#22204)

* more cleanup of project.ts (#22242)

* fix a couple database reference tests (#22248)

* Organizing sqlcmd variable and db reference code (#22284)

* organize database references and sqlcmd variable functions

* separate database reference tests

* Script and folder get + add support (#22166)

* Initial sqlobjectscripts

* adding mock filter

* test fixing

* another test passing

* swapping pre/post/none checkpoint

* awaiters

* convert addExistingItem

* swapping folders

* removing print

* stripping out project folder and file readers

* adding some regions

* Updating sqlproj style checks and cross-platform compatibility to use STS

* Updating sqlproj style checks and cross-platform compatibility to use STS

* added type property to tree items

* projectController swapovers

* removing imported targets

* Deleting the last of the TS XML parsing!

* Removing old functions

* renamed readNoneScripts to readNoneItems

* fixing path passed to STS calls

* remove system dacpac tests that were moved to DacFx (#22299)

* fix error when opening file after adding a file to sql project (#22309)

* fix error when opening file after adding a file to sql project

* remove unused import

* fix exclude for table and externalStreamingJob (#22310)

* add reload project (#22313)

* set DSP from STS (#22320)

* fix adding post-deployment script and existing item (#22317)

* Test cleanup for .sqlproj content operations (#22330)

* Fixing up tests

* sqlproj content operations tests

* remove only

* Cleanup

* Correcting collation

* cleanup constants.ts (#22336)

* fix folders not showing in project tree (#22319)

* Fix project controller tests (#22327)

* fixing ProjectController tests after swap

* remove only from database reference tests

* change system dbs back to lowercase in sql projects (#22353)

* Bump tools service

* Updated yarn.lock file

* pass SystemDacpacsLocation when building legacy style sql projects (#22329)

* Benjin/fix types (#22365)

* Updated yarn.lock file

* Fixing types

* fix projectController tests (#22375)

* Fixing the deletion flow for files and folders (#22366)

* checkpoint

* PR feedback

* Fixing up SDK-style operations project test group (#22377)

* Fixing up SDK-style project test group

* Removing .only

* Fixing up database reference tests (#22380)

* Fixing DB reference test group

* Extra cleanup

* removing only

* Consolidating None and PublishProfile; lighting up test (#22382)

* Lighting up project property tests (#22395)

* Checkpoint

* Lighting up project property tests

* removing timeout

* Fixing buildHelper test (#22400)

* Unskipping up roundtrip test (#22397)

* Refactoring database references to split literalVariable from databaseName (#22412)

* refactoring database references to split databaseVariableLiteralValue out from databaseName

* renaming more properties

* Removing branch in entry population

* removing only

* Fixing baselines for delete test

* PR feedback

* Fixing up ProjectTree tests (#22419)

* Fixing up projectTree tests

* remove only

* Updating projectController exclude test (#22413)

* Updating test

* moving filtering for external folders to readFolders() method

* Removing EntryType import

* fix ups (#22435)

* adding extra info for test failure

* hide exclude folder from context menu until it's supported (#22454)

* Adding current test name to generated folder to avoid conflicts (#22478)

* Adding current test name to generated folder to avoid conflicts

* passing correct test parameter in

* Adding trimming and entropy

* Deleting unused baselines (#22497)

* Replacing addToProject() with addSqlObjectScripts() (#22489)

* checkpoint

* Fixing test

* Updating file scraper function to filter only to .sql files (no folders, no txt)

* changing var names to reflect that the lists only contain .sql scripts

---------

Co-authored-by: Kim Santiago <31145923+kisantia@users.noreply.github.com>
Co-authored-by: AkshayMata <akam520@gmail.com>
Co-authored-by: Cheena Malhotra <13396919+cheenamalhotra@users.noreply.github.com>
Co-authored-by: Charles Gagnon <chgagnon@microsoft.com>
Co-authored-by: Alex Ma <alma1@microsoft.com>
This commit is contained in:
Benjin Dubishar
2023-03-28 13:39:57 -07:00
committed by GitHub
parent a7ecff77dd
commit 15c0c68e44
58 changed files with 2157 additions and 5084 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -908,10 +908,6 @@ export interface AddSqlCmdVariableParams extends SqlProjectParams {
* Default value of the SQLCMD variable * Default value of the SQLCMD variable
*/ */
defaultValue: string; defaultValue: string;
/**
* Value of the SQLCMD variable, with or without the $()
*/
value: string;
} }
export interface DeleteSqlCmdVariableParams extends SqlProjectParams { export interface DeleteSqlCmdVariableParams extends SqlProjectParams {

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

@@ -490,9 +490,8 @@ declare module 'mssql' {
* @param projectUri Absolute path of the project, including .sqlproj * @param projectUri Absolute path of the project, including .sqlproj
* @param name Name of the SQLCMD variable * @param name Name of the SQLCMD variable
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $()
*/ */
addSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<azdata.ResultStatus>; addSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<azdata.ResultStatus>;
/** /**
* Delete a SQLCMD variable from a project * Delete a SQLCMD variable from a project
@@ -506,9 +505,8 @@ declare module 'mssql' {
* @param projectUri Absolute path of the project, including .sqlproj * @param projectUri Absolute path of the project, including .sqlproj
* @param name Name of the SQLCMD variable * @param name Name of the SQLCMD variable
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $()
*/ */
updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<azdata.ResultStatus>; updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<azdata.ResultStatus>;
/** /**
* Add a SQL object script to a project * Add a SQL object script to a project
@@ -570,7 +568,7 @@ declare module 'mssql' {
getSqlCmdVariables(projectUri: string): Promise<GetSqlCmdVariablesResult>; getSqlCmdVariables(projectUri: string): Promise<GetSqlCmdVariablesResult>;
/** /**
* getSqlObjectScripts * Get all the SQL object scripts in a project
* @param projectUri Absolute path of the project, including .sqlproj * @param projectUri Absolute path of the project, including .sqlproj
*/ */
getSqlObjectScripts(projectUri: string): Promise<GetScriptsResult>; getSqlObjectScripts(projectUri: string): Promise<GetScriptsResult>;
@@ -708,7 +706,7 @@ declare module 'mssql' {
} }
interface UserDatabaseReference extends DatabaseReference { interface UserDatabaseReference extends DatabaseReference {
databaseVariable: SqlCmdVariable; databaseVariable?: SqlCmdVariable;
serverVariable?: SqlCmdVariable; serverVariable?: SqlCmdVariable;
} }
@@ -726,13 +724,8 @@ declare module 'mssql' {
} }
export const enum SystemDatabase { export const enum SystemDatabase {
master = 0, Master = 0,
msdb = 1 MSDB = 1
}
export const enum ProjectType {
sdkStyle = 0,
legacyStyle = 1
} }
export interface SqlCmdVariable { export interface SqlCmdVariable {

8
extensions/mssql/src/sqlProjects/sqlProjectsService.ts
View File

@@ -274,8 +274,8 @@ export class SqlProjectsService implements mssql.ISqlProjectsService {
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $() * @param value Value of the SQLCMD variable, with or without the $()
*/ */
public async addSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<azdata.ResultStatus> { public async addSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<azdata.ResultStatus> {
const params: contracts.AddSqlCmdVariableParams = { projectUri: projectUri, name: name, defaultValue: defaultValue, value: value }; const params: contracts.AddSqlCmdVariableParams = { projectUri: projectUri, name: name, defaultValue: defaultValue };
return await this.runWithErrorHandling(contracts.AddSqlCmdVariableRequest.type, params); return await this.runWithErrorHandling(contracts.AddSqlCmdVariableRequest.type, params);
} }
@@ -296,8 +296,8 @@ export class SqlProjectsService implements mssql.ISqlProjectsService {
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $() * @param value Value of the SQLCMD variable, with or without the $()
*/ */
public async updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<azdata.ResultStatus> { public async updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<azdata.ResultStatus> {
const params: contracts.AddSqlCmdVariableParams = { projectUri: projectUri, name: name, defaultValue: defaultValue, value: value }; const params: contracts.AddSqlCmdVariableParams = { projectUri: projectUri, name: name, defaultValue: defaultValue };
return await this.runWithErrorHandling(contracts.UpdateSqlCmdVariableRequest.type, params); return await this.runWithErrorHandling(contracts.UpdateSqlCmdVariableRequest.type, params);
} }

11
extensions/sql-database-projects/package.json
View File

@@ -188,11 +188,6 @@
"title": "%sqlDatabaseProjects.generateProjectFromOpenApiSpec%", "title": "%sqlDatabaseProjects.generateProjectFromOpenApiSpec%",
"category": "%sqlDatabaseProjects.displayName%" "category": "%sqlDatabaseProjects.displayName%"
}, },
{
"command": "sqlDatabaseProjects.convertToSdkStyleProject",
"title": "%sqlDatabaseProjects.convertToSdkStyleProject%",
"category": "%sqlDatabaseProjects.displayName%"
},
{ {
"command": "sqlDatabaseProjects.openInDesigner", "command": "sqlDatabaseProjects.openInDesigner",
"title": "%sqlDatabaseProjects.openInDesigner%", "title": "%sqlDatabaseProjects.openInDesigner%",
@@ -320,10 +315,6 @@
"command": "sqlDatabaseProjects.changeTargetPlatform", "command": "sqlDatabaseProjects.changeTargetPlatform",
"when": "false" "when": "false"
}, },
{
"command": "sqlDatabaseProjects.convertToSdkStyleProject",
"when": "false"
},
{ {
"command": "sqlDatabaseProjects.openInDesigner", "command": "sqlDatabaseProjects.openInDesigner",
"when": "false" "when": "false"
@@ -428,7 +419,7 @@
}, },
{ {
"command": "sqlDatabaseProjects.exclude", "command": "sqlDatabaseProjects.exclude",
"when": "view == dataworkspace.views.main && viewItem == databaseProject.itemType.folder || viewItem =~ /^databaseProject.itemType.file/", "when": "view == dataworkspace.views.main && viewItem =~ /^databaseProject.itemType.file/",
"group": "9_dbProjectsLast@1" "group": "9_dbProjectsLast@1"
}, },
{ {

143
extensions/sql-database-projects/src/common/constants.ts
View File

@@ -10,23 +10,26 @@ import * as utils from '../common/utils';
const localize = nls.loadMessageBundle(); const localize = nls.loadMessageBundle();
// Placeholder values //#region file extensions
export const dataSourcesFileName = 'datasources.json'; export const dataSourcesFileName = 'datasources.json';
export const sqlprojExtension = '.sqlproj'; export const sqlprojExtension = '.sqlproj';
export const sqlFileExtension = '.sql'; export const sqlFileExtension = '.sql';
export const publishProfileExtension = '.publish.xml'; export const publishProfileExtension = '.publish.xml';
export const openApiSpecFileExtensions = ['yaml', 'yml', 'json']; export const openApiSpecFileExtensions = ['yaml', 'yml', 'json'];
//#endregion
//#region Placeholder values
export const schemaCompareExtensionId = 'microsoft.schema-compare'; export const schemaCompareExtensionId = 'microsoft.schema-compare';
export const master = 'master'; export const master = 'master';
export const masterDacpac = 'master.dacpac';
export const msdb = 'msdb'; export const msdb = 'msdb';
export const msdbDacpac = 'msdb.dacpac';
export const MicrosoftDatatoolsSchemaSqlSql = 'Microsoft.Data.Tools.Schema.Sql.Sql'; export const MicrosoftDatatoolsSchemaSqlSql = 'Microsoft.Data.Tools.Schema.Sql.Sql';
export const databaseSchemaProvider = 'DatabaseSchemaProvider'; export const databaseSchemaProvider = 'DatabaseSchemaProvider';
export const sqlProjectSdk = 'Microsoft.Build.Sql'; export const sqlProjectSdk = 'Microsoft.Build.Sql';
export const sqlProjectSdkVersion = '0.1.7-preview';
// Project Provider //#endregion
//#region Project Provider
export const emptySqlDatabaseProjectTypeId = 'EmptySqlDbProj'; export const emptySqlDatabaseProjectTypeId = 'EmptySqlDbProj';
export const emptyProjectTypeDisplayName = localize('emptyProjectTypeDisplayName', "SQL Server Database"); export const emptyProjectTypeDisplayName = localize('emptyProjectTypeDisplayName', "SQL Server Database");
export const emptyProjectTypeDescription = localize('emptyProjectTypeDescription', "Develop and publish schemas for SQL Server databases starting from an empty project"); export const emptyProjectTypeDescription = localize('emptyProjectTypeDescription', "Develop and publish schemas for SQL Server databases starting from an empty project");
@@ -43,7 +46,9 @@ export const emptyAzureDbSqlDatabaseProjectTypeId = 'EmptyAzureSqlDbProj';
export const emptyAzureDbProjectTypeDisplayName = localize('emptyAzureDbProjectTypeDisplayName', "Azure SQL Database"); export const emptyAzureDbProjectTypeDisplayName = localize('emptyAzureDbProjectTypeDisplayName', "Azure SQL Database");
export const emptyAzureDbProjectTypeDescription = localize('emptyAzureDbProjectTypeDescription', "Develop and publish schemas for Azure SQL Database starting from an empty project"); export const emptyAzureDbProjectTypeDescription = localize('emptyAzureDbProjectTypeDescription', "Develop and publish schemas for Azure SQL Database starting from an empty project");
// Dashboard //#endregion
//#region Dashboard
export const addItemAction = localize('addItemAction', "Add Item"); export const addItemAction = localize('addItemAction', "Add Item");
export const schemaCompareAction = localize('schemaCompareAction', "Schema Compare"); export const schemaCompareAction = localize('schemaCompareAction', "Schema Compare");
export const buildAction = localize('buildAction', "Build"); export const buildAction = localize('buildAction', "Build");
@@ -70,14 +75,18 @@ export const msec = localize('msec', "msec");
export const at = localize('at', "at"); export const at = localize('at', "at");
// commands //#endregion
//#region commands
export const revealFileInOsCommand = 'revealFileInOS'; export const revealFileInOsCommand = 'revealFileInOS';
export const schemaCompareStartCommand = 'schemaCompare.start'; export const schemaCompareStartCommand = 'schemaCompare.start';
export const schemaCompareRunComparisonCommand = 'schemaCompare.runComparison'; export const schemaCompareRunComparisonCommand = 'schemaCompare.runComparison';
export const vscodeOpenCommand = 'vscode.open'; export const vscodeOpenCommand = 'vscode.open';
export const refreshDataWorkspaceCommand = 'dataworkspace.refresh'; export const refreshDataWorkspaceCommand = 'dataworkspace.refresh';
// UI Strings //#endregion
//#region UI Strings
export const databaseReferencesNodeName = localize('databaseReferencesNodeName', "Database References"); export const databaseReferencesNodeName = localize('databaseReferencesNodeName', "Database References");
export const sqlcmdVariablesNodeName = localize('sqlcmdVariablesNodeName', "SQLCMD Variables"); export const sqlcmdVariablesNodeName = localize('sqlcmdVariablesNodeName', "SQLCMD Variables");
export const sqlConnectionStringFriendly = localize('sqlConnectionStringFriendly', "SQL connection string"); export const sqlConnectionStringFriendly = localize('sqlConnectionStringFriendly', "SQL connection string");
@@ -112,8 +121,11 @@ export function projectUpdatedToSdkStyle(projectName: string) { return localize(
export function convertToSdkStyleConfirmation(projectName: string) { return localize('convertToSdkStyleConfirmation', "The project '{0}' will not be fully compatible with SSDT after conversion. A backup copy of the project file will be created in the project folder prior to conversion. More information is available at https://aka.ms/sqlprojsdk. Continue with converting to SDK-style project?", projectName); } export function convertToSdkStyleConfirmation(projectName: string) { return localize('convertToSdkStyleConfirmation', "The project '{0}' will not be fully compatible with SSDT after conversion. A backup copy of the project file will be created in the project folder prior to conversion. More information is available at https://aka.ms/sqlprojsdk. Continue with converting to SDK-style project?", projectName); }
export function updatedToSdkStyleError(projectName: string) { return localize('updatedToSdkStyleError', "Converting the project {0} to SDK-style was unsuccessful. Changes to the .sqlproj have been rolled back.", projectName); } export function updatedToSdkStyleError(projectName: string) { return localize('updatedToSdkStyleError', "Converting the project {0} to SDK-style was unsuccessful. Changes to the .sqlproj have been rolled back.", projectName); }
export const enterNewName = localize('enterNewName', "Enter new name"); export const enterNewName = localize('enterNewName', "Enter new name");
//#endregion
// Publish dialog strings export const reservedProjectFolders = ['Properties', 'SQLCMD Variables', 'Database References'];
//#region Publish dialog strings
export const publishDialogName = localize('publishDialogName', "Publish project"); export const publishDialogName = localize('publishDialogName', "Publish project");
export const publish = localize('publish', "Publish"); export const publish = localize('publish', "Publish");
export const cancelButtonText = localize('cancelButtonText', "Cancel"); export const cancelButtonText = localize('cancelButtonText', "Cancel");
@@ -152,7 +164,9 @@ export const selectDatabase = localize('selectDatabase', "Select database");
export const done = localize('done', "Done"); export const done = localize('done', "Done");
export const nameMustNotBeEmpty = localize('nameMustNotBeEmpty', "Name must not be empty"); export const nameMustNotBeEmpty = localize('nameMustNotBeEmpty', "Name must not be empty");
// Publish Dialog options //#endregion
//#region Publish Dialog options
export const AdvancedOptionsButton = localize('advancedOptionsButton', 'Advanced...'); export const AdvancedOptionsButton = localize('advancedOptionsButton', 'Advanced...');
export const AdvancedPublishOptions = localize('advancedPublishOptions', 'Advanced Publish Options'); export const AdvancedPublishOptions = localize('advancedPublishOptions', 'Advanced Publish Options');
export const PublishOptions = localize('publishOptions', 'Publish Options'); export const PublishOptions = localize('publishOptions', 'Publish Options');
@@ -163,7 +177,9 @@ export const OptionName: string = localize('optionName', "Option Name");
export const OptionInclude: string = localize('include', "Include"); export const OptionInclude: string = localize('include', "Include");
export function OptionNotFoundWarningMessage(label: string) { return localize('optionNotFoundWarningMessage', "label: {0} does not exist in the options value name lookup", label); } export function OptionNotFoundWarningMessage(label: string) { return localize('optionNotFoundWarningMessage', "label: {0} does not exist in the options value name lookup", label); }
// Deploy //#endregion
//#region Deploy
export const SqlServerName = 'SQL server'; export const SqlServerName = 'SQL server';
export const AzureSqlServerName = 'Azure SQL server'; export const AzureSqlServerName = 'Azure SQL server';
export const SqlServerDockerImageName = 'Microsoft SQL Server'; export const SqlServerDockerImageName = 'Microsoft SQL Server';
@@ -206,7 +222,9 @@ export const dockerImageLabelPrefix = 'source=sqldbproject';
export const dockerImageNamePrefix = 'sqldbproject'; export const dockerImageNamePrefix = 'sqldbproject';
export const dockerImageDefaultTag = 'latest'; export const dockerImageDefaultTag = 'latest';
// Publish to Container //#endregion
//#region Publish to Container
export const eulaAgreementTemplate = localize({ key: 'eulaAgreementTemplate', comment: ['The placeholders are contents of the line and should not be translated.'] }, "I accept the {0}."); export const eulaAgreementTemplate = localize({ key: 'eulaAgreementTemplate', comment: ['The placeholders are contents of the line and should not be translated.'] }, "I accept the {0}.");
export function eulaAgreementText(name: string) { return localize({ key: 'eulaAgreementText', comment: ['The placeholders are contents of the line and should not be translated.'] }, "I accept the {0}.", name); } export function eulaAgreementText(name: string) { return localize({ key: 'eulaAgreementText', comment: ['The placeholders are contents of the line and should not be translated.'] }, "I accept the {0}.", name); }
export const eulaAgreementTitle = localize('eulaAgreementTitle', "Microsoft SQL Server License Agreement"); export const eulaAgreementTitle = localize('eulaAgreementTitle', "Microsoft SQL Server License Agreement");
@@ -262,8 +280,9 @@ export function retrySucceedMessage(name: string, result: string) { return local
export function retryFailedMessage(name: string, result: string, error: string) { return localize('retryFailedMessage', "Operation '{0}' failed. Re-trying... Current Result: {1}. Error: '{2}'", name, result, error); } export function retryFailedMessage(name: string, result: string, error: string) { return localize('retryFailedMessage', "Operation '{0}' failed. Re-trying... Current Result: {1}. Error: '{2}'", name, result, error); }
export function retryMessage(name: string, error: string) { return localize('retryMessage', "Operation '{0}' failed. Re-trying... Error: '{1}' ", name, error); } export function retryMessage(name: string, error: string) { return localize('retryMessage', "Operation '{0}' failed. Re-trying... Error: '{1}' ", name, error); }
// Add Database Reference dialog strings //#endregion
//#region Add Database Reference dialog strings
export const addDatabaseReferenceDialogName = localize('addDatabaseReferencedialogName', "Add database reference"); export const addDatabaseReferenceDialogName = localize('addDatabaseReferencedialogName', "Add database reference");
export const addDatabaseReferenceOkButtonText = localize('addDatabaseReferenceOkButtonText', "Add reference"); export const addDatabaseReferenceOkButtonText = localize('addDatabaseReferenceOkButtonText', "Add reference");
export const referenceRadioButtonsGroupTitle = localize('referenceRadioButtonsGroupTitle', "Type"); export const referenceRadioButtonsGroupTitle = localize('referenceRadioButtonsGroupTitle', "Type");
@@ -291,8 +310,13 @@ export const databaseProject = localize('databaseProject', "Database project");
export const dacpacMustBeOnSameDrive = localize('dacpacNotOnSameDrive', "Dacpac references need to be located on the same drive as the project file."); export const dacpacMustBeOnSameDrive = localize('dacpacNotOnSameDrive', "Dacpac references need to be located on the same drive as the project file.");
export const dacpacNotOnSameDrive = (projectLocation: string): string => { return localize('dacpacNotOnSameDrive', "Dacpac references need to be located on the same drive as the project file. The project file is located at {0}", projectLocation); }; export const dacpacNotOnSameDrive = (projectLocation: string): string => { return localize('dacpacNotOnSameDrive', "Dacpac references need to be located on the same drive as the project file. The project file is located at {0}", projectLocation); };
export const referenceType = localize('referenceType', "Reference type"); export const referenceType = localize('referenceType', "Reference type");
export const excludeFolderNotSupported = localize('excludeFolderNotSupported', "Excluding folders is not yet supported");
export const unhandledDeleteType = (itemType: string): string => { return localize('unhandledDeleteType', "Unhandled item type during delete: '{0}", itemType); }
export const unhandledExcludeType = (itemType: string): string => { return localize('unhandledDeleteType', "Unhandled item type during exclude: '{0}", itemType); }
// Create Project From Database dialog strings //#endregion
//#region Create Project From Database dialog strings
export const createProjectFromDatabaseDialogName = localize('createProjectFromDatabaseDialogName', "Create project from database"); export const createProjectFromDatabaseDialogName = localize('createProjectFromDatabaseDialogName', "Create project from database");
export const createProjectDialogOkButtonText = localize('createProjectDialogOkButtonText', "Create"); export const createProjectDialogOkButtonText = localize('createProjectDialogOkButtonText', "Create");
export const sourceDatabase = localize('sourceDatabase', "Source database"); export const sourceDatabase = localize('sourceDatabase', "Source database");
@@ -307,7 +331,6 @@ export const selectFolderStructure = localize('selectFolderStructure', "Select f
export const folderStructureLabel = localize('folderStructureLabel', "Folder structure"); export const folderStructureLabel = localize('folderStructureLabel', "Folder structure");
export const includePermissionsLabel = localize('includePermissionsLabel', "Include permissions"); export const includePermissionsLabel = localize('includePermissionsLabel', "Include permissions");
export const includePermissionsInProject = localize('includePermissionsInProject', "Include permissions in project"); export const includePermissionsInProject = localize('includePermissionsInProject', "Include permissions in project");
export const WorkspaceFileExtension = '.code-workspace';
export const browseEllipsisWithIcon = `$(folder) ${localize('browseEllipsis', "Browse...")}`; export const browseEllipsisWithIcon = `$(folder) ${localize('browseEllipsis', "Browse...")}`;
export const selectProjectLocation = localize('selectProjectLocation', "Select project location"); export const selectProjectLocation = localize('selectProjectLocation', "Select project location");
export const sdkStyleProject = localize('sdkStyleProject', 'SDK-style project (Preview)'); export const sdkStyleProject = localize('sdkStyleProject', 'SDK-style project (Preview)');
@@ -316,8 +339,9 @@ export const SdkLearnMorePlaceholder = localize('sdkLearnMorePlaceholder', "Clic
export const ProjectParentDirectoryNotExistError = (location: string): string => { return localize('dataworkspace.projectParentDirectoryNotExistError', "The selected project location '{0}' does not exist or is not a directory.", location); }; export const ProjectParentDirectoryNotExistError = (location: string): string => { return localize('dataworkspace.projectParentDirectoryNotExistError', "The selected project location '{0}' does not exist or is not a directory.", location); };
export const ProjectDirectoryAlreadyExistError = (projectName: string, location: string): string => { return localize('dataworkspace.projectDirectoryAlreadyExistError', "There is already a directory named '{0}' in the selected location: '{1}'.", projectName, location); }; export const ProjectDirectoryAlreadyExistError = (projectName: string, location: string): string => { return localize('dataworkspace.projectDirectoryAlreadyExistError', "There is already a directory named '{0}' in the selected location: '{1}'.", projectName, location); };
// Update Project From Database dialog strings //#endregion
//#region Update Project From Database dialog strings
export const updateProjectFromDatabaseDialogName = localize('updateProjectFromDatabaseDialogName', "Update project from database"); export const updateProjectFromDatabaseDialogName = localize('updateProjectFromDatabaseDialogName', "Update project from database");
export const updateText = localize('updateText', "Update"); export const updateText = localize('updateText', "Update");
export const noSqlProjFile = localize('noSqlProjFile', "The selected project file does not exist"); export const noSqlProjFile = localize('noSqlProjFile', "The selected project file does not exist");
@@ -329,15 +353,18 @@ export const updateActionRadioButtonLabel = localize('updateActionRadiButtonLabe
export const actionLabel = localize('actionLabel', "Action"); export const actionLabel = localize('actionLabel', "Action");
export const applyConfirmation: string = localize('applyConfirmation', "Are you sure you want to update the target project?"); export const applyConfirmation: string = localize('applyConfirmation', "Are you sure you want to update the target project?");
// Update project from database //#endregion
//#region Update project from database
export const applySuccess = localize('applySuccess', "Project was successfully updated."); export const applySuccess = localize('applySuccess', "Project was successfully updated.");
export const equalComparison = localize('equalComparison', "The project is already up to date with the database."); export const equalComparison = localize('equalComparison', "The project is already up to date with the database.");
export function applyError(errorMessage: string): string { return localize('applyError', "There was an error updating the project: {0}", errorMessage); } export function applyError(errorMessage: string): string { return localize('applyError', "There was an error updating the project: {0}", errorMessage); }
export function updatingProjectFromDatabase(projectName: string, databaseName: string): string { return localize('updatingProjectFromDatabase', "Updating {0} from {1}...", projectName, databaseName); } export function updatingProjectFromDatabase(projectName: string, databaseName: string): string { return localize('updatingProjectFromDatabase', "Updating {0} from {1}...", projectName, databaseName); }
// Error messages //#endregion
//#region Error messages
export function errorPrefix(errorMessage: string): string { return localize('errorPrefix', "Error: {0}", errorMessage); }
export function compareErrorMessage(errorMessage: string): string { return localize('schemaCompare.compareErrorMessage', "Schema Compare failed: {0}", errorMessage ? errorMessage : 'Unknown'); } export function compareErrorMessage(errorMessage: string): string { return localize('schemaCompare.compareErrorMessage', "Schema Compare failed: {0}", errorMessage ? errorMessage : 'Unknown'); }
export const multipleSqlProjFiles = localize('multipleSqlProjFilesSelected', "Multiple .sqlproj files selected; please select only one."); export const multipleSqlProjFiles = localize('multipleSqlProjFilesSelected', "Multiple .sqlproj files selected; please select only one.");
export const noSqlProjFiles = localize('noSqlProjFilesSelected', "No .sqlproj file selected; please select one."); export const noSqlProjFiles = localize('noSqlProjFilesSelected', "No .sqlproj file selected; please select one.");
@@ -391,7 +418,11 @@ export function unableToFindSqlCmdVariable(variableName: string) { return locali
export function unableToFindDatabaseReference(reference: string) { return localize('unableToFindReference', "Unable to find database reference {0}", reference); } export function unableToFindDatabaseReference(reference: string) { return localize('unableToFindReference', "Unable to find database reference {0}", reference); }
export function invalidGuid(guid: string) { return localize('invalidGuid', "Specified GUID is invalid: {0}", guid); } export function invalidGuid(guid: string) { return localize('invalidGuid', "Specified GUID is invalid: {0}", guid); }
export function invalidTargetPlatform(targetPlatform: string, supportedTargetPlatforms: string[]) { return localize('invalidTargetPlatform', "Invalid target platform: {0}. Supported target platforms: {1}", targetPlatform, supportedTargetPlatforms.toString()); } export function invalidTargetPlatform(targetPlatform: string, supportedTargetPlatforms: string[]) { return localize('invalidTargetPlatform', "Invalid target platform: {0}. Supported target platforms: {1}", targetPlatform, supportedTargetPlatforms.toString()); }
export function errorReadingProject(section: string, path: string) { return localize('errorReadingProjectGuid', "Error trying to read {0} of project '{1}'", section, path); } export function errorReadingProject(section: string, path: string, error?: string) { return localize('errorReadingProjectGuid', "Error trying to read {0} of project '{1}'. {2}", section, path, error); }
export function errorAddingDatabaseReference(referenceName: string, error: string) { return localize('errorAddingDatabaseReference', "Error adding database reference to {0}. Error: {1}", referenceName, error); }
export function errorNotSupportedInVsCode(actionDescription: string) { return localize('errorNotSupportedInVsCode', "Error: {0} is not currently supported in SQL Database Projects for VS Code.", actionDescription); }
//#endregion
// Action types // Action types
export const deleteAction = localize('deleteAction', 'Delete'); export const deleteAction = localize('deleteAction', 'Delete');
@@ -401,8 +432,7 @@ export const excludeAction = localize('excludeAction', 'Exclude');
export const fileObject = localize('fileObject', "file"); export const fileObject = localize('fileObject', "file");
export const folderObject = localize('folderObject', "folder"); export const folderObject = localize('folderObject', "folder");
// Project script types //#region Project script types
export const folderFriendlyName = localize('folderFriendlyName', "Folder"); export const folderFriendlyName = localize('folderFriendlyName', "Folder");
export const scriptFriendlyName = localize('scriptFriendlyName', "Script"); export const scriptFriendlyName = localize('scriptFriendlyName', "Script");
export const tableFriendlyName = localize('tableFriendlyName', "Table"); export const tableFriendlyName = localize('tableFriendlyName', "Table");
@@ -415,18 +445,21 @@ export const externalStreamingJobFriendlyName = localize('externalStreamingJobFr
export const preDeployScriptFriendlyName = localize('preDeployScriptFriendlyName', "Script.PreDeployment"); export const preDeployScriptFriendlyName = localize('preDeployScriptFriendlyName', "Script.PreDeployment");
export const postDeployScriptFriendlyName = localize('postDeployScriptFriendlyName', "Script.PostDeployment"); export const postDeployScriptFriendlyName = localize('postDeployScriptFriendlyName', "Script.PostDeployment");
// Build //#endregion
//#region Build
export const DotnetInstallationConfirmation: string = localize('sqlDatabaseProjects.DotnetInstallationConfirmation', "The .NET SDK cannot be located. Project build will not work. Please install .NET 6 SDK or higher or update the .NET SDK location in settings if already installed."); export const DotnetInstallationConfirmation: string = localize('sqlDatabaseProjects.DotnetInstallationConfirmation', "The .NET SDK cannot be located. Project build will not work. Please install .NET 6 SDK or higher or update the .NET SDK location in settings if already installed.");
export function NetCoreSupportedVersionInstallationConfirmation(installedVersion: string) { return localize('sqlDatabaseProjects.NetCoreSupportedVersionInstallationConfirmation', "Currently installed .NET SDK version is {0}, which is not supported. Project build will not work. Please install .NET 6 SDK or higher or update the .NET SDK supported version location in settings if already installed.", installedVersion); } export function NetCoreSupportedVersionInstallationConfirmation(installedVersion: string) { return localize('sqlDatabaseProjects.NetCoreSupportedVersionInstallationConfirmation', "Currently installed .NET SDK version is {0}, which is not supported. Project build will not work. Please install .NET 6 SDK or higher or update the .NET SDK supported version location in settings if already installed.", installedVersion); }
export const UpdateDotnetLocation: string = localize('sqlDatabaseProjects.UpdateDotnetLocation', "Update Location"); export const UpdateDotnetLocation: string = localize('sqlDatabaseProjects.UpdateDotnetLocation', "Update Location");
export const projectsOutputChannel = localize('sqlDatabaseProjects.outputChannel', "Database Projects"); export const projectsOutputChannel = localize('sqlDatabaseProjects.outputChannel', "Database Projects");
//#endregion
// Prompt buttons // Prompt buttons
export const Install: string = localize('sqlDatabaseProjects.Install', "Install"); export const Install: string = localize('sqlDatabaseProjects.Install', "Install");
export const DoNotAskAgain: string = localize('sqlDatabaseProjects.doNotAskAgain', "Don't Ask Again"); export const DoNotAskAgain: string = localize('sqlDatabaseProjects.doNotAskAgain', "Don't Ask Again");
// SqlProj file XML names //#region SqlProj file XML names
export const ItemGroup = 'ItemGroup'; export const ItemGroup = 'ItemGroup';
export const Build = 'Build'; export const Build = 'Build';
export const Folder = 'Folder'; export const Folder = 'Folder';
@@ -486,11 +519,9 @@ export const ProjectReferenceElement = localize('projectReferenceElement', "Proj
export const DacpacReferenceElement = localize('dacpacReferenceElement', "Dacpac reference"); export const DacpacReferenceElement = localize('dacpacReferenceElement', "Dacpac reference");
export const PublishProfileElements = localize('publishProfileElements', "Publish profile elements"); export const PublishProfileElements = localize('publishProfileElements', "Publish profile elements");
/** Name of the property item in the project file that defines default database collation. */ //#endregion
export const DefaultCollationProperty = 'DefaultCollation';
/** Default database collation to use when none is specified in the project */
export const DefaultCollation = 'SQL_Latin1_General_CP1_CI_AS';
/** /**
* Well-known database source values that are allowed to be sent in telemetry. * Well-known database source values that are allowed to be sent in telemetry.
@@ -500,34 +531,8 @@ export const DefaultCollation = 'SQL_Latin1_General_CP1_CI_AS';
*/ */
export const WellKnownDatabaseSources = ['dsct-oracle-to-ms-sql']; export const WellKnownDatabaseSources = ['dsct-oracle-to-ms-sql'];
// SqlProj File targets
export const NetCoreTargets = '$(NETCoreTargetsPath)\\Microsoft.Data.Tools.Schema.SqlTasks.targets';
export const SqlDbTargets = '$(SQLDBExtensionsRefPath)\\Microsoft.Data.Tools.Schema.SqlTasks.targets';
export const MsBuildtargets = '$(MSBuildExtensionsPath)\\Microsoft\\VisualStudio\\v$(VisualStudioVersion)\\SSDT\\Microsoft.Data.Tools.Schema.SqlTasks.targets';
export const NetCoreCondition = '\'$(NetCoreBuild)\' == \'true\'';
export const NotNetCoreCondition = '\'$(NetCoreBuild)\' != \'true\'';
export const SqlDbPresentCondition = '\'$(SQLDBExtensionsRefPath)\' != \'\'';
export const SqlDbNotPresentCondition = '\'$(SQLDBExtensionsRefPath)\' == \'\'';
export const RoundTripSqlDbPresentCondition = '\'$(NetCoreBuild)\' != \'true\' AND \'$(SQLDBExtensionsRefPath)\' != \'\'';
export const RoundTripSqlDbNotPresentCondition = '\'$(NetCoreBuild)\' != \'true\' AND \'$(SQLDBExtensionsRefPath)\' == \'\'';
export const DacpacRootPath = '$(DacPacRootPath)';
export const ProjJsonToClean = '$(BaseIntermediateOutputPath)\\project.assets.json';
export const EmptyConfigurationCondition = '\'$(Configuration)\' == \'\'';
export const EmptyPlatformCondition = '\'$(Platform)\' == \'\'';
export function ConfigurationPlatformCondition(configuration: string, platform: string) { return `'$(Configuration)|$(Platform)' == '${configuration}|${platform}'`; }
export function defaultOutputPath(configuration: string) { return path.join('.', 'bin', configuration); } export function defaultOutputPath(configuration: string) { return path.join('.', 'bin', configuration); }
// Sqlproj VS property conditions
export const VSVersionCondition = '\'$(VisualStudioVersion)\' == \'\'';
export const SsdtExistsCondition = '\'$(SSDTExists)\' == \'\'';
export const targetsExistsCondition = 'Exists(\'$(MSBuildExtensionsPath)\\Microsoft\\VisualStudio\\v$(VisualStudioVersion)\\SSDT\\Microsoft.Data.Tools.Schema.SqlTasks.targets\')';
// SqlProj Reference Assembly Information
export const NETFrameworkAssembly = 'Microsoft.NETFramework.ReferenceAssemblies';
export const VersionNumber = '1.0.0';
export const All = 'All';
/** /**
* Path separator to use within SqlProj file for `Include`, `Exclude`, etc. attributes. * Path separator to use within SqlProj file for `Include`, `Exclude`, etc. attributes.
* This matches Windows path separator, as expected by SSDT. * This matches Windows path separator, as expected by SSDT.
@@ -538,7 +543,7 @@ export const SqlProjPathSeparator = '\\';
export const targetDatabaseName = 'TargetDatabaseName'; export const targetDatabaseName = 'TargetDatabaseName';
export const targetConnectionString = 'TargetConnectionString'; export const targetConnectionString = 'TargetConnectionString';
// SQL connection string components //#region SQL connection string components
export const initialCatalogSetting = 'Initial Catalog'; export const initialCatalogSetting = 'Initial Catalog';
export const dataSourceSetting = 'Data Source'; export const dataSourceSetting = 'Data Source';
export const integratedSecuritySetting = 'Integrated Security'; export const integratedSecuritySetting = 'Integrated Security';
@@ -551,8 +556,9 @@ export const trustServerCertificateSetting = 'Trust Server Certificate';
export const hostnameInCertificateSetting = 'Host Name in Certificate'; export const hostnameInCertificateSetting = 'Host Name in Certificate';
export const azureAddAccount = localize('azureAddAccount', "Add an Account..."); export const azureAddAccount = localize('azureAddAccount', "Add an Account...");
//#endregion
// Tree item types //#region Tree item types
export enum DatabaseProjectItemType { export enum DatabaseProjectItemType {
project = 'databaseProject.itemType.project', project = 'databaseProject.itemType.project',
legacyProject = 'databaseProject.itemType.legacyProject', legacyProject = 'databaseProject.itemType.legacyProject',
@@ -572,7 +578,9 @@ export enum DatabaseProjectItemType {
publishProfile = 'databaseProject.itemType.file.publishProfile' publishProfile = 'databaseProject.itemType.file.publishProfile'
} }
// AutoRest //#endregion
//#region AutoRest
export const autorestPostDeploymentScriptName = 'PostDeploymentScript.sql'; export const autorestPostDeploymentScriptName = 'PostDeploymentScript.sql';
export const nodeButNotAutorestFound = localize('nodeButNotAutorestFound', "Autorest tool not found in system path, but found Node.js. Prompting user for how to proceed. Execute 'npm install autorest -g' to install permanently and avoid this message."); export const nodeButNotAutorestFound = localize('nodeButNotAutorestFound', "Autorest tool not found in system path, but found Node.js. Prompting user for how to proceed. Execute 'npm install autorest -g' to install permanently and avoid this message.");
export const nodeNotFound = localize('nodeNotFound', "Neither Autorest nor Node.js (npx) found in system path. Please install Node.js for Autorest generation to work."); export const nodeNotFound = localize('nodeNotFound', "Neither Autorest nor Node.js (npx) found in system path. Please install Node.js for Autorest generation to work.");
@@ -590,6 +598,7 @@ export function multipleMostDeploymentScripts(count: number) { return localize('
export const specSelectionText = localize('specSelectionText', "OpenAPI/Swagger spec"); export const specSelectionText = localize('specSelectionText', "OpenAPI/Swagger spec");
export const autorestProjectName = localize('autorestProjectName', "New SQL project name"); export const autorestProjectName = localize('autorestProjectName', "New SQL project name");
export function generatingProjectFromAutorest(specName: string) { return localize('generatingProjectFromAutorest', "Generating new SQL project from {0}... Check output window for details.", specName); } export function generatingProjectFromAutorest(specName: string) { return localize('generatingProjectFromAutorest', "Generating new SQL project from {0}... Check output window for details.", specName); }
//#endregion
// System dbs // System dbs
export const systemDbs = ['master', 'msdb', 'tempdb', 'model']; export const systemDbs = ['master', 'msdb', 'tempdb', 'model'];
@@ -598,8 +607,9 @@ export const systemDbs = ['master', 'msdb', 'tempdb', 'model'];
export const sameDatabaseExampleUsage = 'SELECT * FROM [Schema1].[Table1]'; export const sameDatabaseExampleUsage = 'SELECT * FROM [Schema1].[Table1]';
export function differentDbSameServerExampleUsage(db: string) { return `SELECT * FROM [${db}].[Schema1].[Table1]`; } export function differentDbSameServerExampleUsage(db: string) { return `SELECT * FROM [${db}].[Schema1].[Table1]`; }
export function differentDbDifferentServerExampleUsage(server: string, db: string) { return `SELECT * FROM [${server}].[${db}].[Schema1].[Table1]`; } export function differentDbDifferentServerExampleUsage(server: string, db: string) { return `SELECT * FROM [${server}].[${db}].[Schema1].[Table1]`; }
//#endregion
// Target platforms //#region Target platforms
export const targetPlatformToVersion: Map<string, string> = new Map<string, string>([ export const targetPlatformToVersion: Map<string, string> = new Map<string, string>([
[SqlTargetPlatform.sqlServer2012, '110'], [SqlTargetPlatform.sqlServer2012, '110'],
[SqlTargetPlatform.sqlServer2014, '120'], [SqlTargetPlatform.sqlServer2014, '120'],
@@ -635,33 +645,44 @@ export function getTargetPlatformFromVersion(version: string): string {
return Array.from(targetPlatformToVersion.keys()).filter(k => targetPlatformToVersion.get(k) === version)[0]; return Array.from(targetPlatformToVersion.keys()).filter(k => targetPlatformToVersion.get(k) === version)[0];
} }
//#endregion
export enum PublishTargetType { export enum PublishTargetType {
existingServer = 'existingServer', existingServer = 'existingServer',
docker = 'docker', docker = 'docker',
newAzureServer = 'newAzureServer' newAzureServer = 'newAzureServer'
} }
// Configuration keys //#region Configuration keys
export const CollapseProjectNodesKey = 'collapseProjectNodes'; export const CollapseProjectNodesKey = 'collapseProjectNodes';
export const microsoftBuildSqlVersionKey = 'microsoftBuildSqlVersion'; export const microsoftBuildSqlVersionKey = 'microsoftBuildSqlVersion';
export const enablePreviewFeaturesKey = 'enablePreviewFeatures'; export const enablePreviewFeaturesKey = 'enablePreviewFeatures';
// httpClient //#endregion
//#region httpClient
export const downloadError = localize('downloadError', "Download error"); export const downloadError = localize('downloadError', "Download error");
export const downloadProgress = localize('downloadProgress', "Download progress"); export const downloadProgress = localize('downloadProgress', "Download progress");
export const downloading = localize('downloading', "Downloading"); export const downloading = localize('downloading', "Downloading");
// buildHelper //#endregion
//#region buildHelper
export const downloadingDacFxDlls = localize('downloadingDacFxDlls', "Downloading Microsoft.Build.Sql nuget to get build DLLs"); export const downloadingDacFxDlls = localize('downloadingDacFxDlls', "Downloading Microsoft.Build.Sql nuget to get build DLLs");
export function downloadingFromTo(from: string, to: string) { return localize('downloadingFromTo', "Downloading from {0} to {1}", from, to); } export function downloadingFromTo(from: string, to: string) { return localize('downloadingFromTo', "Downloading from {0} to {1}", from, to); }
export function extractingDacFxDlls(location: string) { return localize('extractingDacFxDlls', "Extracting DacFx build DLLs to {0}", location); } export function extractingDacFxDlls(location: string) { return localize('extractingDacFxDlls', "Extracting DacFx build DLLs to {0}", location); }
export function errorDownloading(url: string, error: string) { return localize('errorDownloading', "Error downloading {0}. Error: {1}", url, error); } export function errorDownloading(url: string, error: string) { return localize('errorDownloading', "Error downloading {0}. Error: {1}", url, error); }
export function errorExtracting(path: string, error: string) { return localize('errorExtracting', "Error extracting files from {0}. Error: {1}", path, error); } export function errorExtracting(path: string, error: string) { return localize('errorExtracting', "Error extracting files from {0}. Error: {1}", path, error); }
// move //#endregion
//#region move
export const onlyMoveSqlFilesSupported = localize('onlyMoveSqlFilesSupported', "Only moving .sql files is supported"); export const onlyMoveSqlFilesSupported = localize('onlyMoveSqlFilesSupported', "Only moving .sql files is supported");
export const movingFilesBetweenProjectsNotSupported = localize('movingFilesBetweenProjectsNotSupported', "Moving files between projects is not supported"); export const movingFilesBetweenProjectsNotSupported = localize('movingFilesBetweenProjectsNotSupported', "Moving files between projects is not supported");
export function errorMovingFile(source: string, destination: string, error: string) { return localize('errorMovingFile', "Error when moving file from {0} to {1}. Error: {2}", source, destination, error); } export function errorMovingFile(source: string, destination: string, error: string) { return localize('errorMovingFile', "Error when moving file from {0} to {1}. Error: {2}", source, destination, error); }
export function moveConfirmationPrompt(source: string, destination: string) { return localize('moveConfirmationPrompt', "Are you sure you want to move {0} to {1}?", source, destination); } export function moveConfirmationPrompt(source: string, destination: string) { return localize('moveConfirmationPrompt', "Are you sure you want to move {0} to {1}?", source, destination); }
export const move = localize('Move', "Move"); export const move = localize('Move', "Move");
export function errorRenamingFile(source: string, destination: string, error: string) { return localize('errorRenamingFile', "Error when renaming file from {0} to {1}. Error: {2}", source, destination, error); } export function errorRenamingFile(source: string, destination: string, error: string) { return localize('errorRenamingFile', "Error when renaming file from {0} to {1}. Error: {2}", source, destination, error); }
export const unhandledMoveNode = localize('unhandledMoveNode', "Unhandled node type for move");
//#endregion

3
extensions/sql-database-projects/src/common/telemetry.ts
View File

@@ -34,9 +34,6 @@ export enum TelemetryActions {
build = 'build', build = 'build',
updateProjectForRoundtrip = 'updateProjectForRoundtrip', updateProjectForRoundtrip = 'updateProjectForRoundtrip',
changePlatformType = 'changePlatformType', changePlatformType = 'changePlatformType',
updateSystemDatabaseReferencesInProjFile = 'updateSystemDatabaseReferencesInProjFile',
startAddSqlBinding = 'startAddSqlBinding',
finishAddSqlBinding = 'finishAddSqlBinding',
createProjectFromDatabase = 'createProjectFromDatabase', createProjectFromDatabase = 'createProjectFromDatabase',
updateProjectFromDatabase = 'updateProjectFromDatabase', updateProjectFromDatabase = 'updateProjectFromDatabase',
publishToContainer = 'publishToContainer', publishToContainer = 'publishToContainer',

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

@@ -152,6 +152,19 @@ export function convertSlashesForSqlProj(filePath: string): string {
: filePath; : filePath;
} }
/**
* Converts a SystemDatabase enum to its string value
* @param systemDb
* @returns
*/
export function systemDatabaseToString(systemDb: mssql.SystemDatabase): string {
if (systemDb === mssql.SystemDatabase.Master) {
return constants.master;
} else {
return constants.msdb;
}
}
/** /**
* Read SQLCMD variables from xmlDoc and return them * Read SQLCMD variables from xmlDoc and return them
* @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
@@ -303,14 +316,15 @@ export async function getSchemaCompareService(): Promise<ISchemaCompareService>
} }
} }
export async function getSqlProjectsService(): Promise<ISqlProjectsService> { export async function getSqlProjectsService(): Promise<mssql.ISqlProjectsService> {
if (getAzdataApi()) { if (getAzdataApi()) {
const ext = vscode.extensions.getExtension(mssql.extension.name) as vscode.Extension<mssql.IExtension>; const ext = vscode.extensions.getExtension(mssql.extension.name) as vscode.Extension<mssql.IExtension>;
const api = await ext.activate(); const api = await ext.activate();
return api.sqlProjects; return api.sqlProjects;
} else { } else {
const api = await getVscodeMssqlApi(); throw new Error(constants.errorNotSupportedInVsCode('SqlProjectService'));
return api.sqlProjects; // const api = await getVscodeMssqlApi();
// return api.sqlProjects;
} }
} }
@@ -785,3 +799,33 @@ export function isPublishProfile(fileName: string): boolean {
const hasPublishExtension = fileName.trim().toLowerCase().endsWith(constants.publishProfileExtension); const hasPublishExtension = fileName.trim().toLowerCase().endsWith(constants.publishProfileExtension);
return hasPublishExtension; return hasPublishExtension;
} }
/**
* Checks to see if a file exists at absoluteFilePath, and writes contents if it doesn't.
* If either the file already exists and contents is specified or the file doesn't exist and contents is blank,
* then an exception is thrown.
* @param absoluteFilePath
* @param contents
*/
export async function ensureFileExists(absoluteFilePath: string, contents?: string): Promise<void> {
if (contents) {
// Create the file if contents were passed in and file does not exist yet
await fs.mkdir(path.dirname(absoluteFilePath), { recursive: true });
try {
await fs.writeFile(absoluteFilePath, contents, { flag: 'wx' });
} catch (error) {
if (error.code === 'EEXIST') {
// Throw specialized error, if file already exists
throw new Error(constants.fileAlreadyExists(path.parse(absoluteFilePath).name));
}
throw error;
}
} else {
// If no contents were provided, then check that file already exists
if (!await exists(absoluteFilePath)) {
throw new Error(constants.noFileExist(absoluteFilePath));
}
}
}

1
extensions/sql-database-projects/src/controllers/mainController.ts
View File

@@ -82,7 +82,6 @@ export default class MainController implements vscode.Disposable {
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.addDatabaseReference', async (node: WorkspaceTreeItem) => { return this.projectsController.addDatabaseReference(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.addDatabaseReference', async (node: WorkspaceTreeItem) => { return this.projectsController.addDatabaseReference(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.openContainingFolder', async (node: WorkspaceTreeItem) => { return this.projectsController.openContainingFolder(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.openContainingFolder', async (node: WorkspaceTreeItem) => { return this.projectsController.openContainingFolder(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.editProjectFile', async (node: WorkspaceTreeItem) => { return this.projectsController.editProjectFile(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.editProjectFile', async (node: WorkspaceTreeItem) => { return this.projectsController.editProjectFile(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.convertToSdkStyleProject', async (node: WorkspaceTreeItem) => { return this.projectsController.convertToSdkStyleProject(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.delete', async (node: WorkspaceTreeItem) => { return this.projectsController.delete(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.delete', async (node: WorkspaceTreeItem) => { return this.projectsController.delete(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.exclude', async (node: WorkspaceTreeItem) => { return this.projectsController.exclude(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.exclude', async (node: WorkspaceTreeItem) => { return this.projectsController.exclude(node); }));
this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.rename', async (node: WorkspaceTreeItem) => { return this.projectsController.rename(node); })); this.context.subscriptions.push(vscode.commands.registerCommand('sqlDatabaseProjects.rename', async (node: WorkspaceTreeItem) => { return this.projectsController.rename(node); }));

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

@@ -17,9 +17,9 @@ import * as mssqlVscode from 'vscode-mssql';
import { promises as fs } from 'fs'; import { promises as fs } from 'fs';
import { PublishDatabaseDialog } from '../dialogs/publishDatabaseDialog'; import { PublishDatabaseDialog } from '../dialogs/publishDatabaseDialog';
import { Project, reservedProjectFolders } from '../models/project'; import { Project } from '../models/project';
import { SqlDatabaseProjectTreeViewProvider } from './databaseProjectTreeViewProvider'; import { SqlDatabaseProjectTreeViewProvider } from './databaseProjectTreeViewProvider';
import { FolderNode, FileNode, SqlObjectFileNode, PreDeployNode, PostDeployNode } from '../models/tree/fileFolderTreeItem'; import { FolderNode, FileNode } from '../models/tree/fileFolderTreeItem';
import { BaseProjectTreeItem } from '../models/tree/baseTreeItem'; import { BaseProjectTreeItem } from '../models/tree/baseTreeItem';
import { ImportDataModel } from '../models/api/import'; import { ImportDataModel } from '../models/api/import';
import { NetCoreTool, DotNetError } from '../tools/netcoreTool'; import { NetCoreTool, DotNetError } from '../tools/netcoreTool';
@@ -201,8 +201,9 @@ export class ProjectsController {
const projectStyle = creationParams.sdkStyle ? mssql.ProjectType.SdkStyle : mssql.ProjectType.LegacyStyle; const projectStyle = creationParams.sdkStyle ? mssql.ProjectType.SdkStyle : mssql.ProjectType.LegacyStyle;
await (sqlProjectsService as mssql.ISqlProjectsService).createProject(newProjFilePath, projectStyle, targetPlatform); await (sqlProjectsService as mssql.ISqlProjectsService).createProject(newProjFilePath, projectStyle, targetPlatform);
} else { } else {
const projectStyle = creationParams.sdkStyle ? mssqlVscode.ProjectType.SdkStyle : mssqlVscode.ProjectType.LegacyStyle; throw new Error(constants.errorNotSupportedInVsCode('createProject'));
await (sqlProjectsService as mssqlVscode.ISqlProjectsService).createProject(newProjFilePath, projectStyle, targetPlatform); //const projectStyle = creationParams.sdkStyle ? mssqlVscode.ProjectType.SdkStyle : mssqlVscode.ProjectType.LegacyStyle;
//await (sqlProjectsService as mssqlVscode.ISqlProjectsService).createProject(newProjFilePath, projectStyle, targetPlatform);
} }
await this.addTemplateFiles(newProjFilePath, creationParams.projectTypeId); await this.addTemplateFiles(newProjFilePath, creationParams.projectTypeId);
@@ -223,19 +224,34 @@ 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.createFileFromTemplate(project, templates.get(ItemType.table), 'DataTable.sql', { 'OBJECT_NAME': 'DataTable' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.table), 'DataTable.sql', { 'OBJECT_NAME': 'DataTable' });
await this.createFileFromTemplate(project, templates.get(ItemType.dataSource), 'EdgeHubInputDataSource.sql', { 'OBJECT_NAME': 'EdgeHubInputDataSource', 'LOCATION': 'edgehub://' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'EdgeHubInputDataSource.sql', { 'OBJECT_NAME': 'EdgeHubInputDataSource', 'LOCATION': 'edgehub://' });
await this.createFileFromTemplate(project, templates.get(ItemType.dataSource), 'SqlOutputDataSource.sql', { 'OBJECT_NAME': 'SqlOutputDataSource', 'LOCATION': 'sqlserver://tcp:.,1433' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.dataSource), 'SqlOutputDataSource.sql', { 'OBJECT_NAME': 'SqlOutputDataSource', 'LOCATION': 'sqlserver://tcp:.,1433' });
await this.createFileFromTemplate(project, templates.get(ItemType.fileFormat), 'StreamFileFormat.sql', { 'OBJECT_NAME': 'StreamFileFormat' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.fileFormat), 'StreamFileFormat.sql', { 'OBJECT_NAME': 'StreamFileFormat' });
await this.createFileFromTemplate(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', { 'OBJECT_NAME': 'EdgeHubInputStream', 'DATA_SOURCE_NAME': 'EdgeHubInputDataSource', 'LOCATION': 'input', 'OPTIONS': ',\n\tFILE_FORMAT = StreamFileFormat' });
await this.createFileFromTemplate(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', { 'OBJECT_NAME': 'SqlOutputStream', 'DATA_SOURCE_NAME': 'SqlOutputDataSource', 'LOCATION': 'TSQLStreaming.dbo.DataTable', 'OPTIONS': '' });
await this.createFileFromTemplate(project, templates.get(ItemType.externalStreamingJob), 'EdgeStreamingJob.sql', { 'OBJECT_NAME': 'EdgeStreamingJob' }); await this.addFileToProjectFromTemplate(project, templates.get(ItemType.externalStreamingJob), 'EdgeStreamingJob.sql', { 'OBJECT_NAME': 'EdgeStreamingJob' });
} }
} }
private async createFileFromTemplate(project: Project, itemType: templates.ProjectScriptType, relativePath: string, expansionMacros: Record<string, string>): Promise<void> { private async addFileToProjectFromTemplate(project: ISqlProject, itemType: templates.ProjectScriptType, relativePath: string, expansionMacros: Record<string, string>): Promise<string> {
const newFileText = templates.macroExpansion(itemType.templateScript, expansionMacros); const newFileText = templates.macroExpansion(itemType.templateScript, expansionMacros);
await project.addScriptItem(relativePath, newFileText, itemType.type); const absolutePath = path.join(project.projectFolderPath, relativePath)
await utils.ensureFileExists(absolutePath, newFileText);
switch (itemType.type) {
case ItemType.preDeployScript:
await project.addPreDeploymentScript(relativePath);
break;
case ItemType.postDeployScript:
await project.addPostDeploymentScript(relativePath);
break;
default: // a normal SQL object script
await project.addSqlObjectScript(relativePath);
break;
}
return absolutePath;
} }
//#endregion //#endregion
@@ -266,7 +282,7 @@ export class ProjectsController {
} }
// get dlls and targets file needed for building for legacy style projects // get dlls and targets file needed for building for legacy style projects
if (!project.isSdkStyleProject) { if (project.sqlProjStyle === mssql.ProjectType.LegacyStyle) {
const result = await this.buildHelper.createBuildDirFolder(this._outputChannel); const result = await this.buildHelper.createBuildDirFolder(this._outputChannel);
if (!result) { if (!result) {
@@ -278,7 +294,7 @@ export class ProjectsController {
const options: ShellCommandOptions = { const options: ShellCommandOptions = {
commandTitle: 'Build', commandTitle: 'Build',
workingDirectory: project.projectFolderPath, workingDirectory: project.projectFolderPath,
argument: this.buildHelper.constructBuildArguments(project.projectFilePath, this.buildHelper.extensionBuildDirPath, project.isSdkStyleProject) argument: this.buildHelper.constructBuildArguments(project.projectFilePath, this.buildHelper.extensionBuildDirPath, project.sqlProjStyle)
}; };
try { try {
@@ -640,7 +656,7 @@ export class ProjectsController {
throw new Error(constants.folderAlreadyExists(path.parse(absoluteFolderPath).name)); throw new Error(constants.folderAlreadyExists(path.parse(absoluteFolderPath).name));
} }
await project.addFolderItem(relativeFolderPath); await project.addFolder(relativeFolderPath);
this.refreshProjectsTree(treeNode); this.refreshProjectsTree(treeNode);
} catch (err) { } catch (err) {
void vscode.window.showErrorMessage(utils.getErrorMessage(err)); void vscode.window.showErrorMessage(utils.getErrorMessage(err));
@@ -669,7 +685,7 @@ export class ProjectsController {
} }
public isReservedFolder(absoluteFolderPath: string, projectFolderPath: string): boolean { public isReservedFolder(absoluteFolderPath: string, projectFolderPath: string): boolean {
const sameName = reservedProjectFolders.find(f => f === path.parse(absoluteFolderPath).name) !== undefined; const sameName = constants.reservedProjectFolders.find(f => f === path.parse(absoluteFolderPath).name) !== undefined;
const sameLocation = path.parse(absoluteFolderPath).dir === projectFolderPath; const sameLocation = path.parse(absoluteFolderPath).dir === projectFolderPath;
return sameName && sameLocation; return sameName && sameLocation;
} }
@@ -707,7 +723,6 @@ export class ProjectsController {
return; // user cancelled return; // user cancelled
} }
const newFileText = templates.macroExpansion(itemType.templateScript, { 'OBJECT_NAME': itemObjectName });
const relativeFilePath = path.join(relativePath, itemObjectName + constants.sqlFileExtension); const relativeFilePath = path.join(relativePath, itemObjectName + constants.sqlFileExtension);
const telemetryProps: Record<string, string> = { itemType: itemType.type }; const telemetryProps: Record<string, string> = { itemType: itemType.type };
@@ -720,14 +735,14 @@ export class ProjectsController {
} }
try { try {
const newEntry = await project.addScriptItem(relativeFilePath, newFileText, itemType.type); const absolutePath = await this.addFileToProjectFromTemplate(project, itemType, relativeFilePath, { 'OBJECT_NAME': itemObjectName });
TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addItemFromTree) TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addItemFromTree)
.withAdditionalProperties(telemetryProps) .withAdditionalProperties(telemetryProps)
.withAdditionalMeasurements(telemetryMeasurements) .withAdditionalMeasurements(telemetryMeasurements)
.send(); .send();
await vscode.commands.executeCommand(constants.vscodeOpenCommand, newEntry.fsUri); await vscode.commands.executeCommand(constants.vscodeOpenCommand, vscode.Uri.file(absolutePath));
treeDataProvider?.notifyTreeDataChanged(); treeDataProvider?.notifyTreeDataChanged();
} catch (err) { } catch (err) {
void vscode.window.showErrorMessage(utils.getErrorMessage(err)); void vscode.window.showErrorMessage(utils.getErrorMessage(err));
@@ -772,7 +787,30 @@ export class ProjectsController {
if (fileEntry) { if (fileEntry) {
TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.excludeFromProject); TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.excludeFromProject);
await project.exclude(fileEntry);
switch (node.type) {
case constants.DatabaseProjectItemType.sqlObjectScript:
case constants.DatabaseProjectItemType.table:
case constants.DatabaseProjectItemType.externalStreamingJob:
await project.excludeSqlObjectScript(fileEntry.relativePath);
break;
case constants.DatabaseProjectItemType.folder:
// TODO: not yet supported in DacFx
//await project.excludeFolder(fileEntry.relativePath);
void vscode.window.showErrorMessage(constants.excludeFolderNotSupported);
break;
case constants.DatabaseProjectItemType.preDeploymentScript:
await project.excludePreDeploymentScript(fileEntry.relativePath);
break;
case constants.DatabaseProjectItemType.postDeploymentScript:
await project.excludePostDeploymentScript(fileEntry.relativePath);
break;
case constants.DatabaseProjectItemType.noneFile:
await project.excludeNoneItem(fileEntry.relativePath);
break;
default:
throw new Error(constants.unhandledExcludeType(node.type));
}
} else { } else {
TelemetryReporter.sendErrorEvent2(TelemetryViews.ProjectTree, TelemetryActions.excludeFromProject); TelemetryReporter.sendErrorEvent2(TelemetryViews.ProjectTree, TelemetryActions.excludeFromProject);
void vscode.window.showErrorMessage(constants.unableToPerformAction(constants.excludeAction, node.relativeProjectUri.path)); void vscode.window.showErrorMessage(constants.unableToPerformAction(constants.excludeAction, node.relativeProjectUri.path));
@@ -802,35 +840,43 @@ export class ProjectsController {
return; return;
} }
let success = false; try {
if (node instanceof DatabaseReferenceTreeItem) { if (node instanceof DatabaseReferenceTreeItem) {
const databaseReference = this.getDatabaseReference(project, node); const databaseReference = this.getDatabaseReference(project, node);
if (databaseReference) { if (databaseReference) {
await project.deleteDatabaseReference(databaseReference); await project.deleteDatabaseReferenceByEntry(databaseReference);
success = true;
} }
} else if (node instanceof SqlCmdVariableTreeItem) { } else if (node instanceof SqlCmdVariableTreeItem) {
const sqlProjectsService = await utils.getSqlProjectsService(); await project.deleteSqlCmdVariable(node.friendlyName);
const result = await sqlProjectsService.deleteSqlCmdVariable(project.projectFilePath, node.friendlyName); } else if (node instanceof FolderNode) {
success = result.success; await project.deleteFolder(node.entryKey);
} else if (node instanceof FileNode || FolderNode) { } else if (node instanceof FileNode) {
const fileEntry = this.getFileProjectEntry(project, node); switch (node.type) {
case constants.DatabaseProjectItemType.sqlObjectScript:
if (fileEntry) { case constants.DatabaseProjectItemType.table:
await project.deleteFileFolder(fileEntry); case constants.DatabaseProjectItemType.externalStreamingJob:
success = true; await project.deleteSqlObjectScript(node.entryKey);
break;
case constants.DatabaseProjectItemType.preDeploymentScript:
await project.deletePreDeploymentScript(node.entryKey);
break;
case constants.DatabaseProjectItemType.postDeploymentScript:
await project.deletePostDeploymentScript(node.entryKey);
break;
case constants.DatabaseProjectItemType.noneFile:
await project.deleteNoneItem(node.entryKey);
break;
default:
throw new Error(constants.unhandledDeleteType(node.type));
} }
} }
if (success) {
TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.deleteObjectFromProject) TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.deleteObjectFromProject)
.withAdditionalProperties({ objectType: node.constructor.name }) .withAdditionalProperties({ objectType: node.constructor.name })
.send(); .send();
this.refreshProjectsTree(context); this.refreshProjectsTree(context);
} else { } catch {
TelemetryReporter.createErrorEvent2(TelemetryViews.ProjectTree, TelemetryActions.deleteObjectFromProject) TelemetryReporter.createErrorEvent2(TelemetryViews.ProjectTree, TelemetryActions.deleteObjectFromProject)
.withAdditionalProperties({ objectType: node.constructor.name }) .withAdditionalProperties({ objectType: node.constructor.name })
.send(); .send();
@@ -862,7 +908,7 @@ export class ProjectsController {
const newFilePath = path.join(path.dirname(utils.getPlatformSafeFileEntryPath(file?.relativePath!)), `${newFileName}.sql`); const newFilePath = path.join(path.dirname(utils.getPlatformSafeFileEntryPath(file?.relativePath!)), `${newFileName}.sql`);
const renameResult = await this.move(node, node.projectFileUri.fsPath, newFilePath); const renameResult = await project.move(node, newFilePath);
if (renameResult?.success) { if (renameResult?.success) {
TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.rename); TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.rename);
@@ -885,11 +931,12 @@ export class ProjectsController {
public async editSqlCmdVariable(context: dataworkspace.WorkspaceTreeItem): Promise<void> { public async editSqlCmdVariable(context: dataworkspace.WorkspaceTreeItem): Promise<void> {
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 originalValue = project.sqlCmdVariables[node.friendlyName]; // TODO: update to hookup with however sqlcmd vars work after swap const variableName = node.friendlyName;
const originalValue = project.sqlCmdVariables[variableName];
const newValue = await vscode.window.showInputBox( const newValue = await vscode.window.showInputBox(
{ {
title: constants.enterNewValueForVar(node.friendlyName), title: constants.enterNewValueForVar(variableName),
value: originalValue, value: originalValue,
ignoreFocusOut: true ignoreFocusOut: true
}); });
@@ -898,7 +945,8 @@ export class ProjectsController {
return; return;
} }
// TODO: update value in sqlcmd variables after swap await project.updateSqlCmdVariable(variableName, newValue)
this.refreshProjectsTree(context);
} }
/** /**
@@ -931,9 +979,7 @@ export class ProjectsController {
return; return;
} }
// TODO: update after swap
await project.addSqlCmdVariable(variableName, defaultValue); await project.addSqlCmdVariable(variableName, defaultValue);
this.refreshProjectsTree(context); this.refreshProjectsTree(context);
} }
@@ -945,7 +991,7 @@ export class ProjectsController {
const databaseReference = context as DatabaseReferenceTreeItem; const databaseReference = context as DatabaseReferenceTreeItem;
if (databaseReference) { if (databaseReference) {
return project.databaseReferences.find(r => r.databaseName === databaseReference.treeItem.label); return project.databaseReferences.find(r => r.referenceName === databaseReference.treeItem.label);
} }
return undefined; return undefined;
@@ -1068,35 +1114,6 @@ export class ProjectsController {
} }
} }
/**
* Converts a legacy style project to an SDK-style project
* @param context a treeItem in a project's hierarchy, to be used to obtain a Project
*/
public async convertToSdkStyleProject(context: dataworkspace.WorkspaceTreeItem): Promise<void> {
const project = await this.getProjectFromContext(context);
// confirm that user wants to update the project and knows the SSDT doesn't have support for displaying glob files yet
await vscode.window.showWarningMessage(constants.convertToSdkStyleConfirmation(project.projectFileName), { modal: true }, constants.yesString).then(async (result) => {
if (result === constants.yesString) {
const updateResult = await project.convertProjectToSdkStyle();
void this.reloadProject(context);
if (!updateResult) {
void vscode.window.showErrorMessage(constants.updatedToSdkStyleError(project.projectFileName));
} else {
void this.reloadProject(context);
// show message that project file can be simplified
const result = await vscode.window.showInformationMessage(constants.projectUpdatedToSdkStyle(project.projectFileName), constants.learnMore);
if (result === constants.learnMore) {
void vscode.env.openExternal(vscode.Uri.parse(constants.sdkLearnMoreUrl!));
}
}
}
});
}
//#region database references //#region database references
/** /**
@@ -1367,9 +1384,9 @@ export class ProjectsController {
return; return;
} }
const fileFolderList: vscode.Uri[] | undefined = await this.getSqlFileList(projectInfo.newProjectFolder); const scriptList: vscode.Uri[] | undefined = await this.getSqlFileList(projectInfo.newProjectFolder);
if (!fileFolderList || fileFolderList.length === 0) { if (!scriptList || scriptList.length === 0) {
void vscode.window.showInformationMessage(constants.noSqlFilesGenerated); void vscode.window.showInformationMessage(constants.noSqlFilesGenerated);
this._outputChannel.show(); this._outputChannel.show();
return; return;
@@ -1386,12 +1403,15 @@ export class ProjectsController {
const project = await Project.openProject(newProjFilePath); const project = await Project.openProject(newProjFilePath);
// 6. add generated files to SQL project // 6. add generated files to SQL project
await project.addToProject(fileFolderList.filter(f => !f.fsPath.endsWith(constants.autorestPostDeploymentScriptName))); // Add generated file structure to the project
const postDeploymentScript: vscode.Uri | undefined = this.findPostDeploymentScript(fileFolderList); const uriList = scriptList.filter(f => !f.fsPath.endsWith(constants.autorestPostDeploymentScriptName))
const relativePaths = uriList.map(f => path.relative(project.projectFolderPath, f.path));
await project.addSqlObjectScripts(relativePaths); // Add generated file structure to the project
const postDeploymentScript: vscode.Uri | undefined = this.findPostDeploymentScript(scriptList);
if (postDeploymentScript) { if (postDeploymentScript) {
await project.addScriptItem(path.relative(project.projectFolderPath, postDeploymentScript.fsPath), undefined, ItemType.postDeployScript); await project.addPostDeploymentScript(path.relative(project.projectFolderPath, postDeploymentScript.fsPath));
} }
if (options?.doNotOpenInWorkspace !== true) { if (options?.doNotOpenInWorkspace !== true) {
@@ -1576,10 +1596,12 @@ export class ProjectsController {
.withAdditionalMeasurements({ durationMs: timeToExtract }) .withAdditionalMeasurements({ durationMs: timeToExtract })
.send(); .send();
let fileFolderList: vscode.Uri[] = model.extractTarget === mssql.ExtractTarget.file ? [vscode.Uri.file(model.filePath)] : await this.generateList(model.filePath); // Create a list of all the files and directories to be added to project const scriptList: vscode.Uri[] = model.extractTarget === mssql.ExtractTarget.file ? [vscode.Uri.file(model.filePath)] : await this.generateScriptList(model.filePath); // Create a list of all the files to be added to project
const relativePaths = scriptList.map(f => path.relative(project.projectFolderPath, f.path));
if (!model.sdkStyle) { if (!model.sdkStyle) {
await project.addToProject(fileFolderList); // Add generated file structure to the project await project.addSqlObjectScripts(relativePaths); // Add generated file structure to the project
} }
// add project to workspace // add project to workspace
@@ -1611,19 +1633,19 @@ export class ProjectsController {
} }
/** /**
* Generate a flat list of all files and folder under a folder. * Generate a flat list of all scripts under a folder.
* @param absolutePath absolute path to folder to generate the list of files from * @param absolutePath absolute path to folder to generate the list of files from
* @returns array of uris of files and folders under the provided folder * @returns array of uris of files under the provided folder
*/ */
public async generateList(absolutePath: string): Promise<vscode.Uri[]> { public async generateScriptList(absolutePath: string): Promise<vscode.Uri[]> {
let fileFolderList: vscode.Uri[] = []; let fileList: vscode.Uri[] = [];
if (!await utils.exists(absolutePath)) { if (!await utils.exists(absolutePath)) {
if (await utils.exists(absolutePath + constants.sqlFileExtension)) { if (await utils.exists(absolutePath + constants.sqlFileExtension)) {
absolutePath += constants.sqlFileExtension; absolutePath += constants.sqlFileExtension;
} else { } else {
void vscode.window.showErrorMessage(constants.cannotResolvePath(absolutePath)); void vscode.window.showErrorMessage(constants.cannotResolvePath(absolutePath));
return fileFolderList; return fileList;
} }
} }
@@ -1635,19 +1657,18 @@ export class ProjectsController {
const stat = await fs.stat(filepath); const stat = await fs.stat(filepath);
if (stat.isDirectory()) { if (stat.isDirectory()) {
fileFolderList.push(vscode.Uri.file(filepath));
(await fs (await fs
.readdir(filepath)) .readdir(filepath))
.forEach((f: string) => files.push(path.join(filepath, f))); .forEach((f: string) => files.push(path.join(filepath, f)));
} }
else if (stat.isFile()) { else if (stat.isFile() && path.extname(filepath) === constants.sqlFileExtension) {
fileFolderList.push(vscode.Uri.file(filepath)); fileList.push(vscode.Uri.file(filepath));
} }
} }
} while (files.length !== 0); } while (files.length !== 0);
return fileFolderList; return fileList;
} }
//#endregion //#endregion
@@ -1817,7 +1838,9 @@ export class ProjectsController {
let toAdd: vscode.Uri[] = []; let toAdd: vscode.Uri[] = [];
result.addedFiles.forEach((f: any) => toAdd.push(vscode.Uri.file(f))); result.addedFiles.forEach((f: any) => toAdd.push(vscode.Uri.file(f)));
await project.addToProject(toAdd); const relativePaths = toAdd.map(f => path.relative(project.projectFolderPath, f.path));
await project.addSqlObjectScripts(relativePaths);
let toRemove: vscode.Uri[] = []; let toRemove: vscode.Uri[] = [];
result.deletedFiles.forEach((f: any) => toRemove.push(vscode.Uri.file(f))); result.deletedFiles.forEach((f: any) => toRemove.push(vscode.Uri.file(f)));
@@ -1825,7 +1848,7 @@ export class ProjectsController {
let toRemoveEntries: FileProjectEntry[] = []; let toRemoveEntries: FileProjectEntry[] = [];
toRemove.forEach(f => toRemoveEntries.push(new FileProjectEntry(f, f.path.replace(projectPath + '\\', ''), EntryType.File))); toRemove.forEach(f => toRemoveEntries.push(new FileProjectEntry(f, f.path.replace(projectPath + '\\', ''), EntryType.File)));
toRemoveEntries.forEach(async f => await project.exclude(f)); toRemoveEntries.forEach(async f => await project.excludeSqlObjectScript(f.fsUri.fsPath));
await this.buildProject(project); await this.buildProject(project);
} }
@@ -1843,6 +1866,7 @@ export class ProjectsController {
*/ */
public async moveFile(projectUri: vscode.Uri, source: any, target: dataworkspace.WorkspaceTreeItem): Promise<void> { public async moveFile(projectUri: vscode.Uri, source: any, target: dataworkspace.WorkspaceTreeItem): Promise<void> {
const sourceFileNode = source as FileNode; const sourceFileNode = source as FileNode;
const project = await this.getProjectFromContext(sourceFileNode);
// only moving files is supported // only moving files is supported
if (!sourceFileNode || !(sourceFileNode instanceof FileNode)) { if (!sourceFileNode || !(sourceFileNode instanceof FileNode)) {
@@ -1885,7 +1909,7 @@ export class ProjectsController {
} }
// Move the file // Move the file
const moveResult = await this.move(sourceFileNode, projectUri.fsPath, newPath); const moveResult = await project.move(sourceFileNode, newPath);
if (moveResult?.success) { if (moveResult?.success) {
TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.move); TelemetryReporter.sendActionEvent(TelemetryViews.ProjectTree, TelemetryActions.move);
@@ -1894,38 +1918,6 @@ export class ProjectsController {
void vscode.window.showErrorMessage(constants.errorMovingFile(sourceFileNode.fileSystemUri.fsPath, newPath, utils.getErrorMessage(moveResult?.errorMessage))); void vscode.window.showErrorMessage(constants.errorMovingFile(sourceFileNode.fileSystemUri.fsPath, newPath, utils.getErrorMessage(moveResult?.errorMessage)));
} }
} }
/**
* Moves a file to a different location
* @param node Node being moved
* @param projectFilePath Full file path to .sqlproj
* @param destinationRelativePath path of the destination, relative to .sqlproj
*/
private async move(node: BaseProjectTreeItem, projectFilePath: string, destinationRelativePath: string): Promise<azdataType.ResultStatus | undefined> {
// trim off the project folder at the beginning of the relative path stored in the tree
const projectRelativeUri = vscode.Uri.file(path.basename(projectFilePath, constants.sqlprojExtension));
const originalRelativePath = utils.trimUri(projectRelativeUri, node.relativeProjectUri);
destinationRelativePath = utils.trimUri(projectRelativeUri, vscode.Uri.file(destinationRelativePath));
if (originalRelativePath === destinationRelativePath) {
return;
}
const sqlProjectsService = await utils.getSqlProjectsService();
let result;
if (node instanceof SqlObjectFileNode) {
result = await sqlProjectsService.moveSqlObjectScript(projectFilePath, destinationRelativePath, originalRelativePath)
} else if (node instanceof PreDeployNode) {
result = await sqlProjectsService.movePreDeploymentScript(projectFilePath, destinationRelativePath, originalRelativePath)
} else if (node instanceof PostDeployNode) {
result = await sqlProjectsService.movePostDeploymentScript(projectFilePath, destinationRelativePath, originalRelativePath)
}
// TODO add support for renaming none scripts after those are added in STS
// TODO add support for renaming publish profiles when support is added in DacFx
return result;
}
} }
export interface NewProjectParams { export interface NewProjectParams {

57
extensions/sql-database-projects/src/dialogs/addDatabaseReferenceDialog.ts
View File

@@ -15,7 +15,8 @@ import { IconPathHelper } from '../common/iconHelper';
import { ISystemDatabaseReferenceSettings, IDacpacReferenceSettings, IProjectReferenceSettings } from '../models/IDatabaseReferenceSettings'; import { ISystemDatabaseReferenceSettings, IDacpacReferenceSettings, IProjectReferenceSettings } from '../models/IDatabaseReferenceSettings';
import { Deferred } from '../common/promise'; import { Deferred } from '../common/promise';
import { TelemetryActions, TelemetryReporter, TelemetryViews } from '../common/telemetry'; import { TelemetryActions, TelemetryReporter, TelemetryViews } from '../common/telemetry';
import { SystemDatabase } from '../models/projectEntry'; import { SystemDatabase } from 'mssql';
import { DbServerValues, ensureSetOrDefined, populateResultWithVars } from './utils';
export enum ReferenceType { export enum ReferenceType {
project, project,
@@ -151,32 +152,42 @@ export class AddDatabaseReferenceDialog {
public async addReferenceClick(): Promise<void> { public async addReferenceClick(): Promise<void> {
let referenceSettings: ISystemDatabaseReferenceSettings | IDacpacReferenceSettings | IProjectReferenceSettings; let referenceSettings: ISystemDatabaseReferenceSettings | IDacpacReferenceSettings | IProjectReferenceSettings;
if (this.currentReferenceType === ReferenceType.project) { if (this.currentReferenceType === ReferenceType.systemDb) {
referenceSettings = { const systemDbRef: ISystemDatabaseReferenceSettings = {
projectName: <string>this.projectDropdown?.value, databaseVariableLiteralValue: <string>this.databaseNameTextbox?.value,
projectGuid: '',
projectRelativePath: undefined,
databaseName: <string>this.databaseNameTextbox?.value,
databaseVariable: <string>this.databaseVariableTextbox?.value,
serverName: <string>this.serverNameTextbox?.value,
serverVariable: <string>this.serverVariableTextbox?.value,
suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked
};
} else if (this.currentReferenceType === ReferenceType.systemDb) {
referenceSettings = {
databaseName: <string>this.databaseNameTextbox?.value,
systemDb: getSystemDatabase(<string>this.systemDatabaseDropdown?.value), systemDb: getSystemDatabase(<string>this.systemDatabaseDropdown?.value),
suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked
}; };
} else { // this.currentReferenceType === ReferenceType.dacpac
referenceSettings = { referenceSettings = systemDbRef;
databaseName: <string>this.databaseNameTextbox?.value, } else {
dacpacFileLocation: vscode.Uri.file(<string>this.dacpacTextbox?.value), if (this.currentReferenceType === ReferenceType.project) {
databaseVariable: utils.removeSqlCmdVariableFormatting(<string>this.databaseVariableTextbox?.value), const projRef: IProjectReferenceSettings = {
serverName: <string>this.serverNameTextbox?.value, projectName: <string>this.projectDropdown?.value,
serverVariable: utils.removeSqlCmdVariableFormatting(<string>this.serverVariableTextbox?.value), projectGuid: '',
projectRelativePath: undefined,
suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked
}; };
referenceSettings = projRef;
} else { // this.currentReferenceType === ReferenceType.dacpac
const dacpacRef: IDacpacReferenceSettings = {
databaseName: ensureSetOrDefined(this.databaseNameTextbox?.value),
dacpacFileLocation: vscode.Uri.file(<string>this.dacpacTextbox?.value),
suppressMissingDependenciesErrors: <boolean>this.suppressMissingDependenciesErrorsCheckbox?.checked
};
referenceSettings = dacpacRef;
}
const dbServerValues: DbServerValues = {
dbName: this.databaseNameTextbox?.value,
dbVariable: this.databaseVariableTextbox?.value,
serverName: this.serverNameTextbox?.value,
serverVariable: this.serverVariableTextbox?.value
};
populateResultWithVars(referenceSettings, dbServerValues);
} }
TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addDatabaseReference) TelemetryReporter.createActionEvent(TelemetryViews.ProjectTree, TelemetryActions.addDatabaseReference)
@@ -625,7 +636,7 @@ export function getSystemDbOptions(project: Project): string[] {
} }
export function getSystemDatabase(name: string): SystemDatabase { export function getSystemDatabase(name: string): SystemDatabase {
return name === constants.master ? SystemDatabase.master : SystemDatabase.msdb; return name === constants.master ? SystemDatabase.Master : SystemDatabase.MSDB;
} }
export async function promptDacpacLocation(): Promise<vscode.Uri[] | undefined> { export async function promptDacpacLocation(): Promise<vscode.Uri[] | undefined> {

30
extensions/sql-database-projects/src/dialogs/addDatabaseReferenceQuickpick.ts
View File

@@ -6,18 +6,14 @@
import path = require('path'); import path = require('path');
import * as vscode from 'vscode'; import * as vscode from 'vscode';
import * as constants from '../common/constants'; import * as constants from '../common/constants';
import { getSqlProjectsInWorkspace, isValidSqlCmdVariableName, removeSqlCmdVariableFormatting } from '../common/utils'; import { getSqlProjectsInWorkspace, isValidSqlCmdVariableName } from '../common/utils';
import { DbServerValues, populateResultWithVars } from './utils';
import { AddDatabaseReferenceSettings } from '../controllers/projectController'; import { AddDatabaseReferenceSettings } from '../controllers/projectController';
import { IDacpacReferenceSettings, IProjectReferenceSettings, ISystemDatabaseReferenceSettings } from '../models/IDatabaseReferenceSettings'; import { IDacpacReferenceSettings, IProjectReferenceSettings, ISystemDatabaseReferenceSettings } from '../models/IDatabaseReferenceSettings';
import { Project } from '../models/project'; import { Project } from '../models/project';
import { getSystemDatabase, getSystemDbOptions, promptDacpacLocation } from './addDatabaseReferenceDialog'; import { getSystemDatabase, getSystemDbOptions, promptDacpacLocation } from './addDatabaseReferenceDialog';
interface DbServerValues {
dbName?: string,
dbVariable?: string,
serverName?: string,
serverVariable?: string
}
/** /**
* Create flow for adding a database reference using only VS Code-native APIs such as QuickPick * Create flow for adding a database reference using only VS Code-native APIs such as QuickPick
@@ -93,10 +89,8 @@ async function addProjectReference(otherProjectsInWorkspace: vscode.Uri[]): Prom
// User cancelled // User cancelled
return; return;
} }
referenceSettings.databaseName = dbServerValues.dbName;
referenceSettings.databaseVariable = dbServerValues.dbVariable; populateResultWithVars(referenceSettings, dbServerValues);
referenceSettings.serverName = dbServerValues.serverName;
referenceSettings.serverVariable = dbServerValues.serverVariable;
// 7. Prompt suppress unresolved ref errors // 7. Prompt suppress unresolved ref errors
const suppressErrors = await promptSuppressUnresolvedRefErrors(); const suppressErrors = await promptSuppressUnresolvedRefErrors();
@@ -124,7 +118,7 @@ async function addSystemDatabaseReference(project: Project): Promise<ISystemData
const suppressErrors = await promptSuppressUnresolvedRefErrors(); const suppressErrors = await promptSuppressUnresolvedRefErrors();
return { return {
databaseName: dbName, databaseVariableLiteralValue: dbName,
systemDb: getSystemDatabase(selectedSystemDb), systemDb: getSystemDatabase(selectedSystemDb),
suppressMissingDependenciesErrors: suppressErrors suppressMissingDependenciesErrors: suppressErrors
}; };
@@ -181,14 +175,16 @@ async function addDacpacReference(project: Project): Promise<IDacpacReferenceSet
// 5. Prompt suppress unresolved ref errors // 5. Prompt suppress unresolved ref errors
const suppressErrors = await promptSuppressUnresolvedRefErrors(); const suppressErrors = await promptSuppressUnresolvedRefErrors();
return { // 6. Construct result
databaseName: dbServerValues.dbName,
const referenceSettings: IDacpacReferenceSettings = {
dacpacFileLocation: dacPacLocation, dacpacFileLocation: dacPacLocation,
databaseVariable: removeSqlCmdVariableFormatting(dbServerValues.dbVariable),
serverName: dbServerValues.serverName,
serverVariable: removeSqlCmdVariableFormatting(dbServerValues.serverVariable),
suppressMissingDependenciesErrors: suppressErrors suppressMissingDependenciesErrors: suppressErrors
}; };
populateResultWithVars(referenceSettings, dbServerValues);
return referenceSettings;
} }
async function promptLocation(): Promise<string | undefined> { async function promptLocation(): Promise<string | undefined> {

31
extensions/sql-database-projects/src/dialogs/utils.ts
View File

@@ -9,6 +9,8 @@ import * as utils from '../common/utils';
import * as mssql from 'mssql'; import * as mssql from 'mssql';
import { HttpClient } from '../common/httpClient'; import { HttpClient } from '../common/httpClient';
import { AgreementInfo, DockerImageInfo } from '../models/deploy/deployProfile'; import { AgreementInfo, DockerImageInfo } from '../models/deploy/deployProfile';
import { IUserDatabaseReferenceSettings } from '../models/IDatabaseReferenceSettings';
import { removeSqlCmdVariableFormatting } from '../common/utils';
/** /**
* Gets connection name from connection object if there is one, * Gets connection name from connection object if there is one,
@@ -214,3 +216,32 @@ export function mapExtractTargetEnum(inputTarget: string): mssql.ExtractTarget {
throw new Error(constants.extractTargetRequired); throw new Error(constants.extractTargetRequired);
} }
} }
export interface DbServerValues {
dbName?: string,
dbVariable?: string,
serverName?: string,
serverVariable?: string
}
export function populateResultWithVars(referenceSettings: IUserDatabaseReferenceSettings, dbServerValues: DbServerValues) {
if (dbServerValues.dbVariable) {
referenceSettings.databaseName = ensureSetOrDefined(dbServerValues.dbName);
referenceSettings.databaseVariable = ensureSetOrDefined(removeSqlCmdVariableFormatting(dbServerValues.dbVariable));
referenceSettings.serverName = ensureSetOrDefined(dbServerValues.serverName);
referenceSettings.serverVariable = ensureSetOrDefined(removeSqlCmdVariableFormatting(dbServerValues.serverVariable));
} else {
referenceSettings.databaseVariableLiteralValue = ensureSetOrDefined(dbServerValues.dbName);
}
}
/**
* Returns undefined for settings that are an empty string, meaning they are unset
* @param setting
*/
export function ensureSetOrDefined(setting?: string): string | undefined {
if (!setting || setting.trim().length === 0) {
return undefined;
}
return setting;
}

17
extensions/sql-database-projects/src/models/IDatabaseReferenceSettings.ts
View File

@@ -3,11 +3,11 @@
* Licensed under the Source EULA. See License.txt in the project root for license information. * Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
import { SystemDatabase } from 'mssql';
import { Uri } from 'vscode'; import { Uri } from 'vscode';
import { SystemDatabase } from './projectEntry';
export interface IDatabaseReferenceSettings { export interface IDatabaseReferenceSettings {
databaseName?: string; databaseVariableLiteralValue?: string;
suppressMissingDependenciesErrors: boolean; suppressMissingDependenciesErrors: boolean;
} }
@@ -15,18 +15,19 @@ export interface ISystemDatabaseReferenceSettings extends IDatabaseReferenceSett
systemDb: SystemDatabase; systemDb: SystemDatabase;
} }
export interface IDacpacReferenceSettings extends IDatabaseReferenceSettings { export interface IUserDatabaseReferenceSettings extends IDatabaseReferenceSettings {
dacpacFileLocation: Uri; databaseName?: string;
databaseVariable?: string; databaseVariable?: string;
serverName?: string; serverName?: string;
serverVariable?: string; serverVariable?: string;
} }
export interface IProjectReferenceSettings extends IDatabaseReferenceSettings { export interface IDacpacReferenceSettings extends IUserDatabaseReferenceSettings {
dacpacFileLocation: Uri;
}
export interface IProjectReferenceSettings extends IUserDatabaseReferenceSettings {
projectRelativePath: Uri | undefined; projectRelativePath: Uri | undefined;
projectName: string; projectName: string;
projectGuid: string; projectGuid: string;
databaseVariable?: string;
serverName?: string;
serverVariable?: string;
} }

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

File diff suppressed because it is too large Load Diff

76
extensions/sql-database-projects/src/models/projectEntry.ts
View File

@@ -44,25 +44,29 @@ export class FileProjectEntry extends ProjectEntry implements IFileProjectEntry
} }
export class DacpacReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry { export class DacpacReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry {
databaseSqlCmdVariableValue?: string;
databaseSqlCmdVariableName?: string;
databaseVariableLiteralValue?: string; databaseVariableLiteralValue?: string;
databaseSqlCmdVariable?: string; serverSqlCmdVariableName?: string;
serverName?: string; serverSqlCmdVariableValue?: string;
serverSqlCmdVariable?: string;
suppressMissingDependenciesErrors: boolean; suppressMissingDependenciesErrors: boolean;
constructor(settings: IDacpacReferenceSettings) { constructor(settings: IDacpacReferenceSettings) {
super(settings.dacpacFileLocation, '', EntryType.DatabaseReference); super(settings.dacpacFileLocation, /* relativePath doesn't get set for database references */ '', EntryType.DatabaseReference);
this.databaseSqlCmdVariable = settings.databaseVariable;
this.databaseVariableLiteralValue = settings.databaseName;
this.serverName = settings.serverName;
this.serverSqlCmdVariable = settings.serverVariable;
this.suppressMissingDependenciesErrors = settings.suppressMissingDependenciesErrors; this.suppressMissingDependenciesErrors = settings.suppressMissingDependenciesErrors;
this.databaseVariableLiteralValue = settings.databaseVariableLiteralValue;
this.databaseSqlCmdVariableName = settings.databaseName;
this.databaseSqlCmdVariableValue = settings.databaseVariable;
this.serverSqlCmdVariableName = settings.serverName;
this.serverSqlCmdVariableValue = settings.serverVariable;
} }
/** /**
* File name that gets displayed in the project tree * File name that gets displayed in the project tree
*/ */
public get databaseName(): string { public get referenceName(): string {
return path.parse(utils.getPlatformSafeFileEntryPath(this.fsUri.fsPath)).name; return path.parse(utils.getPlatformSafeFileEntryPath(this.fsUri.fsPath)).name;
} }
@@ -73,49 +77,44 @@ export class DacpacReferenceProjectEntry extends FileProjectEntry implements IDa
} }
export class SystemDatabaseReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry { export class SystemDatabaseReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry {
constructor(uri: Uri, public ssdtUri: Uri, public databaseVariableLiteralValue: string | undefined, public suppressMissingDependenciesErrors: boolean) { constructor(public referenceName: string, public databaseVariableLiteralValue: string | undefined, public suppressMissingDependenciesErrors: boolean) {
super(uri, '', EntryType.DatabaseReference); super(Uri.file(referenceName), referenceName, EntryType.DatabaseReference);
} }
/** /**
* File name that gets displayed in the project tree * Returns the name of the system database - this is used for deleting the system database reference
*/ */
public get databaseName(): string {
return path.parse(utils.getPlatformSafeFileEntryPath(this.fsUri.fsPath)).name;
}
public override pathForSqlProj(): string { public override pathForSqlProj(): string {
// need to remove the leading slash for system database path for build to work on Windows return this.referenceName;
return utils.convertSlashesForSqlProj(this.fsUri.path.substring(1));
}
public ssdtPathForSqlProj(): string {
// need to remove the leading slash for system database path for build to work on Windows
return utils.convertSlashesForSqlProj(this.ssdtUri.path.substring(1));
} }
} }
export class SqlProjectReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry { export class SqlProjectReferenceProjectEntry extends FileProjectEntry implements IDatabaseReferenceProjectEntry {
projectName: string; public projectName: string;
projectGuid: string; public projectGuid: string;
databaseVariableLiteralValue?: string; public databaseVariableLiteralValue?: string;
databaseSqlCmdVariable?: string; public databaseSqlCmdVariableName?: string;
serverName?: string; public databaseSqlCmdVariableValue?: string;
serverSqlCmdVariable?: string; public serverSqlCmdVariableName?: string;
suppressMissingDependenciesErrors: boolean; public serverSqlCmdVariableValue?: string;
public suppressMissingDependenciesErrors: boolean;
constructor(settings: IProjectReferenceSettings) { constructor(settings: IProjectReferenceSettings) {
super(settings.projectRelativePath!, '', EntryType.DatabaseReference); super(settings.projectRelativePath!, /* relativePath doesn't get set for database references */ '', EntryType.DatabaseReference);
this.projectName = settings.projectName; this.projectName = settings.projectName;
this.projectGuid = settings.projectGuid; this.projectGuid = settings.projectGuid;
this.databaseSqlCmdVariable = settings.databaseVariable;
this.databaseVariableLiteralValue = settings.databaseName;
this.serverName = settings.serverName;
this.serverSqlCmdVariable = settings.serverVariable;
this.suppressMissingDependenciesErrors = settings.suppressMissingDependenciesErrors; this.suppressMissingDependenciesErrors = settings.suppressMissingDependenciesErrors;
this.databaseVariableLiteralValue = settings.databaseVariableLiteralValue;
this.databaseSqlCmdVariableName = settings.databaseName;
this.databaseSqlCmdVariableValue = settings.databaseVariable;
this.serverSqlCmdVariableName = settings.serverName;
this.serverSqlCmdVariableValue = settings.serverVariable;
} }
public get databaseName(): string { public get referenceName(): string {
return this.projectName; return this.projectName;
} }
@@ -136,8 +135,3 @@ export enum DatabaseReferenceLocation {
differentDatabaseSameServer, differentDatabaseSameServer,
differentDatabaseDifferentServer differentDatabaseDifferentServer
} }
export enum SystemDatabase {
master,
msdb
}

5
extensions/sql-database-projects/src/models/tree/baseTreeItem.ts
View File

@@ -5,6 +5,7 @@
import * as vscode from 'vscode'; import * as vscode from 'vscode';
import * as path from 'path'; import * as path from 'path';
import { DatabaseProjectItemType } from '../../common/constants';
/** /**
* Base class for an item that appears in the ADS project tree * Base class for an item that appears in the ADS project tree
@@ -21,6 +22,10 @@ export abstract class BaseProjectTreeItem {
abstract get treeItem(): vscode.TreeItem; abstract get treeItem(): vscode.TreeItem;
abstract get type(): DatabaseProjectItemType;
public entryKey?: string;
public get friendlyName(): string { public get friendlyName(): string {
return path.parse(this.relativeProjectUri.path).base; return path.parse(this.relativeProjectUri.path).base;
} }

18
extensions/sql-database-projects/src/models/tree/databaseReferencesTreeItem.ts
View File

@@ -26,7 +26,6 @@ export class DatabaseReferencesTreeItem extends BaseProjectTreeItem {
*/ */
constructor(projectNodeName: string, sqlprojUri: vscode.Uri, databaseReferences: IDatabaseReferenceProjectEntry[]) { constructor(projectNodeName: string, sqlprojUri: vscode.Uri, databaseReferences: IDatabaseReferenceProjectEntry[]) {
super(vscode.Uri.file(path.join(projectNodeName, constants.databaseReferencesNodeName)), sqlprojUri); super(vscode.Uri.file(path.join(projectNodeName, constants.databaseReferencesNodeName)), sqlprojUri);
this.construct(databaseReferences); this.construct(databaseReferences);
} }
@@ -44,9 +43,13 @@ export class DatabaseReferencesTreeItem extends BaseProjectTreeItem {
return this.references; return this.references;
} }
public get type(): constants.DatabaseProjectItemType {
return constants.DatabaseProjectItemType.referencesRoot;
}
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const refFolderItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.Collapsed); const refFolderItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.Collapsed);
refFolderItem.contextValue = constants.DatabaseProjectItemType.referencesRoot; refFolderItem.contextValue = this.type;
refFolderItem.iconPath = IconPathHelper.referenceGroup; refFolderItem.iconPath = IconPathHelper.referenceGroup;
return refFolderItem; return refFolderItem;
@@ -55,17 +58,22 @@ export class DatabaseReferencesTreeItem extends BaseProjectTreeItem {
export class DatabaseReferenceTreeItem extends BaseProjectTreeItem { export class DatabaseReferenceTreeItem extends BaseProjectTreeItem {
constructor(private reference: IDatabaseReferenceProjectEntry, referencesNodeRelativeProjectUri: vscode.Uri, sqlprojUri: vscode.Uri) { constructor(private reference: IDatabaseReferenceProjectEntry, referencesNodeRelativeProjectUri: vscode.Uri, sqlprojUri: vscode.Uri) {
super(vscode.Uri.file(path.join(referencesNodeRelativeProjectUri.fsPath, reference.databaseName)), sqlprojUri); super(vscode.Uri.file(path.join(referencesNodeRelativeProjectUri.fsPath, reference.referenceName)), sqlprojUri);
this.entryKey = this.friendlyName;
} }
public get children(): BaseProjectTreeItem[] { public get children(): BaseProjectTreeItem[] {
return []; return [];
} }
public get type(): constants.DatabaseProjectItemType {
return constants.DatabaseProjectItemType.reference;
}
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const refItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.None); const refItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.None);
refItem.label = this.reference.databaseName; refItem.label = this.reference.referenceName;
refItem.contextValue = constants.DatabaseProjectItemType.reference; refItem.contextValue = this.type;
refItem.iconPath = IconPathHelper.referenceDatabase; refItem.iconPath = IconPathHelper.referenceDatabase;
return refItem; return refItem;

56
extensions/sql-database-projects/src/models/tree/fileFolderTreeItem.ts
View File

@@ -16,19 +16,25 @@ import { IconPathHelper } from '../../common/iconHelper';
export class FolderNode extends BaseProjectTreeItem { export class FolderNode extends BaseProjectTreeItem {
public fileChildren: { [childName: string]: (FolderNode | FileNode) } = {}; public fileChildren: { [childName: string]: (FolderNode | FileNode) } = {};
public fileSystemUri: vscode.Uri; public fileSystemUri: vscode.Uri;
public override entryKey: string;
constructor(folderPath: vscode.Uri, sqlprojUri: vscode.Uri) { constructor(folderPath: vscode.Uri, sqlprojUri: vscode.Uri, entryKey: string) {
super(fsPathToProjectUri(folderPath, sqlprojUri), sqlprojUri); super(fsPathToProjectUri(folderPath, sqlprojUri), sqlprojUri);
this.fileSystemUri = folderPath; this.fileSystemUri = folderPath;
this.entryKey = entryKey;
} }
public get children(): BaseProjectTreeItem[] { public get children(): BaseProjectTreeItem[] {
return Object.values(this.fileChildren).sort(sortFileFolderNodes); return Object.values(this.fileChildren).sort(sortFileFolderNodes);
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.folder;
}
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const folderItem = new vscode.TreeItem(this.fileSystemUri, vscode.TreeItemCollapsibleState.Collapsed); const folderItem = new vscode.TreeItem(this.fileSystemUri, vscode.TreeItemCollapsibleState.Collapsed);
folderItem.contextValue = DatabaseProjectItemType.folder; folderItem.contextValue = this.type;
folderItem.iconPath = IconPathHelper.folder; folderItem.iconPath = IconPathHelper.folder;
return folderItem; return folderItem;
@@ -40,10 +46,12 @@ export class FolderNode extends BaseProjectTreeItem {
*/ */
export abstract class FileNode extends BaseProjectTreeItem { export abstract class FileNode extends BaseProjectTreeItem {
public fileSystemUri: vscode.Uri; public fileSystemUri: vscode.Uri;
public override entryKey: string;
constructor(filePath: vscode.Uri, sqlprojUri: vscode.Uri) { constructor(filePath: vscode.Uri, sqlprojUri: vscode.Uri, entryKey: string) {
super(fsPathToProjectUri(filePath, sqlprojUri, true), sqlprojUri); super(fsPathToProjectUri(filePath, sqlprojUri, true), sqlprojUri);
this.fileSystemUri = filePath; this.fileSystemUri = filePath;
this.entryKey = entryKey;
} }
public get children(): BaseProjectTreeItem[] { public get children(): BaseProjectTreeItem[] {
@@ -68,64 +76,92 @@ export abstract class FileNode extends BaseProjectTreeItem {
export class SqlObjectFileNode extends FileNode { export class SqlObjectFileNode extends FileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.sqlObjectScript; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.sqlObjectScript;
}
} }
export class ExternalStreamingJobFileNode extends SqlObjectFileNode { export class ExternalStreamingJobFileNode extends SqlObjectFileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.externalStreamingJob; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public override get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.externalStreamingJob;
}
} }
export class TableFileNode extends SqlObjectFileNode { export class TableFileNode extends SqlObjectFileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.table; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public override get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.table;
}
} }
export class PreDeployNode extends FileNode { export class PreDeployNode extends FileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.preDeploymentScript; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.preDeploymentScript;
}
} }
export class PostDeployNode extends FileNode { export class PostDeployNode extends FileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.postDeploymentScript; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.postDeploymentScript;
}
} }
export class NoneNode extends FileNode { export class NoneNode extends FileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.noneFile; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.noneFile;
}
} }
export class PublishProfileNode extends FileNode { export class PublishProfileNode extends FileNode {
public override get treeItem(): vscode.TreeItem { public override get treeItem(): vscode.TreeItem {
const treeItem = super.treeItem; const treeItem = super.treeItem;
treeItem.contextValue = DatabaseProjectItemType.publishProfile; treeItem.contextValue = this.type;
return treeItem; return treeItem;
} }
public get type(): DatabaseProjectItemType {
return DatabaseProjectItemType.publishProfile;
}
} }
/** /**

64
extensions/sql-database-projects/src/models/tree/projectTreeItem.ts
View File

@@ -10,12 +10,13 @@ import * as fileTree from './fileFolderTreeItem';
import { Project } from '../project'; import { Project } from '../project';
import * as utils from '../../common/utils'; import * as utils from '../../common/utils';
import { DatabaseReferencesTreeItem } from './databaseReferencesTreeItem'; import { DatabaseReferencesTreeItem } from './databaseReferencesTreeItem';
import { DatabaseProjectItemType, RelativeOuterPath, ExternalStreamingJob, sqlprojExtension, CollapseProjectNodesKey } from '../../common/constants'; import { DatabaseProjectItemType, RelativeOuterPath, ExternalStreamingJob, sqlprojExtension, CollapseProjectNodesKey, errorPrefix } from '../../common/constants';
import { IconPathHelper } from '../../common/iconHelper'; import { IconPathHelper } from '../../common/iconHelper';
import { FileProjectEntry } from '../projectEntry'; import { FileProjectEntry } from '../projectEntry';
import { EntryType } from 'sqldbproj'; import { EntryType } from 'sqldbproj';
import { DBProjectConfigurationKey } from '../../tools/netcoreTool'; import { DBProjectConfigurationKey } from '../../tools/netcoreTool';
import { SqlCmdVariablesTreeItem } from './sqlcmdVariableTreeItem'; import { SqlCmdVariablesTreeItem } from './sqlcmdVariableTreeItem';
import { ProjectType } from 'mssql';
/** /**
* TreeNode root that represents an entire project * TreeNode root that represents an entire project
@@ -51,62 +52,62 @@ export class ProjectRootTreeItem extends BaseProjectTreeItem {
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const collapsibleState = vscode.workspace.getConfiguration(DBProjectConfigurationKey)[CollapseProjectNodesKey] ? vscode.TreeItemCollapsibleState.Collapsed : vscode.TreeItemCollapsibleState.Expanded; const collapsibleState = vscode.workspace.getConfiguration(DBProjectConfigurationKey)[CollapseProjectNodesKey] ? vscode.TreeItemCollapsibleState.Collapsed : vscode.TreeItemCollapsibleState.Expanded;
const projectItem = new vscode.TreeItem(this.fileSystemUri, collapsibleState); const projectItem = new vscode.TreeItem(this.fileSystemUri, collapsibleState);
projectItem.contextValue = this.project.isSdkStyleProject ? DatabaseProjectItemType.project : DatabaseProjectItemType.legacyProject; projectItem.contextValue = this.type;
projectItem.iconPath = IconPathHelper.databaseProject; projectItem.iconPath = IconPathHelper.databaseProject;
projectItem.label = this.projectNodeName; projectItem.label = this.projectNodeName;
return projectItem; return projectItem;
} }
public get type(): DatabaseProjectItemType {
return this.project.sqlProjStyle === ProjectType.SdkStyle ? DatabaseProjectItemType.project : DatabaseProjectItemType.legacyProject;
}
/** /**
* Processes the list of files in a project file to constructs the tree * Processes the list of files in a project file to constructs the tree
*/ */
private construct() { private construct() {
// folders
// Note: folders must be sorted to ensure that parent folders come before their children
for (const folder of this.project.folders.sort((a, b) => a.relativePath < b.relativePath ? -1 : (a.relativePath > b.relativePath ? 1 : 0))) {
const newNode = new fileTree.FolderNode(folder.fsUri, this.projectFileUri, folder.relativePath);
this.addNode(newNode, folder);
}
// pre deploy scripts // pre deploy scripts
for (const preDeployEntry of this.project.preDeployScripts) { for (const preDeployEntry of this.project.preDeployScripts) {
const newNode = new fileTree.PreDeployNode(preDeployEntry.fsUri, this.projectFileUri); const newNode = new fileTree.PreDeployNode(preDeployEntry.fsUri, this.projectFileUri, preDeployEntry.relativePath);
this.addNode(newNode, preDeployEntry); this.addNode(newNode, preDeployEntry);
} }
// post deploy scripts // post deploy scripts
for (const postDeployEntry of this.project.postDeployScripts) { for (const postDeployEntry of this.project.postDeployScripts) {
const newNode = new fileTree.PostDeployNode(postDeployEntry.fsUri, this.projectFileUri); const newNode = new fileTree.PostDeployNode(postDeployEntry.fsUri, this.projectFileUri, postDeployEntry.relativePath);
this.addNode(newNode, postDeployEntry); this.addNode(newNode, postDeployEntry);
} }
// none scripts // none scripts
for (const noneEntry of this.project.noneDeployScripts) { for (const noneEntry of this.project.noneDeployScripts) {
const newNode = new fileTree.NoneNode(noneEntry.fsUri, this.projectFileUri); const newNode = new fileTree.NoneNode(noneEntry.fsUri, this.projectFileUri, noneEntry.relativePath);
this.addNode(newNode, noneEntry); this.addNode(newNode, noneEntry);
} }
// publish profiles // publish profiles
for (const publishProfile of this.project.publishProfiles) { for (const publishProfile of this.project.publishProfiles) {
const newNode = new fileTree.PublishProfileNode(publishProfile.fsUri, this.projectFileUri); const newNode = new fileTree.PublishProfileNode(publishProfile.fsUri, this.projectFileUri, publishProfile.relativePath);
this.addNode(newNode, publishProfile); this.addNode(newNode, publishProfile);
} }
// sql object scripts and folders // sql object scripts
for (const entry of this.project.files) { for (const entry of this.project.files) {
let newNode: fileTree.FolderNode | fileTree.FileNode; let newNode: fileTree.FileNode;
switch (entry.type) {
case EntryType.File:
if (entry.sqlObjectType === ExternalStreamingJob) { if (entry.sqlObjectType === ExternalStreamingJob) {
newNode = new fileTree.ExternalStreamingJobFileNode(entry.fsUri, this.projectFileUri); newNode = new fileTree.ExternalStreamingJobFileNode(entry.fsUri, this.projectFileUri, entry.relativePath);
} else if (entry.containsCreateTableStatement) { } else if (entry.containsCreateTableStatement) {
newNode = new fileTree.TableFileNode(entry.fsUri, this.projectFileUri); newNode = new fileTree.TableFileNode(entry.fsUri, this.projectFileUri, entry.relativePath);
} } else {
else { newNode = new fileTree.SqlObjectFileNode(entry.fsUri, this.projectFileUri, entry.relativePath);
newNode = new fileTree.SqlObjectFileNode(entry.fsUri, this.projectFileUri);
}
break;
case EntryType.Folder:
newNode = new fileTree.FolderNode(entry.fsUri, this.projectFileUri);
break;
default:
throw new Error(`Unknown EntryType: '${entry.type}'`);
} }
this.addNode(newNode, entry); this.addNode(newNode, entry);
@@ -138,23 +139,26 @@ export class ProjectRootTreeItem extends BaseProjectTreeItem {
return this; // if nothing left after trimming the entry itself, must been root return this; // if nothing left after trimming the entry itself, must been root
} }
if (relativePathParts[0] === RelativeOuterPath) { if (relativePathParts[0] === RelativeOuterPath) { // scripts external to the project folder are always parented by the project root node because external folders aren't supported
return this; return this;
} }
let current: fileTree.FolderNode | ProjectRootTreeItem = this; let current: fileTree.FolderNode | ProjectRootTreeItem = this; // start with the Project root node
for (const part of relativePathParts) { for (const part of relativePathParts) { // iterate from the project root, down the path to the entry in question
if (current.fileChildren[part] === undefined) { if (current.fileChildren[part] === undefined) {
const parentPath = current instanceof ProjectRootTreeItem ? path.dirname(current.fileSystemUri.fsPath) : current.fileSystemUri.fsPath; // DacFx.Projects populates the list of folders with those implicitly included via parentage.
current.fileChildren[part] = new fileTree.FolderNode(vscode.Uri.file(path.join(parentPath, part)), this.projectFileUri); // e.g. <Folder Include="MySchema\Tables"> and <Build Include="MySchema\SomeScript.sql"> both result in the "MySchema" folder being automatically added,
// even if there's no <Folder Include="MySchema"> entry.
// Project tree unit tests need to explicitly include parent folders because they bypass DacFx's logic, or they'll hit this error.
throw new Error(errorPrefix(`All parent nodes for ${relativePathParts} should have already been added.`));
} }
if (current.fileChildren[part] instanceof fileTree.FileNode) { if (current.fileChildren[part] instanceof fileTree.FileNode) {
return current; return current; // if we've made it to the node in question, we're done
} }
else { else {
current = current.fileChildren[part] as fileTree.FolderNode | ProjectRootTreeItem; current = current.fileChildren[part] as fileTree.FolderNode; // otherwise, shift the current node down, and repeat
} }
} }

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

@@ -45,9 +45,13 @@ export class SqlCmdVariablesTreeItem extends BaseProjectTreeItem {
return this.sqlcmdVariableTreeItems; return this.sqlcmdVariableTreeItems;
} }
public get type(): constants.DatabaseProjectItemType {
return constants.DatabaseProjectItemType.sqlcmdVariablesRoot;
}
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const sqlCmdVariableFolderItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.Collapsed); const sqlCmdVariableFolderItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.Collapsed);
sqlCmdVariableFolderItem.contextValue = constants.DatabaseProjectItemType.sqlcmdVariablesRoot; sqlCmdVariableFolderItem.contextValue = this.type;
sqlCmdVariableFolderItem.iconPath = IconPathHelper.sqlCmdVariablesGroup; sqlCmdVariableFolderItem.iconPath = IconPathHelper.sqlCmdVariablesGroup;
return sqlCmdVariableFolderItem; return sqlCmdVariableFolderItem;
@@ -60,16 +64,21 @@ export class SqlCmdVariablesTreeItem extends BaseProjectTreeItem {
export class SqlCmdVariableTreeItem extends BaseProjectTreeItem { export class SqlCmdVariableTreeItem extends BaseProjectTreeItem {
constructor(private sqlcmdVar: string, sqlCmdNodeRelativeProjectUri: vscode.Uri, sqlprojUri: vscode.Uri,) { constructor(private sqlcmdVar: string, sqlCmdNodeRelativeProjectUri: vscode.Uri, sqlprojUri: vscode.Uri,) {
super(vscode.Uri.file(path.join(sqlCmdNodeRelativeProjectUri.fsPath, sqlcmdVar)), sqlprojUri); super(vscode.Uri.file(path.join(sqlCmdNodeRelativeProjectUri.fsPath, sqlcmdVar)), sqlprojUri);
this.entryKey = this.friendlyName;
} }
public get children(): BaseProjectTreeItem[] { public get children(): BaseProjectTreeItem[] {
return []; return [];
} }
public get type(): constants.DatabaseProjectItemType {
return constants.DatabaseProjectItemType.sqlcmdVariable;
}
public get treeItem(): vscode.TreeItem { public get treeItem(): vscode.TreeItem {
const sqlcmdVariableItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.None); const sqlcmdVariableItem = new vscode.TreeItem(this.relativeProjectUri, vscode.TreeItemCollapsibleState.None);
sqlcmdVariableItem.label = this.sqlcmdVar; sqlcmdVariableItem.label = this.sqlcmdVar;
sqlcmdVariableItem.contextValue = constants.DatabaseProjectItemType.sqlcmdVariable; sqlcmdVariableItem.contextValue = this.type;
sqlcmdVariableItem.iconPath = IconPathHelper.sqlCmdVariable; sqlcmdVariableItem.iconPath = IconPathHelper.sqlCmdVariable;
return sqlcmdVariableItem; return sqlcmdVariableItem;

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

@@ -40,7 +40,7 @@ export class SqlDatabaseProjectProvider implements dataworkspace.IProjectProvide
*/ */
public async getProjectTreeDataProvider(projectFilePath: vscode.Uri): Promise<vscode.TreeDataProvider<BaseProjectTreeItem>> { public async getProjectTreeDataProvider(projectFilePath: vscode.Uri): Promise<vscode.TreeDataProvider<BaseProjectTreeItem>> {
const provider = new SqlDatabaseProjectTreeViewProvider(); const provider = new SqlDatabaseProjectTreeViewProvider();
const project = await Project.openProject(projectFilePath.fsPath); const project = await Project.openProject(projectFilePath.fsPath, true, true);
// open project in STS // open project in STS
const sqlProjectsService = await getSqlProjectsService(); const sqlProjectsService = await getSqlProjectsService();
@@ -112,7 +112,7 @@ export class SqlDatabaseProjectProvider implements dataworkspace.IProjectProvide
* Opens and loads a .sqlproj file * Opens and loads a .sqlproj file
*/ */
public openProject(projectFilePath: string): Promise<sqldbproj.ISqlProject> { public openProject(projectFilePath: string): Promise<sqldbproj.ISqlProject> {
return Project.openProject(projectFilePath); return Project.openProject(projectFilePath, true, true);
} }
public addItemPrompt(project: sqldbproj.ISqlProject, relativeFilePath: string, options?: sqldbproj.AddItemOptions): Promise<void> { public addItemPrompt(project: sqldbproj.ISqlProject, relativeFilePath: string, options?: sqldbproj.AddItemOptions): Promise<void> {

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

@@ -149,18 +149,35 @@ declare module 'sqldbproj' {
readProjFile(): Promise<void>; readProjFile(): Promise<void>;
/** /**
* Adds the list of sql files and directories to the project, and saves the project file * Adds a pre-deployment script
* * @param relativePath
* @param list list of files and folder Uris. Files and folders must already exist. No files or folders will be added if any do not exist.
*/ */
addToProject(list: vscode.Uri[]): Promise<void>; addPreDeploymentScript(relativePath: string): Promise<void>;
/**
* Adds a post-deployment script
* @param relativePath
*/
addPostDeploymentScript(relativePath: string): Promise<void>;
/**
* Add a SQL object script that will be included in the schema
* @param relativePath
*/
addSqlObjectScript(relativePath: string): Promise<void>;
/**
* Adds multiple SQL object scripts that will be included in the schema
* @param relativePaths Array of paths relative to the .sqlproj file
*/
addSqlObjectScripts(relativePaths: string[]): Promise<void>;
/** /**
* Adds a folder to the project, and saves the project file * Adds a folder to the project, and saves the project file
* *
* @param relativeFolderPath Relative path of the folder * @param relativeFolderPath Relative path of the folder
*/ */
addFolderItem(relativeFolderPath: string): Promise<IFileProjectEntry>; addFolder(relativeFolderPath: string): Promise<void>;
/** /**
* Writes a file to disk if contents are provided, adds that file to the project, and writes it to disk * Writes a file to disk if contents are provided, adds that file to the project, and writes it to disk
@@ -194,18 +211,6 @@ declare module 'sqldbproj' {
*/ */
removeDatabaseSource(databaseSource: string): Promise<void>; removeDatabaseSource(databaseSource: string): Promise<void>;
/**
* Excludes entry from project by removing it from the project file
* @param entry
*/
exclude(entry: IFileProjectEntry): Promise<void>;
/**
* Deletes file or folder and removes it from the project file
* @param entry
*/
deleteFileFolder(entry: IFileProjectEntry): Promise<void>;
/** /**
* returns the sql version the project is targeting * returns the sql version the project is targeting
*/ */
@@ -290,7 +295,7 @@ declare module 'sqldbproj' {
* Represents a database reference entry in a project file * Represents a database reference entry in a project file
*/ */
export interface IDatabaseReferenceProjectEntry extends IFileProjectEntry { export interface IDatabaseReferenceProjectEntry extends IFileProjectEntry {
databaseName: string; referenceName: string;
databaseVariableLiteralValue?: string; databaseVariableLiteralValue?: string;
suppressMissingDependenciesErrors: boolean; suppressMissingDependenciesErrors: boolean;
} }

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

@@ -77,7 +77,7 @@ export function macroExpansion(template: string, macroDict: Record<string, strin
return output; return output;
} }
async function loadObjectTypeInfo(key: string, friendlyName: string, templateFolderPath: string, fileName: string): Promise<string> { async function loadObjectTypeInfo(key: ItemType, friendlyName: string, templateFolderPath: string, fileName: string): Promise<string> {
const template = await loadTemplate(templateFolderPath, fileName); const template = await loadTemplate(templateFolderPath, fileName);
scriptTypes.push(new ProjectScriptType(key, friendlyName, template)); scriptTypes.push(new ProjectScriptType(key, friendlyName, template));
@@ -89,11 +89,11 @@ async function loadTemplate(templateFolderPath: string, fileName: string): Promi
} }
export class ProjectScriptType { export class ProjectScriptType {
type: string; type: ItemType;
friendlyName: string; friendlyName: string;
templateScript: string; templateScript: string;
constructor(type: string, friendlyName: string, templateScript: string) { constructor(type: ItemType, friendlyName: string, templateScript: string) {
this.type = type; this.type = type;
this.friendlyName = friendlyName; this.friendlyName = friendlyName;
this.templateScript = templateScript; this.templateScript = templateScript;

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

@@ -25,7 +25,7 @@ describe('Autorest tests', function (): void {
sinon.restore(); sinon.restore();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
@@ -41,7 +41,7 @@ describe('Autorest tests', function (): void {
sinon.stub(window, 'showInformationMessage').returns(<any>Promise.resolve(runViaNpx)); // stub a selection in case test runner doesn't have autorest installed sinon.stub(window, 'showInformationMessage').returns(<any>Promise.resolve(runViaNpx)); // stub a selection in case test runner doesn't have autorest installed
const autorestHelper = new AutorestHelper(testContext.outputChannel); const autorestHelper = new AutorestHelper(testContext.outputChannel);
const dummyFile = path.join(await testUtils.generateTestFolderPath(), 'testoutput.log'); const dummyFile = path.join(await testUtils.generateTestFolderPath(this.test), 'testoutput.log');
sinon.stub(autorestHelper, 'constructAutorestCommand').returns(`${await autorestHelper.detectInstallation()} --version > ${dummyFile}`); sinon.stub(autorestHelper, 'constructAutorestCommand').returns(`${await autorestHelper.detectInstallation()} --version > ${dummyFile}`);
try { try {

89
extensions/sql-database-projects/src/test/baselines/SSDTProjectAfterUpdateBaseline.xml
View File

@@ -1,89 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
</Project>

80
extensions/sql-database-projects/src/test/baselines/SSDTProjectBaselineWithBeforeBuildTargetAfterUpdate.xml
View File

@@ -1,80 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Target Name="BeforeBuild">
<!-- Custom logic added by user -->
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
</Project>

97
extensions/sql-database-projects/src/test/baselines/SSDTUpdatedProjectAfterSystemDbUpdateBaseline.xml
View File

@@ -1,97 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\msdb.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>msdb</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\msdb.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>msdb</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
</Project>

28
extensions/sql-database-projects/src/test/baselines/baselines.ts
View File

@@ -9,25 +9,16 @@ import { promises as fs } from 'fs';
// Project baselines // Project baselines
export let newProjectFileBaseline: string; export let newProjectFileBaseline: string;
export let newProjectFileWithScriptBaseline: string; export let newProjectFileWithScriptBaseline: string;
export let newProjectFileNoPropertiesFolderBaseline: string;
export let openProjectFileBaseline: string; export let openProjectFileBaseline: string;
export let openProjectFileReleaseConfigurationBaseline: string;
export let openProjectFileUnknownConfigurationBaseline: string;
export let openProjectFileSingleOutputPathBaseline: string;
export let openProjectFileMultipleOutputPathBaseline: string;
export let openDataSourcesBaseline: string; export let openDataSourcesBaseline: string;
export let SSDTProjectFileBaseline: string; export let SSDTProjectFileBaseline: string;
export let SSDTProjectAfterUpdateBaseline: string;
export let SSDTUpdatedProjectBaseline: string; export let SSDTUpdatedProjectBaseline: string;
export let SSDTUpdatedProjectAfterSystemDbUpdateBaseline: string;
export let SSDTProjectBaselineWithBeforeBuildTarget: string; export let SSDTProjectBaselineWithBeforeBuildTarget: string;
export let SSDTProjectBaselineWithBeforeBuildTargetAfterUpdate: string;
export let publishProfileIntegratedSecurityBaseline: string; export let publishProfileIntegratedSecurityBaseline: string;
export let publishProfileSqlLoginBaseline: string; export let publishProfileSqlLoginBaseline: string;
export let publishProfileDefaultValueBaseline: string; export let publishProfileDefaultValueBaseline: string;
export let openProjectWithProjectReferencesBaseline: string; export let openProjectWithProjectReferencesBaseline: string;
export let openSqlProjectWithPrePostDeploymentError: string; export let openSqlProjectWithPrePostDeploymentError: string;
export let openSqlProjectWithAdditionalSqlCmdVariablesBaseline: string;
export let sqlProjectMissingVersionBaseline: string; export let sqlProjectMissingVersionBaseline: string;
export let sqlProjectInvalidVersionBaseline: string; export let sqlProjectInvalidVersionBaseline: string;
export let sqlProjectCustomCollationBaseline: string; export let sqlProjectCustomCollationBaseline: string;
@@ -38,34 +29,24 @@ export let newStyleProjectSdkImportAttributeBaseline: string;
export let openSdkStyleSqlProjectBaseline: string; export let openSdkStyleSqlProjectBaseline: string;
export let openSdkStyleSqlProjectWithFilesSpecifiedBaseline: string; export let openSdkStyleSqlProjectWithFilesSpecifiedBaseline: string;
export let openSdkStyleSqlProjectWithGlobsSpecifiedBaseline: string; export let openSdkStyleSqlProjectWithGlobsSpecifiedBaseline: string;
export let openSdkStyleSqlProjectWithBuildRemoveBaseline: string; export let sqlProjPropertyReadBaseline: string;
export let openSdkStyleSqlProjectNoProjectGuidBaseline: string; export let databaseReferencesReadBaseline: string;
export let openSqlProjectWithAdditionalPublishProfileBaseline: string;
const baselineFolderPath = __dirname; const baselineFolderPath = __dirname;
export async function loadBaselines() { export async function loadBaselines() {
newProjectFileBaseline = await loadBaseline(baselineFolderPath, 'newSqlProjectBaseline.xml'); newProjectFileBaseline = await loadBaseline(baselineFolderPath, 'newSqlProjectBaseline.xml');
newProjectFileWithScriptBaseline = await loadBaseline(baselineFolderPath, 'newSqlProjectWithScriptBaseline.xml'); newProjectFileWithScriptBaseline = await loadBaseline(baselineFolderPath, 'newSqlProjectWithScriptBaseline.xml');
newProjectFileNoPropertiesFolderBaseline = await loadBaseline(baselineFolderPath, 'newSqlProjectNoPropertiesFolderBaseline.xml');
openProjectFileBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectBaseline.xml'); openProjectFileBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectBaseline.xml');
openProjectFileReleaseConfigurationBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectReleaseConfigurationBaseline.xml');
openProjectFileUnknownConfigurationBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectUnknownConfigurationBaseline.xml');
openProjectFileSingleOutputPathBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectSingleOutputPathBaseline.xml');
openProjectFileMultipleOutputPathBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectMultipleOutputPathBaseline.xml');
openDataSourcesBaseline = await loadBaseline(baselineFolderPath, 'openDataSourcesBaseline.json'); openDataSourcesBaseline = await loadBaseline(baselineFolderPath, 'openDataSourcesBaseline.json');
SSDTProjectFileBaseline = await loadBaseline(baselineFolderPath, 'SSDTProjectBaseline.xml'); SSDTProjectFileBaseline = await loadBaseline(baselineFolderPath, 'SSDTProjectBaseline.xml');
SSDTProjectAfterUpdateBaseline = await loadBaseline(baselineFolderPath, 'SSDTProjectAfterUpdateBaseline.xml');
SSDTUpdatedProjectBaseline = await loadBaseline(baselineFolderPath, 'SSDTUpdatedProjectBaseline.xml'); SSDTUpdatedProjectBaseline = await loadBaseline(baselineFolderPath, 'SSDTUpdatedProjectBaseline.xml');
SSDTUpdatedProjectAfterSystemDbUpdateBaseline = await loadBaseline(baselineFolderPath, 'SSDTUpdatedProjectAfterSystemDbUpdateBaseline.xml');
SSDTProjectBaselineWithBeforeBuildTarget = await loadBaseline(baselineFolderPath, 'SSDTProjectBaselineWithBeforeBuildTarget.xml'); SSDTProjectBaselineWithBeforeBuildTarget = await loadBaseline(baselineFolderPath, 'SSDTProjectBaselineWithBeforeBuildTarget.xml');
SSDTProjectBaselineWithBeforeBuildTargetAfterUpdate = await loadBaseline(baselineFolderPath, 'SSDTProjectBaselineWithBeforeBuildTargetAfterUpdate.xml');
publishProfileIntegratedSecurityBaseline = await loadBaseline(baselineFolderPath, 'publishProfileIntegratedSecurityBaseline.publish.xml'); publishProfileIntegratedSecurityBaseline = await loadBaseline(baselineFolderPath, 'publishProfileIntegratedSecurityBaseline.publish.xml');
publishProfileSqlLoginBaseline = await loadBaseline(baselineFolderPath, 'publishProfileSqlLoginBaseline.publish.xml'); publishProfileSqlLoginBaseline = await loadBaseline(baselineFolderPath, 'publishProfileSqlLoginBaseline.publish.xml');
publishProfileDefaultValueBaseline = await loadBaseline(baselineFolderPath, 'publishProfileDefaultValueBaseline.publish.xml'); publishProfileDefaultValueBaseline = await loadBaseline(baselineFolderPath, 'publishProfileDefaultValueBaseline.publish.xml');
openProjectWithProjectReferencesBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectWithProjectReferenceBaseline.xml'); openProjectWithProjectReferencesBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectWithProjectReferenceBaseline.xml');
openSqlProjectWithPrePostDeploymentError = await loadBaseline(baselineFolderPath, 'openSqlProjectWithPrePostDeploymentError.xml'); openSqlProjectWithPrePostDeploymentError = await loadBaseline(baselineFolderPath, 'openSqlProjectWithPrePostDeploymentError.xml');
openSqlProjectWithAdditionalSqlCmdVariablesBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectWithAdditionalSqlCmdVariablesBaseline.xml');
sqlProjectMissingVersionBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectMissingVersionBaseline.xml'); sqlProjectMissingVersionBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectMissingVersionBaseline.xml');
sqlProjectInvalidVersionBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectInvalidVersionBaseline.xml'); sqlProjectInvalidVersionBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectInvalidVersionBaseline.xml');
sqlProjectCustomCollationBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectCustomCollationBaseline.xml'); sqlProjectCustomCollationBaseline = await loadBaseline(baselineFolderPath, 'sqlProjectCustomCollationBaseline.xml');
@@ -76,9 +57,8 @@ export async function loadBaselines() {
openSdkStyleSqlProjectBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectBaseline.xml'); openSdkStyleSqlProjectBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectBaseline.xml');
openSdkStyleSqlProjectWithFilesSpecifiedBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectWithFilesSpecifiedBaseline.xml'); openSdkStyleSqlProjectWithFilesSpecifiedBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectWithFilesSpecifiedBaseline.xml');
openSdkStyleSqlProjectWithGlobsSpecifiedBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectWithGlobsSpecifiedBaseline.xml'); openSdkStyleSqlProjectWithGlobsSpecifiedBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectWithGlobsSpecifiedBaseline.xml');
openSdkStyleSqlProjectWithBuildRemoveBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectWithBuildRemoveBaseline.xml'); sqlProjPropertyReadBaseline = await loadBaseline(baselineFolderPath, 'sqlProjPropertyRead.xml');
openSdkStyleSqlProjectNoProjectGuidBaseline = await loadBaseline(baselineFolderPath, 'openSdkStyleSqlProjectNoProjectGuidBaseline.xml'); databaseReferencesReadBaseline = await loadBaseline(baselineFolderPath, 'databaseReferencesReadBaseline.xml');
openSqlProjectWithAdditionalPublishProfileBaseline = await loadBaseline(baselineFolderPath, 'openSqlProjectWithAdditionalPublishProfileBaseline.xml');
} }
async function loadBaseline(baselineFolderPath: string, fileName: string): Promise<string> { async function loadBaseline(baselineFolderPath: string, fileName: string): Promise<string> {

67
extensions/sql-database-projects/src/test/baselines/databaseReferencesReadBaseline.xml Normal file
View File

@@ -0,0 +1,67 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build">
<Sdk Name="Microsoft.Build.Sql" Version="0.1.3-preview" />
<PropertyGroup>
<Name>ReferenceTest</Name>
<ProjectGuid>{843865B6-7286-4DA7-ADA3-BD5EA485B40A}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<ModelCollation>1033, CI</ModelCollation>
</PropertyGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(SystemDacpacsLocation)\SystemDacpacs\150\msdb.dacpac">
<SuppressMissingDependenciesErrors>True</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>msdbLiteral</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\msdb.dacpac">
<SuppressMissingDependenciesErrors>True</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>msdbLiteral</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Include="..\ReferencedDacpac\ReferencedDacpac.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseSqlCmdVariable>dacpacDbVar</DatabaseSqlCmdVariable>
<ServerSqlCmdVariable>dacpacServerVar</ServerSqlCmdVariable>
</ArtifactReference>
<ArtifactReference Include="..\OtherDacpac\OtherDacpac.dacpac">
<SuppressMissingDependenciesErrors>True</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>OtherDacpacLiteral</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="projDbVar">
<DefaultValue>projDbVar</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="projServerVar">
<DefaultValue>projServerName</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="dacpacDbVar">
<DefaultValue>dacpacDbName</DefaultValue>
<Value>$(SqlCmdVar__3)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="dacpacServerVar">
<DefaultValue>dacpacServerName</DefaultValue>
<Value>$(SqlCmdVar__4)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ReferencedProject\ReferencedProject.sqlproj">
<Name>ReferencedProject</Name>
<Project>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</Project>
<Private>True</Private>
<SuppressMissingDependenciesErrors>True</SuppressMissingDependenciesErrors>
<DatabaseSqlCmdVariable>projDbVar</DatabaseSqlCmdVariable>
<ServerSqlCmdVariable>projServerVar</ServerSqlCmdVariable>
</ProjectReference>
<ProjectReference Include="..\OtherProject\OtherProject.sqlproj">
<Name>OtherProject</Name>
<Project>{C0DEBA11-BA5E-5EA7-ACE5-BABB1E70A575}</Project>
<Private>True</Private>
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>OtherProjLiteral</DatabaseVariableLiteralValue>
</ProjectReference>
</ItemGroup>
</Project>

64
extensions/sql-database-projects/src/test/baselines/newSqlProjectNoPropertiesFolderBaseline.xml
View File

@@ -1,64 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql160DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets"/>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

26
extensions/sql-database-projects/src/test/baselines/openSdkStyleSqlProjectNoProjectGuidBaseline.xml
View File

@@ -1,26 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build">
<Sdk Name="Microsoft.Build.Sql" Version="0.1.7-preview" />
<PropertyGroup>
<Name>TestProjectName</Name>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<ModelCollation>1033, CI</ModelCollation>
</PropertyGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
</Project>

37
extensions/sql-database-projects/src/test/baselines/openSdkStyleSqlProjectWithBuildRemoveBaseline.xml
View File

@@ -1,37 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build">
<Sdk Name="Microsoft.Build.Sql" Version="0.1.7-preview" />
<PropertyGroup>
<Name>TestProjectName</Name>
<ProjectGuid>{2C283C5D-9E4A-4313-8FF9-4E0CEE20B063}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<ModelCollation>1033, CI</ModelCollation>
</PropertyGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
<ItemGroup>
<Folder Include="Properties" />
</ItemGroup>
<ItemGroup>
<Build Include="..\other\folder1\file*.sql" />
<Build Remove="..\other\folder1\file1.sql" />
<Build Include="..\other\folder2\file2.sql" />
<Build Remove="..\other\folder2\**" />
<Build Remove="folder1\*.sql" />
<Build Include="folder1\file2.sql" />
<Build Remove="folder2\file3.sql" />
<Build Include="folder2\*.sql" />
<Build Remove="file1.sql" />
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(SystemDacpacsLocation)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
</Project>

114
extensions/sql-database-projects/src/test/baselines/openSqlProjectMultipleOutputPathBaseline.xml
View File

@@ -1,114 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<OutputPath>bin\other</OutputPath>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets"/>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

111
extensions/sql-database-projects/src/test/baselines/openSqlProjectReleaseConfigurationBaseline.xml
View File

@@ -1,111 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets"/>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

89
extensions/sql-database-projects/src/test/baselines/openSqlProjectSingleOutputPathBaseline.xml
View File

@@ -1,89 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
<OutputPath>..\otherFolder</OutputPath>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets"/>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

111
extensions/sql-database-projects/src/test/baselines/openSqlProjectUnknownConfigurationBaseline.xml
View File

@@ -1,111 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Unknown</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets"/>
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

117
extensions/sql-database-projects/src/test/baselines/openSqlProjectWithAdditionalPublishProfileBaseline.xml
View File

@@ -1,117 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>MyProdDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<ItemGroup>
<None Include="TestProjectName_1.publish.xml" />
<None Include="TestProjectName_2.publish.xml" />
<None Include="TestProjectName_3.publish.xml" />
<None Include="TestProjectName_4.publish.xml" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

120
extensions/sql-database-projects/src/test/baselines/openSqlProjectWithAdditionalSqlCmdVariablesBaseline.xml
View File

@@ -1,120 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<Name>TestProjectName</Name>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>4.1</ProjectVersion>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql150DatabaseSchemaProvider</DSP>
<OutputType>Database</OutputType>
<RootPath>
</RootPath>
<RootNamespace>TestProjectName</RootNamespace>
<AssemblyName>TestProjectName</AssemblyName>
<ModelCollation>1033, CI</ModelCollation>
<DefaultFileStructure>BySchemaAndSchemaType</DefaultFileStructure>
<DeployToDatabase>True</DeployToDatabase>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<TargetLanguage>CS</TargetLanguage>
<AppDesignerFolder>Properties</AppDesignerFolder>
<SqlServerVerification>False</SqlServerVerification>
<IncludeCompositeObjects>True</IncludeCompositeObjects>
<TargetDatabaseSet>True</TargetDatabaseSet>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<DefineDebug>false</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<DefineDebug>true</DefineDebug>
<DefineTrace>true</DefineTrace>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
<!-- Default to the v11.0 targets path if the targets file for the current VS version is not found -->
<SSDTExists Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets')">True</SSDTExists>
<VisualStudioVersion Condition="'$(SSDTExists)' == ''">11.0</VisualStudioVersion>
</PropertyGroup>
<Import Condition="'$(NetCoreBuild)' == 'true'" Project="$(NETCoreTargetsPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' != ''" Project="$(SQLDBExtensionsRefPath)\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<Import Condition="'$(NetCoreBuild)' != 'true' AND '$(SQLDBExtensionsRefPath)' == ''" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" />
<ItemGroup>
<PackageReference Condition="'$(NetCoreBuild)' == 'true'" Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties" />
<Folder Include="Tables" />
<Folder Include="Views" />
<Folder Include="Views\Maintenance" />
</ItemGroup>
<ItemGroup>
<Build Include="Tables\Users.sql" />
<Build Include="Tables\Action History.sql" />
<Build Include="Views\Maintenance\Database Performance.sql" />
<Build Include="..\Test\Test.sql" />
</ItemGroup>
<ItemGroup>
<Folder Include="Views\User" />
<Build Include="Views\User\Profile.sql" />
</ItemGroup>
<ItemGroup>
<Build Include="MyExternalStreamingJob.sql" Type="ExternalStreamingJob" />
</ItemGroup>
<ItemGroup>
<SqlCmdVariable Include="BackupDatabaseName">
<DefaultValue>MyBackupDatabase</DefaultValue>
<Value>$(SqlCmdVar__2)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="TestDatabaseName">
<DefaultValue>TestDb</DefaultValue>
<Value>$(SqlCmdVar__3)</Value>
</SqlCmdVariable>
<SqlCmdVariable Include="ProdDatabaseName">
<DefaultValue>NewProdName</DefaultValue>
<Value>$(SqlCmdVar__4)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ArtifactReference Condition="'$(NetCoreBuild)' == 'true'" Include="$(NETCoreTargetsPath)\SystemDacpacs\150\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
<ArtifactReference Condition="'$(NetCoreBuild)' != 'true'" Include="$(DacPacRootPath)\Extensions\Microsoft\SQLDB\Extensions\SqlServer\150\SqlSchemas\master.dacpac">
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseVariableLiteralValue>master</DatabaseVariableLiteralValue>
</ArtifactReference>
</ItemGroup>
<ItemGroup>
<PreDeploy Include="Script.PreDeployment1.sql" />
<None Include="Script.PreDeployment2.sql" />
</ItemGroup>
<ItemGroup>
<PostDeploy Include="Script.PostDeployment1.sql" />
<None Include="Tables\Script.PostDeployment1.sql" />
</ItemGroup>
<ItemGroup>
<None Include="TestProjectName_1.publish.xml" />
<None Include="TestProjectName_2.publish.xml" />
<None Include="TestProjectName_3.publish.xml" />
</ItemGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

12
extensions/sql-database-projects/src/test/baselines/openSqlProjectWithProjectReferenceBaseline.xml
View File

@@ -95,12 +95,18 @@
</ArtifactReference> </ArtifactReference>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\ReferencedProject\TestProject.sqlproj"> <SqlCmdVariable Include="ReferencedTestProjectName">
<Name>TestProjectName</Name> <DefaultValue>MyReferencedTestDatabase</DefaultValue>
<Value>$(SqlCmdVar__1)</Value>
</SqlCmdVariable>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ReferencedProject\ReferencedTestProject.sqlproj">
<Name>ReferencedTestProjectName</Name>
<Project>{f9008554-068f-4f91-979a-58bd1f7c8f6e}</Project> <Project>{f9008554-068f-4f91-979a-58bd1f7c8f6e}</Project>
<Private>True</Private> <Private>True</Private>
<SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors> <SuppressMissingDependenciesErrors>False</SuppressMissingDependenciesErrors>
<DatabaseSqlCmdVariable>TestProjectName</DatabaseSqlCmdVariable> <DatabaseSqlCmdVariable>ReferencedTestProjectName</DatabaseSqlCmdVariable>
</ProjectReference> </ProjectReference>
</ItemGroup> </ItemGroup>
<Target Name="BeforeBuild"> <Target Name="BeforeBuild">

18
extensions/sql-database-projects/src/test/baselines/sqlProjPropertyRead.xml Normal file
View File

@@ -0,0 +1,18 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build">
<Sdk Name="Microsoft.Build.Sql" Version="0.1.9-preview" />
<PropertyGroup>
<Name>SdkStyle</Name>
<ProjectGuid>{BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575}</ProjectGuid>
<DSP>Microsoft.Data.Tools.Schema.Sql.Sql130DatabaseSchemaProvider</DSP>
<ModelCollation>1041, CI</ModelCollation>
<Configuration>Release</Configuration>
<Platform>x64</Platform>
<OutputPath>CustomOutputPath\Dacpacs\</OutputPath>
<DefaultCollation>Japanese_CI_AS</DefaultCollation>
<DatabaseSource>oneSource;twoSource;redSource;blueSource</DatabaseSource>
</PropertyGroup>
<Target Name="BeforeBuild">
<Delete Files="$(BaseIntermediateOutputPath)\project.assets.json" />
</Target>
</Project>

14
extensions/sql-database-projects/src/test/buildHelper.test.ts
View File

@@ -9,26 +9,26 @@ import * as vscode from 'vscode';
import * as path from 'path'; import * as path from 'path';
import { BuildHelper } from '../tools/buildHelper'; import { BuildHelper } from '../tools/buildHelper';
import { TestContext, createContext } from './testContext'; import { TestContext, createContext } from './testContext';
import { ProjectType } from 'mssql';
describe('BuildHelper: Build Helper tests', function (): void { describe('BuildHelper: Build Helper tests', function (): void {
it('Should get correct build arguments for legacy-style projects', function (): void {
it('Should get correct build arguments', function (): void {
// update settings and validate // update settings and validate
const buildHelper = new BuildHelper(); const buildHelper = new BuildHelper();
const resultArg = buildHelper.constructBuildArguments('dummy\\project path\\more space in path', 'dummy\\dll path', false); const resultArg = buildHelper.constructBuildArguments('dummy\\project path\\more space in path', 'dummy\\dll path', ProjectType.LegacyStyle);
if (os.platform() === 'win32') { if (os.platform() === 'win32') {
should(resultArg).equal(' build "dummy\\\\project path\\\\more space in path" /p:NetCoreBuild=true /p:NETCoreTargetsPath="dummy\\\\dll path"'); should(resultArg).equal(' build "dummy\\\\project path\\\\more space in path" /p:NetCoreBuild=true /p:NETCoreTargetsPath="dummy\\\\dll path" /p:SystemDacpacsLocation="dummy\\\\dll path"');
} }
else { else {
should(resultArg).equal(' build "dummy/project path/more space in path" /p:NetCoreBuild=true /p:NETCoreTargetsPath="dummy/dll path"'); should(resultArg).equal(' build "dummy/project path/more space in path" /p:NetCoreBuild=true /p:NETCoreTargetsPath="dummy/dll path" /p:SystemDacpacsLocation="dummy/dll path"');
} }
}); });
it('Should get correct build arguments for sdk style projects', function (): void { it('Should get correct build arguments for SDK-style projects', function (): void {
// update settings and validate // update settings and validate
const buildHelper = new BuildHelper(); const buildHelper = new BuildHelper();
const resultArg = buildHelper.constructBuildArguments('dummy\\project path\\more space in path', 'dummy\\dll path', true); const resultArg = buildHelper.constructBuildArguments('dummy\\project path\\more space in path', 'dummy\\dll path', ProjectType.SdkStyle);
if (os.platform() === 'win32') { if (os.platform() === 'win32') {
should(resultArg).equal(' build "dummy\\\\project path\\\\more space in path" /p:NetCoreBuild=true /p:SystemDacpacsLocation="dummy\\\\dll path"'); should(resultArg).equal(' build "dummy\\\\project path\\\\more space in path" /p:NetCoreBuild=true /p:SystemDacpacsLocation="dummy\\\\dll path"');

8
extensions/sql-database-projects/src/test/datasource.test.ts
View File

@@ -10,16 +10,16 @@ import * as sql from '../models/dataSources/sqlConnectionStringSource';
import * as dataSources from '../models/dataSources/dataSources'; import * as dataSources from '../models/dataSources/dataSources';
describe('Data Sources: DataSource operations', function (): void { describe('Data Sources: DataSource operations', function (): void {
before(async function () : Promise<void> { before(async function (): Promise<void> {
await baselines.loadBaselines(); await baselines.loadBaselines();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
it.skip('Should read DataSources from datasource.json', async function (): Promise<void> { it.skip('Should read DataSources from datasource.json', async function (): Promise<void> {
const dataSourcePath = await testUtils.createTestDataSources(baselines.openDataSourcesBaseline); const dataSourcePath = await testUtils.createTestDataSources(this.test, baselines.openDataSourcesBaseline);
const dataSourceList = await dataSources.load(dataSourcePath); const dataSourceList = await dataSources.load(dataSourcePath);
should(dataSourceList.length).equal(3); should(dataSourceList.length).equal(3);
@@ -36,7 +36,7 @@ describe('Data Sources: DataSource operations', function (): void {
should((dataSourceList[2] as sql.SqlConnectionDataSource).azureMFA).equal(true); should((dataSourceList[2] as sql.SqlConnectionDataSource).azureMFA).equal(true);
}); });
it ('Should be able to create sql data source from connection strings with and without ending semicolon', function (): void { it('Should be able to create sql data source from connection strings with and without ending semicolon', function (): void {
should.doesNotThrow(() => new sql.SqlConnectionDataSource('no ending semicolon', 'Data Source=(LOCAL);Initial Catalog=testdb;User id=sa;Password=PLACEHOLDER')); should.doesNotThrow(() => new sql.SqlConnectionDataSource('no ending semicolon', 'Data Source=(LOCAL);Initial Catalog=testdb;User id=sa;Password=PLACEHOLDER'));
should.doesNotThrow(() => new sql.SqlConnectionDataSource('ending in semicolon', 'Data Source=(LOCAL);Initial Catalog=testdb;User id=sa;Password=PLACEHOLDER;')); should.doesNotThrow(() => new sql.SqlConnectionDataSource('ending in semicolon', 'Data Source=(LOCAL);Initial Catalog=testdb;User id=sa;Password=PLACEHOLDER;'));
should.throws(() => new sql.SqlConnectionDataSource('invalid extra equals sign', 'Data Source=(LOCAL);Initial Catalog=testdb=extra;User id=sa;Password=PLACEHOLDER')); should.throws(() => new sql.SqlConnectionDataSource('invalid extra equals sign', 'Data Source=(LOCAL);Initial Catalog=testdb=extra;User id=sa;Password=PLACEHOLDER'));

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

@@ -70,7 +70,7 @@ describe('deploy service', function (): void {
sandbox = sinon.createSandbox(); sandbox = sinon.createSandbox();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
@@ -93,7 +93,7 @@ describe('deploy service', function (): void {
dockerBaseImageEula: '' dockerBaseImageEula: ''
} }
}; };
const projFilePath = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline); const projFilePath = await testUtils.createTestSqlProjFile(this.test, baselines.newProjectFileBaseline);
const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath); const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath);
const shellExecutionHelper = TypeMoq.Mock.ofType(ShellExecutionHelper); const shellExecutionHelper = TypeMoq.Mock.ofType(ShellExecutionHelper);
shellExecutionHelper.setup(x => x.runStreamedCommand(TypeMoq.It.isAny(), shellExecutionHelper.setup(x => x.runStreamedCommand(TypeMoq.It.isAny(),
@@ -128,7 +128,7 @@ describe('deploy service', function (): void {
dockerBaseImageEula: '' dockerBaseImageEula: ''
} }
}; };
const projFilePath = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline); const projFilePath = await testUtils.createTestSqlProjFile(this.test, baselines.newProjectFileBaseline);
const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath); const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath);
const shellExecutionHelper = TypeMoq.Mock.ofType(ShellExecutionHelper); const shellExecutionHelper = TypeMoq.Mock.ofType(ShellExecutionHelper);
shellExecutionHelper.setup(x => x.runStreamedCommand(TypeMoq.It.isAny(), shellExecutionHelper.setup(x => x.runStreamedCommand(TypeMoq.It.isAny(),

39
extensions/sql-database-projects/src/test/dialogs/addDatabaseReferenceDialog.test.ts
View File

@@ -22,28 +22,38 @@ describe('Add Database Reference Dialog', () => {
}); });
beforeEach(function (): void { beforeEach(function (): void {
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>(); // const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve([])); // dataWorkspaceMock.setup(x => x.getProjectsInWorkspace(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve([]));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object }); // sinon.stub(vscode.extensions, 'getExtension').withArgs('Microsoft.data-workspace').returns(<any>{ exports: dataWorkspaceMock.object });
}); });
afterEach(function (): void { afterEach(function (): void {
sinon.restore(); sinon.restore();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
it('Should open dialog successfully', async function (): Promise<void> { it('Should open dialog successfully', async function (): Promise<void> {
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve([]));
sinon.stub(vscode.extensions, 'getExtension').withArgs('Microsoft.data-workspace').returns(<any>{ exports: dataWorkspaceMock.object });
const dialog = new AddDatabaseReferenceDialog(project); const dialog = new AddDatabaseReferenceDialog(project);
await dialog.openDialog(); await dialog.openDialog();
should.notEqual(dialog.addDatabaseReferenceTab, undefined); should.notEqual(dialog.addDatabaseReferenceTab, undefined);
}); });
it('Should enable ok button correctly', async function (): Promise<void> { it('Should enable ok button correctly', async function (): Promise<void> {
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve([]));
sinon.stub(vscode.extensions, 'getExtension').withArgs('Microsoft.data-workspace').returns(<any>{ exports: dataWorkspaceMock.object });
const dialog = new AddDatabaseReferenceDialog(project); const dialog = new AddDatabaseReferenceDialog(project);
await dialog.openDialog(); await dialog.openDialog();
@@ -97,35 +107,40 @@ describe('Add Database Reference Dialog', () => {
}); });
it('Should enable and disable input boxes depending on the reference type', async function (): Promise<void> { it('Should enable and disable input boxes depending on the reference type', async function (): Promise<void> {
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.getProjectsInWorkspace(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve([]));
sinon.stub(vscode.extensions, 'getExtension').withArgs('Microsoft.data-workspace').returns(<any>{ exports: dataWorkspaceMock.object });
const dialog = new AddDatabaseReferenceDialog(project); const dialog = new AddDatabaseReferenceDialog(project);
await dialog.openDialog(); await dialog.openDialog();
// dialog starts with system db because there aren't any other projects in the workspace // dialog starts with system db because there aren't any other projects in the workspace
should(dialog.currentReferenceType).equal(ReferenceType.systemDb); should(dialog.currentReferenceType).equal(ReferenceType.systemDb);
validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false}); validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false });
// change to dacpac reference // change to dacpac reference
dialog.dacpacRadioButtonClick(); dialog.dacpacRadioButtonClick();
should(dialog.currentReferenceType).equal(ReferenceType.dacpac); should(dialog.currentReferenceType).equal(ReferenceType.dacpac);
should(dialog.locationDropdown!.value).equal(constants.differentDbSameServer); should(dialog.locationDropdown!.value).equal(constants.differentDbSameServer);
validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: true, serverNameEnabled: false, serverVariabledEnabled: false}); validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: true, serverNameEnabled: false, serverVariabledEnabled: false });
// change location to different db, different server // change location to different db, different server
dialog.locationDropdown!.value = constants.differentDbDifferentServer; dialog.locationDropdown!.value = constants.differentDbDifferentServer;
dialog.updateEnabledInputBoxes(); dialog.updateEnabledInputBoxes();
validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: true, serverNameEnabled: true, serverVariabledEnabled: true}); validateInputBoxEnabledStates(dialog, { databaseNameEnabled: true, databaseVariableEnabled: true, serverNameEnabled: true, serverVariabledEnabled: true });
// change location to same db // change location to same db
dialog.locationDropdown!.value = constants.sameDatabase; dialog.locationDropdown!.value = constants.sameDatabase;
dialog.updateEnabledInputBoxes(); dialog.updateEnabledInputBoxes();
validateInputBoxEnabledStates(dialog, { databaseNameEnabled: false, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false}); validateInputBoxEnabledStates(dialog, { databaseNameEnabled: false, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false });
// change to project reference // change to project reference
dialog.projectRadioButtonClick(); dialog.projectRadioButtonClick();
should(dialog.currentReferenceType).equal(ReferenceType.project); should(dialog.currentReferenceType).equal(ReferenceType.project);
should(dialog.locationDropdown!.value).equal(constants.sameDatabase); should(dialog.locationDropdown!.value).equal(constants.sameDatabase);
validateInputBoxEnabledStates(dialog, { databaseNameEnabled: false, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false}); validateInputBoxEnabledStates(dialog, { databaseNameEnabled: false, databaseVariableEnabled: false, serverNameEnabled: false, serverVariabledEnabled: false });
}); });
}); });

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

@@ -155,9 +155,9 @@ describe('Create Project From Database Quickpick', () => {
it('Should exit when folder structure is not selected and existing folder/file location is selected', async function (): Promise<void> { it('Should exit when folder structure is not selected and existing folder/file location is selected', async function (): Promise<void> {
//create folder and project file //create folder and project file
const projectFileName = 'TestProject'; const projectFileName = 'TestProject';
const testProjectFilePath = await generateTestFolderPath(); const testProjectFilePath = await generateTestFolderPath(this.test);
await fs.rm(testProjectFilePath, { force: true, recursive: true }); //clean up if it already exists await fs.rm(testProjectFilePath, { force: true, recursive: true }); //clean up if it already exists
await createTestFile('', `${projectFileName}.sqlproj`, testProjectFilePath); await createTestFile(this.test, '', `${projectFileName}.sqlproj`, testProjectFilePath);
//user chooses connection and database //user chooses connection and database
sinon.stub(testUtils.vscodeMssqlIExtension.object, 'connect').resolves('testConnectionURI'); sinon.stub(testUtils.vscodeMssqlIExtension.object, 'connect').resolves('testConnectionURI');

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

@@ -26,13 +26,13 @@ describe('Publish Database Dialog', () => {
testContext = createContext(); testContext = createContext();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
it('Should open dialog successfully ', async function (): Promise<void> { it('Should open dialog successfully ', async function (): Promise<void> {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projFileDir = path.join(testUtils.generateBaseFolderName(), `TestProject_${new Date().getTime()}`); const projFileDir = await testUtils.generateTestFolderPath(this.test);
const projFilePath = await projController.createNewProject({ const projFilePath = await projController.createNewProject({
newProjName: 'TestProjectName', newProjName: 'TestProjectName',
@@ -50,8 +50,7 @@ describe('Publish Database Dialog', () => {
it('Should create default database name correctly ', async function (): Promise<void> { it('Should create default database name correctly ', async function (): Promise<void> {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projFolder = `TestProject_${new Date().getTime()}`; const projFileDir = await testUtils.generateTestFolderPath(this.test);
const projFileDir = path.join(testUtils.generateBaseFolderName(), projFolder);
const projFilePath = await projController.createNewProject({ const projFilePath = await projController.createNewProject({
newProjName: 'TestProjectName', newProjName: 'TestProjectName',
@@ -68,7 +67,7 @@ describe('Publish Database Dialog', () => {
}); });
it('Should include all info in publish profile', async function (): Promise<void> { it('Should include all info in publish profile', async function (): Promise<void> {
const proj = await testUtils.createTestProject(baselines.openProjectFileBaseline); const proj = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
const dialog = TypeMoq.Mock.ofType(PublishDatabaseDialog, undefined, undefined, proj); const dialog = TypeMoq.Mock.ofType(PublishDatabaseDialog, undefined, undefined, proj);
dialog.setup(x => x.getConnectionUri()).returns(() => { return Promise.resolve('Mock|Connection|Uri'); }); dialog.setup(x => x.getConnectionUri()).returns(() => { return Promise.resolve('Mock|Connection|Uri'); });
dialog.setup(x => x.targetDatabaseName).returns(() => 'MockDatabaseName'); dialog.setup(x => x.targetDatabaseName).returns(() => 'MockDatabaseName');

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

@@ -19,7 +19,7 @@ describe('Publish Database Options Dialog', () => {
await baselines.loadBaselines(); await baselines.loadBaselines();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
@@ -36,7 +36,7 @@ describe('Publish Database Options Dialog', () => {
it('Should deployment options gets initialized correctly with sample test project', async function (): Promise<void> { it('Should deployment options gets initialized correctly with sample test project', async function (): Promise<void> {
// Create new sample test project // Create new sample test project
const project = await testUtils.createTestProject(baselines.openProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
const dialog = TypeMoq.Mock.ofType(PublishDatabaseDialog, undefined, undefined, project); const dialog = TypeMoq.Mock.ofType(PublishDatabaseDialog, undefined, undefined, project);
dialog.setup(x => x.getDeploymentOptions()).returns(() => { return Promise.resolve(testData.mockDacFxOptionsResult.deploymentOptions); }); dialog.setup(x => x.getDeploymentOptions()).returns(() => { return Promise.resolve(testData.mockDacFxOptionsResult.deploymentOptions); });

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

@@ -36,7 +36,7 @@ describe('Update Project From Database Dialog', () => {
}); });
it('Should populate endpoints correctly when Project context is passed', async function (): Promise<void> { it('Should populate endpoints correctly when Project context is passed', async function (): Promise<void> {
const project = await testUtils.createTestProject(baselines.openProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
const dialog = new UpdateProjectFromDatabaseDialog(undefined, project, mockURIList); const dialog = new UpdateProjectFromDatabaseDialog(undefined, project, mockURIList);
await dialog.openDialog(); await dialog.openDialog();
@@ -62,7 +62,7 @@ describe('Update Project From Database Dialog', () => {
}); });
it('Should populate endpoints correctly when context is complete', async function (): Promise<void> { it('Should populate endpoints correctly when context is complete', async function (): Promise<void> {
const project = await testUtils.createTestProject(baselines.openProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
sinon.stub(azdata.connection, 'getConnections').resolves([<azdata.connection.ConnectionProfile><unknown>mockConnectionProfile]); sinon.stub(azdata.connection, 'getConnections').resolves([<azdata.connection.ConnectionProfile><unknown>mockConnectionProfile]);
sinon.stub(azdata.connection, 'listDatabases').resolves([mockConnectionProfile.databaseName!]); sinon.stub(azdata.connection, 'listDatabases').resolves([mockConnectionProfile.databaseName!]);

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

@@ -25,7 +25,7 @@ describe('NetCoreTool: Net core tests', function (): void {
testContext = createContext(); testContext = createContext();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await deleteGeneratedTestFolder(); await deleteGeneratedTestFolder();
}); });
@@ -55,7 +55,7 @@ describe('NetCoreTool: Net core tests', function (): void {
should(result).true('dotnet not present in programfiles by default'); should(result).true('dotnet not present in programfiles by default');
} }
if (os.platform() === 'linux'){ if (os.platform() === 'linux') {
//check that path should start with /usr/share //check that path should start with /usr/share
let result = !netcoreTool.netcoreInstallLocation || netcoreTool.netcoreInstallLocation.toLowerCase() === '/usr/share/dotnet'; let result = !netcoreTool.netcoreInstallLocation || netcoreTool.netcoreInstallLocation.toLowerCase() === '/usr/share/dotnet';
should(result).true('dotnet not present in /usr/share'); should(result).true('dotnet not present in /usr/share');
@@ -70,7 +70,7 @@ describe('NetCoreTool: Net core tests', function (): void {
it('should run a command successfully', async function (): Promise<void> { it('should run a command successfully', async function (): Promise<void> {
const netcoreTool = new NetCoreTool(testContext.outputChannel); const netcoreTool = new NetCoreTool(testContext.outputChannel);
const dummyFile = path.join(await generateTestFolderPath(), 'dummy.dacpac'); const dummyFile = path.join(await generateTestFolderPath(this.test), 'dummy.dacpac');
try { try {
await netcoreTool.runStreamedCommand('echo test > ' + getQuotedPath(dummyFile), undefined); await netcoreTool.runStreamedCommand('echo test > ' + getQuotedPath(dummyFile), undefined);

20
extensions/sql-database-projects/src/test/newProjectTool.test.ts
View File

@@ -11,25 +11,25 @@ import * as dataworkspace from 'dataworkspace';
import * as newProjectTool from '../tools/newProjectTool'; import * as newProjectTool from '../tools/newProjectTool';
import { generateTestFolderPath, createTestFile, deleteGeneratedTestFolder } from './testUtils'; import { generateTestFolderPath, createTestFile, deleteGeneratedTestFolder } from './testUtils';
let previousSetting : string; let previousSetting: string;
let testFolderPath : string; let testFolderPath: string;
describe('NewProjectTool: New project tool tests', function (): void { describe('NewProjectTool: New project tool tests', function (): void {
const projectConfigurationKey = 'projects'; const projectConfigurationKey = 'projects';
const projectSaveLocationKey= 'defaultProjectSaveLocation'; const projectSaveLocationKey = 'defaultProjectSaveLocation';
beforeEach(async function () { beforeEach(async function () {
previousSetting = await vscode.workspace.getConfiguration(projectConfigurationKey)[projectSaveLocationKey]; previousSetting = await vscode.workspace.getConfiguration(projectConfigurationKey)[projectSaveLocationKey];
testFolderPath = await generateTestFolderPath(); testFolderPath = await generateTestFolderPath(this.test);
// set the default project folder path to the test folder // set the default project folder path to the test folder
await vscode.workspace.getConfiguration(projectConfigurationKey).update(projectSaveLocationKey, testFolderPath, true); await vscode.workspace.getConfiguration(projectConfigurationKey).update(projectSaveLocationKey, testFolderPath, true);
const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>(); const dataWorkspaceMock = TypeMoq.Mock.ofType<dataworkspace.IExtension>();
dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file(testFolderPath)); dataWorkspaceMock.setup(x => x.defaultProjectSaveLocation).returns(() => vscode.Uri.file(testFolderPath));
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object}); sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: dataWorkspaceMock.object });
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await deleteGeneratedTestFolder(); await deleteGeneratedTestFolder();
}); });
@@ -47,20 +47,20 @@ describe('NewProjectTool: New project tool tests', function (): void {
it('Should auto-increment default project names for new projects', async function (): Promise<void> { it('Should auto-increment default project names for new projects', async function (): Promise<void> {
should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject1'); should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject1');
await createTestFile('', 'DatabaseProject1', testFolderPath); await createTestFile(this.test, '', 'DatabaseProject1', testFolderPath);
should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject2'); should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject2');
await createTestFile('', 'DatabaseProject2', testFolderPath); await createTestFile(this.test, '', 'DatabaseProject2', testFolderPath);
should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject3'); should(newProjectTool.defaultProjectNameNewProj()).equal('DatabaseProject3');
}); });
it('Should auto-increment default project names for create project for database', async function (): Promise<void> { it('Should auto-increment default project names for create project for database', async function (): Promise<void> {
should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster'); should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster');
await createTestFile('', 'DatabaseProjectmaster', testFolderPath); await createTestFile(this.test, '', 'DatabaseProjectmaster', testFolderPath);
should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster2'); should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster2');
await createTestFile('', 'DatabaseProjectmaster2', testFolderPath); await createTestFile(this.test, '', 'DatabaseProjectmaster2', testFolderPath);
should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster3'); should(newProjectTool.defaultProjectNameFromDb('master')).equal('DatabaseProjectmaster3');
}); });

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

File diff suppressed because it is too large Load Diff

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

@@ -20,7 +20,7 @@ import { SqlDatabaseProjectTreeViewProvider } from '../controllers/databaseProje
import { ProjectsController } from '../controllers/projectController'; import { ProjectsController } from '../controllers/projectController';
import { promises as fs } from 'fs'; import { promises as fs } from 'fs';
import { createContext, TestContext, mockDacFxResult, mockConnectionProfile } from './testContext'; import { createContext, TestContext, mockDacFxResult, mockConnectionProfile } from './testContext';
import { Project, reservedProjectFolders } from '../models/project'; import { Project } from '../models/project';
import { PublishDatabaseDialog } from '../dialogs/publishDatabaseDialog'; import { PublishDatabaseDialog } from '../dialogs/publishDatabaseDialog';
import { ProjectRootTreeItem } from '../models/tree/projectTreeItem'; import { ProjectRootTreeItem } from '../models/tree/projectTreeItem';
import { FolderNode, FileNode } from '../models/tree/fileFolderTreeItem'; import { FolderNode, FileNode } from '../models/tree/fileFolderTreeItem';
@@ -30,7 +30,8 @@ import { IDacpacReferenceSettings } from '../models/IDatabaseReferenceSettings';
import { CreateProjectFromDatabaseDialog } from '../dialogs/createProjectFromDatabaseDialog'; import { CreateProjectFromDatabaseDialog } from '../dialogs/createProjectFromDatabaseDialog';
import { ImportDataModel } from '../models/api/import'; import { ImportDataModel } from '../models/api/import';
import { EntryType, ItemType, SqlTargetPlatform } from 'sqldbproj'; import { EntryType, ItemType, SqlTargetPlatform } from 'sqldbproj';
import { SystemDatabaseReferenceProjectEntry, SystemDatabase, FileProjectEntry } from '../models/projectEntry'; import { FileProjectEntry } from '../models/projectEntry';
import { SystemDatabase } from 'mssql';
let testContext: TestContext; let testContext: TestContext;
@@ -56,7 +57,7 @@ describe('ProjectsController', function (): void {
describe('Project file operations and prompting', function (): void { describe('Project file operations and prompting', function (): void {
it('Should create new sqlproj file with correct specified target platform', async function (): Promise<void> { it('Should create new sqlproj file with correct specified target platform', async function (): Promise<void> {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projFileDir = path.join(testUtils.generateBaseFolderName(), `TestProject_${new Date().getTime()}`); const projFileDir = await testUtils.generateTestFolderPath(this.test);
const projTargetPlatform = SqlTargetPlatform.sqlAzure; // default is SQL Server 2022 const projTargetPlatform = SqlTargetPlatform.sqlAzure; // default is SQL Server 2022
const projFilePath = await projController.createNewProject({ const projFilePath = await projController.createNewProject({
@@ -75,7 +76,7 @@ describe('ProjectsController', function (): void {
it('Should create new edge project with expected template files', async function (): Promise<void> { it('Should create new edge project with expected template files', async function (): Promise<void> {
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const projFileDir = path.join(testUtils.generateBaseFolderName(), `TestProject_${new Date().getTime()}`); const projFileDir = await testUtils.generateTestFolderPath(this.test);
const projFilePath = await projController.createNewProject({ const projFilePath = await projController.createNewProject({
newProjName: 'TestProjectName', newProjName: 'TestProjectName',
@@ -111,7 +112,7 @@ describe('ProjectsController', function (): void {
sinon.stub(utils, 'sanitizeStringForFilename').returns(tableName); sinon.stub(utils, 'sanitizeStringForFilename').returns(tableName);
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
let project = await testUtils.createTestProject(baselines.newProjectFileBaseline); let project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
should(project.files.length).equal(0, 'There should be no files'); should(project.files.length).equal(0, 'There should be no files');
await projController.addItemPrompt(project, '', { itemType: ItemType.script }); await projController.addItemPrompt(project, '', { itemType: ItemType.script });
@@ -127,7 +128,7 @@ describe('ProjectsController', function (): void {
sinon.stub(vscode.window, 'showQuickPick').resolves(undefined); sinon.stub(vscode.window, 'showQuickPick').resolves(undefined);
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
should(project.files.length).equal(0, 'There should be no files'); should(project.files.length).equal(0, 'There should be no files');
await projController.addItemPrompt(project, ''); await projController.addItemPrompt(project, '');
@@ -141,7 +142,7 @@ describe('ProjectsController', function (): void {
sinon.stub(utils, 'sanitizeStringForFilename').returns(tableName); sinon.stub(utils, 'sanitizeStringForFilename').returns(tableName);
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
let project = await testUtils.createTestProject(baselines.newProjectFileBaseline); let project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
should(project.files.length).equal(0, 'There should be no files'); should(project.files.length).equal(0, 'There should be no files');
await projController.addItemPrompt(project, '', { itemType: ItemType.script }); await projController.addItemPrompt(project, '', { itemType: ItemType.script });
@@ -171,22 +172,22 @@ describe('ProjectsController', function (): void {
sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName); sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
let project = await testUtils.createTestProject(baselines.newProjectFileBaseline); let project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
const projectRoot = new ProjectRootTreeItem(project); const projectRoot = new ProjectRootTreeItem(project);
should(project.files.length).equal(0, 'There should be no other folders'); should(project.folders.length).equal(0, 'There should be no other folders');
await projController.addFolderPrompt(createWorkspaceTreeItem(projectRoot)); await projController.addFolderPrompt(createWorkspaceTreeItem(projectRoot));
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(project.files.length).equal(1, 'Folder should be successfully added'); should(project.folders.length).equal(1, 'Folder should be successfully added');
stub.restore(); stub.restore();
await verifyFolderNotAdded(folderName, projController, project, projectRoot); await verifyFolderNotAdded(folderName, projController, project, projectRoot);
// reserved folder names // reserved folder names
for (let i in reservedProjectFolders) { for (let i in constants.reservedProjectFolders) {
await verifyFolderNotAdded(reservedProjectFolders[i], projController, project, projectRoot); await verifyFolderNotAdded(constants.reservedProjectFolders[i], projController, project, projectRoot);
} }
}); });
@@ -196,47 +197,48 @@ describe('ProjectsController', function (): void {
sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName); sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
let project = await testUtils.createTestProject(baselines.openProjectFileBaseline); let project = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
const projectRoot = new ProjectRootTreeItem(project); const projectRoot = new ProjectRootTreeItem(project);
// make sure it's ok to add these folders if they aren't where the reserved folders are at the root of the project // make sure it's ok to add these folders if they aren't where the reserved folders are at the root of the project
let node = projectRoot.children.find(c => c.friendlyName === 'Tables'); let node = projectRoot.children.find(c => c.friendlyName === 'Tables');
sinon.restore(); sinon.restore();
for (let i in reservedProjectFolders) { for (let i in constants.reservedProjectFolders) {
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
await verifyFolderAdded(reservedProjectFolders[i], projController, project, <BaseProjectTreeItem>node); await verifyFolderAdded(constants.reservedProjectFolders[i], projController, project, <BaseProjectTreeItem>node);
} }
}); });
async function verifyFolderAdded(folderName: string, projController: ProjectsController, project: Project, node: BaseProjectTreeItem): Promise<void> { async function verifyFolderAdded(folderName: string, projController: ProjectsController, project: Project, node: BaseProjectTreeItem): Promise<void> {
const beforeFileCount = project.files.length; const beforeFolderCount = project.folders.length;
let beforeFiles = project.files.map(f => f.relativePath); let beforeFolders = project.folders.map(f => f.relativePath);
sinon.stub(vscode.window, 'showInputBox').resolves(folderName); sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName); sinon.stub(utils, 'sanitizeStringForFilename').returns(folderName);
await projController.addFolderPrompt(createWorkspaceTreeItem(node)); await projController.addFolderPrompt(createWorkspaceTreeItem(node));
// reload project // reload project
project = await Project.openProject(project.projectFilePath); project = await Project.openProject(project.projectFilePath);
should(project.files.length).equal(beforeFileCount + 1, `File count should be increased by one after adding the folder ${folderName}. before files: ${JSON.stringify(beforeFiles)}/n after files: ${JSON.stringify(project.files.map(f => f.relativePath))}`); should(project.folders.length).equal(beforeFolderCount + 1, `Folder count should be increased by one after adding the folder ${folderName}. before folders: ${JSON.stringify(beforeFolders)}/n after folders: ${JSON.stringify(project.files.map(f => f.relativePath))}`);
sinon.restore(); sinon.restore();
} }
async function verifyFolderNotAdded(folderName: string, projController: ProjectsController, project: Project, node: BaseProjectTreeItem): Promise<void> { async function verifyFolderNotAdded(folderName: string, projController: ProjectsController, project: Project, node: BaseProjectTreeItem): Promise<void> {
const beforeFileCount = project.files.length; const beforeFileCount = project.folders.length;
const showInputBoxStub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName); const showInputBoxStub = sinon.stub(vscode.window, 'showInputBox').resolves(folderName);
const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage'); const showErrorMessageSpy = sinon.spy(vscode.window, 'showErrorMessage');
await projController.addFolderPrompt(createWorkspaceTreeItem(node)); await projController.addFolderPrompt(createWorkspaceTreeItem(node));
should(showErrorMessageSpy.calledOnce).be.true('showErrorMessage should have been called exactly once'); should(showErrorMessageSpy.calledOnce).be.true('showErrorMessage should have been called exactly once');
const msg = constants.folderAlreadyExists(folderName); const msg = constants.folderAlreadyExists(folderName);
should(showErrorMessageSpy.calledWith(msg)).be.true(`showErrorMessage not called with expected message '${msg}' Actual '${showErrorMessageSpy.getCall(0).args[0]}'`); should(showErrorMessageSpy.calledWith(msg)).be.true(`showErrorMessage not called with expected message '${msg}' Actual '${showErrorMessageSpy.getCall(0).args[0]}'`);
should(project.files.length).equal(beforeFileCount, 'File count should be the same as before the folder was attempted to be added'); should(project.folders.length).equal(beforeFileCount, 'File count should be the same as before the folder was attempted to be added');
showInputBoxStub.restore(); showInputBoxStub.restore();
showErrorMessageSpy.restore(); showErrorMessageSpy.restore();
} }
it('Should delete nested ProjectEntry from node', async function (): Promise<void> { // TODO: move test to DacFx and fix delete
let proj = await testUtils.createTestProject(templates.newSqlProjectTemplate); it.skip('Should delete nested ProjectEntry from node', async function (): Promise<void> {
let proj = await testUtils.createTestProject(this.test, templates.newSqlProjectTemplate);
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];
@@ -252,11 +254,11 @@ describe('ProjectsController', function (): void {
proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk
// confirm result // confirm result
should(proj.files.length).equal(1, 'number of file/folder entries'); // lowerEntry and the contained scripts should be deleted should(proj.files.length).equal(3, 'number of file entries'); // lowerEntry and the contained scripts should be deleted
should(proj.files[0].relativePath).equal('UpperFolder\\'); should(proj.folders[0].relativePath).equal('UpperFolder');
should(proj.preDeployScripts.length).equal(0); should(proj.preDeployScripts.length).equal(0, 'Pre Deployment scripts should have been deleted');
should(proj.postDeployScripts.length).equal(0); should(proj.postDeployScripts.length).equal(0, 'Post Deployment scripts should have been deleted');
should(proj.noneDeployScripts.length).equal(0); should(proj.noneDeployScripts.length).equal(0, 'None file should have been deleted');
should(await utils.exists(scriptEntry.fsUri.fsPath)).equal(false, 'script is supposed to be deleted'); should(await utils.exists(scriptEntry.fsUri.fsPath)).equal(false, 'script is supposed to be deleted');
should(await utils.exists(preDeployEntry.fsUri.fsPath)).equal(false, 'pre-deployment script is supposed to be deleted'); should(await utils.exists(preDeployEntry.fsUri.fsPath)).equal(false, 'pre-deployment script is supposed to be deleted');
@@ -266,7 +268,7 @@ describe('ProjectsController', function (): void {
it('Should delete database references', async function (): Promise<void> { it('Should delete database references', async function (): Promise<void> {
// setup - openProject baseline has a system db reference to master // setup - openProject baseline has a system db reference to master
let proj = await testUtils.createTestProject(baselines.openProjectFileBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString)); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString));
@@ -277,6 +279,7 @@ describe('ProjectsController', function (): void {
databaseVariable: 'test2Db', databaseVariable: 'test2Db',
suppressMissingDependenciesErrors: false suppressMissingDependenciesErrors: false
}); });
// add project reference // add project reference
await proj.addProjectReference({ await proj.addProjectReference({
projectName: 'project1', projectName: 'project1',
@@ -286,8 +289,6 @@ describe('ProjectsController', function (): void {
}); });
const projTreeRoot = new ProjectRootTreeItem(proj); const projTreeRoot = new ProjectRootTreeItem(proj);
// reload project
proj = await Project.openProject(proj.projectFilePath);
should(proj.databaseReferences.length).equal(3, 'Should start with 3 database references'); should(proj.databaseReferences.length).equal(3, 'Should start with 3 database references');
const databaseReferenceNodeChildren = projTreeRoot.children.find(x => x.friendlyName === constants.databaseReferencesNodeName)?.children; const databaseReferenceNodeChildren = projTreeRoot.children.find(x => x.friendlyName === constants.databaseReferencesNodeName)?.children;
@@ -302,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(templates.newSqlProjectTemplate); let proj = await testUtils.createTestProject(this.test, templates.newSqlProjectTemplate);
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];
@@ -317,11 +318,11 @@ describe('ProjectsController', function (): void {
proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk proj = await Project.openProject(proj.projectFilePath); // reload edited sqlproj from disk
// confirm result // confirm result
should(proj.files.length).equal(1, 'number of file/folder entries'); // LowerFolder and the contained scripts should be deleted should(proj.files.length).equal(2, 'number of file entries'); // LowerFolder and the contained scripts should be deleted
should(proj.files[0].relativePath).equal('UpperFolder\\'); // UpperFolder should still be there should(proj.folders.find(f => f.relativePath === 'UpperFolder')).not.equal(undefined, 'UpperFolder should still be there');
should(proj.preDeployScripts.length).equal(0); should(proj.preDeployScripts.length).equal(0, 'Pre deployment scripts');
should(proj.postDeployScripts.length).equal(0); should(proj.postDeployScripts.length).equal(0, 'Post deployment scripts');
should(proj.noneDeployScripts.length).equal(0); should(proj.noneDeployScripts.length).equal(0, 'None files');
should(await utils.exists(scriptEntry.fsUri.fsPath)).equal(true, 'script is supposed to still exist on disk'); should(await utils.exists(scriptEntry.fsUri.fsPath)).equal(true, 'script is supposed to still exist on disk');
should(await utils.exists(preDeployEntry.fsUri.fsPath)).equal(true, 'pre-deployment script is supposed to still exist on disk'); should(await utils.exists(preDeployEntry.fsUri.fsPath)).equal(true, 'pre-deployment script is supposed to still exist on disk');
@@ -329,8 +330,9 @@ describe('ProjectsController', function (): void {
should(await utils.exists(noneEntry.fsUri.fsPath)).equal(true, 'none entry pre-deployment script is supposed to still exist on disk'); should(await utils.exists(noneEntry.fsUri.fsPath)).equal(true, 'none entry pre-deployment script is supposed to still exist on disk');
}); });
it('Should delete folders with excluded items', async function (): Promise<void> { // TODO: move test to DacFx and fix delete
let proj = await testUtils.createTestProject(templates.newSqlProjectTemplate); it.skip('Should delete folders with excluded items', async function (): Promise<void> {
let proj = await testUtils.createTestProject(this.test, templates.newSqlProjectTemplate);
const setupResult = await setupDeleteExcludeTest(proj); const setupResult = await setupDeleteExcludeTest(proj);
const scriptEntry = setupResult[0], projTreeRoot = setupResult[1]; const scriptEntry = setupResult[0], projTreeRoot = setupResult[1];
@@ -358,8 +360,8 @@ describe('ProjectsController', function (): void {
it('Should reload correctly after changing sqlproj file', async function (): Promise<void> { it('Should reload correctly after changing sqlproj file', async function (): Promise<void> {
// create project // create project
const folderPath = await testUtils.generateTestFolderPath(); const folderPath = await testUtils.generateTestFolderPath(this.test);
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline, folderPath); const sqlProjPath = await testUtils.createTestSqlProjFile(this.test, baselines.newProjectFileBaseline, folderPath);
const treeProvider = new SqlDatabaseProjectTreeViewProvider(); const treeProvider = new SqlDatabaseProjectTreeViewProvider();
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
let project = await Project.openProject(vscode.Uri.file(sqlProjPath).fsPath); let project = await Project.openProject(vscode.Uri.file(sqlProjPath).fsPath);
@@ -375,7 +377,7 @@ describe('ProjectsController', function (): void {
// calling this because this gets called in the projectProvider.getProjectTreeDataProvider(), which is called by workspaceTreeDataProvider // calling this because this gets called in the projectProvider.getProjectTreeDataProvider(), which is called by workspaceTreeDataProvider
// when notifyTreeDataChanged() happens // when notifyTreeDataChanged() happens
// reload project // reload project
project = await Project.openProject(sqlProjPath); project = await Project.openProject(sqlProjPath, false, true);
treeProvider.load([project]); treeProvider.load([project]);
// check that the new project is in the tree // check that the new project is in the tree
@@ -388,7 +390,7 @@ describe('ProjectsController', function (): void {
const postDeployScriptName = 'PostDeployScript1.sql'; const postDeployScriptName = 'PostDeployScript1.sql';
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const project = await testUtils.createTestProject(baselines.newProjectFileBaseline); const project = await testUtils.createTestProject(this.test, baselines.newProjectFileBaseline);
sinon.stub(vscode.window, 'showInputBox').resolves(preDeployScriptName); sinon.stub(vscode.window, 'showInputBox').resolves(preDeployScriptName);
sinon.stub(utils, 'sanitizeStringForFilename').returns(preDeployScriptName); sinon.stub(utils, 'sanitizeStringForFilename').returns(preDeployScriptName);
@@ -408,18 +410,13 @@ describe('ProjectsController', function (): void {
sinon.stub(vscode.window, 'showQuickPick').resolves({ label: SqlTargetPlatform.sqlAzure }); sinon.stub(vscode.window, 'showQuickPick').resolves({ label: SqlTargetPlatform.sqlAzure });
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const sqlProjPath = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline); const sqlProjPath = await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline);
const project = await Project.openProject(sqlProjPath); const project = await Project.openProject(sqlProjPath);
should(project.getProjectTargetVersion()).equal(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlServer2019)); should(project.getProjectTargetVersion()).equal(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlServer2019));
should(project.databaseReferences.length).equal(1, 'Project should have one database reference to master'); should(project.databaseReferences.length).equal(1, 'Project should have one database reference to master');
should(project.databaseReferences[0].fsUri.fsPath).containEql(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlServer2019));
should((<SystemDatabaseReferenceProjectEntry>project.databaseReferences[0]).ssdtUri.fsPath).containEql(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlServer2019));
await projController.changeTargetPlatform(project); await projController.changeTargetPlatform(project);
should(project.getProjectTargetVersion()).equal(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlAzure)); should(project.getProjectTargetVersion()).equal(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlAzure));
// verify system db reference got updated too
should(project.databaseReferences[0].fsUri.fsPath).containEql(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlAzure));
should((<SystemDatabaseReferenceProjectEntry>project.databaseReferences[0]).ssdtUri.fsPath).containEql(constants.targetPlatformToVersion.get(SqlTargetPlatform.sqlAzure));
}); });
}); });
@@ -440,9 +437,9 @@ describe('ProjectsController', function (): void {
}); });
it('Callbacks are hooked up and called from Publish dialog', async function (): Promise<void> { it('Callbacks are hooked up and called from Publish dialog', async function (): Promise<void> {
const projectFile = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline) const projectFile = await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline)
const projFolder = path.dirname(projectFile); const projFolder = path.dirname(projectFile);
await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, projFolder); await testUtils.createTestDataSources(this.test, baselines.openDataSourcesBaseline, projFolder);
const proj = await Project.openProject(projectFile); const proj = await Project.openProject(projectFile);
const publishHoller = 'hello from callback for publish()'; const publishHoller = 'hello from callback for publish()';
@@ -501,12 +498,12 @@ describe('ProjectsController', function (): void {
projController.callBase = true; projController.callBase = true;
projController.setup(x => x.buildProject(TypeMoq.It.isAny())).returns(async () => { projController.setup(x => x.buildProject(TypeMoq.It.isAny())).returns(async () => {
builtDacpacPath = await testUtils.createTestFile(fakeDacpacContents, 'output.dacpac'); builtDacpacPath = await testUtils.createTestFile(this.test, fakeDacpacContents, 'output.dacpac');
return builtDacpacPath; return builtDacpacPath;
}); });
sinon.stub(utils, 'getDacFxService').resolves(testContext.dacFxService.object); sinon.stub(utils, 'getDacFxService').resolves(testContext.dacFxService.object);
const proj = await testUtils.createTestProject(baselines.openProjectFileBaseline); const proj = await testUtils.createTestProject(this.test, baselines.openProjectFileBaseline);
await projController.object.publishOrScriptProject(proj, { connectionUri: '', databaseName: '', serverName: '' }, false); await projController.object.publishOrScriptProject(proj, { connectionUri: '', databaseName: '', serverName: '' }, false);
@@ -525,23 +522,26 @@ describe('ProjectsController', function (): void {
}); });
it('Should create list of all files and folders correctly', async function (): Promise<void> { it('Should create list of all files and folders correctly', async function (): Promise<void> {
const testFolderPath = await testUtils.createDummyFileStructure(); // dummy structure is 2 files (one .sql, one .txt) under parent folder + 2 directories with 5 .sql scripts each
const testFolderPath = await testUtils.createDummyFileStructure(this.test);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const fileList = await projController.generateList(testFolderPath); const fileList = await projController.generateScriptList(testFolderPath);
should(fileList.length).equal(15); // Parent folder + 2 files under parent folder + 2 directories with 5 files each // script list should only include the .sql files, no folders and not the .txt file
(fileList.length).should.equal(11, 'number of files returned by generateScriptList()');
(fileList.filter(x => path.extname(x.fsPath) !== constants.sqlFileExtension).length).should.equal(0, 'number of non-.sql files');
}); });
it('Should error out for inaccessible path', async function (): Promise<void> { it('Should error out for inaccessible path', async function (): Promise<void> {
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
let testFolderPath = await testUtils.generateTestFolderPath(); let testFolderPath = await testUtils.generateTestFolderPath(this.test);
testFolderPath += '_nonexistentFolder'; // Modify folder path to point to a nonexistent location testFolderPath += '_nonexistentFolder'; // Modify folder path to point to a nonexistent location
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
await projController.generateList(testFolderPath); await projController.generateScriptList(testFolderPath);
should(spy.calledOnce).be.true('showErrorMessage should have been called'); should(spy.calledOnce).be.true('showErrorMessage should have been called');
const msg = constants.cannotResolvePath(testFolderPath); const msg = constants.cannotResolvePath(testFolderPath);
should(spy.calledWith(msg)).be.true(`showErrorMessage not called with expected message '${msg}' Actual '${spy.getCall(0).args[0]}'`); should(spy.calledWith(msg)).be.true(`showErrorMessage not called with expected message '${msg}' Actual '${spy.getCall(0).args[0]}'`);
@@ -597,7 +597,7 @@ describe('ProjectsController', function (): void {
}); });
it('Should set model filePath correctly for ExtractType = File', async function (): Promise<void> { it('Should set model filePath correctly for ExtractType = File', async function (): Promise<void> {
let folderPath = await testUtils.generateTestFolderPath(); let folderPath = await testUtils.generateTestFolderPath(this.test);
let projectName = 'My Project'; let projectName = 'My Project';
let importPath; let importPath;
let model: ImportDataModel = { connectionUri: 'My Id', database: 'My Database', projName: projectName, filePath: folderPath, version: '1.0.0.0', extractTarget: mssql.ExtractTarget['file'], sdkStyle: false }; let model: ImportDataModel = { connectionUri: 'My Id', database: 'My Database', projName: projectName, filePath: folderPath, version: '1.0.0.0', extractTarget: mssql.ExtractTarget['file'], sdkStyle: false };
@@ -610,7 +610,7 @@ describe('ProjectsController', function (): void {
}); });
it('Should set model filePath correctly for ExtractType = Schema/Object Type', async function (): Promise<void> { it('Should set model filePath correctly for ExtractType = Schema/Object Type', async function (): Promise<void> {
let folderPath = await testUtils.generateTestFolderPath(); let folderPath = await testUtils.generateTestFolderPath(this.test);
let projectName = 'My Project'; let projectName = 'My Project';
let importPath; let importPath;
let model: ImportDataModel = { connectionUri: 'My Id', database: 'My Database', projName: projectName, filePath: folderPath, version: '1.0.0.0', extractTarget: mssql.ExtractTarget['schemaObjectType'], sdkStyle: false }; let model: ImportDataModel = { connectionUri: 'My Id', database: 'My Database', projName: projectName, filePath: folderPath, version: '1.0.0.0', extractTarget: mssql.ExtractTarget['schemaObjectType'], sdkStyle: false };
@@ -639,7 +639,7 @@ describe('ProjectsController', function (): void {
}); });
it('Callbacks are hooked up and called from Add database reference dialog', async function (): Promise<void> { it('Callbacks are hooked up and called from Add database reference dialog', async function (): Promise<void> {
const projPath = path.dirname(await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline)); const projPath = path.dirname(await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline));
const proj = new Project(projPath); const proj = new Project(projPath);
const addDbRefHoller = 'hello from callback for addDatabaseReference()'; const addDbRefHoller = 'hello from callback for addDatabaseReference()';
@@ -650,7 +650,7 @@ describe('ProjectsController', function (): void {
addDbReferenceDialog.callBase = true; addDbReferenceDialog.callBase = true;
addDbReferenceDialog.setup(x => x.addReferenceClick()).returns(() => { addDbReferenceDialog.setup(x => x.addReferenceClick()).returns(() => {
return projController.object.addDatabaseReferenceCallback(proj, return projController.object.addDatabaseReferenceCallback(proj,
{ systemDb: SystemDatabase.master, databaseName: 'master', suppressMissingDependenciesErrors: false }, { systemDb: SystemDatabase.Master, databaseName: 'master', suppressMissingDependenciesErrors: false },
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined }); { treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
}); });
addDbReferenceDialog.setup(x => x.openDialog()).returns(() => Promise.resolve()); addDbReferenceDialog.setup(x => x.openDialog()).returns(() => Promise.resolve());
@@ -669,9 +669,9 @@ describe('ProjectsController', function (): void {
should(holler).equal(addDbRefHoller, 'executionCallback() is supposed to have been setup and called for add database reference scenario'); should(holler).equal(addDbRefHoller, 'executionCallback() is supposed to have been setup and called for add database reference scenario');
}); });
it('Should not allow adding circular project references', async function (): Promise<void> { it.skip('Should not allow adding circular project references', async function (): Promise<void> {
const projPath1 = await testUtils.createTestSqlProjFile(baselines.openProjectFileBaseline); const projPath1 = await testUtils.createTestSqlProjFile(this.test, baselines.openProjectFileBaseline);
const projPath2 = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline); const projPath2 = await testUtils.createTestSqlProjFile(this.test, baselines.newProjectFileBaseline);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const project1 = await Project.openProject(vscode.Uri.file(projPath1).fsPath); const project1 = await Project.openProject(vscode.Uri.file(projPath1).fsPath);
@@ -707,8 +707,8 @@ describe('ProjectsController', function (): void {
should(showErrorMessageSpy.called).be.true('showErrorMessage should have been called'); should(showErrorMessageSpy.called).be.true('showErrorMessage should have been called');
}); });
it('Should add dacpac references as relative paths', async function (): Promise<void> { it.skip('Should add dacpac references as relative paths', async function (): Promise<void> {
const projFilePath = await testUtils.createTestSqlProjFile(baselines.newProjectFileBaseline); const projFilePath = await testUtils.createTestSqlProjFile(this.test, baselines.newProjectFileBaseline);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath); const project1 = await Project.openProject(vscode.Uri.file(projFilePath).fsPath);
@@ -731,7 +731,7 @@ describe('ProjectsController', function (): void {
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined }); { treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called'); should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called');
should(project1.databaseReferences.length).equal(1, 'Dacpac reference should have been added'); should(project1.databaseReferences.length).equal(1, 'Dacpac reference should have been added');
should(project1.databaseReferences[0].databaseName).equal('sameFolderTest'); should(project1.databaseReferences[0].referenceName).equal('sameFolderTest');
should(project1.databaseReferences[0].pathForSqlProj()).equal('sameFolderTest.dacpac'); should(project1.databaseReferences[0].pathForSqlProj()).equal('sameFolderTest.dacpac');
// make sure reference to sameFolderTest.dacpac was added to project file // make sure reference to sameFolderTest.dacpac was added to project file
let projFileText = (await fs.readFile(projFilePath)).toString(); let projFileText = (await fs.readFile(projFilePath)).toString();
@@ -746,7 +746,7 @@ describe('ProjectsController', function (): void {
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined }); { treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called'); should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called');
should(project1.databaseReferences.length).equal(2, 'Another dacpac reference should have been added'); should(project1.databaseReferences.length).equal(2, 'Another dacpac reference should have been added');
should(project1.databaseReferences[1].databaseName).equal('nestedFolderTest'); should(project1.databaseReferences[1].referenceName).equal('nestedFolderTest');
should(project1.databaseReferences[1].pathForSqlProj()).equal('refs\\nestedFolderTest.dacpac'); should(project1.databaseReferences[1].pathForSqlProj()).equal('refs\\nestedFolderTest.dacpac');
// make sure reference to nestedFolderTest.dacpac was added to project file // make sure reference to nestedFolderTest.dacpac was added to project file
projFileText = (await fs.readFile(projFilePath)).toString(); projFileText = (await fs.readFile(projFilePath)).toString();
@@ -761,7 +761,7 @@ describe('ProjectsController', function (): void {
{ treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined }); { treeDataProvider: new SqlDatabaseProjectTreeViewProvider(), element: undefined });
should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called'); should(showErrorMessageSpy.notCalled).be.true('showErrorMessage should not have been called');
should(project1.databaseReferences.length).equal(3, 'Another dacpac reference should have been added'); should(project1.databaseReferences.length).equal(3, 'Another dacpac reference should have been added');
should(project1.databaseReferences[2].databaseName).equal('outsideFolderTest'); should(project1.databaseReferences[2].referenceName).equal('outsideFolderTest');
should(project1.databaseReferences[2].pathForSqlProj()).equal('..\\someFolder\\outsideFolderTest.dacpac'); should(project1.databaseReferences[2].pathForSqlProj()).equal('..\\someFolder\\outsideFolderTest.dacpac');
// make sure reference to outsideFolderTest.dacpac was added to project file // make sure reference to outsideFolderTest.dacpac was added to project file
projFileText = (await fs.readFile(projFilePath)).toString(); projFileText = (await fs.readFile(projFilePath)).toString();
@@ -770,9 +770,10 @@ describe('ProjectsController', function (): void {
}); });
describe('AutoRest generation', function (): void { describe('AutoRest generation', function (): void {
it('Should create project from autorest-generated files', async function (): Promise<void> { // skipping for now because this feature is hidden under preview flag
const parentFolder = await testUtils.generateTestFolderPath(); it.skip('Should create project from autorest-generated files', async function (): Promise<void> {
await testUtils.createDummyFileStructure(); const parentFolder = await testUtils.generateTestFolderPath(this.test);
await testUtils.createDummyFileStructure(this.test);
const specName = 'DummySpec.yaml'; const specName = 'DummySpec.yaml';
const renamedProjectName = 'RenamedProject'; const renamedProjectName = 'RenamedProject';
const newProjFolder = path.join(parentFolder, renamedProjectName); const newProjFolder = path.join(parentFolder, renamedProjectName);
@@ -793,8 +794,8 @@ describe('ProjectsController', function (): void {
}); });
projController.setup(x => x.generateAutorestFiles(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => { projController.setup(x => x.generateAutorestFiles(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => {
await testUtils.createDummyFileStructure(true, fileList, newProjFolder); await testUtils.createDummyFileStructure(this.test, true, fileList, newProjFolder);
await testUtils.createTestFile('SELECT \'This is a post-deployment script\'', constants.autorestPostDeploymentScriptName, newProjFolder); await testUtils.createTestFile(this.test, 'SELECT \'This is a post-deployment script\'', constants.autorestPostDeploymentScriptName, newProjFolder);
return 'some dummy console output'; return 'some dummy console output';
}); });
@@ -823,7 +824,7 @@ describe('ProjectsController', function (): void {
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move)); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move));
let proj = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot = await setupMoveTest(proj); const projTreeRoot = await setupMoveTest(proj);
@@ -846,7 +847,7 @@ describe('ProjectsController', function (): void {
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move)); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move));
let proj = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot = await setupMoveTest(proj); const projTreeRoot = await setupMoveTest(proj);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
@@ -868,7 +869,7 @@ describe('ProjectsController', function (): void {
it('Should only allow moving files', async function (): Promise<void> { it('Should only allow moving files', async function (): Promise<void> {
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
let proj = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot = await setupMoveTest(proj); const projTreeRoot = await setupMoveTest(proj);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
@@ -902,8 +903,8 @@ describe('ProjectsController', function (): void {
const spy = sinon.spy(vscode.window, 'showErrorMessage'); const spy = sinon.spy(vscode.window, 'showErrorMessage');
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move)); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.move));
let proj1 = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj1 = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
let proj2 = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj2 = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot1 = await setupMoveTest(proj1); const projTreeRoot1 = await setupMoveTest(proj1);
const projTreeRoot2 = await setupMoveTest(proj2); const projTreeRoot2 = await setupMoveTest(proj2);
@@ -926,7 +927,7 @@ describe('ProjectsController', function (): void {
describe('Rename file', function (): void { describe('Rename file', function (): void {
it('Should not do anything if no new name is provided', async function (): Promise<void> { it('Should not do anything if no new name is provided', async function (): Promise<void> {
sinon.stub(vscode.window, 'showInputBox').resolves(''); sinon.stub(vscode.window, 'showInputBox').resolves('');
let proj = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot = await setupMoveTest(proj); const projTreeRoot = await setupMoveTest(proj);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
@@ -942,7 +943,7 @@ describe('ProjectsController', function (): void {
it('Should rename a sql object file', async function (): Promise<void> { it('Should rename a sql object file', async function (): Promise<void> {
sinon.stub(vscode.window, 'showInputBox').resolves('newName'); sinon.stub(vscode.window, 'showInputBox').resolves('newName');
let proj = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let proj = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const projTreeRoot = await setupMoveTest(proj); const projTreeRoot = await setupMoveTest(proj);
const projController = new ProjectsController(testContext.outputChannel); const projController = new ProjectsController(testContext.outputChannel);
@@ -957,7 +958,7 @@ describe('ProjectsController', function (): void {
}); });
it('Should rename a pre and post deploy script', async function (): Promise<void> { it('Should rename a pre and post deploy script', async function (): Promise<void> {
let proj = await testUtils.createTestProject(baselines.newSdkStyleProjectSdkNodeBaseline); let proj = await testUtils.createTestProject(this.test, baselines.newSdkStyleProjectSdkNodeBaseline);
await proj.addScriptItem('Script.PreDeployment1.sql', 'pre-deployment stuff', ItemType.preDeployScript); await proj.addScriptItem('Script.PreDeployment1.sql', 'pre-deployment stuff', ItemType.preDeployScript);
await proj.addScriptItem('Script.PostDeployment1.sql', 'post-deployment stuff', ItemType.postDeployScript); await proj.addScriptItem('Script.PostDeployment1.sql', 'post-deployment stuff', ItemType.postDeployScript);
@@ -989,7 +990,7 @@ describe('ProjectsController', function (): void {
describe('SqlCmd Variables', function (): void { describe('SqlCmd Variables', function (): void {
it('Should delete sqlcmd variable', async function (): Promise<void> { it('Should delete sqlcmd variable', async function (): Promise<void> {
let project = await testUtils.createTestProject(baselines.openSdkStyleSqlProjectBaseline); let project = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const sqlProjectsService = await utils.getSqlProjectsService(); const sqlProjectsService = await utils.getSqlProjectsService();
await sqlProjectsService.openProject(project.projectFilePath); await sqlProjectsService.openProject(project.projectFilePath);
@@ -1013,12 +1014,72 @@ describe('ProjectsController', function (): void {
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(Object.keys(project.sqlCmdVariables).length).equal(1, 'The project should only have 1 sqlcmd variable after deletion');
}); });
it('Should add sqlcmd variable', async function (): Promise<void> {
let project = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const sqlProjectsService = await utils.getSqlProjectsService();
await sqlProjectsService.openProject(project.projectFilePath);
const projController = new ProjectsController(testContext.outputChannel);
const projRoot = new ProjectRootTreeItem(project);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should start with 2 sqlcmd variables');
const inputBoxStub = sinon.stub(vscode.window, 'showInputBox');
inputBoxStub.resolves('');
await projController.addSqlCmdVariable(createWorkspaceTreeItem(projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!));
// reload project
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');
inputBoxStub.reset();
inputBoxStub.onFirstCall().resolves('newVariable');
inputBoxStub.onSecondCall().resolves('testValue');
await projController.addSqlCmdVariable(createWorkspaceTreeItem(projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!));
// reload project
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');
});
it('Should update sqlcmd variable', async function (): Promise<void> {
let project = await testUtils.createTestProject(this.test, baselines.openSdkStyleSqlProjectBaseline);
const sqlProjectsService = await utils.getSqlProjectsService();
await sqlProjectsService.openProject(project.projectFilePath);
const projController = new ProjectsController(testContext.outputChannel);
const projRoot = new ProjectRootTreeItem(project);
should(Object.keys(project.sqlCmdVariables).length).equal(2, 'The project should start with 2 sqlcmd variables');
const inputBoxStub = sinon.stub(vscode.window, 'showInputBox');
inputBoxStub.resolves('');
const sqlcmdVarToUpdate = projRoot.children.find(x => x.friendlyName === constants.sqlcmdVariablesNodeName)!.children[0];
const originalValue = project.sqlCmdVariables[sqlcmdVarToUpdate.friendlyName];
await projController.editSqlCmdVariable(createWorkspaceTreeItem(sqlcmdVarToUpdate));
// reload project
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[sqlcmdVarToUpdate.friendlyName]).equal(originalValue, 'The value of the sqlcmd variable should not have changed');
inputBoxStub.reset();
const updatedValue = 'newValue';
inputBoxStub.resolves(updatedValue);
await projController.editSqlCmdVariable(createWorkspaceTreeItem(sqlcmdVarToUpdate));
// reload project
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[sqlcmdVarToUpdate.friendlyName]).equal(updatedValue, 'The value of the sqlcmd variable should have been updated');
});
}); });
}); });
async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry, ProjectRootTreeItem, FileProjectEntry, FileProjectEntry, FileProjectEntry]> { async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry, ProjectRootTreeItem, FileProjectEntry, FileProjectEntry, FileProjectEntry]> {
await proj.addFolderItem('UpperFolder'); await proj.addFolder('UpperFolder');
await proj.addFolderItem('UpperFolder/LowerFolder'); await proj.addFolder('UpperFolder/LowerFolder');
const scriptEntry = await proj.addScriptItem('UpperFolder/LowerFolder/someScript.sql', 'not a real script'); const scriptEntry = await proj.addScriptItem('UpperFolder/LowerFolder/someScript.sql', 'not a real script');
await proj.addScriptItem('UpperFolder/LowerFolder/someOtherScript.sql', 'Also not a real script'); await proj.addScriptItem('UpperFolder/LowerFolder/someOtherScript.sql', 'Also not a real script');
await proj.addScriptItem('../anotherScript.sql', 'Also not a real script'); await proj.addScriptItem('../anotherScript.sql', 'Also not a real script');
@@ -1030,7 +1091,8 @@ async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry,
sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString)); sinon.stub(vscode.window, 'showWarningMessage').returns(<any>Promise.resolve(constants.yesString));
// confirm setup // confirm setup
should(proj.files.length).equal(5, 'number of file/folder entries'); should(proj.files.length).equal(3, 'number of file entries');
should(proj.folders.length).equal(2, 'number of folder entries');
should(proj.preDeployScripts.length).equal(1, 'number of pre-deployment script entries'); should(proj.preDeployScripts.length).equal(1, 'number of pre-deployment script entries');
should(proj.postDeployScripts.length).equal(1, 'number of post-deployment script entries'); should(proj.postDeployScripts.length).equal(1, 'number of post-deployment script entries');
should(proj.noneDeployScripts.length).equal(1, 'number of none script entries'); should(proj.noneDeployScripts.length).equal(1, 'number of none script entries');
@@ -1041,8 +1103,8 @@ async function setupDeleteExcludeTest(proj: Project): Promise<[FileProjectEntry,
} }
async function setupMoveTest(proj: Project): Promise<ProjectRootTreeItem> { async function setupMoveTest(proj: Project): Promise<ProjectRootTreeItem> {
await proj.addFolderItem('UpperFolder'); await proj.addFolder('UpperFolder');
await proj.addFolderItem('UpperFolder/LowerFolder'); await proj.addFolder('UpperFolder/LowerFolder');
await proj.addScriptItem('UpperFolder/LowerFolder/someScript.sql', 'not a real script'); await proj.addScriptItem('UpperFolder/LowerFolder/someScript.sql', 'not a real script');
await proj.addScriptItem('UpperFolder/LowerFolder/someOtherScript.sql', 'Also not a real script'); await proj.addScriptItem('UpperFolder/LowerFolder/someOtherScript.sql', 'Also not a real script');
await proj.addScriptItem('../anotherScript.sql', 'Also not a real script'); await proj.addScriptItem('../anotherScript.sql', 'Also not a real script');

46
extensions/sql-database-projects/src/test/projectTree.test.ts
View File

@@ -21,27 +21,27 @@ describe('Project Tree tests', function (): void {
const sqlprojUri = vscode.Uri.file(`${root}Fake.sqlproj`); const sqlprojUri = vscode.Uri.file(`${root}Fake.sqlproj`);
let inputNodes: (FileNode | FolderNode)[] = [ let inputNodes: (FileNode | FolderNode)[] = [
new SqlObjectFileNode(vscode.Uri.file(`${root}C`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}C`), sqlprojUri, 'C'),
new SqlObjectFileNode(vscode.Uri.file(`${root}D`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}D`), sqlprojUri, 'D'),
new FolderNode(vscode.Uri.file(`${root}Z`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}Z`), sqlprojUri, 'Z'),
new FolderNode(vscode.Uri.file(`${root}X`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}X`), sqlprojUri, 'X'),
new SqlObjectFileNode(vscode.Uri.file(`${root}B`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}B`), sqlprojUri, 'B'),
new SqlObjectFileNode(vscode.Uri.file(`${root}A`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}A`), sqlprojUri, 'A'),
new FolderNode(vscode.Uri.file(`${root}W`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}W`), sqlprojUri, 'W'),
new FolderNode(vscode.Uri.file(`${root}Y`), sqlprojUri) new FolderNode(vscode.Uri.file(`${root}Y`), sqlprojUri, 'Y')
]; ];
inputNodes = inputNodes.sort(sortFileFolderNodes); inputNodes = inputNodes.sort(sortFileFolderNodes);
const expectedNodes: (FileNode | FolderNode)[] = [ const expectedNodes: (FileNode | FolderNode)[] = [
new FolderNode(vscode.Uri.file(`${root}W`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}W`), sqlprojUri, 'W'),
new FolderNode(vscode.Uri.file(`${root}X`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}X`), sqlprojUri, 'X'),
new FolderNode(vscode.Uri.file(`${root}Y`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}Y`), sqlprojUri, 'Y'),
new FolderNode(vscode.Uri.file(`${root}Z`), sqlprojUri), new FolderNode(vscode.Uri.file(`${root}Z`), sqlprojUri, 'Z'),
new SqlObjectFileNode(vscode.Uri.file(`${root}A`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}A`), sqlprojUri, 'A'),
new SqlObjectFileNode(vscode.Uri.file(`${root}B`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}B`), sqlprojUri, 'B'),
new SqlObjectFileNode(vscode.Uri.file(`${root}C`), sqlprojUri), new SqlObjectFileNode(vscode.Uri.file(`${root}C`), sqlprojUri, 'C'),
new SqlObjectFileNode(vscode.Uri.file(`${root}D`), sqlprojUri) new SqlObjectFileNode(vscode.Uri.file(`${root}D`), sqlprojUri, 'D')
]; ];
should(inputNodes.map(n => n.relativeProjectUri.path)).deepEqual(expectedNodes.map(n => n.relativeProjectUri.path)); should(inputNodes.map(n => n.relativeProjectUri.path)).deepEqual(expectedNodes.map(n => n.relativeProjectUri.path));
@@ -54,18 +54,18 @@ describe('Project Tree tests', function (): void {
// nested entries before explicit top-level folder entry // nested entries before explicit top-level folder entry
// also, ordering of files/folders at all levels // also, ordering of files/folders at all levels
proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'bNestedTest.sql'), EntryType.File)); proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'bNestedTest.sql'), EntryType.File));
proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'bNestedFolder'), EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry(path.join('someFolder', 'bNestedFolder'), EntryType.Folder));
proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'aNestedTest.sql'), EntryType.File)); proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'aNestedTest.sql'), EntryType.File));
proj.files.push(proj.createFileProjectEntry(path.join('someFolder', 'aNestedFolder'), EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry(path.join('someFolder', 'aNestedFolder'), EntryType.Folder));
proj.files.push(proj.createFileProjectEntry('someFolder', EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry('someFolder', EntryType.Folder));
// duplicate files // duplicate files
proj.files.push(proj.createFileProjectEntry('duplicate.sql', EntryType.File)); proj.files.push(proj.createFileProjectEntry('duplicate.sql', EntryType.File));
proj.files.push(proj.createFileProjectEntry('duplicate.sql', EntryType.File)); proj.files.push(proj.createFileProjectEntry('duplicate.sql', EntryType.File));
// duplicate folders // duplicate folders
proj.files.push(proj.createFileProjectEntry('duplicateFolder', EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry('duplicateFolder', EntryType.Folder));
proj.files.push(proj.createFileProjectEntry('duplicateFolder', EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry('duplicateFolder', EntryType.Folder));
const tree = new ProjectRootTreeItem(proj); const tree = new ProjectRootTreeItem(proj);
should(tree.children.map(x => x.relativeProjectUri.path)).deepEqual([ should(tree.children.map(x => x.relativeProjectUri.path)).deepEqual([
@@ -102,7 +102,9 @@ describe('Project Tree tests', function (): void {
// nested entries before explicit top-level folder entry // nested entries before explicit top-level folder entry
// also, ordering of files/folders at all levels // also, ordering of files/folders at all levels
proj.files.push(proj.createFileProjectEntry('someFolder1\\MyNestedFolder1\\MyFile1.sql', EntryType.File)); proj.files.push(proj.createFileProjectEntry('someFolder1\\MyNestedFolder1\\MyFile1.sql', EntryType.File));
proj.files.push(proj.createFileProjectEntry('someFolder1\\MyNestedFolder2', EntryType.Folder)); proj.folders.push(proj.createFileProjectEntry('someFolder1\\MyNestedFolder2', EntryType.Folder));
proj.folders.push(proj.createFileProjectEntry('someFolder1', EntryType.Folder));
proj.folders.push(proj.createFileProjectEntry('someFolder1\\MyNestedFolder1', EntryType.Folder));
proj.files.push(proj.createFileProjectEntry('someFolder1\\MyFile2.sql', EntryType.File)); proj.files.push(proj.createFileProjectEntry('someFolder1\\MyFile2.sql', EntryType.File));
const tree = new ProjectRootTreeItem(proj); const tree = new ProjectRootTreeItem(proj);

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

@@ -29,13 +29,13 @@ describe('Publish profile tests', function (): void {
sinon.restore(); sinon.restore();
}); });
after(async function(): Promise<void> { after(async function (): Promise<void> {
await testUtils.deleteGeneratedTestFolder(); await testUtils.deleteGeneratedTestFolder();
}); });
it('Should read database name, integrated security connection string, and SQLCMD variables from publish profile', async function (): Promise<void> { it('Should read database name, integrated security connection string, and SQLCMD variables from publish profile', async function (): Promise<void> {
await baselines.loadBaselines(); await baselines.loadBaselines();
const profilePath = await testUtils.createTestFile(baselines.publishProfileIntegratedSecurityBaseline, 'publishProfile.publish.xml'); const profilePath = await testUtils.createTestFile(this.test, baselines.publishProfileIntegratedSecurityBaseline, 'publishProfile.publish.xml');
const connectionResult = { const connectionResult = {
connected: true, connected: true,
connectionId: 'connId', connectionId: 'connId',
@@ -58,7 +58,7 @@ describe('Publish profile tests', function (): void {
it('Should read database name, SQL login connection string, and SQLCMD variables from publish profile', async function (): Promise<void> { it('Should read database name, SQL login connection string, and SQLCMD variables from publish profile', async function (): Promise<void> {
await baselines.loadBaselines(); await baselines.loadBaselines();
const profilePath = await testUtils.createTestFile(baselines.publishProfileSqlLoginBaseline, 'publishProfile.publish.xml'); const profilePath = await testUtils.createTestFile(this.test, baselines.publishProfileSqlLoginBaseline, 'publishProfile.publish.xml');
const connectionResult = { const connectionResult = {
providerName: 'MSSQL', providerName: 'MSSQL',
connectionId: 'connId', connectionId: 'connId',
@@ -83,7 +83,7 @@ describe('Publish profile tests', function (): void {
it('Should read SQLCMD variables correctly from publish profile even if DefaultValue is used', async function (): Promise<void> { it('Should read SQLCMD variables correctly from publish profile even if DefaultValue is used', async function (): Promise<void> {
await baselines.loadBaselines(); await baselines.loadBaselines();
const profilePath = await testUtils.createTestFile(baselines.publishProfileDefaultValueBaseline, 'publishProfile.publish.xml'); const profilePath = await testUtils.createTestFile(this.test, baselines.publishProfileDefaultValueBaseline, 'publishProfile.publish.xml');
testContext.dacFxService.setup(x => x.getOptionsFromProfile(TypeMoq.It.isAny())).returns(async () => { testContext.dacFxService.setup(x => x.getOptionsFromProfile(TypeMoq.It.isAny())).returns(async () => {
return Promise.resolve(mockDacFxOptionsResult); return Promise.resolve(mockDacFxOptionsResult);
}); });
@@ -97,7 +97,7 @@ describe('Publish profile tests', function (): void {
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> {
await baselines.loadBaselines(); await baselines.loadBaselines();
const profilePath = await testUtils.createTestFile(baselines.publishProfileIntegratedSecurityBaseline, 'publishProfile.publish.xml'); const profilePath = await testUtils.createTestFile(this.test, baselines.publishProfileIntegratedSecurityBaseline, 'publishProfile.publish.xml');
sinon.stub(azdata.connection, 'connect').throws(new Error('Could not connect')); sinon.stub(azdata.connection, 'connect').throws(new Error('Could not connect'));

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

@@ -13,7 +13,8 @@ import should = require('should');
import { AssertionError } from 'assert'; import { AssertionError } from 'assert';
import { Project } from '../models/project'; import { Project } from '../models/project';
import { Uri } from 'vscode'; import { Uri } from 'vscode';
import { exists } from '../common/utils'; import { exists, getSqlProjectsService } from '../common/utils';
import { ProjectType } from 'mssql';
export async function shouldThrowSpecificError(block: Function, expectedMessage: string, details?: string) { export async function shouldThrowSpecificError(block: Function, expectedMessage: string, details?: string) {
let succeeded = false; let succeeded = false;
@@ -30,37 +31,52 @@ export async function shouldThrowSpecificError(block: Function, expectedMessage:
} }
} }
export async function createTestSqlProjFile(contents: string, folderPath?: string): Promise<string> { export async function createTestSqlProject(test: Mocha.Runnable | undefined): Promise<Project> {
folderPath = folderPath ?? path.join(await generateTestFolderPath(), 'TestProject'); const projPath = await getTestProjectPath(test);
await (await getSqlProjectsService()).createProject(projPath, ProjectType.SdkStyle);
return await Project.openProject(projPath);
}
export async function getTestProjectPath(test: Mocha.Runnable | undefined): Promise<string> {
return path.join(await generateTestFolderPath(test), 'TestProject', 'TestProject.sqlproj');
}
export async function createTestSqlProjFile(test: Mocha.Runnable | undefined, contents: string, folderPath?: string): Promise<string> {
folderPath = folderPath ?? path.join(await generateTestFolderPath(test), 'TestProject');
const macroDict: Record<string, string> = { const macroDict: Record<string, string> = {
'PROJECT_DSP': constants.defaultDSP 'PROJECT_DSP': constants.defaultDSP
}; };
contents = templates.macroExpansion(contents, macroDict); contents = templates.macroExpansion(contents, macroDict);
return await createTestFile(contents, 'TestProject.sqlproj', folderPath); return await createTestFile(test, contents, 'TestProject.sqlproj', folderPath);
} }
export async function createTestProject(contents: string, folderPath?: string): Promise<Project> { export async function createTestProject(test: Mocha.Runnable | undefined, contents: string, folderPath?: string): Promise<Project> {
return await Project.openProject(await createTestSqlProjFile(contents, folderPath)); return await Project.openProject(await createTestSqlProjFile(test, contents, folderPath));
} }
export async function createTestDataSources(contents: string, folderPath?: string): Promise<string> { export async function createTestDataSources(test: Mocha.Runnable | undefined, contents: string, folderPath?: string): Promise<string> {
return await createTestFile(contents, constants.dataSourcesFileName, folderPath); return await createTestFile(test, contents, constants.dataSourcesFileName, folderPath);
} }
export async function generateTestFolderPath(): Promise<string> { export async function generateTestFolderPath(test: Mocha.Runnable | undefined): Promise<string> {
const folderPath = path.join(generateBaseFolderName(), `TestRun_${new Date().getTime()}`); const testName = test?.title === undefined ? '' : `${normalizeTestName(test?.title)}_`
const folderPath = path.join(generateBaseFolderName(), `Test_${testName}${new Date().getTime()}_${Math.floor((Math.random() * 1000))}`);
await fs.mkdir(folderPath, { recursive: true }); await fs.mkdir(folderPath, { recursive: true });
return folderPath; return folderPath;
} }
function normalizeTestName(rawTestName: string): string {
return rawTestName.replace(/[^\w]+/g, '').substring(0, 40); // remove all non-alphanumeric characters, then trim to a reasonable length
}
export function generateBaseFolderName(): string { export function generateBaseFolderName(): string {
const folderPath = path.join(os.tmpdir(), 'ADS_Tests'); const folderPath = path.join(os.tmpdir(), 'ADS_Tests');
return folderPath; return folderPath;
} }
export async function createTestFile(contents: string, fileName: string, folderPath?: string): Promise<string> { export async function createTestFile(test: Mocha.Runnable | undefined, contents: string, fileName: string, folderPath?: string): Promise<string> {
folderPath = folderPath ?? await generateTestFolderPath(); folderPath = folderPath ?? await generateTestFolderPath(test);
const filePath = path.join(folderPath, fileName); const filePath = path.join(folderPath, fileName);
await fs.mkdir(path.dirname(filePath), { recursive: true }); await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -89,13 +105,12 @@ export async function createTestFile(contents: string, fileName: string, folderP
* @param createList Boolean specifying to create a list of the files and folders been created * @param createList Boolean specifying to create a list of the files and folders been created
* @param list List of files and folders that are been created * @param list List of files and folders that are been created
*/ */
export async function createDummyFileStructure(createList?: boolean, list?: Uri[], testFolderPath?: string): Promise<string> { export async function createDummyFileStructure(test: Mocha.Runnable | undefined, createList?: boolean, list?: Uri[], testFolderPath?: string): Promise<string> {
testFolderPath = testFolderPath ?? await generateTestFolderPath(); testFolderPath = testFolderPath ?? await generateTestFolderPath(test);
let filePath = path.join(testFolderPath, 'file1.sql'); let filePath = path.join(testFolderPath, 'file1.sql');
await fs.writeFile(filePath, ''); await fs.writeFile(filePath, '');
if (createList) { if (createList) {
list?.push(Uri.file(testFolderPath));
list?.push(Uri.file(filePath)); list?.push(Uri.file(filePath));
} }
@@ -103,10 +118,6 @@ export async function createDummyFileStructure(createList?: boolean, list?: Uri[
let dirName = path.join(testFolderPath, `folder${dirCount}`); let dirName = path.join(testFolderPath, `folder${dirCount}`);
await fs.mkdir(dirName, { recursive: true }); await fs.mkdir(dirName, { recursive: true });
if (createList) {
list?.push(Uri.file(dirName));
}
for (let fileCount = 1; fileCount <= 5; fileCount++) { for (let fileCount = 1; fileCount <= 5; fileCount++) {
let fileName = path.join(dirName, `file${fileCount}.sql`); let fileName = path.join(dirName, `file${fileCount}.sql`);
await fs.writeFile(fileName, ''); await fs.writeFile(fileName, '');
@@ -117,7 +128,7 @@ export async function createDummyFileStructure(createList?: boolean, list?: Uri[
} }
filePath = path.join(testFolderPath, 'file2.txt'); filePath = path.join(testFolderPath, 'file2.txt');
//await touchFile(filePath);
await fs.writeFile(filePath, ''); await fs.writeFile(filePath, '');
if (createList) { if (createList) {
list?.push(Uri.file(filePath)); list?.push(Uri.file(filePath));
@@ -153,8 +164,8 @@ export async function createDummyFileStructure(createList?: boolean, list?: Uri[
* @param createList Boolean specifying to create a list of the files and folders been created * @param createList Boolean specifying to create a list of the files and folders been created
* @param list List of files and folders that are been created * @param list List of files and folders that are been created
*/ */
export async function createDummyFileStructureWithPrePostDeployScripts(createList?: boolean, list?: Uri[], testFolderPath?: string): Promise<string> { export async function createDummyFileStructureWithPrePostDeployScripts(test: Mocha.Runnable | undefined, createList?: boolean, list?: Uri[], testFolderPath?: string): Promise<string> {
testFolderPath = await createDummyFileStructure(createList, list, testFolderPath); testFolderPath = await createDummyFileStructure(test, createList, list, testFolderPath);
// add pre-deploy scripts // add pre-deploy scripts
const predeployscript1 = path.join(testFolderPath, 'Script.PreDeployment1.sql'); const predeployscript1 = path.join(testFolderPath, 'Script.PreDeployment1.sql');
@@ -189,10 +200,10 @@ export async function createDummyFileStructureWithPrePostDeployScripts(createLis
return testFolderPath; return testFolderPath;
} }
export async function createListOfFiles(filePath?: string): Promise<Uri[]> { export async function createListOfFiles(test: Mocha.Runnable | undefined, filePath?: string): Promise<Uri[]> {
let fileFolderList: Uri[] = []; let fileFolderList: Uri[] = [];
await createDummyFileStructure(true, fileFolderList, filePath); await createDummyFileStructure(test, true, fileFolderList, filePath);
return fileFolderList; return fileFolderList;
} }
@@ -201,14 +212,14 @@ export async function createListOfFiles(filePath?: string): Promise<Uri[]> {
* TestFolder directory structure * TestFolder directory structure
* - file1.sql * - file1.sql
* - folder1 * - folder1
* -file1.sql * - file1.sql
* -file2.sql * - file2.sql
* -test1.sql * - test1.sql
* -test2.sql * - test2.sql
* -testLongerName.sql * - testLongerName.sql
* - folder2 * - folder2
* -file1.sql * - file1.sql
* -file2.sql * - file2.sql
* - Script.PreDeployment1.sql * - Script.PreDeployment1.sql
* - Script.PostDeployment1.sql * - Script.PostDeployment1.sql
* - Script.PostDeployment2.sql * - Script.PostDeployment2.sql
@@ -262,7 +273,6 @@ export async function createOtherDummyFiles(testFolderPath: string): Promise<Uri
export async function deleteGeneratedTestFolder(): Promise<void> { export async function deleteGeneratedTestFolder(): Promise<void> {
const testFolderPath: string = generateBaseFolderName(); const testFolderPath: string = generateBaseFolderName();
if (await exists(testFolderPath)) { if (await exists(testFolderPath)) {
// cleanup folder await fs.rm(testFolderPath, { recursive: true }); // cleanup folder
await fs.rm(testFolderPath, { recursive: true });
} }
} }

163
extensions/sql-database-projects/src/test/utils.test.ts
View File

@@ -6,20 +6,22 @@
import * as should from 'should'; import * as should from 'should';
import * as path from 'path'; import * as path from 'path';
import * as os from 'os'; import * as os from 'os';
import * as constants from '../common/constants';
import * as utils from '../common/utils';
import { createDummyFileStructure, deleteGeneratedTestFolder } from './testUtils'; import { createDummyFileStructure, deleteGeneratedTestFolder } from './testUtils';
import { exists, trimUri, removeSqlCmdVariableFormatting, formatSqlCmdVariable, isValidSqlCmdVariableName, timeConversion, validateSqlServerPortNumber, isEmptyString, detectCommandInstallation, isValidSQLPassword, findSqlVersionInImageName, findSqlVersionInTargetPlatform } from '../common/utils';
import { Uri } from 'vscode'; import { Uri } from 'vscode';
describe('Tests to verify utils functions', function (): void { describe('Tests to verify utils functions', function (): void {
it('Should determine existence of files/folders', async () => { it('Should determine existence of files/folders', async () => {
let testFolderPath = await createDummyFileStructure(); let testFolderPath = await createDummyFileStructure(undefined);
should(await exists(testFolderPath)).equal(true); should(await utils.exists(testFolderPath)).equal(true);
should(await exists(path.join(testFolderPath, 'file1.sql'))).equal(true); should(await utils.exists(path.join(testFolderPath, 'file1.sql'))).equal(true);
should(await exists(path.join(testFolderPath, 'folder2'))).equal(true); should(await utils.exists(path.join(testFolderPath, 'folder2'))).equal(true);
should(await exists(path.join(testFolderPath, 'folder4'))).equal(false); should(await utils.exists(path.join(testFolderPath, 'folder4'))).equal(false);
should(await exists(path.join(testFolderPath, 'folder2', 'file4.sql'))).equal(true); should(await utils.exists(path.join(testFolderPath, 'folder2', 'file4.sql'))).equal(true);
should(await exists(path.join(testFolderPath, 'folder4', 'file2.sql'))).equal(false); should(await utils.exists(path.join(testFolderPath, 'folder4', 'file2.sql'))).equal(false);
await deleteGeneratedTestFolder(); await deleteGeneratedTestFolder();
}); });
@@ -28,117 +30,124 @@ describe('Tests to verify utils functions', function (): void {
const root = os.platform() === 'win32' ? 'Z:\\' : '/'; const root = os.platform() === 'win32' ? 'Z:\\' : '/';
let projectUri = Uri.file(path.join(root, 'project', 'folder', 'project.sqlproj')); let projectUri = Uri.file(path.join(root, 'project', 'folder', 'project.sqlproj'));
let fileUri = Uri.file(path.join(root, 'project', 'folder', 'file.sql')); let fileUri = Uri.file(path.join(root, 'project', 'folder', 'file.sql'));
should(trimUri(projectUri, fileUri)).equal('file.sql'); should(utils.trimUri(projectUri, fileUri)).equal('file.sql');
fileUri = Uri.file(path.join(root, 'project', 'file.sql')); fileUri = Uri.file(path.join(root, 'project', 'file.sql'));
let urifile = trimUri(projectUri, fileUri); let urifile = utils.trimUri(projectUri, fileUri);
should(urifile).equal('../file.sql'); should(urifile).equal('../file.sql');
fileUri = Uri.file(path.join(root, 'project', 'forked', 'file.sql')); fileUri = Uri.file(path.join(root, 'project', 'forked', 'file.sql'));
should(trimUri(projectUri, fileUri)).equal('../forked/file.sql'); should(utils.trimUri(projectUri, fileUri)).equal('../forked/file.sql');
fileUri = Uri.file(path.join(root, 'forked', 'from', 'top', 'file.sql')); fileUri = Uri.file(path.join(root, 'forked', 'from', 'top', 'file.sql'));
should(trimUri(projectUri, fileUri)).equal('../../forked/from/top/file.sql'); should(utils.trimUri(projectUri, fileUri)).equal('../../forked/from/top/file.sql');
}); });
it('Should remove $() from sqlcmd variables', () => { it('Should remove $() from sqlcmd variables', () => {
should(removeSqlCmdVariableFormatting('$(test)')).equal('test', '$() surrounding the variable should have been removed'); should(utils.removeSqlCmdVariableFormatting('$(test)')).equal('test', '$() surrounding the variable should have been removed');
should(removeSqlCmdVariableFormatting('$(test')).equal('test', '$( at the beginning of the variable should have been removed'); should(utils.removeSqlCmdVariableFormatting('$(test')).equal('test', '$( at the beginning of the variable should have been removed');
should(removeSqlCmdVariableFormatting('test')).equal('test', 'string should not have been changed because it is not in sqlcmd variable format'); should(utils.removeSqlCmdVariableFormatting('test')).equal('test', 'string should not have been changed because it is not in sqlcmd variable format');
}); });
it('Should make variable be in sqlcmd variable format with $()', () => { it('Should make variable be in sqlcmd variable format with $()', () => {
should(formatSqlCmdVariable('$(test)')).equal('$(test)', 'string should not have been changed because it was already in the correct format'); should(utils.formatSqlCmdVariable('$(test)')).equal('$(test)', 'string should not have been changed because it was already in the correct format');
should(formatSqlCmdVariable('test')).equal('$(test)', 'string should have been changed to be in sqlcmd variable format'); should(utils.formatSqlCmdVariable('test')).equal('$(test)', 'string should have been changed to be in sqlcmd variable format');
should(formatSqlCmdVariable('$(test')).equal('$(test)', 'string should have been changed to be in sqlcmd variable format'); should(utils.formatSqlCmdVariable('$(test')).equal('$(test)', 'string should have been changed to be in sqlcmd variable format');
should(formatSqlCmdVariable('')).equal('', 'should not do anything to an empty string'); should(utils.formatSqlCmdVariable('')).equal('', 'should not do anything to an empty string');
}); });
it('Should determine invalid sqlcmd variable names', () => { it('Should determine invalid sqlcmd variable names', () => {
// valid names // valid names
should(isValidSqlCmdVariableName('$(test)')).equal(true); should(utils.isValidSqlCmdVariableName('$(test)')).equal(true);
should(isValidSqlCmdVariableName('$(test )')).equal(true, 'trailing spaces should be valid because they will be trimmed'); should(utils.isValidSqlCmdVariableName('$(test )')).equal(true, 'trailing spaces should be valid because they will be trimmed');
should(isValidSqlCmdVariableName('test')).equal(true); should(utils.isValidSqlCmdVariableName('test')).equal(true);
should(isValidSqlCmdVariableName('test ')).equal(true, 'trailing spaces should be valid because they will be trimmed'); should(utils.isValidSqlCmdVariableName('test ')).equal(true, 'trailing spaces should be valid because they will be trimmed');
should(isValidSqlCmdVariableName('$(test')).equal(true); should(utils.isValidSqlCmdVariableName('$(test')).equal(true);
should(isValidSqlCmdVariableName('$(test ')).equal(true, 'trailing spaces should be valid because they will be trimmed'); should(utils.isValidSqlCmdVariableName('$(test ')).equal(true, 'trailing spaces should be valid because they will be trimmed');
// whitespace // whitespace
should(isValidSqlCmdVariableName('')).equal(false); should(utils.isValidSqlCmdVariableName('')).equal(false);
should(isValidSqlCmdVariableName(' ')).equal(false); should(utils.isValidSqlCmdVariableName(' ')).equal(false);
should(isValidSqlCmdVariableName(' ')).equal(false); should(utils.isValidSqlCmdVariableName(' ')).equal(false);
should(isValidSqlCmdVariableName('test abc')).equal(false); should(utils.isValidSqlCmdVariableName('test abc')).equal(false);
should(isValidSqlCmdVariableName(' ')).equal(false); should(utils.isValidSqlCmdVariableName(' ')).equal(false);
// invalid characters // invalid characters
should(isValidSqlCmdVariableName('$($test')).equal(false); should(utils.isValidSqlCmdVariableName('$($test')).equal(false);
should(isValidSqlCmdVariableName('$test')).equal(false); should(utils.isValidSqlCmdVariableName('$test')).equal(false);
should(isValidSqlCmdVariableName('$test')).equal(false); should(utils.isValidSqlCmdVariableName('$test')).equal(false);
should(isValidSqlCmdVariableName('test@')).equal(false); should(utils.isValidSqlCmdVariableName('test@')).equal(false);
should(isValidSqlCmdVariableName('test#')).equal(false); should(utils.isValidSqlCmdVariableName('test#')).equal(false);
should(isValidSqlCmdVariableName('test"')).equal(false); should(utils.isValidSqlCmdVariableName('test"')).equal(false);
should(isValidSqlCmdVariableName('test\'')).equal(false); should(utils.isValidSqlCmdVariableName('test\'')).equal(false);
should(isValidSqlCmdVariableName('test-1')).equal(false); should(utils.isValidSqlCmdVariableName('test-1')).equal(false);
}); });
it('Should convert from milliseconds to hr min sec correctly', () => { it('Should convert from milliseconds to hr min sec correctly', () => {
should(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000) + (59 * 1000))).equal('1 hr, 59 min, 59 sec'); should(utils.timeConversion((60 * 60 * 1000) + (59 * 60 * 1000) + (59 * 1000))).equal('1 hr, 59 min, 59 sec');
should(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000))).equal('1 hr, 59 min'); should(utils.timeConversion((60 * 60 * 1000) + (59 * 60 * 1000))).equal('1 hr, 59 min');
should(timeConversion((60 * 60 * 1000))).equal('1 hr'); should(utils.timeConversion((60 * 60 * 1000))).equal('1 hr');
should(timeConversion((60 * 60 * 1000) + (59 * 1000))).equal('1 hr, 59 sec'); should(utils.timeConversion((60 * 60 * 1000) + (59 * 1000))).equal('1 hr, 59 sec');
should(timeConversion((59 * 60 * 1000) + (59 * 1000))).equal('59 min, 59 sec'); should(utils.timeConversion((59 * 60 * 1000) + (59 * 1000))).equal('59 min, 59 sec');
should(timeConversion((59 * 1000))).equal('59 sec'); should(utils.timeConversion((59 * 1000))).equal('59 sec');
should(timeConversion((59))).equal('59 msec'); should(utils.timeConversion((59))).equal('59 msec');
}); });
it('Should validate port number correctly', () => { it('Should validate port number correctly', () => {
should(validateSqlServerPortNumber('invalid')).equals(false); should(utils.validateSqlServerPortNumber('invalid')).equals(false);
should(validateSqlServerPortNumber('')).equals(false); should(utils.validateSqlServerPortNumber('')).equals(false);
should(validateSqlServerPortNumber(undefined)).equals(false); should(utils.validateSqlServerPortNumber(undefined)).equals(false);
should(validateSqlServerPortNumber('65536')).equals(false); should(utils.validateSqlServerPortNumber('65536')).equals(false);
should(validateSqlServerPortNumber('-1')).equals(false); should(utils.validateSqlServerPortNumber('-1')).equals(false);
should(validateSqlServerPortNumber('65530')).equals(true); should(utils.validateSqlServerPortNumber('65530')).equals(true);
should(validateSqlServerPortNumber('1533')).equals(true); should(utils.validateSqlServerPortNumber('1533')).equals(true);
}); });
it('Should validate empty string correctly', () => { it('Should validate empty string correctly', () => {
should(isEmptyString('invalid')).equals(false); should(utils.isEmptyString('invalid')).equals(false);
should(isEmptyString('')).equals(true); should(utils.isEmptyString('')).equals(true);
should(isEmptyString(undefined)).equals(true); should(utils.isEmptyString(undefined)).equals(true);
should(isEmptyString('65536')).equals(false); should(utils.isEmptyString('65536')).equals(false);
}); });
it('Should correctly detect present commands', async () => { it('Should correctly detect present commands', async () => {
should(await detectCommandInstallation('node')).equal(true, '"node" should have been detected.'); should(await utils.detectCommandInstallation('node')).equal(true, '"node" should have been detected.');
should(await detectCommandInstallation('bogusFakeCommand')).equal(false, '"bogusFakeCommand" should have been detected.'); should(await utils.detectCommandInstallation('bogusFakeCommand')).equal(false, '"bogusFakeCommand" should have been detected.');
}); });
it('Should validate SQL server password correctly', () => { it('Should validate SQL server password correctly', () => {
should(isValidSQLPassword('invalid')).equals(false, 'string with chars only is invalid password'); should(utils.isValidSQLPassword('invalid')).equals(false, 'string with chars only is invalid password');
should(isValidSQLPassword('')).equals(false, 'empty string is invalid password'); should(utils.isValidSQLPassword('')).equals(false, 'empty string is invalid password');
should(isValidSQLPassword('65536')).equals(false, 'string with numbers only is invalid password'); should(utils.isValidSQLPassword('65536')).equals(false, 'string with numbers only is invalid password');
should(isValidSQLPassword('dFGj')).equals(false, 'string with lowercase and uppercase char only is invalid password'); should(utils.isValidSQLPassword('dFGj')).equals(false, 'string with lowercase and uppercase char only is invalid password');
should(isValidSQLPassword('dj$')).equals(false, 'string with char and symbols only is invalid password'); should(utils.isValidSQLPassword('dj$')).equals(false, 'string with char and symbols only is invalid password');
should(isValidSQLPassword('dF65530')).equals(false, 'string with char and numbers only is invalid password'); should(utils.isValidSQLPassword('dF65530')).equals(false, 'string with char and numbers only is invalid password');
should(isValidSQLPassword('dF6$30')).equals(false, 'dF6$30 is invalid password'); should(utils.isValidSQLPassword('dF6$30')).equals(false, 'dF6$30 is invalid password');
should(isValidSQLPassword('dF65$530')).equals(true, 'dF65$530 is valid password'); should(utils.isValidSQLPassword('dF65$530')).equals(true, 'dF65$530 is valid password');
should(isValidSQLPassword('dFdf65$530')).equals(true, 'dF65$530 is valid password'); should(utils.isValidSQLPassword('dFdf65$530')).equals(true, 'dF65$530 is valid password');
should(isValidSQLPassword('av1fgh533@')).equals(true, 'dF65$530 is valid password'); should(utils.isValidSQLPassword('av1fgh533@')).equals(true, 'dF65$530 is valid password');
}); });
it('findSqlVersionInImageName should return the version correctly', () => { it('findSqlVersionInImageName should return the version correctly', () => {
should(findSqlVersionInImageName('2017-CU1-ubuntu')).equals(2017, 'invalid number returned for 2017-CU1-ubuntu'); should(utils.findSqlVersionInImageName('2017-CU1-ubuntu')).equals(2017, 'invalid number returned for 2017-CU1-ubuntu');
should(findSqlVersionInImageName('2019-latest')).equals(2019, 'invalid number returned for 2019-latest'); should(utils.findSqlVersionInImageName('2019-latest')).equals(2019, 'invalid number returned for 2019-latest');
should(findSqlVersionInImageName('latest')).equals(undefined, 'invalid number returned for latest'); should(utils.findSqlVersionInImageName('latest')).equals(undefined, 'invalid number returned for latest');
should(findSqlVersionInImageName('latest-ubuntu')).equals(undefined, 'invalid number returned for latest-ubuntu'); should(utils.findSqlVersionInImageName('latest-ubuntu')).equals(undefined, 'invalid number returned for latest-ubuntu');
should(findSqlVersionInImageName('2017-CU20-ubuntu-16.04')).equals(2017, 'invalid number returned for 2017-CU20-ubuntu-16.04'); should(utils.findSqlVersionInImageName('2017-CU20-ubuntu-16.04')).equals(2017, 'invalid number returned for 2017-CU20-ubuntu-16.04');
}); });
it('findSqlVersionInTargetPlatform should return the version correctly', () => { it('findSqlVersionInTargetPlatform should return the version correctly', () => {
should(findSqlVersionInTargetPlatform('SQL Server 2012')).equals(2012, 'invalid number returned for SQL Server 2012'); should(utils.findSqlVersionInTargetPlatform('SQL Server 2012')).equals(2012, 'invalid number returned for SQL Server 2012');
should(findSqlVersionInTargetPlatform('SQL Server 2019')).equals(2019, 'invalid number returned for SQL Server 2019'); should(utils.findSqlVersionInTargetPlatform('SQL Server 2019')).equals(2019, 'invalid number returned for SQL Server 2019');
should(findSqlVersionInTargetPlatform('Azure SQL Database')).equals(undefined, 'invalid number returned for Azure SQL Database'); should(utils.findSqlVersionInTargetPlatform('Azure SQL Database')).equals(undefined, 'invalid number returned for Azure SQL Database');
should(findSqlVersionInTargetPlatform('Azure Synapse SQL Pool')).equals(undefined, 'invalid number returned for Azure Synapse SQL Pool'); should(utils.findSqlVersionInTargetPlatform('Azure Synapse SQL Pool')).equals(undefined, 'invalid number returned for Azure Synapse SQL Pool');
});
it('Should only return well known database strings when getWellKnownDatabaseSources function is called', async function (): Promise<void> {
const sources = ['test1', 'test2', 'test3', constants.WellKnownDatabaseSources[0]];
(utils.getWellKnownDatabaseSources(sources).length).should.equal(1);
(utils.getWellKnownDatabaseSources(sources)[0]).should.equal(constants.WellKnownDatabaseSources[0]);
}); });
}); });

7
extensions/sql-database-projects/src/tools/buildHelper.ts
View File

@@ -12,6 +12,7 @@ import * as extractZip from 'extract-zip';
import * as constants from '../common/constants'; import * as constants from '../common/constants';
import { HttpClient } from '../common/httpClient'; import { HttpClient } from '../common/httpClient';
import { DBProjectConfigurationKey } from './netcoreTool'; import { DBProjectConfigurationKey } from './netcoreTool';
import { ProjectType } from 'mssql';
const buildDirectory = 'BuildDirectory'; const buildDirectory = 'BuildDirectory';
const sdkName = 'Microsoft.Build.Sql'; const sdkName = 'Microsoft.Build.Sql';
@@ -128,17 +129,17 @@ export class BuildHelper {
return this.extensionBuildDir; return this.extensionBuildDir;
} }
public constructBuildArguments(projectPath: string, buildDirPath: string, isSdkStyleProject: boolean): string { public constructBuildArguments(projectPath: string, buildDirPath: string, sqlProjStyle: ProjectType): string {
projectPath = utils.getQuotedPath(projectPath); projectPath = utils.getQuotedPath(projectPath);
buildDirPath = utils.getQuotedPath(buildDirPath); buildDirPath = utils.getQuotedPath(buildDirPath);
// Right now SystemDacpacsLocation and NETCoreTargetsPath get set to the same thing, but separating them out for if we move // Right now SystemDacpacsLocation and NETCoreTargetsPath get set to the same thing, but separating them out for if we move
// the system dacpacs somewhere else and also so that the variable name makes more sense if building from the commandline, // the system dacpacs somewhere else and also so that the variable name makes more sense if building from the commandline,
// since SDK style projects don't to specify the targets path, just where the system dacpacs are // since SDK style projects don't to specify the targets path, just where the system dacpacs are
if (isSdkStyleProject) { if (sqlProjStyle === ProjectType.SdkStyle) {
return ` build ${projectPath} /p:NetCoreBuild=true /p:SystemDacpacsLocation=${buildDirPath}`; return ` build ${projectPath} /p:NetCoreBuild=true /p:SystemDacpacsLocation=${buildDirPath}`;
} else { } else {
return ` build ${projectPath} /p:NetCoreBuild=true /p:NETCoreTargetsPath=${buildDirPath}`; return ` build ${projectPath} /p:NetCoreBuild=true /p:NETCoreTargetsPath=${buildDirPath} /p:SystemDacpacsLocation=${buildDirPath}`;
} }
} }
} }

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

@@ -610,9 +610,8 @@ declare module 'vscode-mssql' {
* @param projectUri Absolute path of the project, including .sqlproj * @param projectUri Absolute path of the project, including .sqlproj
* @param name Name of the SQLCMD variable * @param name Name of the SQLCMD variable
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $()
*/ */
addSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<ResultStatus>; addSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<ResultStatus>;
/** /**
* Delete a SQLCMD variable from a project * Delete a SQLCMD variable from a project
@@ -626,9 +625,8 @@ declare module 'vscode-mssql' {
* @param projectUri Absolute path of the project, including .sqlproj * @param projectUri Absolute path of the project, including .sqlproj
* @param name Name of the SQLCMD variable * @param name Name of the SQLCMD variable
* @param defaultValue Default value of the SQLCMD variable * @param defaultValue Default value of the SQLCMD variable
* @param value Value of the SQLCMD variable, with or without the $()
*/ */
updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string, value: string): Promise<ResultStatus>; updateSqlCmdVariable(projectUri: string, name: string, defaultValue: string): Promise<ResultStatus>;
/** /**
* Add a SQL object script to a project * Add a SQL object script to a project
@@ -764,6 +762,14 @@ declare module 'vscode-mssql' {
* Source of the database schema, used in telemetry * Source of the database schema, used in telemetry
*/ */
databaseSource?: string; databaseSource?: string;
/**
* Style of the .sqlproj file - SdkStyle or LegacyStyle
*/
projectStyle: ProjectType;
/**
* Database Schema Provider, in the format "Microsoft.Data.Tools.Schema.Sql.SqlXYZDatabaseSchemaProvider"
*/
databaseSchemaProvider: string
} }
export interface GetDatabaseReferencesResult extends ResultStatus { export interface GetDatabaseReferencesResult extends ResultStatus {
@@ -1128,7 +1134,7 @@ declare module 'vscode-mssql' {
} }
interface UserDatabaseReference extends DatabaseReference { interface UserDatabaseReference extends DatabaseReference {
databaseVariable: SqlCmdVariable; databaseVariable?: SqlCmdVariable;
serverVariable?: SqlCmdVariable; serverVariable?: SqlCmdVariable;
} }