Fix Windows tests (paths)

Author: khawkins

test/lib/lwc-bundle.js

@@ -10,6 +10,7 @@
 const { expect } = require('chai');
 const LwcBundle = require('../../lib/lwc-bundle');
 const { FilesystemProvider } = require('../../lib/util/filesystem-provider');
+const { join } = require('path');
 
 class MockFilesystemProvider extends FilesystemProvider {
     constructor() {
@@ -232,22 +233,22 @@ describe('LwcBundle', () => {
 
     describe('lwcBundleFromFilesystem', () => {
         let mockFs;
+        const testDir = join('path', 'to');
+        const testJsPath = join(testDir, 'test.js');
+        const testHtmlPath = join(testDir, 'test.html');
+        const nonexistentPath = join(testDir, 'nonexistent.js');
+        const cssPath = join(testDir, 'test.css');
 
         beforeEach(() => {
             mockFs = new MockFilesystemProvider();
-            mockFs.addFile('/path/to/test.js', 'export default class Test {}');
-            mockFs.addFile('/path/to/test.html', '<template></template>');
-            mockFs.addDirectory('/path/to', ['test.js', 'test.html']);
+            mockFs.addFile(testJsPath, 'export default class Test {}');
+            mockFs.addFile(testHtmlPath, '<template></template>');
+            mockFs.addDirectory(testDir, ['test.js', 'test.html']);
         });
 
         it('should create bundle from filesystem files', () => {
             const jsContent = 'export default class Test {}';
-            const bundle = LwcBundle.lwcBundleFromFilesystem(
-                jsContent,
-                '/path/to/test.js',
-                '.js',
-                mockFs
-            );
+            const bundle = LwcBundle.lwcBundleFromFilesystem(jsContent, testJsPath, '.js', mockFs);
 
             expect(bundle.componentBaseName).to.equal('test');
             expect(bundle.js.filename).to.equal('test.js');
@@ -261,7 +262,7 @@ describe('LwcBundle', () => {
         it('should return null for non-existent file', () => {
             const bundle = LwcBundle.lwcBundleFromFilesystem(
                 'content',
-                '/path/to/nonexistent.js',
+                nonexistentPath,
                 '.js',
                 mockFs
             );
@@ -270,7 +271,7 @@ describe('LwcBundle', () => {
 
         it('should throw error for unsupported file extension', () => {
             expect(() => {
-                LwcBundle.lwcBundleFromFilesystem('content', '/path/to/test.css', '.css', mockFs);
+                LwcBundle.lwcBundleFromFilesystem('content', cssPath, '.css', mockFs);
             }).to.throw('Unsupported file extension: .css');
         });
     });

test/lib/util/filesystem-provider.js

@@ -12,6 +12,7 @@ const {
     FilesystemProvider,
     DefaultFilesystemProvider
 } = require('../../../lib/util/filesystem-provider');
+const { join } = require('path');
 
 describe('FilesystemProvider', () => {
     describe('FilesystemProvider (abstract class)', () => {
@@ -22,30 +23,38 @@ describe('FilesystemProvider', () => {
         });
 
         it('should throw error for unimplemented existsSync', () => {
-            expect(() => provider.existsSync('/some/path')).to.throw('Method not implemented');
+            expect(() => provider.existsSync(join('some', 'path'))).to.throw(
+                'Method not implemented'
+            );
         });
 
         it('should throw error for unimplemented readdirSync', () => {
-            expect(() => provider.readdirSync('/some/path')).to.throw('Method not implemented');
+            expect(() => provider.readdirSync(join('some', 'path'))).to.throw(
+                'Method not implemented'
+            );
         });
 
         it('should throw error for unimplemented readFileSync', () => {
-            expect(() => provider.readFileSync('/some/path')).to.throw('Method not implemented');
+            expect(() => provider.readFileSync(join('some', 'path'))).to.throw(
+                'Method not implemented'
+            );
         });
     });
 
     describe('DefaultFilesystemProvider', () => {
         let provider;
         const testDir = __dirname;
         const testFile = __filename;
+        const nonexistentFile = join('nonexistent', 'file');
+        const nonexistentDir = join('nonexistent', 'directory');
 
         beforeEach(() => {
             provider = new DefaultFilesystemProvider();
         });
 
         it('should check if file exists', () => {
             expect(provider.existsSync(testFile)).to.be.true;
-            expect(provider.existsSync('/nonexistent/file')).to.be.false;
+            expect(provider.existsSync(nonexistentFile)).to.be.false;
         });
 
         it('should read directory contents', () => {
@@ -67,13 +76,13 @@ describe('FilesystemProvider', () => {
 
         it('should throw error for nonexistent file read', () => {
             expect(() => {
-                provider.readFileSync('/nonexistent/file');
+                provider.readFileSync(nonexistentFile);
             }).to.throw();
         });
 
         it('should throw error for nonexistent directory read', () => {
             expect(() => {
-                provider.readdirSync('/nonexistent/directory');
+                provider.readdirSync(nonexistentDir);
             }).to.throw();
         });
     });