public void Should_Not_Throw_Given_Another_Descriptor()
        {
            // Given
            var resolveHandler    = Substitute.For <ICodeLensHandler>();
            var handlerDescriptor = new LspHandlerDescriptor(
                0,
                TextDocumentNames.CodeLens,
                "Key",
                resolveHandler,
                resolveHandler.GetType(),
                typeof(CodeLensParams),
                null,
                null,
                null,
                null,
                null,
                () => { },
                Substitute.For <ILspHandlerTypeDescriptor>()
                );
            var handlerMatcher = new ResolveCommandPipeline <CodeLensParams, CodeLensContainer>(
                new RequestContext {
                Descriptor = handlerDescriptor
            },
                LoggerFactory.CreateLogger <ResolveCommandPipeline <CodeLensParams, CodeLensContainer> >()
                );

            // When
            Func <Task> a = async() => await handlerMatcher.Handle(new CodeLensParams(), CancellationToken.None, () => Task.FromResult(new CodeLensContainer()));

            a.Should().NotThrow();
        }
        public async Task Should_Update_CodeLensContainer_With_HandlerType()
        {
            // Given
            var resolveHandler = Substitute.For(
                new[] {
                typeof(ICodeLensHandler),
                typeof(ICodeLensResolveHandler),
                typeof(ICanBeIdentifiedHandler)
            }, new object[0]
                );

            (resolveHandler as ICanBeIdentifiedHandler)?.Id.Returns(TrueId);
            var descriptor = new LspHandlerDescriptor(
                TextDocumentNames.CodeLens,
                "Key",
                resolveHandler as IJsonRpcHandler,
                resolveHandler.GetType(),
                typeof(CodeLensParams),
                null,
                null,
                () => false,
                null,
                null,
                () => { },
                Substitute.For <ILspHandlerTypeDescriptor>()
                );
            var handlerMatcher = new ResolveCommandPipeline <CodeLensParams, CodeLensContainer>(
                new RequestContext {
                Descriptor = descriptor
            },
                Substitute.For <ILogger <ResolveCommandPipeline <CodeLensParams, CodeLensContainer> > >()
                );

            var item = new CodeLens {
                Data = JObject.FromObject(new { hello = "world" })
            };
            var list = new CodeLensContainer(item);

            (list is IEnumerable <ICanBeResolved>).Should().BeTrue();

            // When
            var response = await handlerMatcher.Handle(new CodeLensParams(), CancellationToken.None, () => Task.FromResult(list));

            // Then
            response.Should().BeEquivalentTo(list);
            response.Should().Contain(item);
            var responseItem = response.First();

            responseItem.Data[Constants.PrivateHandlerId].Value <Guid>().Should().Be(TrueId);
            responseItem.Data["hello"].Value <string>().Should().Be("world");
        }
        public async Task Should_Update_CompletionItems_With_HandlerType()
        {
            // Given
            var resolveHandler = Substitute.For(new Type[] {
                typeof(ICompletionHandler),
                typeof(ICompletionResolveHandler)
            }, new object[0]);

            (resolveHandler as ICompletionResolveHandler).CanResolve(Arg.Any <CompletionItem>()).Returns(true);
            var descriptor = new LspHandlerDescriptor(
                TextDocumentNames.Completion,
                "Key",
                resolveHandler as IJsonRpcHandler,
                resolveHandler.GetType(),
                typeof(CompletionParams),
                null,
                null,
                () => false,
                null,
                null,
                () => { },
                Substitute.For <ILspHandlerTypeDescriptor>());
            var handlerMatcher = new ResolveCommandPipeline <CompletionParams, CompletionList>(
                new RequestContext()
            {
                Descriptor = descriptor
            },
                Substitute.For <ILogger <ResolveCommandPipeline <CompletionParams, CompletionList> > >());

            var item = new CompletionItem()
            {
                Data = JObject.FromObject(new { hello = "world" })
            };
            var list = new CompletionList(new[] { item });

            (list is IEnumerable <ICanBeResolved>).Should().BeTrue();

            // When
            var response = await handlerMatcher.Handle(new CompletionParams(), CancellationToken.None, () => Task.FromResult(list));

            // Then
            response.Should().BeEquivalentTo(list);
            (response as CompletionList).Items.Should().Contain(item);
            var responseItem = (response as CompletionList).Items.First();

            responseItem.Data[ResolveCommandMatcher.PrivateHandlerTypeName].Value <string>().Should().NotBeNullOrEmpty();
            responseItem.Data[ResolveCommandMatcher.PrivateHandlerKey].Value <string>().Should().NotBeNullOrEmpty();
            responseItem.Data["data"]["hello"].Value <string>().Should().Be("world");
        }
        public async Task Should_Update_CodeLens_Removing_HandlerType()
        {
            // Given
            var resolveHandler = Substitute.For(new Type[] {
                typeof(ICodeLensHandler),
                typeof(ICodeLensResolveHandler)
            }, new object[0]);

            (resolveHandler as ICodeLensResolveHandler).CanResolve(Arg.Any <CodeLens>()).Returns(true);
            var descriptor = new LspHandlerDescriptor(
                TextDocumentNames.CodeLensResolve,
                "Key",
                resolveHandler as IJsonRpcHandler,
                resolveHandler.GetType(),
                typeof(CodeLens),
                null,
                null,
                () => false,
                null,
                null,
                () => { },
                Substitute.For <ILspHandlerTypeDescriptor>());
            var handlerMatcher = new ResolveCommandPipeline <CodeLens, CodeLens>(
                new RequestContext()
            {
                Descriptor = descriptor
            },
                Substitute.For <ILogger <ResolveCommandPipeline <CodeLens, CodeLens> > >());

            var item = new CodeLens()
            {
                Data = JObject.FromObject(new { data = new { hello = "world" } })
            };

            item.Data[ResolveCommandMatcher.PrivateHandlerTypeName] = resolveHandler.GetType().FullName;

            // When
            var response = await handlerMatcher.Handle(item, CancellationToken.None, () => Task.FromResult(item));

            // Then
            response.Should().BeEquivalentTo(item);
            item.Data?[ResolveCommandMatcher.PrivateHandlerTypeName].Should().BeNull();
            item.Data["hello"].Value <string>().Should().Be("world");
        }