From f5e46c9bf2f50d66a953fa133161fc829cecff06 Mon Sep 17 00:00:00 2001
From: Matt Mastracci <matthew@mastracci.com>
Date: Sat, 10 Feb 2024 13:22:13 -0700
Subject: chore: move cli/tests/ -> tests/  (#22369)

This looks like a massive PR, but it's only a move from cli/tests ->
tests, and updates of relative paths for files.

This is the first step towards aggregate all of the integration test
files under tests/, which will lead to a set of integration tests that
can run without the CLI binary being built.

While we could leave these tests under `cli`, it would require us to
keep a more complex directory structure for the various test runners. In
addition, we have a lot of complexity to ignore various test files in
the `cli` project itself (cargo publish exclusion rules, autotests =
false, etc).

And finally, the `tests/` folder will eventually house the `test_ffi`,
`test_napi` and other testing code, reducing the size of the root repo
directory.

For easier review, the extremely large and noisy "move" is in the first
commit (with no changes -- just a move), while the remainder of the
changes to actual files is in the second commit.
---
 tests/testdata/assets/DenoWinRunner.cs | 127 +++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 tests/testdata/assets/DenoWinRunner.cs

(limited to 'tests/testdata/assets/DenoWinRunner.cs')

diff --git a/tests/testdata/assets/DenoWinRunner.cs b/tests/testdata/assets/DenoWinRunner.cs
new file mode 100644
index 000000000..2f9e9f89f
--- /dev/null
+++ b/tests/testdata/assets/DenoWinRunner.cs
@@ -0,0 +1,127 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+
+[Flags]
+public enum DenoConstraints : int
+{
+    None = 0,
+    NoStdin = 1,
+    NoStdout = 2,
+    NoStderr = 4
+}
+
+public class DenoWinRunner
+{
+    private const int STD_INPUT_HANDLE = -10;
+    private const int STD_OUTPUT_HANDLE = -11;
+    private const int STD_ERROR_HANDLE = -12;
+
+    private const int FILE_NOT_FOUND = 2;
+    private const int WAIT_TIMEOUT = 258;
+
+    [DllImport("kernel32.dll")]
+    private static extern void SetStdHandle(int nStdHandle, IntPtr handle);
+
+    /// <summary>
+    /// Runs Deno.exe under the specified constraints
+    /// </summary>
+    /// <param name="pathToDenoExe">Path to the Deno.exe file. Can be absolute or relative</param>
+    /// <param name="pathToTestScript">Path to the script file Deno should run.</param>
+    /// <param name="constraints">The constraints to apply to the Deno process</param>
+    /// <param name="timeoutMilliseconds">How long to wait for the Deno process to exit</param>
+    /// <returns>The deno.exe exit code, or an exit code provided by the test runner</returns>
+    public static int RunDenoScript(string pathToDenoExe, string pathToTestScript, DenoConstraints constraints, uint timeoutMilliseconds = 1000)
+    {
+        try
+        {
+            if (!File.Exists(pathToDenoExe))
+            {
+                Console.Error.WriteLine("Cannot find Deno.exe at " + pathToDenoExe);
+                return FILE_NOT_FOUND;
+            }
+
+            if (!File.Exists(pathToTestScript))
+            {
+                Console.Error.WriteLine("Cannot find test script at " + pathToTestScript);
+                return FILE_NOT_FOUND;
+            }
+
+            ProcessStartInfo startInfo = new ProcessStartInfo(pathToDenoExe)
+            {
+                ErrorDialog = false,
+                UseShellExecute = false,
+                Arguments = @"run -A " + pathToTestScript,
+                RedirectStandardInput = !constraints.HasFlag(DenoConstraints.NoStdin),
+                RedirectStandardOutput = !constraints.HasFlag(DenoConstraints.NoStdout),
+                RedirectStandardError = !constraints.HasFlag(DenoConstraints.NoStderr)
+            };
+
+            startInfo.Environment.Add("RUST_BACKTRACE", "1");
+
+            if (constraints.HasFlag(DenoConstraints.NoStdin))
+            {
+                SetStdHandle(STD_INPUT_HANDLE, (IntPtr)null);
+            }
+
+            if (constraints.HasFlag(DenoConstraints.NoStdout))
+            {
+                SetStdHandle(STD_OUTPUT_HANDLE, (IntPtr)null);
+            }
+
+            if (constraints.HasFlag(DenoConstraints.NoStderr))
+            {
+                SetStdHandle(STD_ERROR_HANDLE, (IntPtr)null);
+            }
+
+            Process process = new Process { StartInfo = startInfo };
+            process.Start();
+
+            Task<string> stdErrTask = startInfo.RedirectStandardError ?
+                process.StandardError.ReadToEndAsync() : Task.FromResult<string>(null);
+            Task<string> stdOutTask = startInfo.RedirectStandardOutput ?
+                process.StandardOutput.ReadToEndAsync() : Task.FromResult<string>(null);
+
+            if (!process.WaitForExit((int)timeoutMilliseconds))
+            {
+                Console.Error.WriteLine("Timed out waiting for Deno process to exit");
+                try
+                {
+                    process.Kill();
+                }
+                catch
+                {
+                    // Kill might fail, either because the process already exited or due to some other error
+                    Console.Error.WriteLine("Failure killing the Deno process - possible Zombie Deno.exe process");
+                }
+                return WAIT_TIMEOUT;
+            }
+
+            // If the Deno process wrote to STDERR - append it to our STDERR
+            if (!constraints.HasFlag(DenoConstraints.NoStderr))
+            {
+                string error = stdErrTask.Result;
+                if (!string.IsNullOrWhiteSpace(error))
+                {
+                    Console.Error.WriteLine(error);
+                }
+            }
+
+            return process.ExitCode;
+
+        }
+        catch (Win32Exception ex)
+        {
+            Console.Error.WriteLine("Win32Exception: code = " + ex.ErrorCode + ", message: " + ex.Message);
+            return ex.NativeErrorCode;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine("Exception: message: " + ex.Message);
+            return -1;
+        }
+    }
+}
-- 
cgit v1.2.3