public async Task ShouldHandle_Request_WithNullParameters()
{
bool wasShutDown = false;
var shutdownHandler = new ShutdownHandler();
shutdownHandler.Shutdown.Subscribe(shutdownRequested =>
{
wasShutDown = true;
});
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
shutdownHandler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
JToken @params = JValue.CreateNull(); // If the "params" property present but null, this will be JTokenType.Null.
var id = Guid.NewGuid().ToString();
var request = new Request(id, GeneralNames.Shutdown, @params);
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
Assert.True(wasShutDown, "WasShutDown");
}
public async Task ShouldRouteToCorrect_Request()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);
var codeActionHandler = Substitute.For <ICodeActionHandler>();
codeActionHandler.GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
});
codeActionHandler
.Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>())
.Returns(new CommandContainer());
var collection = new HandlerCollection {
textDocumentSyncHandler, codeActionHandler
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, _handlerMatcherCollection);
var id = Guid.NewGuid().ToString();
var @params = new DidSaveTextDocumentParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs"))
};
var request = new Request(id, DocumentNames.CodeAction, JObject.Parse(JsonConvert.SerializeObject(@params)));
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
await codeActionHandler.Received(1).Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>());
}
public async Task RequestsCancellation()
{
var executeCommandHandler = Substitute.For <IExecuteCommandHandler>();
executeCommandHandler
.Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>())
.Returns(async(c) => {
await Task.Delay(1000, c.Arg <CancellationToken>());
throw new XunitException("Task was not cancelled in time!");
return(Unit.Value);
});
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
executeCommandHandler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var id = Guid.NewGuid().ToString();
var @params = new ExecuteCommandParams()
{
Command = "123"
};
var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
var response = ((IRequestRouter)mediator).RouteRequest(request);
mediator.CancelRequest(id);
var result = await response;
result.IsError.Should().BeTrue();
result.Error.Should().BeEquivalentTo(new RequestCancelled());
}
public async Task ShouldHandle_Request_WithMissingParameters()
{
bool wasShutdown = false;
var shutdownHandler = new ServerShutdownHandler();
shutdownHandler.Shutdown.Subscribe(shutdownRequested =>
{
wasShutdown = true;
});
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
shutdownHandler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
AutoSubstitute.Provide <IEnumerable <ILspHandlerDescriptor> >(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
JToken @params = null; // If the "params" property was missing entirely, this will be null.
var id = Guid.NewGuid().ToString();
var request = new Request(id, GeneralNames.Shutdown, @params);
await mediator.RouteRequest(mediator.GetDescriptor(request), request, CancellationToken.None);
Assert.True(shutdownHandler.ShutdownRequested, "WasShutDown");
}
public async Task ShouldRouteToCorrect_Notification()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
AutoSubstitute.Provide <IEnumerable <ILspHandlerDescriptor> >(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var @params = new DidSaveTextDocumentParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs"))
};
var request = new Notification(DocumentNames.DidSave, JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
await mediator.RouteNotification(mediator.GetDescriptor(request), request, CancellationToken.None);
await textDocumentSyncHandler.Received(1).Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>());
}
public async Task ShouldRouteToCorrect_Notification_WithManyHandlers()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
var textDocumentSyncHandler2 = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cake"));
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);
textDocumentSyncHandler2.Handle(Arg.Any <DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);
var collection = new HandlerCollection {
textDocumentSyncHandler, textDocumentSyncHandler2
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, _handlerMatcherCollection);
var @params = new DidSaveTextDocumentParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cake"))
};
var request = new Notification(DocumentNames.DidSave, JObject.Parse(JsonConvert.SerializeObject(@params)));
await mediator.RouteNotification(mediator.GetDescriptor(request), request);
await textDocumentSyncHandler.Received(1).Handle(Arg.Any <DidSaveTextDocumentParams>());
await textDocumentSyncHandler2.Received(0).Handle(Arg.Any <DidSaveTextDocumentParams>());
}
public void Should_Handle_Mixed_Capabilities()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
var codeActionHandler = Substitute.For <ICodeActionHandler>();
var definitionHandler = Substitute.For <IDefinitionHandler>();
var typeDefinitionHandler = Substitute.For <ITypeDefinitionHandler>();
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
textDocumentSyncHandler, codeActionHandler, definitionHandler, typeDefinitionHandler
};
var provider = new ClientCapabilityProvider(collection);
var capabilities = new ClientCapabilities()
{
TextDocument = new TextDocumentClientCapabilities()
{
CodeAction = new Supports <CodeActionCapability>(true, new CodeActionCapability()
{
DynamicRegistration = false,
}),
TypeDefinition = new Supports <TypeDefinitionCapability>(true, new TypeDefinitionCapability()
{
DynamicRegistration = true,
})
}
};
provider.GetStaticOptions(capabilities.TextDocument.CodeAction).Get <ICodeActionOptions, CodeActionOptions>(CodeActionOptions.Of).Should().NotBeNull();
provider.HasStaticHandler(capabilities.TextDocument.Definition).Should().BeTrue();
provider.HasStaticHandler(capabilities.TextDocument.TypeDefinition).Should().BeFalse();
}
public void GH162_TextDocumentSync_Should_Work_With_WillSave_Or_WillSaveWaitUntil()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
var willSaveTextDocumentHandler = Substitute.For <IWillSaveTextDocumentHandler>();
var willSaveWaitUntilTextDocumentHandler = Substitute.For <IWillSaveWaitUntilTextDocumentHandler>();
var didSaveTextDocumentHandler = Substitute.For <IDidSaveTextDocumentHandler>();
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler, willSaveTextDocumentHandler, willSaveWaitUntilTextDocumentHandler, didSaveTextDocumentHandler
};
var provider = new ClientCapabilityProvider(collection, true);
var capabilities = new ClientCapabilities()
{
TextDocument = new TextDocumentClientCapabilities()
{
Synchronization = new SynchronizationCapability()
{
DidSave = true,
DynamicRegistration = false,
WillSave = true,
WillSaveWaitUntil = true
},
}
};
provider.HasStaticHandler(capabilities.TextDocument.Synchronization).Should().BeTrue();
}
public void Should_Contain_AllDefinedMethods_OnLanguageServer_WithDifferentKeys(Type requestHandler, Type type2, string key, string key2, int count)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
var sub = (IJsonRpcHandler)Substitute.For(new Type[] { requestHandler, type2 }, new object[0]);
if (sub is IRegistration <TextDocumentRegistrationOptions> reg)
{
reg.GetRegistrationOptions()
.Returns(new TextDocumentRegistrationOptions()
{
DocumentSelector = new DocumentSelector()
{
}
});
}
var sub2 = (IJsonRpcHandler)Substitute.For(new Type[] { requestHandler, type2 }, new object[0]);
if (sub2 is IRegistration <TextDocumentRegistrationOptions> reg2)
{
reg2.GetRegistrationOptions()
.Returns(new TextDocumentRegistrationOptions()
{
DocumentSelector = new DocumentSelector()
});
}
handler.Add(sub);
handler.Add(sub2);
handler._handlers.Should().Contain(x => x.Method == key);
handler._handlers.Should().Contain(x => x.Method == key2);
handler._handlers.Count.Should().Be(count);
}
public async Task RequestsCancellation()
{
var executeCommandHandler = Substitute.For <IExecuteCommandHandler>();
executeCommandHandler
.Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>())
.Returns(async(c) => {
await Task.Delay(1000, c.Arg <CancellationToken>());
throw new XunitException("Task was not cancelled in time!");
});
var collection = new HandlerCollection {
executeCommandHandler
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, _handlerMatcherCollection);
var id = Guid.NewGuid().ToString();
var @params = new ExecuteCommandParams()
{
Command = "123"
};
var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params)));
var response = ((IRequestRouter)mediator).RouteRequest(request);
mediator.CancelRequest(id);
var result = await response;
result.IsError.Should().BeTrue();
result.Error.ShouldBeEquivalentTo(new RequestCancelled());
}
public async Task ShouldHandle_Request_WithMissingParameters()
{
bool wasShutDown = false;
var shutdownHandler = new ShutdownHandler();
shutdownHandler.Shutdown += shutdownRequested =>
{
wasShutDown = true;
};
var collection = new HandlerCollection {
shutdownHandler
};
var handlerMatcherCollection = new HandlerMatcherCollection {
new TextDocumentMatcher(_testLoggerFactory.CreateLogger <TextDocumentMatcher>(), collection.TextDocumentSyncHandlers)
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, handlerMatcherCollection, new Serializer());
JToken @params = null; // If the "params" property was missing entirely, this will be null.
var id = Guid.NewGuid().ToString();
var request = new Request(id, GeneralNames.Shutdown, @params);
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
Assert.True(wasShutDown, "WasShutDown");
}
public async Task ShouldRouteToCorrect_Request_WithManyHandlers()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
var textDocumentSyncHandler2 = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cake"), "csharp");
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
textDocumentSyncHandler2.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
var codeActionHandler = Substitute.For <ICodeActionHandler>();
codeActionHandler.GetRegistrationOptions().Returns(new CodeActionRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
});
codeActionHandler
.Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>())
.Returns(new CommandOrCodeActionContainer());
var registry = new TestLanguageServerRegistry();
var codeActionDelegate = Substitute.For <Func <CodeActionParams, CancellationToken, Task <CommandOrCodeActionContainer> > >();
codeActionDelegate.Invoke(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>())
.Returns(new CommandOrCodeActionContainer());
registry.OnCodeAction(
codeActionDelegate,
new CodeActionRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cake")
}
);
var textDocumentIdentifiers = new TextDocumentIdentifiers();
AutoSubstitute.Provide(textDocumentIdentifiers);
var handlerCollection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, textDocumentIdentifiers)
{
textDocumentSyncHandler, textDocumentSyncHandler2, codeActionHandler
};
handlerCollection.Add(registry.Handlers);
AutoSubstitute.Provide <IHandlerCollection>(handlerCollection);
AutoSubstitute.Provide <IEnumerable <ILspHandlerDescriptor> >(handlerCollection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var id = Guid.NewGuid().ToString();
var @params = new CodeActionParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cake"))
};
var request = new Request(id, DocumentNames.CodeAction, JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
await mediator.RouteRequest(mediator.GetDescriptor(request), request, CancellationToken.None);
await codeActionHandler.Received(0).Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>());
await codeActionDelegate.Received(1).Invoke(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>());
}
public void Should_Contain_AllDefinedTextDocumentSyncMethods(string key, int count)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
var sub = (IJsonRpcHandler)TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.something"), "csharp");
handler.Add(sub);
handler._handlers.Should().Contain(x => x.Method == key);
handler._handlers.Count.Should().Be(count);
}
public void Should_Contain_AllDefinedMethods(Type requestHandler, string key, int count)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
var sub = (IJsonRpcHandler)Substitute.For(new Type[] { requestHandler }, new object[0]);
handler.Add(sub);
handler._handlers.Should().Contain(x => x.Method == key);
handler._handlers.Count.Should().Be(count);
}
public void Should_DealWithClassesThatImplementMultipleHandlers_WithoutConflictingRegistrations(string method, IJsonRpcHandler sub)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
handler.Add(sub);
var descriptor = handler._handlers.First(x => x.Method == method);
descriptor.Key.Should().Be("default");
}
public void Should_DisallowUnsupportedCapabilities(IJsonRpcHandler handler, object instance)
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
var collection = new HandlerCollection {
textDocumentSyncHandler, handler
};
var provider = new ClientCapabilityProvider(collection);
HasHandler(provider, instance).Should().BeFalse();
}
public void Should_AllowSpecificHandlers_ToBeAdded(string method, Type handlerType)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
var sub = (IJsonRpcHandler)Substitute.For(new Type[] { handlerType }, new object[0]);
var sub2 = (IJsonRpcHandler)Substitute.For(new Type[] { handlerType }, new object[0]);
handler.Add(method, sub);
handler.Add(method, sub2);
handler._handlers.Should().Contain(x => x.Method == method);
handler._handlers.Should().Contain(x => x.Method == method);
handler._handlers.Count.Should().Be(1);
}
public ClientCapabilityProviderFixture()
{
handler = Substitute.For <IExecuteCommandHandler>();
handler.GetRegistrationOptions().Returns(new ExecuteCommandRegistrationOptions());
var handlerCollection = new HandlerCollection {
handler
};
var capabilityProvider = new ClientCapabilityProvider(handlerCollection);
Provider = capabilityProvider;
}
public void Should_AllowNullSupportedCapabilities(IJsonRpcHandler handler, object instance)
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
textDocumentSyncHandler, handler
};
var provider = new ClientCapabilityProvider(collection);
HasHandler(provider, instance).Should().BeTrue();
}
public void Should_DisallowDynamicSupportedCapabilities(IJsonRpcHandler handler, object instance)
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler, handler
};
var provider = new ClientCapabilityProvider(collection, true);
HasHandler(provider, instance).Should().BeFalse();
}
public void Should_Contain_AllDefinedLanguageServerMethods(string key, int count)
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
handler.Add(
Substitute.For <IInitializeHandler>(),
Substitute.For <IInitializedHandler>(),
Substitute.For <IExitHandler>(),
Substitute.For <IShutdownHandler>()
);
handler._handlers.Should().Contain(x => x.Method == key);
handler._handlers.Count.Should().Be(count);
}
public async Task RequestsCancellation()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
var codeActionHandler = Substitute.For <ICodeActionHandler>();
codeActionHandler.GetRegistrationOptions().Returns(new CodeActionRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
});
codeActionHandler
.Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>())
.Returns(async(c) =>
{
await Task.Delay(1000, c.Arg <CancellationToken>());
throw new XunitException("Task was not cancelled in time!");
return(new CommandOrCodeActionContainer());
});
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler, codeActionHandler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
AutoSubstitute.Provide <IEnumerable <ILspHandlerDescriptor> >(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var id = Guid.NewGuid().ToString();
var @params = new CodeActionParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs")),
Range = new Range(new Position(1, 1), new Position(2, 2)),
Context = new CodeActionContext()
{
Diagnostics = new Container <Diagnostic>()
}
};
var request = new Request(id, "textDocument/codeAction", JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
var response = ((IRequestRouter <ILspHandlerDescriptor>)mediator).RouteRequest(request, CancellationToken.None);
mediator.CancelRequest(id);
var result = await response;
result.IsError.Should().BeTrue();
result.Error.Should().BeEquivalentTo(new RequestCancelled());
}
public async Task ShouldRouteToCorrect_Request_WithManyHandlers_CodeLensHandler()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
var textDocumentSyncHandler2 = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cake"));
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
textDocumentSyncHandler2.Handle(Arg.Any <DidSaveTextDocumentParams>(), Arg.Any <CancellationToken>()).Returns(Unit.Value);
var codeActionHandler = Substitute.For <ICodeLensHandler>();
codeActionHandler.GetRegistrationOptions().Returns(new CodeLensRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
});
codeActionHandler
.Handle(Arg.Any <CodeLensParams>(), Arg.Any <CancellationToken>())
.Returns(new CodeLensContainer());
var codeActionHandler2 = Substitute.For <ICodeLensHandler>();
codeActionHandler2.GetRegistrationOptions().Returns(new CodeLensRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cake")
});
codeActionHandler2
.Handle(Arg.Any <CodeLensParams>(), Arg.Any <CancellationToken>())
.Returns(new CodeLensContainer());
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
textDocumentSyncHandler, textDocumentSyncHandler2, codeActionHandler, codeActionHandler2
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var id = Guid.NewGuid().ToString();
var @params = new CodeLensParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs"))
};
var request = new Request(id, DocumentNames.CodeLens, JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
await codeActionHandler2.Received(0).Handle(Arg.Any <CodeLensParams>(), Arg.Any <CancellationToken>());
await codeActionHandler.Received(1).Handle(Arg.Any <CodeLensParams>(), Arg.Any <CancellationToken>());
}
public ClientCapabilityProviderFixture()
{
var handler = Substitute.For <IExecuteCommandHandler>();
handler.GetRegistrationOptions().Returns(new ExecuteCommandRegistrationOptions());
var handlerCollection = new OmniSharp.Extensions.LanguageServer.Server.HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
handler
};
var capabilityProvider = new ClientCapabilityProvider(handlerCollection);
Provider = capabilityProvider;
}
public void Should_Contain_AllConcreteDefinedMethods()
{
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
handler.Add(
Substitute.For <IExitHandler>(),
Substitute.For <IInitializeHandler>(),
Substitute.For <IInitializedHandler>(),
Substitute.For <IShutdownHandler>()
);
handler._handlers.Should().Contain(x => x.Method == "exit");
handler._handlers.Should().Contain(x => x.Method == "shutdown");
handler._handlers.Count.Should().Be(4);
}
public async Task RequestsCancellation()
{
var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);
var codeActionHandler = Substitute.For <ICodeActionHandler>();
codeActionHandler.GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions()
{
DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
});
codeActionHandler
.Handle(Arg.Any <CodeActionParams>(), Arg.Any <CancellationToken>())
.Returns(async(c) => {
await Task.Delay(1000, c.Arg <CancellationToken>());
throw new XunitException("Task was not cancelled in time!");
return(new CommandContainer());
});
var collection = new HandlerCollection {
textDocumentSyncHandler, codeActionHandler
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, _handlerMatcherCollection, new Serializer());
var id = Guid.NewGuid().ToString();
var @params = new CodeActionParams()
{
TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs")),
Range = new Range(new Position(1, 1), new Position(2, 2)),
Context = new CodeActionContext()
{
Diagnostics = new Container <Diagnostic>()
}
};
var request = new Request(id, "textDocument/codeAction", JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings)));
var response = ((IRequestRouter)mediator).RouteRequest(request);
mediator.CancelRequest(id);
var result = await response;
result.IsError.Should().BeTrue();
result.Error.ShouldBeEquivalentTo(new RequestCancelled());
}
public void Should_DealWithClassesThatImplementMultipleHandlers_BySettingKeyAccordingly()
{
var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler), typeof(ICodeLensResolveHandler) }, new object[0]);
((ICodeLensHandler)codeLensHandler).GetRegistrationOptions()
.Returns(new CodeLensRegistrationOptions()
{
DocumentSelector = new DocumentSelector(DocumentFilter.ForLanguage("foo"))
});
var handler = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers());
handler.Add(codeLensHandler as IJsonRpcHandler);
var descriptor = handler._handlers.Select(x => x.Key);
descriptor.Should().BeEquivalentTo(new [] { "[foo]", "[foo]" });
}
public async Task ShouldRouteTo_CorrectRequestWhenGivenNullParams()
{
var handler = Substitute.For <IShutdownHandler>();
handler
.Handle(Arg.Any <EmptyRequest>(), Arg.Any <CancellationToken>())
.Returns(Unit.Value);
var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue)
{
handler
};
AutoSubstitute.Provide <IHandlerCollection>(collection);
var mediator = AutoSubstitute.Resolve <LspRequestRouter>();
var id = Guid.NewGuid().ToString();
var request = new Request(id, GeneralNames.Shutdown, new JObject());
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
await handler.Received(1).Handle(Arg.Any <EmptyRequest>(), Arg.Any <CancellationToken>());
}
public async Task ShouldRouteTo_CorrectRequestWhenGivenNullParams()
{
var handler = Substitute.For <IShutdownHandler>();
handler
.Handle(Arg.Any <object>(), Arg.Any <CancellationToken>())
.Returns(Task.CompletedTask);
var collection = new HandlerCollection {
handler
};
var handlerMatcherCollection = new HandlerMatcherCollection {
new TextDocumentMatcher(_testLoggerFactory.CreateLogger <TextDocumentMatcher>(), collection.TextDocumentSyncHandlers)
};
var mediator = new LspRequestRouter(collection, _testLoggerFactory, handlerMatcherCollection, new Serializer());
var id = Guid.NewGuid().ToString();
var request = new Request(id, GeneralNames.Shutdown, new JObject());
await mediator.RouteRequest(mediator.GetDescriptor(request), request);
await handler.Received(1).Handle(Arg.Any <object>(), Arg.Any <CancellationToken>());
}
