Fastify

https://www.fastify.io/docs/latest/
Admin
Fastify is a fast, low-overhead web framework for Node.js that enables building efficient HTTP...
Tokens:2,711
Snippets:24
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Test Fastify with a Running Server using Undici

Source: https://www.fastify.io/docs/latest/Guides/Testing

Tests a Fastify application by starting the server and making requests using the undici HTTP client. Remember to close both the Fastify server and the client after tests.

```javascript
const { test } = require('node:test')
const { Client } = require('undici')
const buildFastify = require('./app')

test('should work with undici', async t => {
  t.plan(2)

  const fastify = buildFastify()

  await fastify.listen()

   const client = new Client(
    'http://localhost:' + fastify.server.address().port, {
      keepAliveTimeout: 10,
      keepAliveMaxTimeout: 10
    }
  )

  t.after(() => {
    fastify.close()
    client.close()
  })

  const response = await client.request({ method: 'GET', path: '/' })

  t.assert.strictEqual(await response.body.text(), '{"hello":"world"}')
  t.assert.strictEqual(response.statusCode, 200)
})
```

--------------------------------

### Test Fastify with a Running Server using Fetch

Source: https://www.fastify.io/docs/latest/Guides/Testing

Tests a Fastify application using the built-in fetch API after starting the server. Ensure the server is closed after the test completes.

```javascript
const { test } = require('node:test')
const buildFastify = require('./app')

test('should work with fetch', async t => {
  t.plan(3)

  const fastify = buildFastify()

  t.after(() => fastify.close())

  await fastify.listen()

  const response = await fetch(
    'http://localhost:' + fastify.server.address().port
  )

  t.assert.strictEqual(response.status, 200)
  t.assert.strictEqual(
    response.headers.get('content-type'),
    'application/json; charset=utf-8'
  )
  const jsonResult = await response.json()
  t.assert.strictEqual(jsonResult.hello, 'world')
})
```

--------------------------------

### Initialize Server

Source: https://www.fastify.io/docs/latest/Guides/Testing

Entry point for the application using the exported build function.

```javascript
'use strict'  
  
  

const server = require('./app')({  

  logger: {  

    level: 'info',  

    transport: {  

      target: 'pino-pretty'  

    }  

  }  

})  

  

server.listen({ port: 3000 }, (err, address) => {  

  if (err) {  

    server.log.error(err)  

    process.exit(1)  

  }  

})
```

--------------------------------

### Create a Basic Fastify Plugin

Source: https://www.fastify.io/docs/latest/Guides/Testing

Defines a plugin that uses fastify.decorate and fastify.decorateRequest to extend the Fastify instance and request objects.

```javascript

const fP = require("fastify-plugin")  

  

async function myPlugin(fastify, options) {  

    fastify.decorateRequest("helloRequest", "Hello World")  

    fastify.decorate("helloInstance", "Hello Fastify Instance")  

}  

  

module.exports = fP(myPlugin)  


```

--------------------------------

### Test Fastify with Ready State using SuperTest

Source: https://www.fastify.io/docs/latest/Guides/Testing

Tests a Fastify application after it has been initialized with `fastify.ready()`, using the SuperTest library for making HTTP requests. Remember to close the Fastify instance.

```javascript
const { test } = require('node:test')
const supertest = require('supertest')
const buildFastify = require('./app')

test('GET `/` route', async (t) => {
  const fastify = buildFastify()

  t.after(() => fastify.close())

  await fastify.ready()

  const response = await supertest(fastify.server)
    .get('/')
    .expect(200)
    .expect('Content-Type', 'application/json; charset=utf-8')
  t.assert.deepStrictEqual(response.body, { hello: 'world' })
})
```

--------------------------------

### Test a Fastify Plugin with fastify.inject

Source: https://www.fastify.io/docs/latest/Guides/Testing

Demonstrates testing a plugin by creating a mock Fastify application and using fastify.inject to simulate HTTP requests.

