refactor: split test by types

packages/api/tests/buffered.response.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest'
+import { NextApiRequestBuilder, ResponseMock } from '../src'
+import BufferedEndpoint from './fixture/BufferedEndpoint'
+
+describe('buffered endpoint', () => {
+    it('should handle buffered response as JSON', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock<{ name: string }>()
+
+        BufferedEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getHeader('Content-Type')).toEqual(
+            'application/octet-stream'
+        )
+        expect(res.getBodyJson()).toStrictEqual({
+            a: 'b',
+            c: 'd',
+        })
+    })
+
+    it('should handle buffered response as string', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock<{ name: string }>()
+
+        BufferedEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getHeader('Content-Type')).toEqual(
+            'application/octet-stream'
+        )
+        expect(res.getBodyString()).toStrictEqual(
+            JSON.stringify({
+                a: 'b',
+                c: 'd',
+            })
+        )
+    })
+
+    it('should handle buffered response as raw Buffer', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock<{ name: string }>()
+
+        BufferedEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getHeader('Content-Type')).toEqual(
+            'application/octet-stream'
+        )
+        expect(res.getBodyBuffer()).toStrictEqual(
+            Buffer.from(
+                JSON.stringify({
+                    a: 'b',
+                    c: 'd',
+                })
+            )
+        )
+    })
+})

packages/api/tests/echo.response.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import { NextApiRequestBuilder, ResponseMock } from '../src'
+import EchoEndpoint from './fixture/EchoEndpoint'
+
+describe('echo endpoint', () => {
+    it('should read parameters in the request query and url', () => {
+        const req = new NextApiRequestBuilder()
+            .setMethod('GET')
+            .setQuery({
+                foo: 'hello',
+            })
+            .setUrl('http://localhost/api/hello/echo')
+            .build()
+        const res = ResponseMock()
+
+        EchoEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getBodyJson()).toStrictEqual({
+            foo: 'hello',
+            url: 'http://localhost/api/hello/echo',
+        })
+    })
+})

packages/api/tests/empty.response.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest'
+import { NextApiRequestBuilder, ResponseMock } from '../src'
+import EmptyEndpoint from './fixture/EmptyEndpoint'
+
+describe('empty endpoint', () => {
+    it('should accept empty response with no body', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock()
+
+        EmptyEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(204)
+        expect(res.getBodyBuffer()).toEqual(Buffer.alloc(0))
+    })
+})

packages/api/tests/forward.response.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+    NextApiRequestBuilder,
+    NextApiResponseMock,
+    ResponseMock,
+} from '../src'
+import { NextApiRequest } from 'next'
+import ForwardEndpoint from './fixture/ForwardEndpoint'
+
+describe('forward endpoint', () => {
+    let req: NextApiRequest, res: NextApiResponseMock<any>
+
+    beforeEach(() => {
+        req = new NextApiRequestBuilder()
+            .setMethod('POST')
+            .setCookies({ myCookie: 'value' })
+            .setHeaders({
+                authorization: 'panda',
+            })
+            .setBody({ all: true })
+            .build()
+        res = ResponseMock()
+    })
+
+    it('should forward req as response', () => {
+        ForwardEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getHeader('authorization')).toEqual('panda')
+        expect(res.getBodyJson()).toStrictEqual({
+            body: {
+                all: true,
+            },
+            cookies: {
+                myCookie: 'value',
+            },
+            method: 'POST',
+        })
+        expect(res.getBodyBuffer()).toStrictEqual(
+            Buffer.from(
+                JSON.stringify({
+                    body: {
+                        all: true,
+                    },
+                    method: 'POST',
+                    cookies: {
+                        myCookie: 'value',
+                    },
+                })
+            )
+        )
+    })
+
+    it('should forward req as response buffer', () => {
+        ForwardEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getBodyBuffer()).toStrictEqual(
+            Buffer.from(
+                JSON.stringify({
+                    body: {
+                        all: true,
+                    },
+                    method: 'POST',
+                    cookies: {
+                        myCookie: 'value',
+                    },
+                })
+            )
+        )
+    })
+
+    it('should forward req as response text', () => {
+        ForwardEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getBodyString()).toStrictEqual(
+            JSON.stringify({
+                body: {
+                    all: true,
+                },
+                method: 'POST',
+                cookies: {
+                    myCookie: 'value',
+                },
+            })
+        )
+    })
+})

packages/api/tests/json.response.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest'
+import { NextApiRequestBuilder, ResponseMock } from '../src'
+import JSONEndpoint from './fixture/JSONEndpoint'
+
+describe('json response', () => {
+    it('should be able to parse simple JSON', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock<{ name: string }>()
+
+        JSONEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(200)
+        expect(res.getBodyJson()).toStrictEqual({ name: 'John Doe' })
+    })
+})

packages/api/tests/redirect.response.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest'
+import { NextApiRequestBuilder, ResponseMock } from '../src'
+import RedirectEndpoint from './fixture/RedirectEndpoint'
+
+describe('redirect endpoint', () => {
+    it('should redirect response', () => {
+        const req = new NextApiRequestBuilder().build()
+        const res = ResponseMock()
+
+        RedirectEndpoint(req, res)
+
+        expect(res.getStatusCode()).toEqual(307)
+
+        expect(res.isRedirect()).toEqual(true)
+        expect(res.redirectLocation()).toEqual('/path/home')
+    })
+})