public async Task InitializeAsync()
{
LoggerFactory factory = new();
_psesProcess = new PsesStdioProcess(factory, IsDebugAdapterTests);
await _psesProcess.Start().ConfigureAwait(false);
Diagnostics = new List <Diagnostic>();
TelemetryEvents = new List <PsesTelemetryEvent>();
DirectoryInfo testdir =
Directory.CreateDirectory(Path.Combine(s_binDir, Path.GetRandomFileName()));
PsesLanguageClient = LanguageClient.PreInit(options =>
{
options
.WithInput(_psesProcess.OutputStream)
.WithOutput(_psesProcess.InputStream)
.WithRootUri(DocumentUri.FromFileSystemPath(testdir.FullName))
.OnPublishDiagnostics(diagnosticParams => Diagnostics.AddRange(diagnosticParams.Diagnostics.Where(d => d != null)))
.OnLogMessage(logMessageParams => Output?.WriteLine($"{logMessageParams.Type}: {logMessageParams.Message}"))
.OnTelemetryEvent(telemetryEventParams => TelemetryEvents.Add(
new PsesTelemetryEvent
{
EventName = (string)telemetryEventParams.ExtensionData["eventName"],
Data = telemetryEventParams.ExtensionData["data"] as JObject
}));
// Enable all capabilities this this is for testing.
// This will be a built in feature of the Omnisharp client at some point.
IEnumerable <Type> capabilityTypes = typeof(ICapability).Assembly.GetExportedTypes()
.Where(z => typeof(ICapability).IsAssignableFrom(z) && z.IsClass && !z.IsAbstract);
foreach (Type capabilityType in capabilityTypes)
{
options.WithCapability(Activator.CreateInstance(capabilityType, Array.Empty <object>()) as ICapability);
}
});
await PsesLanguageClient.Initialize(CancellationToken.None).ConfigureAwait(false);
// Make sure Script Analysis is enabled because we'll need it in the tests.
// This also makes sure the configuration is set to default values.
PsesLanguageClient.Workspace.DidChangeConfiguration(
new DidChangeConfigurationParams
{
Settings = JToken.FromObject(new LanguageServerSettingsWrapper
{
Files = new EditorFileSettings(),
Search = new EditorSearchSettings(),
Powershell = new LanguageServerSettings()
})
});
}
internal virtual void publishDiagnostics(LanguageClient client)
{
//Todo: あとで実装
/*var diagnostics = client.PullTextDocumentPublishDiagnostics(sourceUri.AbsoluteUri);
* if (diagnostics == null)
* {
* Console.WriteLine("diagnostics==null");
* return;
* }
* Console.WriteLine(string.Format("diagnostics.diagnostics.Length={0}", diagnostics.diagnostics.Length));
*/
}
/// <summary>
/// Dispose of resources being used by the extension package.
/// </summary>
/// <param name="disposing">
/// Explicit disposal?
/// </param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (LanguageClient != null)
{
LanguageClient.Dispose();
LanguageClient = null;
}
}
base.Dispose(disposing);
}
async Task ExecuteCheckTextAnalyticsApiCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
LanguageClient languageClient = new LanguageClient(ApiKeys.TextAnalyticsApiKey);
languageClient.Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/languages";
LanguageRequest lr = new LanguageRequest();
lr.Documents.Add(new Document()
{
Id = Guid.NewGuid().ToString(),
Text = TextAnalyticsText
});
var lrResult = await languageClient.GetLanguagesAsync(lr);
var language = lrResult.Documents.First().DetectedLanguages.First().Name;
var languageCode = lrResult.Documents.First().DetectedLanguages.First().Iso639Name;
SentimentClient textClient = new SentimentClient(ApiKeys.TextAnalyticsApiKey);
textClient.Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment";
SentimentRequest sr = new SentimentRequest();
sr.Documents.Add(new SentimentDocument()
{
Id = Guid.NewGuid().ToString(),
Text = TextAnalyticsText,
Language = languageCode
});
var result = await textClient.GetSentimentAsync(sr);
TextAnalyticsResult = $"Language: {language}, Sentiment Score: {result.Documents.First().Score}";
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public static DetectedLanguage AnalyzeLanguage(string id, string text)
{
DetectedLanguage language = new DetectedLanguage();
var document = new Document()
{
Id = id,
Text = text
};
var client = new LanguageClient(Constants.API_KEY)
{
Url = Constants.API_URI_LANG
};
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = client.GetLanguages(request);
language = response.Documents.First().DetectedLanguages.First();
}
catch (Exception ex)
{
var message = "";
var innerMessage = "";
if (!String.IsNullOrEmpty(ex.Message))
{
message = ex.Message;
}
try
{
if ((ex.InnerException != null) && (!String.IsNullOrEmpty(ex.InnerException.Message)))
{
innerMessage = ex.InnerException.Message;
}
}
catch (Exception innerEx)
{
if ((innerEx.InnerException != null) && (!String.IsNullOrEmpty(innerEx.InnerException.Message)))
{
innerMessage = innerEx.InnerException.Message;
}
}
//Console.WriteLine(String.Format("Error in AnalyzeSentiment: {0}:{1}", message, innerMessage));
}
return(language);
}
internal virtual void Shutdown(LanguageClient client)
{
var requestId = client.Send.Shutdown();
var error = client.QueryResponse(requestId).item as ResponseError;
if (error != null)
{
Console.WriteLine("[Failed]Shutdown.");
return;
}
client.Send.Exit();
client.Send.LoggingResponseLeak();
Console.WriteLine("[Success]Shutdown.");
}
public static DetectedLanguage AnalyzeLanguage(string id, string text)
{
DetectedLanguage language = new DetectedLanguage();
var document = new Document()
{
Id = id,
Text = text
};
var client = new LanguageClient(Constants.ApiKey)
{
Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/languages"
};
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = client.GetLanguages(request);
language = response.Documents.First().DetectedLanguages.First();
}
catch (Exception ex)
{
var message = "";
var innerMessage = "";
if (!String.IsNullOrEmpty(ex.Message))
{
message = ex.Message;
}
try
{
if ((ex.InnerException != null) && (!String.IsNullOrEmpty(ex.InnerException.Message)))
{
innerMessage = ex.InnerException.Message;
}
}
catch (Exception innerEx)
{
if ((innerEx.InnerException != null) && (!String.IsNullOrEmpty(innerEx.InnerException.Message)))
{
innerMessage = innerEx.InnerException.Message;
}
}
Console.WriteLine(String.Format("Error in AnalyzeSentiment: {0}:{1}", message, innerMessage));
}
return(language);
}
protected internal virtual (ILanguageClient client, ILanguageServer server) Create(
Action <LanguageClientOptions> clientOptionsAction,
Action <LanguageServerOptions> serverOptionsAction
)
{
var clientPipe = new Pipe(TestOptions.DefaultPipeOptions);
var serverPipe = new Pipe(TestOptions.DefaultPipeOptions);
_client = LanguageClient.PreInit(
options => {
options
.WithLoggerFactory(TestOptions.ClientLoggerFactory)
.WithAssemblies(TestOptions.Assemblies)
.ConfigureLogging(x => x.SetMinimumLevel(LogLevel.Trace))
.WithAssemblies(typeof(LanguageProtocolTestBase).Assembly, GetType().Assembly)
.WithInputScheduler(options.InputScheduler)
.WithOutputScheduler(options.OutputScheduler)
.WithDefaultScheduler(options.DefaultScheduler)
.Services
.AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
.AddSingleton(ClientEvents as IRequestSettler);
ConfigureClientInputOutput(serverPipe.Reader, clientPipe.Writer, options);
clientOptionsAction(options);
}
);
_server = RealLanguageServer.PreInit(
options => {
options
.WithLoggerFactory(TestOptions.ServerLoggerFactory)
.WithAssemblies(TestOptions.Assemblies)
.ConfigureLogging(x => x.SetMinimumLevel(LogLevel.Trace))
.WithAssemblies(typeof(LanguageProtocolTestBase).Assembly, GetType().Assembly)
.WithInputScheduler(options.InputScheduler)
.WithOutputScheduler(options.OutputScheduler)
.WithDefaultScheduler(options.DefaultScheduler)
.Services
.AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
.AddSingleton(ServerEvents as IRequestSettler);
ConfigureServerInputOutput(clientPipe.Reader, serverPipe.Writer, options);
serverOptionsAction(options);
}
);
Disposable.Add(_client);
Disposable.Add(_server);
return(_client, _server);
}
public override async Task DisposeAsync()
{
try
{
await LanguageClient.Shutdown();
await _psesProcess.Stop();
LanguageClient?.Dispose();
}
catch (ObjectDisposedException)
{
// Language client has a disposal bug in it
}
}
public async Task DocumentSymbols_DocumentSymbol_Success()
{
await Connect();
const int line = 5;
const int character = 6;
var expectedDocumentPath = AbsoluteDocumentPath;
var expectedDocumentUri = DocumentUri.FromFileSystemPath(expectedDocumentPath);
var detail = "some detail";
var documentSymbol = new DocumentSymbol {
Detail = detail,
Kind = SymbolKind.Class,
Range = new Range(new Position(line, character), new Position(line, character))
};
var expectedSymbols = new SymbolInformationOrDocumentSymbolContainer(
new SymbolInformationOrDocumentSymbol(documentSymbol));
ServerDispatcher.HandleRequest <DocumentSymbolParams, SymbolInformationOrDocumentSymbolContainer>(DocumentNames.DocumentSymbol, (request, cancellationToken) => {
Assert.NotNull(request.TextDocument);
Assert.Equal(expectedDocumentUri, request.TextDocument.Uri);
return(Task.FromResult(expectedSymbols));
});
var documentSymbolParams = new DocumentSymbolParams {
TextDocument = new TextDocumentIdentifier(expectedDocumentUri)
};
var symbols = await LanguageClient.SendRequest <SymbolInformationOrDocumentSymbolContainer>(DocumentNames.DocumentSymbol, documentSymbolParams);
var actualSymbols = symbols.ToArray();
Assert.Collection(actualSymbols, actualSymbol => {
var expectedSymbol = expectedSymbols.Single();
Assert.True(expectedSymbol.IsDocumentSymbol);
Assert.NotNull(actualSymbol.DocumentSymbol);
Assert.Equal(expectedSymbol.DocumentSymbol.Detail, actualSymbol.DocumentSymbol.Detail);
Assert.Equal(expectedSymbol.DocumentSymbol.Kind, actualSymbol.DocumentSymbol.Kind);
Assert.Equal(expectedSymbol.DocumentSymbol.Range.Start.Line, actualSymbol.DocumentSymbol.Range.Start.Line);
Assert.Equal(expectedSymbol.DocumentSymbol.Range.Start.Character, actualSymbol.DocumentSymbol.Range.Start.Character);
Assert.Equal(expectedSymbol.DocumentSymbol.Range.End.Line, actualSymbol.DocumentSymbol.Range.End.Line);
Assert.Equal(expectedSymbol.DocumentSymbol.Range.End.Character, actualSymbol.DocumentSymbol.Range.End.Character);
});
}
public async override Task CustomInitializeAsync(
ILoggerFactory factory,
Stream inputStream,
Stream outputStream)
{
Diagnostics = new List <Diagnostic>();
DirectoryInfo testdir =
Directory.CreateDirectory(Path.Combine(s_binDir, Path.GetRandomFileName()));
PsesLanguageClient = LanguageClient.PreInit(options =>
{
options
.WithInput(inputStream)
.WithOutput(outputStream)
.WithRootUri(DocumentUri.FromFileSystemPath(testdir.FullName))
.OnPublishDiagnostics(diagnosticParams => Diagnostics.AddRange(diagnosticParams.Diagnostics.Where(d => d != null)))
.OnLogMessage(logMessageParams => Output?.WriteLine($"{logMessageParams.Type.ToString()}: {logMessageParams.Message}"));
// Enable all capabilities this this is for testing.
// This will be a built in feature of the Omnisharp client at some point.
var capabilityTypes = typeof(ICapability).Assembly.GetExportedTypes()
.Where(z => typeof(ICapability).IsAssignableFrom(z) && z.IsClass && !z.IsAbstract);
foreach (Type capabilityType in capabilityTypes)
{
options.WithCapability(Activator.CreateInstance(capabilityType, Array.Empty <object>()) as ICapability);
}
});
await PsesLanguageClient.Initialize(CancellationToken.None).ConfigureAwait(false);
// Make sure Script Analysis is enabled because we'll need it in the tests.
PsesLanguageClient.Workspace.DidChangeConfiguration(
new DidChangeConfigurationParams
{
Settings = JObject.Parse(@"
{
""powershell"": {
""scriptAnalysis"": {
""enable"": true
}
}
}
")
});
}
public void GetLanguagesTest_OneLangage()
{
var doc01 = new Document()
{
Id = "TEST001", Text = "Hello my friend"
};
var request = new LanguageRequest();
request.Documents.Add(doc01);
var client = new LanguageClient(this.apiKey);
var response = client.GetLanguages(request);
Assert.AreEqual("en", response.Documents[0].DetectedLanguages[0].Iso639Name);
Assert.AreEqual("English", response.Documents[0].DetectedLanguages[0].Name);
Assert.AreEqual(1.0, response.Documents[0].DetectedLanguages[0].Score);
}
protected virtual async Task <(ILanguageClient client, ILanguageServer server)> Initialize(
Action <LanguageClientOptions> clientOptionsAction,
Action <LanguageServerOptions> serverOptionsAction)
{
var clientPipe = new Pipe(TestOptions.DefaultPipeOptions);
var serverPipe = new Pipe(TestOptions.DefaultPipeOptions);
_client = LanguageClient.PreInit(options => {
options
.WithLoggerFactory(TestOptions.ClientLoggerFactory)
.ConfigureLogging(x => {
x.Services.RemoveAll(typeof(ILoggerFactory));
x.Services.AddSingleton(TestOptions.ClientLoggerFactory);
})
.Services
.AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
.AddSingleton(ServerEvents as IRequestSettler);
ConfigureClientInputOutput(serverPipe.Reader, clientPipe.Writer, options);
clientOptionsAction(options);
});
_server = RealLanguageServer.PreInit(options => {
options
.WithLoggerFactory(TestOptions.ServerLoggerFactory)
.ConfigureLogging(x => {
x.Services.RemoveAll(typeof(ILoggerFactory));
x.Services.AddSingleton(TestOptions.ServerLoggerFactory);
})
.Services
.AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
.AddSingleton(ServerEvents as IRequestSettler);
ConfigureServerInputOutput(clientPipe.Reader, serverPipe.Writer, options);
serverOptionsAction(options);
});
Disposable.Add(_client);
Disposable.Add(_server);
return(await ObservableEx.ForkJoin(
Observable.FromAsync(_client.Initialize),
Observable.FromAsync(_server.Initialize),
(a, b) => (_client, _server)
).ToTask(CancellationToken));
}
private async Task <ILanguageClient> InitializeLanguageClient(Stream inputStream, Stream outputStream, MultipleMessageListener <PublishDiagnosticsParams> publishDiagnosticsListener, CancellationToken cancellationToken)
{
var client = LanguageClient.PreInit(options =>
{
options
.WithInput(inputStream)
.WithOutput(outputStream)
.OnInitialize((client, request, cancellationToken) => { TestContext.WriteLine("Language client initializing."); return(Task.CompletedTask); })
.OnInitialized((client, request, response, cancellationToken) => { TestContext.WriteLine("Language client initialized."); return(Task.CompletedTask); })
.OnStarted((client, cancellationToken) => { TestContext.WriteLine("Language client started."); return(Task.CompletedTask); })
.OnLogTrace(@params => TestContext.WriteLine($"TRACE: {@params.Message} VERBOSE: {@params.Verbose}"))
.OnLogMessage(@params => TestContext.WriteLine($"{@params.Type}: {@params.Message}"))
.OnPublishDiagnostics(x => publishDiagnosticsListener.AddMessage(x));
});
await client.Initialize(cancellationToken);
return(client);
}
void InitializeClient()
{
JObject WorkspaceConfiguration = null;
if (options_.WorkspaceConfig != "")
{
WorkspaceConfiguration = (JObject)JsonConvert.DeserializeObject(options_.WorkspaceConfig);
}
client_ = new LSP.Implementation.LanguageClient();
client_.Start(
new LSP.Implementation.LanguageClient.LspParameter
{
logger = lspLogger_,
exeFileName = options_.ExcutablePath,
exeArguments = options_.Arguments,
jsonWorkspaceConfiguration = WorkspaceConfiguration,
}
);
}
private static async Task RunLanguageIdentification()
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Begining language identification ({0})", DateTime.Now.ToString());
foreach (var conversation in conversations)
{
var client = new LanguageClient(textAnalyticsApiKey);
foreach (var message in conversation.Messages)
{
try
{
var document = new Document()
{
Id = message.Id.ToString(),
Text = message.Text
};
var request = new LanguageRequest();
request.Documents.Add(document);
var response = await client.GetLanguagesAsync(request);
message.Metadata.LanguageName = response.Documents[0].DetectedLanguages[0].Iso639Name;
message.Metadata.LanguageConfidenceScore = response.Documents[0].DetectedLanguages[0].Score;
Console.Write("Conversation {0} | Message {1} | Language {2}", conversation.Id, message.Id, message.Metadata.LanguageName);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine("Exception encountered ({0})", DateTime.Now.ToString());
Console.WriteLine("Conversation {0} | Message {1}", conversation.Id, message.Id);
Console.WriteLine(ex.Message);
}
}
Console.WriteLine("Language identification complete ({0})", DateTime.Now.ToString());
Console.WriteLine();
}
}
private async Task <string> GetLanguage(string text)
{
var document = new Document()
{
Id = Guid.NewGuid().ToString(), Text = text
};
var request = new LanguageRequest();
request.Documents.Add(document);
var client = new LanguageClient(_subKey)
{
Url = ConfigurationManager.AppSettings["TextSentimentServiceUrl"] + "/languages"
};
var response = await client.GetLanguagesAsync(request);
return(response.Documents[0].DetectedLanguages[0].Iso639Name);
}
/// <summary>
/// Create a <see cref="LanguageClient"/> connected to the test's <see cref="PipeServerProcess"/>.
/// </summary>
/// <param name="initialize">
/// Automatically initialise the client?
///
/// Default is <c>true</c>.
/// </param>
/// <returns>
/// The <see cref="LanguageClient"/>.
/// </returns>
protected async Task <LanguageClient> CreateClient(bool initialize = true)
{
if (!_serverProcess.IsRunning)
{
await StartServer();
}
await _serverProcess.HasStarted;
LanguageClient client = new LanguageClient(LoggerFactory, _serverProcess);
Disposal.Add(client);
if (initialize)
{
await client.Initialize(WorkspaceRoot);
}
return(client);
}
public LanguageServerProtocolMessageTests(ITestOutputHelper output, LSPTestsFixture data)
{
LanguageClient = data.LanguageClient;
Diagnostics = data.Diagnostics;
Diagnostics.Clear();
PwshExe = TestsFixture.PwshExe;
_output = output;
if (!s_registeredOnLogMessage)
{
LanguageClient.Window.OnLogMessage((message, messageType) =>
{
_output.WriteLine($"{messageType.ToString()}: {message}");
});
s_registeredOnLogMessage = true;
}
}
public static async Task <ILanguageClient> StartServerWithClientConnection(Action <LanguageClientOptions> onClientOptions)
{
var clientPipe = new Pipe();
var serverPipe = new Pipe();
var server = new Server(serverPipe.Reader, clientPipe.Writer);
var _ = server.Run(CancellationToken.None); // do not wait on this async method, or you'll be waiting a long time!
var client = LanguageClient.PreInit(options =>
{
options
.WithInput(clientPipe.Reader)
.WithOutput(serverPipe.Writer);
onClientOptions(options);
});
await client.Initialize(CancellationToken.None);
return(client);
}
private static async Task HandleLanguageEvaluation(Activity activity)
{
var document = new Document()
{
Id = Guid.NewGuid().ToString(),
Text = activity.Text
};
var languageRequest = new LanguageRequest();
languageRequest.Documents.Add(document);
var languageClient = new LanguageClient(_configuration.LanguageApiKey);
var connector = new ConnectorClient(new Uri(activity.ServiceUrl));
try
{
var languageResponse = await languageClient.GetLanguagesAsync(languageRequest);
foreach (var doc in languageResponse.Documents)
{
var lang = doc.DetectedLanguages
.Where(l => l.Score > _configuration.MinimumLanguageConfidence)
.Where(l => !l.Name.Equals(_configuration.PreferredLanguage, StringComparison.InvariantCultureIgnoreCase))
.Select(l => l.Name.Replace('_', ' '))
.ToList();
if (lang != null && lang.Any())
{
var candidates = String.Join(", or ", lang);
var reply = activity.CreateReply($"That looks like {candidates}, please use {_configuration.PreferredLanguage} in this channel.");
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
}
catch (Exception ex)
{
await connector.Conversations.ReplyToActivityAsync(activity.CreateReply($"{ex.Message}"));
}
}
private async Task <string> GetLanguage()
{
var document = new Document()
{
Id = Guid.NewGuid().ToString(), Text = this.InputText
};
var request = new LanguageRequest();
request.Documents.Add(document);
MainWindow mainWindow = Window.GetWindow(this) as MainWindow;
var client = new LanguageClient(mainWindow._scenariosControl.SubscriptionKey);
MainWindow.Log("Request: Identifying language.");
var response = await client.GetLanguagesAsync(request);
MainWindow.Log("Response: Success. Language identified.");
return(response.Documents[0].DetectedLanguages[0].Iso639Name);
}
protected virtual ILanguageClient CreateClient(Action <LanguageClientOptions> clientOptionsAction = null)
{
_client = LanguageClient.PreInit(
options => {
var(reader, writer) = SetupServer();
options
.WithInput(reader)
.WithOutput(writer)
.WithLoggerFactory(TestOptions.ClientLoggerFactory)
.ConfigureLogging(x => x.SetMinimumLevel(LogLevel.Trace))
.Services
.AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
.AddSingleton(Events as IRequestSettler);
clientOptionsAction?.Invoke(options);
}
);
Disposable.Add(_client);
return(_client);
}
public static async Task <ILanguageClient> StartServerWithClientConnectionAsync(Action <LanguageClientOptions> onClientOptions, Func <IResourceTypeProvider>?typeProviderBuilder = null)
{
typeProviderBuilder ??= TestResourceTypeProvider.Create;
var clientPipe = new Pipe();
var serverPipe = new Pipe();
var server = new Server(serverPipe.Reader, clientPipe.Writer, typeProviderBuilder);
var _ = server.RunAsync(CancellationToken.None); // do not wait on this async method, or you'll be waiting a long time!
var client = LanguageClient.PreInit(options =>
{
options
.WithInput(clientPipe.Reader)
.WithOutput(serverPipe.Writer);
onClientOptions(options);
});
await client.Initialize(CancellationToken.None);
return(client);
}
static async Task MainAsync()
{
var apiKey = "YOUR-TEXT-ANALYTICS-API-SUBSCRIPTION-KEY";
var document = new Document()
{
Id = "YOUR-UNIQUE-ID",
Text = "YOUR-TEXT"
};
var client = new LanguageClient(apiKey);
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = await client.GetLanguagesAsync(request);
foreach (var doc in response.Documents)
{
Console.WriteLine("Document Id: {0}", doc.Id);
foreach (var lang in doc.DetectedLanguages)
{
Console.WriteLine("--Language: {0}({1})", lang.Name, lang.Iso639Name);
Console.WriteLine("--Confidence: {0}%", (lang.Score * 100));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
public static async Task <LanguageServerHelper> StartServerWithClientConnectionAsync(TestContext testContext, Action <LanguageClientOptions> onClientOptions, Server.CreationOptions?creationOptions = null)
{
var clientPipe = new Pipe();
var serverPipe = new Pipe();
creationOptions ??= new Server.CreationOptions();
creationOptions = creationOptions with
{
SnippetsProvider = creationOptions.SnippetsProvider ?? SnippetsProvider,
FileResolver = creationOptions.FileResolver ?? new InMemoryFileResolver(new Dictionary <Uri, string>()),
ModuleRestoreScheduler = creationOptions.ModuleRestoreScheduler ?? BicepTestConstants.ModuleRestoreScheduler
};
var server = new Server(
creationOptions,
options => options
.WithInput(serverPipe.Reader)
.WithOutput(clientPipe.Writer));
var _ = server.RunAsync(CancellationToken.None); // do not wait on this async method, or you'll be waiting a long time!
var client = LanguageClient.PreInit(options =>
{
options
.WithInput(clientPipe.Reader)
.WithOutput(serverPipe.Writer)
.OnInitialize((client, request, cancellationToken) => { testContext.WriteLine("Language client initializing."); return(Task.CompletedTask); })
.OnInitialized((client, request, response, cancellationToken) => { testContext.WriteLine("Language client initialized."); return(Task.CompletedTask); })
.OnStarted((client, cancellationToken) => { testContext.WriteLine("Language client started."); return(Task.CompletedTask); })
.OnLogTrace(@params => testContext.WriteLine($"TRACE: {@params.Message} VERBOSE: {@params.Verbose}"))
.OnLogMessage(@params => testContext.WriteLine($"{@params.Type}: {@params.Message}"));
onClientOptions(options);
});
await client.Initialize(CancellationToken.None);
testContext.WriteLine("LanguageClient initialize finished.");
return(new(server, client));
}
public static async Task <ILanguageClient> StartServerWithClientConnectionAsync(TestContext testContext, Action <LanguageClientOptions> onClientOptions, IResourceTypeProvider?resourceTypeProvider = null, IFileResolver?fileResolver = null)
{
resourceTypeProvider ??= TestTypeHelper.CreateEmptyProvider();
fileResolver ??= new InMemoryFileResolver(new Dictionary <Uri, string>());
var clientPipe = new Pipe();
var serverPipe = new Pipe();
var server = new Server(
serverPipe.Reader,
clientPipe.Writer,
new Server.CreationOptions
{
ResourceTypeProvider = resourceTypeProvider,
FileResolver = fileResolver,
SnippetsProvider = SnippetsProvider
});
var _ = server.RunAsync(CancellationToken.None); // do not wait on this async method, or you'll be waiting a long time!
var client = LanguageClient.PreInit(options =>
{
options
.WithInput(clientPipe.Reader)
.WithOutput(serverPipe.Writer)
.OnInitialize((client, request, cancellationToken) => { testContext.WriteLine("Language client initializing."); return(Task.CompletedTask); })
.OnInitialized((client, request, response, cancellationToken) => { testContext.WriteLine("Language client initialized."); return(Task.CompletedTask); })
.OnStarted((client, cancellationToken) => { testContext.WriteLine("Language client started."); return(Task.CompletedTask); })
.OnLogTrace(@params => testContext.WriteLine($"TRACE: {@params.Message} VERBOSE: {@params.Verbose}"))
.OnLogMessage(@params => testContext.WriteLine($"{@params.Type}: {@params.Message}"));
onClientOptions(options);
});
await client.Initialize(CancellationToken.None);
testContext.WriteLine("LanguageClient initialize finished.");
return(client);
}
public async Task TriggersStartedTask()
{
var startupInterface = Substitute.For(new [] { typeof(IOnStarted), typeof(IDidChangeConfigurationHandler) }, Array.Empty <object>()) as IOnStarted;
var startedDelegate = Substitute.For <StartedDelegate>();
startedDelegate(Arg.Any <ILanguageServer>(), Arg.Any <InitializeResult>(), Arg.Any <CancellationToken>()).Returns(Task.CompletedTask);
var process = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory);
await process.Start();
var client = new LanguageClient(LoggerFactory, process);
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(15));
var serverStart = LanguageServer.From(x => x
.OnStarted(startedDelegate)
.OnStarted(startedDelegate)
.OnStarted(startedDelegate)
.OnStarted(startedDelegate)
.WithHandler((IDidChangeConfigurationHandler)startupInterface)
.WithInput(process.ClientOutputStream)
.WithOutput(process.ClientInputStream)
.ConfigureLogging(z => z.Services.AddSingleton(LoggerFactory))
.AddHandlers(TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp"))
, cts.Token);
await Task.WhenAll(
client.Initialize(
Directory.GetCurrentDirectory(),
new object(),
cts.Token),
serverStart
);
using var server = await serverStart;
_ = startedDelegate.Received(4)(Arg.Any <ILanguageServer>(), Arg.Any <InitializeResult>(), Arg.Any <CancellationToken>());
_ = startupInterface.Received(1).OnStarted(Arg.Any <ILanguageServer>(), Arg.Any <InitializeResult>(), Arg.Any <CancellationToken>());
}
public static LanguageClient MakeClient(Action <ClientCapabilities> configureClientCaps)
{
Directory.CreateDirectory(DefaultSrcFolder);
var loggerFactory = new LoggerFactory(new[] { new InMemoryLoggerProvider() });
var client = new LanguageClient(loggerFactory, new DummyServerProcess(loggerFactory));
client.ClientCapabilities.Window = new WindowClientCapabilities
{
WorkDoneProgress = new Supports <bool>(true, true)
};
client.ClientCapabilities.Workspace.WorkspaceEdit = Supports.OfBoolean <WorkspaceEditCapability>(true);
client.ClientCapabilities.Workspace.WorkspaceFolders = Supports.OfBoolean <bool>(true);
client.ClientCapabilities.TextDocument.Completion = Supports.OfBoolean <CompletionCapability>(true);
configureClientCaps(client.ClientCapabilities);
bool hasInitialized = client.Initialize(DefaultWorkspaceRoot).Wait(3000);
Assert.IsTrue(hasInitialized);
return(client);
}
public async Task Test1()
{
var logFactory = LoggerFactory.Create(a => a.AddNLog().SetMinimumLevel(LogLevel.Trace));
var serverProcess = new NamedPipeServerProcess("test", logFactory);
var languageClient = new LanguageClient(logFactory, serverProcess);
var clientInit = languageClient.Initialize("/");
var serverInit = RhetosLanguageServer.BuildLanguageServer(serverProcess.ClientOutputStream, serverProcess.ClientInputStream, builder => builder.AddNLog().AddLanguageServer().AddConsole());
Task.WaitAll(clientInit, serverInit);
Console.WriteLine(languageClient.IsConnected.ToString());
var textDocument = new TextDocumentItem()
{
Text = @"// <rhetosRootPath="""" />\nble ble ble\nblelle",
Uri = new Uri("file://ble.rhe")
};
var opened = await languageClient.SendRequest <object>(DocumentNames.DidOpen, new DidOpenTextDocumentParams()
{
TextDocument = textDocument
});
Task.Delay(2500).Wait();
var result = await languageClient.SendRequest <CompletionList>(DocumentNames.Completion, new CompletionParams()
{
TextDocument = new TextDocumentIdentifier(textDocument.Uri), Position = new Position()
});
Console.WriteLine(JsonConvert.SerializeObject(result.Items, Formatting.Indented));
Task.Delay(3000).Wait();
languageClient.Dispose();
}
