node-fastify 5.8.3

package/test/plugin.2.test.js

@@ -0,0 +1,314 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../fastify')
+const fp = require('fastify-plugin')
+
+test('check dependencies - should not throw', async t => {
+  t.plan(11)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    instance.register(fp((i, o, n) => {
+      i.decorate('test', () => {})
+      t.assert.ok(i.test)
+      n()
+    }))
+
+    instance.register(fp((i, o, n) => {
+      try {
+        i.decorate('otherTest', () => {}, ['test'])
+        t.assert.ok(i.test)
+        t.assert.ok(i.otherTest)
+        n()
+      } catch (e) {
+        t.assert.fail()
+      }
+    }))
+
+    instance.get('/', (req, reply) => {
+      t.assert.ok(instance.test)
+      t.assert.ok(instance.otherTest)
+      reply.send({ hello: 'world' })
+    })
+
+    done()
+  })
+
+  fastify.ready(() => {
+    t.assert.ok(!fastify.test)
+    t.assert.ok(!fastify.otherTest)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer)
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+})
+
+test('check dependencies - should throw', async t => {
+  t.plan(11)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    instance.register(fp((i, o, n) => {
+      try {
+        i.decorate('otherTest', () => {}, ['test'])
+        t.assert.fail()
+      } catch (e) {
+        t.assert.strictEqual(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
+        t.assert.strictEqual(e.message, 'The decorator is missing dependency \'test\'.')
+      }
+      n()
+    }))
+
+    instance.register(fp((i, o, n) => {
+      i.decorate('test', () => {})
+      t.assert.ok(i.test)
+      t.assert.ok(!i.otherTest)
+      n()
+    }))
+
+    instance.get('/', (req, reply) => {
+      t.assert.ok(instance.test)
+      t.assert.ok(!instance.otherTest)
+      reply.send({ hello: 'world' })
+    })
+
+    done()
+  })
+
+  fastify.ready(() => {
+    t.assert.ok(!fastify.test)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer)
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+})
+
+test('set the plugin name based on the plugin displayName symbol', (t, testDone) => {
+  t.plan(6)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(fp((fastify, opts, done) => {
+    t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A')
+    fastify.register(fp((fastify, opts, done) => {
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
+      done()
+    }, { name: 'plugin-AB' }))
+    fastify.register(fp((fastify, opts, done) => {
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      done()
+    }, { name: 'plugin-AC' }))
+    done()
+  }, { name: 'plugin-A' }))
+
+  fastify.register(fp((fastify, opts, done) => {
+    t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
+    done()
+  }, { name: 'plugin-B' }))
+
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('plugin name will change when using no encapsulation', (t, testDone) => {
+  t.plan(6)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(fp((fastify, opts, done) => {
+    // store it in a different variable will hold the correct name
+    const pluginName = fastify.pluginName
+    fastify.register(fp((fastify, opts, done) => {
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
+      done()
+    }, { name: 'plugin-AB' }))
+    fastify.register(fp((fastify, opts, done) => {
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      done()
+    }, { name: 'plugin-AC' }))
+    setImmediate(() => {
+      // normally we would expect the name plugin-A
+      // but we operate on the same instance in each plugin
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      t.assert.strictEqual(pluginName, 'fastify -> plugin-A')
+    })
+    done()
+  }, { name: 'plugin-A' }))
+
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('plugin name is undefined when accessing in no plugin context', (t, testDone) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('set the plugin name based on the plugin function name', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(function myPluginA (fastify, opts, done) {
+    t.assert.strictEqual(fastify.pluginName, 'myPluginA')
+    fastify.register(function myPluginAB (fastify, opts, done) {
+      t.assert.strictEqual(fastify.pluginName, 'myPluginAB')
+      done()
+    })
+    setImmediate(() => {
+      // exact name due to encapsulation
+      t.assert.strictEqual(fastify.pluginName, 'myPluginA')
+    })
+    done()
+  })
+
+  fastify.register(function myPluginB (fastify, opts, done) {
+    t.assert.strictEqual(fastify.pluginName, 'myPluginB')
+    done()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('approximate a plugin name when no meta data is available', (t, testDone) => {
+  t.plan(7)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register((fastify, opts, done) => {
+    // A
+    t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+    t.assert.strictEqual(fastify.pluginName.includes('// A'), true)
+    fastify.register((fastify, opts, done) => {
+      // B
+      t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+      t.assert.strictEqual(fastify.pluginName.includes('// B'), true)
+      done()
+    })
+    setImmediate(() => {
+      t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+      t.assert.strictEqual(fastify.pluginName.includes('// A'), true)
+    })
+    done()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('approximate a plugin name also when fastify-plugin has no meta data', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  // plugin name is got from current file name
+  const pluginName = /plugin\.2\.test/
+  const pluginNameWithFunction = /plugin\.2\.test-auto-\d+ -> B/
+
+  fastify.register(fp((fastify, opts, done) => {
+    t.assert.match(fastify.pluginName, pluginName)
+    fastify.register(fp(function B (fastify, opts, done) {
+      // function has name
+      t.assert.match(fastify.pluginName, pluginNameWithFunction)
+      done()
+    }))
+    setImmediate(() => {
+      t.assert.match(fastify.pluginName, pluginNameWithFunction)
+    })
+    done()
+  }))
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    testDone()
+  })
+})
+
+test('plugin encapsulation', async t => {
+  t.plan(9)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register((instance, opts, done) => {
+    instance.register(fp((i, o, n) => {
+      i.decorate('test', 'first')
+      n()
+    }))
+
+    instance.get('/first', (req, reply) => {
+      reply.send({ plugin: instance.test })
+    })
+
+    done()
+  })
+
+  fastify.register((instance, opts, done) => {
+    instance.register(fp((i, o, n) => {
+      i.decorate('test', 'second')
+      n()
+    }))
+
+    instance.get('/second', (req, reply) => {
+      reply.send({ plugin: instance.test })
+    })
+
+    done()
+  })
+
+  fastify.ready(() => {
+    t.assert.ok(!fastify.test)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result1 = await fetch(fastifyServer + '/first')
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.text()
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { plugin: 'first' })
+
+  const result2 = await fetch(fastifyServer + '/second')
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  const body2 = await result2.text()
+  t.assert.strictEqual(result2.headers.get('content-length'), '' + body2.length)
+  t.assert.deepStrictEqual(JSON.parse(body2), { plugin: 'second' })
+})

package/test/plugin.3.test.js

@@ -0,0 +1,287 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../fastify')
+const fp = require('fastify-plugin')
+
+test('if a plugin raises an error and there is not a callback to handle it, the server must not start', (t, testDone) => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    done(new Error('err'))
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ok(err instanceof Error)
+    t.assert.strictEqual(err.message, 'err')
+    testDone()
+  })
+})
+
+test('add hooks after route declaration', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  function plugin (instance, opts, done) {
+    instance.decorateRequest('check', null)
+    instance.addHook('onRequest', (req, reply, done) => {
+      req.check = {}
+      done()
+    })
+    setImmediate(done)
+  }
+  fastify.register(fp(plugin))
+
+  fastify.register((instance, options, done) => {
+    instance.addHook('preHandler', function b (req, res, done) {
+      req.check.hook2 = true
+      done()
+    })
+
+    instance.get('/', (req, reply) => {
+      reply.send(req.check)
+    })
+
+    instance.addHook('preHandler', function c (req, res, done) {
+      req.check.hook3 = true
+      done()
+    })
+
+    done()
+  })
+
+  fastify.addHook('preHandler', function a (req, res, done) {
+    req.check.hook1 = true
+    done()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+  t.assert.ok(result.ok)
+  t.assert.deepStrictEqual(await result.json(), { hook1: true, hook2: true, hook3: true })
+})
+
+test('nested plugins', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  t.after(() => fastify.close())
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.register((fastify, opts, done) => {
+      fastify.get('/', function (req, reply) {
+        reply.send('I am child 1')
+      })
+      done()
+    }, { prefix: '/child1' })
+
+    fastify.register((fastify, opts, done) => {
+      fastify.get('/', function (req, reply) {
+        reply.send('I am child 2')
+      })
+      done()
+    }, { prefix: '/child2' })
+
+    done()
+  }, { prefix: '/parent' })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result1 = await fetch(fastifyServer + '/parent/child1')
+  t.assert.ok(result1.ok)
+  t.assert.deepStrictEqual(await result1.text(), 'I am child 1')
+
+  const result2 = await fetch(fastifyServer + '/parent/child2')
+  t.assert.ok(result2.ok)
+  t.assert.deepStrictEqual(await result2.text(), 'I am child 2')
+})
+
+test('nested plugins awaited', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  t.after(() => fastify.close())
+
+  fastify.register(async function wrap (fastify, opts) {
+    await fastify.register(async function child1 (fastify, opts) {
+      fastify.get('/', function (req, reply) {
+        reply.send('I am child 1')
+      })
+    }, { prefix: '/child1' })
+
+    await fastify.register(async function child2 (fastify, opts) {
+      fastify.get('/', function (req, reply) {
+        reply.send('I am child 2')
+      })
+    }, { prefix: '/child2' })
+  }, { prefix: '/parent' })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result1 = await fetch(fastifyServer + '/parent/child1')
+  t.assert.ok(result1.ok)
+  t.assert.deepStrictEqual(await result1.text(), 'I am child 1')
+
+  const result2 = await fetch(fastifyServer + '/parent/child2')
+  t.assert.ok(result2.ok)
+  t.assert.deepStrictEqual(await result2.text(), 'I am child 2')
+})
+
+test('plugin metadata - decorators', (t, testDone) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorate('plugin1', true)
+  fastify.decorateReply('plugin1', true)
+  fastify.decorateRequest('plugin1', true)
+
+  plugin[Symbol.for('skip-override')] = true
+  plugin[Symbol.for('plugin-meta')] = {
+    decorators: {
+      fastify: ['plugin1'],
+      reply: ['plugin1'],
+      request: ['plugin1']
+    }
+  }
+
+  fastify.register(plugin)
+
+  fastify.ready(() => {
+    t.assert.ok(fastify.plugin)
+    testDone()
+  })
+
+  function plugin (instance, opts, done) {
+    instance.decorate('plugin', true)
+    done()
+  }
+})
+
+test('plugin metadata - decorators - should throw', (t, testDone) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorate('plugin1', true)
+  fastify.decorateReply('plugin1', true)
+
+  plugin[Symbol.for('skip-override')] = true
+  plugin[Symbol.for('plugin-meta')] = {
+    decorators: {
+      fastify: ['plugin1'],
+      reply: ['plugin1'],
+      request: ['plugin1']
+    }
+  }
+
+  fastify.register(plugin)
+  fastify.ready((err) => {
+    t.assert.strictEqual(err.message, "The decorator 'plugin1' is not present in Request")
+    testDone()
+  })
+
+  function plugin (instance, opts, done) {
+    instance.decorate('plugin', true)
+    done()
+  }
+})
+
+test('plugin metadata - decorators - should throw with plugin name', (t, testDone) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorate('plugin1', true)
+  fastify.decorateReply('plugin1', true)
+
+  plugin[Symbol.for('skip-override')] = true
+  plugin[Symbol.for('plugin-meta')] = {
+    name: 'the-plugin',
+    decorators: {
+      fastify: ['plugin1'],
+      reply: ['plugin1'],
+      request: ['plugin1']
+    }
+  }
+
+  fastify.register(plugin)
+  fastify.ready((err) => {
+    t.assert.strictEqual(err.message, "The decorator 'plugin1' required by 'the-plugin' is not present in Request")
+    testDone()
+  })
+
+  function plugin (instance, opts, done) {
+    instance.decorate('plugin', true)
+    done()
+  }
+})
+
+test('plugin metadata - dependencies', (t, testDone) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  dependency[Symbol.for('skip-override')] = true
+  dependency[Symbol.for('plugin-meta')] = {
+    name: 'plugin'
+  }
+
+  plugin[Symbol.for('skip-override')] = true
+  plugin[Symbol.for('plugin-meta')] = {
+    dependencies: ['plugin']
+  }
+
+  fastify.register(dependency)
+  fastify.register(plugin)
+
+  fastify.ready(() => {
+    t.assert.ok('everything right')
+    testDone()
+  })
+
+  function dependency (instance, opts, done) {
+    done()
+  }
+
+  function plugin (instance, opts, done) {
+    done()
+  }
+})
+
+test('plugin metadata - dependencies (nested)', (t, testDone) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  dependency[Symbol.for('skip-override')] = true
+  dependency[Symbol.for('plugin-meta')] = {
+    name: 'plugin'
+  }
+
+  nested[Symbol.for('skip-override')] = true
+  nested[Symbol.for('plugin-meta')] = {
+    dependencies: ['plugin']
+  }
+
+  fastify.register(dependency)
+  fastify.register(plugin)
+
+  fastify.ready(() => {
+    t.assert.ok('everything right')
+    testDone()
+  })
+
+  function dependency (instance, opts, done) {
+    done()
+  }
+
+  function plugin (instance, opts, done) {
+    instance.register(nested)
+    done()
+  }
+
+  function nested (instance, opts, done) {
+    done()
+  }
+})