Exemple #1
0
        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);

            var @params = new DidSaveTextDocumentParams()
            {
                TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cake"))
            };

            var request = new Notification("textDocument/didSave", JObject.Parse(JsonConvert.SerializeObject(@params)));

            await mediator.RouteNotification(mediator.GetDescriptor(request), request);

            await textDocumentSyncHandler.Received(0).Handle(Arg.Any <DidSaveTextDocumentParams>());

            await textDocumentSyncHandler2.Received(1).Handle(Arg.Any <DidSaveTextDocumentParams>());
        }
Exemple #2
0
        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);

            var id      = Guid.NewGuid().ToString();
            var @params = new DidSaveTextDocumentParams()
            {
                TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs"))
            };

            var request = new Request(id, "textDocument/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 ShouldRouteToCorrect_Notification()
        {
            var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));

            textDocumentSyncHandler.Handle(Arg.Any <DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);

            var collection = new HandlerCollection {
                textDocumentSyncHandler
            };
            var handlerMatcherCollection = new HandlerMatcherCollection {
                new TextDocumentMatcher(_testLoggerFactory.CreateLogger <TextDocumentMatcher>(), collection.TextDocumentSyncHandlers)
            };
            var mediator = new LspRequestRouter(collection, _testLoggerFactory, handlerMatcherCollection, new Serializer());

            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);

            await textDocumentSyncHandler.Received(1).Handle(Arg.Any <DidSaveTextDocumentParams>());
        }
        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_CodeLensHandler()
        {
            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 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 {
                textDocumentSyncHandler, textDocumentSyncHandler2, codeActionHandler, codeActionHandler2
            };
            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 @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>());
        }
Exemple #7
0
        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);

            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)));

            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 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>());
        }
 internal CancelRequestHandler(LspRequestRouter requestRouter)
 {
     _requestRouter = requestRouter;
 }