Setup Windows GH actions job

We cannot use the existing windows job setup because it launches a
docker container which we cannot open a VS Code window in to run
the tests as no tool like Xvfb exists for Windows

Fix up some tests that fail on windows (mostly related to path
separator mismatches)

Author: award999

.github/workflows/pull_request.yml

@@ -37,3 +37,30 @@ jobs:
         echo "$NODE_PATH" >> $GITHUB_PATH
       linux_build_command: ./docker/test.sh
       enable_windows_checks: false
+
+  tests-windows:
+    name: Windows (${{ matrix.swift_version }})
+    runs-on: ${{ contains(matrix.swift_version, 'nightly') && 'windows-2019' || 'windows-2022' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        swift_version: ['5.9', '5.10', '6.0', 'nightly', 'nightly-6.0']
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Create test script
+        run: |
+          mkdir $env:TEMP\test-script
+          echo 'Set-PSDebug -Trace 1' >> $env:TEMP\test-script\run.ps1
+          echo '$ErrorActionPreference = "Stop"' >> $env:TEMP\test-script\run.ps1
+          echo 'winget install --id Microsoft.VisualStudio.2022.Community --exact --force --custom "--add Microsoft.VisualStudio.Component.Windows11SDK.22000 --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64"' >> $env:TEMP\test-script\run.ps1
+          echo 'winget install --id Swift.Toolchain -e' >> $env:TEMP\test-script\run.ps1
+          echo 'winget install --id Schniz.fnm -e' >> $env:TEMP\test-script\run.ps1
+          echo 'fnm env --use-on-cd | Out-String | Invoke-Expression' >> $env:TEMP\test-script\run.ps1
+          echo 'fnm use --install-if-missing 18.19.0' >> $env:TEMP\test-script\run.ps1
+          echo 'refreshenv' >> $env:TEMP\test-script\run.ps1
+          echo 'swift --version' >> $env:TEMP\test-script\run.ps1
+          echo 'node --version' >> $env:TEMP\test-script\run.ps1
+          echo 'cd $env:GITHUB_WORKSPACE' >> $env:TEMP\test-script\run.ps1
+          echo 'docker\test-windows.ps1' >> $env:TEMP\test-script\run.ps1
+          powershell.exe -NoLogo -File $env:TEMP\test-script\run.ps1

docker/test-windows.ps1

@@ -0,0 +1,7 @@
+$env:CI = "1"
+$env:FAST_TEST_RUN = "1"
+npm ci -ignore-script node-pty
+npm run lint
+npm run format
+npm run package
+npm run integration-test

test/integration-tests/tasks/SwiftTaskProvider.test.ts

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import { expect } from "chai";
 import * as vscode from "vscode";
 import * as assert from "assert";
 import { WorkspaceContext } from "../../../src/WorkspaceContext";
@@ -41,7 +42,7 @@ suite("SwiftTaskProvider Test Suite", () => {
     suiteSetup(async () => {
         workspaceContext = await globalWorkspaceContextPromise;
         toolchain = workspaceContext.toolchain;
-        assert.notEqual(workspaceContext.folders.length, 0);
+        expect(workspaceContext.folders).to.not.have.lengthOf(0);
         workspaceFolder = workspaceContext.folders[0].workspaceFolder;
 
         // Make sure have another folder
@@ -61,10 +62,21 @@ suite("SwiftTaskProvider Test Suite", () => {
                 toolchain
             );
             const { exitCode } = await executeTaskAndWaitForResult(task);
-            assert.equal(exitCode, 0);
-        }).timeout(10000);
+            expect(exitCode).to.equal(0);
+        });
 
         test("Exit code on failure", async () => {
+            const task = createSwiftTask(
+                ["invalid_swift_command"],
+                "invalid",
+                { cwd: workspaceFolder.uri, scope: vscode.TaskScope.Workspace },
+                toolchain
+            );
+            const { exitCode } = await executeTaskAndWaitForResult(task);
+            expect(exitCode).to.equal(1);
+        });
+
+        test("Exit code on failure to launch", async () => {
             const task = createSwiftTask(
                 ["--help"],
                 "help",
@@ -82,8 +94,8 @@ suite("SwiftTaskProvider Test Suite", () => {
                 )
             );
             const { exitCode } = await executeTaskAndWaitForResult(task);
-            assert.equal(exitCode, 1);
-        }).timeout(10000);
+            expect(exitCode).to.not.equal(0);
+        });
     });
 
     suite("provideTasks", () => {
@@ -96,18 +108,17 @@ suite("SwiftTaskProvider Test Suite", () => {
             });
 
             test("provided", async () => {
-                assert.equal(
-                    task?.detail,
-                    "swift build --build-tests -Xswiftc -diagnostic-style=llvm"
-                );
+                expect(task?.detail)
+                    .to.include("swift build --build-tests")
+                    .and.to.include("-Xswiftc -diagnostic-style=llvm");
             });
 
             test("executes @slow", async () => {
                 assert(task);
                 const exitPromise = waitForEndTaskProcess(task);
                 await vscode.tasks.executeTask(task);
                 const exitCode = await exitPromise;
-                assert.equal(exitCode, 0);
+                expect(exitCode).to.equal(0);
             }).timeout(180000); // 3 minutes to build
         });
 
