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); }
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); }
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); }
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); }