Meik/simple-mail-cleaner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aktueller Stand

Browse Source
This commit is contained in:
Meik
2026-01-22 19:05:45 +01:00
parent 85dee61a4d
commit e280e4eadb
1967 changed files with 397327 additions and 74093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
backend/node_modules/fast-json-stringify/test/additionalProperties.test.js generated vendored
View File

@@ -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"}')
})

76
backend/node_modules/fast-json-stringify/test/allof.test.js generated vendored
View File

@@ -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"}}')
})

56
backend/node_modules/fast-json-stringify/test/any.test.js generated vendored
View File

@@ -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.'))
})

90
backend/node_modules/fast-json-stringify/test/anyof.test.js generated vendored
View File

@@ -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"}')
}
})

38
backend/node_modules/fast-json-stringify/test/array.test.js generated vendored
View File

@@ -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: {

4
backend/node_modules/fast-json-stringify/test/asNumber.test.js generated vendored
View File

@@ -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')
})

52
backend/node_modules/fast-json-stringify/test/basic.test.js generated vendored
View File

@@ -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))
})

12
backend/node_modules/fast-json-stringify/test/bigint.test.js generated vendored
View File

@@ -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}')
})

16
backend/node_modules/fast-json-stringify/test/clean-cache.test.js generated vendored
View File

@@ -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)
})
})

70
backend/node_modules/fast-json-stringify/test/const.test.js generated vendored
View File

@@ -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')
})

154
backend/node_modules/fast-json-stringify/test/date.test.js generated vendored
View File

@@ -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')
})

54
backend/node_modules/fast-json-stringify/test/debug-mode.test.js generated vendored
View File

@@ -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)
})

4
backend/node_modules/fast-json-stringify/test/defaults.test.js generated vendored
View File

@@ -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))
})
}

6
backend/node_modules/fast-json-stringify/test/enum.test.js generated vendored
View File

@@ -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))
})

35
backend/node_modules/fast-json-stringify/test/fix-604.test.js generated vendored
View File

@@ -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.' })
})

46
backend/node_modules/fast-json-stringify/test/if-then-else.test.js generated vendored
View File

@@ -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"}}')
})

8
backend/node_modules/fast-json-stringify/test/inferType.test.js generated vendored
View File

@@ -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')
})
}

8
backend/node_modules/fast-json-stringify/test/infinity.test.js generated vendored
View File

@@ -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)))
})

42
backend/node_modules/fast-json-stringify/test/integer.test.js generated vendored
View File

@@ -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')
})
})

12
backend/node_modules/fast-json-stringify/test/invalidSchema.test.js generated vendored
View File

@@ -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:.*/ })
})

4
backend/node_modules/fast-json-stringify/test/issue-479.test.js generated vendored
View File

@@ -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"}')
})

107
backend/node_modules/fast-json-stringify/test/issue-793.test.js generated vendored Normal file
View File