```javascript

const Fastify = require("fastify");  
const { test } = require("node:test");  
const myPlugin = require("../plugin/myFirstPlugin");  

  

test("Test the Plugin Route", async t => {  

    // Create a mock fastify application to test the plugin  

    const fastify = Fastify()  

  

    fastify.register(myPlugin)  

  

    // Add an endpoint of your choice  

    fastify.get("/", async (request, reply) => {  

        return ({ message: request.helloRequest })  

    })  

  

    // Use fastify.inject to fake a HTTP Request  

    const fastifyResponse = await fastify.inject({  

        method: "GET",  

        url: "/"  

    })  

  

  console.log('status code: ', fastifyResponse.statusCode)  

  console.log('body: ', fastifyResponse.body)  

})  


```

--------------------------------

### Run Tests with Node.js CLI Flags

Source: https://www.fastify.io/docs/latest/Guides/Testing

Execute tests using the `node --test` command. Use `--test-only` to run tests marked with `{only: true}` and `--inspect-brk` to enable debugging.

```bash
> node --test --test-only --inspect-brk test/<test-file.test.js>
```

--------------------------------

### Async/Await Injection

Source: https://www.fastify.io/docs/latest/Guides/Testing

Using async/await syntax for cleaner test code.

```javascript
try {  

  const res = await fastify.inject({ method: String, url: String, payload: Object, headers: Object })  

  // your tests  

} catch (err) {  

  // handle error  

}
```

--------------------------------

### Build and Test Fastify App with Injection

Source: https://www.fastify.io/docs/latest/Guides/Testing

Defines a Fastify application and tests its root route by directly injecting requests. Ensure to close the Fastify instance after tests.

```javascript
const Fastify = require('fastify')

function buildFastify () {
  const fastify = Fastify()

  fastify.get('/', function (request, reply) {
    reply.send({ hello: 'world' })
  })

  return fastify
}

module.exports = buildFastify
```

```javascript
const { test } = require('node:test')
const buildFastify = require('./app')

test('GET `/` route', t => {
  t.plan(4)

  const fastify = buildFastify()

  // At the end of your tests it is highly recommended to call `.close()`
  // to ensure that all connections to external services get closed.
  t.after(() => fastify.close())

  fastify.inject({
    method: 'GET',
    url: '/'
  }, (err, response) => {
    t.assert.ifError(err)
    t.assert.strictEqual(response.statusCode, 200)
    t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
    t.assert.deepStrictEqual(response.json(), { hello: 'world' })
  })
})
```

--------------------------------

### Expected Test Output

Source: https://www.fastify.io/docs/latest/Guides/Testing

The console output resulting from running the initial test file.

```text

status code:  200  

body:  {"message":"Hello World"}  


```

--------------------------------

### Perform Manual Injection Test

Source: https://www.fastify.io/docs/latest/Guides/Testing

Demonstrates using .inject() to manually verify route responses.

```javascript
'use strict'  
  
  

const build = require('./app')  

  

const test = async () => {  

  const app = build()  

  

  const response = await app.inject({  

    method: 'GET',  

    url: '/'  

  })  

  

  console.log('status code: ', response.statusCode)  

  console.log('body: ', response.body)  

}  

test()
```

--------------------------------

### Define Application Factory

Source: https://www.fastify.io/docs/latest/Guides/Testing

Encapsulate the Fastify instance in a build function to facilitate testing and modularity.

```javascript
'use strict'  
  
  

const fastify = require('fastify')  
  
  

function build(opts={}) {  

  const app = fastify(opts)  

  app.get('/', async function (request, reply) {  

    return { hello: 'world' }  

  })  

  

  return app  

}  

  

module.exports = build
```

--------------------------------

### Test with Node Test Runner

Source: https://www.fastify.io/docs/latest/Guides/Testing

Standard test implementation using the Node.js test runner and Fastify injection.

