feat: move to tap 15 (#313)

* feat: move to tap15

* fix: deprecated methods

Author: zekth

.taprc

@@ -1,4 +1,3 @@
-esm: false
 ts: false
 jsx: false
 coverage: false

package.json

@@ -40,7 +40,7 @@
     "proxyquire": "^2.1.3",
     "semver": "^7.1.0",
     "standard": "^16.0.1",
-    "tap": "^14.0.0",
+    "tap": "^15.0.0",
     "typescript": "^4.0.2"
   },
   "dependencies": {

test/allof.test.js

@@ -44,23 +44,23 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       id: 1
     })
   } catch (e) {
-    t.is(e.message, '"name" is required!')
+    t.equal(e.message, '"name" is required!')
   }
 
   try {
     stringify({
       name: 'string'
     })
   } catch (e) {
-    t.is(e.message, '"id" is required!')
+    t.equal(e.message, '"id" is required!')
   }
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1,
     name: 'string'
   }), '{"name":"string","id":1}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1,
     name: 'string',
     tag: 'otherString'
@@ -92,7 +92,7 @@ test('object with allOf and one schema on the allOf', (t) => {
   const value = stringify({
     id: 1
   })
-  t.is(value, '{"id":1}')
+  t.equal(value, '{"id":1}')
 })
 
 test('object with allOf and no schema on the allOf', (t) => {
@@ -108,7 +108,7 @@ test('object with allOf and no schema on the allOf', (t) => {
     build(schema)
     t.fail()
   } catch (e) {
-    t.is(e.message, 'schema is invalid: data.allOf should NOT have fewer than 1 items')
+    t.equal(e.message, 'schema is invalid: data.allOf should NOT have fewer than 1 items')
   }
 })
 
@@ -160,7 +160,7 @@ test('object with nested allOfs', (t) => {
     id3: 3,
     id4: 4 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2,"id3":3}')
+  t.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
 test('object with $ref in allOf', (t) => {
@@ -191,7 +191,7 @@ test('object with $ref in allOf', (t) => {
     id1: 1,
     id2: 2 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1}')
+  t.equal(value, '{"id1":1}')
 })
 
 test('object with $ref and other object in allOf', (t) => {
@@ -231,7 +231,7 @@ test('object with $ref and other object in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('object with multiple $refs in allOf', (t) => {
@@ -274,7 +274,7 @@ test('object with multiple $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('object with external $refs in allOf', (t) => {
@@ -325,5 +325,5 @@ test('object with external $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })

test/any.test.js

@@ -16,19 +16,19 @@ test('object with nested random property', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: 'string'
   }), '{"id":1,"name":"string"}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: { first: 'name', last: 'last' }
   }), '{"id":1,"name":{"first":"name","last":"last"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: null
   }), '{"id":1,"name":null}')
 
-  t.is(stringify({
+  t.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.is(stringify({
+  t.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.is(value, '[1,"string",null]')
+  t.equal(value, '[1,"string",null]')
 })
 
 test('empty schema', (t) => {
@@ -71,13 +71,13 @@ test('empty schema', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify(null), 'null')
-  t.is(stringify(1), '1')
-  t.is(stringify(true), 'true')
-  t.is(stringify('hello'), '"hello"')
-  t.is(stringify({}), '{}')
-  t.is(stringify({ x: 10 }), '{"x":10}')
-  t.is(stringify([true, 1, 'hello']), '[true,1,"hello"]')
+  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"]')
 })
 
 test('empty schema on nested object', (t) => {
@@ -92,13 +92,13 @@ test('empty schema on nested object', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ x: null }), '{"x":null}')
-  t.is(stringify({ x: 1 }), '{"x":1}')
-  t.is(stringify({ x: true }), '{"x":true}')
-  t.is(stringify({ x: 'hello' }), '{"x":"hello"}')
-  t.is(stringify({ x: {} }), '{"x":{}}')
-  t.is(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
-  t.is(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
+  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"]}')
 })
 
 test('empty schema on array', (t) => {
@@ -111,7 +111,7 @@ test('empty schema on array', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
+  t.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
 })
 
 test('empty schema on anyOf', (t) => {
@@ -147,8 +147,8 @@ test('empty schema on anyOf', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
-  t.is(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
-  t.is(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
-  t.is(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
+  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"}')
 })

test/anyof.test.js

@@ -21,11 +21,11 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     str: 'string'
   }), '{"str":"string"}')
 
-  t.is(stringify({
+  t.equal(stringify({
     str: true
   }), '{"str":true}')
 })
@@ -53,11 +53,11 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: null
   }), '{"prop":null}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string'
     }
@@ -87,13 +87,13 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string'
     }
   }), '{"prop":{"str":"string"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -117,7 +117,7 @@ test('object with field of type string and coercion disable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":null}')
+  t.equal(value, '{"str":null}')
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -145,7 +145,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":"1"}')
+  t.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -179,9 +179,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
+  t.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
 
-  t.is(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
+  t.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -221,10 +221,10 @@ test('symbol value in schema', (t) => {
   }
 
   const stringify = build(schema)
-  t.is(stringify({ value: 'foo' }), '{"value":"foo"}')
-  t.is(stringify({ value: 'bar' }), '{"value":"bar"}')
-  t.is(stringify({ value: 'baz' }), '{"value":"baz"}')
-  t.is(stringify({ value: 'qux' }), '{"value":null}')
+  t.equal(stringify({ value: 'foo' }), '{"value":"foo"}')
+  t.equal(stringify({ value: 'bar' }), '{"value":"bar"}')
+  t.equal(stringify({ value: 'baz' }), '{"value":"baz"}')
+  t.equal(stringify({ value: 'qux' }), '{"value":null}')
 })
 
 test('anyOf and $ref together', (t) => {
@@ -253,9 +253,9 @@ test('anyOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.is(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('anyOf and $ref: 2 levels are fine', (t) => {
@@ -291,7 +291,7 @@ test('anyOf and $ref: 2 levels are fine', (t) => {
 
   const stringify = build(schema)
   const value = stringify({ cs: 3 })
-  t.is(value, '{"cs":3}')
+  t.equal(value, '{"cs":3}')
 })
 
 test('anyOf and $ref: multiple levels should throw at build.', (t) => {
@@ -330,9 +330,9 @@ test('anyOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 3 }), '{"cs":3}')
-  t.is(stringify({ cs: true }), '{"cs":true}')
-  t.is(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('anyOf and $ref - multiple external $ref', (t) => {
@@ -423,7 +423,7 @@ test('anyOf looks for all of the array items', (t) => {
   const stringify = build(schema)
 
   const value = stringify([{ savedId: 'great' }, { error: 'oops' }])
-  t.is(value, '[{"savedId":"great"},{"error":"oops"}]')
+  t.equal(value, '[{"savedId":"great"},{"error":"oops"}]')
 })
 
 test('anyOf with enum with more than 100 entries', (t) => {
@@ -445,5 +445,5 @@ test('anyOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.is(value, '["EUR","USD",null]')
+  t.equal(value, '["EUR","USD",null]')
 })

test/array.test.js

@@ -13,7 +13,7 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.deepEqual(JSON.parse(output), toStringify)
+    t.same(JSON.parse(output), toStringify)
     t.equal(output, JSON.stringify(toStringify))
     t.ok(validate(JSON.parse(output)), 'valid schema')
   })
@@ -195,7 +195,7 @@ test('moment array', (t) => {
   const value = stringify({
     times: [moment('2018-04-21T07:52:31.017Z')]
   })
-  t.is(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
+  t.equal(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
 })
 
 buildTest({
@@ -254,5 +254,5 @@ test('object array with anyOf and symbol', (t) => {
     { name: 'name-0', option: 'Foo' },
     { name: 'name-1', option: 'Bar' }
   ])
-  t.is(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
+  t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })

test/basic.test.js

@@ -12,7 +12,7 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.deepEqual(JSON.parse(output), toStringify)
+    t.same(JSON.parse(output), toStringify)
     t.equal(output, JSON.stringify(toStringify))
     t.ok(validate(JSON.parse(output)), 'valid schema')
   })
@@ -280,14 +280,14 @@ test('skip or coerce numbers and integers that are not numbers', (t) => {
     distance: 'long'
   })
 
-  t.deepEqual(JSON.parse(result), {})
+  t.same(JSON.parse(result), {})
 
   result = stringify({
     age: '42',
     distance: true
   })
 
-  t.deepEqual(JSON.parse(result), { age: 42, distance: 1 })
+  t.same(JSON.parse(result), { age: 42, distance: 1 })
   t.end()
 })