@@ -0,0 +1,107 @@
'use strict'
const { test } = require('node:test')
const build = require('..')
test('serialize string with newlines - issue #793', (t) => {
t.plan(2)
const schema = {
type: 'object',
properties: {
message: {
type: 'string'
}
}
}
const input = {
message: `This is a string
with multiple
newlines in it
Foo`
}
const stringify = build(schema)
const output = stringify(input)
// The output should be valid JSON
t.assert.doesNotThrow(() => {
JSON.parse(output)
}, 'JSON output should be parseable')
// The parsed output should match the input
const parsed = JSON.parse(output)
t.assert.equal(parsed.message, input.message)
})
test('serialize string with various newline characters - issue #793', (t) => {
t.plan(4)
const schema = {
type: 'string'
}
const stringify = build(schema)
// Test \n (line feed)
const inputLF = 'line1\nline2'
const outputLF = stringify(inputLF)
t.assert.equal(JSON.parse(outputLF), inputLF)
// Test \r (carriage return)
const inputCR = 'line1\rline2'
const outputCR = stringify(inputCR)
t.assert.equal(JSON.parse(outputCR), inputCR)
// Test \r\n (CRLF)
const inputCRLF = 'line1\r\nline2'
const outputCRLF = stringify(inputCRLF)
t.assert.equal(JSON.parse(outputCRLF), inputCRLF)
// Test mixed newlines
const inputMixed = 'line1\nline2\rline3\r\nline4'
const outputMixed = stringify(inputMixed)
t.assert.equal(JSON.parse(outputMixed), inputMixed)
})
test('serialize object with newlines in multiple properties - issue #793', (t) => {
t.plan(2)
const schema = {
type: 'object',
properties: {
message: {
type: 'string'
},
description: {
type: 'string'
},
timestamp: {
type: 'string'
}
}
}
const input = {
message: `This is a string
with multiple
newlines in it
Foo`,
description: 'This JSON response contains a field with newline characters',
timestamp: new Date().toISOString()
}
const stringify = build(schema)
const output = stringify(input)
// The output should be valid JSON
t.assert.doesNotThrow(() => {
JSON.parse(output)
}, 'JSON output should be parseable')
// The parsed output should match the input
const parsed = JSON.parse(output)
t.assert.deepEqual(parsed, input)
})

177
backend/node_modules/fast-json-stringify/test/issue-794.test.js generated vendored Normal file
View File

@@ -0,0 +1,177 @@
'use strict'
const { test } = require('node:test')
const build = require('..')
test('serialize string with quotes - issue #794', (t) => {
t.plan(2)
const schema = {
type: 'object',
properties: {
message: {
type: 'string'
}
}
}
const input = {
message: 'Error: Property "name" is required'
}
const stringify = build(schema)
const output = stringify(input)
// The output should be valid JSON
t.assert.doesNotThrow(() => {
JSON.parse(output)
}, 'JSON output should be parseable')
// The parsed output should match the input
const parsed = JSON.parse(output)
t.assert.equal(parsed.message, input.message)
})
test('serialize string with various quote types - issue #794', (t) => {
t.plan(6)
const schema = {
type: 'string'
}
const stringify = build(schema)
// Test double quotes
const inputDoubleQuotes = 'Property "name" is required'
const outputDoubleQuotes = stringify(inputDoubleQuotes)
t.assert.doesNotThrow(() => JSON.parse(outputDoubleQuotes))
t.assert.equal(JSON.parse(outputDoubleQuotes), inputDoubleQuotes)
// Test single quotes (should be fine but test for completeness)
const inputSingleQuotes = "Property 'name' is required"
const outputSingleQuotes = stringify(inputSingleQuotes)
t.assert.doesNotThrow(() => JSON.parse(outputSingleQuotes))
t.assert.equal(JSON.parse(outputSingleQuotes), inputSingleQuotes)
// Test mixed quotes
const inputMixedQuotes = 'Error: "Property \'name\' is required"'
const outputMixedQuotes = stringify(inputMixedQuotes)
t.assert.doesNotThrow(() => JSON.parse(outputMixedQuotes))
t.assert.equal(JSON.parse(outputMixedQuotes), inputMixedQuotes)
})
test('serialize error-like object with quotes in message - issue #794', (t) => {
t.plan(2)
const schema = {
type: 'object',
properties: {
error: {
type: 'object',
properties: {
message: {
type: 'string'
},
code: {
type: 'string'
}
}
}
}
}
const input = {
error: {
message: 'Validation failed: Property "email" must be a valid email address',
code: 'VALIDATION_ERROR'
}
}
const stringify = build(schema)
const output = stringify(input)
// The output should be valid JSON
t.assert.doesNotThrow(() => {
JSON.parse(output)
}, 'JSON output should be parseable')
// The parsed output should match the input
const parsed = JSON.parse(output)
t.assert.deepEqual(parsed, input)
})
test('serialize validation errors array with quotes - issue #794', (t) => {
t.plan(2)
const schema = {
type: 'object',
properties: {
errors: {
type: 'array',
items: {
type: 'object',
properties: {
message: {
type: 'string'
},
field: {
type: 'string'
}
}
}
}
}
}
const input = {
errors: [
{
message: 'Property "name" is required',
field: 'name'
},
{
message: 'Property "email" must be a valid email address',
field: 'email'
},
{
message: 'Value must be between "1" and "100"',
field: 'age'
}
]
}
const stringify = build(schema)
const output = stringify(input)
// The output should be valid JSON
t.assert.doesNotThrow(() => {
JSON.parse(output)
}, 'JSON output should be parseable')
// The parsed output should match the input
const parsed = JSON.parse(output)
t.assert.deepEqual(parsed, input)
})
test('serialize string with backslashes and quotes - issue #794', (t) => {
t.plan(4)
const schema = {
type: 'string'
}
const stringify = build(schema)
// Test backslashes
const inputBackslash = 'Path: C:\\Users\\test\\file.json'
const outputBackslash = stringify(inputBackslash)
t.assert.doesNotThrow(() => JSON.parse(outputBackslash))
t.assert.equal(JSON.parse(outputBackslash), inputBackslash)
// Test combination of backslashes and quotes
const inputMixed = 'Error: Could not find file "C:\\Users\\test\\config.json"'
const outputMixed = stringify(inputMixed)
t.assert.doesNotThrow(() => JSON.parse(outputMixed))
t.assert.equal(JSON.parse(outputMixed), inputMixed)
})

