public async Task CancelInProgressQueryTest()
{
// If:
// ... I request a query (doesn't matter what kind) and execute it
var workspaceService = Common.GetPrimedWorkspaceService(Common.StandardQuery);
var queryService = Common.GetPrimedExecutionService(null, true, false, workspaceService);
var executeParams = new ExecuteDocumentSelectionParams {
QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri
};
var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
await queryService.HandleExecuteRequest(executeParams, executeRequest.Object);
await queryService.ActiveQueries[Common.OwnerUri].ExecutionTask;
queryService.ActiveQueries[Common.OwnerUri].HasExecuted = false; // Fake that it hasn't completed execution
// ... And then I request to cancel the query
var cancelParams = new QueryCancelParams {
OwnerUri = Common.OwnerUri
};
var cancelRequest = new EventFlowValidator <QueryCancelResult>()
.AddResultValidation(r =>
{
Assert.Null(r.Messages);
}).Complete();
await queryService.HandleCancelRequest(cancelParams, cancelRequest.Object);
// Then:
// ... The query should not have been disposed
Assert.Equal(1, queryService.ActiveQueries.Count);
cancelRequest.Validate();
}
public async Task CancelExecutedQueryTest()
{
// If:
// ... I request a query (doesn't matter what kind) and wait for execution
var workspaceService = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
var queryService = Common.GetPrimedExecutionService(null, true, false, false, workspaceService);
var executeParams = new ExecuteDocumentSelectionParams {
QuerySelection = Common.WholeDocument, OwnerUri = Constants.OwnerUri
};
var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
await queryService.HandleExecuteRequest(executeParams, executeRequest.Object);
await queryService.ActiveQueries[Constants.OwnerUri].ExecutionTask;
// ... And then I request to cancel the query
var cancelParams = new QueryCancelParams {
OwnerUri = Constants.OwnerUri
};
var cancelRequest = new EventFlowValidator <QueryCancelResult>()
.AddResultValidation(r =>
{
Assert.False(string.IsNullOrWhiteSpace(r.Messages));
}).Complete();
await queryService.HandleCancelRequest(cancelParams, cancelRequest.Object);
// Then:
// ... The query should not have been disposed
Assert.NotEmpty(queryService.ActiveQueries);
cancelRequest.Validate();
}
/// <summary>
/// Handles a request to cancel this query if it is in progress
/// </summary>
internal async Task HandleCancelRequest(QueryCancelParams cancelParams,
RequestContext <QueryCancelResult> requestContext)
{
try
{
// Attempt to find the query for the owner uri
Query result;
if (!ActiveQueries.TryGetValue(cancelParams.OwnerUri, out result))
{
await requestContext.SendResult(new QueryCancelResult
{
Messages = SR.QueryServiceRequestsNoQuery
});
return;
}
// Cancel the query and send a success message
result.Cancel();
await requestContext.SendResult(new QueryCancelResult());
}
catch (InvalidOperationException e)
{
// If this exception occurred, we most likely were trying to cancel a completed query
await requestContext.SendResult(new QueryCancelResult
{
Messages = e.Message
});
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>
/// Request to cancel an executing query
/// </summary>
public async Task <QueryCancelResult> CancelQuery(string ownerUri)
{
var cancelParams = new QueryCancelParams {
OwnerUri = ownerUri
};
var result = await Driver.SendRequest(QueryCancelRequest.Type, cancelParams);
return(result);
}
public async void CancelInProgressQueryTest()
{
// Set up file for returning the query
var fileMock = new Mock <ScriptFile>();
fileMock.Setup(file => file.GetLinesInRange(It.IsAny <BufferRange>()))
.Returns(new[] { 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 a query (doesn't matter what kind) and execute it
var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object);
var executeParams = new QueryExecuteParams {
QuerySelection = Common.GetSubSectionDocument(), OwnerUri = Common.OwnerUri
};
var executeRequest =
RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>(null, QueryExecuteCompleteEvent.Type, null, null);
await queryService.HandleExecuteRequest(executeParams, executeRequest.Object);
await queryService.ActiveQueries[Common.OwnerUri].ExecutionTask;
queryService.ActiveQueries[Common.OwnerUri].HasExecuted = false; // Fake that it hasn't completed execution
// ... And then I request to cancel the query
var cancelParams = new QueryCancelParams {
OwnerUri = Common.OwnerUri
};
QueryCancelResult result = null;
var cancelRequest = GetQueryCancelResultContextMock(qcr => result = qcr, null);
queryService.HandleCancelRequest(cancelParams, cancelRequest.Object).Wait();
// Then:
// ... I should have seen a successful event (no messages)
VerifyQueryCancelCallCount(cancelRequest, Times.Once(), Times.Never());
Assert.Null(result.Messages);
// ... The query should not have been disposed
Assert.Equal(1, queryService.ActiveQueries.Count);
}
public async Task CancelNonExistantTest()
{
var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >();
// If:
// ... I request to cancel a query that doesn't exist
var queryService = Common.GetPrimedExecutionService(null, false, false, workspaceService.Object);
var cancelParams = new QueryCancelParams {
OwnerUri = "Doesn't Exist"
};
QueryCancelResult result = null;
var cancelRequest = GetQueryCancelResultContextMock(qcr => result = qcr, null);
await queryService.HandleCancelRequest(cancelParams, cancelRequest.Object);
// Then:
// ... I should have seen a result event with an error message
VerifyQueryCancelCallCount(cancelRequest, Times.Once(), Times.Never());
Assert.NotNull(result.Messages);
}
public async Task CancelNonExistantTest()
{
// If:
// ... I request to cancel a query that doesn't exist
var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >();
var queryService = Common.GetPrimedExecutionService(null, false, false, false, workspaceService.Object);
var cancelParams = new QueryCancelParams {
OwnerUri = "Doesn't Exist"
};
var cancelRequest = new EventFlowValidator <QueryCancelResult>()
.AddResultValidation(r =>
{
Assert.False(string.IsNullOrWhiteSpace(r.Messages));
}).Complete();
await queryService.HandleCancelRequest(cancelParams, cancelRequest.Object);
cancelRequest.Validate();
}
public async void CancelExecutedQueryTest()
{
// 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 a query (doesn't matter what kind) and wait for execution
var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object);
var executeParams = new QueryExecuteParams {
QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri
};
var executeRequest =
RequestContextMocks.SetupRequestContextMock <QueryExecuteResult, QueryExecuteCompleteParams>(null, QueryExecuteCompleteEvent.Type, null, null);
await queryService.HandleExecuteRequest(executeParams, executeRequest.Object);
await queryService.ActiveQueries[Common.OwnerUri].ExecutionTask;
// ... And then I request to cancel the query
var cancelParams = new QueryCancelParams {
OwnerUri = Common.OwnerUri
};
QueryCancelResult result = null;
var cancelRequest = GetQueryCancelResultContextMock(qcr => result = qcr, null);
await queryService.HandleCancelRequest(cancelParams, cancelRequest.Object);
// Then:
// ... I should have seen a result event with an error message
VerifyQueryCancelCallCount(cancelRequest, Times.Once(), Times.Never());
Assert.NotNull(result.Messages);
// ... The query should not have been disposed
Assert.NotEmpty(queryService.ActiveQueries);
}