Fix Windows path separator issues in tests

Author: jdalton

test/registry/additional-coverage.test.mts

@@ -4,6 +4,7 @@ import path from 'node:path'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { normalizePath } from '../../registry/dist/lib/path.js'
 import { trash } from '../../scripts/utils/fs.mjs'
 
 // Helper predicate moved to outer scope.
@@ -88,12 +89,12 @@ describe('additional coverage tests', () => {
       // Create the directory
       require('node:fs').mkdirSync(dirPath)
       const unique2 = fsUtils.uniqueSync(dirPath)
-      expect(unique2).toBe(path.join(tmpDir, 'mydir-1'))
+      expect(unique2).toBe(normalizePath(path.join(tmpDir, 'mydir-1')))
 
       // Create another file with same name to test multiple suffixes
       require('node:fs').mkdirSync(unique2)
       const unique3 = fsUtils.uniqueSync(dirPath)
-      expect(unique3).toBe(path.join(tmpDir, 'mydir-2'))
+      expect(unique3).toBe(normalizePath(path.join(tmpDir, 'mydir-2')))
     })
 
     it('should handle safeReadFile with different encodings', async () => {

test/registry/fs-utilities.test.mts

@@ -25,6 +25,7 @@ import {
   writeJson,
   writeJsonSync,
 } from '../../registry/dist/lib/fs.js'
+import { normalizePath } from '../../registry/dist/lib/path.js'
 import { trash } from '../../scripts/utils/fs.mjs'
 
 describe('fs utilities', () => {
@@ -46,7 +47,7 @@ describe('fs utilities', () => {
       fs.writeFileSync(path.join(tmpDir, 'target.txt'), 'content')
 
       const result = await findUp('target.txt', { cwd: subDir })
-      expect(result).toBe(path.join(tmpDir, 'target.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'target.txt')))
     })
 
     it('should find directory when onlyDirectories is true', async () => {
@@ -59,7 +60,7 @@ describe('fs utilities', () => {
         cwd: subDir,
         onlyDirectories: true,
       })
-      expect(result).toBe(targetDir)
+      expect(result).toBe(normalizePath(targetDir))
     })
 
     it('should find multiple target names', async () => {
@@ -70,7 +71,7 @@ describe('fs utilities', () => {
       const result = await findUp(['package.json', 'config.json'], {
         cwd: subDir,
       })
-      expect(result).toBe(path.join(tmpDir, 'config.json'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'config.json')))
     })
 
     it('should return undefined when not found', async () => {
@@ -97,7 +98,7 @@ describe('fs utilities', () => {
       fs.writeFileSync(path.join(tmpDir, 'target.txt'), 'content')
 
       const result = findUpSync('target.txt', { cwd: subDir })
-      expect(result).toBe(path.join(tmpDir, 'target.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'target.txt')))
     })
 
     it('should stop at specified directory', () => {
@@ -108,7 +109,7 @@ describe('fs utilities', () => {
       fs.writeFileSync(path.join(stopDir, 'local.txt'), 'content')
 
       const result = findUpSync('local.txt', { cwd: subDir, stopAt: stopDir })
-      expect(result).toBe(path.join(stopDir, 'local.txt'))
+      expect(result).toBe(normalizePath(path.join(stopDir, 'local.txt')))
     })
 
     it('should return undefined when stopAt prevents finding', () => {
@@ -419,7 +420,7 @@ describe('fs utilities', () => {
     it('should return original path when file does not exist', () => {
       const filePath = path.join(tmpDir, 'unique.txt')
       const result = uniqueSync(filePath)
-      expect(result).toBe(filePath)
+      expect(result).toBe(normalizePath(filePath))
     })
 
     it('should generate unique path when file exists', () => {

test/registry/fs.test.mts

@@ -27,6 +27,7 @@ import {
   writeJson,
   writeJsonSync,
 } from '../../registry/dist/lib/fs.js'
+import { normalizePath } from '../../registry/dist/lib/path.js'
 import { trash } from '../../scripts/utils/fs.mjs'
 
 describe('fs module', () => {
@@ -393,22 +394,22 @@ describe('fs module', () => {
       const filePath = path.join(tmpDir, 'test.txt')
       fs.writeFileSync(filePath, 'content')
       const result = uniqueSync(filePath)
-      expect(result).toBe(path.join(tmpDir, 'test-1.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'test-1.txt')))
     })
 
     it('should increment number for multiple conflicts', () => {
       const base = path.join(tmpDir, 'test.txt')
       fs.writeFileSync(base, 'content')
       fs.writeFileSync(path.join(tmpDir, 'test-1.txt'), 'content')
       const result = uniqueSync(base)
-      expect(result).toBe(path.join(tmpDir, 'test-2.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'test-2.txt')))
     })
 
     it('should handle files with extensions', () => {
       const filePath = path.join(tmpDir, 'file.json')
       fs.writeFileSync(filePath, '{}')
       const result = uniqueSync(filePath)
-      expect(result).toBe(path.join(tmpDir, 'file-1.json'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'file-1.json')))
     })
   })
 
@@ -417,15 +418,15 @@ describe('fs module', () => {
       const searchFile = 'target.txt'
       fs.writeFileSync(path.join(tmpDir, searchFile), 'found')
       const result = findUpSync(searchFile, { cwd: tmpDir })
-      expect(result).toBe(path.join(tmpDir, searchFile))
+      expect(result).toBe(normalizePath(path.join(tmpDir, searchFile)))
     })
 
     it('should find file in parent directories', () => {
       const subDir = path.join(tmpDir, 'sub', 'dir')
       fs.mkdirSync(subDir, { recursive: true })
       fs.writeFileSync(path.join(tmpDir, 'target.txt'), 'found')
       const result = findUpSync('target.txt', { cwd: subDir })
-      expect(result).toBe(path.join(tmpDir, 'target.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'target.txt')))
     })
 
     it('should return undefined if not found', () => {
@@ -450,15 +451,15 @@ describe('fs module', () => {
       const searchFile = 'target.txt'
       fs.writeFileSync(path.join(tmpDir, searchFile), 'found')
       const result = await findUp(searchFile, { cwd: tmpDir })
-      expect(result).toBe(path.join(tmpDir, searchFile))
+      expect(result).toBe(normalizePath(path.join(tmpDir, searchFile)))
     })
 
     it('should find file in parent directories', async () => {
       const subDir = path.join(tmpDir, 'sub', 'dir')
       fs.mkdirSync(subDir, { recursive: true })
       fs.writeFileSync(path.join(tmpDir, 'target.txt'), 'found')
       const result = await findUp('target.txt', { cwd: subDir })
-      expect(result).toBe(path.join(tmpDir, 'target.txt'))
+      expect(result).toBe(normalizePath(path.join(tmpDir, 'target.txt')))
     })
 
     it('should return undefined if not found', async () => {