test: Node Test

.github/dependabot.yml

@@ -13,7 +13,3 @@ updates:
         patterns:
           - '@typescript-eslint/*'
           - 'eslint*'
-      vitest:
-        patterns:
-          - '@vitest/*'
-          - 'vitest'

.nvmrc

@@ -1 +1 @@
-v20
+v23

.vscode/extensions.json

@@ -1,3 +1,3 @@
 {
-  "recommendations": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode", "vitest.explorer"]
+  "recommendations": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"]
 }

README.md

@@ -39,7 +39,7 @@ npm run lint
 
 ### Testing
 
-Run tests using [Vitest](https://vitest.dev/) testing framework.
+Run tests using [Node Test](https://nodejs.org/api/test.html) test runner.
 
 ```sh
 npm test

bin/index.mjs

@@ -31,14 +31,15 @@ export default foo;
 }
 
 function testTemplate() {
-  return `import foo from '.';
+  return `import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import foo from './index.ts';
 
 describe('foo', () => {
   it('should', () => {
-
+    assert.strictEqual(foo(), );
   });
-});
-`;
+});`;
 }
 
 async function getKata(id) {

kata/4 kyu/adding-big-numbers/index.test.ts

@@ -1,17 +1,17 @@
-import { describe, expect, it } from 'vitest';
-import add from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import add from './index.ts';
 
 describe('add', () => {
   it('should add two large numbers', () => {
-    expect.assertions(7);
-
-    expect(add('1', '1')).toBe('2');
-    expect(add('123', '456')).toBe('579');
-    expect(add('888', '222')).toBe('1110');
-    expect(add('1372', '69')).toBe('1441');
-    expect(add('12', '456')).toBe('468');
-    expect(add('101', '100')).toBe('201');
-    expect(add('63829983432984289347293874', '90938498237058927340892374089')).toBe(
+    assert.strictEqual(add('1', '1'), '2');
+    assert.strictEqual(add('123', '456'), '579');
+    assert.strictEqual(add('888', '222'), '1110');
+    assert.strictEqual(add('1372', '69'), '1441');
+    assert.strictEqual(add('12', '456'), '468');
+    assert.strictEqual(add('101', '100'), '201');
+    assert.strictEqual(
+      add('63829983432984289347293874', '90938498237058927340892374089'),
       '91002328220491911630239667963',
     );
   });

kata/4 kyu/next-bigger-number-with-the-same-digits/index.test.ts

@@ -1,17 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import nextBigger from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import nextBigger from './index.ts';
 
 describe('nextBigger', () => {
   it('should return next bigger number', () => {
-    expect.assertions(8);
-
-    expect(nextBigger(12)).toBe(21);
-    expect(nextBigger(513)).toBe(531);
-    expect(nextBigger(2017)).toBe(2071);
-    expect(nextBigger(414)).toBe(441);
-    expect(nextBigger(144)).toBe(414);
-    expect(nextBigger(9)).toBe(-1);
-    expect(nextBigger(111)).toBe(-1);
-    expect(nextBigger(531)).toBe(-1);
+    assert.strictEqual(nextBigger(12), 21);
+    assert.strictEqual(nextBigger(513), 531);
+    assert.strictEqual(nextBigger(2017), 2071);
+    assert.strictEqual(nextBigger(414), 441);
+    assert.strictEqual(nextBigger(144), 414);
+    assert.strictEqual(nextBigger(9), -1);
+    assert.strictEqual(nextBigger(111), -1);
+    assert.strictEqual(nextBigger(531), -1);
   });
 });

kata/4 kyu/sum-strings-as-numbers/index.test.ts

@@ -1,10 +1,9 @@
-import { describe, expect, it } from 'vitest';
-import sumStrings from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import sumStrings from './index.ts';
 
 describe('sumStrings', () => {
   it('should sum two strings', () => {
-    expect.assertions(1);
-
-    expect(sumStrings('123', '456')).toBe('579');
+    assert.strictEqual(sumStrings('123', '456'), '579');
   });
 });

kata/5 kyu/calculating-with-functions/index.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, it } from 'vitest';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
 import {
   dividedBy,
   eight,
@@ -14,37 +15,35 @@ import {
   times,
   two,
   zero,
-} from '.';
+} from './index.ts';
 
 describe('calculations', () => {
   it('should calculate with functions', () => {
-    expect.assertions(24);
+    assert.strictEqual(zero(), 0);
+    assert.strictEqual(one(), 1);
+    assert.strictEqual(two(), 2);
+    assert.strictEqual(three(), 3);
+    assert.strictEqual(four(), 4);
+    assert.strictEqual(five(), 5);
+    assert.strictEqual(six(), 6);
+    assert.strictEqual(seven(), 7);
+    assert.strictEqual(eight(), 8);
+    assert.strictEqual(nine(), 9);
 
-    expect(zero()).toBe(0);
-    expect(one()).toBe(1);
-    expect(two()).toBe(2);
-    expect(three()).toBe(3);
-    expect(four()).toBe(4);
-    expect(five()).toBe(5);
-    expect(six()).toBe(6);
-    expect(seven()).toBe(7);
-    expect(eight()).toBe(8);
-    expect(nine()).toBe(9);
+    assert.strictEqual(zero(plus(one())), 1);
+    assert.strictEqual(one(plus(two())), 3);
+    assert.strictEqual(two(plus(three())), 5);
+    assert.strictEqual(three(plus(four())), 7);
+    assert.strictEqual(four(plus(five())), 9);
+    assert.strictEqual(five(plus(six())), 11);
+    assert.strictEqual(six(plus(seven())), 13);
+    assert.strictEqual(seven(plus(eight())), 15);
+    assert.strictEqual(eight(plus(nine())), 17);
+    assert.strictEqual(nine(plus(zero())), 9);
 
-    expect(zero(plus(one()))).toBe(1);
-    expect(one(plus(two()))).toBe(3);
-    expect(two(plus(three()))).toBe(5);
-    expect(three(plus(four()))).toBe(7);
-    expect(four(plus(five()))).toBe(9);
-    expect(five(plus(six()))).toBe(11);
-    expect(six(plus(seven()))).toBe(13);
-    expect(seven(plus(eight()))).toBe(15);
-    expect(eight(plus(nine()))).toBe(17);
-    expect(nine(plus(zero()))).toBe(9);
-
-    expect(seven(times(five()))).toBe(35);
-    expect(four(plus(nine()))).toBe(13);
-    expect(eight(minus(three()))).toBe(5);
-    expect(six(dividedBy(two()))).toBe(3);
+    assert.strictEqual(seven(times(five())), 35);
+    assert.strictEqual(four(plus(nine())), 13);
+    assert.strictEqual(eight(minus(three())), 5);
+    assert.strictEqual(six(dividedBy(two())), 3);
   });
 });

kata/5 kyu/directions-reduction/index.test.ts

@@ -1,19 +1,18 @@
-import { describe, expect, it } from 'vitest';
-import dirReduc from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import dirReduc from './index.ts';
 
 describe('dirReduc', () => {
   it('should return reduced directions', () => {
-    expect.assertions(3);
-
-    expect(dirReduc(['NORTH', 'SOUTH', 'SOUTH', 'EAST', 'WEST', 'NORTH', 'WEST'])).toStrictEqual([
+    assert.deepEqual(dirReduc(['NORTH', 'SOUTH', 'SOUTH', 'EAST', 'WEST', 'NORTH', 'WEST']), [
       'WEST',
     ]);
-    expect(dirReduc(['NORTH', 'WEST', 'SOUTH', 'EAST'])).toStrictEqual([
+    assert.deepEqual(dirReduc(['NORTH', 'WEST', 'SOUTH', 'EAST']), [
       'NORTH',
       'WEST',
       'SOUTH',
       'EAST',
     ]);
-    expect(dirReduc(['NORTH', 'SOUTH', 'EAST', 'WEST', 'EAST', 'WEST'])).toStrictEqual([]);
+    assert.deepEqual(dirReduc(['NORTH', 'SOUTH', 'EAST', 'WEST', 'EAST', 'WEST']), []);
   });
 });

kata/5 kyu/extract-the-domain-name-from-a-url-1/index.test.ts

@@ -1,13 +1,12 @@
-import { describe, expect, it } from 'vitest';
-import domainName from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import domainName from './index.ts';
 
 describe('domainName', () => {
   it('should extract domain from url', () => {
-    expect.assertions(4);
-
-    expect(domainName('http://google.com')).toBe('google');
-    expect(domainName('http://google.co.jp')).toBe('google');
-    expect(domainName('www.xakep.ru')).toBe('xakep');
-    expect(domainName('https://youtube.com')).toBe('youtube');
+    assert.strictEqual(domainName('http://google.com'), 'google');
+    assert.strictEqual(domainName('http://google.co.jp'), 'google');
+    assert.strictEqual(domainName('www.xakep.ru'), 'xakep');
+    assert.strictEqual(domainName('https://youtube.com'), 'youtube');
   });
 });

kata/5 kyu/first-non-repeating-character/index.test.ts

@@ -1,12 +1,11 @@
-import { describe, expect, it } from 'vitest';
-import firstNonRepeatingLetter from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import firstNonRepeatingLetter from './index.ts';
 
 describe('firstNonRepeatingLetter', () => {
   it('should return first non repeating letter in string', () => {
-    expect.assertions(3);
-
-    expect(firstNonRepeatingLetter('a')).toBe('a');
-    expect(firstNonRepeatingLetter('stress')).toBe('t');
-    expect(firstNonRepeatingLetter('moonmen')).toBe('e');
+    assert.strictEqual(firstNonRepeatingLetter('a'), 'a');
+    assert.strictEqual(firstNonRepeatingLetter('stress'), 't');
+    assert.strictEqual(firstNonRepeatingLetter('moonmen'), 'e');
   });
 });

kata/5 kyu/human-readable-time/index.test.ts

@@ -1,14 +1,13 @@
-import { describe, expect, it } from 'vitest';
-import humanReadable from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import humanReadable from './index.ts';
 
 describe('humanReadable', () => {
   it('should return the time in a human-readable format', () => {
-    expect.assertions(5);
-
-    expect(humanReadable(0)).toBe('00:00:00');
-    expect(humanReadable(5)).toBe('00:00:05');
-    expect(humanReadable(60)).toBe('00:01:00');
-    expect(humanReadable(86399)).toBe('23:59:59');
-    expect(humanReadable(359999)).toBe('99:59:59');
+    assert.strictEqual(humanReadable(0), '00:00:00');
+    assert.strictEqual(humanReadable(5), '00:00:05');
+    assert.strictEqual(humanReadable(60), '00:01:00');
+    assert.strictEqual(humanReadable(86399), '23:59:59');
+    assert.strictEqual(humanReadable(359999), '99:59:59');
   });
 });

kata/5 kyu/is-my-friend-cheating/index.test.ts

@@ -1,14 +1,13 @@
-import { describe, expect, it } from 'vitest';
-import removeNb from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import removeNb from './index.ts';
 
 describe('removeNb', () => {
   it('should return array of all numbers which are the possible removed numbers in the sequence', () => {
-    expect.assertions(2);
-
-    expect(removeNb(26)).toStrictEqual([
+    assert.deepEqual(removeNb(26), [
       [15, 21],
       [21, 15],
     ]);
-    expect(removeNb(100)).toStrictEqual([]);
+    assert.deepEqual(removeNb(100), []);
   });
 });

kata/5 kyu/maximum-subarray-sum/index.test.ts

@@ -1,11 +1,10 @@
-import { describe, expect, it } from 'vitest';
-import maxSequence from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import maxSequence from './index.ts';
 
 describe('maxSequence', () => {
   it('should return max sum of subarray', () => {
-    expect.assertions(2);
-
-    expect(maxSequence([])).toBe(0);
-    expect(maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4])).toBe(6);
+    assert.strictEqual(maxSequence([]), 0);
+    assert.strictEqual(maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]), 6);
   });
 });

kata/5 kyu/memoized-fibonacci/index.test.ts

@@ -1,18 +1,17 @@
-import { describe, expect, it } from 'vitest';
-import fibonacci from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import fibonacci from './index.ts';
 
 describe('fibonacci', () => {
   it('should calculate the nth fibonacci number', () => {
-    expect.assertions(9);
-
-    expect(fibonacci(0)).toBe(0);
-    expect(fibonacci(1)).toBe(1);
-    expect(fibonacci(5)).toBe(5);
-    expect(fibonacci(10)).toBe(55);
-    expect(fibonacci(15)).toBe(610);
-    expect(fibonacci(20)).toBe(6765);
-    expect(fibonacci(50)).toBe(12586269025);
-    expect(fibonacci(60)).toBe(1548008755920);
-    expect(fibonacci(70)).toBe(190392490709135);
+    assert.strictEqual(fibonacci(0), 0);
+    assert.strictEqual(fibonacci(1), 1);
+    assert.strictEqual(fibonacci(5), 5);
+    assert.strictEqual(fibonacci(10), 55);
+    assert.strictEqual(fibonacci(15), 610);
+    assert.strictEqual(fibonacci(20), 6765);
+    assert.strictEqual(fibonacci(50), 12586269025);
+    assert.strictEqual(fibonacci(60), 1548008755920);
+    assert.strictEqual(fibonacci(70), 190392490709135);
   });
 });

kata/5 kyu/moving-zeros-to-the-end/index.test.ts

@@ -1,10 +1,9 @@
-import { describe, expect, it } from 'vitest';
-import moveZeros from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import moveZeros from './index.ts';
 
 describe('moveZeros', () => {
   it('should move all zeros to the end', () => {
-    expect.assertions(1);
-
-    expect(moveZeros([1, 2, 0, 1, 0, 1, 0, 3, 0, 1])).toStrictEqual([1, 2, 1, 1, 3, 1, 0, 0, 0, 0]);
+    assert.deepEqual(moveZeros([1, 2, 0, 1, 0, 1, 0, 3, 0, 1]), [1, 2, 1, 1, 3, 1, 0, 0, 0, 0]);
   });
 });

kata/5 kyu/not-very-secure/index.test.ts

@@ -1,13 +1,12 @@
-import { describe, expect, it } from 'vitest';
-import alphanumeric from '.';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import alphanumeric from './index.ts';
 
 describe('alphanumeric', () => {
   it('should validate if the string is alphanumeric', () => {
-    expect.assertions(4);
-
-    expect(alphanumeric('Mazinkaiser')).toBe(true);
-    expect(alphanumeric('hello world_')).toBe(false);
-    expect(alphanumeric('PassW0rd')).toBe(true);
-    expect(alphanumeric('     ')).toBe(false);
+    assert.strictEqual(alphanumeric('Mazinkaiser'), true);
+    assert.strictEqual(alphanumeric('hello world_'), false);
+    assert.strictEqual(alphanumeric('PassW0rd'), true);
+    assert.strictEqual(alphanumeric('     '), false);
   });
 });