public void SynchronizationContextCaptured()
{
var syncContext = SingleThreadedTestSynchronizationContext.New();
SynchronizationContext.SetSynchronizationContext(syncContext);
TaskCompletionSource <object> callbackResult = new TaskCompletionSource <object>();
var frame = SingleThreadedTestSynchronizationContext.NewFrame();
var callback = new Action <GenericParameterHelper>(
p =>
{
try
{
Assert.NotNull(SynchronizationContext.Current);
callbackResult.SetResult(null);
}
catch (Exception e)
{
callbackResult.SetException(e);
}
frame.Continue = false;
});
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
IProgress <GenericParameterHelper> reporter = progress;
Task.Run(delegate
{
reporter.Report(new GenericParameterHelper(1));
});
SingleThreadedTestSynchronizationContext.PushFrame(syncContext, frame);
callbackResult.Task.GetAwaiter().GetResult();
}
public void NoWorkAction()
{
var callback = new Action <GenericParameterHelper>(p => { });
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
Assert.True(progress.WaitAsync().IsCompleted);
}
/// <summary>
/// Retrieves all messages waiting for pickup at our endpoint.
/// </summary>
/// <param name="longPoll">if set to <c>true</c> [long poll].</param>
/// <param name="progress">A callback to invoke for each downloaded message as it arrives.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A task whose result is the complete list of received messages.
/// </returns>
public virtual async Task<ReadOnlyListOfMessage> ReceiveAsync(bool longPoll = false, IProgress<Message> progress = null, CancellationToken cancellationToken = default(CancellationToken)) {
var messages = new List<Message>();
ReadOnlyListOfPayload payloads = null;
var payloadProgress = new ProgressWithCompletion<Payload>(
async payload => {
var message = FromPayload(payload);
if (message != null) {
// Sterilize the message of its claimed endpoint's claimed identifiers,
// so that only verifiable identifiers are passed onto our application.
var verifiedIdentifiers = await this.Channel.GetVerifiableIdentifiersAsync(message.Author, cancellationToken);
message.Author.AuthorizedIdentifiers = verifiedIdentifiers.ToArray();
lock (messages) {
messages.Add(message);
}
if (progress != null) {
progress.Report(message);
}
}
});
payloads = await this.Channel.ReceiveAsync(longPoll, payloadProgress, cancellationToken);
// Ensure that we've receives the asynchronous progress notifications for all the payloads
// so we don't return a partial result.
await payloadProgress.WaitAsync();
return messages;
}
private async Task ReceiveMessageLoopAsync()
{
TimeSpan delay = TimeSpan.Zero;
while (this.IsLoaded)
{
try
{
await Task.Delay(delay);
bool lastTimeFailed = delay > TimeSpan.Zero;
delay = TimeSpan.Zero;
var progress = new ProgressWithCompletion <PostalService.MessageReceipt>(m => this.ProcessReceivedMessagedAsync(m.Message));
await this.PostalService.ReceiveAsync(longPoll : !lastTimeFailed, progress : progress);
this.TopInfoBar.Visibility = Visibility.Collapsed;
}
catch (HttpRequestException)
{
// report the error eventually if it keeps happening.
// sleep on it for a while.
delay = TimeSpan.FromSeconds(5);
this.TopInfoBar.Text = "Unable to receive messages. Will try again soon.";
this.TopInfoBar.Visibility = Visibility.Visible;
}
}
}
public void NoWorkFuncOfTask()
{
var callback = new Func <GenericParameterHelper, Task>(p => { return(TplExtensions.CompletedTask); });
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
Assert.True(progress.WaitAsync().IsCompleted);
}
/// <summary>
/// Retrieves all messages waiting for pickup at our endpoint.
/// </summary>
/// <param name="longPoll">if set to <c>true</c> [long poll].</param>
/// <param name="progress">A callback to invoke for each downloaded message as it arrives.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A task whose result is the complete list of received messages.
/// </returns>
public virtual async Task <ReadOnlyListOfMessage> ReceiveAsync(bool longPoll = false, IProgress <Message> progress = null, CancellationToken cancellationToken = default(CancellationToken))
{
var messages = new List <Message>();
ReadOnlyListOfPayload payloads = null;
var payloadProgress = new ProgressWithCompletion <Payload>(
async payload => {
var message = FromPayload(payload);
if (message != null)
{
// Sterilize the message of its claimed endpoint's claimed identifiers,
// so that only verifiable identifiers are passed onto our application.
var verifiedIdentifiers = await this.Channel.GetVerifiableIdentifiersAsync(message.Author, cancellationToken);
message.Author.AuthorizedIdentifiers = verifiedIdentifiers.ToArray();
lock (messages) {
messages.Add(message);
}
if (progress != null)
{
progress.Report(message);
}
}
});
payloads = await this.Channel.ReceiveAsync(longPoll, payloadProgress, cancellationToken);
// Ensure that we've receives the asynchronous progress notifications for all the payloads
// so we don't return a partial result.
await payloadProgress.WaitAsync();
return(messages);
}
public async Task WaitAsync_CancellationToken()
{
var handlerMayComplete = new AsyncManualResetEvent();
var callback = new Func <GenericParameterHelper, Task>(
async p =>
{
Assert.Equal(1, p.Data);
await handlerMayComplete;
});
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
IProgress <GenericParameterHelper> reporter = progress;
reporter.Report(new GenericParameterHelper(1));
var cts = new CancellationTokenSource();
var progressAwaitable = progress.WaitAsync(cts.Token);
await Task.Delay(AsyncDelay);
Assert.False(progressAwaitable.GetAwaiter().IsCompleted);
cts.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => progressAwaitable).WithCancellation(this.TimeoutToken);
// clean up
handlerMayComplete.Set();
}
public void SynchronizationContextCaptured()
{
var syncContext = SingleThreadedTestSynchronizationContext.New();
SynchronizationContext.SetSynchronizationContext(syncContext);
Exception callbackError = null;
var callback = new Action <GenericParameterHelper>(
p =>
{
try
{
Assert.Same(syncContext, SynchronizationContext.Current);
}
catch (Exception e)
{
callbackError = e;
}
});
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
IProgress <GenericParameterHelper> reporter = progress;
Task.Run(delegate
{
reporter.Report(new GenericParameterHelper(1));
});
if (callbackError != null)
{
throw callbackError;
}
}
public async Task HandleRequestAsync_RemapFailure_DiscardsLocation()
{
// Arrange
var progressReported = false;
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var virtualCSharpUri = new Uri("C:/path/to/file.razor.g.cs");
var csharpLocation = GetReferenceItem(100, virtualCSharpUri);
var(requestInvoker, progressListener) = MockServices(csharpLocation, out var token);
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>();
documentMappingProvider.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, Uri, new[] { csharpLocation.Location.Range }, It.IsAny <CancellationToken>())).
Returns(Task.FromResult <RazorMapToDocumentRangesResponse>(null));
var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>();
var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider.Object, progressListener);
referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout;
var progressToken = new ProgressWithCompletion <object>((val) =>
{
var results = Assert.IsType <VSReferenceItem[]>(val);
Assert.Empty(results);
progressReported = true;
});
var referenceRequest = new ReferenceParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5),
PartialResultToken = progressToken
};
// Act
var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(progressReported);
Assert.Empty(result);
}
public async Task HandleRequestAsync_CSharpProjection_DoesNotRemapNonRazorFiles()
{
// Arrange
var progressReported = false;
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var externalCSharpUri = new Uri("C:/path/to/someotherfile.cs");
var externalCsharpLocation = GetReferenceItem(100, 100, 100, 100, externalCSharpUri);
var(requestInvoker, progressListener) = MockServices(externalCsharpLocation, out var token);
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>();
var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>();
var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider, progressListener);
referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout;
var progressToken = new ProgressWithCompletion <object>((val) =>
{
var results = Assert.IsType <VSReferenceItem[]>(val);
var actualLocation = Assert.Single(results);
AssertVSReferenceItem(externalCsharpLocation, actualLocation);
progressReported = true;
});
var referenceRequest = new ReferenceParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5),
PartialResultToken = progressToken
};
// Act
var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(progressReported);
}
private async Task <ImmutableArray <SymbolInformation> > GetVsSearchResultsAsync(TestWorkspace workspace, string query)
{
var solution = workspace.CurrentSolution;
using var client = await RemoteHostClient.TryGetClientAsync(workspace, CancellationToken.None).ConfigureAwait(false);
Assert.NotNull(client);
var document = solution.Projects.First().Documents.First();
await UpdatePrimaryWorkspace(client, solution.WithDocumentFilePath(document.Id, Path.Combine(TempRoot.Root, document.FilePath)));
var workspaceSymbolParams = new WorkspaceSymbolParams
{
Query = query,
};
var symbolResultsBuilder = ArrayBuilder <SymbolInformation> .GetInstance();
var threadingContext = workspace.ExportProvider.GetExportedValue <IThreadingContext>();
var awaitableProgress = new ProgressWithCompletion <SymbolInformation[]>(
symbols => symbolResultsBuilder.AddRange(symbols),
threadingContext.JoinableTaskFactory);
workspaceSymbolParams.PartialResultToken = awaitableProgress;
var result = await client.RunRemoteAsync <JObject>(
WellKnownServiceHubService.RemoteLanguageServer,
Methods.InitializeName,
solution : null,
new object[] { new InitializeParams() },
callbackTarget : null,
CancellationToken.None).ConfigureAwait(false);
Assert.True(result["capabilities"]["workspaceSymbolProvider"].ToObject <bool>());
_ = await client.RunRemoteAsync <SymbolInformation[]>(
WellKnownServiceHubService.RemoteLanguageServer,
Methods.WorkspaceSymbolName,
solution : null,
new object[] { workspaceSymbolParams },
callbackTarget : null,
CancellationToken.None).ConfigureAwait(false);
await awaitableProgress.WaitAsync(CancellationToken.None);
return(symbolResultsBuilder.ToImmutableAndFree());
}
public async Task InvokeWithProgressParameter()
{
AsyncAutoResetEvent signal = new AsyncAutoResetEvent();
int sum = 0;
ProgressWithCompletion <int> progress = new ProgressWithCompletion <int>(report =>
{
sum += report;
signal.Set();
});
int n = 3;
Task <int> invokeTask = this.clientRpc.InvokeWithParameterObjectAsync <int>("test", new { Bar = n, Progress = progress });
JToken request = await this.ReceiveAsync();
long progressID = request["params"]["Progress"].Value <long>();
// Send responses as $/progress
int sum2 = 0;
for (int i = 0; i < n; i++)
{
string content = "{ \"jsonrpc\": \"2.0\", \"method\": \"$/progress\", \"params\": { \"token\": " + progressID + ", \"value\": " + i + "} }";
JObject json = JObject.Parse(content);
this.Send(json);
sum2 += i;
await signal.WaitAsync().WithCancellation(this.TimeoutToken);
Assert.Equal(sum2, sum);
}
Assert.Equal(sum2, sum);
this.Send(new
{
jsonrpc = "2.0",
id = request["id"].Value <long>(),
result = sum,
});
int result = await invokeTask;
Assert.Equal(sum2, result);
}
public async Task InvokeWithProgressParameter()
{
AsyncAutoResetEvent signal = new AsyncAutoResetEvent();
int sum = 0;
ProgressWithCompletion <int> progress = new ProgressWithCompletion <int>(report =>
{
sum += report;
signal.Set();
});
int n = 3;
Task <int> invokeTask = this.clientRpc.InvokeWithParameterObjectAsync <int>("test", new { Bar = n, Progress = progress });
JToken request = await this.ReceiveAsync();
long progressID = request["params"] !["Progress"] !.Value <long>();
private async Task <ImmutableArray <SymbolInformation> > GetVsSearchResultsAsync(TestWorkspace workspace, string query)
{
var solution = workspace.CurrentSolution;
var client = (InProcRemoteHostClient)await InProcRemoteHostClient.CreateAsync(workspace.Services, runCacheCleanup : false);
var document = solution.Projects.First().Documents.First();
await UpdatePrimaryWorkspace(client, solution.WithDocumentFilePath(document.Id, Path.Combine(TempRoot.Root, document.FilePath)));
var workspaceSymbolParams = new WorkspaceSymbolParams
{
Query = query,
};
var symbolResultsBuilder = ArrayBuilder <SymbolInformation> .GetInstance();
var threadingContext = workspace.ExportProvider.GetExportedValue <IThreadingContext>();
var awaitableProgress = new ProgressWithCompletion <SymbolInformation[]>(symbols =>
{
symbolResultsBuilder.AddRange(symbols);
}, threadingContext.JoinableTaskFactory);
workspaceSymbolParams.PartialResultToken = awaitableProgress;
using (var jsonRpc = JsonRpc.Attach(await client.RequestServiceAsync(WellKnownServiceHubService.LanguageServer)))
{
var result = await jsonRpc.InvokeWithCancellationAsync <JObject>(
Methods.InitializeName,
new object[] { new InitializeParams() },
CancellationToken.None);
Assert.True(result["capabilities"]["workspaceSymbolProvider"].ToObject <bool>());
var symbolResult = await jsonRpc.InvokeWithCancellationAsync <SymbolInformation[]>(
Methods.WorkspaceSymbolName,
new object[] { workspaceSymbolParams },
CancellationToken.None);
await awaitableProgress.WaitAsync(CancellationToken.None);
}
return(symbolResultsBuilder.ToImmutableAndFree());
}
private async Task ReceiveMessageLoopAsync() {
TimeSpan delay = TimeSpan.Zero;
while (this.IsLoaded) {
try {
await Task.Delay(delay);
bool lastTimeFailed = delay > TimeSpan.Zero;
delay = TimeSpan.Zero;
var progress = new ProgressWithCompletion<Payload>(m => this.ProcessReceivedMessagedAsync(m));
await this.Channel.ReceiveAsync(longPoll: !lastTimeFailed, progress: progress);
this.TopInfoBar.Visibility = Visibility.Collapsed;
} catch (HttpRequestException) {
// report the error eventually if it keeps happening.
// sleep on it for a while.
delay = TimeSpan.FromSeconds(5);
this.TopInfoBar.Text = "Unable to receive messages. Will try again soon.";
this.TopInfoBar.Visibility = Visibility.Visible;
}
}
}
public async Task WaitAsync()
{
var handlerMayComplete = new AsyncManualResetEvent();
var callback = new Func <GenericParameterHelper, Task>(
async p =>
{
Assert.Equal(1, p.Data);
await handlerMayComplete;
});
var progress = new ProgressWithCompletion <GenericParameterHelper>(callback);
IProgress <GenericParameterHelper> reporter = progress;
reporter.Report(new GenericParameterHelper(1));
var progressAwaitable = progress.WaitAsync();
Assert.False(progressAwaitable.GetAwaiter().IsCompleted);
await Task.Delay(AsyncDelay);
Assert.False(progressAwaitable.GetAwaiter().IsCompleted);
handlerMayComplete.Set();
await progressAwaitable;
}
public async Task HandleRequestAsync_LargeProject_InvokesCSharpLanguageServer()
{
// Validates batching mechanism for the progress notification on large projects
// Arrange
var lspFarEndpointCalled = false;
const int BATCH_SIZE = 10;
const int NUM_BATCHES = 10;
const int NUM_DOCUMENTS = BATCH_SIZE * NUM_BATCHES;
const int MAPPING_OFFSET = 10;
var expectedUris = new Uri[NUM_DOCUMENTS];
var virtualUris = new Uri[NUM_DOCUMENTS];
var expectedReferences = new VSReferenceItem[NUM_BATCHES][];
var csharpUnmappedReferences = new VSReferenceItem[NUM_BATCHES][];
var parameterTokens = new JObject[NUM_BATCHES];
var token = Guid.NewGuid().ToString();
var documentNumber = 0;
for (var batch = 0; batch < NUM_BATCHES; ++batch)
{
expectedReferences[batch] = new VSReferenceItem[BATCH_SIZE];
csharpUnmappedReferences[batch] = new VSReferenceItem[BATCH_SIZE];
for (var documentInBatch = 0; documentInBatch < BATCH_SIZE; ++documentInBatch)
{
expectedUris[documentNumber] = new Uri($"C:/path/to/file{documentNumber}.razor");
virtualUris[documentNumber] = new Uri($"C:/path/to/file{documentNumber}.razor.g.cs");
expectedReferences[batch][documentInBatch] = GetReferenceItem(documentNumber, expectedUris[documentNumber]);
var umappedOffset = documentNumber * MAPPING_OFFSET;
csharpUnmappedReferences[batch][documentInBatch] = GetReferenceItem(umappedOffset, virtualUris[documentNumber]);
documentNumber++;
}
parameterTokens[batch] = new JObject
{
{ "token", token },
{ "value", JArray.FromObject(csharpUnmappedReferences[batch]) }
};
}
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>();
using var lspProgressListener = new DefaultLSPProgressListener(languageServiceBroker);
var requestInvoker = new Mock <LSPRequestInvoker>();
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, VSReferenceItem[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) =>
{
Assert.Equal(Methods.TextDocumentReferencesName, method);
Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType);
lspFarEndpointCalled = true;
for (var i = 0; i < NUM_BATCHES; ++i)
{
_ = lspProgressListener.ProcessProgressNotificationAsync(Methods.ProgressNotificationName, parameterTokens[i]);
}
})
.Returns(Task.FromResult(Array.Empty <VSReferenceItem>()));
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>();
documentMappingProvider
.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, It.IsAny <Uri>(), It.IsAny <Range[]>(), It.IsAny <CancellationToken>()))
.Returns <RazorLanguageKind, Uri, Range[], CancellationToken>((languageKind, uri, ranges, ct) =>
{
var unmappedPosition = ranges[0].Start.Line;
var mappedPosition = unmappedPosition / MAPPING_OFFSET;
var mappedRange = new Range()
{
Start = new Position(mappedPosition, mappedPosition),
End = new Position(mappedPosition, mappedPosition)
};
var response = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { mappedRange }
};
return(Task.FromResult(response));
});
var referencesHandler = new FindAllReferencesHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, lspProgressListener);
referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout;
var progressBatchesReported = new ConcurrentBag <VSReferenceItem[]>();
var progressToken = new ProgressWithCompletion <object>((val) =>
{
var results = Assert.IsType <VSReferenceItem[]>(val);
Assert.Equal(BATCH_SIZE, results.Length);
progressBatchesReported.Add(results);
});
var referenceRequest = new ReferenceParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5),
PartialResultToken = progressToken
};
// Act
var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(lspFarEndpointCalled);
var sortedBatchesReported = progressBatchesReported.ToList();
sortedBatchesReported.Sort((VSReferenceItem[] a, VSReferenceItem[] b) =>
{
var indexA = a[0].Location.Range.Start.Character;
var indexB = b[0].Location.Range.Start.Character;
return(indexA.CompareTo(indexB));
});
Assert.Equal(NUM_BATCHES, sortedBatchesReported.Count);
for (var batch = 0; batch < NUM_BATCHES; ++batch)
{
for (var documentInBatch = 0; documentInBatch < BATCH_SIZE; ++documentInBatch)
{
AssertVSReferenceItem(
expectedReferences[batch][documentInBatch],
sortedBatchesReported[batch][documentInBatch]);
}
}
}
public async Task HandleRequestAsync_HtmlProjection_InvokesHtmlLanguageServer()
{
// Arrange
var lspFarEndpointCalled = false;
var progressReported = false;
var expectedUri1 = new Uri("C:/path/to/file1.razor");
var expectedUri2 = new Uri("C:/path/to/file2.razor");
var expectedLocation1 = GetReferenceItem(5, expectedUri1);
var expectedLocation2 = GetReferenceItem(10, expectedUri2);
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var virtualHtmlUri1 = new Uri("C:/path/to/file1.razor__virtual.html");
var virtualHtmlUri2 = new Uri("C:/path/to/file2.razor__virtual.html");
var htmlLocation1 = GetReferenceItem(100, virtualHtmlUri1);
var htmlLocation2 = GetReferenceItem(200, virtualHtmlUri2);
var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>();
using var lspProgressListener = new DefaultLSPProgressListener(languageServiceBroker);
var token = Guid.NewGuid().ToString();
var parameterToken = new JObject
{
{ "token", token },
{ "value", JArray.FromObject(new[] { htmlLocation1, htmlLocation2 }) }
};
var requestInvoker = new Mock <LSPRequestInvoker>();
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, VSReferenceItem[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) =>
{
Assert.Equal(Methods.TextDocumentReferencesName, method);
Assert.Equal(RazorLSPConstants.HtmlLSPContentTypeName, serverContentType);
lspFarEndpointCalled = true;
_ = lspProgressListener.ProcessProgressNotificationAsync(Methods.ProgressNotificationName, parameterToken);
})
.Returns(Task.FromResult(Array.Empty <VSReferenceItem>()));
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.Html,
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var remappingResult1 = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { expectedLocation1.Location.Range }
};
var remappingResult2 = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { expectedLocation2.Location.Range }
};
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>();
documentMappingProvider
.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.Html, It.IsAny <Uri>(), It.IsAny <Range[]>(), It.IsAny <CancellationToken>()))
.Returns <RazorLanguageKind, Uri, Range[], CancellationToken>((languageKind, uri, ranges, ct) => Task.FromResult(uri.LocalPath.Contains("file1") ? remappingResult1 : remappingResult2));
var referencesHandler = new FindAllReferencesHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, lspProgressListener);
referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout;
var progressToken = new ProgressWithCompletion <object>((val) =>
{
var results = Assert.IsType <VSReferenceItem[]>(val);
Assert.Collection(results,
a => AssertVSReferenceItem(expectedLocation1, a),
b => AssertVSReferenceItem(expectedLocation2, b));
progressReported = true;
});
var referenceRequest = new ReferenceParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5),
PartialResultToken = progressToken
};
// Act
var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(lspFarEndpointCalled);
Assert.True(progressReported);
}
public async Task HandleRequestAsync_CSharpProjection_FiltersReferenceClassifiedRuns()
{
// Arrange
var progressReported = false;
var externalUri = new Uri("C:/path/to/someotherfile.razor");
var expectedClassifiedRun = new ClassifiedTextElement(new ClassifiedTextRun[]
{
new ClassifiedTextRun("text", "counter"),
});
var expectedReferenceItem = GetReferenceItem(5, 5, 5, 5, externalUri, text: expectedClassifiedRun);
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(d => d.Version == 2));
documentManager.AddDocument(externalUri, Mock.Of <LSPDocumentSnapshot>(d => d.Version == 5));
var virtualClassifiedRun = new ClassifiedTextElement(new ClassifiedTextRun[]
{
new ClassifiedTextRun("field name", "__o"),
new ClassifiedTextRun("text", " "),
new ClassifiedTextRun("operator", "="),
new ClassifiedTextRun("text", " "),
new ClassifiedTextRun("text", "counter"),
new ClassifiedTextRun("punctuation", ";"),
});
var virtualCSharpUri = new Uri("C:/path/to/someotherfile.razor.g.cs");
var csharpLocation = GetReferenceItem(100, 100, 100, 100, virtualCSharpUri, text: virtualClassifiedRun);
var(requestInvoker, progressListener) = MockServices(csharpLocation, out var token);
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var remappingResult = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { expectedReferenceItem.Location.Range },
HostDocumentVersion = 5
};
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>();
documentMappingProvider.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, externalUri, new[] { csharpLocation.Location.Range }, It.IsAny <CancellationToken>())).
Returns(Task.FromResult(remappingResult));
var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider.Object, progressListener);
referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout;
var progressToken = new ProgressWithCompletion <object>((val) =>
{
var results = Assert.IsType <VSReferenceItem[]>(val);
var actualReferenceItem = Assert.Single(results);
AssertVSReferenceItem(expectedReferenceItem, actualReferenceItem);
progressReported = true;
});
var referenceRequest = new ReferenceParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5),
PartialResultToken = progressToken
};
// Act
var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(progressReported);
}
public void Ctor_NullJtf()
{
var progress = new ProgressWithCompletion <GenericParameterHelper>(v => { }, joinableTaskFactory: null);
progress = new ProgressWithCompletion <GenericParameterHelper>(v => TplExtensions.CompletedTask, joinableTaskFactory: null);
}
