bugfix: Lute tests on windows machines

Author: Vighnesh-V

.github/workflows/ci.yml

@@ -5,6 +5,7 @@ on:
     branches: ["primary"]
   pull_request:
     branches: ["primary"]
+  workflow_dispatch:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -43,7 +44,8 @@ jobs:
         run: rm .luaurc
 
       - name: Run Luau Tests
-        run: find tests -name "*.test.luau" | xargs -I {} ${{ steps.build_lute.outputs.exe_path }} run {}
+        shell: bash
+        run: find tests -name "*.test.luau" | xargs -I {} $(echo '${{ steps.build_lute.outputs.exe_path }}' | tr '\\' '/') run {}
 
   run-lute-cxx-unittests:
     runs-on: ${{ matrix.os }}

lute/fs/src/fs.cpp

@@ -727,12 +727,14 @@ int type(lua_State* L)
 
     if (err)
     {
+        printf("ARE WE ERRORING INSIDE OF type?? - reason [%s]\n", uv_strerror(err));
         uv_fs_req_cleanup(&req);
         luaL_errorL(L, "%s", uv_strerror(err));
     }
 
     auto type = fileModeToType(req.statbuf.st_mode);
     lua_pushstring(L, type);
+    printf("%s\n", type);
     uv_fs_req_cleanup(&req);
 
     return 1;

lute/std/libs/fs.luau

@@ -92,7 +92,7 @@ end
 function fslib.createdirectory(path: pathlike, options: createdirectoryoptions?): ()
 	if options and options.makeparents then
 		local parts: { string } = pathlib.parse(path).parts
-
+		
 		local subdir: pathlike = "."
 		if pathlib.isabsolute(path) then
 			subdir = pathlib.format({ absolute = true, parts = {} })

lute/std/libs/path/win32/init.luau

@@ -59,6 +59,24 @@ function win32.extname(path: pathlike): string
 	return filename:sub(dotIndex)
 end
 
+function win32.getdrive(path: pathlike): path
+	if typeof(path) == "string" then
+		path = win32.parse(path)
+	end
+
+	path = path :: path
+
+	if path.driveLetter == nil then
+		error("Path does not have a drive letter: " .. win32.format(path))
+	end
+
+	return setmetatable({
+		parts = {},
+		kind = "absolute",
+		driveLetter = path.driveLetter,
+	}, path_mt)
+end
+
 function win32.format(path: pathlike): string
 	if typeof(path) == "string" then
 		return path

tests/cli/compile.test.luau

@@ -23,8 +23,8 @@ local COMPILEE_CONTENTS = [[return "Hello world"]]
 local lutePath = process.execpath()
 local tmpDir = system.tmpdir()
 
