feat: migrate test suite from Mocha to Vitest

package.json

@@ -18,7 +18,8 @@
     "devDependencies": {
         "cross-env": "^7.0.2",
         "prettier": "~3.3.3",
-        "ts-node": "^10.0.0"
+        "ts-node": "^10.0.0",
+        "vitest": "^3.2.4"
     },
     "packageManager": "[email protected]"
 }

packages/language-server/package.json

@@ -10,7 +10,7 @@
         "./bin/server.js": "./bin/server.js"
     },
     "scripts": {
-        "test": "cross-env TS_NODE_TRANSPILE_ONLY=true mocha --require ts-node/register \"test/**/*.test.ts\"",
+        "test": "vitest --run",
         "build": "tsc",
         "prepublishOnly": "npm run build",
         "watch": "tsc -w"
@@ -42,13 +42,10 @@
         "@types/estree": "^0.0.42",
         "@types/globrex": "^0.1.4",
         "@types/lodash": "^4.14.116",
-        "@types/mocha": "^9.1.0",
         "@types/node": "^18.0.0",
         "@types/sinon": "^7.5.2",
-        "cross-env": "^7.0.2",
-        "mocha": "^9.2.0",
         "sinon": "^11.0.0",
-        "ts-node": "^10.0.0"
+        "vitest": "^3.2.4"
     },
     "dependencies": {
         "@jridgewell/trace-mapping": "^0.3.25",

packages/language-server/test/lib/documents/Document.test.ts

@@ -1,32 +1,32 @@
-import * as assert from 'assert';
+import { describe, it, expect } from 'vitest';
 import { Document } from '../../../src/lib/documents';
 import { Position } from 'vscode-languageserver';
 
 describe('Document', () => {
     it('gets the correct text', () => {
         const document = new Document('file:///hello.svelte', '<h1>Hello, world!</h1>');
-        assert.strictEqual(document.getText(), '<h1>Hello, world!</h1>');
+        expect(document.getText()).toEqual('<h1>Hello, world!</h1>');
     });
 
     it('sets the text', () => {
         const document = new Document('file:///hello.svelte', '<h1>Hello, world!</h1>');
         document.setText('<h1>Hello, svelte!</h1>');
-        assert.strictEqual(document.getText(), '<h1>Hello, svelte!</h1>');
+        expect(document.getText()).toEqual('<h1>Hello, svelte!</h1>');
     });
 
     it('increments the version on edits', () => {
         const document = new Document('file:///hello.svelte', 'hello');
-        assert.strictEqual(document.version, 0);
+        expect(document.version).toEqual(0);
 
         document.setText('Hello, world!');
-        assert.strictEqual(document.version, 1);
+        expect(document.version).toEqual(1);
         document.update('svelte', 7, 12);
-        assert.strictEqual(document.version, 2);
+        expect(document.version).toEqual(2);
     });
 
     it('recalculates the tag infos on edits', () => {
         const document = new Document('file:///hello.svelte', '<script>a</script><style>b</style>');
-        assert.deepEqual(document.scriptInfo, {
+        expect(document.scriptInfo).toEqual({
             content: 'a',
             attributes: {},
             start: 8,
@@ -35,7 +35,7 @@ describe('Document', () => {
             endPos: Position.create(0, 9),
             container: { start: 0, end: 18 }
         });
-        assert.deepEqual(document.styleInfo, {
+        expect(document.styleInfo).toEqual({
             content: 'b',
             attributes: {},
             start: 25,
@@ -46,7 +46,7 @@ describe('Document', () => {
         });
 
         document.setText('<script>b</script>');
-        assert.deepEqual(document.scriptInfo, {
+        expect(document.scriptInfo).toEqual({
             content: 'b',
             attributes: {},
             start: 8,
@@ -55,76 +55,76 @@ describe('Document', () => {
             endPos: Position.create(0, 9),
             container: { start: 0, end: 18 }
         });
-        assert.strictEqual(document.styleInfo, null);
+        expect(document.styleInfo).toEqual(null);
     });
 
     it('returns the correct file path', () => {
         const document = new Document('file:///hello.svelte', 'hello');
 
-        assert.strictEqual(document.getFilePath(), '/hello.svelte');
+        expect(document.getFilePath()).toEqual('/hello.svelte');
     });
 
     it('returns null for non file urls', () => {
         const document = new Document('ftp:///hello.svelte', 'hello');
 
-        assert.strictEqual(document.getFilePath(), null);
+        expect(document.getFilePath()).toEqual(null);
     });
 
     it('gets the text length', () => {
         const document = new Document('file:///hello.svelte', 'Hello, world!');
-        assert.strictEqual(document.getTextLength(), 13);
+        expect(document.getTextLength()).toEqual(13);
     });
 
     it('updates the text range', () => {
         const document = new Document('file:///hello.svelte', 'Hello, world!');
         document.update('svelte', 7, 12);
-        assert.strictEqual(document.getText(), 'Hello, svelte!');
+        expect(document.getText()).toEqual('Hello, svelte!');
     });
 
     it('gets the correct position from offset', () => {
         const document = new Document('file:///hello.svelte', 'Hello\nworld\n');
-        assert.deepStrictEqual(document.positionAt(1), { line: 0, character: 1 });
-        assert.deepStrictEqual(document.positionAt(9), { line: 1, character: 3 });
-        assert.deepStrictEqual(document.positionAt(12), { line: 2, character: 0 });
+        expect(document.positionAt(1)).toEqual({ line: 0, character: 1 });
+        expect(document.positionAt(9)).toEqual({ line: 1, character: 3 });
+        expect(document.positionAt(12)).toEqual({ line: 2, character: 0 });
     });
 
     it('gets the correct offset from position', () => {
         const document = new Document('file:///hello.svelte', 'Hello\nworld\n');
-        assert.strictEqual(document.offsetAt({ line: 0, character: 1 }), 1);
-        assert.strictEqual(document.offsetAt({ line: 1, character: 3 }), 9);
-        assert.strictEqual(document.offsetAt({ line: 2, character: 0 }), 12);
+        expect(document.offsetAt({ line: 0, character: 1 })).toBe(1);
+        expect(document.offsetAt({ line: 1, character: 3 })).toBe(9);
+        expect(document.offsetAt({ line: 2, character: 0 })).toBe(12);
     });
 
     it('gets the correct position from offset with CRLF', () => {
         const document = new Document('file:///hello.svelte', 'Hello\r\nworld\r\n');
-        assert.deepStrictEqual(document.positionAt(1), { line: 0, character: 1 });
-        assert.deepStrictEqual(document.positionAt(10), { line: 1, character: 3 });
-        assert.deepStrictEqual(document.positionAt(14), { line: 2, character: 0 });
+        expect(document.positionAt(1)).toEqual({ line: 0, character: 1 });
+        expect(document.positionAt(10)).toEqual({ line: 1, character: 3 });
+        expect(document.positionAt(14)).toEqual({ line: 2, character: 0 });
     });
 
     it('gets the correct offset from position with CRLF', () => {
         const document = new Document('file:///hello.svelte', 'Hello\r\nworld\r\n');
-        assert.strictEqual(document.offsetAt({ line: 0, character: 1 }), 1);
-        assert.strictEqual(document.offsetAt({ line: 1, character: 3 }), 10);
-        assert.strictEqual(document.offsetAt({ line: 2, character: 0 }), 14);
+        expect(document.offsetAt({ line: 0, character: 1 })).toEqual(1);
+        expect(document.offsetAt({ line: 1, character: 3 })).toEqual(10);
+        expect(document.offsetAt({ line: 2, character: 0 })).toEqual(14);
     });
 
     it('limits the position when offset is out of bounds', () => {
         const document = new Document('file:///hello.svelte', 'Hello\nworld\n');
-        assert.deepStrictEqual(document.positionAt(20), { line: 2, character: 0 });
-        assert.deepStrictEqual(document.positionAt(-1), { line: 0, character: 0 });
+        expect(document.positionAt(20)).toEqual({ line: 2, character: 0 });
+        expect(document.positionAt(-1)).toEqual({ line: 0, character: 0 });
     });
 
     it('limits the offset when position is out of bounds', () => {
         const document = new Document('file:///hello.svelte', 'Hello\nworld\n');
-        assert.strictEqual(document.offsetAt({ line: 5, character: 0 }), 12);
-        assert.strictEqual(document.offsetAt({ line: 1, character: 20 }), 12);
-        assert.strictEqual(document.offsetAt({ line: -1, character: 0 }), 0);
+        expect(document.offsetAt({ line: 5, character: 0 })).toEqual(12);
+        expect(document.offsetAt({ line: 1, character: 20 })).toEqual(12);
+        expect(document.offsetAt({ line: -1, character: 0 })).toEqual(0);
     });
 
     it('supports empty contents', () => {
         const document = new Document('file:///hello.svelte', '');
-        assert.strictEqual(document.offsetAt({ line: 0, character: 0 }), 0);
-        assert.deepStrictEqual(document.positionAt(0), { line: 0, character: 0 });
+        expect(document.offsetAt({ line: 0, character: 0 })).toEqual(0);
+        expect(document.positionAt(0)).toEqual({ line: 0, character: 0 });
     });
 });

packages/language-server/test/lib/documents/DocumentManager.test.ts

@@ -1,5 +1,5 @@
 import sinon from 'sinon';
-import * as assert from 'assert';
+import { describe, it, expect } from 'vitest';
 import { TextDocumentItem, Range } from 'vscode-languageserver-types';
 import { DocumentManager, Document } from '../../../src/lib/documents';
 
@@ -65,7 +65,7 @@ describe('Document Manager', () => {
     it("fails to update if document isn't open", () => {
         const manager = new DocumentManager(createTextDocument);
 
-        assert.throws(() => manager.updateDocument(textDocument, []));
+        expect(() => manager.updateDocument(textDocument, [])).toThrow();
     });
 
     it('emits a document change event on open and update', () => {
@@ -109,6 +109,6 @@ describe('Document Manager', () => {
             ]
         );
 
-        assert.ok(manager.get(textDocument.uri)!.version > firstVersion);
+        expect(manager.get(textDocument.uri)!.version > firstVersion).toBeTruthy();
     });
 });

packages/language-server/test/lib/documents/DocumentMapper.test.ts

@@ -1,4 +1,4 @@
-import * as assert from 'assert';
+import { describe, it, expect } from 'vitest';
 import { FragmentMapper, positionAt } from '../../../src/lib/documents';
 
 describe('DocumentMapper', () => {
@@ -19,16 +19,16 @@ describe('DocumentMapper', () => {
         it('isInGenerated works', () => {
             const fragment = setup('Hello, \nworld!', 8, 13);
 
-            assert.strictEqual(fragment.isInGenerated({ line: 0, character: 0 }), false);
-            assert.strictEqual(fragment.isInGenerated({ line: 1, character: 0 }), true);
-            assert.strictEqual(fragment.isInGenerated({ line: 1, character: 5 }), true);
-            assert.strictEqual(fragment.isInGenerated({ line: 1, character: 6 }), false);
+            expect(fragment.isInGenerated({ line: 0, character: 0 })).toEqual(false);
+            expect(fragment.isInGenerated({ line: 1, character: 0 })).toEqual(true);
+            expect(fragment.isInGenerated({ line: 1, character: 5 })).toEqual(true);
+            expect(fragment.isInGenerated({ line: 1, character: 6 })).toEqual(false);
         });
 
         it('calculates the position in parent', () => {
             const fragment = setup('Hello, \nworld!', 8, 13);
 
-            assert.deepStrictEqual(fragment.getOriginalPosition({ line: 0, character: 2 }), {
+            expect(fragment.getOriginalPosition({ line: 0, character: 2 })).toEqual({
                 line: 1,
                 character: 2
             });
@@ -37,7 +37,7 @@ describe('DocumentMapper', () => {
         it('calculates the position in fragment', () => {
             const fragment = setup('Hello, \nworld!', 8, 13);
 
-            assert.deepStrictEqual(fragment.getGeneratedPosition({ line: 1, character: 2 }), {
+            expect(fragment.getGeneratedPosition({ line: 1, character: 2 })).toEqual({
                 line: 0,
                 character: 2
             });

packages/language-server/test/lib/documents/configLoader.test.ts

@@ -1,7 +1,7 @@
 import { ConfigLoader } from '../../../src/lib/documents/configLoader';
 import path from 'path';
 import { pathToFileURL, URL } from 'url';
-import assert from 'assert';
+import { describe, it, expect } from 'vitest';
 import { spy } from 'sinon';
 
 describe('ConfigLoader', () => {
@@ -49,8 +49,8 @@ describe('ConfigLoader', () => {
     ) {
         filePath = normalizePath(filePath);
         configPath = normalizePath(configPath);
-        assert.deepStrictEqual(configLoader.getConfig(filePath), configFrom(configPath));
-        assert.deepStrictEqual(await configLoader.awaitConfig(filePath), configFrom(configPath));
+        expect(configLoader.getConfig(filePath)).toEqual(configFrom(configPath));
+        expect(await configLoader.awaitConfig(filePath)).toEqual(configFrom(configPath));
     }
 
     it('should load all config files below and the one inside/above given directory', async () => {
@@ -108,13 +108,12 @@ describe('ConfigLoader', () => {
         );
         await configLoader.loadConfigs(normalizePath('/some/path'));
 
-        assert.deepStrictEqual(
+        expect(
             // Can't do the equal-check directly, instead check if it's the expected object props
             Object.keys(
                 configLoader.getConfig(normalizePath('/some/path/comp.svelte'))?.preprocess || {}
-            ).sort(),
-            ['name', 'script'].sort()
-        );
+            ).sort()
+        ).toEqual(['name', 'script'].sort());
     });
 
     it('will not load config multiple times if config loading started in parallel', async () => {
@@ -158,17 +157,14 @@ describe('ConfigLoader', () => {
             '/some/path/sub/comp.svelte',
             '/some/path/svelte.config.js'
         );
-        assert.deepStrictEqual(nrImportCalls, 1);
+        expect(nrImportCalls).toEqual(1);
     });
 
     it('can deal with missing config', () => {
         const configLoader = new ConfigLoader(mockFdir([]), { existsSync: () => false }, path, () =>
             Promise.resolve('unimportant')
         );
-        assert.deepStrictEqual(
-            configLoader.getConfig(normalizePath('/some/file.svelte')),
-            undefined
-        );
+        expect(configLoader.getConfig(normalizePath('/some/file.svelte'))).toEqual(undefined);
     });
 
     it('should await config', async () => {
@@ -178,8 +174,7 @@ describe('ConfigLoader', () => {
             path,
             (module: URL) => Promise.resolve({ default: { preprocess: module.toString() } })
         );
-        assert.deepStrictEqual(
-            await configLoader.awaitConfig(normalizePath('some/file.svelte')),
+        expect(await configLoader.awaitConfig(normalizePath('some/file.svelte'))).toEqual(
             configFrom(normalizePath('some/svelte.config.js'))
         );
     });
@@ -194,6 +189,6 @@ describe('ConfigLoader', () => {
         );
         configLoader.setDisabled(true);
         await configLoader.awaitConfig(normalizePath('some/file.svelte'));
-        assert.deepStrictEqual(moduleLoader.notCalled, true);
+        expect(moduleLoader.notCalled).toEqual(true);
     });
 });