@@ -120,25 +131,24 @@ suite("SwiftTaskProvider Test Suite", () => {
             });
 
             test("provided", async () => {
-                assert.equal(task?.detail, "swift build --show-bin-path");
+                expect(task?.detail).to.include("swift build --show-bin-path");
             });
 
             test("executes", async () => {
                 assert(task);
                 const exitPromise = waitForEndTaskProcess(task);
                 await vscode.tasks.executeTask(task);
                 const exitCode = await exitPromise;
-                assert.equal(exitCode, 0);
+                expect(exitCode).to.equal(0);
             });
         });
 
         test("includes product debug task", async () => {
             const tasks = await vscode.tasks.fetchTasks({ type: "swift" });
             const task = tasks.find(t => t.name === "Build Debug PackageExe (defaultPackage)");
-            assert.equal(
-                task?.detail,
-                "swift build --product PackageExe -Xswiftc -diagnostic-style=llvm"
-            );
+            expect(task?.detail)
+                .to.include("swift build --product PackageExe")
+                .and.to.include("-Xswiftc -diagnostic-style=llvm");
         });
 
         test("includes product release task", async () => {
@@ -147,30 +157,23 @@ suite("SwiftTaskProvider Test Suite", () => {
                 new vscode.CancellationTokenSource().token
             );
             const task = tasks.find(t => t.name === "Build Release PackageExe (defaultPackage)");
-            assert.equal(
-                task?.detail,
-                "swift build -c release --product PackageExe -Xswiftc -diagnostic-style=llvm"
-            );
+            expect(task?.detail).to.include("swift build -c release --product PackageExe");
         });
 
         test("includes additional folders", async () => {
             const tasks = await vscode.tasks.fetchTasks({ type: "swift" });
             const diagnosticTasks = tasks.filter(t => t.name.endsWith("(diagnostics)"));
-            assert.equal(diagnosticTasks.length, 3);
+            expect(diagnosticTasks).to.have.lengthOf(3);
         });
     });
 
     suite("createBuildAllTask", () => {
         test("should return same task instance", async () => {
-            assert.strictEqual(
-                createBuildAllTask(folderContext),
-                createBuildAllTask(folderContext)
-            );
+            expect(createBuildAllTask(folderContext)).to.equal(createBuildAllTask(folderContext));
         });
 
         test("different task returned for release mode", async () => {
-            assert.notEqual(
-                createBuildAllTask(folderContext),
+            expect(createBuildAllTask(folderContext)).to.not.equal(
                 createBuildAllTask(folderContext, true)
             );
         });
@@ -181,8 +184,7 @@ suite("SwiftTaskProvider Test Suite", () => {
 
         test("creates build all task when it cannot find one", async () => {
             tasksMock.fetchTasks.resolves([]);
-            assert.strictEqual(
-                await getBuildAllTask(folderContext),
+            await expect(getBuildAllTask(folderContext)).to.eventually.equal(
                 createBuildAllTask(folderContext)
             );
         });