All WasmBuildTests use static project from assets or dotnet new, unification of browser tests

src/mono/wasm/Wasm.Build.Tests/Common/SharedBuildPerTestClassFixture.cs → src/mono/wasi/Wasi.Build.Tests/SharedBuildPerTestClassFixture.cs

@@ -9,6 +9,7 @@
 
 #nullable enable
 
+// ToDo: should be common with Wasm.Build.Tests, copied here after Wasm.Build.Tests refactoring
 namespace Wasm.Build.Tests
 {
     public class SharedBuildPerTestClassFixture : IDisposable

src/mono/wasm/Wasm.Build.Tests/Blazor/AppsettingsTests.cs

@@ -18,44 +18,44 @@ public AppsettingsTests(ITestOutputHelper output, SharedBuildPerTestClassFixture
         _enablePerTestCleanup = true;
     }
 
-    [Fact]
-    public async Task FileInVfs()
-    {
-        string id = $"blazor_{GetRandomId()}";
-        string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
-
-        string projectDirectory = Path.GetDirectoryName(projectFile)!;
-
-        File.WriteAllText(Path.Combine(projectDirectory, "wwwroot", "appsettings.json"), $"{{ \"Id\": \"{id}\" }}");
-
-        string programPath = Path.Combine(projectDirectory, "Program.cs");
-        string programContent = File.ReadAllText(programPath);
-        programContent = programContent.Replace("var builder",
-        """
-        System.Console.WriteLine($"appSettings Exists '{File.Exists("/appsettings.json")}'");
-        System.Console.WriteLine($"appSettings Content '{File.ReadAllText("/appsettings.json")}'");
-        var builder
-        """);
-        File.WriteAllText(programPath, programContent);
-
-        BlazorBuild(new BlazorBuildOptions(id, "debug", NativeFilesType.FromRuntimePack));
-
-        bool existsChecked = false;
-        bool contentChecked = false;
-
-        await BlazorRunForBuildWithDotnetRun(new BlazorRunOptions()
-        {
-            Config = "debug",
-            OnConsoleMessage = (_, msg) =>
-            {
-                if (msg.Text.Contains("appSettings Exists 'True'"))
-                    existsChecked = true;
-                else if (msg.Text.Contains($"appSettings Content '{{ \"Id\": \"{id}\" }}'"))
-                    contentChecked = true;
-            }
-        });
-
-        Assert.True(existsChecked, "File '/appsettings.json' wasn't found");
-        Assert.True(contentChecked, "Content of '/appsettings.json' is not matched");
-    }
+    // [Fact]
+    // public async Task FileInVfs()
+    // {
+    //     string id = $"blazor_{GetRandomId()}";
+    //     string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
+
+    //     string projectDirectory = Path.GetDirectoryName(projectFile)!;
+
+    //     File.WriteAllText(Path.Combine(projectDirectory, "wwwroot", "appsettings.json"), $"{{ \"Id\": \"{id}\" }}");
+
+    //     string programPath = Path.Combine(projectDirectory, "Program.cs");
+    //     string programContent = File.ReadAllText(programPath);
+    //     programContent = programContent.Replace("var builder",
+    //     """
+    //     System.Console.WriteLine($"appSettings Exists '{File.Exists("/appsettings.json")}'");
+    //     System.Console.WriteLine($"appSettings Content '{File.ReadAllText("/appsettings.json")}'");
+    //     var builder
+    //     """);
+    //     File.WriteAllText(programPath, programContent);
+
+    //     BlazorBuild(new BuildProjectOptions(id, "debug", NativeFilesType.FromRuntimePack));
+
+    //     bool existsChecked = false;
+    //     bool contentChecked = false;
+
+    //     await BlazorRunForBuildWithDotnetRun(new RunOptions()
+    //     {
+    //         Configuration = "debug",
+    //         OnConsoleMessage = (_, msg) =>
+    //         {
+    //             if (msg.Text.Contains("appSettings Exists 'True'"))
+    //                 existsChecked = true;
+    //             else if (msg.Text.Contains($"appSettings Content '{{ \"Id\": \"{id}\" }}'"))
+    //                 contentChecked = true;
+    //         }
+    //     });
+
+    //     Assert.True(existsChecked, "File '/appsettings.json' wasn't found");
+    //     Assert.True(contentChecked, "Content of '/appsettings.json' is not matched");
+    // }
 }

