public void ValidateSettingsObjectUpdates() { // If: I update a settings object with a new settings object var qes = new QueryExecutionService(null, null); SqlToolsSettings settings = new SqlToolsSettings() { SqlTools = new SqlToolsSettingsValues { QueryExecutionSettings = new QueryExecutionSettings { DisplayBitAsNumber = false, MaxXmlCharsToStore = 1, MaxCharsToStore = 1, ExecutionPlanOptions = new ExecutionPlanOptions { IncludeActualExecutionPlanXml = true, IncludeEstimatedExecutionPlanXml = true }, BatchSeparator = "YO" } } }; qes.UpdateSettings(settings, null, new EventContext()); // Then: The settings object should match what it was updated to Assert.False(qes.Settings.QueryExecutionSettings.DisplayBitAsNumber); Assert.True(qes.Settings.QueryExecutionSettings.ExecutionPlanOptions.IncludeActualExecutionPlanXml); Assert.True(qes.Settings.QueryExecutionSettings.ExecutionPlanOptions.IncludeEstimatedExecutionPlanXml); Assert.Equal(1, qes.Settings.QueryExecutionSettings.MaxCharsToStore); Assert.Equal(1, qes.Settings.QueryExecutionSettings.MaxXmlCharsToStore); Assert.Equal("YO", qes.Settings.QueryExecutionSettings.BatchSeparator); }
public async Task SaveResultsCsvNonExistentQuery() { // Given: A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(null); QueryExecutionService qes = Common.GetPrimedExecutionService(null, false, false, ws); // If: I attempt to save a result set from a query that doesn't exist SaveResultsAsCsvRequestParams saveParams = new SaveResultsAsCsvRequestParams { OwnerUri = Common.OwnerUri // Won't exist because nothing has executed }; object error = null; var requestContext = RequestContextMocks.Create <SaveResultRequestResult>(null) .AddErrorHandling(o => error = o); await qes.HandleSaveResultsAsCsvRequest(saveParams, requestContext.Object); // Then: // ... An error event should have been fired // ... No success event should have been fired VerifyResponseCalls(requestContext, false, true); Assert.IsType <SaveResultRequestError>(error); Assert.NotNull(error); Assert.NotNull(((SaveResultRequestError)error).message); }
private static async Task AwaitExecution(QueryExecutionService service, QueryExecuteParams qeParams, RequestContext <QueryExecuteResult> requestContext) { await service.HandleExecuteRequest(qeParams, requestContext); await service.ActiveQueries[qeParams.OwnerUri].ExecutionTask; }
public static async Task AwaitExecution(QueryExecutionService service, ExecuteDocumentSelectionParams qeParams, HostingProtocol.RequestContext <ExecuteRequestResult> requestContext) { await service.HandleExecuteRequest(qeParams, requestContext); if (service.ActiveQueries.ContainsKey(qeParams.OwnerUri) && service.ActiveQueries[qeParams.OwnerUri].ExecutionTask != null) { await service.ActiveQueries[qeParams.OwnerUri].ExecutionTask; } }
public static async Task AwaitExecution(QueryExecutionService service, QueryExecuteParams qeParams, RequestContext <QueryExecuteResult> requestContext) { await service.HandleExecuteRequest(qeParams, requestContext); if (service.ActiveQueries.ContainsKey(qeParams.OwnerUri) && service.ActiveQueries[qeParams.OwnerUri].ExecutionTask != null) { await service.ActiveQueries[qeParams.OwnerUri].ExecutionTask; } }
public async Task InterServiceDisposeNullFailureFunc() { // Setup: Create a query service and dispose params var qes = new QueryExecutionService(null, null); Func <Task> successFunc = () => Task.FromResult(0); // If: I call the inter-service API to dispose a query with a null success function // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceDisposeQuery(Constants.OwnerUri, successFunc, null)); }
public async Task InterServiceExecuteNullEventSender() { // Setup: Create a query service, and execute params var qes = new QueryExecutionService(null, null); var executeParams = new ExecuteStringParams(); // If: I call the inter-service API to execute a query with a a null event sender // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceExecuteQuery(executeParams, null, null, null, null, null, null)); }
public async Task InterServiceExecuteNullExecuteParams() { // Setup: Create a query service var qes = new QueryExecutionService(null, null); var eventSender = new EventFlowValidator <ExecuteRequestResult>().Complete().Object; // If: I call the inter-service API to execute with a null execute params // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceExecuteQuery(null, null, eventSender, null, null, null, null)); }
public void GetSqlTextFromInvalidType() { // Setup: // ... Mock up an implementation of ExecuteRequestParamsBase // ... Create a query execution service without a connection service or workspace // service (we won't execute code that uses either var mockParams = new Mock <ExecuteRequestParamsBase>().Object; var queryService = new QueryExecutionService(null, null); // If: I attempt to get query text from the mock params // Then: It should throw an exception Assert.Throws <InvalidCastException>(() => queryService.GetSqlText(mockParams)); }
public async Task InterServiceExecuteNullFailureFunc() { // Setup: Create a query service, and execute params var qes = new QueryExecutionService(null, null); var executeParams = new ExecuteStringParams(); var eventSender = new EventFlowValidator<ExecuteRequestResult>().Complete().Object; Func<Task> successFunc = () => Task.FromResult(0); // If: I call the inter-service API to execute a query with a a null failure function // Then: It should throw await Assert.ThrowsAsync<ArgumentNullException>( () => qes.InterServiceExecuteQuery(executeParams, eventSender, successFunc, null)); }
public void GetSqlTextFromStringRequest() { // Setup: // ... Create a query execution service without a connection service or workspace // service (we won't execute code that uses either var queryService = new QueryExecutionService(null, null); // If: I attempt to get query text from execute string params var queryParams = new ExecuteStringParams {OwnerUri = Common.OwnerUri, Query = Common.StandardQuery}; var queryText = queryService.GetSqlText(queryParams); // Then: The text should match the standard query Assert.Equal(Common.StandardQuery, queryText); }
public void ExecuteDocumentStatementTest() { string query = string.Format("{0}{1}GO{1}{0}", Constants.StandardQuery, Environment.NewLine); var workspaceService = GetDefaultWorkspaceService(query); var queryService = new QueryExecutionService(null, workspaceService); var queryParams = new ExecuteDocumentStatementParams { OwnerUri = Constants.OwnerUri, Line = 0, Column = 0 }; var queryText = queryService.GetSqlText(queryParams); // The text should match the standard query Assert.Equal(queryText, Constants.StandardQuery); }
public async Task SaveResultAsCsvFailure() { // Given: // ... A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Common.StandardQuery); Dictionary <string, byte[]> storage; QueryExecutionService qes = Common.GetPrimedExecutionService(Common.ExecutionPlanTestDataSet, true, false, ws, out storage); // ... The query execution service has executed a query with results var executeParams = new ExecuteDocumentSelectionParams { QuerySelection = null, OwnerUri = Common.OwnerUri }; var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null); await qes.HandleExecuteRequest(executeParams, executeRequest.Object); await qes.ActiveQueries[Common.OwnerUri].ExecutionTask; // If: I attempt to save a result set and get it to throw because of invalid column selection SaveResultsAsCsvRequestParams saveParams = new SaveResultsAsCsvRequestParams { BatchIndex = 0, FilePath = "qqq", OwnerUri = Common.OwnerUri, ResultSetIndex = 0, ColumnStartIndex = -1, ColumnEndIndex = 100, RowStartIndex = 0, RowEndIndex = 5 }; qes.CsvFileFactory = GetCsvStreamFactory(storage, saveParams); object error = null; var requestContext = RequestContextMocks.Create <SaveResultRequestResult>(null) .AddErrorHandling(e => error = e); await qes.HandleSaveResultsAsCsvRequest(saveParams, requestContext.Object); await qes.ActiveQueries[saveParams.OwnerUri] .Batches[saveParams.BatchIndex] .ResultSets[saveParams.ResultSetIndex] .SaveTasks[saveParams.FilePath]; // Then: // ... An error event should have been fired // ... No success event should have been fired VerifyResponseCalls(requestContext, false, true); Assert.IsType <SaveResultRequestError>(error); Assert.NotNull(error); Assert.NotNull(((SaveResultRequestError)error).message); }
public void GetSqlTextFromDocumentRequestPartial() { // Setup: // ... Create a workspace service with a multi-line constructed query string query = string.Format("{0}{1}GO{1}{0}", Common.StandardQuery, Environment.NewLine); var workspaceService = GetDefaultWorkspaceService(query); var queryService = new QueryExecutionService(null, workspaceService); // If: I attempt to get query text from execute document params (partial document) var queryParams = new ExecuteDocumentSelectionParams {OwnerUri = Common.OwnerUri, QuerySelection = Common.SubsectionDocument}; var queryText = queryService.GetSqlText(queryParams); // Then: The text should be a subset of the constructed query Assert.Contains(queryText, query); }
private void ExecuteDocumentStatementSameLineHelper(string statement1, string statement2, int cursorColumn, string expectedQueryText) { string query = string.Format("{0};{1}", statement1, statement2); var workspaceService = GetDefaultWorkspaceService(query); var queryService = new QueryExecutionService(null, workspaceService); // If a line has multiple statements and the cursor is somewhere in the line var queryParams = new ExecuteDocumentStatementParams { OwnerUri = Constants.OwnerUri, Line = 0, Column = cursorColumn }; var queryText = queryService.GetSqlText(queryParams); // The query text should match the expected statement at the cursor Assert.Equal(expectedQueryText, queryText); }
public async Task SaveResultAsExcelFailure() { // Given: // ... A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery); ConcurrentDictionary <string, byte[]> storage; QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage); // ... The query execution service has executed a query with results var executeParams = new ExecuteDocumentSelectionParams { QuerySelection = null, OwnerUri = Constants.OwnerUri }; var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null); await qes.HandleExecuteRequest(executeParams, executeRequest.Object); await qes.WorkTask; await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask; // If: I attempt to save a result set and get it to throw because of invalid column selection SaveResultsAsExcelRequestParams saveParams = new SaveResultsAsExcelRequestParams { BatchIndex = 0, FilePath = "qqq", OwnerUri = Constants.OwnerUri, ResultSetIndex = 0, ColumnStartIndex = -1, ColumnEndIndex = 100, RowStartIndex = 0, RowEndIndex = 5 }; qes.JsonFileFactory = GetExcelStreamFactory(storage, saveParams); var efv = new EventFlowValidator <SaveResultRequestResult>() .AddStandardErrorValidation() .Complete(); await qes.HandleSaveResultsAsExcelRequest(saveParams, efv.Object); await qes.ActiveQueries[saveParams.OwnerUri] .Batches[saveParams.BatchIndex] .ResultSets[saveParams.ResultSetIndex] .SaveTasks[saveParams.FilePath]; // Then: // ... An error event should have been fired // ... No success event should have been fired efv.Validate(); }
public void GetSqlTextFromDocumentRequestFull() { // Setup: // ... Create a workspace service with a multi-line constructed query // ... Create a query execution service without a connection service (we won't be // executing queries), and the previously created workspace service string query = string.Format("{0}{1}GO{1}{0}", Common.StandardQuery, Environment.NewLine); var workspaceService = GetDefaultWorkspaceService(query); var queryService = new QueryExecutionService(null, workspaceService); // If: I attempt to get query text from execute document params (entire document) var queryParams = new ExecuteDocumentSelectionParams {OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument}; var queryText = queryService.GetSqlText(queryParams); // Then: The text should match the constructed query Assert.Equal(query, queryText); }
public async Task SaveResultsAsXmlSuccess() { // Given: // ... A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery); ConcurrentDictionary <string, byte[]> storage; QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage); // ... The query execution service has executed a query with results var executeParams = new ExecuteDocumentSelectionParams { QuerySelection = null, OwnerUri = Constants.OwnerUri }; var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null); await qes.HandleExecuteRequest(executeParams, executeRequest.Object); await qes.WorkTask; await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask; // If: I attempt to save a result set from a query SaveResultsAsXmlRequestParams saveParams = new SaveResultsAsXmlRequestParams { OwnerUri = Constants.OwnerUri, FilePath = "qqq", BatchIndex = 0, ResultSetIndex = 0, Formatted = true }; qes.XmlFileFactory = GetXmlStreamFactory(storage, saveParams); var efv = new EventFlowValidator <SaveResultRequestResult>() .AddStandardResultValidator() .Complete(); await qes.HandleSaveResultsAsXmlRequest(saveParams, efv.Object); await qes.ActiveQueries[saveParams.OwnerUri] .Batches[saveParams.BatchIndex] .ResultSets[saveParams.ResultSetIndex] .SaveTasks[saveParams.FilePath]; // Then: // ... I should have a successful result // ... There should not have been an error efv.Validate(); }
public async Task SaveResultsAsJsonSuccess() { // Given: // ... A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Common.StandardQuery); Dictionary <string, byte[]> storage; QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, ws, out storage); // ... The query execution service has executed a query with results var executeParams = new ExecuteDocumentSelectionParams { QuerySelection = null, OwnerUri = Common.OwnerUri }; var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null); await qes.HandleExecuteRequest(executeParams, executeRequest.Object); await qes.ActiveQueries[Common.OwnerUri].ExecutionTask; // If: I attempt to save a result set from a query SaveResultsAsJsonRequestParams saveParams = new SaveResultsAsJsonRequestParams { OwnerUri = Common.OwnerUri, FilePath = "qqq", BatchIndex = 0, ResultSetIndex = 0 }; qes.JsonFileFactory = GetJsonStreamFactory(storage, saveParams); SaveResultRequestResult result = null; var requestContext = RequestContextMocks.Create <SaveResultRequestResult>(r => result = r); await qes.HandleSaveResultsAsJsonRequest(saveParams, requestContext.Object); await qes.ActiveQueries[saveParams.OwnerUri] .Batches[saveParams.BatchIndex] .ResultSets[saveParams.ResultSetIndex] .SaveTasks[saveParams.FilePath]; // Then: // ... I should have a successful result // ... There should not have been an error VerifyResponseCalls(requestContext, true, false); Assert.NotNull(result); Assert.Null(result.Messages); }
public async Task SaveResultsCsvNonExistentQuery() { // Given: A working query and workspace service WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(null); QueryExecutionService qes = Common.GetPrimedExecutionService(null, false, false, false, ws); // If: I attempt to save a result set from a query that doesn't exist SaveResultsAsCsvRequestParams saveParams = new SaveResultsAsCsvRequestParams { OwnerUri = Constants.OwnerUri // Won't exist because nothing has executed }; var evf = new EventFlowValidator <SaveResultRequestResult>() .AddStandardErrorValidation() .Complete(); await qes.HandleSaveResultsAsCsvRequest(saveParams, evf.Object); // Then: // ... An error event should have been fired // ... No success event should have been fired evf.Validate(); }
internal EditDataService(QueryExecutionService qes, ConnectionService cs, IEditMetadataFactory factory) { queryExecutionService = qes; connectionService = cs; metadataFactory = factory; }
public void ValidateSettingsObjectUpdates() { // If: I update a settings object with a new settings object var qes = new QueryExecutionService(null, null); SqlToolsSettings settings = new SqlToolsSettings() { SqlTools = new SqlToolsSettingsValues { QueryExecutionSettings = new QueryExecutionSettings { DisplayBitAsNumber = false, MaxXmlCharsToStore = 1, MaxCharsToStore = 1, RowCount = 0, TextSize = 1000, ExecutionTimeout = 5000, NoCount = true, NoExec = true, ParseOnly = true, ArithAbort = true, StatisticsTime = true, StatisticsIO = true, XactAbortOn = true, TransactionIsolationLevel = "REPEATABLE READ", DeadlockPriority = "LOW", LockTimeout = 5000, QueryGovernorCostLimit = 2000, AnsiDefaults = false, QuotedIdentifier = true, AnsiNullDefaultOn = true, ImplicitTransactions = true, CursorCloseOnCommit = true, AnsiPadding = true, AnsiWarnings = true, AnsiNulls = true, ExecutionPlanOptions = new ExecutionPlanOptions { IncludeActualExecutionPlanXml = true, IncludeEstimatedExecutionPlanXml = true }, BatchSeparator = "YO" } } }; qes.UpdateSettings(settings, null, new EventContext()); // Then: The settings object should match what it was updated to Assert.False(qes.Settings.QueryExecutionSettings.DisplayBitAsNumber); Assert.True(qes.Settings.QueryExecutionSettings.ExecutionPlanOptions.IncludeActualExecutionPlanXml); Assert.True(qes.Settings.QueryExecutionSettings.ExecutionPlanOptions.IncludeEstimatedExecutionPlanXml); Assert.Equal(1, qes.Settings.QueryExecutionSettings.MaxCharsToStore); Assert.Equal(1, qes.Settings.QueryExecutionSettings.MaxXmlCharsToStore); Assert.Equal("YO", qes.Settings.QueryExecutionSettings.BatchSeparator); Assert.Equal(1, qes.Settings.QueryExecutionSettings.MaxCharsToStore); Assert.Equal(0, qes.Settings.QueryExecutionSettings.RowCount); Assert.Equal(1000, qes.Settings.QueryExecutionSettings.TextSize); Assert.Equal(5000, qes.Settings.QueryExecutionSettings.ExecutionTimeout); Assert.True(qes.Settings.QueryExecutionSettings.NoCount); Assert.True(qes.Settings.QueryExecutionSettings.NoExec); Assert.True(qes.Settings.QueryExecutionSettings.ParseOnly); Assert.True(qes.Settings.QueryExecutionSettings.ArithAbort); Assert.True(qes.Settings.QueryExecutionSettings.StatisticsTime); Assert.True(qes.Settings.QueryExecutionSettings.StatisticsIO); Assert.True(qes.Settings.QueryExecutionSettings.XactAbortOn); Assert.Equal("REPEATABLE READ", qes.Settings.QueryExecutionSettings.TransactionIsolationLevel); Assert.Equal("LOW", qes.Settings.QueryExecutionSettings.DeadlockPriority); Assert.Equal(5000, qes.Settings.QueryExecutionSettings.LockTimeout); Assert.Equal(2000, qes.Settings.QueryExecutionSettings.QueryGovernorCostLimit); Assert.False(qes.Settings.QueryExecutionSettings.AnsiDefaults); Assert.True(qes.Settings.QueryExecutionSettings.QuotedIdentifier); Assert.True(qes.Settings.QueryExecutionSettings.AnsiNullDefaultOn); Assert.True(qes.Settings.QueryExecutionSettings.ImplicitTransactions); Assert.True(qes.Settings.QueryExecutionSettings.CursorCloseOnCommit); Assert.True(qes.Settings.QueryExecutionSettings.AnsiPadding); Assert.True(qes.Settings.QueryExecutionSettings.AnsiWarnings); Assert.True(qes.Settings.QueryExecutionSettings.AnsiNulls); }