57
backend/node_modules/fast-json-stringify/test/json-add-comma.test.js generated vendored Normal file
View File

@@ -0,0 +1,57 @@
'use strict'
const { test } = require('node:test')
const build = require('..')
test('additionalProperties: false', (t) => {
t.plan(1)
const stringify = build({
title: 'additionalProperties',
type: 'object',
properties: {
foo: {
type: 'string'
}
},
additionalProperties: false
})
const obj = { foo: 'a', bar: 'b', baz: 'c' }
t.assert.equal(stringify(obj), '{"foo":"a"}')
})
test('additionalProperties: {}', (t) => {
t.plan(1)
const stringify = build({
title: 'additionalProperties',
type: 'object',
properties: {
foo: {
type: 'string'
}
},
additionalProperties: {}
})
const obj = { foo: 'a', bar: 'b', baz: 'c' }
t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
})
test('additionalProperties: {type: string}', (t) => {
t.plan(1)
const stringify = build({
title: 'additionalProperties',
type: 'object',
properties: {
foo: {
type: 'string'
}
},
additionalProperties: {
type: 'string'
}
})
const obj = { foo: 'a', bar: 'b', baz: 'c' }
t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
})

2
backend/node_modules/fast-json-stringify/test/json-schema-test-suite/README.md generated vendored
View File

@@ -5,6 +5,6 @@ It contains a set of JSON objects that implementors of JSON Schema validation li
# How to add another test case?
1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/master/tests)
1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests)
2. Choose a draft `draft4`, `draft6` or `draft7`
3. Copy & paste the `test-case.json` to the project and add a test like in the `draft4.test.js`

6
backend/node_modules/fast-json-stringify/test/json-schema-test-suite/draft4.test.js generated vendored
View File

@@ -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)
})

6
backend/node_modules/fast-json-stringify/test/json-schema-test-suite/draft6.test.js generated vendored
View File

@@ -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)
})

6
backend/node_modules/fast-json-stringify/test/json-schema-test-suite/draft7.test.js generated vendored
View File

@@ -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)
})

15
backend/node_modules/fast-json-stringify/test/json-schema-test-suite/util.js generated vendored
View File

@@ -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)
}
})
}

16
backend/node_modules/fast-json-stringify/test/missing-values.test.js generated vendored
View File

@@ -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 }))
})

4
backend/node_modules/fast-json-stringify/test/multi-type-serializer.test.js generated vendored
View File

@@ -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.'))
})

6
backend/node_modules/fast-json-stringify/test/nestedObjects.test.js generated vendored
View File

@@ -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))
})

70
backend/node_modules/fast-json-stringify/test/nullable.test.js generated vendored
View File