src/mono/wasm/Wasm.Build.Tests/Blazor/BlazorWasmTestBase.cs

@@ -17,11 +17,11 @@ namespace Wasm.Build.Tests;
 
 public abstract class BlazorWasmTestBase : WasmTemplateTestsBase
 {
-    protected readonly BlazorWasmProjectProvider _provider;
+    protected readonly WasmSdkBasedProjectProvider _provider;
     protected BlazorWasmTestBase(ITestOutputHelper output, SharedBuildPerTestClassFixture buildContext)
-                : base(output, buildContext, new BlazorWasmProjectProvider(output, DefaultTargetFrameworkForBlazor))
+                : base(output, buildContext, new WasmSdkBasedProjectProvider(output, DefaultTargetFrameworkForBlazor))
     {
-        _provider = GetProvider<BlazorWasmProjectProvider>();
+        _provider = GetProvider<WasmSdkBasedProjectProvider>();
     }
 
     public void InitBlazorWasmProjectDir(string id, string targetFramework = DefaultTargetFrameworkForBlazor)
@@ -54,12 +54,17 @@ public string CreateBlazorWasmTemplateProject(string id)
         return Path.Combine(_projectDir!, $"{id}.csproj");
     }
 
-    protected (CommandResult, string) BlazorBuild(BlazorBuildOptions options, params string[] extraArgs)
+    protected (CommandResult, string) BlazorBuild(BuildProjectOptions options, params string[] extraArgs)
     {
         if (options.WarnAsError)
             extraArgs = extraArgs.Append("/warnaserror").ToArray();
 
-        (CommandResult res, string logPath) = BlazorBuildInternal(options.Id, options.Config, publish: false, setWasmDevel: false, expectSuccess: options.ExpectSuccess, extraArgs);
+        (CommandResult res, string logPath) = BlazorBuildInternal(
+            options.Id,
+            options.Configuration,
+            setWasmDevel: false,
+            expectSuccess: options.ExpectSuccess,
+            extraArgs: extraArgs);
 
         if (options.ExpectSuccess && options.AssertAppBundle)
         {
@@ -69,17 +74,17 @@ public string CreateBlazorWasmTemplateProject(string id)
         return (res, logPath);
     }
 
-    protected (CommandResult, string) BlazorPublish(BlazorBuildOptions options, params string[] extraArgs)
+    protected (CommandResult, string) BlazorPublish(BuildProjectOptions options, params string[] extraArgs)
     {
         if (options.WarnAsError)
             extraArgs = extraArgs.Append("/warnaserror").ToArray();
 
-        (CommandResult res, string logPath) = BlazorBuildInternal(options.Id, options.Config, publish: true, setWasmDevel: false, expectSuccess: options.ExpectSuccess, extraArgs);
+        (CommandResult res, string logPath) = BlazorBuildInternal(options.Id, options.Configuration, publish: true, setWasmDevel: false, expectSuccess: options.ExpectSuccess, extraArgs);
 
         if (options.ExpectSuccess && options.AssertAppBundle)
         {
             // Because we do relink in Release publish by default
-            if (options.Config == "Release")
+            if (options.Configuration == "Release")
                 options = options with { ExpectedFileType = NativeFilesType.Relinked };
 
             AssertBundle(res.Output, options with { IsPublish = true });
@@ -99,9 +104,13 @@ public string CreateBlazorWasmTemplateProject(string id)
         try
         {
             return BuildProjectWithoutAssert(
-                        id,
-                        config,
-                        new BuildProjectOptions(CreateProject: false, UseCache: false, Publish: publish, ExpectSuccess: expectSuccess),
+                        new BuildProjectOptions(
+                            id,
+                            config,
+                            GetBlazorBinFrameworkDir(config, forPublish: publish),
+                            UseCache: false,
+                            IsPublish: publish,
+                            ExpectSuccess: expectSuccess),
                         extraArgs.Concat(new[]
                         {
                             "-p:BlazorEnableCompression=false",
@@ -116,22 +125,22 @@ public string CreateBlazorWasmTemplateProject(string id)
         }
     }
 
-    public void AssertBundle(string buildOutput, BlazorBuildOptions blazorBuildOptions)
+    public void AssertBundle(string buildOutput, BuildProjectOptions buildOptions)
     {
         if (IsUsingWorkloads)
         {
             // In no-workload case, the path would be from a restored nuget
-            ProjectProviderBase.AssertRuntimePackPath(buildOutput, blazorBuildOptions.TargetFramework ?? DefaultTargetFramework, blazorBuildOptions.RuntimeType);
+            ProjectProviderBase.AssertRuntimePackPath(buildOutput, buildOptions.TargetFramework ?? DefaultTargetFramework, buildOptions.RuntimeType);
         }
 
-        _provider.AssertBundle(blazorBuildOptions);
+        _provider.AssertBundle(buildOptions);
 
-        if (!blazorBuildOptions.IsPublish)
+        if (!buildOptions.IsPublish)
             return;
 
         // Publish specific checks
 
-        if (blazorBuildOptions.ExpectedFileType == NativeFilesType.AOT)
+        if (buildOptions.ExpectedFileType == NativeFilesType.AOT)
         {
             // check for this too, so we know the format is correct for the negative
             // test for jsinterop.webassembly.dll
@@ -141,9 +150,9 @@ public void AssertBundle(string buildOutput, BlazorBuildOptions blazorBuildOptio
             Assert.DoesNotContain("Microsoft.JSInterop.WebAssembly.dll -> Microsoft.JSInterop.WebAssembly.dll.bc", buildOutput);
         }
 
-        string objBuildDir = Path.Combine(_projectDir!, "obj", blazorBuildOptions.Config, blazorBuildOptions.TargetFramework!, "wasm", "for-build");
+        string objBuildDir = Path.Combine(_projectDir!, "obj", buildOptions.Configuration, buildOptions.TargetFramework!, "wasm", "for-build");
         // Check that we linked only for publish
-        if (blazorBuildOptions.ExpectRelinkDirWhenPublishing)
+        if (buildOptions.ExpectRelinkDirWhenPublishing)
             Assert.True(Directory.Exists(objBuildDir), $"Could not find expected {objBuildDir}, which gets created when relinking during Build. This is likely a test authoring error");
         else
             Assert.False(File.Exists(Path.Combine(objBuildDir, "emcc-link.rsp")), $"Found unexpected `emcc-link.rsp` in {objBuildDir}, which gets created when relinking during Build.");
@@ -165,88 +174,45 @@ protected string CreateProjectWithNativeReference(string id)
 
     // Keeping these methods with explicit Build/Publish in the name
     // so in the test code it is evident which is being run!
-    public Task BlazorRunForBuildWithDotnetRun(BlazorRunOptions runOptions)
-        => BlazorRunTest(runOptions with { Host = BlazorRunHost.DotnetRun });
+    public async Task<RunResult> BlazorRunForBuildWithDotnetRun(RunOptions runOptions)
+        => await BlazorRunTest(runOptions with { Host = RunHost.DotnetRun });
 
-    public Task BlazorRunForPublishWithWebServer(BlazorRunOptions runOptions)
-        => BlazorRunTest(runOptions with { Host = BlazorRunHost.WebServer });
+    public async Task<RunResult> BlazorRunForPublishWithWebServer(RunOptions runOptions)
+        => await BlazorRunTest(runOptions with { Host = RunHost.WebServer });
 
-    public Task BlazorRunTest(BlazorRunOptions runOptions) => runOptions.Host switch
+    public async Task<RunResult> BlazorRunTest(RunOptions runOptions)
     {
-        BlazorRunHost.DotnetRun =>
-                BlazorRunTest($"run -c {runOptions.Config} --no-build", _projectDir!, runOptions),
-
-        BlazorRunHost.WebServer =>
-                BlazorRunTest($"{s_xharnessRunnerCommand} wasm webserver --app=. --web-server-use-default-files",
-                     Path.GetFullPath(Path.Combine(FindBlazorBinFrameworkDir(runOptions.Config, forPublish: true), "..")),
-                     runOptions),
-
-        _ => throw new NotImplementedException(runOptions.Host.ToString())
-    };
-
-    public async Task BlazorRunTest(string runArgs,
-                                    string workingDirectory,
-                                    BlazorRunOptions runOptions)
-    {
-        if (!string.IsNullOrEmpty(runOptions.ExtraArgs))
-            runArgs += $" {runOptions.ExtraArgs}";
-
-        runOptions.ServerEnvironment?.ToList().ForEach(
-            kv => s_buildEnv.EnvVars[kv.Key] = kv.Value);
-
-        using RunCommand runCommand = new RunCommand(s_buildEnv, _testOutput);
-        ToolCommand cmd = runCommand.WithWorkingDirectory(workingDirectory);
-
-        await using var runner = new BrowserRunner(_testOutput);
-        var page = await runner.RunAsync(
-            cmd,
-            runArgs,
-            onConsoleMessage: OnConsoleMessage,
-            onServerMessage: runOptions.OnServerMessage,
-            onError: OnErrorMessage,
-            modifyBrowserUrl: browserUrl => new Uri(new Uri(browserUrl), runOptions.BrowserPath + runOptions.QueryString).ToString());
-
-        _testOutput.WriteLine("Waiting for page to load");
-        await page.WaitForLoadStateAsync(LoadState.DOMContentLoaded, new () { Timeout = 1 * 60 * 1000 });
-
-        if (runOptions.CheckCounter)
+        if (runOptions.ExecuteAfterLoaded is null)
         {
-            await page.Locator("text=Counter").ClickAsync();
-            var txt = await page.Locator("p[role='status']").InnerHTMLAsync();
-            Assert.Equal("Current count: 0", txt);
-
-            await page.Locator("text=\"Click me\"").ClickAsync();
-            await Task.Delay(300);
-            txt = await page.Locator("p[role='status']").InnerHTMLAsync();
-            Assert.Equal("Current count: 1", txt);
+            runOptions = runOptions with { ExecuteAfterLoaded = async (runOptions, page) =>
+                {
+                    if (runOptions.CheckCounter)
+                    {
+                        await page.Locator("text=Counter").ClickAsync();
+                        var txt = await page.Locator("p[role='status']").InnerHTMLAsync();
+                        Assert.Equal("Current count: 0", txt);
+
+                        await page.Locator("text=\"Click me\"").ClickAsync();
+                        await Task.Delay(300);
+                        txt = await page.Locator("p[role='status']").InnerHTMLAsync();
+                        Assert.Equal("Current count: 1", txt);
+                    }
+                }
+            };
         }
-
-        if (runOptions.Test is not null)
-            await runOptions.Test(page);
-
-        _testOutput.WriteLine($"Waiting for additional 10secs to see if any errors are reported");
-        await Task.Delay(10_000);
-
-        void OnConsoleMessage(IPage page, IConsoleMessage msg)
-        {
-            _testOutput.WriteLine($"[{msg.Type}] {msg.Text}");
-
-            runOptions.OnConsoleMessage?.Invoke(page, msg);
-
-            if (runOptions.DetectRuntimeFailures)
-            {
-                if (msg.Text.Contains("[MONO] * Assertion") || msg.Text.Contains("Error: [MONO] "))
-                    throw new XunitException($"Detected a runtime failure at line: {msg.Text}");
-            }
-        }
-
-        void OnErrorMessage(string msg)
+        switch (runOptions.Host)
         {
-            _testOutput.WriteLine($"[ERROR] {msg}");
-            runOptions.OnErrorMessage?.Invoke(msg);
+            case RunHost.DotnetRun:
+                return await BrowserRunTest($"run -c {runOptions.Configuration} --no-build", _projectDir!, runOptions);
+            case RunHost.WebServer:
+                return await BrowserRunTest($"{s_xharnessRunnerCommand} wasm webserver --app=. --web-server-use-default-files",
+                    Path.GetFullPath(Path.Combine(GetBlazorBinFrameworkDir(runOptions.Configuration, forPublish: true), "..")),
+                    runOptions);
+            default:
+                throw new NotImplementedException(runOptions.Host.ToString());
         }
     }
 
-    public string FindBlazorBinFrameworkDir(string config, bool forPublish, string framework = DefaultTargetFrameworkForBlazor, string? projectDir = null)
-        => _provider.FindBinFrameworkDir(config: config, forPublish: forPublish, framework: framework, projectDir: projectDir);
+    public string GetBlazorBinFrameworkDir(string config, bool forPublish, string framework = DefaultTargetFrameworkForBlazor, string? projectDir = null)
+        => _provider.GetBinFrameworkDir(config: config, forPublish: forPublish, framework: framework, projectDir: projectDir);
 }