public async Task it_returns_exceptions_thrown_in_user_code(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
Language.FSharp => new[]
{
// F# syntax doesn't allow a bare `raise ...` expression at the root due to type inference being
// ambiguous, but the same effect can be achieved by wrapping the exception in a strongly-typed
// function call.
"open System",
"let f (): unit = raise (new NotImplementedException())",
"f ()"
},
Language.CSharp => new[]
{
"using System;",
"throw new NotImplementedException();"
}
};
await SubmitCode(kernel, source);
KernelEvents
.Where(x => x.GetType() != typeof(KernelIdle) && x.GetType() != typeof(KernelBusy))
.Last()
.Should()
.BeOfType <CommandFailed>()
.Which
.Exception
.Should()
.BeOfType <NotImplementedException>();
}
public async Task the_output_is_asynchronous(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
Language.FSharp => @"
open System
Console.Write(DateTime.Now)
System.Threading.Thread.Sleep(1000)
Console.Write(DateTime.Now)
5",
Language.CSharp => @"
Console.Write(DateTime.Now);
System.Threading.Thread.Sleep(1000);
Console.Write(DateTime.Now);
5",
};
await SubmitCode(kernel, source);
var events =
KernelEvents
.Where(e => e is StandardOutputValueProduced).OfType <StandardOutputValueProduced>().ToArray();
var diff = DateTime.Parse((string)(events[1].Value)) - DateTime.Parse((string)(events[0].Value));
diff.Should().BeCloseTo(1.Seconds(), precision: 200);
}
public async Task the_output_is_asynchronous()
{
var kernel = CreateKernel();
var kernelCommand = new SubmitCode(@"
Console.Write(DateTime.Now);
System.Threading.Thread.Sleep(1000);
Console.Write(DateTime.Now);
5", "csharp");
await kernel.SendAsync(kernelCommand);
var events = KernelEvents
.Where(e => e.Value is DisplayedValueProduced).ToArray();
var diff = events[1].Timestamp - events[0].Timestamp;
diff.Should().BeCloseTo(1.Seconds(), precision: 200);
}
public async Task Value_display_and_update_are_in_right_order(Language language)
{
var kernel = CreateKernel(language);
var submission = language switch
{
Language.CSharp => "var d = display(b(\"hello\")); d.Update(b(\"world\"));",
Language.FSharp => "let d = display(b.innerHTML(\"hello\"))\nd.Update(b.innerHTML(\"world\"))",
};
await kernel.SendAsync(new SubmitCode(submission));
var valueEvents =
KernelEvents
.Where(e => e is DisplayedValueProduced || e is DisplayedValueUpdated)
.Select(e => e)
.ToList();
valueEvents.First().Should().BeOfType <DisplayedValueProduced>();
valueEvents.Last().Should().BeOfType <DisplayedValueUpdated>();
}
public async Task it_returns_diagnostics(Language language)
{
var kernel = CreateKernel(language);
var source = language switch
{
Language.FSharp => new[]
{
"open System",
"aaaadd"
},
Language.CSharp => new[]
{
"using System;",
"aaaadd"
}
};
await SubmitCode(kernel, source);
var error = language switch
{
Language.FSharp => "input.fsx (1,1)-(1,7) typecheck error The value or constructor 'aaaadd' is not defined.",
Language.CSharp => "(1,1): error CS0103: The name 'aaaadd' does not exist in the current context",
};
KernelEvents
.Where(x => x.GetType() != typeof(KernelIdle) && x.GetType() != typeof(KernelBusy))
.Last()
.Should()
.BeOfType <CommandFailed>()
.Which
.Message
.Should()
.Be(error);
}