public async Task kernel_base_ignores_command_line_directives(Language language)
{
// The text `[1;2;3;4]` parses as a System.CommandLine directive; ensure it's not consumed and is passed on to the kernel.
var kernel = CreateKernel(language);
var source = @"
[1;2;3;4]
|> List.sum";
await SubmitCode(kernel, source);
KernelEvents
.OfType <ReturnValueProduced>()
.Last()
.Value
.Should()
.Be(10);
}
public async Task PowerShell_native_executable_output_is_collected()
{
var kernel = CreateKernel(Language.PowerShell);
var command = Platform.IsWindows
? new SubmitCode("ping.exe -n 1 localhost")
: new SubmitCode("ping -c 1 localhost");
await kernel.SendAsync(command);
var outputs = KernelEvents.OfType <StandardOutputValueProduced>();
outputs.Should().HaveCountGreaterThan(1);
outputs.Select(e => e.Value.ToString())
.First(s => s.Trim().Length > 0)
.ToLowerInvariant()
.Should().Match("*ping*data*");
}
public async Task PowerShell_native_executable_output_is_collected()
{
var kernel = CreateKernel(Language.PowerShell);
var command = new SubmitCode("dotnet --help");
await kernel.SendAsync(command);
var outputs = KernelEvents.OfType <StandardOutputValueProduced>();
outputs.Should().HaveCountGreaterThan(1);
string.Join("",
outputs
.SelectMany(e => e.FormattedValues.Select(v => v.Value))
).ToLowerInvariant()
.Should()
.ContainAll("build-server", "restore");
}
public async Task it_returns_completion_list_for_types(Language language)
{
var kernel = CreateKernel(language);
var source = "System.Console."; // same code is valid regardless of the language
await kernel.SendAsync(new RequestCompletion(source, 15));
KernelEvents
.Should()
.ContainSingle(e => e is CompletionRequestReceived);
KernelEvents
.OfType <CompletionRequestCompleted>()
.Single()
.CompletionList
.Should()
.Contain(i => i.DisplayText == "ReadLine");
}
public async Task it_aggregates_multiple_submissions()
{
var repl = await CreateKernelAsync();
await repl.SendAsync(new SubmitCode("var x = new List<int>{1,2};"));
await repl.SendAsync(new SubmitCode("x.Add(3);"));
await repl.SendAsync(new SubmitCode("x.Max()"));
KernelEvents.OfType <ValueProduced>()
.Last()
.Should()
.BeOfType <ValueProduced>()
.Which
.Value
.Should()
.Be(3);
}
public async Task expression_evaluated_to_null_has_result_with_null_value(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
// null returned.
Language.FSharp => "null :> obj",
Language.CSharp => "null as object"
};
await SubmitCode(kernel, source);
KernelEvents
.OfType <ReturnValueProduced>()
.Last()
.Value
.Should()
.BeNull();
}
public async Task Display_helper_can_be_called_without_specifying_class_name(Language language)
{
var kernel = CreateKernel(language);
var submission = language switch
{
Language.CSharp => "display(b(\"hi!\"));",
Language.FSharp => "display(b.innerHTML(\"hi!\"));",
};
await kernel.SendAsync(new SubmitCode(submission));
KernelEvents
.OfType <DisplayedValueProduced>()
.SelectMany(v => v.FormattedValues)
.Should()
.ContainSingle(v =>
v.MimeType == "text/html" &&
v.Value.ToString().Contains("<b>hi!</b>"));
}
public async Task it_returns_a_similarly_shaped_error(Language language)
{
var kernel = CreateKernel(language);
var(source, error) = language switch
{
Language.CSharp => ("using Not.A.Namespace;", "(1,7): error CS0246: The type or namespace name 'Not' could not be found (are you missing a using directive or an assembly reference?)"),
Language.FSharp => ("open Not.A.Namespace", @"input.fsx (1,6)-(1,9) typecheck error The namespace or module 'Not' is not defined. Maybe you want one of the following:
Net")
};
await SubmitCode(kernel, source);
KernelEvents
.OfType <CommandFailed>()
.Last()
.Message
.Should()
.Be(error);
}
public async Task When_a_chart_is_returned_the_value_produced_has_html_with_the_require_config_call()
{
var kernel = CreateKernel();
kernel.UseXplot();
await kernel.SendAsync(new SubmitCode("using XPlot.Plotly;"));
await kernel.SendAsync(new SubmitCode("new PlotlyChart()"));
KernelEvents
.OfType <ReturnValueProduced>()
.Should().
ContainSingle(valueProduced =>
valueProduced.FormattedValues.Any(formattedValue =>
formattedValue.MimeType == "text/html" &&
formattedValue.Value.ToString().Contains("var xplotRequire = requirejs.config({context:'xplot-3.0.1',paths:{plotly:'https://cdn.plot.ly/plotly-1.49.2.min'}});") &&
formattedValue.Value.ToString().Contains("xplotRequire([\'plotly\'], function(Plotly)")
));
}
public async Task diagnostics_can_be_produced_from_multiple_subkernels()
{
var kernel = CreateCompositeKernel(Language.FSharp);
var code = @"
#!fsharp
printfnnn """"
#!csharp
Console.WriteLin();
";
await SubmitCode(kernel, code);
KernelEvents
.OfType <DiagnosticsProduced>()
.SelectMany(dp => dp.Diagnostics)
.Should()
.ContainSingle(d => d.Code.StartsWith("CS"))
.And
.ContainSingle(d => d.Code.StartsWith("FS"));
}
public async Task it_returns_completion_list_for_previously_declared_items(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
Language.FSharp => @"let alpha = new Random()",
Language.CSharp => @"var alpha = new Random();",
Language.PowerShell => @"function alpha { 5 }",
};
await SubmitCode(kernel, source);
await kernel.SendAsync(new RequestCompletions("al", new LinePosition(0, 2)));
KernelEvents
.OfType <CompletionsProduced>()
.Single()
.Completions
.Should()
.Contain(i => i.DisplayText == "alpha");
}
public async Task it_can_load_assembly_references_using_r_directive_separate_submissions(Language language)
{
var kernel = CreateKernel(language);
// F# strings treat \ as an escape character. So do C# strings, except #r in C# is special, and doesn't. F# usually uses @ strings for paths @"c:\temp\...."
var dllPath = new FileInfo(typeof(JsonConvert).Assembly.Location).FullName.Replace('\\', '/');
var source = language switch
{
Language.FSharp => new[]
{
$"#r \"{dllPath}\"",
"open Newtonsoft.Json",
@"let json = JsonConvert.SerializeObject( struct {| value = ""hello"" |} )",
"json"
},
Language.CSharp => new[]
{
$"#r \"{dllPath}\"",
"using Newtonsoft.Json;",
@"var json = JsonConvert.SerializeObject(new { value = ""hello"" });",
"json"
}
};
await SubmitCode(kernel, source);
KernelEvents
.Should()
.ContainSingle(e => e is ReturnValueProduced);
KernelEvents
.OfType <ReturnValueProduced>()
.Single()
.Value
.Should()
.Be(new { value = "hello" }.ToJson());
}
public async Task Display_indicates_when_a_value_is_null(Language language)
{
var kernel = CreateKernel(language);
var submission = language switch
{
Language.CSharp => "display(null);",
Language.FSharp => "display(null)"
};
await kernel.SendAsync(new SubmitCode(submission));
KernelEvents.Should().NotContainErrors();
KernelEvents
.OfType <DisplayedValueProduced>()
.SelectMany(v => v.FormattedValues)
.Should()
.ContainSingle(v =>
v.MimeType == "text/html" &&
v.Value.ToString().Contains(Formatter.NullString.HtmlEncode().ToString()));
}
// [InlineData(Language.FSharp)] // Todo: need to generate CompletionRequestReceived event ... perhaps
public async Task it_returns_completion_list_for_types(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
Language.FSharp => @"System.Console.",
Language.CSharp => @"System.Console."
};
await kernel.SendAsync(new RequestCompletion(source, 15));
KernelEvents
.Should()
.ContainSingle(e => e is CompletionRequestReceived);
KernelEvents
.OfType <CompletionRequestCompleted>()
.Single()
.CompletionList
.Should()
.Contain(i => i.DisplayText == "ReadLine");
}
private void ListenForPackagesToScanForExtensions() =>
RegisterForDisposal(KernelEvents
.OfType <PackageAdded>()
.Where(pa => pa?.PackageReference.PackageRoot != null)
.Distinct(pa => pa.PackageReference.PackageRoot)
.Subscribe(added => _packagesToCheckForExtensions.Enqueue(added)));