@@ -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))
})

56
backend/node_modules/fast-json-stringify/test/oneof.test.js generated vendored
View File

@@ -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, [], {}] }))
})

22
backend/node_modules/fast-json-stringify/test/patternProperties.test.js generated vendored
View File

@@ -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: {},

12
backend/node_modules/fast-json-stringify/test/recursion.test.js generated vendored
View File

@@ -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":[]}]}]}]}')
})

288
backend/node_modules/fast-json-stringify/test/ref.test.js generated vendored
View File

@@ -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 schema "test".')
}
})

9
backend/node_modules/fast-json-stringify/test/regex.test.js generated vendored
View File

@@ -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')
})

119
backend/node_modules/fast-json-stringify/test/required.test.js generated vendored
View File

@@ -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.' })
})

66
backend/node_modules/fast-json-stringify/test/requiresAjv.test.js generated vendored
View File

@@ -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"]}}}')
})

85
backend/node_modules/fast-json-stringify/test/sanitize.test.js generated vendored
View File

@@ -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": {}
}
})
// 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 stringify3 = build({
title: 'Example Schema',
type: 'object',
properties: {
"\"phra\\'&&(console.log(42))//||'phra": {}
}
}
})
})
t.same(JSON.parse(stringify4({})), {
'"\\\\\\\\\'w00t': '"\'w00t'
})
// this verifies the escaping
JSON.parse(stringify3({
'"phra\'&&(console.log(42))//||\'phra': 42
}))
t.pass('no crashes')
const stringify4 = build({
title: 'Example Schema',
type: 'object',
properties: {
'"\\\\\\\\\'w00t': {
type: 'string',
default: '"\'w00t'
}
}
})
t.assert.deepStrictEqual(JSON.parse(stringify4({})), {
'"\\\\\\\\\'w00t': '"\'w00t'
})
})

22
backend/node_modules/fast-json-stringify/test/sanitize2.test.js generated vendored
View File

@@ -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'
}
}
}
})
t.assert.doesNotThrow(() => stringify({}))
})
stringify({})
t.pass('no crashes')

24
backend/node_modules/fast-json-stringify/test/sanitize3.test.js generated vendored
View File

@@ -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' })
})

18
backend/node_modules/fast-json-stringify/test/sanitize4.test.js generated vendored
View File

@@ -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.assert.throws(() => {
stringify({})
}, { message: '""];(throw "pwoned")//" is required!' })
})
t.throws(() => {
stringify({})
}, 'Error: ""];(throw "pwoned")//" is required!')

22
backend/node_modules/fast-json-stringify/test/sanitize5.test.js generated vendored
View File

@@ -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"' })
})

28
backend/node_modules/fast-json-stringify/test/sanitize6.test.js generated vendored
View File

@@ -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')

10
backend/node_modules/fast-json-stringify/test/sanitize7.test.js generated vendored
View File

@@ -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!'))
})

24
backend/node_modules/fast-json-stringify/test/side-effect.test.js generated vendored
View File

@@ -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)
})

55
backend/node_modules/fast-json-stringify/test/standalone-mode.test.js generated vendored
View File

@@ -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"}}')
})

24
backend/node_modules/fast-json-stringify/test/string.test.js generated vendored
View File

@@ -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)
})
})

18
backend/node_modules/fast-json-stringify/test/surrogate.test.js generated vendored
View File

@@ -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')
})

18
backend/node_modules/fast-json-stringify/test/toJSON.test.js generated vendored
View File

@@ -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, '{}')
})

4
backend/node_modules/fast-json-stringify/test/typebox.test.js generated vendored
View File

@@ -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"}}}')
})

68
backend/node_modules/fast-json-stringify/test/typesArray.test.js generated vendored
View File

@@ -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.')
})

10
backend/node_modules/fast-json-stringify/test/unknownFormats.test.js generated vendored
View File

@@ -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()
})

4
backend/node_modules/fast-json-stringify/test/webpack.test.js generated vendored
View File

@@ -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}')
})