-test.suite("Lute CLI Compile", function(suite)
-	suite:case("Run compile", function(check)
+test.suite("stdlib_compile", function(suite)
+	suite:case("run_in_script_bytecode_compilation", function(check)
 		-- Setup
 		-- Create files
 		local compilerPath = path.join(tmpDir, "compiler.luau")
@@ -39,8 +39,9 @@ test.suite("Lute CLI Compile", function(suite)
 
 		local result = process.run({ path.format(lutePath), path.format(compilerPath), path.format(compileePath) })
 		-- Compilation should work with no memory leaks
+		local expectedNewline = system.os == "Windows_NT" and "\r\n" or "\n"
 		check.eq(result.stderr, "")
-		check.eq(result.stdout, "SUCCESS\n")
+		check.eq(result.stdout, "SUCCESS" .. expectedNewline)
 		check.eq(result.exitcode, 0)
 
 		-- -- Cleanup

tests/cli/loadbypath.test.luau

@@ -43,7 +43,8 @@ test.suite("Lute CLI Run", function(suite)
 
 		local result = process.run({ tostring(lutePath), requirerPath, requireePath })
 		check.eq(result.exitcode, 0)
-		check.eq(result.stdout, "Success\n")
+		local expectedNewline = if system.win32 then "\r\n" else "\n"
+		check.eq(result.stdout, "Success" .. expectedNewline)
 
 		-- Cleanup
 		fs.remove(requirerPath)

tests/std/.#fs.test.luau

@@ -0,0 +1 @@
+vvijay@HQ-VHWFGJQN04.23020

tests/std/fs.test.luau

@@ -47,11 +47,12 @@ test.suite("FsSuite", function(suite)
 	end)
 
 	suite:case("mkdir_listdir_rmdir", function(assert)
-		local dir = path.join(tmpdir, "subdir")
+		    local dir = path.join(tmpdir, "subdir")
+		    print(`FAILING TEST_ {path.format(dir)}`)
 		if not fs.exists(dir) then
 			fs.createdirectory(dir, { makeparents = true })
 		end
-
+		print(`FAILING {fs.exists(dir)} {fs.type(dir)}`)
 		assert.eq(fs.exists(dir), true)
 		assert.eq(fs.type(dir), "dir")
 

tests/std/path/path.win32.test.luau

@@ -1,5 +1,6 @@
 local system = require("@std/system")
 local test = require("@std/test")
+local process = require("@std/process")
 
 local path = require("@std/path")
 local win32 = require("@std/path/win32")
@@ -655,10 +656,16 @@ test.suite("PathWin32ResolveSuite", function(suite)
 	end)
 
 	suite:case("resolve_drive_relative_path", function(assert)
-		local result = path.win32.resolve("C:Documents\\file.txt")
+		-- Get the drive letter from the current working directory
+		local cwd = process.cwd()
+		local cwdPath = path.win32.parse(cwd)
+		local driveLetter = if system.win32 then cwdPath.driveLetter else "C"
+
+		local testPath = driveLetter .. ":Documents\\file.txt"
+		local result = path.win32.resolve(testPath)
 		-- Absolute unix paths will be parsed as relative Windows paths because they don't have drive letters
 		assert.eq(result.kind, if system.win32 then "absolute" else "relative")
-		assert.eq(result.driveLetter, "C")
+		assert.eq(result.driveLetter, driveLetter)
 		-- The exact parts depend on cwd, but should be absolute
 		local endIndex = #result.parts
 		assert.eq(result.parts[endIndex - 1], "Documents")

tests/std/process.test.luau

@@ -1,6 +1,7 @@
 local pathlib = require("@std/path")
 local process = require("@std/process")
 local test = require("@std/test")
+local system = require("@std/system")
 
 test.suite("ProcessSuite", function(suite)
 	suite:case("homedir_and_cwd_and_execpath", function(assert)
@@ -19,7 +20,10 @@ test.suite("ProcessSuite", function(suite)
 		assert.eq(r.stdout, "hello-from-lute\n")
 	end)
 
-	suite:case("run_shell_and_cwd", function(assert)
+	suite:case("run_shell_and_cwd_posix", function(assert)
+		if system.win32 then
+			return
+		end
 		local r = process.run({ "pwd" }, { cwd = "/" })
 		assert.tableeq(r, {
 			exitcode = 0,
@@ -37,6 +41,55 @@ test.suite("ProcessSuite", function(suite)
 		})
 	end)
 
+	suite:case("run_shell_and_cwd_windows", function(assert)
+		if system.unix or system.macos or system.linux then
+			return
+		end
+		-- Get the current drive root using getdrive helper
+		local cwd = process.cwd()
+		local driveRoot = pathlib.win32.getdrive(cwd)
+		local rootPath = pathlib.format(driveRoot)
+		local driveLetter = driveRoot.driveLetter
+
+		-- Git Bash on Windows converts C:\ to /c, D:\ to /d, etc.
+		local expectedOutput = "/" .. string.lower(driveLetter) .. "\n"
+
+		local r = process.run({ "pwd" }, { cwd = rootPath })
+		assert.tableeq(r, {
+			exitcode = 0,
+			stdout = expectedOutput,
+			stderr = "",
+			ok = true,
+		})
+
+		local r2 = process.run({ "echo hello!" }, { shell = true })
+		assert.tableeq(r2, {
+			exitcode = 0,
+			stdout = "hello!\r\n",
+			stderr = "",
+			ok = true,
+		})
+	end)
+
+	suite:case("run_with_cwd_tmpdir", function(assert)
+		-- Platform-independent test using tmpdir
+		local tmpdir = system.tmpdir()
+		local tmpdirStr = pathlib.format(tmpdir)
+
+		-- Use pwd/cd to verify cwd was changed correctly
+		local cmd = if system.win32 then { "cd" } else { "pwd" }
+		local opts = if system.win32 then { cwd = tmpdirStr, shell = true } else { cwd = tmpdirStr }
+		local lf = if system.win32 then "\r\n" else "\n"
+
+		local r = process.run(cmd, opts)
+		assert.eq(r.exitcode, 0)
+		assert.eq(r.ok, true)
+		assert.eq(r.stderr, "")
+		-- Normalize path separators and compare (remove trailing newline)
+		local actualPath = string.gsub(r.stdout, lf .. "$", "")
+		assert.eq(actualPath, tmpdirStr)
+	end)
+
 	suite:case("run_nonzero_exitcode", function(assert)
 		local r = process.run({ "sh", "-c", "exit 41" })
 		assert.tableeq(r, {