From 517a7bfdfd2a4958c27dc535172b71cb203420b3 Mon Sep 17 00:00:00 2001 From: Giovanni Bucci Date: Thu, 26 Sep 2024 17:20:32 +0200 Subject: [PATCH] chore(test): converted all the tap tests with node:test (#739) --- .gitignore | 3 - .taprc | 7 - package.json | 4 +- test/additionalProperties.test.js | 40 +-- test/allof.test.js | 76 +++--- test/any.test.js | 56 ++-- test/anyof.test.js | 90 ++++--- test/array.test.js | 38 +-- test/asNumber.test.js | 4 +- test/basic.test.js | 52 ++-- test/bigint.test.js | 12 +- test/clean-cache.test.js | 16 +- test/const.test.js | 70 ++--- test/date.test.js | 154 +++++------ test/debug-mode.test.js | 54 ++-- test/defaults.test.js | 4 +- test/enum.test.js | 6 +- test/fix-604.test.js | 35 +-- test/if-then-else.test.js | 46 ++-- test/inferType.test.js | 8 +- test/infinity.test.js | 8 +- test/integer.test.js | 42 +-- test/invalidSchema.test.js | 12 +- test/issue-479.test.js | 4 +- test/json-schema-test-suite/draft4.test.js | 6 +- test/json-schema-test-suite/draft6.test.js | 6 +- test/json-schema-test-suite/draft7.test.js | 6 +- test/json-schema-test-suite/util.js | 15 +- test/missing-values.test.js | 16 +- test/multi-type-serializer.test.js | 4 +- test/nestedObjects.test.js | 6 +- test/nullable.test.js | 70 ++--- test/oneof.test.js | 56 ++-- test/patternProperties.test.js | 22 +- test/recursion.test.js | 12 +- test/ref.test.js | 288 ++++++++------------- test/regex.test.js | 9 +- test/required.test.js | 119 +++------ test/requiresAjv.test.js | 66 ++--- test/sanitize.test.js | 81 +++--- test/sanitize2.test.js | 22 +- test/sanitize3.test.js | 24 +- test/sanitize4.test.js | 18 +- test/sanitize5.test.js | 22 +- test/sanitize6.test.js | 28 +- test/sanitize7.test.js | 10 +- test/side-effect.test.js | 24 +- test/standalone-mode.test.js | 55 ++-- test/string.test.js | 24 +- test/surrogate.test.js | 18 +- test/toJSON.test.js | 18 +- test/typebox.test.js | 4 +- test/typesArray.test.js | 68 ++--- test/unknownFormats.test.js | 10 +- test/webpack.test.js | 4 +- 55 files changed, 912 insertions(+), 1060 deletions(-) delete mode 100644 .taprc diff --git a/.gitignore b/.gitignore index 2b6aed4e..3c21249e 100644 --- a/.gitignore +++ b/.gitignore @@ -147,6 +147,3 @@ yarn.lock # editor files .vscode .idea - -#tap files -.tap/ diff --git a/.taprc b/.taprc deleted file mode 100644 index ed623b2e..00000000 --- a/.taprc +++ /dev/null @@ -1,7 +0,0 @@ -disable-coverage: true - -files: - - test/**/*.test.js - -plugin: - - "!@tapjs/typescript" diff --git a/package.json b/package.json index 6dc0b578..6528621d 100644 --- a/package.json +++ b/package.json @@ -13,7 +13,7 @@ "lint": "standard", "lint:fix": "standard --fix", "test:typescript": "tsd", - "test:unit": "tap", + "test:unit": "c8 node --test", "test": "npm run test:unit && npm run test:typescript" }, "precommit": [ @@ -40,13 +40,13 @@ "@fastify/pre-commit": "^2.1.0", "@sinclair/typebox": "^0.33.4", "benchmark": "^2.1.4", + "c8": "^10.1.2", "cli-select": "^1.1.2", "compile-json-stringify": "^0.1.2", "fast-json-stringify": ".", "is-my-json-valid": "^2.20.6", "simple-git": "^3.23.0", "standard": "^17.1.0", - "tap": "^19.2.5", "tsd": "^0.31.0", "webpack": "^5.90.3" }, diff --git a/test/additionalProperties.test.js b/test/additionalProperties.test.js index be7bf26d..a42e176b 100644 --- a/test/additionalProperties.test.js +++ b/test/additionalProperties.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('additionalProperties', (t) => { @@ -19,7 +19,7 @@ test('additionalProperties', (t) => { }) const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true } } - t.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}') + t.assert.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}') }) test('additionalProperties should not change properties', (t) => { @@ -38,7 +38,7 @@ test('additionalProperties should not change properties', (t) => { }) const obj = { foo: '42', ofoo: 42 } - t.equal(stringify(obj), '{"foo":"42","ofoo":42}') + t.assert.equal(stringify(obj), '{"foo":"42","ofoo":42}') }) test('additionalProperties should not change properties and patternProperties', (t) => { @@ -62,7 +62,7 @@ test('additionalProperties should not change properties and patternProperties', }) const obj = { foo: '42', ofoo: 42, test: '42' } - t.equal(stringify(obj), '{"foo":"42","ofoo":"42","test":42}') + t.assert.equal(stringify(obj), '{"foo":"42","ofoo":"42","test":42}') }) test('additionalProperties set to true, use of fast-safe-stringify', (t) => { @@ -75,7 +75,7 @@ test('additionalProperties set to true, use of fast-safe-stringify', (t) => { }) const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } } - t.equal(stringify(obj), '{"foo":true,"ofoo":42,"arrfoo":["array","test"],"objfoo":{"a":"world"}}') + t.assert.equal(stringify(obj), '{"foo":true,"ofoo":42,"arrfoo":["array","test"],"objfoo":{"a":"world"}}') }) test('additionalProperties - string coerce', (t) => { @@ -90,7 +90,7 @@ test('additionalProperties - string coerce', (t) => { }) const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } } - t.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}') + t.assert.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}') }) test('additionalProperties - number skip', (t) => { @@ -106,7 +106,7 @@ test('additionalProperties - number skip', (t) => { // const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } } const obj = { foo: true, ofoo: '42' } - t.equal(stringify(obj), '{"foo":1,"ofoo":42}') + t.assert.equal(stringify(obj), '{"foo":1,"ofoo":42}') }) test('additionalProperties - boolean coerce', (t) => { @@ -121,7 +121,7 @@ test('additionalProperties - boolean coerce', (t) => { }) const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { a: true } } - t.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}') + t.assert.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}') }) test('additionalProperties - object coerce', (t) => { @@ -141,7 +141,7 @@ test('additionalProperties - object coerce', (t) => { }) const obj = { objfoo: { answer: 42 } } - t.equal(stringify(obj), '{"objfoo":{"answer":42}}') + t.assert.equal(stringify(obj), '{"objfoo":{"answer":42}}') }) test('additionalProperties - array coerce', (t) => { @@ -159,10 +159,10 @@ test('additionalProperties - array coerce', (t) => { }) const coercibleValues = { arrfoo: [1, 2] } - t.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}') + t.assert.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}') const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } } - t.throws(() => stringify(incoercibleValues)) + t.assert.throws(() => stringify(incoercibleValues)) }) test('additionalProperties with empty schema', (t) => { @@ -173,7 +173,7 @@ test('additionalProperties with empty schema', (t) => { }) const obj = { a: 1, b: true, c: null } - t.equal(stringify(obj), '{"a":1,"b":true,"c":null}') + t.assert.equal(stringify(obj), '{"a":1,"b":true,"c":null}') }) test('additionalProperties with nested empty schema', (t) => { @@ -187,7 +187,7 @@ test('additionalProperties with nested empty schema', (t) => { }) const obj = { data: { a: 1, b: true, c: null } } - t.equal(stringify(obj), '{"data":{"a":1,"b":true,"c":null}}') + t.assert.equal(stringify(obj), '{"data":{"a":1,"b":true,"c":null}}') }) test('nested additionalProperties', (t) => { @@ -207,7 +207,7 @@ test('nested additionalProperties', (t) => { }) const obj = [{ ap: { value: 'string' } }] - t.equal(stringify(obj), '[{"ap":{"value":"string"}}]') + t.assert.equal(stringify(obj), '[{"ap":{"value":"string"}}]') }) test('very nested additionalProperties', (t) => { @@ -244,7 +244,7 @@ test('very nested additionalProperties', (t) => { }) const obj = [{ ap: { nested: { moarNested: { finally: { value: 'str' } } } } }] - t.equal(stringify(obj), '[{"ap":{"nested":{"moarNested":{"finally":{"value":"str"}}}}}]') + t.assert.equal(stringify(obj), '[{"ap":{"nested":{"moarNested":{"finally":{"value":"str"}}}}}]') }) test('nested additionalProperties set to true', (t) => { @@ -261,7 +261,7 @@ test('nested additionalProperties set to true', (t) => { }) const obj = { ap: { value: 'string', someNumber: 42 } } - t.equal(stringify(obj), '{"ap":{"value":"string","someNumber":42}}') + t.assert.equal(stringify(obj), '{"ap":{"value":"string","someNumber":42}}') }) test('field passed to fastSafeStringify as undefined should be removed', (t) => { @@ -278,7 +278,7 @@ test('field passed to fastSafeStringify as undefined should be removed', (t) => }) const obj = { ap: { value: 'string', someNumber: undefined } } - t.equal(stringify(obj), '{"ap":{"value":"string"}}') + t.assert.equal(stringify(obj), '{"ap":{"value":"string"}}') }) test('property without type but with enum, will acts as additionalProperties', (t) => { @@ -294,7 +294,7 @@ test('property without type but with enum, will acts as additionalProperties', ( }) const obj = { ap: { additional: 'field' } } - t.equal(stringify(obj), '{"ap":{"additional":"field"}}') + t.assert.equal(stringify(obj), '{"ap":{"additional":"field"}}') }) test('property without type but with enum, will acts as additionalProperties without overwriting', (t) => { @@ -311,7 +311,7 @@ test('property without type but with enum, will acts as additionalProperties wit }) const obj = { ap: { additional: 'field' } } - t.equal(stringify(obj), '{"ap":{}}') + t.assert.equal(stringify(obj), '{"ap":{}}') }) test('function and symbol references are not serialized as undefined', (t) => { @@ -328,5 +328,5 @@ test('function and symbol references are not serialized as undefined', (t) => { }) const obj = { str: 'x', test: 'test', meth: () => 'x', sym: Symbol('x') } - t.equal(stringify(obj), '{"str":"x","test":"test"}') + t.assert.equal(stringify(obj), '{"str":"x","test":"test"}') }) diff --git a/test/allof.test.js b/test/allof.test.js index 5c80873d..fe3d2c20 100644 --- a/test/allof.test.js +++ b/test/allof.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') process.env.TZ = 'UTC' @@ -17,7 +17,7 @@ test('allOf: combine type and format ', (t) => { const stringify = build(schema) const date = new Date(1674263005800) const value = stringify(date) - t.equal(value, '"01:03:25"') + t.assert.equal(value, '"01:03:25"') }) test('allOf: combine additional properties ', (t) => { @@ -35,7 +35,7 @@ test('allOf: combine additional properties ', (t) => { const stringify = build(schema) const data = { property: true } const value = stringify(data) - t.equal(value, JSON.stringify(data)) + t.assert.equal(value, JSON.stringify(data)) }) test('allOf: combine pattern properties', (t) => { @@ -57,7 +57,7 @@ test('allOf: combine pattern properties', (t) => { const stringify = build(schema) const data = { foo: 42 } const value = stringify(data) - t.equal(value, JSON.stringify(data)) + t.assert.equal(value, JSON.stringify(data)) }) test('object with allOf and multiple schema on the allOf', (t) => { @@ -101,7 +101,7 @@ test('object with allOf and multiple schema on the allOf', (t) => { id: 1 }) } catch (e) { - t.equal(e.message, '"name" is required!') + t.assert.equal(e.message, '"name" is required!') } try { @@ -109,15 +109,15 @@ test('object with allOf and multiple schema on the allOf', (t) => { name: 'string' }) } catch (e) { - t.equal(e.message, '"id" is required!') + t.assert.equal(e.message, '"id" is required!') } - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: 'string' }), '{"name":"string","id":1}') - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: 'string', tag: 'otherString' @@ -149,7 +149,7 @@ test('object with allOf and one schema on the allOf', (t) => { const value = stringify({ id: 1 }) - t.equal(value, '{"id":1}') + t.assert.equal(value, '{"id":1}') }) test('object with allOf and no schema on the allOf', (t) => { @@ -165,7 +165,7 @@ test('object with allOf and no schema on the allOf', (t) => { build(schema) t.fail() } catch (e) { - t.equal(e.message, 'schema is invalid: data/allOf must NOT have fewer than 1 items') + t.assert.equal(e.message, 'schema is invalid: data/allOf must NOT have fewer than 1 items') } }) @@ -217,7 +217,7 @@ test('object with nested allOfs', (t) => { id3: 3, id4: 4 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1,"id2":2,"id3":3}') + t.assert.equal(value, '{"id1":1,"id2":2,"id3":3}') }) test('object with anyOf nested inside allOf', (t) => { @@ -286,7 +286,7 @@ test('object with anyOf nested inside allOf', (t) => { obj: { nested: 'yes' }, nestedObj: { nested: 'yes' } }) - t.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}') + t.assert.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}') }) test('object with $ref in allOf', (t) => { @@ -317,7 +317,7 @@ test('object with $ref in allOf', (t) => { id1: 1, id2: 2 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1}') + t.assert.equal(value, '{"id1":1}') }) test('object with $ref and other object in allOf', (t) => { @@ -357,7 +357,7 @@ test('object with $ref and other object in allOf', (t) => { id2: 2, id3: 3 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1,"id2":2}') + t.assert.equal(value, '{"id1":1,"id2":2}') }) test('object with multiple $refs in allOf', (t) => { @@ -400,7 +400,7 @@ test('object with multiple $refs in allOf', (t) => { id2: 2, id3: 3 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1,"id2":2}') + t.assert.equal(value, '{"id1":1,"id2":2}') }) test('allOf with nested allOf in $ref', (t) => { @@ -452,7 +452,7 @@ test('allOf with nested allOf in $ref', (t) => { id3: 3, id4: 4 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1,"id2":2,"id3":3}') + t.assert.equal(value, '{"id1":1,"id2":2,"id3":3}') }) test('object with external $refs in allOf', (t) => { @@ -505,7 +505,7 @@ test('object with external $refs in allOf', (t) => { id2: 2, id3: 3 // extra prop shouldn't be in result }) - t.equal(value, '{"id1":1,"id2":2}') + t.assert.equal(value, '{"id1":1,"id2":2}') }) test('allof with local anchor reference', (t) => { @@ -550,7 +550,7 @@ test('allof with local anchor reference', (t) => { const stringify = build(schema, { schema: externalSchemas }) const data = { type: 'foo', validation: 'bar' } - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) test('allOf: multiple nested $ref properties', (t) => { @@ -601,12 +601,12 @@ test('allOf: multiple nested $ref properties', (t) => { const stringify = build(schema, { schema: [externalSchema1, externalSchema2] }) - t.equal(stringify({ id1: 1 }), JSON.stringify({ id1: 1 })) - t.equal(stringify({ id2: 2 }), JSON.stringify({ id2: 2 })) + t.assert.equal(stringify({ id1: 1 }), JSON.stringify({ id1: 1 })) + t.assert.equal(stringify({ id2: 2 }), JSON.stringify({ id2: 2 })) }) test('allOf: throw Error if types mismatch ', (t) => { - t.plan(3) + t.plan(1) const schema = { allOf: [ @@ -614,18 +614,16 @@ test('allOf: throw Error if types mismatch ', (t) => { { type: 'number' } ] } - try { + t.assert.throws(() => { build(schema) - t.fail('should throw the MergeError') - } catch (error) { - t.ok(error instanceof Error) - t.equal(error.message, 'Failed to merge "type" keyword schemas.') - t.same(error.schemas, [['string'], ['number']]) - } + }, { + message: 'Failed to merge "type" keyword schemas.', + schemas: [['string'], ['number']] + }) }) test('allOf: throw Error if format mismatch ', (t) => { - t.plan(3) + t.plan(1) const schema = { allOf: [ @@ -633,14 +631,12 @@ test('allOf: throw Error if format mismatch ', (t) => { { format: 'time' } ] } - try { + t.assert.throws(() => { build(schema) - t.fail('should throw the MergeError') - } catch (error) { - t.ok(error instanceof Error) - t.equal(error.message, 'Failed to merge "format" keyword schemas.') - t.same(error.schemas, ['date', 'time']) - } + }, { + message: 'Failed to merge "format" keyword schemas.' + // schemas: ['date', 'time'] + }) }) test('recursive nested allOfs', (t) => { @@ -658,7 +654,7 @@ test('recursive nested allOfs', (t) => { const data = { foo: {} } const stringify = build(schema) - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) test('recursive nested allOfs', (t) => { @@ -676,7 +672,7 @@ test('recursive nested allOfs', (t) => { const data = { foo: {} } const stringify = build(schema) - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) test('external recursive allOfs', (t) => { @@ -715,7 +711,7 @@ test('external recursive allOfs', (t) => { } } const stringify = build(schema, { schema: { externalSchema } }) - t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}') + t.assert.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}') }) test('do not crash with $ref prop', (t) => { @@ -751,5 +747,5 @@ test('do not crash with $ref prop', (t) => { $ref: 'true' } }) - t.equal(value, '{"outside":{"$ref":"true"}}') + t.assert.equal(value, '{"outside":{"$ref":"true"}}') }) diff --git a/test/any.test.js b/test/any.test.js index be136abb..a73aa0c1 100644 --- a/test/any.test.js +++ b/test/any.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('object with nested random property', (t) => { @@ -16,19 +16,19 @@ test('object with nested random property', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: 'string' }), '{"id":1,"name":"string"}') - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: { first: 'name', last: 'last' } }), '{"id":1,"name":{"first":"name","last":"last"}}') - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: null }), '{"id":1,"name":null}') - t.equal(stringify({ + t.assert.equal(stringify({ id: 1, name: ['first', 'last'] }), '{"id":1,"name":["first","last"]}') }) @@ -45,7 +45,7 @@ test('object with empty schema with $id: undefined set', (t) => { } } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ name: 'string' }), '{"name":"string"}') }) @@ -61,7 +61,7 @@ test('array with random items', (t) => { const stringify = build(schema) const value = stringify([1, 'string', null]) - t.equal(value, '[1,"string",null]') + t.assert.equal(value, '[1,"string",null]') }) test('empty schema', (t) => { @@ -71,13 +71,13 @@ test('empty schema', (t) => { const stringify = build(schema) - t.equal(stringify(null), 'null') - t.equal(stringify(1), '1') - t.equal(stringify(true), 'true') - t.equal(stringify('hello'), '"hello"') - t.equal(stringify({}), '{}') - t.equal(stringify({ x: 10 }), '{"x":10}') - t.equal(stringify([true, 1, 'hello']), '[true,1,"hello"]') + t.assert.equal(stringify(null), 'null') + t.assert.equal(stringify(1), '1') + t.assert.equal(stringify(true), 'true') + t.assert.equal(stringify('hello'), '"hello"') + t.assert.equal(stringify({}), '{}') + t.assert.equal(stringify({ x: 10 }), '{"x":10}') + t.assert.equal(stringify([true, 1, 'hello']), '[true,1,"hello"]') }) test('empty schema on nested object', (t) => { @@ -92,13 +92,13 @@ test('empty schema on nested object', (t) => { const stringify = build(schema) - t.equal(stringify({ x: null }), '{"x":null}') - t.equal(stringify({ x: 1 }), '{"x":1}') - t.equal(stringify({ x: true }), '{"x":true}') - t.equal(stringify({ x: 'hello' }), '{"x":"hello"}') - t.equal(stringify({ x: {} }), '{"x":{}}') - t.equal(stringify({ x: { x: 10 } }), '{"x":{"x":10}}') - t.equal(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}') + t.assert.equal(stringify({ x: null }), '{"x":null}') + t.assert.equal(stringify({ x: 1 }), '{"x":1}') + t.assert.equal(stringify({ x: true }), '{"x":true}') + t.assert.equal(stringify({ x: 'hello' }), '{"x":"hello"}') + t.assert.equal(stringify({ x: {} }), '{"x":{}}') + t.assert.equal(stringify({ x: { x: 10 } }), '{"x":{"x":10}}') + t.assert.equal(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}') }) test('empty schema on array', (t) => { @@ -111,7 +111,7 @@ test('empty schema on array', (t) => { const stringify = build(schema) - t.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]') + t.assert.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]') }) test('empty schema on anyOf', (t) => { @@ -147,10 +147,10 @@ test('empty schema on anyOf', (t) => { const stringify = build(schema) - t.equal(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}') - t.equal(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}') - t.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}') - t.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}') + t.assert.equal(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}') + t.assert.equal(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}') + t.assert.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}') + t.assert.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}') }) test('should throw a TypeError with the path to the key of the invalid value /1', (t) => { @@ -186,7 +186,7 @@ test('should throw a TypeError with the path to the key of the invalid value /1' const stringify = build(schema) - t.throws(() => stringify({ kind: 'Baz', value: 1 }), new TypeError('The value of \'#\' does not match schema definition.')) + t.assert.throws(() => stringify({ kind: 'Baz', value: 1 }), new TypeError('The value of \'#\' does not match schema definition.')) }) test('should throw a TypeError with the path to the key of the invalid value /2', (t) => { @@ -227,5 +227,5 @@ test('should throw a TypeError with the path to the key of the invalid value /2' const stringify = build(schema) - t.throws(() => stringify({ data: { kind: 'Baz', value: 1 } }), new TypeError('The value of \'#/properties/data\' does not match schema definition.')) + t.assert.throws(() => stringify({ data: { kind: 'Baz', value: 1 } }), new TypeError('The value of \'#/properties/data\' does not match schema definition.')) }) diff --git a/test/anyof.test.js b/test/anyof.test.js index cec222f7..baa81060 100644 --- a/test/anyof.test.js +++ b/test/anyof.test.js @@ -1,6 +1,6 @@ 'use strict' -const { test } = require('tap') +const { test } = require('node:test') const build = require('..') process.env.TZ = 'UTC' @@ -23,11 +23,11 @@ test('object with multiple types field', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ str: 'string' }), '{"str":"string"}') - t.equal(stringify({ + t.assert.equal(stringify({ str: true }), '{"str":true}') }) @@ -55,11 +55,11 @@ test('object with field of type object or null', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ prop: null }), '{"prop":null}') - t.equal(stringify({ + t.assert.equal(stringify({ prop: { str: 'string' } @@ -89,13 +89,13 @@ test('object with field of type object or array', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ prop: { str: 'string' } }), '{"prop":{"str":"string"}}') - t.equal(stringify({ + t.assert.equal(stringify({ prop: ['string'] }), '{"prop":["string"]}') }) @@ -115,7 +115,7 @@ test('object with field of type string and coercion disable ', (t) => { } } const stringify = build(schema) - t.throws(() => stringify({ str: 1 })) + t.assert.throws(() => stringify({ str: 1 })) }) test('object with field of type string and coercion enable ', (t) => { @@ -143,7 +143,7 @@ test('object with field of type string and coercion enable ', (t) => { const value = stringify({ str: 1 }) - t.equal(value, '{"str":"1"}') + t.assert.equal(value, '{"str":"1"}') }) test('object with field with type union of multiple objects', (t) => { @@ -177,9 +177,9 @@ test('object with field with type union of multiple objects', (t) => { const stringify = build(schema) - t.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}') + t.assert.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}') - t.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}') + t.assert.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}') }) test('null value in schema', (t) => { @@ -219,10 +219,10 @@ test('symbol value in schema', (t) => { } const stringify = build(schema) - t.equal(stringify({ value: 'foo' }), '{"value":"foo"}') - t.equal(stringify({ value: 'bar' }), '{"value":"bar"}') - t.equal(stringify({ value: 'baz' }), '{"value":"baz"}') - t.throws(() => stringify({ value: 'qux' })) + t.assert.equal(stringify({ value: 'foo' }), '{"value":"foo"}') + t.assert.equal(stringify({ value: 'bar' }), '{"value":"bar"}') + t.assert.equal(stringify({ value: 'baz' }), '{"value":"baz"}') + t.assert.throws(() => stringify({ value: 'qux' })) }) test('anyOf and $ref together', (t) => { @@ -251,9 +251,9 @@ test('anyOf and $ref together', (t) => { const stringify = build(schema) - t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}') + t.assert.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}') - t.equal(stringify({ cs: true }), '{"cs":true}') + t.assert.equal(stringify({ cs: true }), '{"cs":true}') }) test('anyOf and $ref: 2 levels are fine', (t) => { @@ -289,7 +289,7 @@ test('anyOf and $ref: 2 levels are fine', (t) => { const stringify = build(schema) const value = stringify({ cs: 3 }) - t.equal(value, '{"cs":3}') + t.assert.equal(value, '{"cs":3}') }) test('anyOf and $ref: multiple levels should throw at build.', (t) => { @@ -328,9 +328,9 @@ test('anyOf and $ref: multiple levels should throw at build.', (t) => { const stringify = build(schema) - t.equal(stringify({ cs: 3 }), '{"cs":3}') - t.equal(stringify({ cs: true }), '{"cs":true}') - t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}') + t.assert.equal(stringify({ cs: 3 }), '{"cs":3}') + t.assert.equal(stringify({ cs: true }), '{"cs":true}') + t.assert.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}') }) test('anyOf and $ref - multiple external $ref', (t) => { @@ -383,10 +383,8 @@ test('anyOf and $ref - multiple external $ref', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"prop":{"prop2":"test"}}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}') }) test('anyOf looks for all of the array items', (t) => { @@ -421,7 +419,7 @@ test('anyOf looks for all of the array items', (t) => { const stringify = build(schema) const value = stringify([{ savedId: 'great' }, { error: 'oops' }]) - t.equal(value, '[{"savedId":"great"},{"error":"oops"}]') + t.assert.equal(value, '[{"savedId":"great"},{"error":"oops"}]') }) test('anyOf with enum with more than 100 entries', (t) => { @@ -443,7 +441,7 @@ test('anyOf with enum with more than 100 entries', (t) => { const stringify = build(schema) const value = stringify(['EUR', 'USD', null]) - t.equal(value, '["EUR","USD",null]') + t.assert.equal(value, '["EUR","USD",null]') }) test('anyOf object with field date-time of type string with format or null', (t) => { @@ -465,7 +463,7 @@ test('anyOf object with field date-time of type string with format or null', (t) const withOneOfStringify = build(withOneOfSchema) - t.equal(withOneOfStringify({ + t.assert.equal(withOneOfStringify({ prop: toStringify }), `{"prop":"${toStringify.toISOString()}"}`) }) @@ -495,7 +493,7 @@ test('anyOf object with nested field date-time of type string with format or nul prop: { nestedProp: new Date() } } - t.equal(withOneOfStringify(data), JSON.stringify(data)) + t.assert.equal(withOneOfStringify(data), JSON.stringify(data)) }) test('anyOf object with nested field date of type string with format or null', (t) => { @@ -523,7 +521,7 @@ test('anyOf object with nested field date of type string with format or null', ( prop: { nestedProp: new Date(1674263005800) } } - t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"2023-01-21"}}') + t.assert.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"2023-01-21"}}') }) test('anyOf object with nested field time of type string with format or null', (t) => { @@ -550,7 +548,7 @@ test('anyOf object with nested field time of type string with format or null', ( const data = { prop: { nestedProp: new Date(1674263005800) } } - t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"01:03:25"}}') + t.assert.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"01:03:25"}}') }) test('anyOf object with field date of type string with format or null', (t) => { @@ -571,7 +569,7 @@ test('anyOf object with field date of type string with format or null', (t) => { } const withOneOfStringify = build(withOneOfSchema) - t.equal(withOneOfStringify({ + t.assert.equal(withOneOfStringify({ prop: toStringify }), '{"prop":"2011-01-01"}') }) @@ -594,7 +592,7 @@ test('anyOf object with invalid field date of type string with format or null', } const withOneOfStringify = build(withOneOfSchema) - t.throws(() => withOneOfStringify({ prop: toStringify })) + t.assert.throws(() => withOneOfStringify({ prop: toStringify })) }) test('anyOf with a nested external schema', (t) => { @@ -614,7 +612,7 @@ test('anyOf with a nested external schema', (t) => { const schema = { anyOf: [{ $ref: 'external' }] } const stringify = build(schema, { schema: externalSchemas }) - t.equal(stringify('foo'), '"foo"') + t.assert.equal(stringify('foo'), '"foo"') }) test('object with ref and validated properties', (t) => { @@ -642,7 +640,7 @@ test('object with ref and validated properties', (t) => { } const stringify = build(schema, { schema: externalSchemas }) - t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}') + t.assert.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}') }) test('anyOf required props', (t) => { @@ -659,9 +657,9 @@ test('anyOf required props', (t) => { anyOf: [{ required: ['prop2'] }, { required: ['prop3'] }] } const stringify = build(schema) - t.equal(stringify({ prop1: 'test', prop2: 'test2' }), '{"prop1":"test","prop2":"test2"}') - t.equal(stringify({ prop1: 'test', prop3: 'test3' }), '{"prop1":"test","prop3":"test3"}') - t.equal(stringify({ prop1: 'test', prop2: 'test2', prop3: 'test3' }), '{"prop1":"test","prop2":"test2","prop3":"test3"}') + t.assert.equal(stringify({ prop1: 'test', prop2: 'test2' }), '{"prop1":"test","prop2":"test2"}') + t.assert.equal(stringify({ prop1: 'test', prop3: 'test3' }), '{"prop1":"test","prop3":"test3"}') + t.assert.equal(stringify({ prop1: 'test', prop2: 'test2', prop3: 'test3' }), '{"prop1":"test","prop2":"test2","prop3":"test3"}') }) test('anyOf required props', (t) => { @@ -686,9 +684,9 @@ test('anyOf required props', (t) => { ] } const stringify = build(schema) - t.equal(stringify({ prop1: 'test1' }), '{"prop1":"test1"}') - t.equal(stringify({ prop2: 'test2' }), '{"prop2":"test2"}') - t.equal(stringify({ prop1: 'test1', prop2: 'test2' }), '{"prop1":"test1","prop2":"test2"}') + t.assert.equal(stringify({ prop1: 'test1' }), '{"prop1":"test1"}') + t.assert.equal(stringify({ prop2: 'test2' }), '{"prop2":"test2"}') + t.assert.equal(stringify({ prop1: 'test1', prop2: 'test2' }), '{"prop1":"test1","prop2":"test2"}') }) test('recursive nested anyOfs', (t) => { @@ -706,7 +704,7 @@ test('recursive nested anyOfs', (t) => { const data = { foo: {} } const stringify = build(schema) - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) test('recursive nested anyOfs', (t) => { @@ -724,7 +722,7 @@ test('recursive nested anyOfs', (t) => { const data = { foo: {} } const stringify = build(schema) - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) test('external recursive anyOfs', (t) => { @@ -763,7 +761,7 @@ test('external recursive anyOfs', (t) => { } } const stringify = build(schema, { schema: { externalSchema } }) - t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}') + t.assert.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}') }) test('should build merged schemas twice', (t) => { @@ -784,11 +782,11 @@ test('should build merged schemas twice', (t) => { { const stringify = build(schema) - t.equal(stringify({ enums: 'FOO' }), '{"enums":"FOO"}') + t.assert.equal(stringify({ enums: 'FOO' }), '{"enums":"FOO"}') } { const stringify = build(schema) - t.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}') + t.assert.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}') } }) diff --git a/test/array.test.js b/test/array.test.js index fbffe02f..dc643226 100644 --- a/test/array.test.js +++ b/test/array.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') const Ajv = require('ajv') @@ -8,7 +8,7 @@ const Ajv = require('ajv') test('error on invalid largeArrayMechanism', (t) => { t.plan(1) - t.throws(() => build({ + t.assert.throws(() => build({ title: 'large array of null values with default mechanism', type: 'object', properties: { @@ -31,9 +31,9 @@ function buildTest (schema, toStringify, options) { const stringify = build(schema, options) const output = stringify(toStringify) - t.same(JSON.parse(output), JSON.parse(JSON.stringify(toStringify))) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.deepStrictEqual(JSON.parse(output), JSON.parse(JSON.stringify(toStringify))) + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) } @@ -216,7 +216,7 @@ test('invalid items throw', (t) => { } } const stringify = build(schema) - t.throws(() => stringify({ args: ['invalid'] })) + t.assert.throws(() => stringify({ args: ['invalid'] })) }) buildTest({ @@ -258,7 +258,7 @@ test('array items is a list of schema and additionalItems is true, just the desc ] }) - t.equal(result, '{"foo":["foo","bar",1]}') + t.assert.equal(result, '{"foo":["foo","bar",1]}') }) test('array items is a list of schema and additionalItems is true, just the described item is validated', (t) => { @@ -287,7 +287,7 @@ test('array items is a list of schema and additionalItems is true, just the desc foo: ['foo'] }) - t.equal(result, '{"foo":["foo"]}') + t.assert.equal(result, '{"foo":["foo"]}') }) test('array items is a list of schema and additionalItems is false /1', (t) => { @@ -307,7 +307,7 @@ test('array items is a list of schema and additionalItems is false /1', (t) => { } const stringify = build(schema) - t.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.')) + t.assert.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.')) }) test('array items is a list of schema and additionalItems is false /2', (t) => { @@ -329,9 +329,9 @@ test('array items is a list of schema and additionalItems is false /2', (t) => { const stringify = build(schema) - t.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.')) - t.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.')) - t.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.')) + t.assert.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.')) + t.assert.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.')) + t.assert.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.')) }) test('array items is a schema and additionalItems is false', (t) => { @@ -354,8 +354,8 @@ test('array items is a schema and additionalItems is false', (t) => { const ajv = new Ajv({ allErrors: true, strict: false }) const validate = ajv.compile(schema) - t.same(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}') - t.equal(validate({ foo: ['foo', 'bar'] }), true) + t.assert.equal(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}') + t.assert.equal(validate({ foo: ['foo', 'bar'] }), true) }) // https://github.com/fastify/fast-json-stringify/issues/279 @@ -402,7 +402,7 @@ test('object array with anyOf and symbol', (t) => { { name: 'name-0', option: 'Foo' }, { name: 'name-1', option: 'Bar' } ]) - t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]') + t.assert.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]') }) test('different arrays with same item schemas', (t) => { @@ -427,7 +427,7 @@ test('different arrays with same item schemas', (t) => { const stringify = build(schema) const data = { array1: ['bar'], array2: ['foo', 'bar'] } - t.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}') + t.assert.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}') }) const largeArray = new Array(2e4).fill({ a: 'test', b: 1 }) @@ -557,7 +557,7 @@ buildTest({ test('error on invalid value for largeArraySize /1', (t) => { t.plan(1) - t.throws(() => build({ + t.assert.throws(() => build({ title: 'large array of null values with default mechanism', type: 'object', properties: { @@ -574,7 +574,7 @@ test('error on invalid value for largeArraySize /1', (t) => { test('error on invalid value for largeArraySize /2', (t) => { t.plan(1) - t.throws(() => build({ + t.assert.throws(() => build({ title: 'large array of null values with default mechanism', type: 'object', properties: { @@ -591,7 +591,7 @@ test('error on invalid value for largeArraySize /2', (t) => { test('error on invalid value for largeArraySize /3', (t) => { t.plan(1) - t.throws(() => build({ + t.assert.throws(() => build({ title: 'large array of null values with default mechanism', type: 'object', properties: { diff --git a/test/asNumber.test.js b/test/asNumber.test.js index 5e68b922..94a40b43 100644 --- a/test/asNumber.test.js +++ b/test/asNumber.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') test('asNumber should convert BigInt', (t) => { t.plan(1) @@ -9,5 +9,5 @@ test('asNumber should convert BigInt', (t) => { const number = serializer.asNumber(11753021440n) - t.equal(number, '11753021440') + t.assert.equal(number, '11753021440') }) diff --git a/test/basic.test.js b/test/basic.test.js index 9f6ea5f3..754f4489 100644 --- a/test/basic.test.js +++ b/test/basic.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -12,9 +12,9 @@ function buildTest (schema, toStringify) { const stringify = build(schema) const output = stringify(toStringify) - t.same(JSON.parse(output), toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.deepStrictEqual(JSON.parse(output), toStringify) + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) } @@ -281,41 +281,34 @@ test('throw an error or coerce numbers and integers that are not numbers', (t) = } }) - try { + t.assert.throws(() => { stringify({ age: 'hello ', distance: 'long' }) - t.fail('should throw an error') - } catch (err) { - t.ok(err) - } + }, { message: 'The value "hello " cannot be converted to a number.' }) const result = stringify({ age: '42', distance: true }) - t.same(JSON.parse(result), { age: 42, distance: 1 }) - t.end() + t.assert.deepStrictEqual(JSON.parse(result), { age: 42, distance: 1 }) }) test('Should throw on invalid schema', t => { t.plan(1) - try { + t.assert.throws(() => { build({ type: 'Dinosaur', properties: { claws: { type: 'sharp' } } }) - t.fail('should be an invalid schema') - } catch (err) { - t.ok(err) - } + }, { message: 'schema is invalid: data/properties/claws/type must be equal to one of the allowed values' }) }) test('additionalProperties - throw on unknown type', (t) => { t.plan(1) - try { + t.assert.throws(() => { build({ title: 'check array coerce', type: 'object', @@ -325,15 +318,13 @@ test('additionalProperties - throw on unknown type', (t) => { } }) t.fail('should be an invalid schema') - } catch (err) { - t.ok(err) - } + }, { message: 'schema is invalid: data/additionalProperties/type must be equal to one of the allowed values' }) }) test('patternProperties - throw on unknown type', (t) => { t.plan(1) - try { + t.assert.throws(() => { build({ title: 'check array coerce', type: 'object', @@ -344,10 +335,7 @@ test('patternProperties - throw on unknown type', (t) => { } } }) - t.fail('should be an invalid schema') - } catch (err) { - t.ok(err) - } + }, { message: 'schema is invalid: data/patternProperties/foo/type must be equal to one of the allowed values' }) }) test('render a double quote as JSON /1', (t) => { @@ -362,8 +350,8 @@ test('render a double quote as JSON /1', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a double quote as JSON /2', (t) => { @@ -378,8 +366,8 @@ test('render a double quote as JSON /2', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a long string', (t) => { @@ -394,8 +382,8 @@ test('render a long string', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('returns JSON.stringify if schema type is boolean', t => { @@ -408,5 +396,5 @@ test('returns JSON.stringify if schema type is boolean', t => { const array = [1, true, 'test'] const stringify = build(schema) - t.equal(stringify(array), JSON.stringify(array)) + t.assert.equal(stringify(array), JSON.stringify(array)) }) diff --git a/test/bigint.test.js b/test/bigint.test.js index 02a75d4d..86bb4fa8 100644 --- a/test/bigint.test.js +++ b/test/bigint.test.js @@ -1,7 +1,7 @@ 'use strict' -const t = require('tap') -const test = t.test +const { test } = require('node:test') + const build = require('..') test('render a bigint as JSON', (t) => { @@ -15,7 +15,7 @@ test('render a bigint as JSON', (t) => { const stringify = build(schema) const output = stringify(1615n) - t.equal(output, '1615') + t.assert.equal(output, '1615') }) test('render an object with a bigint as JSON', (t) => { @@ -36,7 +36,7 @@ test('render an object with a bigint as JSON', (t) => { id: 1615n }) - t.equal(output, '{"id":1615}') + t.assert.equal(output, '{"id":1615}') }) test('render an array with a bigint as JSON', (t) => { @@ -53,7 +53,7 @@ test('render an array with a bigint as JSON', (t) => { const stringify = build(schema) const output = stringify([1615n]) - t.equal(output, '[1615]') + t.assert.equal(output, '[1615]') }) test('render an object with an additionalProperty of type bigint as JSON', (t) => { @@ -72,5 +72,5 @@ test('render an object with an additionalProperty of type bigint as JSON', (t) = num: 1615n }) - t.equal(output, '{"num":1615}') + t.assert.equal(output, '{"num":1615}') }) diff --git a/test/clean-cache.test.js b/test/clean-cache.test.js index f7b3ef1d..958fbcaa 100644 --- a/test/clean-cache.test.js +++ b/test/clean-cache.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('Should clean the cache', (t) => { @@ -11,9 +11,10 @@ test('Should clean the cache', (t) => { type: 'string' } - build(schema) - build(schema) - t.pass() + t.assert.doesNotThrow(() => { + build(schema) + build(schema) + }) }) test('Should clean the cache with external schemas', (t) => { @@ -39,7 +40,8 @@ test('Should clean the cache with external schemas', (t) => { } } - build(schema) - build(schema) - t.pass() + t.assert.doesNotThrow(() => { + build(schema) + build(schema) + }) }) diff --git a/test/const.test.js b/test/const.test.js index 644c27f6..48e10525 100644 --- a/test/const.test.js +++ b/test/const.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -20,8 +20,8 @@ test('schema with const string', (t) => { foo: 'bar' }) - t.equal(output, '{"foo":"bar"}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":"bar"}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const string and different input', (t) => { @@ -40,8 +40,8 @@ test('schema with const string and different input', (t) => { foo: 'baz' }) - t.equal(output, '{"foo":"bar"}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":"bar"}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const string and different type input', (t) => { @@ -60,8 +60,8 @@ test('schema with const string and different type input', (t) => { foo: 1 }) - t.equal(output, '{"foo":"bar"}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":"bar"}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const string and no input', (t) => { @@ -78,8 +78,8 @@ test('schema with const string and no input', (t) => { const stringify = build(schema) const output = stringify({}) - t.equal(output, '{}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const string that contains \'', (t) => { @@ -98,8 +98,8 @@ test('schema with const string that contains \'', (t) => { foo: "'bar'" }) - t.equal(output, '{"foo":"\'bar\'"}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":"\'bar\'"}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const number', (t) => { @@ -118,8 +118,8 @@ test('schema with const number', (t) => { foo: 1 }) - t.equal(output, '{"foo":1}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":1}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const number and different input', (t) => { @@ -138,8 +138,8 @@ test('schema with const number and different input', (t) => { foo: 2 }) - t.equal(output, '{"foo":1}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":1}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const bool', (t) => { @@ -158,8 +158,8 @@ test('schema with const bool', (t) => { foo: true }) - t.equal(output, '{"foo":true}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":true}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const number', (t) => { @@ -178,8 +178,8 @@ test('schema with const number', (t) => { foo: 1 }) - t.equal(output, '{"foo":1}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":1}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const null', (t) => { @@ -198,8 +198,8 @@ test('schema with const null', (t) => { foo: null }) - t.equal(output, '{"foo":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const array', (t) => { @@ -218,8 +218,8 @@ test('schema with const array', (t) => { foo: [1, 2, 3] }) - t.equal(output, '{"foo":[1,2,3]}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":[1,2,3]}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const object', (t) => { @@ -238,8 +238,8 @@ test('schema with const object', (t) => { foo: { bar: 'baz' } }) - t.equal(output, '{"foo":{"bar":"baz"}}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":{"bar":"baz"}}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('schema with const and null as type', (t) => { @@ -258,12 +258,12 @@ test('schema with const and null as type', (t) => { foo: null }) - t.equal(output, '{"foo":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') const output2 = stringify({ foo: 'baz' }) - t.equal(output2, '{"foo":"baz"}') - t.ok(validate(JSON.parse(output2)), 'valid schema') + t.assert.equal(output2, '{"foo":"baz"}') + t.assert.ok(validate(JSON.parse(output2)), 'valid schema') }) test('schema with const as nullable', (t) => { @@ -282,14 +282,14 @@ test('schema with const as nullable', (t) => { foo: null }) - t.equal(output, '{"foo":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"foo":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') const output2 = stringify({ foo: 'baz' }) - t.equal(output2, '{"foo":"baz"}') - t.ok(validate(JSON.parse(output2)), 'valid schema') + t.assert.equal(output2, '{"foo":"baz"}') + t.assert.ok(validate(JSON.parse(output2)), 'valid schema') }) test('schema with const and invalid object', (t) => { @@ -309,6 +309,6 @@ test('schema with const and invalid object', (t) => { foo: { foo: 'baz' } }) - t.equal(result, '{"foo":{"foo":"bar"}}') - t.ok(validate(JSON.parse(result)), 'valid schema') + t.assert.equal(result, '{"foo":{"foo":"bar"}}') + t.assert.ok(validate(JSON.parse(result)), 'valid schema') }) diff --git a/test/date.test.js b/test/date.test.js index adf731e1..3d143fa8 100644 --- a/test/date.test.js +++ b/test/date.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -19,8 +19,8 @@ test('render a date in a string as JSON', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a date in a string when format is date-format as ISOString', (t) => { @@ -37,8 +37,8 @@ test('render a date in a string when format is date-format as ISOString', (t) => const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a nullable date in a string when format is date-format as ISOString', (t) => { @@ -56,8 +56,8 @@ test('render a nullable date in a string when format is date-format as ISOString const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a date in a string when format is date as YYYY-MM-DD', (t) => { @@ -74,8 +74,8 @@ test('render a date in a string when format is date as YYYY-MM-DD', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, '"2023-01-21"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"2023-01-21"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a nullable date in a string when format is date as YYYY-MM-DD', (t) => { @@ -93,8 +93,8 @@ test('render a nullable date in a string when format is date as YYYY-MM-DD', (t) const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, '"2023-01-21"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"2023-01-21"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('verify padding for rendered date in a string when format is date', (t) => { @@ -111,8 +111,8 @@ test('verify padding for rendered date in a string when format is date', (t) => const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, '"2020-01-01"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"2020-01-01"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a date in a string when format is time as kk:mm:ss', (t) => { @@ -130,10 +130,10 @@ test('render a date in a string when format is time as kk:mm:ss', (t) => { const output = stringify(toStringify) validate(JSON.parse(output)) - t.equal(validate.errors, null) + t.assert.equal(validate.errors, null) - t.equal(output, '"01:03:25"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"01:03:25"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a nullable date in a string when format is time as kk:mm:ss', (t) => { @@ -152,10 +152,10 @@ test('render a nullable date in a string when format is time as kk:mm:ss', (t) = const output = stringify(toStringify) validate(JSON.parse(output)) - t.equal(validate.errors, null) + t.assert.equal(validate.errors, null) - t.equal(output, '"01:03:25"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"01:03:25"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a midnight time', (t) => { @@ -173,10 +173,10 @@ test('render a midnight time', (t) => { const output = stringify(midnight) validate(JSON.parse(output)) - t.equal(validate.errors, null) + t.assert.equal(validate.errors, null) - t.equal(output, '"00:03:25"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"00:03:25"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('verify padding for rendered date in a string when format is time', (t) => { @@ -194,10 +194,10 @@ test('verify padding for rendered date in a string when format is time', (t) => const output = stringify(toStringify) validate(JSON.parse(output)) - t.equal(validate.errors, null) + t.assert.equal(validate.errors, null) - t.equal(output, '"01:01:01"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"01:01:01"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a nested object in a string when type is date-format as ISOString', (t) => { @@ -219,11 +219,11 @@ test('render a nested object in a string when type is date-format as ISOString', const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) -test('serializing null value', t => { +test('serializing null value', async t => { const input = { updatedAt: null } function createSchema (properties) { @@ -247,10 +247,10 @@ test('serializing null value', t => { t.plan(3) - t.test('type::string', t => { + await t.test('type::string', async t => { t.plan(3) - t.test('format::date-time', t => { + await t.test('format::date-time', t => { t.plan(2) const prop = { @@ -265,11 +265,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a date-time format') }) - t.test('format::date', t => { + await t.test('format::date', t => { t.plan(2) const prop = { @@ -284,11 +284,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a date format') }) - t.test('format::time', t => { + await t.test('format::time', t => { t.plan(2) const prop = { @@ -303,15 +303,15 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a time format') }) }) - t.test('type::array', t => { + await t.test('type::array', async t => { t.plan(6) - t.test('format::date-time', t => { + await t.test('format::date-time', t => { t.plan(2) const prop = { @@ -326,11 +326,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a date-time format') }) - t.test('format::date', t => { + await t.test('format::date', t => { t.plan(2) const prop = { @@ -345,11 +345,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a date format') }) - t.test('format::date', t => { + await t.test('format::date', t => { t.plan(2) const prop = { @@ -364,11 +364,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":""}') - t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format') + t.assert.equal(output, '{"updatedAt":""}') + t.assert.equal(validate(JSON.parse(output)), false, 'an empty string is not a date format') }) - t.test('format::time, Date object', t => { + await t.test('format::time, Date object', t => { t.plan(1) const schema = { @@ -389,10 +389,10 @@ test('serializing null value', t => { const input = { updatedAt: date } const { output } = serialize(schema, input) - t.equal(output, JSON.stringify({ updatedAt: '01:03:25' })) + t.assert.equal(output, JSON.stringify({ updatedAt: '01:03:25' })) }) - t.test('format::time, Date object', t => { + await t.test('format::time, Date object', t => { t.plan(1) const schema = { @@ -407,10 +407,10 @@ test('serializing null value', t => { const date = new Date(1674263005800) const { output } = serialize(schema, date) - t.equal(output, '"01:03:25"') + t.assert.equal(output, '"01:03:25"') }) - t.test('format::time, Date object', t => { + await t.test('format::time, Date object', t => { t.plan(1) const schema = { @@ -424,14 +424,14 @@ test('serializing null value', t => { const { output } = serialize(schema, 42) - t.equal(output, JSON.stringify(42)) + t.assert.equal(output, JSON.stringify(42)) }) }) - t.test('type::array::nullable', t => { + await t.test('type::array::nullable', async t => { t.plan(3) - t.test('format::date-time', t => { + await t.test('format::date-time', t => { t.plan(2) const prop = { @@ -446,11 +446,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"updatedAt":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) - t.test('format::date', t => { + await t.test('format::date', t => { t.plan(2) const prop = { @@ -465,11 +465,11 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"updatedAt":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) - t.test('format::time', t => { + await t.test('format::time', t => { t.plan(2) const prop = { @@ -484,8 +484,8 @@ test('serializing null value', t => { validate } = serialize(createSchema(prop), input) - t.equal(output, '{"updatedAt":null}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"updatedAt":null}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) }) }) @@ -503,7 +503,7 @@ test('Validate Date object as string type', (t) => { const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) + t.assert.equal(output, JSON.stringify(toStringify)) }) test('nullable date', (t) => { @@ -524,7 +524,7 @@ test('nullable date', (t) => { const data = new Date(1674263005800) const result = stringify(data) - t.same(result, '"2023-01-21"') + t.assert.equal(result, '"2023-01-21"') }) test('non-date format should not affect data serialization (issue #491)', (t) => { @@ -543,7 +543,7 @@ test('non-date format should not affect data serialization (issue #491)', (t) => const stringify = build(schema) const data = { hello: 123n } - t.equal(stringify(data), '{"hello":"123"}') + t.assert.equal(stringify(data), '{"hello":"123"}') }) test('should serialize also an invalid string value, even if it is not a valid date', (t) => { @@ -561,8 +561,8 @@ test('should serialize also an invalid string value, even if it is not a valid d const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.not(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.equal(validate(JSON.parse(output)), false, 'valid schema') }) test('should throw an error if value can not be transformed to date-time', (t) => { @@ -579,8 +579,8 @@ test('should throw an error if value can not be transformed to date-time', (t) = const validate = validator(schema) const stringify = build(schema) - t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date-time.')) - t.not(validate(toStringify)) + t.assert.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date-time.')) + t.assert.equal(validate(toStringify), false) }) test('should throw an error if value can not be transformed to date', (t) => { @@ -597,8 +597,8 @@ test('should throw an error if value can not be transformed to date', (t) => { const validate = validator(schema) const stringify = build(schema) - t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date.')) - t.not(validate(toStringify)) + t.assert.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date.')) + t.assert.equal(validate(toStringify), false) }) test('should throw an error if value can not be transformed to time', (t) => { @@ -615,8 +615,8 @@ test('should throw an error if value can not be transformed to time', (t) => { const validate = validator(schema) const stringify = build(schema) - t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a time.')) - t.not(validate(toStringify)) + t.assert.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a time.')) + t.assert.equal(validate(toStringify), false) }) test('should serialize also an invalid string value, even if it is not a valid time', (t) => { @@ -634,6 +634,6 @@ test('should serialize also an invalid string value, even if it is not a valid t const stringify = build(schema) const output = stringify(toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.not(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.equal(validate(JSON.parse(output)), false, 'valid schema') }) diff --git a/test/debug-mode.test.js b/test/debug-mode.test.js index b02a08fb..3e998a73 100644 --- a/test/debug-mode.test.js +++ b/test/debug-mode.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const fjs = require('..') const Ajv = require('ajv').default @@ -24,11 +24,11 @@ test('activate debug mode', t => { t.plan(5) const debugMode = build({ debugMode: true }) - t.type(debugMode, 'object') - t.ok(debugMode.ajv instanceof Ajv) - t.ok(debugMode.validator instanceof Validator) - t.ok(debugMode.serializer instanceof Serializer) - t.type(debugMode.code, 'string') + t.assert.ok(typeof debugMode === 'object') + t.assert.ok(debugMode.ajv instanceof Ajv) + t.assert.ok(debugMode.validator instanceof Validator) + t.assert.ok(debugMode.serializer instanceof Serializer) + t.assert.ok(typeof debugMode.code === 'string') }) test('activate debug mode truthy', t => { @@ -36,26 +36,26 @@ test('activate debug mode truthy', t => { const debugMode = build({ debugMode: 'yes' }) - t.type(debugMode, 'object') - t.type(debugMode.code, 'string') - t.ok(debugMode.ajv instanceof Ajv) - t.ok(debugMode.validator instanceof Validator) - t.ok(debugMode.serializer instanceof Serializer) + t.assert.ok(typeof debugMode === 'object') + t.assert.ok(typeof debugMode.code === 'string') + t.assert.ok(debugMode.ajv instanceof Ajv) + t.assert.ok(debugMode.validator instanceof Validator) + t.assert.ok(debugMode.serializer instanceof Serializer) }) test('to string auto-consistent', t => { t.plan(6) const debugMode = build({ debugMode: 1 }) - t.type(debugMode, 'object') - t.type(debugMode.code, 'string') - t.ok(debugMode.ajv instanceof Ajv) - t.ok(debugMode.serializer instanceof Serializer) - t.ok(debugMode.validator instanceof Validator) + t.assert.ok(typeof debugMode === 'object') + t.assert.ok(typeof debugMode.code === 'string') + t.assert.ok(debugMode.ajv instanceof Ajv) + t.assert.ok(debugMode.serializer instanceof Serializer) + t.assert.ok(debugMode.validator instanceof Validator) const compiled = fjs.restore(debugMode) const tobe = JSON.stringify({ firstName: 'Foo' }) - t.same(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted') + t.assert.equal(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted') }) test('to string auto-consistent with ajv', t => { @@ -75,15 +75,15 @@ test('to string auto-consistent with ajv', t => { } }, { debugMode: 1 }) - t.type(debugMode, 'object') - t.type(debugMode.code, 'string') - t.ok(debugMode.ajv instanceof Ajv) - t.ok(debugMode.validator instanceof Validator) - t.ok(debugMode.serializer instanceof Serializer) + t.assert.ok(typeof debugMode === 'object') + t.assert.ok(typeof debugMode.code === 'string') + t.assert.ok(debugMode.ajv instanceof Ajv) + t.assert.ok(debugMode.validator instanceof Validator) + t.assert.ok(debugMode.serializer instanceof Serializer) const compiled = fjs.restore(debugMode) const tobe = JSON.stringify({ str: 'Foo' }) - t.same(compiled({ str: 'Foo', void: 'me' }), tobe) + t.assert.equal(compiled({ str: 'Foo', void: 'me' }), tobe) }) test('to string auto-consistent with ajv-formats', t => { @@ -104,12 +104,12 @@ test('to string auto-consistent with ajv-formats', t => { } }, { debugMode: 1 }) - t.type(debugMode, 'object') + t.assert.ok(typeof debugMode === 'object') const compiled = fjs.restore(debugMode) const tobe = JSON.stringify({ str: 'foo@bar.com' }) - t.same(compiled({ str: 'foo@bar.com' }), tobe) - t.throws(() => compiled({ str: 'foo' })) + t.assert.equal(compiled({ str: 'foo@bar.com' }), tobe) + t.assert.throws(() => compiled({ str: 'foo' })) }) test('debug should restore the same serializer instance', t => { @@ -117,5 +117,5 @@ test('debug should restore the same serializer instance', t => { const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' }) const compiled = fjs.restore(debugMode) - t.same(compiled(3.95), 4) + t.assert.equal(compiled(3.95), 4) }) diff --git a/test/defaults.test.js b/test/defaults.test.js index 3f4ee2e8..f0430a98 100644 --- a/test/defaults.test.js +++ b/test/defaults.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') function buildTest (schema, toStringify, expected) { @@ -11,7 +11,7 @@ function buildTest (schema, toStringify, expected) { const output = stringify(toStringify) - t.equal(output, JSON.stringify(expected)) + t.assert.equal(output, JSON.stringify(expected)) }) } diff --git a/test/enum.test.js b/test/enum.test.js index ab861686..9e702242 100644 --- a/test/enum.test.js +++ b/test/enum.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('use enum without type', (t) => { @@ -17,7 +17,7 @@ test('use enum without type', (t) => { }) const obj = { order: 'asc' } - t.equal('{"order":"asc"}', stringify(obj)) + t.assert.equal('{"order":"asc"}', stringify(obj)) }) test('use enum without type', (t) => { @@ -33,5 +33,5 @@ test('use enum without type', (t) => { }) const obj = { order: 'asc' } - t.equal('{"order":"asc"}', stringify(obj)) + t.assert.equal('{"order":"asc"}', stringify(obj)) }) diff --git a/test/fix-604.test.js b/test/fix-604.test.js index ce8c3685..239075af 100644 --- a/test/fix-604.test.js +++ b/test/fix-604.test.js @@ -1,24 +1,25 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const fjs = require('..') -const schema = { - type: 'object', - properties: { - fullName: { type: 'string' }, - phone: { type: 'number' } + +test('fix-604', t => { + const schema = { + type: 'object', + properties: { + fullName: { type: 'string' }, + phone: { type: 'number' } + } } -} -const input = { - fullName: 'Jone', - phone: 'phone' -} + const input = { + fullName: 'Jone', + phone: 'phone' + } -const render = fjs(schema) + const render = fjs(schema) -try { - render(input) -} catch (err) { - t.equal(err.message, 'The value "phone" cannot be converted to a number.') -} + t.assert.throws(() => { + render(input) + }, { message: 'The value "phone" cannot be converted to a number.' }) +}) diff --git a/test/if-then-else.test.js b/test/if-then-else.test.js index 1e93be00..dfe25e9b 100644 --- a/test/if-then-else.test.js +++ b/test/if-then-else.test.js @@ -1,6 +1,6 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') process.env.TZ = 'UTC' @@ -251,7 +251,7 @@ const deepFoobarOutput = JSON.stringify({ }) const noElseGreetingOutput = JSON.stringify({}) -t.test('if-then-else', t => { +test('if-then-else', async t => { const tests = [ { name: 'foobar', @@ -315,20 +315,18 @@ t.test('if-then-else', t => { } ] - tests.forEach(test => { - t.test(test.name + ' - normal', t => { + for (const { name, schema, input, expected } of tests) { + await t.test(name + ' - normal', async t => { t.plan(1) - const stringify = build(JSON.parse(JSON.stringify(test.schema)), { ajv: { strictTypes: false } }) - const serialized = stringify(test.input) - t.equal(serialized, test.expected) + const stringify = build(JSON.parse(JSON.stringify(schema)), { ajv: { strictTypes: false } }) + const serialized = stringify(input) + t.assert.equal(serialized, expected) }) - }) - - t.end() + } }) -t.test('nested if/then', t => { +test('nested if/then', t => { t.plan(2) const schema = { @@ -352,18 +350,18 @@ t.test('nested if/then', t => { const stringify = build(schema) - t.equal( + t.assert.equal( stringify({ a: 'A', foo: 'foo', bar: 'bar' }), JSON.stringify({ a: 'A', bar: 'bar' }) ) - t.equal( + t.assert.equal( stringify({ a: 'A', foo: 'foo', bar: 'bar', foo1: 'foo1', bar1: 'bar1' }), JSON.stringify({ a: 'A', bar: 'bar', bar1: 'bar1' }) ) }) -t.test('if/else with string format', (t) => { +test('if/else with string format', (t) => { t.plan(2) const schema = { @@ -376,11 +374,11 @@ t.test('if/else with string format', (t) => { const date = new Date(1674263005800) - t.equal(stringify(date), '"2023-01-21"') - t.equal(stringify('Invalid'), '"Invalid"') + t.assert.equal(stringify(date), '"2023-01-21"') + t.assert.equal(stringify('Invalid'), '"Invalid"') }) -t.test('if/else with const integers', (t) => { +test('if/else with const integers', (t) => { t.plan(2) const schema = { @@ -392,11 +390,11 @@ t.test('if/else with const integers', (t) => { const stringify = build(schema) - t.equal(stringify(100.32), '66') - t.equal(stringify(10.12), '33') + t.assert.equal(stringify(100.32), '66') + t.assert.equal(stringify(10.12), '33') }) -t.test('if/else with array', (t) => { +test('if/else with array', (t) => { t.plan(2) const schema = { @@ -408,11 +406,11 @@ t.test('if/else with array', (t) => { const stringify = build(schema) - t.equal(stringify(['1']), JSON.stringify(['1'])) - t.equal(stringify(['1', '2']), JSON.stringify([1, 2])) + t.assert.equal(stringify(['1']), JSON.stringify(['1'])) + t.assert.equal(stringify(['1', '2']), JSON.stringify([1, 2])) }) -t.test('external recursive if/then/else', (t) => { +test('external recursive if/then/else', (t) => { t.plan(1) const externalSchema = { @@ -466,5 +464,5 @@ t.test('external recursive if/then/else', (t) => { } } const stringify = build(schema, { schema: { externalSchema } }) - t.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}') + t.assert.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}') }) diff --git a/test/inferType.test.js b/test/inferType.test.js index 9648c03f..e2a8d254 100644 --- a/test/inferType.test.js +++ b/test/inferType.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -12,9 +12,9 @@ function buildTest (schema, toStringify) { const stringify = build(schema) const output = stringify(toStringify) - t.same(JSON.parse(output), toStringify) - t.equal(output, JSON.stringify(toStringify)) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.deepStrictEqual(JSON.parse(output), toStringify) + t.assert.equal(output, JSON.stringify(toStringify)) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) } diff --git a/test/infinity.test.js b/test/infinity.test.js index 0316b8c1..28799e65 100644 --- a/test/infinity.test.js +++ b/test/infinity.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('Finite numbers', t => { @@ -17,7 +17,7 @@ test('Finite numbers', t => { const stringify = build(schema) - values.forEach(v => t.equal(stringify(v), JSON.stringify(v))) + values.forEach(v => t.assert.equal(stringify(v), JSON.stringify(v))) }) test('Infinite integers', t => { @@ -35,7 +35,7 @@ test('Infinite integers', t => { try { stringify(v) } catch (err) { - t.equal(err.message, `The value "${v}" cannot be converted to an integer.`) + t.assert.equal(err.message, `The value "${v}" cannot be converted to an integer.`) } }) }) @@ -51,5 +51,5 @@ test('Infinite numbers', t => { const stringify = build(schema) - values.forEach(v => t.equal(stringify(v), JSON.stringify(v))) + values.forEach(v => t.assert.equal(stringify(v), JSON.stringify(v))) }) diff --git a/test/integer.test.js b/test/integer.test.js index c4a2415a..d76261f4 100644 --- a/test/integer.test.js +++ b/test/integer.test.js @@ -1,7 +1,7 @@ 'use strict' -const t = require('tap') -const test = t.test +const { test } = require('node:test') + const validator = require('is-my-json-valid') const build = require('..') const ROUNDING_TYPES = ['ceil', 'floor', 'round'] @@ -18,8 +18,8 @@ test('render an integer as JSON', (t) => { const stringify = build(schema) const output = stringify(1615) - t.equal(output, '1615') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '1615') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a float as an integer', (t) => { @@ -30,8 +30,8 @@ test('render a float as an integer', (t) => { type: 'integer' }, { rounding: 'foobar' }) } catch (error) { - t.ok(error) - t.equal(error.message, 'Unsupported integer rounding method foobar') + t.assert.ok(error) + t.assert.equal(error.message, 'Unsupported integer rounding method foobar') } }) @@ -44,7 +44,7 @@ test('throws on NaN', (t) => { } const stringify = build(schema) - t.throws(() => stringify(NaN), new Error('The value "NaN" cannot be converted to an integer.')) + t.assert.throws(() => stringify(NaN), new Error('The value "NaN" cannot be converted to an integer.')) }) test('render a float as an integer', (t) => { @@ -87,8 +87,8 @@ test('render a float as an integer', (t) => { const stringify = build(schema, { rounding }) const str = stringify(input) - t.equal(str, output) - t.ok(validate(JSON.parse(str)), 'valid schema') + t.assert.equal(str, output) + t.assert.ok(validate(JSON.parse(str)), 'valid schema') } }) @@ -111,8 +111,8 @@ test('render an object with an integer as JSON', (t) => { id: 1615 }) - t.equal(output, '{"id":1615}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"id":1615}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render an array with an integer as JSON', (t) => { @@ -130,8 +130,8 @@ test('render an array with an integer as JSON', (t) => { const stringify = build(schema) const output = stringify([1615]) - t.equal(output, '[1615]') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '[1615]') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render an object with an additionalProperty of type integer as JSON', (t) => { @@ -151,8 +151,8 @@ test('render an object with an additionalProperty of type integer as JSON', (t) num: 1615 }) - t.equal(output, '{"num":1615}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"num":1615}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('should round integer object parameter', t => { @@ -163,8 +163,8 @@ test('should round integer object parameter', t => { const stringify = build(schema, { rounding: 'ceil' }) const output = stringify({ magic: 4.2 }) - t.equal(output, '{"magic":5}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{"magic":5}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('should not stringify a property if it does not exist', t => { @@ -175,8 +175,8 @@ test('should not stringify a property if it does not exist', t => { const stringify = build(schema) const output = stringify({}) - t.equal(output, '{}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) ROUNDING_TYPES.forEach((rounding) => { @@ -188,7 +188,7 @@ ROUNDING_TYPES.forEach((rounding) => { const stringify = build(schema, { rounding }) const output = stringify({}) - t.equal(output, '{}') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '{}') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) }) diff --git a/test/invalidSchema.test.js b/test/invalidSchema.test.js index 3b61badf..4402484b 100644 --- a/test/invalidSchema.test.js +++ b/test/invalidSchema.test.js @@ -1,12 +1,12 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') // Covers issue #139 test('Should throw on invalid schema', t => { - t.plan(2) - try { + t.plan(1) + t.assert.throws(() => { build({}, { schema: { invalid: { @@ -14,9 +14,5 @@ test('Should throw on invalid schema', t => { } } }) - t.fail('should be an invalid schema') - } catch (err) { - t.match(err.message, /^"invalid" schema is invalid:.*/, 'Schema contains invalid key') - t.ok(err) - } + }, { message: /^"invalid" schema is invalid:.*/ }) }) diff --git a/test/issue-479.test.js b/test/issue-479.test.js index 6ca7aefc..10b33e07 100644 --- a/test/issue-479.test.js +++ b/test/issue-479.test.js @@ -1,6 +1,6 @@ 'use strict' -const { test } = require('tap') +const { test } = require('node:test') const build = require('..') test('should validate anyOf after allOf merge', (t) => { @@ -51,7 +51,7 @@ test('should validate anyOf after allOf merge', (t) => { const stringify = build(schema) - t.equal( + t.assert.equal( stringify({ name: 'foo', union: 'a8f1cc50-5530-5c62-9109-5ba9589a6ae1' }), '{"name":"foo","union":"a8f1cc50-5530-5c62-9109-5ba9589a6ae1"}') }) diff --git a/test/json-schema-test-suite/draft4.test.js b/test/json-schema-test-suite/draft4.test.js index 560943a5..f71afe45 100644 --- a/test/json-schema-test-suite/draft4.test.js +++ b/test/json-schema-test-suite/draft4.test.js @@ -1,12 +1,12 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const { counTests, runTests } = require('./util') const requiredTestSuite = require('./draft4/required.json') -test('required', (t) => { +test('required', async (t) => { const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects'] t.plan(counTests(requiredTestSuite, skippedTests)) - runTests(t, requiredTestSuite, skippedTests) + await runTests(t, requiredTestSuite, skippedTests) }) diff --git a/test/json-schema-test-suite/draft6.test.js b/test/json-schema-test-suite/draft6.test.js index ec75003f..072b7cfc 100644 --- a/test/json-schema-test-suite/draft6.test.js +++ b/test/json-schema-test-suite/draft6.test.js @@ -1,12 +1,12 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const { counTests, runTests } = require('./util') const requiredTestSuite = require('./draft6/required.json') -test('required', (t) => { +test('required', async (t) => { const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects'] t.plan(counTests(requiredTestSuite, skippedTests)) - runTests(t, requiredTestSuite, skippedTests) + await runTests(t, requiredTestSuite, skippedTests) }) diff --git a/test/json-schema-test-suite/draft7.test.js b/test/json-schema-test-suite/draft7.test.js index 0da48b37..9c6422a7 100644 --- a/test/json-schema-test-suite/draft7.test.js +++ b/test/json-schema-test-suite/draft7.test.js @@ -1,12 +1,12 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const { counTests, runTests } = require('./util') const requiredTestSuite = require('./draft7/required.json') -test('required', (t) => { +test('required', async (t) => { const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects'] t.plan(counTests(requiredTestSuite, skippedTests)) - runTests(t, requiredTestSuite, skippedTests) + await runTests(t, requiredTestSuite, skippedTests) }) diff --git a/test/json-schema-test-suite/util.js b/test/json-schema-test-suite/util.js index 837f92aa..c4cd4ec8 100644 --- a/test/json-schema-test-suite/util.js +++ b/test/json-schema-test-suite/util.js @@ -2,25 +2,22 @@ const build = require('../..') -function runTests (t, testsuite, skippedTests) { +async function runTests (t, testsuite, skippedTests) { for (const scenario of testsuite) { const stringify = build(scenario.schema) for (const test of scenario.tests) { if (skippedTests.indexOf(test.description) !== -1) { - t.comment('skip %s', test.description) + console.log(`skip ${test.description}`) continue } - t.test(test.description, (t) => { + + await t.test(test.description, (t) => { t.plan(1) try { const output = stringify(test.data) - t.equal(output, JSON.stringify(test.data), 'compare payloads') + t.assert.equal(output, JSON.stringify(test.data), 'compare payloads') } catch (err) { - if (test.valid === false) { - t.pass('payload is invalid') - } else { - t.fail('payload should be valid: ' + err.message) - } + t.assert.ok(test.valid === false, 'payload should be valid: ' + err.message) } }) } diff --git a/test/missing-values.test.js b/test/missing-values.test.js index c08110da..5ddf4771 100644 --- a/test/missing-values.test.js +++ b/test/missing-values.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('missing values', (t) => { @@ -22,9 +22,9 @@ test('missing values', (t) => { } }) - t.equal('{"val":"value"}', stringify({ val: 'value' })) - t.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' })) - t.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' })) + t.assert.equal('{"val":"value"}', stringify({ val: 'value' })) + t.assert.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' })) + t.assert.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' })) }) test('handle null when value should be string', (t) => { @@ -39,7 +39,7 @@ test('handle null when value should be string', (t) => { } }) - t.equal('{"str":""}', stringify({ str: null })) + t.assert.equal('{"str":""}', stringify({ str: null })) }) test('handle null when value should be integer', (t) => { @@ -54,7 +54,7 @@ test('handle null when value should be integer', (t) => { } }) - t.equal('{"int":0}', stringify({ int: null })) + t.assert.equal('{"int":0}', stringify({ int: null })) }) test('handle null when value should be number', (t) => { @@ -69,7 +69,7 @@ test('handle null when value should be number', (t) => { } }) - t.equal('{"num":0}', stringify({ num: null })) + t.assert.equal('{"num":0}', stringify({ num: null })) }) test('handle null when value should be boolean', (t) => { @@ -84,5 +84,5 @@ test('handle null when value should be boolean', (t) => { } }) - t.equal('{"bool":false}', stringify({ bool: null })) + t.assert.equal('{"bool":false}', stringify({ bool: null })) }) diff --git a/test/multi-type-serializer.test.js b/test/multi-type-serializer.test.js index d10909e3..146b42f2 100644 --- a/test/multi-type-serializer.test.js +++ b/test/multi-type-serializer.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('should throw a TypeError with the path to the key of the invalid value', (t) => { @@ -15,5 +15,5 @@ test('should throw a TypeError with the path to the key of the invalid value', ( } const stringify = build(schema) - t.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.')) + t.assert.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.')) }) diff --git a/test/nestedObjects.test.js b/test/nestedObjects.test.js index 4856aee7..f683cba2 100644 --- a/test/nestedObjects.test.js +++ b/test/nestedObjects.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('nested objects with same properties', (t) => { @@ -28,7 +28,7 @@ test('nested objects with same properties', (t) => { numberProperty: 42 } }) - t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}') + t.assert.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}') }) test('names collision', (t) => { @@ -59,5 +59,5 @@ test('names collision', (t) => { tes: { b: 'b', t: {} } } - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) diff --git a/test/nullable.test.js b/test/nullable.test.js index e581a1e4..a6d7eed9 100644 --- a/test/nullable.test.js +++ b/test/nullable.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') @@ -113,7 +113,7 @@ Object.keys(testSet).forEach(key => { const stringifier = build(schema, extraOptions) const result = stringifier(data) - t.same(JSON.parse(result), expected) + t.assert.deepStrictEqual(JSON.parse(result), expected) }) }) @@ -129,8 +129,8 @@ test('handle nullable number correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable integer correctly', (t) => { @@ -145,8 +145,8 @@ test('handle nullable integer correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable boolean correctly', (t) => { @@ -161,8 +161,8 @@ test('handle nullable boolean correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable string correctly', (t) => { @@ -177,8 +177,8 @@ test('handle nullable string correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable date-time correctly', (t) => { @@ -194,8 +194,8 @@ test('handle nullable date-time correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable date correctly', (t) => { @@ -211,8 +211,8 @@ test('handle nullable date correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('handle nullable time correctly', (t) => { @@ -228,8 +228,8 @@ test('handle nullable time correctly', (t) => { const data = null const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.equal(JSON.parse(result), data) }) test('large array of nullable strings with default mechanism', (t) => { @@ -258,8 +258,8 @@ test('large array of nullable strings with default mechanism', (t) => { const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable date-time strings with default mechanism', (t) => { @@ -289,8 +289,8 @@ test('large array of nullable date-time strings with default mechanism', (t) => const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable date-time strings with default mechanism', (t) => { @@ -320,8 +320,8 @@ test('large array of nullable date-time strings with default mechanism', (t) => const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable date-time strings with default mechanism', (t) => { @@ -351,8 +351,8 @@ test('large array of nullable date-time strings with default mechanism', (t) => const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable numbers with default mechanism', (t) => { @@ -381,8 +381,8 @@ test('large array of nullable numbers with default mechanism', (t) => { const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable integers with default mechanism', (t) => { @@ -411,8 +411,8 @@ test('large array of nullable integers with default mechanism', (t) => { const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('large array of nullable booleans with default mechanism', (t) => { @@ -441,8 +441,8 @@ test('large array of nullable booleans with default mechanism', (t) => { const data = { ids: new Array(2e4).fill(null) } const result = stringify(data) - t.same(result, JSON.stringify(data)) - t.same(JSON.parse(result), data) + t.assert.equal(result, JSON.stringify(data)) + t.assert.deepStrictEqual(JSON.parse(result), data) }) test('nullable type in the schema', (t) => { @@ -461,8 +461,8 @@ test('nullable type in the schema', (t) => { const data = { foo: 'bar' } - t.same(stringify(data), JSON.stringify(data)) - t.same(stringify(null), JSON.stringify(null)) + t.assert.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(null), JSON.stringify(null)) }) test('throw an error if the value doesn\'t match the type', (t) => { @@ -493,10 +493,10 @@ test('throw an error if the value doesn\'t match the type', (t) => { const stringify = build(schema) const validData = { data: [1, 'testing'] } - t.equal(stringify(validData), JSON.stringify(validData)) + t.assert.equal(stringify(validData), JSON.stringify(validData)) const invalidData = { data: [false, 'testing'] } - t.throws(() => stringify(invalidData)) + t.assert.throws(() => stringify(invalidData)) }) test('nullable value in oneOf', (t) => { @@ -539,5 +539,5 @@ test('nullable value in oneOf', (t) => { const stringify = build(schema) const data = { data: [{ job: null }] } - t.equal(stringify(data), JSON.stringify(data)) + t.assert.equal(stringify(data), JSON.stringify(data)) }) diff --git a/test/oneof.test.js b/test/oneof.test.js index 491e9aef..f3b29f4b 100644 --- a/test/oneof.test.js +++ b/test/oneof.test.js @@ -1,6 +1,6 @@ 'use strict' -const { test } = require('tap') +const { test } = require('node:test') const build = require('..') test('object with multiple types field', (t) => { @@ -21,8 +21,8 @@ test('object with multiple types field', (t) => { } const stringify = build(schema) - t.equal(stringify({ str: 'string' }), '{"str":"string"}') - t.equal(stringify({ str: true }), '{"str":true}') + t.assert.equal(stringify({ str: 'string' }), '{"str":"string"}') + t.assert.equal(stringify({ str: true }), '{"str":true}') }) test('object with field of type object or null', (t) => { @@ -48,9 +48,9 @@ test('object with field of type object or null', (t) => { } const stringify = build(schema) - t.equal(stringify({ prop: null }), '{"prop":null}') + t.assert.equal(stringify({ prop: null }), '{"prop":null}') - t.equal(stringify({ + t.assert.equal(stringify({ prop: { str: 'string', remove: 'this' } @@ -80,11 +80,11 @@ test('object with field of type object or array', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ prop: { str: 'string' } }), '{"prop":{"str":"string"}}') - t.equal(stringify({ + t.assert.equal(stringify({ prop: ['string'] }), '{"prop":["string"]}') }) @@ -104,7 +104,7 @@ test('object with field of type string and coercion disable ', (t) => { } } const stringify = build(schema) - t.throws(() => stringify({ str: 1 })) + t.assert.throws(() => stringify({ str: 1 })) }) test('object with field of type string and coercion enable ', (t) => { @@ -132,7 +132,7 @@ test('object with field of type string and coercion enable ', (t) => { const value = stringify({ str: 1 }) - t.equal(value, '{"str":"1"}') + t.assert.equal(value, '{"str":"1"}') }) test('object with field with type union of multiple objects', (t) => { @@ -166,9 +166,9 @@ test('object with field with type union of multiple objects', (t) => { const stringify = build(schema) - t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}') + t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}') - t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}') + t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}') }) test('null value in schema', (t) => { @@ -210,9 +210,9 @@ test('oneOf and $ref together', (t) => { const stringify = build(schema) - t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}') + t.assert.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}') - t.equal(stringify({ cs: true }), '{"cs":true}') + t.assert.equal(stringify({ cs: true }), '{"cs":true}') }) test('oneOf and $ref: 2 levels are fine', (t) => { @@ -250,7 +250,7 @@ test('oneOf and $ref: 2 levels are fine', (t) => { const value = stringify({ cs: 3 }) - t.equal(value, '{"cs":3}') + t.assert.equal(value, '{"cs":3}') }) test('oneOf and $ref: multiple levels should throw at build.', (t) => { @@ -289,9 +289,9 @@ test('oneOf and $ref: multiple levels should throw at build.', (t) => { const stringify = build(schema) - t.equal(stringify({ cs: 3 }), '{"cs":3}') - t.equal(stringify({ cs: true }), '{"cs":true}') - t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}') + t.assert.equal(stringify({ cs: 3 }), '{"cs":3}') + t.assert.equal(stringify({ cs: true }), '{"cs":true}') + t.assert.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}') }) test('oneOf and $ref - multiple external $ref', (t) => { @@ -344,10 +344,8 @@ test('oneOf and $ref - multiple external $ref', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"prop":{"prop2":"test"}}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}') }) test('oneOf with enum with more than 100 entries', (t) => { @@ -369,7 +367,7 @@ test('oneOf with enum with more than 100 entries', (t) => { const stringify = build(schema) const value = stringify(['EUR', 'USD', null]) - t.equal(value, '["EUR","USD",null]') + t.assert.equal(value, '["EUR","USD",null]') }) test('oneOf object with field of type string with format or null', (t) => { @@ -393,7 +391,7 @@ test('oneOf object with field of type string with format or null', (t) => { const withOneOfStringify = build(withOneOfSchema) - t.equal(withOneOfStringify({ + t.assert.equal(withOneOfStringify({ prop: toStringify }), `{"prop":"${toStringify.toISOString()}"}`) }) @@ -425,9 +423,9 @@ test('one array item match oneOf types', (t) => { const stringify = build(schema) - t.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}') - t.equal(stringify({ data: [1] }), '{"data":[1]}') - t.throws(() => stringify({ data: [false, 'foo'] })) + t.assert.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}') + t.assert.equal(stringify({ data: [1] }), '{"data":[1]}') + t.assert.throws(() => stringify({ data: [false, 'foo'] })) }) test('some array items match oneOf types', (t) => { @@ -457,8 +455,8 @@ test('some array items match oneOf types', (t) => { const stringify = build(schema) - t.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}') - t.throws(() => stringify({ data: [false, 'foo', true, 5] })) + t.assert.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}') + t.assert.throws(() => stringify({ data: [false, 'foo', true, 5] })) }) test('all array items does not match oneOf types', (t) => { @@ -488,5 +486,5 @@ test('all array items does not match oneOf types', (t) => { const stringify = build(schema) - t.throws(() => stringify({ data: [null, false, true, undefined, [], {}] })) + t.assert.throws(() => stringify({ data: [null, false, true, undefined, [], {}] })) }) diff --git a/test/patternProperties.test.js b/test/patternProperties.test.js index 6817a039..d80a7f1b 100644 --- a/test/patternProperties.test.js +++ b/test/patternProperties.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('patternProperties', (t) => { @@ -21,7 +21,7 @@ test('patternProperties', (t) => { }) const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true }, notMe: false } - t.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}') + t.assert.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}') }) test('patternProperties should not change properties', (t) => { @@ -42,7 +42,7 @@ test('patternProperties should not change properties', (t) => { }) const obj = { foo: '42', ofoo: 42 } - t.equal(stringify(obj), '{"foo":"42","ofoo":42}') + t.assert.equal(stringify(obj), '{"foo":"42","ofoo":42}') }) test('patternProperties - string coerce', (t) => { @@ -59,7 +59,7 @@ test('patternProperties - string coerce', (t) => { }) const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } } - t.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}') + t.assert.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}') }) test('patternProperties - number coerce', (t) => { @@ -76,14 +76,14 @@ test('patternProperties - number coerce', (t) => { }) const coercibleValues = { foo: true, ofoo: '42' } - t.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}') + t.assert.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}') const incoercibleValues = { xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } } try { stringify(incoercibleValues) t.fail('should throw an error') } catch (err) { - t.ok(err) + t.assert.ok(err) } }) @@ -101,7 +101,7 @@ test('patternProperties - boolean coerce', (t) => { }) const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { a: true } } - t.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}') + t.assert.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}') }) test('patternProperties - object coerce', (t) => { @@ -123,7 +123,7 @@ test('patternProperties - object coerce', (t) => { }) const obj = { objfoo: { answer: 42 } } - t.equal(stringify(obj), '{"objfoo":{"answer":42}}') + t.assert.equal(stringify(obj), '{"objfoo":{"answer":42}}') }) test('patternProperties - array coerce', (t) => { @@ -143,16 +143,16 @@ test('patternProperties - array coerce', (t) => { }) const coercibleValues = { arrfoo: [1, 2] } - t.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}') + t.assert.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}') const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } } - t.throws(() => stringify(incoercibleValues)) + t.assert.throws(() => stringify(incoercibleValues)) }) test('patternProperties - fail on invalid regex, handled by ajv', (t) => { t.plan(1) - t.throws(() => build({ + t.assert.throws(() => build({ title: 'check array coerce', type: 'object', properties: {}, diff --git a/test/recursion.test.js b/test/recursion.test.js index d1300955..78be6261 100644 --- a/test/recursion.test.js +++ b/test/recursion.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('can stringify recursive directory tree (issue #181)', (t) => { @@ -25,7 +25,7 @@ test('can stringify recursive directory tree (issue #181)', (t) => { } const stringify = build(schema) - t.equal(stringify([ + t.assert.equal(stringify([ { name: 'directory 1', subDirectories: [] }, { name: 'directory 2', @@ -68,7 +68,7 @@ test('can stringify when recursion in external schema', t => { }) const value = stringify({ people: { name: 'Elizabeth', children: [{ name: 'Charles' }] } }) - t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}') + t.assert.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}') }) test('use proper serialize function', t => { @@ -133,7 +133,7 @@ test('use proper serialize function', t => { ] } }) - t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}') + t.assert.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}') }) test('can stringify recursive references in object types (issue #365)', t => { @@ -176,7 +176,7 @@ test('can stringify recursive references in object types (issue #365)', t => { } } const value = stringify(data) - t.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}') + t.assert.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}') }) test('can stringify recursive inline $id references (issue #410)', t => { @@ -241,5 +241,5 @@ test('can stringify recursive inline $id references (issue #410)', t => { ] } const value = stringify(data) - t.equal(value, '{"id":"0","nodes":[{"id":"1","nodes":[{"id":"2","nodes":[{"id":"3","nodes":[]},{"id":"4","nodes":[]},{"id":"5","nodes":[]}]}]},{"id":"6","nodes":[{"id":"7","nodes":[{"id":"8","nodes":[]},{"id":"9","nodes":[]},{"id":"10","nodes":[]}]}]},{"id":"11","nodes":[{"id":"12","nodes":[{"id":"13","nodes":[]},{"id":"14","nodes":[]},{"id":"15","nodes":[]}]}]}]}') + t.assert.equal(value, '{"id":"0","nodes":[{"id":"1","nodes":[{"id":"2","nodes":[{"id":"3","nodes":[]},{"id":"4","nodes":[]},{"id":"5","nodes":[]}]}]},{"id":"6","nodes":[{"id":"7","nodes":[{"id":"8","nodes":[]},{"id":"9","nodes":[]},{"id":"10","nodes":[]}]}]},{"id":"11","nodes":[{"id":"12","nodes":[{"id":"13","nodes":[]},{"id":"14","nodes":[]},{"id":"15","nodes":[]}]}]}]}') }) diff --git a/test/ref.test.js b/test/ref.test.js index 4163ad24..3f693e1c 100644 --- a/test/ref.test.js +++ b/test/ref.test.js @@ -2,7 +2,7 @@ const clone = require('rfdc')({ proto: true }) -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('ref internal - properties', (t) => { @@ -37,10 +37,8 @@ test('ref internal - properties', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"str":"test"}}') }) test('ref internal - items', (t) => { @@ -69,10 +67,8 @@ test('ref internal - items', (t) => { const stringify = build(schema) const output = stringify(array) - JSON.parse(output) - t.pass() - - t.equal(output, '[{"str":"test"}]') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '[{"str":"test"}]') }) test('ref external - properties', (t) => { @@ -130,10 +126,8 @@ test('ref external - properties', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"str":"test"},"num":{"int":42},"strPlain":"test","strHash":"test"}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"str":"test"},"num":{"int":42},"strPlain":"test","strHash":"test"}') }) test('ref internal - patternProperties', (t) => { @@ -169,10 +163,8 @@ test('ref internal - patternProperties', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"str":"test"}}') }) test('ref internal - additionalProperties', (t) => { @@ -206,10 +198,8 @@ test('ref internal - additionalProperties', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"str":"test"}}') }) test('ref internal - pattern-additional Properties', (t) => { @@ -251,10 +241,8 @@ test('ref internal - pattern-additional Properties', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"reg":{"str":"test"},"obj":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"reg":{"str":"test"},"obj":{"str":"test"}}') }) test('ref external - pattern-additional Properties', (t) => { @@ -302,10 +290,8 @@ test('ref external - pattern-additional Properties', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"reg":{"str":"test"},"obj":{"int":42}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"reg":{"str":"test"},"obj":{"int":42}}') }) test('ref internal - deepObject schema', (t) => { @@ -354,10 +340,8 @@ test('ref internal - deepObject schema', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"winter":{"is":{"coming":{"where":"to town"}}}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"winter":{"is":{"coming":{"where":"to town"}}}}') }) test('ref internal - plain name fragment', (t) => { @@ -394,10 +378,8 @@ test('ref internal - plain name fragment', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"str":"test"}}') }) test('ref external - plain name fragment', (t) => { @@ -453,10 +435,8 @@ test('ref external - plain name fragment', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"},"second":{"int":42}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"},"second":{"int":42}}') }) test('external reference to $id', (t) => { @@ -488,10 +468,8 @@ test('external reference to $id', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"}}') }) test('external reference to key#id', (t) => { @@ -523,10 +501,8 @@ test('external reference to key#id', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"}}') }) test('external and inner reference', (t) => { @@ -564,10 +540,8 @@ test('external and inner reference', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"}}') }) test('external reference to key', (t) => { @@ -599,10 +573,8 @@ test('external reference to key', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"}}') }) test('ref external - plain name fragment', (t) => { @@ -658,10 +630,8 @@ test('ref external - plain name fragment', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"first":{"str":"test"},"second":{"int":42}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"first":{"str":"test"},"second":{"int":42}}') }) test('ref external - duplicate plain name fragment', (t) => { @@ -730,10 +700,8 @@ test('ref external - duplicate plain name fragment', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"local":{"prop":"test"},"external":{"prop":true},"other":{"prop":42}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"local":{"prop":"test"},"external":{"prop":true},"other":{"prop":42}}') }) test('ref external - explicit external plain name fragment must not fallback to other external schemas', (t) => { @@ -787,14 +755,13 @@ test('ref external - explicit external plain name fragment must not fallback to } } - try { + t.assert.throws(() => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) JSON.parse(output) - t.fail() - } catch (e) { - t.pass() - } + }, { + message: 'Cannot find reference "first#wrong"' + }) }) test('ref internal - multiple $ref format', (t) => { @@ -838,10 +805,8 @@ test('ref internal - multiple $ref format', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"zero":"test","a":"test","b":"test","c":"test","d":"test","e":"test"}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"zero":"test","a":"test","b":"test","c":"test","d":"test","e":"test"}') }) test('ref external - external schema with internal ref (object property)', (t) => { @@ -880,10 +845,8 @@ test('ref external - external schema with internal ref (object property)', (t) = const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"prop":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"prop":"test"}}') }) test('ref external - external schema with internal ref (array items)', (t) => { @@ -925,10 +888,8 @@ test('ref external - external schema with internal ref (array items)', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"arr":[{"prop":"test"}]}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"arr":[{"prop":"test"}]}') }) test('ref external - external schema with internal ref (root)', (t) => { @@ -960,10 +921,8 @@ test('ref external - external schema with internal ref (root)', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"prop":"test"}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"prop":"test"}') }) test('ref external - external schema with internal ref (pattern properties)', (t) => { @@ -1002,10 +961,8 @@ test('ref external - external schema with internal ref (pattern properties)', (t const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"obj":{"prop":"test"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":{"prop":"test"}}') }) test('ref in root internal', (t) => { @@ -1033,10 +990,8 @@ test('ref in root internal', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"int":42}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"int":42}') }) test('ref in root external', (t) => { @@ -1068,10 +1023,8 @@ test('ref in root external', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"int":42}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"int":42}') }) test('ref in root external multiple times', (t) => { @@ -1107,10 +1060,8 @@ test('ref in root external multiple times', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"int":42}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"int":42}') }) test('ref external to relative definition', (t) => { @@ -1141,10 +1092,8 @@ test('ref external to relative definition', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"fooParent":{"foo":"bar"}}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"fooParent":{"foo":"bar"}}') }) test('ref to nested ref definition', (t) => { @@ -1179,14 +1128,12 @@ test('ref to nested ref definition', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, '{"foo":"foo"}') + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"foo":"foo"}') }) -test('Bad key', t => { - t.test('Find match', t => { +test('Bad key', async t => { + await t.test('Find match', t => { t.plan(1) try { build({ @@ -1207,13 +1154,14 @@ test('Bad key', t => { }) t.fail('Should throw') } catch (err) { - t.equal(err.message, 'Cannot find reference "#/definitions/porjectId"') + t.assert.equal(err.message, 'Cannot find reference "#/definitions/porjectId"') } }) - t.test('No match', t => { + await t.test('No match', t => { t.plan(1) - try { + + t.assert.throws(() => { build({ definitions: { projectId: { @@ -1230,15 +1178,12 @@ test('Bad key', t => { } } }) - t.fail('Should throw') - } catch (err) { - t.equal(err.message, 'Cannot find reference "#/definitions/foobar"') - } + }, { message: 'Cannot find reference "#/definitions/foobar"' }) }) - t.test('Find match (external schema)', t => { + await t.test('Find match (external schema)', t => { t.plan(1) - try { + t.assert.throws(() => { build({ type: 'object', properties: { @@ -1261,14 +1206,12 @@ test('Bad key', t => { } }) t.fail('Should throw') - } catch (err) { - t.equal(err.message, 'Cannot find reference "external#/definitions/porjectId"') - } + }, { message: 'Cannot find reference "external#/definitions/porjectId"' }) }) - t.test('No match (external schema)', t => { + await t.test('No match (external schema)', t => { t.plan(1) - try { + t.assert.throws(() => { build({ type: 'object', properties: { @@ -1290,15 +1233,12 @@ test('Bad key', t => { } } }) - t.fail('Should throw') - } catch (err) { - t.equal(err.message, 'Cannot find reference "external#/definitions/foobar"') - } + }, { message: 'Cannot find reference "external#/definitions/foobar"' }) }) - t.test('Find match (external definitions typo)', t => { + await t.test('Find match (external definitions typo)', t => { t.plan(1) - try { + t.assert.throws(() => { build({ type: 'object', properties: { @@ -1320,15 +1260,12 @@ test('Bad key', t => { } } }) - t.fail('Should throw') - } catch (err) { - t.equal(err.message, 'Cannot find reference "external#/deifnitions/projectId"') - } + }, { message: 'Cannot find reference "external#/deifnitions/projectId"' }) }) - t.test('Find match (definitions typo)', t => { + await t.test('Find match (definitions typo)', t => { t.plan(1) - try { + t.assert.throws(() => { build({ definitions: { projectId: { @@ -1345,15 +1282,12 @@ test('Bad key', t => { } } }) - t.fail('Should throw') - } catch (err) { - t.equal(err.message, 'Cannot find reference "#/deifnitions/projectId"') - } + }, { message: 'Cannot find reference "#/deifnitions/projectId"' }) }) - t.test('Find match (external schema typo)', t => { + await t.test('Find match (external schema typo)', t => { t.plan(1) - try { + t.assert.throws(() => { build({ type: 'object', properties: { @@ -1375,16 +1309,8 @@ test('Bad key', t => { } } }) - t.fail('Should throw') - } catch (err) { - t.equal( - err.message, - 'Cannot resolve ref "extrenal#/definitions/projectId". Schema with id "extrenal" is not found.' - ) - } + }, { message: 'Cannot resolve ref "extrenal#/definitions/projectId". Schema with id "extrenal" is not found.' }) }) - - t.end() }) test('Regression 2.5.2', t => { @@ -1431,7 +1357,7 @@ test('Regression 2.5.2', t => { const stringify = build(schema, { schema: externalSchema }) const output = stringify([{ field: 'parent', sub: { field: 'joined' } }]) - t.equal(output, '[{"field":"parent","sub":{"field":"joined"}}]') + t.assert.equal(output, '[{"field":"parent","sub":{"field":"joined"}}]') }) test('Reference through multiple definitions', (t) => { @@ -1466,10 +1392,8 @@ test('Reference through multiple definitions', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, JSON.stringify(object)) + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, JSON.stringify(object)) }) test('issue #350', (t) => { @@ -1509,10 +1433,8 @@ test('issue #350', (t) => { const stringify = build(schema) const output = stringify(object) - JSON.parse(output) - t.pass() - - t.equal(output, JSON.stringify(object)) + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, JSON.stringify(object)) }) test('deep union type', (t) => { @@ -1759,10 +1681,10 @@ test('deep union type', (t) => { ] } ] - t.equal(JSON.stringify(obj), stringify(obj)) + t.assert.equal(JSON.stringify(obj), stringify(obj)) }) -test('ref with same id in properties', (t) => { +test('ref with same id in properties', async (t) => { t.plan(2) const externalSchema = { @@ -1781,7 +1703,7 @@ test('ref with same id in properties', (t) => { } } - t.test('anyOf', (t) => { + await t.test('anyOf', (t) => { t.plan(1) const schema = { @@ -1801,10 +1723,10 @@ test('ref with same id in properties', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify({ _id: 'foo', image: { _id: 'bar', name: 'hello', owner: 'baz' } }) - t.equal(output, '{"_id":"foo","image":{"_id":"bar","name":"hello","owner":"baz"}}') + t.assert.equal(output, '{"_id":"foo","image":{"_id":"bar","name":"hello","owner":"baz"}}') }) - t.test('oneOf', (t) => { + await t.test('oneOf', (t) => { t.plan(1) const schema = { @@ -1824,7 +1746,7 @@ test('ref with same id in properties', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify({ _id: 'foo', image: { _id: 'bar', name: 'hello', owner: 'baz' } }) - t.equal(output, '{"_id":"foo","image":{"_id":"bar","name":"hello","owner":"baz"}}') + t.assert.equal(output, '{"_id":"foo","image":{"_id":"bar","name":"hello","owner":"baz"}}') }) }) @@ -1855,8 +1777,8 @@ test('Should not modify external schemas', (t) => { const data = { id: 'a4e4c954-9f5f-443a-aa65-74d95732249a' } const output = stringify(data) - t.equal(output, JSON.stringify(data)) - t.same(options, optionsClone) + t.assert.equal(output, JSON.stringify(data)) + t.assert.deepStrictEqual(options, optionsClone) }) test('input schema is not mutated', (t) => { @@ -1884,15 +1806,9 @@ test('input schema is not mutated', (t) => { const stringify = build(schema) const output = stringify(object) - try { - JSON.parse(output) - t.pass() - } catch (e) { - t.fail() - } - - t.equal(output, '{"obj":"test"}') - t.same(schema, clonedSchema) + t.assert.doesNotThrow(() => JSON.parse(output)) + t.assert.equal(output, '{"obj":"test"}') + t.assert.deepStrictEqual(schema, clonedSchema) }) test('anyOf inside allOf', (t) => { @@ -1927,7 +1843,7 @@ test('anyOf inside allOf', (t) => { const stringify = build(schema) const output = stringify(object) - t.equal(output, JSON.stringify(object)) + t.assert.equal(output, JSON.stringify(object)) }) test('should resolve absolute $refs', (t) => { @@ -1954,7 +1870,7 @@ test('should resolve absolute $refs', (t) => { const stringify = build(schema, { schema: externalSchema }) const output = stringify(object) - t.equal(output, JSON.stringify(object)) + t.assert.equal(output, JSON.stringify(object)) }) test('nested schema should overwrite anchor scope', (t) => { @@ -1981,8 +1897,8 @@ test('nested schema should overwrite anchor scope', (t) => { const stringify = build({ $ref: 'subschema#anchor' }, { schema: externalSchema }) const output = stringify(data) - t.equal(output, JSON.stringify(data)) - t.throws(() => build({ $ref: 'root#anchor' }, { schema: externalSchema })) + t.assert.equal(output, JSON.stringify(data)) + t.assert.throws(() => build({ $ref: 'root#anchor' }, { schema: externalSchema })) }) test('object property reference with default value', (t) => { @@ -2006,7 +1922,7 @@ test('object property reference with default value', (t) => { const stringify = build(schema) const output = stringify({}) - t.equal(output, '{"prop":"foo"}') + t.assert.equal(output, '{"prop":"foo"}') }) test('should throw an Error if two non-identical schemas with same id are provided', (t) => { @@ -2082,7 +1998,7 @@ test('should throw an Error if two non-identical schemas with same id are provid try { build(schema) } catch (err) { - t.equal(err.message, 'There is already another schema with id "inner_schema".') + t.assert.equal(err.message, 'There is already another schema with id "inner_schema".') } }) @@ -2125,6 +2041,6 @@ test('ref internal - throw if schema has definition twice with different shape', try { build(schema) } catch (err) { - t.equal(err.message, 'There is already another anchor "#uri" in a schema "test".') + t.assert.equal(err.message, 'There is already another anchor "#uri" in a schema "test".') } }) diff --git a/test/regex.test.js b/test/regex.test.js index 56706424..e08f8672 100644 --- a/test/regex.test.js +++ b/test/regex.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -25,9 +25,8 @@ test('object with RexExp', (t) => { const validate = validator(schema) const output = stringify(obj) - JSON.parse(output) - t.pass() + t.assert.doesNotThrow(() => JSON.parse(output)) - t.equal(obj.reg.source, new RegExp(JSON.parse(output).reg).source) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(obj.reg.source, new RegExp(JSON.parse(output).reg).source) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) diff --git a/test/required.test.js b/test/required.test.js index 17144698..96d74705 100644 --- a/test/required.test.js +++ b/test/required.test.js @@ -1,10 +1,10 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('object with required field', (t) => { - t.plan(3) + t.plan(2) const schema = { title: 'object with required field', @@ -21,24 +21,21 @@ test('object with required field', (t) => { } const stringify = build(schema) - stringify({ - str: 'string' + t.assert.doesNotThrow(() => { + stringify({ + str: 'string' + }) }) - t.pass() - try { + t.assert.throws(() => { stringify({ num: 42 }) - t.fail() - } catch (e) { - t.equal(e.message, '"str" is required!') - t.pass() - } + }, { message: '"str" is required!' }) }) test('object with required field not in properties schema', (t) => { - t.plan(4) + t.plan(2) const schema = { title: 'object with required field', @@ -52,27 +49,19 @@ test('object with required field not in properties schema', (t) => { } const stringify = build(schema) - try { + t.assert.throws(() => { stringify({}) - t.fail() - } catch (e) { - t.equal(e.message, '"str" is required!') - t.pass() - } + }, { message: '"str" is required!' }) - try { + t.assert.throws(() => { stringify({ num: 42 }) - t.fail() - } catch (e) { - t.equal(e.message, '"str" is required!') - t.pass() - } + }, { message: '"str" is required!' }) }) test('object with required field not in properties schema with additional properties true', (t) => { - t.plan(4) + t.plan(2) const schema = { title: 'object with required field', @@ -87,27 +76,19 @@ test('object with required field not in properties schema with additional proper } const stringify = build(schema) - try { + t.assert.throws(() => { stringify({}) - t.fail() - } catch (e) { - t.equal(e.message, '"str" is required!') - t.pass() - } + }, { message: '"str" is required!' }) - try { + t.assert.throws(() => { stringify({ num: 42 }) - t.fail() - } catch (e) { - t.equal(e.message, '"str" is required!') - t.pass() - } + }, { message: '"str" is required!' }) }) test('object with multiple required field not in properties schema', (t) => { - t.plan(6) + t.plan(3) const schema = { title: 'object with required field', @@ -122,35 +103,23 @@ test('object with multiple required field not in properties schema', (t) => { } const stringify = build(schema) - try { + t.assert.throws(() => { stringify({}) - t.fail() - } catch (e) { - t.equal(e.message, '"key1" is required!') - t.pass() - } + }, { message: '"key1" is required!' }) - try { + t.assert.throws(() => { stringify({ key1: 42, key2: 42 }) - t.fail() - } catch (e) { - t.equal(e.message, '"num" is required!') - t.pass() - } + }, { message: '"num" is required!' }) - try { + t.assert.throws(() => { stringify({ num: 42, key1: 'some' }) - t.fail() - } catch (e) { - t.equal(e.message, '"key2" is required!') - t.pass() - } + }, { message: '"key2" is required!' }) }) test('object with required bool', (t) => { @@ -169,16 +138,14 @@ test('object with required bool', (t) => { } const stringify = build(schema) - try { + t.assert.throws(() => { stringify({}) - t.fail() - } catch (e) { - t.equal(e.message, '"bool" is required!') - t.pass() - } + }, { message: '"bool" is required!' }) - stringify({ - bool: false + t.assert.doesNotThrow(() => { + stringify({ + bool: false + }) }) }) @@ -198,14 +165,15 @@ test('required nullable', (t) => { } const stringify = build(schema) - stringify({ - null: null + t.assert.doesNotThrow(() => { + stringify({ + null: null + }) }) - t.pass() }) test('required numbers', (t) => { - t.plan(3) + t.plan(2) const schema = { title: 'object with required field', @@ -222,18 +190,15 @@ test('required numbers', (t) => { } const stringify = build(schema) - stringify({ - num: 42 + t.assert.doesNotThrow(() => { + stringify({ + num: 42 + }) }) - t.pass() - try { + t.assert.throws(() => { stringify({ num: 'aaa' }) - t.fail() - } catch (e) { - t.equal(e.message, 'The value "aaa" cannot be converted to an integer.') - t.pass() - } + }, { message: 'The value "aaa" cannot be converted to an integer.' }) }) diff --git a/test/requiresAjv.test.js b/test/requiresAjv.test.js index fdf4c1fd..c62289ab 100644 --- a/test/requiresAjv.test.js +++ b/test/requiresAjv.test.js @@ -1,48 +1,50 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -t.test('nested ref requires ajv', async t => { - const schemaA = { - $id: 'urn:schema:a', - definitions: { - foo: { anyOf: [{ type: 'string' }, { type: 'null' }] } +test('nested ref requires ajv', async t => { + t.test('nested ref requires ajv', async t => { + const schemaA = { + $id: 'urn:schema:a', + definitions: { + foo: { anyOf: [{ type: 'string' }, { type: 'null' }] } + } } - } - const schemaB = { - $id: 'urn:schema:b', - type: 'object', - properties: { - results: { - type: 'object', - properties: { - items: { - type: 'object', - properties: { - bar: { - type: 'array', - items: { $ref: 'urn:schema:a#/definitions/foo' } + const schemaB = { + $id: 'urn:schema:b', + type: 'object', + properties: { + results: { + type: 'object', + properties: { + items: { + type: 'object', + properties: { + bar: { + type: 'array', + items: { $ref: 'urn:schema:a#/definitions/foo' } + } } } } } } } - } - const stringify = build(schemaB, { - schema: { - [schemaA.$id]: schemaA - } - }) - const result = stringify({ - results: { - items: { - bar: ['baz'] + const stringify = build(schemaB, { + schema: { + [schemaA.$id]: schemaA } - } + }) + const result = stringify({ + results: { + items: { + bar: ['baz'] + } + } + }) + t.assert.equal(result, '{"results":{"items":{"bar":["baz"]}}}') }) - t.same(result, '{"results":{"items":{"bar":["baz"]}}}') }) diff --git a/test/sanitize.test.js b/test/sanitize.test.js index 0cf6febe..18bd90e7 100644 --- a/test/sanitize.test.js +++ b/test/sanitize.test.js @@ -1,6 +1,6 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') const stringify = build({ @@ -91,52 +91,51 @@ const obj = { notmatchnum: 42 } -// pass if it does not crash -const json = stringify(obj) -JSON.parse(json) +test('sanitize', t => { + const json = stringify(obj) + t.assert.doesNotThrow(() => JSON.parse(json)) -const stringify2 = build({ - title: 'Example Schema', - type: 'object', - patternProperties: { - '"\'w00t.*////': { - type: 'number' + const stringify2 = build({ + title: 'Example Schema', + type: 'object', + patternProperties: { + '"\'w00t.*////': { + type: 'number' + } } - } -}) + }) -t.same(JSON.parse(stringify2({ - '"\'phra////': 42, - asd: 42 -})), { -}) + t.assert.deepStrictEqual(JSON.parse(stringify2({ + '"\'phra////': 42, + asd: 42 + })), { + }) -const stringify3 = build({ - title: 'Example Schema', - type: 'object', - properties: { - "\"phra\\'&&(console.log(42))//||'phra": {} - } -}) + const stringify3 = build({ + title: 'Example Schema', + type: 'object', + properties: { + "\"phra\\'&&(console.log(42))//||'phra": {} + } + }) -// this verifies the escaping -JSON.parse(stringify3({ - '"phra\'&&(console.log(42))//||\'phra': 42 -})) + // this verifies the escaping + JSON.parse(stringify3({ + '"phra\'&&(console.log(42))//||\'phra': 42 + })) -const stringify4 = build({ - title: 'Example Schema', - type: 'object', - properties: { - '"\\\\\\\\\'w00t': { - type: 'string', - default: '"\'w00t' + const stringify4 = build({ + title: 'Example Schema', + type: 'object', + properties: { + '"\\\\\\\\\'w00t': { + type: 'string', + default: '"\'w00t' + } } - } -}) + }) -t.same(JSON.parse(stringify4({})), { - '"\\\\\\\\\'w00t': '"\'w00t' + t.assert.deepStrictEqual(JSON.parse(stringify4({})), { + '"\\\\\\\\\'w00t': '"\'w00t' + }) }) - -t.pass('no crashes') diff --git a/test/sanitize2.test.js b/test/sanitize2.test.js index 06290247..9c7382d3 100644 --- a/test/sanitize2.test.js +++ b/test/sanitize2.test.js @@ -1,18 +1,18 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -const payload = '(throw "pwoned")' +test('sanitize 2', t => { + const payload = '(throw "pwoned")' -const stringify = build({ - properties: { - [`*///\\\\\\']);${payload};{/*`]: { - type: 'number' + const stringify = build({ + properties: { + [`*///\\\\\\']);${payload};{/*`]: { + type: 'number' + } } - } -}) - -stringify({}) + }) -t.pass('no crashes') + t.assert.doesNotThrow(() => stringify({})) +}) diff --git a/test/sanitize3.test.js b/test/sanitize3.test.js index d596a8e6..ac3bab5a 100644 --- a/test/sanitize3.test.js +++ b/test/sanitize3.test.js @@ -1,15 +1,17 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -t.throws(() => { - build({ - $defs: { - type: 'foooo"bar' - }, - patternProperties: { - x: { $ref: '#/$defs' } - } - }) -}, 'foooo"bar unsupported') +test('sanitize 3', t => { + t.assert.throws(() => { + build({ + $defs: { + type: 'foooo"bar' + }, + patternProperties: { + x: { $ref: '#/$defs' } + } + }) + }, { message: 'foooo"bar unsupported' }) +}) diff --git a/test/sanitize4.test.js b/test/sanitize4.test.js index 5ec869a4..c1486dfe 100644 --- a/test/sanitize4.test.js +++ b/test/sanitize4.test.js @@ -1,14 +1,16 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -const payload = '(throw "pwoned")' +test('sanitize 4', t => { + const payload = '(throw "pwoned")' -const stringify = build({ - required: [`"];${payload}//`] -}) + const stringify = build({ + required: [`"];${payload}//`] + }) -t.throws(() => { - stringify({}) -}, 'Error: ""];(throw "pwoned")//" is required!') + t.assert.throws(() => { + stringify({}) + }, { message: '""];(throw "pwoned")//" is required!' }) +}) diff --git a/test/sanitize5.test.js b/test/sanitize5.test.js index ec45927b..039a355c 100644 --- a/test/sanitize5.test.js +++ b/test/sanitize5.test.js @@ -1,16 +1,16 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -const payload = '(throw "pwoned")' +test('sanitize 5', t => { + const payload = '(throw "pwoned")' -const expected = 'Error: Invalid regular expression: /*/: Nothing to repeat. Found at * matching {"type":"*/(throw \\"pwoned\\")){//"}' - -t.throws(() => { - build({ - patternProperties: { - '*': { type: `*/${payload}){//` } - } - }) -}, expected) + t.assert.throws(() => { + build({ + patternProperties: { + '*': { type: `*/${payload}){//` } + } + }) + }, { message: 'schema is invalid: data/patternProperties must match format "regex"' }) +}) diff --git a/test/sanitize6.test.js b/test/sanitize6.test.js index 68b09968..e8dfb4c8 100644 --- a/test/sanitize6.test.js +++ b/test/sanitize6.test.js @@ -1,22 +1,22 @@ 'use strict' -const t = require('tap') +const { test } = require('node:test') const build = require('..') -const payload = '(throw "pwoned")' +test('sanitize 6', t => { + const payload = '(throw "pwoned")' -const stringify = build({ - type: 'object', - properties: { - '/*': { type: 'object' }, - x: { - type: 'object', - properties: { - a: { type: 'string', default: `*/}${payload};{//` } + const stringify = build({ + type: 'object', + properties: { + '/*': { type: 'object' }, + x: { + type: 'object', + properties: { + a: { type: 'string', default: `*/}${payload};{//` } + } } } - } + }) + t.assert.doesNotThrow(() => { stringify({}) }) }) -stringify({}) - -t.pass('no crashes') diff --git a/test/sanitize7.test.js b/test/sanitize7.test.js index 530c1856..d678bfd7 100644 --- a/test/sanitize7.test.js +++ b/test/sanitize7.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('required property containing single quote, contains property', (t) => { @@ -16,7 +16,7 @@ test('required property containing single quote, contains property', (t) => { ] }) - t.throws(() => stringify({}), new Error('"\'" is required!')) + t.assert.throws(() => stringify({}), new Error('"\'" is required!')) }) test('required property containing double quote, contains property', (t) => { @@ -32,7 +32,7 @@ test('required property containing double quote, contains property', (t) => { ] }) - t.throws(() => stringify({}), new Error('""" is required!')) + t.assert.throws(() => stringify({}), new Error('""" is required!')) }) test('required property containing single quote, does not contain property', (t) => { @@ -48,7 +48,7 @@ test('required property containing single quote, does not contain property', (t) ] }) - t.throws(() => stringify({}), new Error('"\'" is required!')) + t.assert.throws(() => stringify({}), new Error('"\'" is required!')) }) test('required property containing double quote, does not contain property', (t) => { @@ -64,5 +64,5 @@ test('required property containing double quote, does not contain property', (t) ] }) - t.throws(() => stringify({}), new Error('""" is required!')) + t.assert.throws(() => stringify({}), new Error('""" is required!')) }) diff --git a/test/side-effect.test.js b/test/side-effect.test.js index a3eece9e..f1a1f30d 100644 --- a/test/side-effect.test.js +++ b/test/side-effect.test.js @@ -1,6 +1,6 @@ 'use strict' -const { test } = require('tap') +const { test } = require('node:test') const clone = require('rfdc/default') const build = require('..') @@ -32,8 +32,8 @@ test('oneOf with $ref should not change the input schema', t => { }) const value = stringify({ people: { name: 'hello', foo: 'bar' } }) - t.equal(value, '{"people":{"name":"hello"}}') - t.same(schema, clonedSchema) + t.assert.equal(value, '{"people":{"name":"hello"}}') + t.assert.deepStrictEqual(schema, clonedSchema) }) test('oneOf and anyOf with $ref should not change the input schema', t => { @@ -75,9 +75,9 @@ test('oneOf and anyOf with $ref should not change the input schema', t => { const valueAny1 = stringify({ people: { name: 'hello', foo: 'bar' }, love: 'music' }) const valueAny2 = stringify({ people: { name: 'hello', foo: 'bar' }, love: true }) - t.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}') - t.equal(valueAny2, '{"people":{"name":"hello"},"love":true}') - t.same(schema, clonedSchema) + t.assert.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}') + t.assert.equal(valueAny2, '{"people":{"name":"hello"},"love":true}') + t.assert.deepStrictEqual(schema, clonedSchema) }) test('multiple $ref tree', t => { @@ -118,8 +118,8 @@ test('multiple $ref tree', t => { }) const value = stringify({ people: { name: 'hello', foo: 'bar', age: 42 } }) - t.equal(value, '{"people":{"name":"hello","age":42}}') - t.same(schema, clonedSchema) + t.assert.equal(value, '{"people":{"name":"hello","age":42}}') + t.assert.deepStrictEqual(schema, clonedSchema) }) test('must not mutate items $ref', t => { @@ -152,8 +152,8 @@ test('must not mutate items $ref', t => { }) const value = stringify([{ name: 'foo' }]) - t.equal(value, '[{"name":"foo"}]') - t.same(schema, clonedSchema) + t.assert.equal(value, '[{"name":"foo"}]') + t.assert.deepStrictEqual(schema, clonedSchema) }) test('must not mutate items referred by $ref', t => { @@ -191,6 +191,6 @@ test('must not mutate items referred by $ref', t => { }) const value = stringify({ name: { name: 'foo' } }) - t.equal(value, '{"name":{"name":"foo"}}') - t.same(firstSchema, clonedSchema) + t.assert.equal(value, '{"name":{"name":"foo"}}') + t.assert.deepStrictEqual(firstSchema, clonedSchema) }) diff --git a/test/standalone-mode.test.js b/test/standalone-mode.test.js index 73b25fa0..528d05fa 100644 --- a/test/standalone-mode.test.js +++ b/test/standalone-mode.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test, after } = require('node:test') const fjs = require('..') const fs = require('fs') const path = require('path') @@ -22,23 +22,29 @@ const tmpDir = 'test/fixtures' test('activate standalone mode', async (t) => { t.plan(3) - const code = build({ mode: 'standalone' }) - t.type(code, 'string') - t.equal(code.indexOf('ajv'), -1) - - const destination = path.resolve(tmpDir, 'standalone.js') - t.teardown(async () => { + after(async () => { await fs.promises.rm(destination, { force: true }) }) + const code = build({ mode: 'standalone' }) + t.assert.ok(typeof code === 'string') + t.assert.equal(code.indexOf('ajv'), -1) + + const destination = path.resolve(tmpDir, 'standalone.js') + await fs.promises.writeFile(destination, code) const standalone = require(destination) - t.same(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted') + t.assert.equal(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted') }) test('test ajv schema', async (t) => { t.plan(3) + + after(async () => { + await fs.promises.rm(destination, { force: true }) + }) + const code = build({ mode: 'standalone' }, { type: 'object', properties: { @@ -86,18 +92,14 @@ test('test ajv schema', async (t) => { } } }) - t.type(code, 'string') - t.equal(code.indexOf('ajv') > 0, true) + t.assert.ok(typeof code === 'string') + t.assert.equal(code.indexOf('ajv') > 0, true) const destination = path.resolve(tmpDir, 'standalone2.js') - t.teardown(async () => { - await fs.promises.rm(destination, { force: true }) - }) - await fs.promises.writeFile(destination, code) const standalone = require(destination) - t.same(standalone({ + t.assert.equal(standalone({ kind: 'foobar', foo: 'FOO', list: [{ @@ -122,6 +124,11 @@ test('test ajv schema', async (t) => { test('no need to keep external schemas once compiled', async (t) => { t.plan(1) + + after(async () => { + await fs.promises.rm(destination, { force: true }) + }) + const externalSchema = { first: { definitions: { @@ -145,19 +152,19 @@ test('no need to keep external schemas once compiled', async (t) => { const destination = path.resolve(tmpDir, 'standalone3.js') - t.teardown(async () => { - await fs.promises.rm(destination, { force: true }) - }) - await fs.promises.writeFile(destination, code) const standalone = require(destination) - t.same(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas') + t.assert.equal(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas') }) test('no need to keep external schemas once compiled - with oneOf validator', async (t) => { t.plan(2) + after(async () => { + await fs.promises.rm(destination, { force: true }) + }) + const externalSchema = { ext: { definitions: { @@ -204,13 +211,9 @@ test('no need to keep external schemas once compiled - with oneOf validator', as const destination = path.resolve(tmpDir, 'standalone-oneOf-ref.js') - t.teardown(async () => { - await fs.promises.rm(destination, { force: true }) - }) - await fs.promises.writeFile(destination, code) const stringify = require(destination) - t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}') - t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}') + t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}') + t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}') }) diff --git a/test/string.test.js b/test/string.test.js index 690014e8..518513da 100644 --- a/test/string.test.js +++ b/test/string.test.js @@ -1,7 +1,7 @@ 'use strict' -const t = require('tap') -const test = t.test +const { test } = require('node:test') + const build = require('..') test('serialize short string', (t) => { @@ -15,8 +15,8 @@ test('serialize short string', (t) => { const stringify = build(schema) const output = stringify(input) - t.equal(output, '"abcd"') - t.equal(JSON.parse(output), input) + t.assert.equal(output, '"abcd"') + t.assert.equal(JSON.parse(output), input) }) test('serialize short string', (t) => { @@ -30,8 +30,8 @@ test('serialize short string', (t) => { const stringify = build(schema) const output = stringify(input) - t.equal(output, '"\\u0000"') - t.equal(JSON.parse(output), input) + t.assert.equal(output, '"\\u0000"') + t.assert.equal(JSON.parse(output), input) }) test('serialize long string', (t) => { @@ -45,8 +45,8 @@ test('serialize long string', (t) => { const stringify = build(schema) const output = stringify(input) - t.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`) - t.equal(JSON.parse(output), input) + t.assert.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`) + t.assert.equal(JSON.parse(output), input) }) test('unsafe string', (t) => { @@ -61,8 +61,8 @@ test('unsafe string', (t) => { const stringify = build(schema) const output = stringify(input) - t.equal(output, `"${input}"`) - t.equal(JSON.parse(output), input) + t.assert.equal(output, `"${input}"`) + t.assert.equal(JSON.parse(output), input) }) test('unsafe unescaped string', (t) => { @@ -77,8 +77,8 @@ test('unsafe unescaped string', (t) => { const stringify = build(schema) const output = stringify(input) - t.equal(output, `"${input}"`) - t.throws(function () { + t.assert.equal(output, `"${input}"`) + t.assert.throws(function () { JSON.parse(output) }) }) diff --git a/test/surrogate.test.js b/test/surrogate.test.js index f45e2b4a..37943bd7 100644 --- a/test/surrogate.test.js +++ b/test/surrogate.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const validator = require('is-my-json-valid') const build = require('..') @@ -16,8 +16,8 @@ test('render a string with surrogate pairs as JSON:test 1', (t) => { const stringify = build(schema) const output = stringify('𝌆') - t.equal(output, '"𝌆"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"𝌆"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a string with surrogate pairs as JSON: test 2', (t) => { @@ -32,8 +32,8 @@ test('render a string with surrogate pairs as JSON: test 2', (t) => { const stringify = build(schema) const output = stringify('\uD834\uDF06') - t.equal(output, '"𝌆"') - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, '"𝌆"') + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a string with Unpaired surrogate code as JSON', (t) => { @@ -47,8 +47,8 @@ test('render a string with Unpaired surrogate code as JSON', (t) => { const validate = validator(schema) const stringify = build(schema) const output = stringify('\uDF06\uD834') - t.equal(output, JSON.stringify('\uDF06\uD834')) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify('\uDF06\uD834')) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) test('render a string with lone surrogate code as JSON', (t) => { @@ -62,6 +62,6 @@ test('render a string with lone surrogate code as JSON', (t) => { const validate = validator(schema) const stringify = build(schema) const output = stringify('\uDEAD') - t.equal(output, JSON.stringify('\uDEAD')) - t.ok(validate(JSON.parse(output)), 'valid schema') + t.assert.equal(output, JSON.stringify('\uDEAD')) + t.assert.ok(validate(JSON.parse(output)), 'valid schema') }) diff --git a/test/toJSON.test.js b/test/toJSON.test.js index 67429550..61010b1b 100644 --- a/test/toJSON.test.js +++ b/test/toJSON.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('use toJSON method on object types', (t) => { @@ -22,7 +22,7 @@ test('use toJSON method on object types', (t) => { } } - t.equal('{"productName":"cola"}', stringify(object)) + t.assert.equal('{"productName":"cola"}', stringify(object)) }) test('use toJSON method on nested object types', (t) => { @@ -55,7 +55,7 @@ test('use toJSON method on nested object types', (t) => { } ] - t.equal('[{"productName":"cola"},{"productName":"sprite"}]', stringify(array)) + t.assert.equal('[{"productName":"cola"},{"productName":"sprite"}]', stringify(array)) }) test('not use toJSON if does not exist', (t) => { @@ -79,7 +79,7 @@ test('not use toJSON if does not exist', (t) => { product: { name: 'cola' } } - t.equal('{"product":{"name":"cola"}}', stringify(object)) + t.assert.equal('{"product":{"name":"cola"}}', stringify(object)) }) test('not fail on null object declared nullable', (t) => { @@ -100,7 +100,7 @@ test('not fail on null object declared nullable', (t) => { } } }) - t.equal('null', stringify(null)) + t.assert.equal('null', stringify(null)) }) test('not fail on null sub-object declared nullable', (t) => { @@ -124,7 +124,7 @@ test('not fail on null sub-object declared nullable', (t) => { const object = { product: null } - t.equal('{"product":null}', stringify(object)) + t.assert.equal('{"product":null}', stringify(object)) }) test('on non nullable null sub-object it should coerce to {}', (t) => { @@ -150,7 +150,7 @@ test('on non nullable null sub-object it should coerce to {}', (t) => { } const result = stringify(object) - t.equal(result, JSON.stringify({ product: {} })) + t.assert.equal(result, JSON.stringify({ product: {} })) }) test('on non nullable null object it should coerce to {}', (t) => { @@ -174,7 +174,7 @@ test('on non nullable null object it should coerce to {}', (t) => { }) const result = stringify(null) - t.equal(result, '{}') + t.assert.equal(result, '{}') }) test('on non-nullable null object it should skip rendering, skipping required fields checks', (t) => { @@ -199,5 +199,5 @@ test('on non-nullable null object it should skip rendering, skipping required fi }) const result = stringify(null) - t.equal(result, '{}') + t.assert.equal(result, '{}') }) diff --git a/test/typebox.test.js b/test/typebox.test.js index 3db22078..9bf8f28d 100644 --- a/test/typebox.test.js +++ b/test/typebox.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('nested object in pattern properties for typebox', (t) => { @@ -32,5 +32,5 @@ test('nested object in pattern properties for typebox', (t) => { } } }) - t.equal(value, '{"key1":{"nestedKey":{"nestedKey1":"value1"}},"key2":{"nestedKey":{"nestedKey1":"value2"}}}') + t.assert.equal(value, '{"key1":{"nestedKey":{"nestedKey1":"value1"}},"key2":{"nestedKey":{"nestedKey1":"value2"}}}') }) diff --git a/test/typesArray.test.js b/test/typesArray.test.js index 920eb8e8..341cc032 100644 --- a/test/typesArray.test.js +++ b/test/typesArray.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('possibly nullable integer primitive alternative', (t) => { @@ -21,7 +21,7 @@ test('possibly nullable integer primitive alternative', (t) => { const value = stringify({ data: 4 }) - t.equal(value, '{"data":4}') + t.assert.equal(value, '{"data":4}') }) test('possibly nullable number primitive alternative', (t) => { @@ -42,7 +42,7 @@ test('possibly nullable number primitive alternative', (t) => { const value = stringify({ data: 4 }) - t.equal(value, '{"data":4}') + t.assert.equal(value, '{"data":4}') }) test('possibly nullable integer primitive alternative with null value', (t) => { @@ -63,7 +63,7 @@ test('possibly nullable integer primitive alternative with null value', (t) => { const value = stringify({ data: null }) - t.equal(value, '{"data":0}') + t.assert.equal(value, '{"data":0}') }) test('possibly nullable number primitive alternative with null value', (t) => { @@ -84,7 +84,7 @@ test('possibly nullable number primitive alternative with null value', (t) => { const value = stringify({ data: null }) - t.equal(value, '{"data":0}') + t.assert.equal(value, '{"data":0}') }) test('possibly nullable number primitive alternative with null value', (t) => { @@ -105,7 +105,7 @@ test('possibly nullable number primitive alternative with null value', (t) => { const value = stringify({ data: null }) - t.equal(value, '{"data":false}') + t.assert.equal(value, '{"data":false}') }) test('nullable integer primitive', (t) => { @@ -126,7 +126,7 @@ test('nullable integer primitive', (t) => { const value = stringify({ data: 4 }) - t.equal(value, '{"data":4}') + t.assert.equal(value, '{"data":4}') }) test('nullable number primitive', (t) => { @@ -147,7 +147,7 @@ test('nullable number primitive', (t) => { const value = stringify({ data: 4 }) - t.equal(value, '{"data":4}') + t.assert.equal(value, '{"data":4}') }) test('nullable primitive with null value', (t) => { @@ -168,7 +168,7 @@ test('nullable primitive with null value', (t) => { const value = stringify({ data: null }) - t.equal(value, '{"data":null}') + t.assert.equal(value, '{"data":null}') }) test('nullable number primitive with null value', (t) => { @@ -189,7 +189,7 @@ test('nullable number primitive with null value', (t) => { const value = stringify({ data: null }) - t.equal(value, '{"data":null}') + t.assert.equal(value, '{"data":null}') }) test('possibly null object with multi-type property', (t) => { @@ -211,19 +211,19 @@ test('possibly null object with multi-type property', (t) => { } const stringify = build(schema) - t.equal(stringify({ + t.assert.equal(stringify({ objectOrNull: { stringOrNumber: 'string' } }), '{"objectOrNull":{"stringOrNumber":"string"}}') - t.equal(stringify({ + t.assert.equal(stringify({ objectOrNull: { stringOrNumber: 42 } }), '{"objectOrNull":{"stringOrNumber":42}}') - t.equal(stringify({ + t.assert.equal(stringify({ objectOrNull: null }), '{"objectOrNull":null}') }) @@ -249,7 +249,7 @@ test('object with possibly null array of multiple types', (t) => { const value = stringify({ arrayOfStringsAndNumbers: null }) - t.equal(value, '{"arrayOfStringsAndNumbers":null}') + t.assert.equal(value, '{"arrayOfStringsAndNumbers":null}') } catch (e) { console.log(e) t.fail() @@ -259,21 +259,21 @@ test('object with possibly null array of multiple types', (t) => { const value = stringify({ arrayOfStringsAndNumbers: ['string1', 'string2'] }) - t.equal(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}') + t.assert.equal(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}') } catch (e) { console.log(e) t.fail() } - t.equal(stringify({ + t.assert.equal(stringify({ arrayOfStringsAndNumbers: [42, 7] }), '{"arrayOfStringsAndNumbers":[42,7]}') - t.equal(stringify({ + t.assert.equal(stringify({ arrayOfStringsAndNumbers: ['string1', 42, 7, 'string2'] }), '{"arrayOfStringsAndNumbers":["string1",42,7,"string2"]}') - t.equal(stringify({ + t.assert.equal(stringify({ arrayOfStringsAndNumbers: ['string1', null, 42, 7, 'string2', null] }), '{"arrayOfStringsAndNumbers":["string1",null,42,7,"string2",null]}') }) @@ -307,7 +307,7 @@ test('object with tuple of multiple types', (t) => { const value = stringify({ fixedTupleOfStringsAndNumbers: ['string1', 42, 7] }) - t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}') + t.assert.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}') } catch (e) { console.log(e) t.fail() @@ -317,7 +317,7 @@ test('object with tuple of multiple types', (t) => { const value = stringify({ fixedTupleOfStringsAndNumbers: ['string1', 42, 'string2'] }) - t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}') + t.assert.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}') } catch (e) { console.log(e) t.fail() @@ -354,17 +354,17 @@ test('object with anyOf and multiple types', (t) => { const value = stringify({ objectOrBoolean: { stringOrNumber: 'string' } }) - t.equal(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}') + t.assert.equal(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}') } catch (e) { console.log(e) t.fail() } - t.equal(stringify({ + t.assert.equal(stringify({ objectOrBoolean: { stringOrNumber: 42 } }), '{"objectOrBoolean":{"stringOrNumber":42}}') - t.equal(stringify({ + t.assert.equal(stringify({ objectOrBoolean: true }), '{"objectOrBoolean":true}') }) @@ -383,7 +383,7 @@ test('string type array can handle dates', (t) => { date: new Date('2018-04-20T07:52:31.017Z'), dateObject: new Date('2018-04-21T07:52:31.017Z') }) - t.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}') + t.assert.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}') }) test('object that is simultaneously a string and a json', (t) => { @@ -406,10 +406,10 @@ test('object that is simultaneously a string and a json', (t) => { const stringify = build(schema) const valueStr = stringify({ simultaneously: likeObjectId }) - t.equal(valueStr, '{"simultaneously":"hello"}') + t.assert.equal(valueStr, '{"simultaneously":"hello"}') const valueObj = stringify({ simultaneously: { foo: likeObjectId } }) - t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') + t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') }) test('object that is simultaneously a string and a json switched', (t) => { @@ -432,10 +432,10 @@ test('object that is simultaneously a string and a json switched', (t) => { const stringify = build(schema) const valueStr = stringify({ simultaneously: likeObjectId }) - t.equal(valueStr, '{"simultaneously":{}}') + t.assert.equal(valueStr, '{"simultaneously":{}}') const valueObj = stringify({ simultaneously: { foo: likeObjectId } }) - t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') + t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') }) test('class instance that is simultaneously a string and a json', (t) => { @@ -461,10 +461,10 @@ test('class instance that is simultaneously a string and a json', (t) => { const stringify = build(schema) const valueStr = stringify({ simultaneously: likeObjectId }) - t.equal(valueStr, '{"simultaneously":"hello"}') + t.assert.equal(valueStr, '{"simultaneously":"hello"}') const valueObj = stringify({ simultaneously: { foo: likeObjectId } }) - t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') + t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}') }) test('should not throw an error when type is array and object is null, it should instead coerce to []', (t) => { @@ -483,7 +483,7 @@ test('should not throw an error when type is array and object is null, it should const stringify = build(schema) const result = stringify({ arr: null }) - t.equal(result, JSON.stringify({ arr: [] })) + t.assert.equal(result, JSON.stringify({ arr: [] })) }) test('should throw an error when type is array and object is not an array', (t) => { @@ -501,7 +501,7 @@ test('should throw an error when type is array and object is not an array', (t) } const stringify = build(schema) - t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.')) + t.assert.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.')) }) test('should throw an error when type is array and object is not an array with external schema', (t) => { @@ -529,7 +529,7 @@ test('should throw an error when type is array and object is not an array with e } const stringify = build(schema, { schema: externalSchema }) - t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'arrayOfNumbers#/definitions/arr\' does not match schema definition.')) + t.assert.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'arrayOfNumbers#/definitions/arr\' does not match schema definition.')) }) test('throw an error if none of types matches', (t) => { @@ -546,5 +546,5 @@ test('throw an error if none of types matches', (t) => { } const stringify = build(schema) - t.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.') + t.assert.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.') }) diff --git a/test/unknownFormats.test.js b/test/unknownFormats.test.js index 92d22d5c..b38363dd 100644 --- a/test/unknownFormats.test.js +++ b/test/unknownFormats.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const build = require('..') test('object with custom format field', (t) => { @@ -19,9 +19,9 @@ test('object with custom format field', (t) => { const stringify = build(schema) - stringify({ - str: 'string' + t.assert.doesNotThrow(() => { + stringify({ + str: 'string' + }) }) - - t.pass() }) diff --git a/test/webpack.test.js b/test/webpack.test.js index 075d64c6..6a27c166 100644 --- a/test/webpack.test.js +++ b/test/webpack.test.js @@ -1,6 +1,6 @@ 'use strict' -const test = require('tap').test +const { test } = require('node:test') const webpack = require('webpack') const path = require('path') @@ -46,5 +46,5 @@ test('the library should work with webpack', async (t) => { }) const obj = { foo: '42', bar: true } - t.equal(stringify(obj), '{"foo":"42","bar":true}') + t.assert.equal(stringify(obj), '{"foo":"42","bar":true}') })