LanguageKernelPackageTests.cs

// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using FluentAssertions;
using FluentAssertions.Execution;
using Microsoft.DotNet.Interactive.Commands;
using Microsoft.DotNet.Interactive.CSharp;
using Microsoft.DotNet.Interactive.Events;
using Microsoft.DotNet.Interactive.Formatting;
using Microsoft.DotNet.Interactive.FSharp;
using Microsoft.DotNet.Interactive.Jupyter;
using Microsoft.DotNet.Interactive.Tests.Utility;
using Newtonsoft.Json;
using Xunit;
using Xunit.Abstractions;

namespace Microsoft.DotNet.Interactive.Tests
{
#pragma warning disable 8509
    public class LanguageKernelPackageTests : LanguageKernelTestBase
    {
        public LanguageKernelPackageTests(ITestOutputHelper output) : base(output)
        {
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task it_returns_completion_list_for_types_imported_at_runtime(Language language)
        {
            var kernel = CreateKernel(language);

            var dll = new FileInfo(typeof(JsonConvert).Assembly.Location).FullName;

            var code = language switch
            {
                Language.CSharp => $"#r \"{dll}\"",
                Language.FSharp => $"#r @\"{dll}\""
            };

            await kernel.SendAsync(new SubmitCode(code));

            await kernel.SendAsync(new RequestCompletions("Newtonsoft.Json.JsonConvert.", new LinePosition(0, 28)));

            KernelEvents.Single(e => e is CompletionsProduced)
                        .As<CompletionsProduced>()
                        .Completions
                        .Should()
                        .Contain(i => i.DisplayText == "SerializeObject");
        }

        [Theory]
        [InlineData(Language.CSharp, "var a = new List<int>();")]
        [InlineData(Language.FSharp, "let _ = List<int>()")]
        public async Task When_SubmitCode_command_adds_packages_to_the_kernel_then_the_submission_is_not_passed_to_the_script(Language language, string assignment)
        {
            using var kernel = CreateKernel(language);
            using var events = kernel.KernelEvents.ToSubscribedList();

            var command = new SubmitCode("#r \"nuget:SixLabors.ImageSharp, 1.0.2\"" + Environment.NewLine + assignment);
            await kernel.SendAsync(command);

            events
                .OfType<CodeSubmissionReceived>()
                .Should()
                .NotContain(e => e.Code.Contains("#r \"nuget:"));
        }

        [Theory]
        [InlineData(Language.CSharp, "Microsoft.Extensions.Logging.ILogger logger = null;")]
        [InlineData(Language.FSharp, "let logger: Microsoft.Extensions.Logging.ILogger = null")]
        public async Task When_SubmitCode_command_adds_packages_to_kernel_then_PackageAdded_event_is_raised(Language language, string expression)
        {
            using Kernel kernel = language switch
            {
                Language.CSharp => new CompositeKernel { new CSharpKernel().UseNugetDirective() },
                Language.FSharp => new CompositeKernel { new FSharpKernel().UseNugetDirective() }
            };

            var code = $@"
#r ""nuget:Microsoft.Extensions.Logging, 2.2.0""
{expression}".Trim();
            var command = new SubmitCode(code);

            var result = await kernel.SendAsync(command);

            using var events = result.KernelEvents.ToSubscribedList();

            events.OfType<PackageAdded>()
                  .Should()
                  .ContainSingle(e => e.PackageReference.PackageName == "Microsoft.Extensions.Logging"
                                      && e.PackageReference.PackageVersion == "2.2.0");
        }

        [Fact]
        public async Task Loads_native_dependencies_from_nugets()
        {
            using var kernel = CreateKernel();

            using var events = kernel.KernelEvents.ToSubscribedList();

            var command = new SubmitCode(@"
#r ""nuget:Microsoft.ML, 1.3.1""

using Microsoft.ML;
using Microsoft.ML.Data;
using System;

class IrisData
{
    public IrisData(float sepalLength, float sepalWidth, float petalLength, float petalWidth)
    {
        SepalLength = sepalLength;
        SepalWidth = sepalWidth;
        PetalLength = petalLength;
        PetalWidth = petalWidth;
    }
    public float SepalLength;
    public float SepalWidth;
    public float PetalLength;
    public float PetalWidth;
}

var data = new[]
{
    new IrisData(1.4f, 1.3f, 2.5f, 4.5f),
    new IrisData(2.4f, 0.3f, 9.5f, 3.4f),
    new IrisData(3.4f, 4.3f, 1.6f, 7.5f),
    new IrisData(3.9f, 5.3f, 1.5f, 6.5f),
};

MLContext mlContext = new MLContext();
var pipeline = mlContext.Transforms
    .Concatenate(""Features"", ""SepalLength"", ""SepalWidth"", ""PetalLength"", ""PetalWidth"")
    .Append(mlContext.Clustering.Trainers.KMeans(""Features"", numberOfClusters: 2));

try
{
    pipeline.Fit(mlContext.Data.LoadFromEnumerable(data));
    Console.WriteLine(""success"");
}
catch (Exception e)
{
    Console.WriteLine(e);
}");

            await kernel.SendAsync(command);

            events
                .Should()
                .Contain(e => e is PackageAdded);

            events
                .Should()
                .ContainSingle<StandardOutputValueProduced>(
                    e => e.FormattedValues.Any(v => v.Value.Contains("success")));
        }

        [Fact]
        public async Task Dependency_version_conflicts_are_resolved_correctly()
        {
            var kernel = CreateKernel(Language.CSharp);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"#!time
#r ""nuget:Microsoft.ML.AutoML,0.16.0-preview""
#r ""nuget:Microsoft.Data.Analysis,0.4.0""
");

            await kernel.SubmitCodeAsync($@"
using Microsoft.Data.Analysis;
using static {typeof(PocketViewTags).FullName};
using {typeof(PocketView).Namespace};");

            await kernel.SubmitCodeAsync(@"
using Microsoft.AspNetCore.Html;
Formatter.Register<DataFrame>((df, writer) =>
{
    var headers = new List<IHtmlContent>();
    headers.Add(th(i(""index"")));
    headers.AddRange(df.Columns.Select(c => (IHtmlContent) th(c)));
    var rows = new List<List<IHtmlContent>>();
    var take = 20;
    for (var i = 0; i < Math.Min(take, df.Rows.Count); i++)
    {
        var cells = new List<IHtmlContent>();
        cells.Add(td(i));
        foreach (var obj in df.Rows[i])
        {
            cells.Add(td(obj));
        }
        rows.Add(cells);
    }

    var t = table(
        thead(
            headers),
        tbody(
            rows.Select(
                r => tr(r))));

    writer.Write(t);
}, ""text/html"");");

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_disallows_empty_package_specification(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"#r ""nuget:""");

            events
                .Should()
                .ContainSingle<CommandFailed>()
                .Which
                .Message
                .Should()
                .Be("Unable to parse package reference: \"nuget:\"");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_disallows_version_only_package_specification(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#r ""nuget:,1.0.0""
");

            events
                .Should()
                .ContainSingle<CommandFailed>()
                .Which
                .Message
                .Should()
                .Be("Unable to parse package reference: \"nuget:,1.0.0\"");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_allows_RestoreSources_package_specification(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
");

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_displays_list_of_added_sources(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#i ""nuget:https://completelyFakerestoreSource1""
#i ""nuget:https://completelyFakerestoreSource2""
");
            events.OfType<DisplayEvent>().Select(e => e.GetType()).Should().ContainInOrder(typeof(DisplayedValueProduced), typeof(DisplayedValueUpdated));
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_with_multi_submissions_combines_the_text_produced(Language language)
        {
            var kernel = CreateKernel(language);

            await kernel.SubmitCodeAsync(@"
#i ""nuget:https://completelyFakerestoreSourceCommand1.1""
#i ""nuget:https://completelyFakerestoreSourceCommand1.2""
");

            var result = await kernel.SubmitCodeAsync(@"
#i ""nuget:https://completelyFakerestoreSourceCommand2.1""
");

            var expectedList = new[]
            {
                "https://completelyFakerestoreSourceCommand1.1",
                "https://completelyFakerestoreSourceCommand1.2",
                "https://completelyFakerestoreSourceCommand2.1"
            };

            using var events = result.KernelEvents.ToSubscribedList();
            events.OfType<DisplayedValueProduced>()
                  .Should()
                  .ContainSingle(v => v.Value is InstallPackagesMessage)
                  .Which.Value
                  .As<InstallPackagesMessage>()
                  .RestoreSources
                  .Aggregate((s, acc) => acc + " & " + s)
                  .Should()
                  .ContainAll(expectedList);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_with_multi_submissions_combines_the_Text_Updates(Language language)
        {
            var kernel = CreateKernel(language);

            await kernel.SubmitCodeAsync(@"
#i ""nuget:https://completelyFakerestoreSourceCommand1.1""
#i ""nuget:https://completelyFakerestoreSourceCommand1.2""
");

            var result = await kernel.SubmitCodeAsync(@"
#i ""nuget:https://completelyFakerestoreSourceCommand2.1""
#i ""nuget:https://completelyFakerestoreSourceCommand2.2""
");

            var expectedList = new[]
            {
                "https://completelyFakerestoreSourceCommand1.1",
                "https://completelyFakerestoreSourceCommand1.2",
                "https://completelyFakerestoreSourceCommand2.1",
                "https://completelyFakerestoreSourceCommand2.2"
            };

            using var events = result.KernelEvents.ToSubscribedList();

            events.OfType<DisplayedValueProduced>()
                  .Should()
                  .ContainSingle(v => v.Value is InstallPackagesMessage)
                  .Which.Value
                  .As<InstallPackagesMessage>()
                  .RestoreSources
                  .Should()
                  .BeEquivalentTo(expectedList);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_allows_duplicate_sources_package_specification_single_cell(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
#i ""nuget:https://completelyFakerestoreSource""
");

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_allows_duplicate_sources_package_specification_multiple_cells(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
");

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
");

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_allows_multiple_sources_package_specification_single_cell(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
");

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_i_nuget_allows_multiple_package_sources_to_be_specified_in_multiple_cells(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://completelyFakerestoreSource""
");
            events.Should().NotContainErrors();

            await kernel.SubmitCodeAsync(
                @"
#!time
#i ""nuget:https://anotherCompletelyFakerestoreSource""
");

            events.Should().NotContainErrors();
        }

        [Theory]
        //[InlineData(Language.CSharp, "using SixLabors.ImageSharp;")]
        [InlineData(Language.FSharp, "open SixLabors.ImageSharp")]
        public async Task Pound_r_nuget_allows_duplicate_package_specifications_single_cell(Language language, string code)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget:SixLabors.ImageSharp,1.0.2""
#r ""nuget:SixLabors.ImageSharp,1.0.2""
");

            await kernel.SubmitCodeAsync(code);

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp, "using SixLabors.ImageSharp;")]
        [InlineData(Language.FSharp, "open SixLabors.ImageSharp")]
        public async Task Pound_r_nuget_allows_duplicate_package_specifications_multiple_cells(Language language, string code)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#r ""nuget:SixLabors.ImageSharp,1.0.2"""
            );
            events.Should().NotContainErrors();

            await kernel.SubmitCodeAsync(
                @"
#r ""nuget:SixLabors.ImageSharp,1.0.2""
");

            await kernel.SubmitCodeAsync(code);

            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_disallows_package_specifications_with_different_versions_single_cell(Language language)
        {
            var kernel = CreateKernel(language);

            var results = await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget:SixLabors.ImageSharp, 1.0.1""
#r ""nuget:SixLabors.ImageSharp, 1.0.2""
");

            var events = results.KernelEvents.ToSubscribedList();

            events.Should()
                  .ContainSingle<CommandFailed>()
                  .Which
                  .Message
                  .Should()
                  .Be("SixLabors.ImageSharp version 1.0.2 cannot be added because version 1.0.1 was added previously.");

        }

        [Theory]
        [InlineData(Language.CSharp, "using SixLabors.ImageSharp;", "*The type or namespace name 'SixLabors' could not be found*")]
        [InlineData(Language.FSharp, "open SixLabors.ImageSharp", "*The namespace or module 'SixLabors' is not defined.")]
        public async Task Pound_r_nuget_with_different_versions_in_a_single_cell_fails_package_restore(Language language, string code, string errorMessage)
        {
            var kernel = CreateKernel(language);

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget:SixLabors.ImageSharp, 1.0.1""
#r ""nuget:SixLabors.ImageSharp, 1.0.2""
");

            var results = await kernel.SubmitCodeAsync(code);

            var events = results.KernelEvents.ToSubscribedList();
            events.Should()
                .ContainSingle<CommandFailed>()
                .Which
                .Message
                .Should()
                .Match(errorMessage);
        }

        [Theory]
        [InlineData(Language.CSharp, "using SixLabors.ImageSharp;")]
        [InlineData(Language.FSharp, "open SixLabors.ImageSharp")]
        public async Task Pound_r_nuget_disallows_package_specifications_with_different_versions_multiple_cells(Language language, string code)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(
                @"
#!time
#r ""nuget:SixLabors.ImageSharp, 1.0.1""
");
            events.Should().NotContainErrors();

            await kernel.SubmitCodeAsync(
                @"
#!time
#r ""nuget:SixLabors.ImageSharp, 1.0.2""
");

            await kernel.SubmitCodeAsync(code);

            events.Should()
                  .ContainSingle<CommandFailed>()
                  .Which
                  .Message
                  .Should()
                  .Be("SixLabors.ImageSharp version 1.0.2 cannot be added because version 1.0.1 was added previously.");
        }

        [Theory]
        [InlineData(Language.CSharp, Language.FSharp)]
        [InlineData(Language.FSharp, Language.CSharp)]
        public async Task cell_with_nuget_and_code_continues_executions_on_right_kernel(Language first, Language second)
        {
            var csk =
                    new CSharpKernel()
                        .UseNugetDirective()
                        .UseKernelHelpers()
                        .UseWho()
                        .LogEventsToPocketLogger();
            var fsk =
                    new FSharpKernel()
                        .UseDefaultFormatting()
                        .UseKernelHelpers()
                        .UseWho()
                        .LogEventsToPocketLogger();

            using var kernel =
                new CompositeKernel
                    {
                        first switch { Language.CSharp => csk, Language.FSharp => fsk },
                        second switch { Language.CSharp => csk, Language.FSharp => fsk }
                    }
                    .UseDefaultMagicCommands();

            kernel.DefaultKernelName = "csharp";

            var events = kernel.KernelEvents.ToSubscribedList();

            var command = new SubmitCode(@"#r ""nuget:Octokit, 0.50.0""
#r ""nuget:NodaTime, 3.1.0""

using Octokit;
using NodaTime;
using NodaTime.Extensions;");

            await kernel.SendAsync(command, CancellationToken.None);

            events.Should().NotContainErrors();

            events
                .Should()
                .ContainSingle<CommandSucceeded>(ch => ch.Command == command);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_disallows_changing_version_of_loaded_dependent_packages(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget:Microsoft.ML, 1.7.1""
#r ""nuget:Microsoft.ML.AutoML, 0.19.1""
#r ""nuget:Microsoft.Data.Analysis, 0.19.1""
");
            events.Should().NotContainErrors();

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget: Google.Protobuf, 3.10.1""
");

            events.Should()
                  .ContainSingle<CommandFailed>()
                  .Which
                  .Message
                  .Should()
                  .Be("Google.Protobuf version 3.10.1 cannot be added because version 3.19.4 was added previously.");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_allows_using_version_of_loaded_dependent_packages(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget:Microsoft.ML, 1.7.1""
#r ""nuget:Microsoft.ML.AutoML, 0.19.1""
#r ""nuget:Microsoft.Data.Analysis, 0.19.1""
");
            events.Should().NotContainErrors();

            await kernel.SubmitCodeAsync(@"
#!time
#r ""nuget: Google.Protobuf, 3.19.4""
");
            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp, "using System.Text.Json;")]
        [InlineData(Language.FSharp, "open System.Text.Json")]
        public async Task Pound_r_nuget_with_System_Text_Json_should_succeed(Language language, string code)
        {
            var kernel = CreateKernel(language);

            var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#r ""nuget:System.Text.Json, 6.0.0""
");

            await kernel.SubmitCodeAsync(code);
            // It should work, no errors, System.Text.Json is part of the shared framework
            events.Should().NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_with_no_version_should_not_get_the_oldest_package_version(Language language)
        {
            // #r "nuget: with no version specified should get the newest version of the package not the oldest:
            // For test purposes we evaluate the retrieved package is not the oldest version, since the newest may change over time.
            var kernel = CreateKernel(language);

            var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"
#r ""nuget:System.Text.Json""
");
            // It should work, no errors and the latest requested package should be added
            events.Should()
                  .NotContainErrors();

            events.OfType<PackageAdded>()
                  .Should()
                  .ContainSingle(e => e.PackageReference.PackageName == "System.Text.Json" &&
                                      e.PackageReference.PackageVersion != "5.0.2");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_with_no_version_displays_the_version_that_was_installed(Language language)
        {
            var expectedList = new[]
            {
                "Its.Log, 2.10.1"
            };

            var kernel = CreateKernel(language);
            using var events = kernel.KernelEvents.ToSubscribedList();
            await kernel.SubmitCodeAsync(@"#r ""nuget:Its.Log""");

            events.Should().NotContainErrors();

            events.OfType<DisplayedValueUpdated>()
                  .Where(v => v.Value is InstallPackagesMessage)
                  .Last().Value
                  .As<InstallPackagesMessage>()
                  .InstalledPackages
                  .Aggregate((p, acc) => acc + " & " + p)
                  .Should()
                  .ContainAll(expectedList);

            events.OfType<PackageAdded>()
                  .Should()
                  .ContainSingle(e => e.PackageReference.PackageName == "Its.Log" &&
                                      e.PackageReference.PackageVersion == "2.10.1");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_does_not_repeat_notifications_for_previous_r_nuget_submissions(Language language)
        {
            var kernel = CreateKernel(language);

            await kernel.SubmitCodeAsync(@"#r ""nuget:Its.Log""");

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync(@"#r ""nuget:System.Text.Json""");

            events.Should().NotContainErrors();

            events.Should()
                  .NotContain(e =>
                                  e is DisplayedValueUpdated &&
                                  e.As<DisplayedValueUpdated>()
                                   .Value.ToString()
                                   .StartsWith("Installing package Its.Log"));
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_does_not_accept_invalid_keys(Language language)
        {
            var kernel = CreateKernel(language);

            using var events = kernel.KernelEvents.ToSubscribedList();

            // nugt is an invalid provider key should fail
            await kernel.SubmitCodeAsync(@"#r ""nugt:System.Text.Json""");

            events.Should()
                 .ContainSingle<DiagnosticsProduced>(d => d.Diagnostics.Count > 0)
                 .Which
                 .FormattedDiagnostics
                 .Should()
                 .ContainSingle(fv => true)
                 .Which
                 .Value
                 .Should()
                 .ContainAll(
                    // C# and F# should both fail, but the messages will be different because they handle it differently internally.
                    language switch
                    {
                        Language.CSharp => new[] { "CS0006", "nugt:System.Text.Json" },
                        Language.FSharp => new[] { "interactive error", "nugt" }
                    }
                );
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task When_restore_fails_then_an_error_is_displayed(Language language)
        {
            var kernel = CreateKernel(language);

            var nonexistentPackageName = Guid.NewGuid().ToString("N");

            using var events = kernel.KernelEvents.ToSubscribedList();

            await kernel.SubmitCodeAsync($"#r nuget:{nonexistentPackageName},1.0.0");

            events.Should()
                  .ContainSingle<CommandFailed>()
                  .Which
                  .Message
                  .Should()
                  .Contain($"error NU1101:", nonexistentPackageName);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task it_can_load_assembly_referenced_from_refs_folder_in_nuget_package(Language language)
        {
            var kernel = CreateKernel(language);

            var source = language switch
            {
                Language.FSharp => @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""

open System
open System.Numerics.Tensors
let inputValues = [| 12.0; 10.0; 17.0; 5.0 |]
let tInput = new DenseTensor<float>(inputValues.AsMemory(), new ReadOnlySpan<int>([|4|]))
tInput.Length
",
                Language.CSharp => @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""

using System;
using System.Numerics.Tensors;
var inputValues = new[] { 12f, 10f, 17f, 5f };
var tInput = new DenseTensor<float>(inputValues.AsMemory(), new ReadOnlySpan<int>(new[] { 4 }));
tInput.Length"
            };

            await SubmitCode(kernel, source);

            KernelEvents
                .Should()
                .ContainSingle<ReturnValueProduced>()
                .Which
                .Value
                .Should()
                .Be(4);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task it_can_load_platform_specific_assembly_in_nugetpackage(Language language)
        {
            var kernel = CreateKernel(language);

            var source = language switch
            {
                Language.FSharp => @"
#r ""nuget:System.Device.Gpio,1.0.0""
typeof<System.Device.Gpio.GpioController>.Assembly.Location
",
                Language.CSharp => @"
#r ""nuget:System.Device.Gpio,1.0.0""
typeof(System.Device.Gpio.GpioController).Assembly.Location
"
            };

            await SubmitCode(kernel, source);

            // Because this is platform specific there are platform specific results
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                KernelEvents
                    .Should()
                    .ContainSingle<ReturnValueProduced>()
                    .Which
                    .Value
                    .As<string>()
                    .EndsWith(@"runtimes\win\lib\netstandard2.0\System.Device.Gpio.dll")
                    .Should()
                    .Be(true);
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                KernelEvents
                    .Should()
                    .ContainSingle<ReturnValueProduced>()
                    .Which
                    .Value
                    .As<string>()
                    .EndsWith(@"runtimes/linux/lib/netstandard2.0/System.Device.Gpio.dll")
                    .Should()
                    .Be(true);
            }
            // (OSPlatform.OSX is not supported by this library
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        [InlineData(Language.PowerShell)]
        public async Task Pound_r_nuget_works_immediately_after_a_language_selector(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var code = @"
#!csharp
#r ""nuget:Newtonsoft.Json,11.0.2""
";

            var command = new SubmitCode(code);

            using var events = kernel.KernelEvents.ToSubscribedList();

            var result = await kernel.SendAsync(command);

            events.Should().NotContainErrors();

            using var _ = new AssertionScope();

            events
                .Should()
                .ContainSingle<PackageAdded>()
                .Which
                .PackageReference
                .PackageName
                .Should()
                .Be("Newtonsoft.Json");

            kernel.FindKernelByName("csharp").As<CSharpKernel>()
                .ResolvedPackageReferences
                .Should()
                .ContainSingle(p => p.PackageName == "Newtonsoft.Json");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_display_only_requested_packages_for_first_submission(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var code = @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""
";

            var command = new SubmitCode(code);

            using var events = kernel.KernelEvents.ToSubscribedList();
            var result = await kernel.SendAsync(command);

            using var _ = new AssertionScope();

            var expectedDisplayed = new[]
            {
                "Microsoft.ML.OnnxTransformer, 1.4.0"
            };

            events.OfType<DisplayedValueUpdated>()
                  .Where(v => v.Value is InstallPackagesMessage)
                  .Last().Value
                  .As<InstallPackagesMessage>()
                  .InstalledPackages
                  .Should()
                  .BeEquivalentTo(expectedDisplayed);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_display_only_requested_packages_for_subsequent_submission(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""
";
            var command1 = new SubmitCode(codeFirstSubmission);
            var _result1 = await kernel.SendAsync(command1);

            var codeSecondSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.1""
";
            var command2 = new SubmitCode(codeSecondSubmission);

            using var events = kernel.KernelEvents.ToSubscribedList();
            var result2 = await kernel.SendAsync(command2);

            using var _ = new AssertionScope();

            var expected = new[]
            {
                "google.protobuf, 3.5.1"
            };

            events.OfType<DisplayedValueUpdated>()
                  .Where(v => v.Value is InstallPackagesMessage)
                  .Last().Value
                  .As<InstallPackagesMessage>()
                  .InstalledPackages
                  .Should()
                  .BeEquivalentTo(expected);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_display_only_requested_packages_for_third_submission(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""
";
            var command1 = new SubmitCode(codeFirstSubmission);
            var _result1 = await kernel.SendAsync(command1);

            var codeSecondSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.1""
";
            var command2 = new SubmitCode(codeSecondSubmission);
            var result2 = await kernel.SendAsync(command2);

            var codeThirdSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.1""
#r ""nuget:Microsoft.ML.OnnxTransformer, 1.4.0""
";
            var command3 = new SubmitCode(codeThirdSubmission);

            using var events = kernel.KernelEvents.ToSubscribedList();
            var result3 = await kernel.SendAsync(command3);

            using var _ = new AssertionScope();

            var expectedDisplayed = new[]
            {
                "google.protobuf, 3.5.1",
                "Microsoft.ML.OnnxTransformer, 1.4.0"
            };

            events.OfType<DisplayedValueUpdated>()
                  .Where(v => v.Value is InstallPackagesMessage)
                  .Last().Value
                  .As<InstallPackagesMessage>()
                  .InstalledPackages
                  .Should()
                  .BeEquivalentTo(expectedDisplayed);
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_error_when_trying_to_specify_a_different_version_of_an_already_loaded_package(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Microsoft.ML.OnnxTransformer,1.4.0""
";
            var command1 = new SubmitCode(codeFirstSubmission);
            var _result1 = await kernel.SendAsync(command1);

            var codeSecondSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.0""
";
            var command2 = new SubmitCode(codeSecondSubmission);

            using var events = kernel.KernelEvents.ToSubscribedList();
            var result2 = await kernel.SendAsync(command2);

            using var _ = new AssertionScope();

            events
                .Should()
                .ContainSingle<CommandFailed>()
                .Which
                .Message
                .Should()
                .Be("Google.Protobuf version 3.5.0 cannot be added because version 3.5.1 was added previously.");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_error_when_trying_to_specify_a_different_version_of_an_already_specified_package(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.0""
#r ""nuget:Google.Protobuf, 3.5.1""
";
            var command = new SubmitCode(codeFirstSubmission);

            using var events = kernel.KernelEvents.ToSubscribedList();
            var result = await kernel.SendAsync(command);

            using var _ = new AssertionScope();

            events
                .Should()
                .ContainSingle<CommandFailed>()
                .Which
                .Message
                .Should()
                .Be("Google.Protobuf version 3.5.1 cannot be added because version 3.5.0 was added previously.");
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should_not_error_when_trying_to_load_again_same_package_with_wildcard(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Google.Protobuf, *-*""
";


            await kernel.SendAsync(new SubmitCode(codeFirstSubmission));


            var codeSecondSubmission = @"
#r ""nuget:Google.Protobuf, *-*""
";

            var result = await kernel.SendAsync(new SubmitCode(codeSecondSubmission));
            using var events = result.KernelEvents.ToSubscribedList();

            using var _ = new AssertionScope();

            events
                .Should()
                .NotContainErrors();
        }

        [Theory]
        [InlineData(Language.CSharp)]
        [InlineData(Language.FSharp)]
        public async Task Pound_r_nuget_should__trying_to_load_again_same_package_with_wildcard_after_loading_a_specific_version_reuses_the_previously_resolved(Language defaultLanguageKernel)
        {
            var kernel = CreateCompositeKernel(defaultLanguageKernel);

            var codeFirstSubmission = @"
#r ""nuget:Google.Protobuf, 3.5.1""
";


            await kernel.SendAsync(new SubmitCode(codeFirstSubmission));


            var codeSecondSubmission = @"
#r ""nuget:Google.Protobuf, *-*""
";

            var result = await kernel.SendAsync(new SubmitCode(codeSecondSubmission));
            using var events = result.KernelEvents.ToSubscribedList();

            using var _ = new AssertionScope();

            var expectedDisplayed = new[]
            {
                "Google.Protobuf, 3.5.1"
            };

            events.OfType<DisplayedValueUpdated>()
                .Where(v => v.Value is InstallPackagesMessage)
                .Last().Value
                .As<InstallPackagesMessage>()
                .InstalledPackages
                .Should()
                .BeEquivalentTo(expectedDisplayed);
        }
    }
}