unit tests: run using both windows and unix paths

Author: evanw

internal/bundler/bundler.go

@@ -1632,6 +1632,11 @@ func lowestCommonAncestorDirectory(fs fs.FS, entryPoints []graph.EntryPoint) str
 					lastSlash = a
 				}
 			} else if boundaryA != boundaryB || unicode.ToLower(runeA) != unicode.ToLower(runeB) {
+				// If we're at the top-level directory, then keep the slash
+				if lastSlash < len(absDir) && !strings.ContainsAny(absDir[:lastSlash], "\\/") {
+					lastSlash++
+				}
+
 				// If both paths are different at this point, stop and set the lowest so
 				// far to the common parent directory. Compare using a case-insensitive
 				// comparison to handle paths on Windows.

internal/bundler/bundler_default_test.go

@@ -2416,7 +2416,7 @@ func TestImportAbsPathAsFile(t *testing.T) {
 }
 
 func TestImportAbsPathAsDir(t *testing.T) {
-	default_suite.expectBundled(t, bundled{
+	default_suite.expectBundledUnix(t, bundled{
 		files: map[string]string{
 			"/Users/user/project/entry.js": `
 				import pkg from '/Users/user/project/node_modules/pkg'
@@ -2432,6 +2432,23 @@ func TestImportAbsPathAsDir(t *testing.T) {
 			AbsOutputDir: "/out",
 		},
 	})
+
+	default_suite.expectBundledWindows(t, bundled{
+		files: map[string]string{
+			"/Users/user/project/entry.js": `
+				import pkg from 'C:\\Users\\user\\project\\node_modules\\pkg'
+				console.log(pkg)
+			`,
+			"/Users/user/project/node_modules/pkg/index.js": `
+				export default 123
+			`,
+		},
+		entryPaths: []string{"/Users/user/project/entry.js"},
+		options: config.Options{
+			Mode:         config.ModeBundle,
+			AbsOutputDir: "/out",
+		},
+	})
 }
 
 func TestAutoExternal(t *testing.T) {
@@ -3898,7 +3915,7 @@ func TestMinifyArguments(t *testing.T) {
 }
 
 func TestWarningsInsideNodeModules(t *testing.T) {
-	default_suite.expectBundled(t, bundled{
+	default_suite.expectBundledUnix(t, bundled{
 		files: map[string]string{
 			"/entry.js": `
 				import "./dup-case.js";        import "./node_modules/dup-case.js";        import "@plugin/dup-case.js"
@@ -4055,7 +4072,7 @@ entry.js: WARNING: "@scope/missing-pkg" should be marked as external for use wit
 }
 
 func TestInjectMissing(t *testing.T) {
-	default_suite.expectBundled(t, bundled{
+	default_suite.expectBundledUnix(t, bundled{
 		files: map[string]string{
 			"/entry.js": ``,
 		},
@@ -4067,8 +4084,22 @@ func TestInjectMissing(t *testing.T) {
 				"/inject.js",
 			},
 		},
-		expectedScanLog: `ERROR: Could not read from file: /inject.js
-`,
+		expectedScanLog: "ERROR: Could not read from file: /inject.js\n",
+	})
+
+	default_suite.expectBundledWindows(t, bundled{
+		files: map[string]string{
+			"/entry.js": ``,
+		},
+		entryPaths: []string{"/entry.js"},
+		options: config.Options{
+			Mode:          config.ModeBundle,
+			AbsOutputFile: "/out.js",
+			InjectAbsPaths: []string{
+				"/inject.js",
+			},
+		},
+		expectedScanLog: "ERROR: Could not read from file: C:\\inject.js\n",
 	})
 }
 

internal/bundler/bundler_test.go

@@ -69,10 +69,34 @@ type suite struct {
 
 func (s *suite) expectBundled(t *testing.T, args bundled) {
 	t.Helper()
+	s.__expectBundledImpl(t, args, fs.MockUnix)
+	s.__expectBundledImpl(t, args, fs.MockWindows)
+}
+
+func (s *suite) expectBundledUnix(t *testing.T, args bundled) {
+	t.Helper()
+	s.__expectBundledImpl(t, args, fs.MockUnix)
+}
+
+func (s *suite) expectBundledWindows(t *testing.T, args bundled) {
+	t.Helper()
+	s.__expectBundledImpl(t, args, fs.MockWindows)
+}
+
+// Don't call this directly. Call the helpers above instead.
+func (s *suite) __expectBundledImpl(t *testing.T, args bundled, fsKind fs.MockKind) {
+	t.Helper()
+
 	testName := t.Name()
-	t.Run("", func(t *testing.T) {
+	subName := "Unix"
+	if fsKind == fs.MockWindows {
+		subName = "Windows"
+	}
+
+	t.Run(subName, func(t *testing.T) {
 		t.Helper()
-		fs := fs.MockFS(args.files)
+
+		// Prepare the options
 		if args.options.ExtensionOrder == nil {
 			args.options.ExtensionOrder = []string{".tsx", ".ts", ".jsx", ".js", ".css", ".json"}
 		}
@@ -87,15 +111,40 @@ func (s *suite) expectBundled(t *testing.T, args bundled) {
 		if args.debugLogs {
 			logKind = logger.DeferLogAll
 		}
-		log := logger.NewDeferLog(logKind, nil)
-		caches := cache.MakeCacheSet()
-		resolver := resolver.NewResolver(fs, log, caches, args.options)
 		entryPoints := make([]EntryPoint, 0, len(args.entryPaths)+len(args.entryPathsAdvanced))
 		for _, path := range args.entryPaths {
 			entryPoints = append(entryPoints, EntryPoint{InputPath: path})
 		}
 		entryPoints = append(entryPoints, args.entryPathsAdvanced...)
-		bundle := ScanBundle(log, fs, resolver, caches, entryPoints, args.options, nil)
+
+		// Handle conversion to Windows-style paths
+		if fsKind == fs.MockWindows {
+			for i, entry := range entryPoints {
+				entry.InputPath = unix2win(entry.InputPath)
+				entryPoints[i] = entry
+			}
+
+			for i, absPath := range args.options.InjectAbsPaths {
+				args.options.InjectAbsPaths[i] = unix2win(absPath)
+			}
+
+			replace := make(map[string]bool)
+			for k, v := range args.options.ExternalSettings.PostResolve.Exact {
+				replace[unix2win(k)] = v
+			}
+			args.options.ExternalSettings.PostResolve.Exact = replace
+
+			args.options.AbsOutputFile = unix2win(args.options.AbsOutputFile)
+			args.options.AbsOutputDir = unix2win(args.options.AbsOutputDir)
+			args.options.TsConfigOverride = unix2win(args.options.TsConfigOverride)
+		}
+
+		// Run the bundler
+		log := logger.NewDeferLog(logKind, nil)
+		caches := cache.MakeCacheSet()
+		mockFS := fs.MockFS(args.files, fsKind)
+		resolver := resolver.NewResolver(mockFS, log, caches, args.options)
+		bundle := ScanBundle(log, mockFS, resolver, caches, entryPoints, args.options, nil)
 		msgs := log.Done()
 		assertLog(t, msgs, args.expectedScanLog)
 
@@ -124,6 +173,9 @@ func (s *suite) expectBundled(t *testing.T, args bundled) {
 				if generated != "" {
 					generated += "\n"
 				}
+				if fsKind == fs.MockWindows {
+					result.AbsPath = win2unix(result.AbsPath)
+				}
 				generated += fmt.Sprintf("---------- %s ----------\n%s", result.AbsPath, string(result.Contents))
 			}
 		}
@@ -235,3 +287,19 @@ func TestMain(m *testing.M) {
 	}
 	os.Exit(code)
 }
+
+func win2unix(p string) string {
+	if strings.HasPrefix(p, "C:\\") {
+		p = p[2:]
+	}
+	p = strings.ReplaceAll(p, "\\", "/")
+	return p
+}
+
+func unix2win(p string) string {
+	p = strings.ReplaceAll(p, "/", "\\")
+	if strings.HasPrefix(p, "\\") {
+		p = "C:" + p
+	}
+	return p
+}

internal/bundler/bundler_tsconfig_test.go

@@ -859,7 +859,7 @@ func TestTsconfigJsonExtends(t *testing.T) {
 }
 
 func TestTsconfigJsonExtendsAbsolute(t *testing.T) {
-	tsconfig_suite.expectBundled(t, bundled{
+	tsconfig_suite.expectBundledUnix(t, bundled{
 		files: map[string]string{
 			"/Users/user/project/entry.jsx": `
 				console.log(<div/>, <></>)
@@ -887,6 +887,35 @@ func TestTsconfigJsonExtendsAbsolute(t *testing.T) {
 			AbsOutputFile: "/out.js",
 		},
 	})
+
+	tsconfig_suite.expectBundledWindows(t, bundled{
+		files: map[string]string{
+			"/Users/user/project/entry.jsx": `
+				console.log(<div/>, <></>)
+			`,
+			"/Users/user/project/tsconfig.json": `
+				{
+					"extends": "C:\\Users\\user\\project\\base.json",
+					"compilerOptions": {
+						"jsxFragmentFactory": "derivedFragment"
+					}
+				}
+			`,
+			"/Users/user/project/base.json": `
+				{
+					"compilerOptions": {
+						"jsxFactory": "baseFactory",
+						"jsxFragmentFactory": "baseFragment"
+					}
+				}
+			`,
+		},
+		entryPaths: []string{"/Users/user/project/entry.jsx"},
+		options: config.Options{
+			Mode:          config.ModeBundle,
+			AbsOutputFile: "/out.js",
+		},
+	})
 }
 
 func TestTsconfigJsonExtendsThreeLevels(t *testing.T) {