public async void QueryExecuteSingleBatchSingleResultTest() { // Given: // ... A workspace with a standard query is configured var workspaceService = Common.GetPrimedWorkspaceService(Common.StandardQuery); // If: // ... I request to execute a valid query with results var queryService = Common.GetPrimedExecutionService(new[] { Common.StandardTestData }, true, false, workspaceService); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; QueryExecuteBatchNotificationParams batchStartParams = null; QueryExecuteBatchNotificationParams batchCompleteParams = null; QueryExecuteResultSetCompleteParams resultCompleteParams = null; var requestContext = RequestContextMocks.Create <QueryExecuteResult>(qer => result = qer) .AddEventHandling(QueryExecuteCompleteEvent.Type, (et, p) => completeParams = p) .AddEventHandling(QueryExecuteBatchStartEvent.Type, (et, p) => batchStartParams = p) .AddEventHandling(QueryExecuteBatchCompleteEvent.Type, (et, p) => batchCompleteParams = p) .AddEventHandling(QueryExecuteResultSetCompleteEvent.Type, (et, p) => resultCompleteParams = p); await Common.AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No errors should have been sent // ... A successful result should have been sent without messages // ... A completion event should have been fired with one result // ... A batch completion event should have been fired // ... A resultset completion event should have been fired VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Once(), Times.Once(), Times.Once(), Times.Never()); Assert.Null(result.Messages); Assert.Equal(1, completeParams.BatchSummaries.Length); Assert.NotEmpty(completeParams.BatchSummaries[0].ResultSetSummaries); Assert.NotEmpty(completeParams.BatchSummaries[0].Messages); Assert.False(completeParams.BatchSummaries[0].HasError); // ... Batch start summary should not contain result sets, messages, but should contain owner URI Assert.NotNull(batchStartParams); Assert.NotNull(batchStartParams.BatchSummary); Assert.Null(batchStartParams.BatchSummary.Messages); Assert.Null(batchStartParams.BatchSummary.ResultSetSummaries); Assert.Equal(Common.OwnerUri, batchStartParams.OwnerUri); Assert.NotNull(batchCompleteParams); Assert.NotEmpty(batchCompleteParams.BatchSummary.ResultSetSummaries); Assert.NotEmpty(batchCompleteParams.BatchSummary.Messages); Assert.Equal(Common.OwnerUri, batchCompleteParams.OwnerUri); Assert.NotNull(resultCompleteParams); Assert.Equal(Common.StandardColumns, resultCompleteParams.ResultSetSummary.ColumnInfo.Length); Assert.Equal(Common.StandardRows, resultCompleteParams.ResultSetSummary.RowCount); Assert.Equal(Common.OwnerUri, resultCompleteParams.OwnerUri); // ... There should be one active query Assert.Equal(1, queryService.ActiveQueries.Count); }
internal static async Task ExecuteQuery(string query) { // create a temporary "workspace" file using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) // create the client helper which wraps the client driver objects using (ClientHelper testHelper = new ClientHelper()) { // connnection details ConnectParams connectParams = new ConnectParams(); connectParams.Connection = new ConnectionDetails(); connectParams.Connection.ServerName = "localhost"; connectParams.Connection.DatabaseName = "master"; connectParams.Connection.AuthenticationType = "Integrated"; // connect to the database await testHelper.Connect(queryTempFile.FilePath, connectParams); // execute the query QueryExecuteCompleteParams queryComplete = await testHelper.RunQuery(queryTempFile.FilePath, query); if (queryComplete.BatchSummaries != null && queryComplete.BatchSummaries.Length > 0) { var batch = queryComplete.BatchSummaries[0]; if (batch.ResultSetSummaries != null && batch.ResultSetSummaries.Length > 0) { var resultSet = batch.ResultSetSummaries[0]; // retrive the results QueryExecuteSubsetResult querySubset = await testHelper.ExecuteSubset( queryTempFile.FilePath, batch.Id, resultSet.Id, 0, (int)resultSet.RowCount); // print the header foreach (var column in resultSet.ColumnInfo) { Console.Write(column.ColumnName + ", "); } Console.Write(Environment.NewLine); // print the rows foreach (var row in querySubset.ResultSubset.Rows) { for (int i = 0; i < resultSet.ColumnInfo.Length; ++i) { Console.Write(row.GetValue(i) + ", "); } Console.Write(Environment.NewLine); } } } // close database connection await testHelper.Disconnect(queryTempFile.FilePath); } }
public async void QueryExecuteSingleBatchNoResultsTest() { // Given: // ... Default settings are stored in the workspace service // ... A workspace with a standard query is configured WorkspaceService <SqlToolsSettings> .Instance.CurrentSettings = new SqlToolsSettings(); var workspaceService = Common.GetPrimedWorkspaceService(Common.StandardQuery); // If: // ... I request to execute a valid query with no results var queryService = Common.GetPrimedExecutionService(null, true, false, workspaceService); var queryParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; QueryExecuteBatchNotificationParams batchStartParams = null; QueryExecuteBatchNotificationParams batchCompleteParams = null; var requestContext = RequestContextMocks.Create <QueryExecuteResult>(qer => result = qer) .AddEventHandling(QueryExecuteCompleteEvent.Type, (et, p) => completeParams = p) .AddEventHandling(QueryExecuteBatchStartEvent.Type, (et, p) => batchStartParams = p) .AddEventHandling(QueryExecuteBatchCompleteEvent.Type, (et, p) => batchCompleteParams = p) .AddEventHandling(QueryExecuteResultSetCompleteEvent.Type, null); await Common.AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No Errors should have been sent // ... A successful result should have been sent with messages on the first batch // ... A completion event should have been fired with empty results // ... A batch completion event should have been fired with empty results // ... A result set completion event should not have been fired VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Once(), Times.Once(), Times.Never(), Times.Never()); Assert.Null(result.Messages); Assert.Equal(1, completeParams.BatchSummaries.Length); Assert.Empty(completeParams.BatchSummaries[0].ResultSetSummaries); Assert.NotEmpty(completeParams.BatchSummaries[0].Messages); // ... Batch start summary should not contain result sets, messages, but should contain owner URI Assert.NotNull(batchStartParams); Assert.NotNull(batchStartParams.BatchSummary); Assert.Null(batchStartParams.BatchSummary.Messages); Assert.Null(batchStartParams.BatchSummary.ResultSetSummaries); Assert.Equal(Common.OwnerUri, batchStartParams.OwnerUri); // ... Batch completion summary should contain result sets, messages, and the owner URI Assert.NotNull(batchCompleteParams); Assert.NotNull(batchCompleteParams.BatchSummary); Assert.Empty(batchCompleteParams.BatchSummary.ResultSetSummaries); Assert.NotEmpty(batchCompleteParams.BatchSummary.Messages); Assert.Equal(Common.OwnerUri, batchCompleteParams.OwnerUri); // ... There should be one active query Assert.Equal(1, queryService.ActiveQueries.Count); }
public async void QueryExecuteValidNoResultsTest() { // Given: // ... Default settings are stored in the workspace service WorkspaceService <SqlToolsSettings> .Instance.CurrentSettings = new SqlToolsSettings(); // Set up file for returning the query var fileMock = new Mock <ScriptFile>(); fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); // Set up workspace mock var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >(); workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny <string>())) .Returns(fileMock.Object); // If: // ... I request to execute a valid query with no results var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); var queryParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; var requestContext = RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>( resultCallback: qer => result = qer, expectedEvent: QueryExecuteCompleteEvent.Type, eventCallback: (et, cp) => completeParams = cp, errorCallback: null); await AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No Errors should have been sent // ... A successful result should have been sent with messages on the first batch // ... A completion event should have been fired with empty results VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Never()); Assert.Null(result.Messages); Assert.Equal(1, completeParams.BatchSummaries.Length); Assert.Empty(completeParams.BatchSummaries[0].ResultSetSummaries); Assert.NotEmpty(completeParams.BatchSummaries[0].Messages); // ... There should be one active query Assert.Equal(1, queryService.ActiveQueries.Count); }
public async void QueryExecuteInvalidQueryTest() { // Given: // ... A workspace with a standard query is configured var workspaceService = Common.GetPrimedWorkspaceService(Common.StandardQuery); // If: // ... I request to execute a query that is invalid var queryService = Common.GetPrimedExecutionService(null, true, true, workspaceService); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams complete = null; QueryExecuteBatchNotificationParams batchStart = null; QueryExecuteBatchNotificationParams batchComplete = null; var requestContext = RequestContextMocks.Create <QueryExecuteResult>(qer => result = qer) .AddEventHandling(QueryExecuteCompleteEvent.Type, (et, qecp) => complete = qecp) .AddEventHandling(QueryExecuteBatchStartEvent.Type, (et, p) => batchStart = p) .AddEventHandling(QueryExecuteBatchCompleteEvent.Type, (et, p) => batchComplete = p); await Common.AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No errors should have been sent // ... A result should have been sent with success (we successfully started the query) // ... A completion event (query, batch, not resultset) should have been sent with error VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Once(), Times.Once(), Times.Never(), Times.Never()); Assert.Null(result.Messages); Assert.Equal(1, complete.BatchSummaries.Length); Assert.True(complete.BatchSummaries[0].HasError); Assert.NotEmpty(complete.BatchSummaries[0].Messages); Assert.NotNull(batchStart); Assert.False(batchStart.BatchSummary.HasError); Assert.Null(batchStart.BatchSummary.Messages); Assert.Null(batchStart.BatchSummary.ResultSetSummaries); Assert.Equal(Common.OwnerUri, batchStart.OwnerUri); Assert.NotNull(batchComplete); Assert.True(batchComplete.BatchSummary.HasError); Assert.NotEmpty(batchComplete.BatchSummary.Messages); Assert.Equal(Common.OwnerUri, batchComplete.OwnerUri); }
private static async Task ExecuteAndCompleteQuery(QueryExecuteParams executeParams, RequestContext <QueryExecuteResult> requestContext, Query query) { // Skip processing if the query is null if (query == null) { return; } // Setup the query completion/failure callbacks Query.QueryAsyncEventHandler callback = async q => { // Send back the results QueryExecuteCompleteParams eventParams = new QueryExecuteCompleteParams { OwnerUri = executeParams.OwnerUri, BatchSummaries = q.BatchSummaries }; await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); }; Query.QueryAsyncErrorEventHandler errorCallback = async errorMessage => { // Send back the error message QueryExecuteCompleteParams eventParams = new QueryExecuteCompleteParams { OwnerUri = executeParams.OwnerUri, Message = errorMessage }; await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); }; query.QueryCompleted += callback; query.QueryFailed += callback; query.QueryConnectionException += errorCallback; // Launch this as an asynchronous task query.Execute(); // Send back a result showing we were successful await requestContext.SendResult(new QueryExecuteResult { Messages = null }); }
public async void QueryExecuteCompletedTest() { // Given: // ... A workspace with a standard query is configured var workspaceService = Common.GetPrimedWorkspaceService(Common.StandardQuery); // If: // ... I request to execute a query var queryService = Common.GetPrimedExecutionService(null, true, false, workspaceService); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; // Note, we don't care about the results of the first request var firstRequestContext = RequestContextMocks.Create <QueryExecuteResult>(null); await Common.AwaitExecution(queryService, queryParams, firstRequestContext.Object); // ... And then I request another query after waiting for the first to complete QueryExecuteResult result = null; QueryExecuteCompleteParams complete = null; QueryExecuteBatchNotificationParams batchStart = null; QueryExecuteBatchNotificationParams batchComplete = null; var secondRequestContext = RequestContextMocks.Create <QueryExecuteResult>(qer => result = qer) .AddEventHandling(QueryExecuteCompleteEvent.Type, (et, qecp) => complete = qecp) .AddEventHandling(QueryExecuteBatchStartEvent.Type, (et, p) => batchStart = p) .AddEventHandling(QueryExecuteBatchCompleteEvent.Type, (et, p) => batchComplete = p); await Common.AwaitExecution(queryService, queryParams, secondRequestContext.Object); // Then: // ... No errors should have been sent // ... A result should have been sent with no errors // ... There should only be one active query // ... A batch completion event should have fired, but not a result set completion event VerifyQueryExecuteCallCount(secondRequestContext, Times.Once(), Times.Once(), Times.Once(), Times.Once(), Times.Never(), Times.Never()); Assert.Null(result.Messages); Assert.False(complete.BatchSummaries.Any(b => b.HasError)); Assert.Equal(1, queryService.ActiveQueries.Count); Assert.NotNull(batchStart); Assert.NotNull(batchComplete); Assert.False(batchComplete.BatchSummary.HasError); Assert.Equal(complete.OwnerUri, batchComplete.OwnerUri); }
public async void QueryExecuteCompletedTest() { // Set up file for returning the query var fileMock = new Mock <ScriptFile>(); fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); // Set up workspace mock var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >(); workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny <string>())) .Returns(fileMock.Object); // If: // ... I request to execute a query var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; // Note, we don't care about the results of the first request var firstRequestContext = RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>(null, QueryExecuteCompleteEvent.Type, null, null); await AwaitExecution(queryService, queryParams, firstRequestContext.Object); // ... And then I request another query after waiting for the first to complete QueryExecuteResult result = null; QueryExecuteCompleteParams complete = null; var secondRequestContext = RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>(qer => result = qer, QueryExecuteCompleteEvent.Type, (et, qecp) => complete = qecp, null); await AwaitExecution(queryService, queryParams, secondRequestContext.Object); // Then: // ... No errors should have been sent // ... A result should have been sent with no errors // ... There should only be one active query VerifyQueryExecuteCallCount(secondRequestContext, Times.Once(), Times.Once(), Times.Never()); Assert.Null(result.Messages); Assert.False(complete.BatchSummaries.Any(b => b.HasError)); Assert.Equal(1, queryService.ActiveQueries.Count); }
public async void QueryExecuteInvalidQueryTest() { // Set up file for returning the query var fileMock = new Mock <ScriptFile>(); fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); // Set up workspace mock var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >(); workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny <string>())) .Returns(fileMock.Object); // If: // ... I request to execute a query that is invalid var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, true), true, workspaceService.Object); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams complete = null; var requestContext = RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>(qer => result = qer, QueryExecuteCompleteEvent.Type, (et, qecp) => complete = qecp, null); await AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No errors should have been sent // ... A result should have been sent with success (we successfully started the query) // ... A completion event should have been sent with error VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Never()); Assert.Null(result.Messages); Assert.Equal(1, complete.BatchSummaries.Length); Assert.True(complete.BatchSummaries[0].HasError); Assert.NotEmpty(complete.BatchSummaries[0].Messages); }
private static async Task ExecuteAndCompleteQuery(QueryExecuteParams executeParams, RequestContext <QueryExecuteResult> requestContext, Query query) { // Skip processing if the query is null if (query == null) { return; } // Setup the query completion/failure callbacks Query.QueryAsyncEventHandler callback = async q => { // Send back the results QueryExecuteCompleteParams eventParams = new QueryExecuteCompleteParams { OwnerUri = executeParams.OwnerUri, BatchSummaries = q.BatchSummaries }; await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); }; Query.QueryAsyncErrorEventHandler errorCallback = async errorMessage => { // Send back the error message QueryExecuteCompleteParams eventParams = new QueryExecuteCompleteParams { OwnerUri = executeParams.OwnerUri, Message = errorMessage }; await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); }; query.QueryCompleted += callback; query.QueryFailed += callback; query.QueryConnectionException += errorCallback; // Setup the batch callbacks Batch.BatchAsyncEventHandler batchStartCallback = async b => { QueryExecuteBatchNotificationParams eventParams = new QueryExecuteBatchNotificationParams { BatchSummary = b.Summary, OwnerUri = executeParams.OwnerUri }; await requestContext.SendEvent(QueryExecuteBatchStartEvent.Type, eventParams); }; query.BatchStarted += batchStartCallback; Batch.BatchAsyncEventHandler batchCompleteCallback = async b => { QueryExecuteBatchNotificationParams eventParams = new QueryExecuteBatchNotificationParams { BatchSummary = b.Summary, OwnerUri = executeParams.OwnerUri }; await requestContext.SendEvent(QueryExecuteBatchCompleteEvent.Type, eventParams); }; query.BatchCompleted += batchCompleteCallback; // Setup the ResultSet completion callback ResultSet.ResultSetAsyncEventHandler resultCallback = async r => { QueryExecuteResultSetCompleteParams eventParams = new QueryExecuteResultSetCompleteParams { ResultSetSummary = r.Summary, OwnerUri = executeParams.OwnerUri }; await requestContext.SendEvent(QueryExecuteResultSetCompleteEvent.Type, eventParams); }; query.ResultSetCompleted += resultCallback; // Launch this as an asynchronous task query.Execute(); // Send back a result showing we were successful string messages = null; if (query.Batches.Length == 0) { // If there were no batches to execute, send back an informational message that the commands were completed successfully messages = SR.QueryServiceCompletedSuccessfully; } await requestContext.SendResult(new QueryExecuteResult { Messages = messages }); }
public async Task QueryExecuteMultipleBatchSingleResultTest() { // Given: // ... A workspace with a standard query is configured var workspaceService = Common.GetPrimedWorkspaceService(string.Format("{0}\r\nGO\r\n{0}", Common.StandardQuery)); // If: // ... I request a to execute a valid query with multiple batches var dataSet = new[] { Common.StandardTestData }; var queryService = Common.GetPrimedExecutionService(dataSet, true, false, workspaceService); var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; List <QueryExecuteBatchNotificationParams> batchStartParams = new List <QueryExecuteBatchNotificationParams>(); List <QueryExecuteBatchNotificationParams> batchCompleteParams = new List <QueryExecuteBatchNotificationParams>(); List <QueryExecuteResultSetCompleteParams> resultCompleteParams = new List <QueryExecuteResultSetCompleteParams>(); var requestContext = RequestContextMocks.Create <QueryExecuteResult>(qer => result = qer) .AddEventHandling(QueryExecuteCompleteEvent.Type, (et, p) => completeParams = p) .AddEventHandling(QueryExecuteBatchStartEvent.Type, (et, p) => batchStartParams.Add(p)) .AddEventHandling(QueryExecuteBatchCompleteEvent.Type, (et, p) => batchCompleteParams.Add(p)) .AddEventHandling(QueryExecuteResultSetCompleteEvent.Type, (et, p) => resultCompleteParams.Add(p)); await Common.AwaitExecution(queryService, queryParams, requestContext.Object); // Then: // ... No errors should have been sent // ... A successful result should have been sent without messages VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Exactly(2), Times.Exactly(2), Times.Exactly(2), Times.Never()); Assert.Null(result.Messages); // ... A completion event should have been fired with one two batch summaries, one result each Assert.Equal(2, completeParams.BatchSummaries.Length); Assert.Equal(1, completeParams.BatchSummaries[0].ResultSetSummaries.Length); Assert.Equal(1, completeParams.BatchSummaries[1].ResultSetSummaries.Length); Assert.NotEmpty(completeParams.BatchSummaries[0].Messages); Assert.NotEmpty(completeParams.BatchSummaries[1].Messages); // ... Two batch start events should have been fired Assert.Equal(2, batchStartParams.Count); foreach (var batch in batchStartParams) { Assert.Null(batch.BatchSummary.Messages); Assert.Null(batch.BatchSummary.ResultSetSummaries); Assert.Equal(Common.OwnerUri, batch.OwnerUri); } // ... Two batch completion events should have been fired Assert.Equal(2, batchCompleteParams.Count); foreach (var batch in batchCompleteParams) { Assert.NotEmpty(batch.BatchSummary.ResultSetSummaries); Assert.NotEmpty(batch.BatchSummary.Messages); Assert.Equal(Common.OwnerUri, batch.OwnerUri); } // ... Two resultset completion events should have been fired Assert.Equal(2, resultCompleteParams.Count); foreach (var resultParam in resultCompleteParams) { Assert.NotNull(resultParam.ResultSetSummary); Assert.Equal(Common.StandardColumns, resultParam.ResultSetSummary.ColumnInfo.Length); Assert.Equal(Common.StandardRows, resultParam.ResultSetSummary.RowCount); Assert.Equal(Common.OwnerUri, resultParam.OwnerUri); } // ... There should be one active query Assert.Equal(1, queryService.ActiveQueries.Count); }