public async Task DisposeExecutedQuery()
{
// If:
// ... I request a query (doesn't matter what kind)
var workspaceService = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
var queryService = Common.GetPrimedExecutionService(null, true, false, false, workspaceService);
var executeParams = new ExecuteDocumentSelectionParams {
QuerySelection = null, OwnerUri = Constants.OwnerUri
};
var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
await queryService.HandleExecuteRequest(executeParams, executeRequest.Object);
await queryService.WorkTask;
await queryService.ActiveQueries[Constants.OwnerUri].ExecutionTask;
// ... And then I dispose of the query
var disposeParams = new QueryDisposeParams {
OwnerUri = Constants.OwnerUri
};
var disposeRequest = new EventFlowValidator <QueryDisposeResult>()
.AddStandardQueryDisposeValidator()
.Complete();
await queryService.HandleDisposeRequest(disposeParams, disposeRequest.Object);
// Then:
// ... And the active queries should be empty
disposeRequest.Validate();
Assert.Empty(queryService.ActiveQueries);
}
public async Task HandleDisposeRequest(QueryDisposeParams disposeParams,
RequestContext <QueryDisposeResult> requestContext)
{
try
{
// Attempt to remove the query for the owner uri
Query result;
if (!ActiveQueries.TryRemove(disposeParams.OwnerUri, out result))
{
await requestContext.SendResult(new QueryDisposeResult
{
Messages = SR.QueryServiceRequestsNoQuery
});
return;
}
// Cleanup the query
result.Dispose();
// Success
await requestContext.SendResult(new QueryDisposeResult
{
Messages = null
});
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>
/// Handles a request to dispose of this query
/// </summary>
internal async Task HandleDisposeRequest(QueryDisposeParams disposeParams,
RequestContext <QueryDisposeResult> requestContext)
{
// Setup action for success and failure
Func <Task> successAction = () => requestContext.SendResult(new QueryDisposeResult());
Func <string, Task> failureAction = message => requestContext.SendError(message);
// Use the inter-service dispose functionality
await InterServiceDisposeQuery(disposeParams.OwnerUri, successAction, failureAction);
}
public async Task QueryDisposeMissingQuery()
{
// If:
// ... I attempt to dispose a query that doesn't exist
var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >();
var queryService = Common.GetPrimedExecutionService(null, false, false, false, workspaceService.Object);
var disposeParams = new QueryDisposeParams {
OwnerUri = Constants.OwnerUri
};
var disposeRequest = new EventFlowValidator <QueryDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleDisposeRequest(disposeParams, disposeRequest.Object);
// Then: I should have received an error
disposeRequest.Validate();
}
public async void QueryDisposeMissingQuery()
{
var workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >();
// If:
// ... I attempt to dispose a query that doesn't exist
var queryService = Common.GetPrimedExecutionService(null, false, false, workspaceService.Object);
var disposeParams = new QueryDisposeParams {
OwnerUri = Common.OwnerUri
};
QueryDisposeResult result = null;
var disposeRequest = GetQueryDisposeResultContextMock(qdr => result = qdr, null);
await queryService.HandleDisposeRequest(disposeParams, disposeRequest.Object);
// Then:
// ... I should have gotten an error result
VerifyQueryDisposeCallCount(disposeRequest, Times.Once(), Times.Never());
Assert.NotNull(result.Messages);
Assert.NotEmpty(result.Messages);
}
public async void DisposeExecutedQuery()
{
// Set up file for returning the query
var fileMock = new Mock <ScriptFile>();
fileMock.SetupGet(file => file.Contents).Returns("doesn't matter");
// 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)
var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object);
var executeParams = new QueryExecuteParams {
QuerySelection = null, 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 dispose of the query
var disposeParams = new QueryDisposeParams {
OwnerUri = Common.OwnerUri
};
QueryDisposeResult result = null;
var disposeRequest = GetQueryDisposeResultContextMock(qdr => {
result = qdr;
}, null);
queryService.HandleDisposeRequest(disposeParams, disposeRequest.Object).Wait();
// Then:
// ... I should have seen a successful result
// ... And the active queries should be empty
VerifyQueryDisposeCallCount(disposeRequest, Times.Once(), Times.Never());
Assert.Null(result.Messages);
Assert.Empty(queryService.ActiveQueries);
}
