Projektstart

backend/node_modules/avvio/test/lib/create-promise.test.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const { test } = require('tap')
+const { createPromise } = require('../../lib/create-promise')
+
+test('createPromise() returns an object', (t) => {
+  t.plan(3)
+  t.type(createPromise(), 'object')
+  t.equal(Array.isArray(createPromise()), false)
+  t.notOk(Array.isArray(createPromise() !== null))
+})
+
+test('createPromise() returns an attribute with attribute resolve', (t) => {
+  t.plan(1)
+  t.ok('resolve' in createPromise())
+})
+
+test('createPromise() returns an attribute with attribute reject', (t) => {
+  t.plan(1)
+  t.ok('reject' in createPromise())
+})
+
+test('createPromise() returns an attribute with attribute createPromise', (t) => {
+  t.plan(1)
+  t.ok('promise' in createPromise())
+})
+
+test('when resolve is called, createPromise attribute is resolved', (t) => {
+  t.plan(1)
+  const p = createPromise()
+
+  p.promise
+    .then(() => {
+      t.pass()
+    })
+    .catch(() => {
+      t.fail()
+    })
+  p.resolve()
+})
+
+test('when reject is called, createPromise attribute is rejected', (t) => {
+  t.plan(1)
+  const p = createPromise()
+
+  p.promise
+    .then(() => {
+      t.fail()
+    })
+    .catch(() => {
+      t.pass()
+    })
+
+  p.reject()
+})

backend/node_modules/avvio/test/lib/execute-with-thenable.test.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const { test } = require('tap')
+const { executeWithThenable } = require('../../lib/execute-with-thenable')
+const { kAvvio } = require('../../lib/symbols')
+
+test('executeWithThenable', (t) => {
+  t.plan(6)
+
+  t.test('passes the arguments to the function', (t) => {
+    t.plan(5)
+
+    executeWithThenable((...args) => {
+      t.equal(args.length, 3)
+      t.equal(args[0], 1)
+      t.equal(args[1], 2)
+      t.equal(args[2], 3)
+    }, [1, 2, 3], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('function references this to itself', (t) => {
+    t.plan(2)
+
+    const func = function () {
+      t.equal(this, func)
+    }
+    executeWithThenable(func, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('handle resolving Promise of func', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      return Promise.resolve(42)
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('handle rejecting Promise of func', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      return Promise.reject(new Error('Arbitrary Error'))
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.equal(err.message, 'Arbitrary Error')
+    })
+  })
+
+  t.test('dont handle avvio mocks PromiseLike results but use callback if provided', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      const result = Promise.resolve(42)
+      result[kAvvio] = true
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('dont handle avvio mocks Promises and if no callback is provided', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      t.pass(1)
+      const result = Promise.resolve(42)
+      result[kAvvio] = true
+    }
+
+    executeWithThenable(fn, [])
+  })
+})

backend/node_modules/avvio/test/lib/get-plugin-name.test.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('tap')
+const { getPluginName } = require('../../lib/get-plugin-name')
+const { kPluginMeta } = require('../../lib/symbols')
+
+test('getPluginName of function', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function aPlugin () { }), 'aPlugin')
+})
+
+test('getPluginName of async function', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(async function aPlugin () { }), 'aPlugin')
+})
+
+test('getPluginName of arrow function without name', (t) => {
+  t.plan(2)
+
+  t.equal(getPluginName(() => { }), '() => { }')
+  t.equal(getPluginName(() => { return 'random' }), '() => { return \'random\' }')
+})
+
+test('getPluginName of arrow function assigned to variable', (t) => {
+  t.plan(1)
+
+  const namedArrowFunction = () => { }
+  t.equal(getPluginName(namedArrowFunction), 'namedArrowFunction')
+})
+
+test("getPluginName based on Symbol 'plugin-meta' /1", (t) => {
+  t.plan(1)
+
+  function plugin () {
+
+  }
+
+  plugin[kPluginMeta] = {}
+  t.equal(getPluginName(plugin), 'plugin')
+})
+
+test("getPluginName based on Symbol 'plugin-meta' /2", (t) => {
+  t.plan(1)
+
+  function plugin () {
+
+  }
+
+  plugin[kPluginMeta] = {
+    name: 'fastify-non-existent'
+  }
+  t.equal(getPluginName(plugin), 'fastify-non-existent')
+})
+
+test('getPluginName if null is provided as options', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function a () {}, null), 'a')
+})
+
+test('getPluginName if name is provided in options', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function defaultName () {}, { name: 'providedName' }), 'providedName')
+})

