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_VersionMismatch_DiscardsExternalRazorFiles()
{
// Arrange
var progressReported = false;
var externalUri = new Uri("C:/path/to/someotherfile.razor");
var expectedLocation = GetReferenceItem(5, externalUri);
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 virtualCSharpUri = new Uri("C:/path/to/someotherfile.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 remappingResult = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { expectedLocation.Location.Range },
HostDocumentVersion = 6
};
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 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_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_InvokesCSharpLanguageServer_RemapsResults()
{
// Arrange
var invokedCSharpServer = false;
var remapped = false;
var expectedEdit = new TextEdit();
var remappedEdit = new TextEdit();
var documentManager = new TestDocumentManager();
var snapshot = new StringTextSnapshot(@"
@code {
public string _foo;
}");
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(m => m.Snapshot == snapshot));
var requestInvoker = new Mock <LSPRequestInvoker>();
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <DocumentOnTypeFormattingParams, TextEdit[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DocumentOnTypeFormattingParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, DocumentOnTypeFormattingParams, CancellationToken>((method, serverContentType, onTypeFormattingParams, ct) =>
{
Assert.Equal(Methods.TextDocumentOnTypeFormattingName, method);
Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType);
invokedCSharpServer = true;
})
.Returns(Task.FromResult(new[] { expectedEdit }));
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 mappingProvider = new Mock <LSPDocumentMappingProvider>();
mappingProvider
.Setup(m => m.RemapFormattedTextEditsAsync(It.IsAny <Uri>(), It.IsAny <TextEdit[]>(), It.IsAny <FormattingOptions>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Callback(() => { remapped = true; })
.Returns(Task.FromResult(new[] { remappedEdit }));
var formatOnTypeHandler = new OnTypeFormattingHandler(documentManager, requestInvoker.Object, projectionProvider.Object, mappingProvider.Object);
var formattingRequest = new DocumentOnTypeFormattingParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(2, 19),
Character = ";",
Options = new FormattingOptions()
};
// Act
var result = await formatOnTypeHandler.HandleRequestAsync(formattingRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(invokedCSharpServer);
Assert.True(remapped);
var edit = Assert.Single(result);
Assert.Same(remappedEdit, edit);
}
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 async Task HandleRequestAsync_HtmlProjection_InvokesHtmlLanguageServer()
{
// Arrange
var invokedLSPRequest = false;
var invokedRemapRequest = false;
var expectedLocation = GetLocation(5, 5, 5, 5, Uri);
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(MockBehavior.Strict));
var virtualHtmlUri = new Uri("C:/path/to/file.razor__virtual.html");
var htmlLocation = GetLocation(100, 100, 100, 100, virtualHtmlUri);
var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, Location[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) =>
{
Assert.Equal(Methods.TextDocumentDefinitionName, method);
Assert.Equal(RazorLSPConstants.HtmlLSPContentTypeName, serverContentType);
invokedLSPRequest = true;
})
.Returns(Task.FromResult(new[] { htmlLocation }));
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.Html,
};
var projectionProvider = new Mock <LSPProjectionProvider>(MockBehavior.Strict);
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(MockBehavior.Strict);
documentMappingProvider
.Setup(d => d.RemapLocationsAsync(It.IsAny <Location[]>(), It.IsAny <CancellationToken>()))
.Callback <Location[], CancellationToken>((locations, token) =>
{
Assert.Equal(htmlLocation, locations[0]);
invokedRemapRequest = true;
})
.Returns(Task.FromResult(Array.Empty <Location>()));
var definitionHandler = new GoToDefinitionHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, LoggerProvider);
var definitionRequest = new TextDocumentPositionParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(10, 5)
};
// Act
var result = await definitionHandler.HandleRequestAsync(definitionRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(invokedLSPRequest);
Assert.True(invokedRemapRequest);
// Actual remapping behavior is tested elsewhere.
}
public async Task HandleRequestAsync_InvokesCSharpServer_RemapsEdits()
{
// Arrange
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(s => s.Uri == Uri && s.Snapshot == Mock.Of <ITextSnapshot>(MockBehavior.Strict), MockBehavior.Strict));
var invokedServer = false;
var mappedTextEdits = false;
var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <DocumentOnAutoInsertParams, DocumentOnAutoInsertResponseItem>(MSLSPMethods.OnAutoInsertName, It.IsAny <string>(), It.IsAny <DocumentOnAutoInsertParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, DocumentOnAutoInsertParams, CancellationToken>((method, serverContentType, formattingParams, ct) =>
{
invokedServer = true;
})
.Returns(Task.FromResult(new DocumentOnAutoInsertResponseItem()
{
TextEdit = new TextEdit()
{
Range = new Range(), NewText = "sometext"
}, TextEditFormat = InsertTextFormat.Snippet
}));
var projectionUri = new Uri(Uri.AbsoluteUri + "__virtual.html");
var projectionResult = new ProjectionResult()
{
Uri = projectionUri,
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>(MockBehavior.Strict);
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(MockBehavior.Strict);
documentMappingProvider
.Setup(d => d.RemapFormattedTextEditsAsync(projectionUri, It.IsAny <TextEdit[]>(), It.IsAny <FormattingOptions>(), /*containsSnippet*/ true, It.IsAny <CancellationToken>()))
.Callback(() => { mappedTextEdits = true; })
.Returns(Task.FromResult(new[] { new TextEdit()
{
NewText = "mapped-sometext"
} }));
var handler = new OnAutoInsertHandler(documentManager, requestInvoker.Object, projectionProvider.Object, documentMappingProvider.Object, LoggerProvider);
var request = new DocumentOnAutoInsertParams()
{
Character = "/",
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Options = new FormattingOptions()
{
OtherOptions = new Dictionary <string, object>()
},
Position = new Position(1, 4)
};
// Act
var response = await handler.HandleRequestAsync(request, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(invokedServer);
Assert.True(mappedTextEdits);
Assert.NotNull(response);
}
public async Task TryGetProvisionalCompletionsAsync_AtCorrectProvisionalCompletionPoint_ReturnsExpectedResult()
{
// Arrange
var completionRequest = new CompletionParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Context = new CompletionContext()
{
TriggerKind = CompletionTriggerKind.TriggerCharacter,
TriggerCharacter = "."
},
Position = new Position(0, 1)
};
var virtualDocumentUri = new Uri("C:/path/to/file.razor__virtual.cs");
var documentManager = new TestDocumentManager();
var languageServerCalled = false;
var expectedItem = new CompletionItem()
{
InsertText = "DateTime"
};
var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <CompletionParams, SumType <CompletionItem[], CompletionList>?>(It.IsAny <string>(), RazorLSPConstants.CSharpContentTypeName, It.IsAny <CompletionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, CompletionParams, CancellationToken>((method, serverContentType, completionParams, ct) =>
{
Assert.Equal(Methods.TextDocumentCompletionName, method);
Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType);
languageServerCalled = true;
})
.Returns(Task.FromResult <SumType <CompletionItem[], CompletionList>?>(new[] { expectedItem }));
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.Html,
Position = new Position(1, 7)
};
var previousCharacterProjection = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
Position = new Position(100, 10),
PositionIndex = 1000,
Uri = virtualDocumentUri
};
var projectionProvider = new Mock <LSPProjectionProvider>();
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(previousCharacterProjection));
var completionHandler = new CompletionHandler(JoinableTaskContext, requestInvoker.Object, documentManager, projectionProvider.Object);
// Act
var(succeeded, result) = await completionHandler.TryGetProvisionalCompletionsAsync(completionRequest, Mock.Of <LSPDocumentSnapshot>(), projectionResult, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(succeeded);
Assert.True(languageServerCalled);
Assert.Equal(2, documentManager.UpdateVirtualDocumentCallCount);
Assert.NotNull(result);
var item = Assert.Single((CompletionItem[])result.Value);
Assert.Equal(expectedItem.InsertText, item.InsertText);
}
public async Task HandleRequestAsync_CSharpProjection_ReturnsKeywordsFromCSharp()
{
// Arrange
var called = false;
var expectedItems = new CompletionItem[] {
new CompletionItem()
{
InsertText = "DateTime", Label = "DateTime"
},
new CompletionItem()
{
InsertText = "FROMCSHARP", Label = "for"
},
};
var completionRequest = new CompletionParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Context = new CompletionContext()
{
TriggerKind = CompletionTriggerKind.Invoked, TriggerCharacter = "@"
},
Position = new Position(0, 1)
};
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var requestInvoker = new Mock <LSPRequestInvoker>();
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <CompletionParams, SumType <CompletionItem[], CompletionList>?>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CompletionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, CompletionParams, CancellationToken>((method, serverContentType, completionParams, ct) =>
{
Assert.Equal(Methods.TextDocumentCompletionName, method);
Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType);
called = true;
})
.Returns(Task.FromResult <SumType <CompletionItem[], CompletionList>?>(expectedItems));
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 completionHandler = new CompletionHandler(JoinableTaskContext, requestInvoker.Object, documentManager, projectionProvider.Object);
// Act
var result = await completionHandler.HandleRequestAsync(completionRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(called);
Assert.True(result.HasValue);
var _ = result.Value.Match <SumType <CompletionItem[], CompletionList> >(
array => {
Assert.Collection(array,
item => Assert.Equal("DateTime", item.InsertText),
item => {
Assert.Equal("for", item.Label);
Assert.Equal("FROMCSHARP", item.InsertText);
},
item => Assert.Equal("foreach", item.Label),
item => Assert.Equal("while", item.Label),
item => Assert.Equal("switch", item.Label),
item => Assert.Equal("lock", item.Label),
item => Assert.Equal("case", item.Label),
item => Assert.Equal("if", item.Label),
item => Assert.Equal("try", item.Label),
item => Assert.Equal("do", item.Label),
item => Assert.Equal("using", item.Label)
);;
return(array);
},
list => {
throw new NotImplementedException();
});
}
public async Task HandleRequestAsync_CSharpProjection_InvokesCSharpLanguageServer()
{
// Arrange
var called = false;
var expectedContents = new SumType <SumType <string, MarkedString>, SumType <string, MarkedString>[], MarkupContent>(
new MarkedString()
{
Language = "markdown",
Value = "Hover Details"
}
);
var lspResponse = new Hover()
{
Range = new Range()
{
Start = new Position(10, 0),
End = new Position(10, 1)
},
Contents = expectedContents
};
var expectedItem = new Hover()
{
Range = new Range()
{
Start = new Position(0, 0),
End = new Position(0, 1)
},
Contents = expectedContents
};
var hoverRequest = new TextDocumentPositionParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(0, 1)
};
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
var requestInvoker = new Mock <LSPRequestInvoker>();
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, Hover>(It.IsAny <string>(), It.IsAny <LanguageServerKind>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, LanguageServerKind, TextDocumentPositionParams, CancellationToken>((method, serverKind, hoverParams, ct) =>
{
Assert.Equal(Methods.TextDocumentHoverName, method);
Assert.Equal(LanguageServerKind.CSharp, serverKind);
called = true;
})
.Returns(Task.FromResult(lspResponse));
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 RazorMapToDocumentRangeResponse()
{
Range = new Range()
{
Start = new Position(0, 0),
End = new Position(0, 1)
}
};
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>();
documentMappingProvider.Setup(d => d.MapToDocumentRangeAsync(RazorLanguageKind.CSharp, It.IsAny <Uri>(), It.IsAny <Range>(), It.IsAny <CancellationToken>())).
Returns(Task.FromResult(remappingResult));
var hoverHandler = new HoverHandler(JoinableTaskContext, requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object);
// Act
var result = await hoverHandler.HandleRequestAsync(hoverRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(called);
Assert.Equal(expectedItem.Contents, result.Contents);
Assert.Equal(expectedItem.Range, result.Range);
}
public async Task HandleRequestAsync_InvokesServer_RemapsAndAppliesEdits()
{
// Arrange
var documentManager = new TestDocumentManager();
documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(s => s.Uri == Uri && s.Snapshot == Mock.Of <ITextSnapshot>()));
var invokedServer = false;
var mappedTextEdits = false;
var appliedTextEdits = false;
var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <DocumentOnTypeFormattingParams, TextEdit[]>(Methods.TextDocumentOnTypeFormattingName, It.IsAny <LanguageServerKind>(), It.IsAny <DocumentOnTypeFormattingParams>(), It.IsAny <CancellationToken>()))
.Callback <string, LanguageServerKind, DocumentOnTypeFormattingParams, CancellationToken>((method, serverKind, formattingParams, ct) =>
{
Assert.True(formattingParams.Options.OtherOptions.ContainsKey(LanguageServerConstants.ExpectsCursorPlaceholderKey));
invokedServer = true;
})
.Returns(Task.FromResult <TextEdit[]>(new[] { new TextEdit()
{
Range = new Range(), NewText = "sometext"
} }));
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 documentMappingProvider = new Mock <LSPDocumentMappingProvider>(MockBehavior.Strict);
documentMappingProvider
.Setup(d => d.MapToDocumentRangeAsync(RazorLanguageKind.Html, Uri, It.IsAny <Range>(), It.IsAny <CancellationToken>()))
.Callback(() => { mappedTextEdits = true; })
.Returns(Task.FromResult(new RazorMapToDocumentRangeResponse()));
var editorService = new Mock <LSPEditorService>(MockBehavior.Strict);
editorService.Setup(e => e.ApplyTextEditsAsync(Uri, It.IsAny <ITextSnapshot>(), It.IsAny <IEnumerable <TextEdit> >())).Callback(() => { appliedTextEdits = true; })
.Returns(Task.CompletedTask);
var handler = new TestOnTypeFormattingHandler(JoinableTaskContext, documentManager, requestInvoker.Object, projectionProvider.Object, documentMappingProvider.Object, editorService.Object);
var request = new DocumentOnTypeFormattingParams()
{
Character = "=",
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Options = new FormattingOptions()
{
OtherOptions = new Dictionary <string, object>()
},
Position = new Position(1, 4)
};
// Act
var edits = await handler.HandleRequestAsync(request, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(invokedServer);
Assert.True(mappedTextEdits);
Assert.True(appliedTextEdits);
Assert.Empty(edits);
}
public async Task HandleRequestAsync_CSharpProjection_InvokesCSharpLanguageServer_FailsRemappingResultRangeWithHostVersionChanged()
{
// Arrange
var called = false;
var expectedContents = new SumType <SumType <string, MarkedString>, SumType <string, MarkedString>[], MarkupContent>(
new MarkedString()
{
Language = "markdown",
Value = "Hover Details"
}
);
var lspResponse = new Hover()
{
Range = new Range()
{
Start = new Position(10, 0),
End = new Position(10, 1)
},
Contents = expectedContents
};
var hoverRequest = new TextDocumentPositionParams()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = Uri
},
Position = new Position(0, 1)
};
var documentManager = new TestDocumentManager();
var document = new Mock <LSPDocumentSnapshot>(MockBehavior.Strict);
document.SetupGet(d => d.Version).Returns(0);
documentManager.AddDocument(Uri, document.Object);
var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);
requestInvoker
.Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, Hover>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>()))
.Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, hoverParams, ct) =>
{
Assert.Equal(Methods.TextDocumentHoverName, method);
Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType);
called = true;
})
.Returns(Task.FromResult(lspResponse));
var projectionResult = new ProjectionResult()
{
LanguageKind = RazorLanguageKind.CSharp,
};
var projectionProvider = new Mock <LSPProjectionProvider>(MockBehavior.Strict);
projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult));
var remappingResult = new RazorMapToDocumentRangesResponse()
{
Ranges = new[] { new Range() },
HostDocumentVersion = 1
};
var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(MockBehavior.Strict);
documentMappingProvider.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, It.IsAny <Uri>(), It.IsAny <Range[]>(), It.IsAny <CancellationToken>())).
Returns(Task.FromResult(remappingResult));
var hoverHandler = new HoverHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, LoggerProvider);
// Act
var result = await hoverHandler.HandleRequestAsync(hoverRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(called);
Assert.Null(result);
}
