public void When_command_type_registered_then_kernel_registers_envelope_type_for_serialization(bool withHandler)
{
KernelCommandEnvelope.RegisterDefaults();
using var kernel = new FakeKernel();
if (withHandler)
{
kernel.RegisterCommandHandler <CustomCommandTypes.FirstSubmission.MyCommand>(
(_, _) => Task.CompletedTask);
}
else
{
kernel.RegisterCommandType <CustomCommandTypes.FirstSubmission.MyCommand>();
}
var originalCommand = new CustomCommandTypes.FirstSubmission.MyCommand("xyzzy");
string envelopeJson = KernelCommandEnvelope.Serialize(originalCommand);
var roundTrippedCommandEnvelope = KernelCommandEnvelope.Deserialize(envelopeJson);
roundTrippedCommandEnvelope
.Command
.Should()
.BeOfType <CustomCommandTypes.FirstSubmission.MyCommand>()
.Which
.Info
.Should()
.Be(originalCommand.Info);
}
public async Task hover_on_unsupported_language_service_returns_nothing()
{
using var kernel = new FakeKernel();
var result = await SendHoverRequest(kernel, "code", 0, 0);
result.KernelEvents
.ToSubscribedList()
.Should()
.NotContain(kv => kv is HoverTextProduced);
}
public IntPtr clCreateKernel(IntPtr program, string kernelName, out OpenClErrorCode errorCodeRet)
{
errorCodeRet = clCreateKernelErrorCode ?? OpenClErrorCode.Success;
if (errorCodeRet != OpenClErrorCode.Success)
{
return(IntPtr.Zero);
}
var id = clCreateKernelReturn ?? new IntPtr(1);
FakeKernels[id] = new FakeKernel(program, kernelName);
return(id);
}
protected async Task <CompositeKernel> CreateKernel(LessonMode mode, HttpClient?httpClient = null)
{
var vscodeKernel = new FakeKernel("vscode");
vscodeKernel.RegisterCommandHandler <SendEditableCode>((_, _) => Task.CompletedTask);
var kernel = new CompositeKernel
{
new CSharpKernel().UseNugetDirective().UseKernelHelpers(),
vscodeKernel
};
Lesson.Mode = mode;
await Main.OnLoadAsync(kernel, httpClient);
return(kernel);
}
public void When_command_type_reregistered_with_changed_type_command_then_kernel_registers_updated_envelope_type_for_serialization(bool withHandler)
{
// Notebook authors should be able to develop their custom commands experimentally and progressively,
// so we don't want any "you have to restart your kernel now" situations just because you already
// called RegisterCommandHandler once for a particular command type.
KernelCommandEnvelope.RegisterDefaults();
using var kernel = new FakeKernel();
if (withHandler)
{
kernel.RegisterCommandHandler <CustomCommandTypes.FirstSubmission.MyCommand>(
(_, _) => Task.CompletedTask);
kernel.RegisterCommandHandler <CustomCommandTypes.SecondSubmission.MyCommand>(
(_, _) => Task.CompletedTask);
}
else
{
kernel.RegisterCommandType <CustomCommandTypes.FirstSubmission.MyCommand>();
kernel.RegisterCommandType <CustomCommandTypes.SecondSubmission.MyCommand>();
}
var originalCommand = new CustomCommandTypes.SecondSubmission.MyCommand("xyzzy", 42);
string envelopeJson = KernelCommandEnvelope.Serialize(originalCommand);
var roundTrippedCommandEnvelope = KernelCommandEnvelope.Deserialize(envelopeJson);
roundTrippedCommandEnvelope
.Command
.Should()
.BeOfType <CustomCommandTypes.SecondSubmission.MyCommand>()
.Which
.Info
.Should()
.Be(originalCommand.Info);
roundTrippedCommandEnvelope
.Command
.As <CustomCommandTypes.SecondSubmission.MyCommand>()
.AdditionalProperty
.Should()
.Be(originalCommand.AdditionalProperty);
}
public async Task Kernel_info_returns_the_list_of_dynamic_kernel_commands()
{
using var kernel = new FakeKernel();
kernel.RegisterCommandHandler <RequestHoverText>((_, _) => Task.CompletedTask);
kernel.RegisterCommandHandler <RequestDiagnostics>((_, _) => Task.CompletedTask);
kernel.RegisterCommandHandler <CustomCommandTypes.FirstSubmission.MyCommand>((_, _) => Task.CompletedTask);
var result = await kernel.SendAsync(new RequestKernelInfo());
var events = result.KernelEvents.ToSubscribedList();
events.Should()
.ContainSingle <KernelInfoProduced>()
.Which
.KernelInfo
.SupportedKernelCommands
.Select(c => c.Name)
.Should()
.Contain(
nameof(RequestHoverText),
nameof(RequestDiagnostics),
nameof(CustomCommandTypes.FirstSubmission.MyCommand));
}