backend/node_modules/avvio/test/lib/is-bundled-or-typescript-plugin.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const { isBundledOrTypescriptPlugin } = require('../../lib/is-bundled-or-typescript-plugin')
+
+test('isBundledOrTypescriptPlugin', (t) => {
+  t.plan(9)
+
+  t.equal(isBundledOrTypescriptPlugin(1), false)
+  t.equal(isBundledOrTypescriptPlugin('function'), false)
+  t.equal(isBundledOrTypescriptPlugin({}), false)
+  t.equal(isBundledOrTypescriptPlugin([]), false)
+  t.equal(isBundledOrTypescriptPlugin(null), false)
+
+  t.equal(isBundledOrTypescriptPlugin(function () {}), false)
+  t.equal(isBundledOrTypescriptPlugin(new Promise((resolve) => resolve)), false)
+  t.equal(isBundledOrTypescriptPlugin(Promise.resolve()), false)
+
+  t.equal(isBundledOrTypescriptPlugin({ default: () => {} }), true)
+})

backend/node_modules/avvio/test/lib/is-promise-like.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const { isPromiseLike } = require('../../lib/is-promise-like')
+
+test('isPromiseLike', (t) => {
+  t.plan(9)
+
+  t.equal(isPromiseLike(1), false)
+  t.equal(isPromiseLike('function'), false)
+  t.equal(isPromiseLike({}), false)
+  t.equal(isPromiseLike([]), false)
+  t.equal(isPromiseLike(null), false)
+
+  t.equal(isPromiseLike(function () {}), false)
+  t.equal(isPromiseLike(new Promise((resolve) => resolve)), true)
+  t.equal(isPromiseLike(Promise.resolve()), true)
+
+  t.equal(isPromiseLike({ then: () => {} }), true)
+})

backend/node_modules/avvio/test/lib/thenify.test.js

@@ -0,0 +1,123 @@
+'use strict'
+
+const { test, mock } = require('tap')
+const { kThenifyDoNotWrap } = require('../../lib/symbols')
+
+test('thenify', (t) => {
+  t.plan(7)
+
+  t.test('return undefined if booted', (t) => {
+    t.plan(2)
+
+    const { thenify } = mock('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify returning undefined because we are already booted') }
+      }
+    })
+    const result = thenify.call({
+      booted: true
+    })
+    t.equal(result, undefined)
+  })
+
+  t.test('return undefined if kThenifyDoNotWrap is true', (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+    const result = thenify.call({
+      [kThenifyDoNotWrap]: true
+    })
+    t.equal(result, undefined)
+  })
+
+  t.test('return PromiseConstructorLike if kThenifyDoNotWrap is false', (t) => {
+    t.plan(3)
+
+    const { thenify } = mock('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify') }
+      }
+    })
+    const promiseContructorLike = thenify.call({
+      [kThenifyDoNotWrap]: false
+    })
+
+    t.type(promiseContructorLike, 'function')
+    t.equal(promiseContructorLike.length, 2)
+  })
+
+  t.test('return PromiseConstructorLike', (t) => {
+    t.plan(3)
+
+    const { thenify } = mock('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify') }
+      }
+    })
+    const promiseContructorLike = thenify.call({})
+
+    t.type(promiseContructorLike, 'function')
+    t.equal(promiseContructorLike.length, 2)
+  })
+
+  t.test('resolve should return _server', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.resolve()
+      },
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.equal(value, 'server')
+    }, function (reason) {
+      t.error(reason)
+    })
+  })
+
+  t.test('resolving should set kThenifyDoNotWrap to true', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.resolve()
+      },
+      [kThenifyDoNotWrap]: false,
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.equal(server[kThenifyDoNotWrap], true)
+    }, function (reason) {
+      t.error(reason)
+    })
+  })
+
+  t.test('rejection should pass through to reject', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.reject(new Error('Arbitrary rejection'))
+      },
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.error(value)
+    }, function (reason) {
+      t.equal(reason.message, 'Arbitrary rejection')
+    })
+  })
+})