```javascript
'use strict'  
  
  

const { test } = require('node:test')  

const build = require('./app')  

  

test('requests the "/" route', async t => {  

  t.plan(1)  

  const app = build()  

  

  const response = await app.inject({  

    method: 'GET',  

    url: '/'  

  })  

  t.assert.strictEqual(response.statusCode, 200, 'returns a status code of 200')  

})
```

--------------------------------

### Injection Output

Source: https://www.fastify.io/docs/latest/Guides/Testing

Expected output from the manual injection test.

```text
status code:  200  

body:  {"hello":"world"}
```

--------------------------------

### Promisified Injection

Source: https://www.fastify.io/docs/latest/Guides/Testing

Using promises to handle injection results.

```javascript
fastify  

  .inject({  

    method: String,  

    url: String,  

    query: Object,  

    payload: Object,  

    headers: Object,  

    cookies: Object  

  })  

  .then(response => {  

    // your tests  

  })  

  .catch(err => {  

    // handle error  

  })
```

--------------------------------

### Chained Injection

Source: https://www.fastify.io/docs/latest/Guides/Testing

Fluent API usage for building requests with .inject().

```javascript
fastify  

  .inject()  

  .get('/')  

  .headers({ foo: 'bar' })  

  .query({ foo: 'bar' })  

  .end((err, res) => { // the .end call will trigger the request  

    console.log(res.payload)  

  })
```

--------------------------------

### Test Plugin with Assertions

Source: https://www.fastify.io/docs/latest/Guides/Testing

Uses t.assert to validate the status code and response body of the plugin route.

```javascript

const Fastify = require("fastify");  
const { test } = require("node:test");  
const myPlugin = require("../plugin/myFirstPlugin");  

  

test("Test the Plugin Route", async t => {  

    // Specifies the number of test  

    t.plan(2)  

  

    const fastify = Fastify()  

  

    fastify.register(myPlugin)  

  

    fastify.get("/", async (request, reply) => {  

        return ({ message: request.helloRequest })  

    })  

  

    const fastifyResponse = await fastify.inject({  

        method: "GET",  

        url: "/"  

    })  

  

    t.assert.strictEqual(fastifyResponse.statusCode, 200)  

    t.assert.deepStrictEqual(JSON.parse(fastifyResponse.body), { message: "Hello World" })  

})  


```

--------------------------------

### Injection Method Signature

Source: https://www.fastify.io/docs/latest/Guides/Testing

Standard callback-based signature for the inject method.

```javascript
fastify.inject({  

  method: String,  

  url: String,  

  query: Object,  

  payload: Object,  

  headers: Object,  

  cookies: Object  

}, (error, response) => {  

  // your tests  

})
```

--------------------------------

### Test Decorators with Assertions

Source: https://www.fastify.io/docs/latest/Guides/Testing

Validates that decorators are correctly applied to the request and Fastify instance.

```javascript

const Fastify = require("fastify");  
const { test }= require("node:test");  
const myPlugin = require("../plugin/myFirstPlugin");  

  

test("Test the Plugin Route", async t => {  

    t.plan(5)  

    const fastify = Fastify()  

  

    fastify.register(myPlugin)  

  

    fastify.get("/", async (request, reply) => {  

        // Testing the fastify decorators  

        t.assert.ifError(request.helloRequest)  

        t.assert.ok(request.helloRequest, "Hello World")  

        t.assert.ok(fastify.helloInstance, "Hello Fastify Instance")  

        return ({ message: request.helloRequest })  

    })  

  

    const fastifyResponse = await fastify.inject({  

        method: "GET",  

        url: "/"  

    })  

    t.assert.strictEqual(fastifyResponse.statusCode, 200)  

    t.assert.deepStrictEqual(JSON.parse(fastifyResponse.body), { message: "Hello World" })  

})  


```

--------------------------------

### Isolate Tests with {only: true}

Source: https://www.fastify.io/docs/latest/Guides/Testing

Use the `{only: true}` option within a test to run only that specific test, aiding in isolation during development.

```javascript
test('should ...', {only: true}, t => ...)
```
Tokens:
Raw