public async Task HandleRequestAsync_CSharpProjection_ReturnsNull()
        {
            // Arrange
            var documentManager = new TestDocumentManager();

            documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(d => d.Version == 0, MockBehavior.Strict));
            var requestInvoker          = Mock.Of <LSPRequestInvoker>(MockBehavior.Strict);
            var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>(MockBehavior.Strict);

            var projectionResult = new ProjectionResult()
            {
                LanguageKind = RazorLanguageKind.CSharp,
            };
            var projectionProvider = GetProjectionProvider(projectionResult);

            var onTypeRenameHandler = new OnTypeRenameHandler(documentManager, requestInvoker, projectionProvider, documentMappingProvider, LoggerProvider);
            var onTypeRenameRequest = new DocumentOnTypeRenameParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = Uri
                },
                Position = new Position(10, 5)
            };

            // Act
            var result = await onTypeRenameHandler.HandleRequestAsync(onTypeRenameRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);

            // Assert
            Assert.Null(result);
        }
        public async Task HandleRequestAsync_ProjectionNotFound_ReturnsNull()
        {
            // Arrange
            var documentManager = new TestDocumentManager();

            documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(MockBehavior.Strict));
            var requestInvoker     = Mock.Of <LSPRequestInvoker>(MockBehavior.Strict);
            var projectionProvider = new Mock <LSPProjectionProvider>(MockBehavior.Strict).Object;

            Mock.Get(projectionProvider).Setup(projectionProvider => projectionProvider.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), CancellationToken.None))
            .Returns(Task.FromResult <ProjectionResult>(null));
            var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>(MockBehavior.Strict);
            var onTypeRenameHandler     = new OnTypeRenameHandler(documentManager, requestInvoker, projectionProvider, documentMappingProvider, LoggerProvider);
            var onTypeRenameRequest     = new DocumentOnTypeRenameParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = Uri
                },
                Position = new Position(0, 1)
            };

            // Act
            var result = await onTypeRenameHandler.HandleRequestAsync(onTypeRenameRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);

            // Assert
            Assert.Null(result);
        }
Esempio n. 3
0
        public async Task HandleRequestAsync_ProjectionNotFound_ReturnsNull()
        {
            // Arrange
            var documentManager = new TestDocumentManager();

            documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>());
            var requestInvoker          = Mock.Of <LSPRequestInvoker>();
            var projectionProvider      = Mock.Of <LSPProjectionProvider>();
            var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>();
            var onTypeRenameHandler     = new OnTypeRenameHandler(documentManager, requestInvoker, projectionProvider, documentMappingProvider);
            var onTypeRenameRequest     = new DocumentOnTypeRenameParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = Uri
                },
                Position = new Position(0, 1)
            };

            // Act
            var result = await onTypeRenameHandler.HandleRequestAsync(onTypeRenameRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);

            // Assert
            Assert.Null(result);
        }
        public async Task HandleRequestAsync_RemapFailure_ReturnsNull()
        {
            // Arrange
            var invokerCalled    = false;
            var expectedResponse = GetMatchingHTMLBracketRange(5);
            var documentManager  = new TestDocumentManager();

            documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(d => d.Version == 0, MockBehavior.Strict));

            var htmlResponse   = GetMatchingHTMLBracketRange(10);
            var requestInvoker = GetRequestInvoker <DocumentOnTypeRenameParams, DocumentOnTypeRenameResponseItem>(
                htmlResponse,
                (method, serverContentType, highlightParams, ct) =>
            {
                Assert.Equal(MSLSPMethods.OnTypeRenameName, method);
                Assert.Equal(RazorLSPConstants.HtmlLSPContentTypeName, serverContentType);
                invokerCalled = true;
            });

            var projectionResult = new ProjectionResult()
            {
                LanguageKind = RazorLanguageKind.Html,
            };
            var projectionProvider = GetProjectionProvider(projectionResult);

            var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(MockBehavior.Strict).Object;

            Mock.Get(documentMappingProvider).Setup(p => p.MapToDocumentRangesAsync(RazorLanguageKind.Html, Uri, It.IsAny <Range[]>(), CancellationToken.None))
            .Returns(Task.FromResult <RazorMapToDocumentRangesResponse>(null));

            var onTypeRenameHandler = new OnTypeRenameHandler(documentManager, requestInvoker, projectionProvider, documentMappingProvider, LoggerProvider);
            var onTypeRenameRequest = new DocumentOnTypeRenameParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = Uri
                },
                Position = new Position(10, 5)
            };

            // Act
            var result = await onTypeRenameHandler.HandleRequestAsync(onTypeRenameRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);

            // Assert
            Assert.True(invokerCalled);
            Assert.Null(result);
        }
        public async Task HandleRequestAsync_HtmlProjection_RemapsHighlightRange()
        {
            // Arrange
            var invokerCalled    = false;
            var expectedResponse = GetMatchingHTMLBracketRange(5);
            var documentManager  = new TestDocumentManager();

            documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>(d => d.Version == 0, MockBehavior.Strict));

            var htmlResponse   = GetMatchingHTMLBracketRange(10);
            var requestInvoker = GetRequestInvoker <DocumentOnTypeRenameParams, DocumentOnTypeRenameResponseItem>(
                htmlResponse,
                (method, serverContentType, highlightParams, ct) =>
            {
                Assert.Equal(MSLSPMethods.OnTypeRenameName, method);
                Assert.Equal(RazorLSPConstants.HtmlLSPContentTypeName, serverContentType);
                invokerCalled = true;
            });

            var projectionResult = new ProjectionResult()
            {
                LanguageKind = RazorLanguageKind.Html,
            };
            var projectionProvider = GetProjectionProvider(projectionResult);

            var documentMappingProvider = GetDocumentMappingProvider(expectedResponse.Ranges, 0, RazorLanguageKind.Html);

            var onTypeRenameHandler = new OnTypeRenameHandler(documentManager, requestInvoker, projectionProvider, documentMappingProvider, LoggerProvider);
            var onTypeRenameRequest = new DocumentOnTypeRenameParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = Uri
                },
                Position = new Position(10, 5)
            };

            // Act
            var result = await onTypeRenameHandler.HandleRequestAsync(onTypeRenameRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false);

            // Assert
            Assert.True(invokerCalled);
            Assert.NotNull(result);
            Assert.Collection(result.Ranges,
                              r => Assert.Equal(expectedResponse.Ranges[0], r),
                              r => Assert.Equal(expectedResponse.Ranges[1], r));
        }