backend/node_modules/avvio/test/lib/time-tree.test.js

@@ -0,0 +1,391 @@
+'use strict'
+
+const { test } = require('tap')
+const { TimeTree } = require('../../lib/time-tree')
+
+test('TimeTree is constructed with a root attribute, set to null', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.root, null)
+})
+
+test('TimeTree is constructed with an empty tableId-Map', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  t.ok(tree.tableId instanceof Map)
+  t.equal(tree.tableId.size, 0)
+})
+
+test('TimeTree is constructed with an empty tableLabel-Map', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  t.ok(tree.tableLabel instanceof Map)
+  t.equal(tree.tableLabel.size, 0)
+})
+
+test('TimeTree#toJSON dumps the content of the TimeTree', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.same(tree.toJSON(), {})
+})
+
+test('TimeTree#toJSON is creating new instances of its content, ensuring being immutable', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.not(tree.toJSON(), tree.toJSON())
+})
+
+test('TimeTree#start is adding a node with correct shape, root-node', t => {
+  t.plan(15)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  const rootNode = tree.root
+
+  t.equal(Object.keys(rootNode).length, 7)
+  t.ok('parent' in rootNode)
+  t.equal(rootNode.parent, null)
+  t.ok('id' in rootNode)
+  t.type(rootNode.id, 'string')
+  t.ok('label' in rootNode)
+  t.type(rootNode.label, 'string')
+  t.ok('nodes' in rootNode)
+  t.ok(Array.isArray(rootNode.nodes))
+  t.ok('start' in rootNode)
+  t.ok(Number.isInteger(rootNode.start))
+  t.ok('stop' in rootNode)
+  t.type(rootNode.stop, 'null')
+  t.ok('diff' in rootNode)
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a node with correct shape, child-node', t => {
+  t.plan(16)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  const rootNode = tree.root
+
+  t.equal(rootNode.nodes.length, 1)
+
+  const childNode = rootNode.nodes[0]
+
+  t.equal(Object.keys(childNode).length, 7)
+  t.ok('parent' in childNode)
+  t.type(childNode.parent, 'string')
+  t.ok('id' in childNode)
+  t.type(childNode.id, 'string')
+  t.ok('label' in childNode)
+  t.type(childNode.label, 'string')
+  t.ok('nodes' in childNode)
+  t.ok(Array.isArray(childNode.nodes))
+  t.ok('start' in childNode)
+  t.ok(Number.isInteger(childNode.start))
+  t.ok('stop' in childNode)
+  t.type(childNode.stop, 'null')
+  t.ok('diff' in childNode)
+  t.type(childNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a root element when parent is null', t => {
+  t.plan(9)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  const rootNode = tree.root
+
+  t.type(rootNode, 'object')
+  t.equal(Object.keys(rootNode).length, 7)
+  t.equal(rootNode.parent, null)
+  t.equal(rootNode.id, 'root')
+  t.equal(rootNode.label, 'root')
+  t.ok(Array.isArray(rootNode.nodes))
+  t.equal(rootNode.nodes.length, 0)
+  t.ok(Number.isInteger(rootNode.start))
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a root element when parent does not exist', t => {
+  t.plan(9)
+
+  const tree = new TimeTree()
+  tree.start('invalid', 'root')
+
+  const rootNode = tree.root
+
+  t.type(rootNode, 'object')
+  t.equal(Object.keys(rootNode).length, 7)
+  t.equal(rootNode.parent, null)
+  t.equal(rootNode.id, 'root')
+  t.equal(rootNode.label, 'root')
+  t.ok(Array.isArray(rootNode.nodes))
+  t.equal(rootNode.nodes.length, 0)
+  t.ok(Number.isInteger(rootNode.start))
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start parameter start can override automatically generated start time', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root', 1337)
+
+  t.ok(tree.root.start, 1337)
+})
+
+test('TimeTree#start returns id of root, when adding a root node /1', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.start(null, 'root'), 'root')
+})
+
+test('TimeTree#start returns id of root, when adding a root node /2', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.start(null, '/'), 'root')
+})
+
+test('TimeTree#start returns id of child, when adding a child node', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.match(tree.start('root', 'child'), /^child-[0-9.]+$/)
+})
+
+test('TimeTree tracks node ids /1', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree tracks node ids /2', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('child', 'grandchild')
+
+  t.equal(tree.tableId.size, 3)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+  t.ok(tree.tableId.has(tree.root.nodes[0].nodes[0].id))
+})
+
+test('TimeTree tracks node ids /3', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableId.size, 3)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+  t.ok(tree.tableId.has(tree.root.nodes[1].id))
+})
+
+test('TimeTree tracks node labels /1', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  t.equal(tree.tableLabel.size, 3)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+  t.ok(tree.tableLabel.has('sibling'))
+})
+
+test('TimeTree tracks node labels /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})
+
+test('TimeTree#stop returns undefined', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  t.type(tree.stop('root'), 'undefined')
+})
+
+test('TimeTree#stop sets stop value of node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('root')
+  t.type(tree.root.stop, 'number')
+  t.ok(Number.isInteger(tree.root.stop))
+})
+
+test('TimeTree#stop parameter stop is used as stop value of node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('root', 1337)
+  t.type(tree.root.stop, 'number')
+  t.equal(tree.root.stop, 1337)
+})
+
+test('TimeTree#stop calculates the diff', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root', 1)
+  t.type(tree.root.diff, 'number')
+  t.equal(tree.root.diff, -1)
+  tree.stop('root', 5)
+
+  t.type(tree.root.diff, 'number')
+  t.equal(tree.root.diff, 4)
+})
+
+test('TimeTree#stop does nothing when node is not found', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('invalid')
+  t.type(tree.root.stop, 'null')
+})
+
+test('TimeTree untracks node ids /1', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+  t.equal(tree.tableId.size, 1)
+  t.ok(tree.tableId.has('root'))
+})
+
+test('TimeTree untracks node ids /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('child', 'grandchild')
+
+  tree.stop(tree.root.nodes[0].nodes[0].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree untracks node ids /3', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[1].id))
+})
+
+test('TimeTree untracks node ids /4', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[1].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree untracks node labels /1', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  tree.stop(tree.root.nodes[1].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})
+
+test('TimeTree untracks node labels /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('sibling'))
+})
+
+test('TimeTree does not untrack label if used by other node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})

backend/node_modules/avvio/test/lib/validate-plugin.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('tap')
+const { validatePlugin } = require('../../lib/validate-plugin')
+const { AVV_ERR_PLUGIN_NOT_VALID } = require('../../lib/errors')
+
+test('validatePlugin', (t) => {
+  t.plan(8)
+
+  t.throws(() => validatePlugin(1), new AVV_ERR_PLUGIN_NOT_VALID('number'))
+  t.throws(() => validatePlugin('function'), new AVV_ERR_PLUGIN_NOT_VALID('string'))
+  t.throws(() => validatePlugin({}), new AVV_ERR_PLUGIN_NOT_VALID('object'))
+  t.throws(() => validatePlugin([]), new AVV_ERR_PLUGIN_NOT_VALID('array'))
+  t.throws(() => validatePlugin(null), new AVV_ERR_PLUGIN_NOT_VALID('null'))
+
+  t.doesNotThrow(() => validatePlugin(function () {}))
+  t.doesNotThrow(() => validatePlugin(new Promise((resolve) => resolve)))
+  t.doesNotThrow(() => validatePlugin(Promise.resolve()))
+})