public async Task CanSendReferencesCodeLensRequest()
{
string filePath = NewTestFile(@"
function CanSendReferencesCodeLensRequest {
}
CanSendReferencesCodeLensRequest
");
CodeLensContainer codeLenses = await LanguageClient.SendRequest <CodeLensContainer>(
"textDocument/codeLens",
new CodeLensParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = new Uri(filePath)
}
});
CodeLens codeLens = Assert.Single(codeLenses);
Range range = codeLens.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(3, range.End.Line);
Assert.Equal(1, range.End.Character);
CodeLens codeLensResolveResult = await LanguageClient.SendRequest <CodeLens>(
"codeLens/resolve",
codeLens);
Assert.Equal("1 reference", codeLensResolveResult.Command.Title);
}
public async Task Should_Resolve_Partial()
{
var(client, server) = await Initialize(
options => { }, options => {
options.OnCodeLens(
(codeLensParams, observer) => {
var a = new CodeLensContainer(
new CodeLens {
Command = new Command {
Name = "execute-a",
Arguments = JArray.FromObject(new object[] { 1, "2", false })
},
}
);
observer.OnNext(a);
observer.OnCompleted();
},
codeLens => {
codeLens.Command.Name = "resolved";
return(Task.FromResult(codeLens));
},
new CodeLensRegistrationOptions()
);
}
);
var item = await client.RequestCodeLens(new CodeLensParams()).SelectMany(z => z).Take(1).ToTask(CancellationToken);
item = await client.ResolveCodeLens(item);
item.Command.Name.Should().Be("resolved");
}
public async Task CanSendPesterLegacyCodeLensRequest()
{
// Make sure LegacyCodeLens is enabled because we'll need it in this test.
LanguageClient.Workspace.DidChangeConfiguration(JObject.Parse(@"
{
""powershell"": {
""pester"": {
""useLegacyCodeLens"": true
}
}
}
"));
string filePath = NewTestFile(@"
Describe 'DescribeName' {
Context 'ContextName' {
It 'ItName' {
1 | Should - Be 1
}
}
}
", isPester: true);
CodeLensContainer codeLenses = await LanguageClient.SendRequest <CodeLensContainer>(
"textDocument/codeLens",
new CodeLensParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = new Uri(filePath)
}
});
Assert.Collection(codeLenses,
codeLens1 =>
{
Range range = codeLens1.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Run tests", codeLens1.Command.Title);
},
codeLens2 =>
{
Range range = codeLens2.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Debug tests", codeLens2.Command.Title);
});
}
protected void RunCodeLens(string testfile)
{
CodeLensParams codeLensParams = new CodeLensParams
{
TextDocument = new TextDocumentIdentifier(new Uri(testfile))
};
Client.TextDocument.DidOpen(testfile, "dfy");
var response = Client.SendRequest <CodeLensContainer>("textDocument/codeLens", codeLensParams, CancellationToken.None);
codelensResults = response.Result;
}
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_CodeLensContainer_With_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 HandlerDescriptor(
DocumentNames.CodeLens,
"Key",
resolveHandler as IJsonRpcHandler,
resolveHandler.GetType(),
typeof(CodeLensParams),
null,
null,
false,
null,
() => { });
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(new[] { 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 as CodeLensContainer).Should().Contain(item);
var responseItem = (response as CodeLensContainer).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 CanSendPesterCodeLensRequest()
{
string filePath = NewTestFile(@"
Describe 'DescribeName' {
Context 'ContextName' {
It 'ItName' {
1 | Should - Be 1
}
}
}
", isPester: true);
CodeLensContainer codeLenses = await LanguageClient.SendRequest <CodeLensContainer>(
"textDocument/codeLens",
new CodeLensParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = new Uri(filePath)
}
});
Assert.Collection(codeLenses,
codeLens1 =>
{
Range range = codeLens1.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Run tests", codeLens1.Command.Title);
},
codeLens2 =>
{
Range range = codeLens2.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Debug tests", codeLens2.Command.Title);
});
}
public async Task Should_Resolve_With_Partial_Data()
{
var(client, server) = await Initialize(
options => { }, options => {
options.OnCodeLens <Data>(
(codeLensParams, observer) => {
var a = new CodeLensContainer <Data>(
new CodeLens <Data> {
Command = new Command {
Name = "execute-a",
Arguments = JArray.FromObject(new object[] { 1, "2", false })
},
Data = new Data {
Child = new Nested {
Date = DateTimeOffset.MinValue
},
Id = Guid.NewGuid(),
Name = "name"
}
}
);
observer.OnNext(a);
observer.OnCompleted();
},
codeLens => {
codeLens.Data.Id.Should().NotBeEmpty();
codeLens.Data.Child.Should().NotBeNull();
codeLens.Data.Name.Should().Be("name");
codeLens.Command.Name = "resolved";
return(Task.FromResult(codeLens));
},
new CodeLensRegistrationOptions()
);
}
);
var item = await client.RequestCodeLens(new CodeLensParams()).SelectMany(z => z).Take(1).ToTask(CancellationToken);
item = await client.ResolveCodeLens(item);
item.Command.Name.Should().Be("resolved");
}
public async Task NoMessageIfPesterCodeLensDisabled()
{
// Make sure Pester legacy CodeLens is disabled because we'll need it in this test.
PsesLanguageClient.Workspace.DidChangeConfiguration(
new DidChangeConfigurationParams
{
Settings = JObject.Parse(@"
{
""powershell"": {
""pester"": {
""codeLens"": false
}
}
}
")
});
string filePath = NewTestFile(@"
Describe 'DescribeName' {
Context 'ContextName' {
It 'ItName' {
1 | Should - Be 1
}
}
}
", isPester: true);
CodeLensContainer codeLenses = await PsesLanguageClient
.SendRequest <CodeLensParams>(
"textDocument/codeLens",
new CodeLensParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = new Uri(filePath)
}
})
.Returning <CodeLensContainer>(CancellationToken.None).ConfigureAwait(false);
Assert.Empty(codeLenses);
}
public void Should_Update_CodeLensContainer_With_HandlerType()
{
// Given
var handlerMatcher = new ResolveCommandMatcher(_logger);
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 HandlerDescriptor(
DocumentNames.CodeLens,
"Key",
resolveHandler as IJsonRpcHandler,
resolveHandler.GetType(),
typeof(CodeLensParams),
null,
null,
() => { });
var item = new CodeLens()
{
Data = JObject.FromObject(new { hello = "world" })
};
var list = new CodeLensContainer(new[] { item });
(list is IEnumerable <ICanBeResolved>).Should().BeTrue();
// When
var response = handlerMatcher.Process(descriptor, new CodeLensParams(), list);
// Then
response.Should().Be(list);
(response as CodeLensContainer).Should().Contain(item);
var responseItem = (response as CodeLensContainer).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 CanSendPesterCodeLensRequestAsync()
{
// Make sure Pester legacy CodeLens is disabled because we'll need it in this test.
PsesLanguageClient.Workspace.DidChangeConfiguration(
new DidChangeConfigurationParams
{
Settings = JObject.Parse(@"
{
""powershell"": {
""pester"": {
""useLegacyCodeLens"": false
}
}
}
")
});
string filePath = NewTestFile(@"
Describe 'DescribeName' {
Context 'ContextName' {
It 'ItName' {
1 | Should - Be 1
}
}
}
", isPester: true);
CodeLensContainer codeLenses = await PsesLanguageClient
.SendRequest <CodeLensParams>(
"textDocument/codeLens",
new CodeLensParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = new Uri(filePath)
}
})
.Returning <CodeLensContainer>(CancellationToken.None).ConfigureAwait(false);
Assert.Collection(codeLenses,
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Run tests", codeLens.Command.Title);
},
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(1, range.Start.Line);
Assert.Equal(0, range.Start.Character);
Assert.Equal(7, range.End.Line);
Assert.Equal(1, range.End.Character);
Assert.Equal("Debug tests", codeLens.Command.Title);
},
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(2, range.Start.Line);
Assert.Equal(4, range.Start.Character);
Assert.Equal(6, range.End.Line);
Assert.Equal(5, range.End.Character);
Assert.Equal("Run tests", codeLens.Command.Title);
},
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(2, range.Start.Line);
Assert.Equal(4, range.Start.Character);
Assert.Equal(6, range.End.Line);
Assert.Equal(5, range.End.Character);
Assert.Equal("Debug tests", codeLens.Command.Title);
},
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(3, range.Start.Line);
Assert.Equal(8, range.Start.Character);
Assert.Equal(5, range.End.Line);
Assert.Equal(9, range.End.Character);
Assert.Equal("Run test", codeLens.Command.Title);
},
codeLens =>
{
Range range = codeLens.Range;
Assert.Equal(3, range.Start.Line);
Assert.Equal(8, range.Start.Character);
Assert.Equal(5, range.End.Line);
Assert.Equal(9, range.End.Character);
Assert.Equal("Debug test", codeLens.Command.Title);
});
}
public void CleanResults()
{
codelensResults = null;
}
