├── .eslintignore ├── .eslintrc.js ├── .github └── workflows │ ├── build-test.yml │ └── publish-release.yml ├── .gitignore ├── .prettierrc.js ├── .snyk ├── LICENSE ├── README.md ├── index.ts ├── jest.config.js ├── package.json ├── src ├── index.ts ├── request │ ├── index.ts │ └── request.ts ├── response │ ├── index.ts │ └── response.ts └── test │ ├── helpers │ ├── provided.ts │ └── response.ts │ ├── request │ ├── defaults │ │ ├── defaults.event.EventEmitter.test.ts │ │ ├── defaults.express.test.ts │ │ ├── defaults.http.IncomingMessage.test.ts │ │ └── defaults.stream.Readable.test.ts │ ├── github.test.ts │ ├── provided │ │ ├── provided.event.EventEmitter.test.ts │ │ ├── provided.express.test.ts │ │ ├── provided.http.IncomingMessage.test.ts │ │ ├── provided.stream.Readable.test.ts │ │ └── provided.test.ts │ └── request.test.ts │ └── response │ ├── defaults │ ├── defaults.event.EventEmitter.test.ts │ ├── defaults.express.test.ts │ ├── defaults.http.OutgoingMessage.test.ts │ ├── defaults.http.ServerResponse.test.ts │ └── defaults.stream.Writable.test.ts │ ├── github.test.ts │ ├── provided │ ├── provided.event.EventEmitter.test.ts │ ├── provided.express.test.ts │ ├── provided.http.OutgoingMessage.test.ts │ ├── provided.http.ServerResponse.test.ts │ ├── provided.stream.Writable.test.ts │ └── provided.test.ts │ └── response.test.ts ├── tsconfig.json └── yarn.lock /.eslintignore: -------------------------------------------------------------------------------- 1 | /dist -------------------------------------------------------------------------------- /.eslintrc.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | parser: '@typescript-eslint/parser', // Specifies the ESLint parser 3 | extends: [ 4 | 'prettier', 5 | 'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin 6 | 'plugin:prettier/recommended', // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array. 7 | ], 8 | parserOptions: { 9 | ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features 10 | sourceType: 'module', // Allows for the use of imports 11 | }, 12 | } 13 | -------------------------------------------------------------------------------- /.github/workflows/build-test.yml: -------------------------------------------------------------------------------- 1 | name: Build and Test 2 | 3 | on: 4 | push: 5 | branches: [master] 6 | pull_request: 7 | branches: [master] 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | strategy: 13 | matrix: 14 | node-version: [18.x, 20.x, 21.x, 22.x] 15 | steps: 16 | - name: Checkout 17 | uses: actions/checkout@v4 18 | 19 | - name: Setup Node.js v${{ matrix.node-version }} 20 | uses: actions/setup-node@v4 21 | with: 22 | node-version: ${{ matrix.node-version }} 23 | - run: yarn 24 | - run: yarn ci 25 | 26 | - name: Test Coverage 27 | uses: coverallsapp/github-action@master 28 | with: 29 | github-token: ${{ secrets.GITHUB_TOKEN }} 30 | -------------------------------------------------------------------------------- /.github/workflows/publish-release.yml: -------------------------------------------------------------------------------- 1 | name: Publish Release 2 | 3 | on: 4 | release: 5 | types: [created] 6 | 7 | jobs: 8 | build: 9 | runs-on: ubuntu-latest 10 | steps: 11 | - uses: actions/checkout@v4 12 | - uses: actions/setup-node@v4 13 | with: 14 | node-version: 22 15 | check-latest: true 16 | - run: yarn 17 | - run: yarn test-verbose 18 | 19 | publish-npm: 20 | needs: build 21 | runs-on: ubuntu-latest 22 | steps: 23 | - uses: actions/checkout@v4 24 | - uses: actions/setup-node@v4 25 | with: 26 | node-version: 22 27 | check-latest: true 28 | registry-url: https://registry.npmjs.org 29 | - run: yarn 30 | - run: npm publish --access public 31 | env: 32 | NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} 33 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # dependencies 2 | /node_modules 3 | 4 | # testing 5 | /coverage 6 | 7 | # production 8 | /dist 9 | 10 | # misc 11 | .DS_Store 12 | .env.local 13 | .env.development.local 14 | .env.test.local 15 | .env.production.local 16 | 17 | npm-debug.log* 18 | yarn-debug.log* 19 | yarn-error.log* 20 | -------------------------------------------------------------------------------- /.prettierrc.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | semi: false, 3 | trailingComma: 'all', 4 | singleQuote: true, 5 | jsxSingleQuote: true, 6 | printWidth: 120, 7 | tabWidth: 2, 8 | tabs: false, 9 | arrowParens: 'always', // Needed for the type in Typescript 10 | bracketSpacing: true, 11 | bracketSameLine: true, 12 | } 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 bikk.uk 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # @jest-mock/express 2 | 3 | A lightweight Jest mock for unit testing Express 4 | 5 | [![Build and Test](https://github.com/bikk-uk/jest-mock-express/actions/workflows/build-test.yml/badge.svg?branch=master)](https://github.com/bikk-uk/jest-mock-express/actions/workflows/build-test.yml) 6 | [![Coverage Status](https://coveralls.io/repos/github/bikk-uk/jest-mock-express/badge.svg?branch=master)](https://coveralls.io/github/bikk-uk/jest-mock-express?branch=master) 7 | [![Known Vulnerabilities](https://snyk.io/test/github/bikk-uk/jest-mock-express/badge.svg?targetFile=package.json)](https://snyk.io/test/github/bikk-uk/jest-mock-express?targetFile=package.json) 8 | ![GitHub package.json version](https://img.shields.io/github/package-json/v/bikk-uk/jest-mock-express?label=github) 9 | ![npm](https://img.shields.io/npm/v/@jest-mock/express) 10 | ![NPM](https://img.shields.io/npm/l/@jest-mock/express) 11 | 12 | ## Getting Started 13 | 14 | Installation: 15 | 16 | `yarn add --dev @jest-mock/express` 17 | 18 | `npm install --save-dev @jest-mock/express` 19 | 20 | Importing: 21 | 22 | ```typescript 23 | import { getMockReq, getMockRes } from '@jest-mock/express' 24 | ``` 25 | 26 | ## Usage 27 | 28 | ### Request - `getMockReq` 29 | 30 | `getMockReq` is intended to mock the `req` object as quickly as possible. In its simplest form, you can call it with no arguments to return a standard `req` object with mocked functions and default values for properties. 31 | 32 | ```typescript 33 | const req = getMockReq() 34 | ``` 35 | 36 | To create a mock `req` with provided values, you can pass them to the function in any order, with all being optional. The advantage of this is that it ensures the other properties are not `undefined`. Loose type definitions for standard properties are provided, custom properties (`[key: string]: any`) will be passed through to the returned `req` object. 37 | 38 | ```typescript 39 | // an example GET request to retrieve an entity 40 | const req = getMockReq({ params: { id: '123' } }) 41 | ``` 42 | 43 | ```typescript 44 | // an example PUT request to update a person 45 | const req = getMockReq({ 46 | params: { id: 564 }, 47 | body: { firstname: 'James', lastname: 'Smith', age: 34 }, 48 | }) 49 | ``` 50 | 51 | For use with extended Requests, `getMockReq` supports generics. 52 | 53 | ```typescript 54 | interface AuthenticatedRequest extends Request { 55 | user: User 56 | } 57 | 58 | const req = getMockReq({ user: mockUser }) 59 | 60 | // req.user is typed 61 | expect(req.user).toBe(mockUser) 62 | ``` 63 | 64 | ### Response - `getMockRes` 65 | 66 | `getMockRes` will return a mocked `res` object with Jest mock functions. Chaining has been implemented for the applicable functions. 67 | 68 | ```typescript 69 | const { res, next, clearMockRes } = getMockRes() 70 | ``` 71 | 72 | All of the returned mock functions can be cleared with a single call to `mockClear`. An alias is also provided called `clearMockRes`. 73 | 74 | ```typescript 75 | const { res, next, mockClear } = getMockRes() 76 | 77 | beforeEach(() => { 78 | mockClear() // can also use clearMockRes() 79 | }) 80 | ``` 81 | 82 | It will also return a mock `next` function for convenience. `next` will also be cleared as part of the call to `mockClear`/`clearMockRes`. 83 | 84 | To create mock responses with provided values, you can provide them to the function in any order, with all being optional. Loose type definitions for standard properties are provided, custom properties (`[key: string]: any`) will be passed through to the returned `res` object. 85 | 86 | ```typescript 87 | const { res, next, clearMockRes } = getMockRes({ 88 | locals: { 89 | user: getLoggedInUser(), 90 | }, 91 | }) 92 | ``` 93 | 94 | For use with extended Responses, `getMockRes` supports generics. 95 | 96 | ```typescript 97 | interface CustomResponse extends Response { 98 | locals: { 99 | sessionId?: string 100 | isPremiumUser?: boolean 101 | } 102 | } 103 | 104 | const { res } = getMockRes({ 105 | locals: { 106 | sessionId: 'abcdef', 107 | isPremiumUser: false, 108 | }, 109 | }) 110 | 111 | // res.locals is typed 112 | expect(res.locals.sessionId).toBe('abcdef') 113 | expect(res.locals.isPremiumUser).toBe(false) 114 | ``` 115 | 116 | ## Example 117 | 118 | A full example to test a controller could be: 119 | 120 | ```typescript 121 | // generate a mocked response and next function, with provided values 122 | const { res, next } = getMockRes({ 123 | locals: { 124 | isPremiumUser: true, 125 | }, 126 | }) 127 | 128 | test('will respond with the entity from the service', async () => { 129 | // generate a mock request with params 130 | const req = getMockReq({ params: { id: 'abc-def' } }) 131 | 132 | // provide the mock req, res, and next to assert 133 | await myController.getEntity(req, res, next) 134 | 135 | expect(res.json).toHaveBeenCalledWith( 136 | expect.objectContaining({ 137 | id: 'abc-def', 138 | }), 139 | ) 140 | expect(next).toBeCalled() 141 | }) 142 | ``` 143 | -------------------------------------------------------------------------------- /index.ts: -------------------------------------------------------------------------------- 1 | import getMockReq from './src/request/request' 2 | import getMockRes from './src/response/response' 3 | 4 | export { getMockReq, getMockRes } 5 | -------------------------------------------------------------------------------- /jest.config.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | preset: 'ts-jest', 3 | testEnvironment: 'node', 4 | coveragePathIgnorePatterns: ['/dist'], 5 | } 6 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "@jest-mock/express", 3 | "version": "3.0.0", 4 | "description": "A lightweight Jest mock for unit testing Express", 5 | "main": "dist/index.js", 6 | "types": "dist/index.d.ts", 7 | "scripts": { 8 | "test": "jest --coverage", 9 | "test-verbose": "jest --coverage --verbose", 10 | "test-watch": "jest \"/*.ts\" --watchAll", 11 | "test-watch-all": "jest --watchAll", 12 | "lint": "tsc --noEmit && eslint '*/**/*.{js,ts}' --quiet --fix", 13 | "build": "tsc", 14 | "clean": "rm -rf dist/*", 15 | "prepublishOnly": "yarn && yarn clean && yarn build", 16 | "release": "yarn prepublishOnly && yarn lint && yarn test", 17 | "ci": "yarn release --verbose", 18 | "snyk-protect": "snyk-protect", 19 | "prepare": "yarn run snyk-protect" 20 | }, 21 | "repository": { 22 | "type": "git", 23 | "url": "https://github.com/bikk-uk/jest-mock-express.git" 24 | }, 25 | "keywords": [ 26 | "test", 27 | "testing", 28 | "mock", 29 | "mocking", 30 | "jest", 31 | "express", 32 | "expressjs", 33 | "controller", 34 | "ts", 35 | "typescript" 36 | ], 37 | "author": "bikk-uk", 38 | "license": "MIT", 39 | "bugs": { 40 | "url": "https://github.com/bikk-uk/jest-mock-express/issues" 41 | }, 42 | "homepage": "https://github.com/bikk-uk/jest-mock-express#readme", 43 | "devDependencies": { 44 | "@snyk/protect": "^1.1291.1", 45 | "@types/jest": "^29.5.12", 46 | "@typescript-eslint/eslint-plugin": "^5.59.9", 47 | "@typescript-eslint/parser": "^5.59.9", 48 | "eslint": "^8.42.0", 49 | "eslint-config-prettier": "^8.8.0", 50 | "eslint-plugin-prettier": "^4.2.1", 51 | "jest": "^29.7.0", 52 | "prettier": "^2.8.8", 53 | "ts-jest": "^29.1.4", 54 | "typescript": "^5.4.5" 55 | }, 56 | "dependencies": { 57 | "@types/express": "^5.0.0" 58 | }, 59 | "snyk": true 60 | } 61 | -------------------------------------------------------------------------------- /src/index.ts: -------------------------------------------------------------------------------- 1 | export interface EventEventEmitter { 2 | addListener?: jest.Mock 3 | on?: jest.Mock 4 | once?: jest.Mock 5 | removeListener?: jest.Mock 6 | off?: jest.Mock 7 | removeAllListeners?: jest.Mock 8 | setMaxListeners?: jest.Mock 9 | getMaxListeners?: jest.Mock 10 | listeners?: jest.Mock 11 | rawListeners?: jest.Mock 12 | emit?: jest.Mock 13 | listenerCount?: jest.Mock 14 | prependListener?: jest.Mock 15 | prependOnceListener?: jest.Mock 16 | eventNames?: jest.Mock 17 | } 18 | -------------------------------------------------------------------------------- /src/request/index.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { IncomingMessage } from 'http' 3 | import type { Readable } from 'stream' 4 | import type { Request } from 'express' 5 | 6 | // Local Types 7 | import type { EventEventEmitter } from '../index' 8 | 9 | interface StreamReadable extends EventEventEmitter { 10 | readable?: Readable['readable'] 11 | readableHighWaterMark?: Readable['readableHighWaterMark'] 12 | readableLength?: Readable['readableLength'] 13 | readableObjectMode?: Readable['readableObjectMode'] 14 | destroyed?: Readable['destroyed'] 15 | _read?: jest.Mock 16 | read?: jest.Mock 17 | setEncoding?: jest.Mock 18 | pause?: jest.Mock 19 | resume?: jest.Mock 20 | isPaused?: jest.Mock 21 | unpipe?: jest.Mock 22 | unshift?: jest.Mock 23 | wrap?: jest.Mock 24 | push?: jest.Mock 25 | _destroy?: jest.Mock 26 | addListener?: jest.Mock 27 | emit?: jest.Mock 28 | on?: jest.Mock 29 | once?: jest.Mock 30 | prependListener?: jest.Mock 31 | prependOnceListener?: jest.Mock 32 | removeListener?: jest.Mock 33 | destroy?: jest.Mock 34 | } 35 | 36 | interface HttpIncomingMessage extends StreamReadable { 37 | aborted?: IncomingMessage['aborted'] 38 | httpVersion?: IncomingMessage['httpVersion'] 39 | httpVersionMajor?: IncomingMessage['httpVersionMajor'] 40 | httpVersionMinor?: IncomingMessage['httpVersionMinor'] 41 | complete?: IncomingMessage['complete'] 42 | connection?: Partial | null 43 | socket?: Partial | null 44 | headers?: Partial 45 | rawHeaders?: IncomingMessage['rawHeaders'] 46 | trailers?: IncomingMessage['trailers'] 47 | rawTrailers?: IncomingMessage['rawTrailers'] 48 | setTimeout?: jest.Mock 49 | statusCode?: IncomingMessage['statusCode'] 50 | statusMessage?: IncomingMessage['statusMessage'] 51 | destroy?: jest.Mock 52 | } 53 | 54 | export interface MockRequest extends HttpIncomingMessage { 55 | params?: Request['params'] 56 | query?: Request['query'] 57 | body?: Request['body'] 58 | cookies?: Request['cookies'] 59 | method?: Request['method'] 60 | protocol?: Request['protocol'] 61 | secure?: Request['secure'] 62 | ip?: Request['ip'] 63 | ips?: Request['ips'] 64 | subdomains?: Request['subdomains'] 65 | path?: Request['path'] 66 | hostname?: Request['hostname'] 67 | host?: Request['host'] 68 | fresh?: Request['fresh'] 69 | stale?: Request['stale'] 70 | xhr?: Request['xhr'] 71 | route?: Request['route'] 72 | signedCookies?: Request['signedCookies'] 73 | originalUrl?: Request['originalUrl'] 74 | url?: Request['url'] 75 | baseUrl?: Request['baseUrl'] 76 | accepted?: Request['accepted'] 77 | get?: jest.Mock 78 | header?: jest.Mock 79 | accepts?: jest.Mock 80 | acceptsCharsets?: jest.Mock 81 | acceptsEncodings?: jest.Mock 82 | acceptsLanguages?: jest.Mock 83 | range?: jest.Mock 84 | param?: jest.Mock 85 | is?: jest.Mock 86 | app?: Partial 87 | res?: Partial 88 | next?: jest.Mock 89 | 90 | // allow custom properties to be provided 91 | // eslint-disable-next-line @typescript-eslint/no-explicit-any 92 | [key: string]: any 93 | } 94 | -------------------------------------------------------------------------------- /src/request/request.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Request } from 'express' 3 | 4 | // Local Types 5 | import type { MockRequest } from './index' 6 | 7 | /** 8 | * Returns a mocked **Express** `Request` with mocked functions and default values. 9 | */ 10 | export const getMockReq = (values: MockRequest = {}): T => { 11 | const { 12 | /* express.Request */ 13 | params = {}, 14 | query = {}, 15 | body = {}, 16 | cookies = {}, 17 | method = '', 18 | protocol = '', 19 | secure = false, 20 | ip = '', 21 | ips = [], 22 | subdomains = [], 23 | path = '', 24 | hostname = '', 25 | host = '', 26 | fresh = false, 27 | stale = false, 28 | xhr = false, 29 | route = {}, 30 | signedCookies = {}, 31 | originalUrl = '', 32 | url = '', 33 | baseUrl = '', 34 | accepted = [], 35 | get = jest.fn().mockName('get mock default'), 36 | header = jest.fn().mockName('header mock default'), 37 | accepts = jest.fn().mockName('accepts mock default'), 38 | acceptsCharsets = jest.fn().mockName('acceptsCharsets mock default'), 39 | acceptsEncodings = jest.fn().mockName('acceptsEncodings mock default'), 40 | acceptsLanguages = jest.fn().mockName('acceptsLanguages mock default'), 41 | range = jest.fn().mockName('range mock default'), 42 | param = jest.fn().mockName('param mock default'), 43 | is = jest.fn().mockName('is mock default'), 44 | app = {}, 45 | res = jest.fn().mockName('res mock default'), 46 | next = jest.fn().mockName('next mock default'), 47 | 48 | /* http.IncomingMessage */ 49 | aborted = false, 50 | httpVersion = '', 51 | httpVersionMajor = 0, 52 | httpVersionMinor = 0, 53 | complete = false, 54 | connection = {}, 55 | socket = {}, 56 | headers = {}, 57 | rawHeaders = [], 58 | trailers = {}, 59 | rawTrailers = [], 60 | setTimeout = jest.fn().mockName('setTimeout mock default'), 61 | statusCode = 0, 62 | statusMessage = '', 63 | destroy = jest.fn().mockName('destroy mock default'), 64 | 65 | /* stream.Readable */ 66 | readable = false, 67 | readableHighWaterMark = 0, 68 | readableLength = 0, 69 | readableObjectMode = false, 70 | destroyed = false, 71 | _read = jest.fn().mockName('_read mock default'), 72 | read = jest.fn().mockName('read mock default'), 73 | setEncoding = jest.fn().mockName('setEncoding mock default'), 74 | pause = jest.fn().mockName('pause mock default'), 75 | resume = jest.fn().mockName('resume mock default'), 76 | isPaused = jest.fn().mockName('isPaused mock default'), 77 | unpipe = jest.fn().mockName('unpipe mock default'), 78 | unshift = jest.fn().mockName('unshift mock default'), 79 | wrap = jest.fn().mockName('wrap mock default'), 80 | push = jest.fn().mockName('push mock default'), 81 | _destroy = jest.fn().mockName('_destroy mock default'), 82 | addListener = jest.fn().mockName('addListener mock default'), 83 | emit = jest.fn().mockName('emit mock default'), 84 | on = jest.fn().mockName('on mock default'), 85 | once = jest.fn().mockName('once mock default'), 86 | prependListener = jest.fn().mockName('prependListener mock default'), 87 | prependOnceListener = jest.fn().mockName('prependOnceListener mock default'), 88 | removeListener = jest.fn().mockName('removeListener mock default'), 89 | // destroy - is handled/overridden as part of http.IncomingMessage 90 | 91 | /* event.EventEmitter */ 92 | // addListener - is handled/overridden as part of stream.Readable 93 | // on - is handled/overridden as part of stream.Readable 94 | // once - is handled/overridden as part of stream.Readable 95 | // removeListener - is handled/overridden as part of stream.Readable 96 | off = jest.fn().mockName('off mock default'), 97 | removeAllListeners = jest.fn().mockName('removeAllListeners mock default'), 98 | setMaxListeners = jest.fn().mockName('setMaxListeners mock default'), 99 | getMaxListeners = jest.fn().mockName('getMaxListeners mock default'), 100 | listeners = jest.fn().mockName('listeners mock default'), 101 | rawListeners = jest.fn().mockName('rawListeners mock default'), 102 | // emit - is handled/overridden as part of stream.Readable 103 | listenerCount = jest.fn().mockName('listenerCount mock default'), 104 | // prependListener - is handled/overridden as part of stream.Readable 105 | // prependOnceListener - is handled/overridden as part of stream.Readable 106 | eventNames = jest.fn().mockName('eventNames mock default'), 107 | 108 | // custom values 109 | ...extraProvidedValues 110 | } = values 111 | 112 | const request = { 113 | /* express.Request */ 114 | params, 115 | query, 116 | body, 117 | cookies, 118 | method, 119 | protocol, 120 | secure, 121 | ip, 122 | ips, 123 | subdomains, 124 | path, 125 | hostname, 126 | host, 127 | fresh, 128 | stale, 129 | xhr, 130 | route, 131 | signedCookies, 132 | originalUrl, 133 | url, 134 | baseUrl, 135 | accepted, 136 | get, 137 | header, 138 | accepts, 139 | acceptsCharsets, 140 | acceptsEncodings, 141 | acceptsLanguages, 142 | range, 143 | param, 144 | is, 145 | app, 146 | res, 147 | next, 148 | 149 | /* http.IncomingMessage */ 150 | aborted, 151 | httpVersion, 152 | httpVersionMajor, 153 | httpVersionMinor, 154 | complete, 155 | connection, 156 | socket, 157 | headers, 158 | rawHeaders, 159 | trailers, 160 | rawTrailers, 161 | setTimeout, 162 | statusCode, 163 | statusMessage, 164 | destroy, 165 | 166 | /* stream.Readable */ 167 | readable, 168 | readableHighWaterMark, 169 | readableLength, 170 | readableObjectMode, 171 | destroyed, 172 | _read, 173 | read, 174 | setEncoding, 175 | pause, 176 | resume, 177 | isPaused, 178 | unpipe, 179 | unshift, 180 | wrap, 181 | push, 182 | _destroy, 183 | addListener, 184 | emit, 185 | on, 186 | once, 187 | prependListener, 188 | prependOnceListener, 189 | removeListener, 190 | // destroy - is handled/overridden as part of http.IncomingMessage 191 | 192 | /* event.EventEmitter */ 193 | // addListener - is handled/overridden as part of stream.Readable 194 | // on - is handled/overridden as part of stream.Readable 195 | // once - is handled/overridden as part of stream.Readable 196 | // removeListener - is handled/overridden as part of stream.Readable 197 | off, 198 | removeAllListeners, 199 | setMaxListeners, 200 | getMaxListeners, 201 | listeners, 202 | rawListeners, 203 | // emit - is handled/overridden as part of stream.Readable 204 | listenerCount, 205 | // prependListener - is handled/overridden as part of stream.Readable 206 | // prependOnceListener - is handled/overridden as part of stream.Readable 207 | eventNames, 208 | 209 | // custom values 210 | ...extraProvidedValues, 211 | } 212 | 213 | return request as unknown as T 214 | } 215 | 216 | export default getMockReq 217 | -------------------------------------------------------------------------------- /src/response/index.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { ServerResponse, OutgoingMessage, IncomingMessage } from 'http' 3 | import type { Writable } from 'stream' 4 | import type { Response } from 'express' 5 | 6 | // Local Types 7 | import type { EventEventEmitter } from '../index' 8 | 9 | interface StreamWritable extends EventEventEmitter { 10 | writable?: Writable['writable'] 11 | writableEnded?: Writable['writableEnded'] 12 | writableFinished?: Writable['writableFinished'] 13 | writableHighWaterMark?: Writable['writableHighWaterMark'] 14 | writableLength?: Writable['writableLength'] 15 | writableObjectMode?: Writable['writableObjectMode'] 16 | writableCorked?: Writable['writableCorked'] 17 | destroyed?: Writable['destroyed'] 18 | _write?: jest.Mock 19 | _writev?: jest.Mock 20 | _destroy?: jest.Mock 21 | _final?: jest.Mock 22 | write?: jest.Mock 23 | setDefaultEncoding?: jest.Mock 24 | end?: jest.Mock 25 | cork?: jest.Mock 26 | uncork?: jest.Mock 27 | destroy?: jest.Mock 28 | addListener?: jest.Mock 29 | emit?: jest.Mock 30 | on?: jest.Mock 31 | once?: jest.Mock 32 | prependListener?: jest.Mock 33 | prependOnceListener?: jest.Mock 34 | removeListener?: jest.Mock 35 | } 36 | 37 | interface HttpOutgoingMessage extends StreamWritable { 38 | req?: Partial 39 | chunkedEncoding?: OutgoingMessage['chunkedEncoding'] 40 | shouldKeepAlive?: OutgoingMessage['shouldKeepAlive'] 41 | useChunkedEncodingByDefault?: OutgoingMessage['useChunkedEncodingByDefault'] 42 | sendDate?: OutgoingMessage['sendDate'] 43 | finished?: OutgoingMessage['finished'] 44 | headersSent?: OutgoingMessage['headersSent'] 45 | connection?: Partial 46 | socket?: Partial 47 | setTimeout?: jest.Mock 48 | setHeader?: jest.Mock 49 | getHeader?: jest.Mock 50 | getHeaders?: jest.Mock 51 | getHeaderNames?: jest.Mock 52 | hasHeader?: jest.Mock 53 | removeHeader?: jest.Mock 54 | addTrailers?: jest.Mock 55 | flushHeaders?: jest.Mock 56 | } 57 | 58 | interface HttpServerResponse extends HttpOutgoingMessage { 59 | statusCode?: ServerResponse['statusCode'] 60 | statusMessage?: ServerResponse['statusMessage'] 61 | assignSocket?: jest.Mock 62 | detachSocket?: jest.Mock 63 | writeContinue?: jest.Mock 64 | writeHead?: jest.Mock 65 | writeProcessing?: jest.Mock 66 | } 67 | 68 | export interface MockResponse extends HttpServerResponse { 69 | status?: jest.Mock 70 | sendStatus?: jest.Mock 71 | links?: jest.Mock 72 | send?: jest.Mock 73 | json?: jest.Mock 74 | jsonp?: jest.Mock 75 | sendFile?: jest.Mock 76 | sendfile?: jest.Mock 77 | download?: jest.Mock 78 | contentType?: jest.Mock 79 | type?: jest.Mock 80 | format?: jest.Mock 81 | attachment?: jest.Mock 82 | set?: jest.Mock 83 | header?: jest.Mock 84 | headersSent?: Response['headersSent'] 85 | get?: jest.Mock 86 | clearCookie?: jest.Mock 87 | cookie?: jest.Mock 88 | location?: jest.Mock 89 | redirect?: jest.Mock 90 | render?: jest.Mock 91 | locals?: Partial 92 | charset?: Response['charset'] 93 | vary?: jest.Mock 94 | app?: Partial 95 | append?: jest.Mock 96 | req?: Partial 97 | 98 | // allow custom properties to be provided 99 | // eslint-disable-next-line @typescript-eslint/no-explicit-any 100 | [key: string]: any 101 | } 102 | -------------------------------------------------------------------------------- /src/response/response.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Response, NextFunction } from 'express' 3 | 4 | // Local Types 5 | import type { MockResponse } from './index' 6 | 7 | /** 8 | * Returns a mocked version of key **Express** components, including: 9 | * - a mocked **Express** `Response`, with mocked functions (chainable) and default values. 10 | * - a mocked `next()` convenience function. 11 | * - `mockClear()` to clear all internal **Jest** functions including `next()` 12 | * - `clearMockRes()` an alias for `mockClear()` 13 | */ 14 | export const getMockRes = ( 15 | values: MockResponse = {}, 16 | ): { 17 | res: T 18 | next: NextFunction 19 | mockClear: () => void 20 | clearMockRes: () => void 21 | } => { 22 | const next = jest.fn() 23 | const { 24 | /* express.Response */ 25 | status = jest.fn().mockName('status mock default'), 26 | sendStatus = jest.fn().mockName('sendStatus mock default'), 27 | links = jest.fn().mockName('links mock default'), 28 | send = jest.fn().mockName('send mock default'), 29 | json = jest.fn().mockName('json mock default'), 30 | jsonp = jest.fn().mockName('jsonp mock default'), 31 | sendFile = jest.fn().mockName('sendFile mock default'), 32 | sendfile = jest.fn().mockName('sendfile mock default'), 33 | download = jest.fn().mockName('download mock default'), 34 | contentType = jest.fn().mockName('contentType mock default'), 35 | type = jest.fn().mockName('type mock default'), 36 | format = jest.fn().mockName('format mock default'), 37 | attachment = jest.fn().mockName('attachment mock default'), 38 | set = jest.fn().mockName('set mock default'), 39 | header = jest.fn().mockName('header mock default'), 40 | headersSent = false, 41 | get = jest.fn().mockName('get mock default'), 42 | clearCookie = jest.fn().mockName('clearCookie mock default'), 43 | cookie = jest.fn().mockName('cookie mock default'), 44 | location = jest.fn().mockName('location mock default'), 45 | redirect = jest.fn().mockName('redirect mock default'), 46 | render = jest.fn().mockName('render mock default'), 47 | locals = {}, 48 | charset = '', 49 | vary = jest.fn().mockName('vary mock default'), 50 | app = {}, 51 | append = jest.fn().mockName('append mock default'), 52 | req = {}, 53 | 54 | /* http.ServerResponse */ 55 | statusCode = 0, 56 | statusMessage = '', 57 | assignSocket = jest.fn().mockName('assignSocket mock default'), 58 | detachSocket = jest.fn().mockName('detachSocket mock default'), 59 | writeContinue = jest.fn().mockName('writeContinue mock default'), 60 | writeHead = jest.fn().mockName('writeHead mock default'), 61 | writeProcessing = jest.fn().mockName('writeProcessing mock default'), 62 | 63 | /* http.OutgoingMessage */ 64 | // req - is handled/overridden as part of express.Response 65 | chunkedEncoding = false, 66 | shouldKeepAlive = false, 67 | useChunkedEncodingByDefault = false, 68 | sendDate = false, 69 | finished = false, 70 | // headersSent - is handled/overridden as part of express.Response 71 | connection = {}, 72 | socket = {}, 73 | setTimeout = jest.fn().mockName('setTimeout mock default'), 74 | setHeader = jest.fn().mockName('setHeader mock default'), 75 | getHeader = jest.fn().mockName('getHeader mock default'), 76 | getHeaders = jest.fn().mockName('getHeaders mock default'), 77 | getHeaderNames = jest.fn().mockName('getHeaderNames mock default'), 78 | hasHeader = jest.fn().mockName('hasHeader mock default'), 79 | removeHeader = jest.fn().mockName('removeHeader mock default'), 80 | addTrailers = jest.fn().mockName('addTrailers mock default'), 81 | flushHeaders = jest.fn().mockName('flushHeaders mock default'), 82 | 83 | /* stream.Writable */ 84 | writable = false, 85 | writableEnded = false, 86 | writableFinished = false, 87 | writableHighWaterMark = 0, 88 | writableLength = 0, 89 | writableObjectMode = false, 90 | writableCorked = 0, 91 | destroyed = false, 92 | _write = jest.fn().mockName('_write mock default'), 93 | _writev = jest.fn().mockName('_writev mock default'), 94 | _destroy = jest.fn().mockName('_destroy mock default'), 95 | _final = jest.fn().mockName('_final mock default'), 96 | write = jest.fn().mockName('write mock default'), 97 | setDefaultEncoding = jest.fn().mockName('setDefaultEncoding mock default'), 98 | end = jest.fn().mockName('end mock default'), 99 | cork = jest.fn().mockName('cork mock default'), 100 | uncork = jest.fn().mockName('uncork mock default'), 101 | destroy = jest.fn().mockName('destroy mock default'), 102 | addListener = jest.fn().mockName('addListener mock default'), 103 | emit = jest.fn().mockName('emit mock default'), 104 | on = jest.fn().mockName('on mock default'), 105 | once = jest.fn().mockName('once mock default'), 106 | prependListener = jest.fn().mockName('prependListener mock default'), 107 | prependOnceListener = jest.fn().mockName('prependOnceListener mock default'), 108 | removeListener = jest.fn().mockName('removeListener mock default'), 109 | 110 | /* event.EventEmitter */ 111 | // addListener - is handled/overridden as part of stream.Writable 112 | // on - is handled/overridden as part of stream.Writable 113 | // once - is handled/overridden as part of stream.Writable 114 | // removeListener - is handled/overridden as part of stream.Writable 115 | off = jest.fn().mockName('off mock default'), 116 | removeAllListeners = jest.fn().mockName('removeAllListeners mock default'), 117 | setMaxListeners = jest.fn().mockName('setMaxListeners mock default'), 118 | getMaxListeners = jest.fn().mockName('getMaxListeners mock default'), 119 | listeners = jest.fn().mockName('listeners mock default'), 120 | rawListeners = jest.fn().mockName('rawListeners mock default'), 121 | // emit - is handled/overridden as part of stream.Writable 122 | listenerCount = jest.fn().mockName('listenerCount mock default'), 123 | // prependListener - is handled/overridden as part of stream.Writable 124 | // prependOnceListener - is handled/overridden as part of stream.Writable 125 | eventNames = jest.fn().mockName('eventNames mock default'), 126 | 127 | // custom values 128 | ...extraProvidedValues 129 | } = values 130 | 131 | const response = { 132 | /* express.Response */ 133 | status, 134 | sendStatus, 135 | links, 136 | send, 137 | json, 138 | jsonp, 139 | sendFile, 140 | sendfile, 141 | download, 142 | contentType, 143 | type, 144 | format, 145 | attachment, 146 | set, 147 | header, 148 | get, 149 | clearCookie, 150 | cookie, 151 | location, 152 | redirect, 153 | render, 154 | vary, 155 | append, 156 | headersSent, 157 | locals, 158 | charset, 159 | app, 160 | req, 161 | 162 | /* http.ServerResponse */ 163 | statusCode, 164 | statusMessage, 165 | assignSocket, 166 | detachSocket, 167 | writeContinue, 168 | writeHead, 169 | writeProcessing, 170 | 171 | /* http.OutgoingMessage */ 172 | chunkedEncoding, 173 | shouldKeepAlive, 174 | useChunkedEncodingByDefault, 175 | sendDate, 176 | finished, 177 | connection, 178 | socket, 179 | setTimeout, 180 | setHeader, 181 | getHeader, 182 | getHeaders, 183 | getHeaderNames, 184 | hasHeader, 185 | removeHeader, 186 | addTrailers, 187 | flushHeaders, 188 | 189 | /* stream.Writable */ 190 | writable, 191 | writableEnded, 192 | writableFinished, 193 | writableHighWaterMark, 194 | writableLength, 195 | writableObjectMode, 196 | writableCorked, 197 | destroyed, 198 | _write, 199 | _writev, 200 | _destroy, 201 | _final, 202 | write, 203 | setDefaultEncoding, 204 | end, 205 | cork, 206 | uncork, 207 | destroy, 208 | addListener, 209 | emit, 210 | on, 211 | once, 212 | prependListener, 213 | prependOnceListener, 214 | removeListener, 215 | 216 | /* event.EventEmitter */ 217 | // addListener - is handled/overridden as part of stream.Writable 218 | // on - is handled/overridden as part of stream.Writable 219 | // once - is handled/overridden as part of stream.Writable 220 | // removeListener - is handled/overridden as part of stream.Writable 221 | off, 222 | removeAllListeners, 223 | setMaxListeners, 224 | getMaxListeners, 225 | listeners, 226 | rawListeners, 227 | // emit - is handled/overridden as part of stream.Writable 228 | listenerCount, 229 | // prependListener - is handled/overridden as part of stream.Writable 230 | // prependOnceListener - is handled/overridden as part of stream.Writable 231 | eventNames, 232 | 233 | // custom values 234 | ...extraProvidedValues, 235 | } 236 | 237 | /* express.Response - chainable functions */ 238 | response.status.mockReturnValue(response) 239 | response.sendStatus.mockReturnValue(response) 240 | response.links.mockReturnValue(response) 241 | response.send.mockReturnValue(response) 242 | response.json.mockReturnValue(response) 243 | response.jsonp.mockReturnValue(response) 244 | response.contentType.mockReturnValue(response) 245 | response.type.mockReturnValue(response) 246 | response.format.mockReturnValue(response) 247 | response.attachment.mockReturnValue(response) 248 | response.set.mockReturnValue(response) 249 | response.header.mockReturnValue(response) 250 | response.clearCookie.mockReturnValue(response) 251 | response.cookie.mockReturnValue(response) 252 | response.location.mockReturnValue(response) 253 | response.vary.mockReturnValue(response) 254 | response.append.mockReturnValue(response) 255 | 256 | /* http.ServerResponse - chainable functions */ 257 | response.writeHead.mockReturnValue(response) 258 | 259 | /* http.OutgoingMessage - chainable functions */ 260 | response.setTimeout.mockReturnValue(response) 261 | 262 | /* stream.Writable - chainable functions */ 263 | response.setDefaultEncoding.mockReturnValue(response) 264 | response.addListener.mockReturnValue(response) 265 | response.on.mockReturnValue(response) 266 | response.once.mockReturnValue(response) 267 | response.prependListener.mockReturnValue(response) 268 | response.prependOnceListener.mockReturnValue(response) 269 | response.removeListener.mockReturnValue(response) 270 | 271 | /* event.EventEmitter - chainable functions */ 272 | // addListener - is handled/overridden as part of stream.Writable 273 | // on - is handled/overridden as part of stream.Writable 274 | // once - is handled/overridden as part of stream.Writable 275 | // removeListener - is handled/overridden as part of stream.Writable 276 | response.off.mockReturnValue(response) 277 | response.removeAllListeners.mockReturnValue(response) 278 | response.setMaxListeners.mockReturnValue(response) 279 | // prependListener - is handled/overridden as part of stream.Writable 280 | // prependOnceListener - is handled/overridden as part of stream.Writable 281 | 282 | const clearAllMocks = (): void => { 283 | next.mockClear() 284 | /* express.Response */ 285 | response.status.mockClear() 286 | response.sendStatus.mockClear() 287 | response.links.mockClear() 288 | response.send.mockClear() 289 | response.json.mockClear() 290 | response.jsonp.mockClear() 291 | response.sendFile.mockClear() 292 | response.sendfile.mockClear() 293 | response.download.mockClear() 294 | response.contentType.mockClear() 295 | response.type.mockClear() 296 | response.format.mockClear() 297 | response.attachment.mockClear() 298 | response.set.mockClear() 299 | response.header.mockClear() 300 | response.get.mockClear() 301 | response.clearCookie.mockClear() 302 | response.cookie.mockClear() 303 | response.location.mockClear() 304 | response.redirect.mockClear() 305 | response.render.mockClear() 306 | response.vary.mockClear() 307 | response.append.mockClear() 308 | 309 | /* http.ServerResponse */ 310 | response.assignSocket.mockClear() 311 | response.detachSocket.mockClear() 312 | response.writeContinue.mockClear() 313 | response.writeHead.mockClear() 314 | response.writeProcessing.mockClear() 315 | 316 | /* http.OutgoingMessage */ 317 | response.setTimeout.mockClear() 318 | response.setHeader.mockClear() 319 | response.getHeader.mockClear() 320 | response.getHeaders.mockClear() 321 | response.getHeaderNames.mockClear() 322 | response.hasHeader.mockClear() 323 | response.removeHeader.mockClear() 324 | response.addTrailers.mockClear() 325 | response.flushHeaders.mockClear() 326 | 327 | /* stream.Writable */ 328 | response._write.mockClear() 329 | response._writev.mockClear() 330 | response._destroy.mockClear() 331 | response._final.mockClear() 332 | response.write.mockClear() 333 | response.setDefaultEncoding.mockClear() 334 | response.end.mockClear() 335 | response.cork.mockClear() 336 | response.uncork.mockClear() 337 | response.destroy.mockClear() 338 | response.addListener.mockClear() 339 | response.emit.mockClear() 340 | response.on.mockClear() 341 | response.once.mockClear() 342 | response.prependListener.mockClear() 343 | response.prependOnceListener.mockClear() 344 | response.removeListener.mockClear() 345 | 346 | /* event.EventEmitter */ 347 | // addListener - is handled/overridden as part of stream.Writable 348 | // on - is handled/overridden as part of stream.Writable 349 | // once - is handled/overridden as part of stream.Writable 350 | // removeListener - is handled/overridden as part of stream.Writable 351 | response.off.mockClear() 352 | response.removeAllListeners.mockClear() 353 | response.setMaxListeners.mockClear() 354 | response.getMaxListeners.mockClear() 355 | response.listeners.mockClear() 356 | response.rawListeners.mockClear() 357 | // emit - is handled/overridden as part of stream.Writable 358 | response.listenerCount.mockClear() 359 | // prependListener - is handled/overridden as part of stream.Writable 360 | // prependOnceListener - is handled/overridden as part of stream.Writable 361 | response.eventNames.mockClear() 362 | } 363 | 364 | return { 365 | res: response as unknown as T, 366 | next: next as NextFunction, 367 | mockClear: clearAllMocks, 368 | clearMockRes: clearAllMocks, 369 | } 370 | } 371 | 372 | export default getMockRes 373 | -------------------------------------------------------------------------------- /src/test/helpers/provided.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Response, Request, MediaType } from 'express' 3 | 4 | export const providedNumber = 123 5 | 6 | export const providedBoolean = true 7 | 8 | export const providedString = 'Provided String' 9 | 10 | export const providedStringArray = ['One', 'Two', 'Three', 'Four'] 11 | 12 | export const providedFunction = jest.fn().mockName('Provided Mock Function') 13 | 14 | export const providedObject = { 15 | one: { 16 | two: 'three', 17 | }, 18 | four: ['five'], 19 | } 20 | 21 | export const providedApp: Partial = { 22 | settings: { 23 | one: 'two', 24 | }, 25 | } 26 | 27 | export const providedReq: Partial = { 28 | path: 'value', 29 | } 30 | 31 | export const providedRes: Partial = { 32 | chunkedEncoding: true, 33 | } 34 | 35 | export const providedSocket: Partial = { 36 | connecting: true, 37 | } 38 | 39 | export const providedStringObject: { [key: string]: string | undefined } = { 40 | one: 'two', 41 | three: 'four', 42 | } 43 | 44 | export const providedParams: Request['params'] = { 45 | one: 'two', 46 | three: 'four', 47 | } 48 | 49 | export const providedMediaTypeArray: MediaType[] = [ 50 | { 51 | value: 'value', 52 | quality: 1, 53 | type: 'type', 54 | subtype: 'subtype', 55 | }, 56 | ] 57 | -------------------------------------------------------------------------------- /src/test/helpers/response.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Socket } from 'net' 3 | import type { Response } from 'express' 4 | 5 | export function callAllFunctions(res: Response) { 6 | /* express.Response */ 7 | res.status(123) 8 | res.sendStatus(123) 9 | res.links({}) 10 | res.send() 11 | res.json() 12 | res.jsonp() 13 | res.sendFile('test') 14 | res.download('test') 15 | res.contentType('test') 16 | res.type('test') 17 | res.format({}) 18 | res.attachment() 19 | res.set({}) 20 | res.header({}) 21 | res.get('test') 22 | res.clearCookie('test') 23 | res.cookie('test', 'test') 24 | res.location('test') 25 | res.redirect('test') 26 | res.render('test') 27 | res.vary('test') 28 | res.append('test') 29 | 30 | /* http.ServerResponse */ 31 | res.assignSocket({} as Socket) 32 | res.detachSocket({} as Socket) 33 | res.writeContinue() 34 | res.writeHead(123) 35 | res.writeProcessing() 36 | 37 | /* http.OutgoingMessage */ 38 | res.setTimeout(123) 39 | res.setHeader('test', 'test') 40 | res.getHeader('test') 41 | res.getHeaders() 42 | res.getHeaderNames() 43 | res.hasHeader('test') 44 | res.removeHeader('test') 45 | res.addTrailers([]) 46 | res.flushHeaders() 47 | 48 | /* stream.Writable */ 49 | res._write({}, 'base64', jest.fn()) 50 | res._writev && res._writev([], jest.fn()) 51 | res._destroy(null, jest.fn()) 52 | res._final(jest.fn()) 53 | res.write({}, jest.fn()) 54 | res.setDefaultEncoding('base64') 55 | res.end() 56 | res.cork() 57 | res.uncork() 58 | res.destroy() 59 | res.addListener('test', jest.fn()) 60 | res.emit('test') 61 | res.on('test', jest.fn()) 62 | res.once('test', jest.fn()) 63 | res.prependListener('test', jest.fn()) 64 | res.prependOnceListener('test', jest.fn()) 65 | res.removeListener('test', jest.fn()) 66 | 67 | /* event.EventEmitter */ 68 | // addListener - is handled/overridden as part of stream.Writable 69 | // on - is handled/overridden as part of stream.Writable 70 | // once - is handled/overridden as part of stream.Writable 71 | // removeListener - is handled/overridden as part of stream.Writable 72 | res.off('test', jest.fn()) 73 | res.removeAllListeners() 74 | res.setMaxListeners(2) 75 | res.getMaxListeners() 76 | res.listeners('test') 77 | res.rawListeners('test') 78 | // emit - is handled/overridden as part of stream.Writable 79 | res.listenerCount('test') 80 | // prependListener - is handled/overridden as part of stream.Writable 81 | // prependOnceListener - is handled/overridden as part of stream.Writable 82 | res.eventNames() 83 | } 84 | -------------------------------------------------------------------------------- /src/test/request/defaults/defaults.event.EventEmitter.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockReq from '../../../request/request' 3 | 4 | describe('request - Defaults from "event.EventEmitter" (accepts no arguments and return default values)', () => { 5 | test('req.addListener is a mocked function', () => { 6 | const req = getMockReq() 7 | 8 | expect(req.addListener).toBeDefined() 9 | expect(typeof req.addListener).toBe('function') 10 | expect((req.addListener as jest.Mock).getMockName()).toBe('addListener mock default') 11 | }) 12 | 13 | test('req.on is a mocked function', () => { 14 | const req = getMockReq() 15 | 16 | expect(req.on).toBeDefined() 17 | expect(typeof req.on).toBe('function') 18 | expect((req.on as jest.Mock).getMockName()).toBe('on mock default') 19 | }) 20 | 21 | test('req.once is a mocked function', () => { 22 | const req = getMockReq() 23 | 24 | expect(req.once).toBeDefined() 25 | expect(typeof req.once).toBe('function') 26 | expect((req.once as jest.Mock).getMockName()).toBe('once mock default') 27 | }) 28 | 29 | test('req.removeListener is a mocked function', () => { 30 | const req = getMockReq() 31 | 32 | expect(req.removeListener).toBeDefined() 33 | expect(typeof req.removeListener).toBe('function') 34 | expect((req.removeListener as jest.Mock).getMockName()).toBe('removeListener mock default') 35 | }) 36 | 37 | test('req.off is a mocked function', () => { 38 | const req = getMockReq() 39 | 40 | expect(req.off).toBeDefined() 41 | expect(typeof req.off).toBe('function') 42 | expect((req.off as jest.Mock).getMockName()).toBe('off mock default') 43 | }) 44 | 45 | test('req.removeAllListeners is a mocked function', () => { 46 | const req = getMockReq() 47 | 48 | expect(req.removeAllListeners).toBeDefined() 49 | expect(typeof req.removeAllListeners).toBe('function') 50 | expect((req.removeAllListeners as jest.Mock).getMockName()).toBe('removeAllListeners mock default') 51 | }) 52 | 53 | test('req.setMaxListeners is a mocked function', () => { 54 | const req = getMockReq() 55 | 56 | expect(req.setMaxListeners).toBeDefined() 57 | expect(typeof req.setMaxListeners).toBe('function') 58 | expect((req.setMaxListeners as jest.Mock).getMockName()).toBe('setMaxListeners mock default') 59 | }) 60 | 61 | test('req.getMaxListeners is a mocked function', () => { 62 | const req = getMockReq() 63 | 64 | expect(req.getMaxListeners).toBeDefined() 65 | expect(typeof req.getMaxListeners).toBe('function') 66 | expect((req.getMaxListeners as jest.Mock).getMockName()).toBe('getMaxListeners mock default') 67 | }) 68 | 69 | test('req.listeners is a mocked function', () => { 70 | const req = getMockReq() 71 | 72 | expect(req.listeners).toBeDefined() 73 | expect(typeof req.listeners).toBe('function') 74 | expect((req.listeners as jest.Mock).getMockName()).toBe('listeners mock default') 75 | }) 76 | 77 | test('req.rawListeners is a mocked function', () => { 78 | const req = getMockReq() 79 | 80 | expect(req.rawListeners).toBeDefined() 81 | expect(typeof req.rawListeners).toBe('function') 82 | expect((req.rawListeners as jest.Mock).getMockName()).toBe('rawListeners mock default') 83 | }) 84 | 85 | test('req.emit is a mocked function', () => { 86 | const req = getMockReq() 87 | 88 | expect(req.emit).toBeDefined() 89 | expect(typeof req.emit).toBe('function') 90 | expect((req.emit as jest.Mock).getMockName()).toBe('emit mock default') 91 | }) 92 | 93 | test('req.listenerCount is a mocked function', () => { 94 | const req = getMockReq() 95 | 96 | expect(req.listenerCount).toBeDefined() 97 | expect(typeof req.listenerCount).toBe('function') 98 | expect((req.listenerCount as jest.Mock).getMockName()).toBe('listenerCount mock default') 99 | }) 100 | 101 | test('req.prependListener is a mocked function', () => { 102 | const req = getMockReq() 103 | 104 | expect(req.prependListener).toBeDefined() 105 | expect(typeof req.prependListener).toBe('function') 106 | expect((req.prependListener as jest.Mock).getMockName()).toBe('prependListener mock default') 107 | }) 108 | 109 | test('req.prependOnceListener is a mocked function', () => { 110 | const req = getMockReq() 111 | 112 | expect(req.prependOnceListener).toBeDefined() 113 | expect(typeof req.prependOnceListener).toBe('function') 114 | expect((req.prependOnceListener as jest.Mock).getMockName()).toBe('prependOnceListener mock default') 115 | }) 116 | 117 | test('req.eventNames is a mocked function', () => { 118 | const req = getMockReq() 119 | 120 | expect(req.eventNames).toBeDefined() 121 | expect(typeof req.eventNames).toBe('function') 122 | expect((req.eventNames as jest.Mock).getMockName()).toBe('eventNames mock default') 123 | }) 124 | }) 125 | -------------------------------------------------------------------------------- /src/test/request/defaults/defaults.express.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockReq from '../../../request/request' 3 | 4 | describe('request - Defaults from "express.Response" (accepts no arguments and return default values)', () => { 5 | test('req.params is an empty object', () => { 6 | const req = getMockReq() 7 | 8 | expect(req.params).toBeDefined() 9 | expect(req.params).toBeInstanceOf(Object) 10 | expect(Object.keys(req.params).length).toBe(0) 11 | }) 12 | 13 | test('req.query is an empty object', () => { 14 | const req = getMockReq() 15 | 16 | expect(req.query).toBeDefined() 17 | expect(req.query).toBeInstanceOf(Object) 18 | expect(Object.keys(req.query).length).toBe(0) 19 | }) 20 | 21 | test('req.body is an empty object', () => { 22 | const req = getMockReq() 23 | 24 | expect(req.body).toBeDefined() 25 | expect(req.body).toBeInstanceOf(Object) 26 | expect(Object.keys(req.body).length).toBe(0) 27 | }) 28 | 29 | test('req.cookies is an empty object', () => { 30 | const req = getMockReq() 31 | 32 | expect(req.cookies).toBeDefined() 33 | expect(req.cookies).toBeInstanceOf(Object) 34 | expect(Object.keys(req.cookies).length).toBe(0) 35 | }) 36 | 37 | test('req.method is an empty string', () => { 38 | const req = getMockReq() 39 | 40 | expect(req.method).toBeDefined() 41 | expect(req.method).toBe('') 42 | }) 43 | 44 | test('req.protocol is an empty string', () => { 45 | const req = getMockReq() 46 | 47 | expect(req.protocol).toBeDefined() 48 | expect(req.protocol).toBe('') 49 | }) 50 | 51 | test('req.secure is a boolean', () => { 52 | const req = getMockReq() 53 | 54 | expect(req.secure).toBeDefined() 55 | expect(req.secure).toBe(false) 56 | }) 57 | 58 | test('req.ip is an empty string', () => { 59 | const req = getMockReq() 60 | 61 | expect(req.ip).toBeDefined() 62 | expect(req.ip).toBe('') 63 | }) 64 | 65 | test('req.ips is an empty array', () => { 66 | const req = getMockReq() 67 | 68 | expect(req.ips).toBeDefined() 69 | expect(Array.isArray(req.ips)).toBe(true) 70 | expect(req.ips.length).toBe(0) 71 | }) 72 | 73 | test('req.subdomains is an empty array', () => { 74 | const req = getMockReq() 75 | 76 | expect(req.subdomains).toBeDefined() 77 | expect(Array.isArray(req.subdomains)).toBe(true) 78 | expect(req.subdomains.length).toBe(0) 79 | }) 80 | 81 | test('req.path is an empty string', () => { 82 | const req = getMockReq() 83 | 84 | expect(req.path).toBeDefined() 85 | expect(req.path).toBe('') 86 | }) 87 | 88 | test('req.hostname is an empty string', () => { 89 | const req = getMockReq() 90 | 91 | expect(req.hostname).toBeDefined() 92 | expect(req.hostname).toBe('') 93 | }) 94 | 95 | test('req.host is an empty string', () => { 96 | const req = getMockReq() 97 | 98 | expect(req.host).toBeDefined() 99 | expect(req.host).toBe('') 100 | }) 101 | 102 | test('req.fresh is a boolean', () => { 103 | const req = getMockReq() 104 | 105 | expect(req.fresh).toBeDefined() 106 | expect(req.fresh).toBe(false) 107 | }) 108 | 109 | test('req.stale is a boolean', () => { 110 | const req = getMockReq() 111 | 112 | expect(req.stale).toBeDefined() 113 | expect(req.stale).toBe(false) 114 | }) 115 | 116 | test('req.xhr is a boolean', () => { 117 | const req = getMockReq() 118 | 119 | expect(req.xhr).toBeDefined() 120 | expect(req.xhr).toBe(false) 121 | }) 122 | 123 | test('req.route is an empty object', () => { 124 | const req = getMockReq() 125 | 126 | expect(req.route).toBeDefined() 127 | expect(req.route).toBeInstanceOf(Object) 128 | expect(Object.keys(req.route).length).toBe(0) 129 | }) 130 | 131 | test('req.signedCookies is an empty object', () => { 132 | const req = getMockReq() 133 | 134 | expect(req.signedCookies).toBeDefined() 135 | expect(req.signedCookies).toBeInstanceOf(Object) 136 | expect(Object.keys(req.signedCookies).length).toBe(0) 137 | }) 138 | 139 | test('req.originalUrl is an empty string', () => { 140 | const req = getMockReq() 141 | 142 | expect(req.originalUrl).toBeDefined() 143 | expect(req.originalUrl).toBe('') 144 | }) 145 | 146 | test('req.url is an empty string', () => { 147 | const req = getMockReq() 148 | 149 | expect(req.url).toBeDefined() 150 | expect(req.url).toBe('') 151 | }) 152 | 153 | test('req.baseUrl is an empty string', () => { 154 | const req = getMockReq() 155 | 156 | expect(req.baseUrl).toBeDefined() 157 | expect(req.baseUrl).toBe('') 158 | }) 159 | 160 | test('req.accepted is an empty array', () => { 161 | const req = getMockReq() 162 | 163 | expect(req.accepted).toBeDefined() 164 | expect(Array.isArray(req.accepted)).toBe(true) 165 | expect(req.accepted.length).toBe(0) 166 | }) 167 | 168 | test('req.get is a mocked function', () => { 169 | const req = getMockReq() 170 | 171 | expect(req.get).toBeDefined() 172 | expect(typeof req.get).toBe('function') 173 | expect((req.get as jest.Mock).getMockName()).toBe('get mock default') 174 | }) 175 | 176 | test('req.header is a mocked function', () => { 177 | const req = getMockReq() 178 | 179 | expect(req.header).toBeDefined() 180 | expect(typeof req.header).toBe('function') 181 | expect((req.header as jest.Mock).getMockName()).toBe('header mock default') 182 | }) 183 | 184 | test('req.accepts is a mocked function', () => { 185 | const req = getMockReq() 186 | 187 | expect(req.accepts).toBeDefined() 188 | expect(typeof req.accepts).toBe('function') 189 | expect((req.accepts as jest.Mock).getMockName()).toBe('accepts mock default') 190 | }) 191 | 192 | test('req.acceptsCharsets is a mocked function', () => { 193 | const req = getMockReq() 194 | 195 | expect(req.acceptsCharsets).toBeDefined() 196 | expect(typeof req.acceptsCharsets).toBe('function') 197 | expect((req.acceptsCharsets as jest.Mock).getMockName()).toBe('acceptsCharsets mock default') 198 | }) 199 | 200 | test('req.acceptsEncodings is a mocked function', () => { 201 | const req = getMockReq() 202 | 203 | expect(req.acceptsEncodings).toBeDefined() 204 | expect(typeof req.acceptsEncodings).toBe('function') 205 | expect((req.acceptsEncodings as jest.Mock).getMockName()).toBe('acceptsEncodings mock default') 206 | }) 207 | 208 | test('req.acceptsLanguages is a mocked function', () => { 209 | const req = getMockReq() 210 | 211 | expect(req.acceptsLanguages).toBeDefined() 212 | expect(typeof req.acceptsLanguages).toBe('function') 213 | expect((req.acceptsLanguages as jest.Mock).getMockName()).toBe('acceptsLanguages mock default') 214 | }) 215 | 216 | test('req.range is a mocked function', () => { 217 | const req = getMockReq() 218 | 219 | expect(req.range).toBeDefined() 220 | expect(typeof req.range).toBe('function') 221 | expect((req.range as jest.Mock).getMockName()).toBe('range mock default') 222 | }) 223 | 224 | test('req.is is a mocked function', () => { 225 | const req = getMockReq() 226 | 227 | expect(req.is).toBeDefined() 228 | expect(typeof req.is).toBe('function') 229 | expect((req.is as jest.Mock).getMockName()).toBe('is mock default') 230 | }) 231 | 232 | test('req.app is an empty object', () => { 233 | const req = getMockReq() 234 | 235 | expect(req.app).toBeDefined() 236 | expect(req.app).toBeInstanceOf(Object) 237 | expect(Object.keys(req.app).length).toBe(0) 238 | }) 239 | 240 | test('req.res is a mocked function', () => { 241 | const req = getMockReq() 242 | 243 | expect(req.res).toBeDefined() 244 | expect(typeof req.res).toBe('function') 245 | expect((req.res as unknown as jest.Mock).getMockName()).toBe('res mock default') 246 | }) 247 | 248 | test('req.next is a mocked function', () => { 249 | const req = getMockReq() 250 | 251 | expect(req.next).toBeDefined() 252 | expect(typeof req.next).toBe('function') 253 | expect((req.next as jest.Mock).getMockName()).toBe('next mock default') 254 | }) 255 | }) 256 | -------------------------------------------------------------------------------- /src/test/request/defaults/defaults.http.IncomingMessage.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockReq from '../../../request/request' 3 | 4 | describe('request - Defaults from "http.IncomingMessage" (accepts no arguments and return default values)', () => { 5 | test('req.aborted is a boolean', () => { 6 | const req = getMockReq() 7 | 8 | expect(req.aborted).toBeDefined() 9 | expect(req.aborted).toBe(false) 10 | }) 11 | 12 | test('req.httpVersion is an empty string', () => { 13 | const req = getMockReq() 14 | 15 | expect(req.httpVersion).toBeDefined() 16 | expect(req.httpVersion).toBe('') 17 | }) 18 | 19 | test('req.httpVersionMajor is a number', () => { 20 | const req = getMockReq() 21 | 22 | expect(req.httpVersionMajor).toBeDefined() 23 | expect(req.httpVersionMajor).toBe(0) 24 | }) 25 | 26 | test('req.httpVersionMinor is a number', () => { 27 | const req = getMockReq() 28 | 29 | expect(req.httpVersionMinor).toBeDefined() 30 | expect(req.httpVersionMinor).toBe(0) 31 | }) 32 | 33 | test('req.complete is a boolean', () => { 34 | const req = getMockReq() 35 | 36 | expect(req.complete).toBeDefined() 37 | expect(req.complete).toBe(false) 38 | }) 39 | 40 | test('req.connection is an empty object', () => { 41 | const req = getMockReq() 42 | 43 | expect(req.connection).toBeDefined() 44 | expect(req.connection).toBeInstanceOf(Object) 45 | expect(Object.keys(req.connection).length).toBe(0) 46 | }) 47 | 48 | test('req.socket is an empty object', () => { 49 | const req = getMockReq() 50 | 51 | expect(req.socket).toBeDefined() 52 | expect(req.socket).toBeInstanceOf(Object) 53 | expect(Object.keys(req.socket).length).toBe(0) 54 | }) 55 | 56 | test('req.headers is an empty object', () => { 57 | const req = getMockReq() 58 | 59 | expect(req.headers).toBeDefined() 60 | expect(req.headers).toBeInstanceOf(Object) 61 | expect(Object.keys(req.headers).length).toBe(0) 62 | }) 63 | 64 | test('req.rawHeaders is an empty array', () => { 65 | const req = getMockReq() 66 | 67 | expect(req.rawHeaders).toBeDefined() 68 | expect(Array.isArray(req.rawHeaders)).toBe(true) 69 | expect(req.rawHeaders.length).toBe(0) 70 | }) 71 | 72 | test('req.trailers is an empty object', () => { 73 | const req = getMockReq() 74 | 75 | expect(req.trailers).toBeDefined() 76 | expect(req.trailers).toBeInstanceOf(Object) 77 | expect(Object.keys(req.trailers).length).toBe(0) 78 | }) 79 | 80 | test('req.rawTrailers is an empty array', () => { 81 | const req = getMockReq() 82 | 83 | expect(req.rawTrailers).toBeDefined() 84 | expect(Array.isArray(req.rawTrailers)).toBe(true) 85 | expect(req.rawTrailers.length).toBe(0) 86 | }) 87 | 88 | test('req.setTimeout is a mocked function', () => { 89 | const req = getMockReq() 90 | 91 | expect(req.setTimeout).toBeDefined() 92 | expect(typeof req.setTimeout).toBe('function') 93 | expect((req.setTimeout as jest.Mock).getMockName()).toBe('setTimeout mock default') 94 | }) 95 | 96 | test('req.statusCode is a number', () => { 97 | const req = getMockReq() 98 | 99 | expect(req.statusCode).toBeDefined() 100 | expect(req.statusCode).toBe(0) 101 | }) 102 | 103 | test('req.statusMessage is an empty string', () => { 104 | const req = getMockReq() 105 | 106 | expect(req.statusMessage).toBeDefined() 107 | expect(req.statusMessage).toBe('') 108 | }) 109 | 110 | test('req.destroy is a mocked function', () => { 111 | const req = getMockReq() 112 | 113 | expect(req.destroy).toBeDefined() 114 | expect(typeof req.destroy).toBe('function') 115 | expect((req.destroy as jest.Mock).getMockName()).toBe('destroy mock default') 116 | }) 117 | }) 118 | -------------------------------------------------------------------------------- /src/test/request/defaults/defaults.stream.Readable.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockReq from '../../../request/request' 3 | 4 | describe('request - Defaults from "stream.Readable" (accepts no arguments and return default values)', () => { 5 | test('req.readable is a boolean', () => { 6 | const req = getMockReq() 7 | 8 | expect(req.readable).toBeDefined() 9 | expect(req.readable).toBe(false) 10 | }) 11 | 12 | test('req.readableHighWaterMark is a number', () => { 13 | const req = getMockReq() 14 | 15 | expect(req.readableHighWaterMark).toBeDefined() 16 | expect(req.readableHighWaterMark).toBe(0) 17 | }) 18 | 19 | test('req.readableLength is a number', () => { 20 | const req = getMockReq() 21 | 22 | expect(req.readableLength).toBeDefined() 23 | expect(req.readableLength).toBe(0) 24 | }) 25 | 26 | test('req.readableObjectMode is a boolean', () => { 27 | const req = getMockReq() 28 | 29 | expect(req.readableObjectMode).toBeDefined() 30 | expect(req.readableObjectMode).toBe(false) 31 | }) 32 | 33 | test('req.destroyed is a boolean', () => { 34 | const req = getMockReq() 35 | 36 | expect(req.destroyed).toBeDefined() 37 | expect(req.destroyed).toBe(false) 38 | }) 39 | 40 | test('req.constructor is a function', () => { 41 | const req = getMockReq() 42 | 43 | // the constructor is not mocked 44 | expect(req.constructor).toBeDefined() 45 | expect(typeof req.constructor).toBe('function') 46 | }) 47 | 48 | test('req._read is a mocked function', () => { 49 | const req = getMockReq() 50 | 51 | expect(req._read).toBeDefined() 52 | expect(typeof req._read).toBe('function') 53 | expect((req._read as jest.Mock).getMockName()).toBe('_read mock default') 54 | }) 55 | 56 | test('req.read is a mocked function', () => { 57 | const req = getMockReq() 58 | 59 | expect(req.read).toBeDefined() 60 | expect(typeof req.read).toBe('function') 61 | expect((req.read as jest.Mock).getMockName()).toBe('read mock default') 62 | }) 63 | 64 | test('req.setEncoding is a mocked function', () => { 65 | const req = getMockReq() 66 | 67 | expect(req.setEncoding).toBeDefined() 68 | expect(typeof req.setEncoding).toBe('function') 69 | expect((req.setEncoding as jest.Mock).getMockName()).toBe('setEncoding mock default') 70 | }) 71 | 72 | test('req.pause is a mocked function', () => { 73 | const req = getMockReq() 74 | 75 | expect(req.pause).toBeDefined() 76 | expect(typeof req.pause).toBe('function') 77 | expect((req.pause as jest.Mock).getMockName()).toBe('pause mock default') 78 | }) 79 | 80 | test('req.resume is a mocked function', () => { 81 | const req = getMockReq() 82 | 83 | expect(req.resume).toBeDefined() 84 | expect(typeof req.resume).toBe('function') 85 | expect((req.resume as jest.Mock).getMockName()).toBe('resume mock default') 86 | }) 87 | 88 | test('req.isPaused is a mocked function', () => { 89 | const req = getMockReq() 90 | 91 | expect(req.isPaused).toBeDefined() 92 | expect(typeof req.isPaused).toBe('function') 93 | expect((req.isPaused as jest.Mock).getMockName()).toBe('isPaused mock default') 94 | }) 95 | 96 | test('req.unpipe is a mocked function', () => { 97 | const req = getMockReq() 98 | 99 | expect(req.unpipe).toBeDefined() 100 | expect(typeof req.unpipe).toBe('function') 101 | expect((req.unpipe as jest.Mock).getMockName()).toBe('unpipe mock default') 102 | }) 103 | 104 | test('req.unshift is a mocked function', () => { 105 | const req = getMockReq() 106 | 107 | expect(req.unshift).toBeDefined() 108 | expect(typeof req.unshift).toBe('function') 109 | expect((req.unshift as jest.Mock).getMockName()).toBe('unshift mock default') 110 | }) 111 | 112 | test('req.wrap is a mocked function', () => { 113 | const req = getMockReq() 114 | 115 | expect(req.wrap).toBeDefined() 116 | expect(typeof req.wrap).toBe('function') 117 | expect((req.wrap as jest.Mock).getMockName()).toBe('wrap mock default') 118 | }) 119 | 120 | test('req.push is a mocked function', () => { 121 | const req = getMockReq() 122 | 123 | expect(req.push).toBeDefined() 124 | expect(typeof req.push).toBe('function') 125 | expect((req.push as jest.Mock).getMockName()).toBe('push mock default') 126 | }) 127 | 128 | test('req._destroy is a mocked function', () => { 129 | const req = getMockReq() 130 | 131 | expect(req._destroy).toBeDefined() 132 | expect(typeof req._destroy).toBe('function') 133 | expect((req._destroy as jest.Mock).getMockName()).toBe('_destroy mock default') 134 | }) 135 | 136 | test('req.addListener is a mocked function', () => { 137 | const req = getMockReq() 138 | 139 | expect(req.addListener).toBeDefined() 140 | expect(typeof req.addListener).toBe('function') 141 | expect((req.addListener as jest.Mock).getMockName()).toBe('addListener mock default') 142 | }) 143 | 144 | test('req.emit is a mocked function', () => { 145 | const req = getMockReq() 146 | 147 | expect(req.emit).toBeDefined() 148 | expect(typeof req.emit).toBe('function') 149 | expect((req.emit as jest.Mock).getMockName()).toBe('emit mock default') 150 | }) 151 | 152 | test('req.on is a mocked function', () => { 153 | const req = getMockReq() 154 | 155 | expect(req.on).toBeDefined() 156 | expect(typeof req.on).toBe('function') 157 | expect((req.on as jest.Mock).getMockName()).toBe('on mock default') 158 | }) 159 | 160 | test('req.once is a mocked function', () => { 161 | const req = getMockReq() 162 | 163 | expect(req.once).toBeDefined() 164 | expect(typeof req.once).toBe('function') 165 | expect((req.once as jest.Mock).getMockName()).toBe('once mock default') 166 | }) 167 | 168 | test('req.prependListener is a mocked function', () => { 169 | const req = getMockReq() 170 | 171 | expect(req.prependListener).toBeDefined() 172 | expect(typeof req.prependListener).toBe('function') 173 | expect((req.prependListener as jest.Mock).getMockName()).toBe('prependListener mock default') 174 | }) 175 | 176 | test('req.prependOnceListener is a mocked function', () => { 177 | const req = getMockReq() 178 | 179 | expect(req.prependOnceListener).toBeDefined() 180 | expect(typeof req.prependOnceListener).toBe('function') 181 | expect((req.prependOnceListener as jest.Mock).getMockName()).toBe('prependOnceListener mock default') 182 | }) 183 | 184 | test('req.removeListener is a mocked function', () => { 185 | const req = getMockReq() 186 | 187 | expect(req.removeListener).toBeDefined() 188 | expect(typeof req.removeListener).toBe('function') 189 | expect((req.removeListener as jest.Mock).getMockName()).toBe('removeListener mock default') 190 | }) 191 | 192 | test('req.destroy is a mocked function', () => { 193 | const req = getMockReq() 194 | 195 | expect(req.destroy).toBeDefined() 196 | expect(typeof req.destroy).toBe('function') 197 | expect((req.destroy as jest.Mock).getMockName()).toBe('destroy mock default') 198 | }) 199 | }) 200 | -------------------------------------------------------------------------------- /src/test/request/github.test.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Request } from 'express' 3 | 4 | // Tested Module 5 | import getMockReq from '../../request/request' 6 | 7 | describe('request - GitHub Issues', () => { 8 | test('issue #6', () => { 9 | enum AppOS { 10 | Android = '1', 11 | } 12 | 13 | const req = getMockReq({ 14 | query: { 15 | os: AppOS.Android, 16 | sellerId: '12345', 17 | }, 18 | headers: { 19 | Authorization: 'valid-token', 20 | }, 21 | }) 22 | 23 | // req.query has the provided arguments 24 | expect(req.query).toBeDefined() 25 | expect(req.query).toBeInstanceOf(Object) 26 | expect(Object.keys(req.query).length).toBe(2) 27 | expect(req.query['os']).toBe(AppOS.Android) 28 | expect(req.query['sellerId']).toBe('12345') 29 | 30 | // req.headers has the provided arguments 31 | expect(req.headers).toBeDefined() 32 | expect(req.headers).toBeInstanceOf(Object) 33 | expect(Object.keys(req.headers).length).toBe(1) 34 | expect(req.headers['Authorization']).toBe('valid-token') 35 | }) 36 | 37 | test('issue #27', () => { 38 | interface CustomRequest extends Request { 39 | locals: unknown 40 | customProperty: string 41 | } 42 | 43 | const req = getMockReq({ 44 | locals: { var: 'hi there' }, 45 | customProperty: 'value', 46 | }) 47 | 48 | // req.locals has the provided arguments 49 | expect(req.locals).toBeDefined() 50 | expect(req.locals).toEqual({ var: 'hi there' }) 51 | 52 | // req.customProperty has the provided arguments 53 | expect(req.customProperty).toBeDefined() 54 | expect(req.customProperty).toEqual('value') 55 | }) 56 | }) 57 | -------------------------------------------------------------------------------- /src/test/request/provided/provided.event.EventEmitter.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedFunction } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockReq from '../../../request/request' 6 | 7 | describe('request - Provided for "event.EventEmitter" (accepts arguments and returns expected values)', () => { 8 | test('req.addListener can be provided', () => { 9 | const req = getMockReq({ addListener: providedFunction }) 10 | 11 | expect(req.addListener).toBeDefined() 12 | expect(req.addListener).toBe(providedFunction) 13 | }) 14 | 15 | test('req.on can be provided', () => { 16 | const req = getMockReq({ on: providedFunction }) 17 | 18 | expect(req.on).toBeDefined() 19 | expect(req.on).toBe(providedFunction) 20 | }) 21 | 22 | test('req.once can be provided', () => { 23 | const req = getMockReq({ once: providedFunction }) 24 | 25 | expect(req.once).toBeDefined() 26 | expect(req.once).toBe(providedFunction) 27 | }) 28 | 29 | test('req.removeListener can be provided', () => { 30 | const req = getMockReq({ removeListener: providedFunction }) 31 | 32 | expect(req.removeListener).toBeDefined() 33 | expect(req.removeListener).toBe(providedFunction) 34 | }) 35 | 36 | test('req.off can be provided', () => { 37 | const req = getMockReq({ off: providedFunction }) 38 | 39 | expect(req.off).toBeDefined() 40 | expect(req.off).toBe(providedFunction) 41 | }) 42 | 43 | test('req.removeAllListeners can be provided', () => { 44 | const req = getMockReq({ removeAllListeners: providedFunction }) 45 | 46 | expect(req.removeAllListeners).toBeDefined() 47 | expect(req.removeAllListeners).toBe(providedFunction) 48 | }) 49 | 50 | test('req.setMaxListeners can be provided', () => { 51 | const req = getMockReq({ setMaxListeners: providedFunction }) 52 | 53 | expect(req.setMaxListeners).toBeDefined() 54 | expect(req.setMaxListeners).toBe(providedFunction) 55 | }) 56 | 57 | test('req.getMaxListeners can be provided', () => { 58 | const req = getMockReq({ getMaxListeners: providedFunction }) 59 | 60 | expect(req.getMaxListeners).toBeDefined() 61 | expect(req.getMaxListeners).toBe(providedFunction) 62 | }) 63 | 64 | test('req.listeners can be provided', () => { 65 | const req = getMockReq({ listeners: providedFunction }) 66 | 67 | expect(req.listeners).toBeDefined() 68 | expect(req.listeners).toBe(providedFunction) 69 | }) 70 | 71 | test('req.rawListeners can be provided', () => { 72 | const req = getMockReq({ rawListeners: providedFunction }) 73 | 74 | expect(req.rawListeners).toBeDefined() 75 | expect(req.rawListeners).toBe(providedFunction) 76 | }) 77 | 78 | test('req.emit can be provided', () => { 79 | const req = getMockReq({ emit: providedFunction }) 80 | 81 | expect(req.emit).toBeDefined() 82 | expect(req.emit).toBe(providedFunction) 83 | }) 84 | 85 | test('req.listenerCount can be provided', () => { 86 | const req = getMockReq({ listenerCount: providedFunction }) 87 | 88 | expect(req.listenerCount).toBeDefined() 89 | expect(req.listenerCount).toBe(providedFunction) 90 | }) 91 | 92 | test('req.prependListener can be provided', () => { 93 | const req = getMockReq({ prependListener: providedFunction }) 94 | 95 | expect(req.prependListener).toBeDefined() 96 | expect(req.prependListener).toBe(providedFunction) 97 | }) 98 | 99 | test('req.prependOnceListener can be provided', () => { 100 | const req = getMockReq({ prependOnceListener: providedFunction }) 101 | 102 | expect(req.prependOnceListener).toBeDefined() 103 | expect(req.prependOnceListener).toBe(providedFunction) 104 | }) 105 | 106 | test('req.eventNames can be provided', () => { 107 | const req = getMockReq({ eventNames: providedFunction }) 108 | 109 | expect(req.eventNames).toBeDefined() 110 | expect(req.eventNames).toBe(providedFunction) 111 | }) 112 | }) 113 | -------------------------------------------------------------------------------- /src/test/request/provided/provided.express.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { 3 | providedApp, 4 | providedBoolean, 5 | providedFunction, 6 | providedMediaTypeArray, 7 | providedObject, 8 | providedParams, 9 | providedRes, 10 | providedString, 11 | providedStringArray, 12 | } from '../../helpers/provided' 13 | 14 | // Tested Module 15 | import getMockReq from '../../../request/request' 16 | 17 | describe('request - Provided for "express - Request" (accepts arguments and returns expected values)', () => { 18 | test('req.params can be provided', () => { 19 | const req = getMockReq({ params: providedParams }) 20 | 21 | expect(req.params).toBeDefined() 22 | expect(req.params).toBe(providedParams) 23 | }) 24 | 25 | test('req.query can be provided', () => { 26 | const req = getMockReq({ query: providedObject }) 27 | 28 | expect(req.query).toBeDefined() 29 | expect(req.query).toBe(providedObject) 30 | }) 31 | 32 | test('req.body can be provided', () => { 33 | const req = getMockReq({ body: providedObject }) 34 | 35 | expect(req.body).toBeDefined() 36 | expect(req.body).toBe(providedObject) 37 | }) 38 | 39 | test('req.cookies can be provided', () => { 40 | const req = getMockReq({ cookies: providedObject }) 41 | 42 | expect(req.cookies).toBeDefined() 43 | expect(req.cookies).toBe(providedObject) 44 | }) 45 | 46 | test('req.method can be provided', () => { 47 | const req = getMockReq({ method: providedString }) 48 | 49 | expect(req.method).toBeDefined() 50 | expect(req.method).toBe(providedString) 51 | }) 52 | 53 | test('req.protocol can be provided', () => { 54 | const req = getMockReq({ protocol: providedString }) 55 | 56 | expect(req.protocol).toBeDefined() 57 | expect(req.protocol).toBe(providedString) 58 | }) 59 | 60 | test('req.secure can be provided', () => { 61 | const req = getMockReq({ secure: providedBoolean }) 62 | 63 | expect(req.secure).toBeDefined() 64 | expect(req.secure).toBe(providedBoolean) 65 | }) 66 | 67 | test('req.ip can be provided', () => { 68 | const req = getMockReq({ ip: providedString }) 69 | 70 | expect(req.ip).toBeDefined() 71 | expect(req.ip).toBe(providedString) 72 | }) 73 | 74 | test('req.ips can be provided', () => { 75 | const req = getMockReq({ ips: providedStringArray }) 76 | 77 | expect(req.ips).toBeDefined() 78 | expect(req.ips).toBe(providedStringArray) 79 | }) 80 | 81 | test('req.subdomains can be provided', () => { 82 | const req = getMockReq({ subdomains: providedStringArray }) 83 | 84 | expect(req.subdomains).toBeDefined() 85 | expect(req.subdomains).toBe(providedStringArray) 86 | }) 87 | 88 | test('req.path can be provided', () => { 89 | const req = getMockReq({ path: providedString }) 90 | 91 | expect(req.path).toBeDefined() 92 | expect(req.path).toBe(providedString) 93 | }) 94 | 95 | test('req.hostname can be provided', () => { 96 | const req = getMockReq({ hostname: providedString }) 97 | 98 | expect(req.hostname).toBeDefined() 99 | expect(req.hostname).toBe(providedString) 100 | }) 101 | 102 | test('req.host can be provided', () => { 103 | const req = getMockReq({ host: providedString }) 104 | 105 | expect(req.host).toBeDefined() 106 | expect(req.host).toBe(providedString) 107 | }) 108 | 109 | test('req.fresh can be provided', () => { 110 | const req = getMockReq({ fresh: providedBoolean }) 111 | 112 | expect(req.fresh).toBeDefined() 113 | expect(req.fresh).toBe(providedBoolean) 114 | }) 115 | 116 | test('req.stale can be provided', () => { 117 | const req = getMockReq({ stale: providedBoolean }) 118 | 119 | expect(req.stale).toBeDefined() 120 | expect(req.stale).toBe(providedBoolean) 121 | }) 122 | 123 | test('req.xhr can be provided', () => { 124 | const req = getMockReq({ xhr: providedBoolean }) 125 | 126 | expect(req.xhr).toBeDefined() 127 | expect(req.xhr).toBe(providedBoolean) 128 | }) 129 | 130 | test('req.route can be provided', () => { 131 | const req = getMockReq({ route: providedObject }) 132 | 133 | expect(req.route).toBeDefined() 134 | expect(req.route).toBe(providedObject) 135 | }) 136 | 137 | test('req.signedCookies can be provided', () => { 138 | const req = getMockReq({ signedCookies: providedObject }) 139 | 140 | expect(req.signedCookies).toBeDefined() 141 | expect(req.signedCookies).toBe(providedObject) 142 | }) 143 | 144 | test('req.originalUrl can be provided', () => { 145 | const req = getMockReq({ originalUrl: providedString }) 146 | 147 | expect(req.originalUrl).toBeDefined() 148 | expect(req.originalUrl).toBe(providedString) 149 | }) 150 | 151 | test('req.url can be provided', () => { 152 | const req = getMockReq({ url: providedString }) 153 | 154 | expect(req.url).toBeDefined() 155 | expect(req.url).toBe(providedString) 156 | }) 157 | 158 | test('req.baseUrl can be provided', () => { 159 | const req = getMockReq({ baseUrl: providedString }) 160 | 161 | expect(req.baseUrl).toBeDefined() 162 | expect(req.baseUrl).toBe(providedString) 163 | }) 164 | 165 | test('req.accepted can be provided', () => { 166 | const req = getMockReq({ accepted: providedMediaTypeArray }) 167 | 168 | expect(req.accepted).toBeDefined() 169 | expect(req.accepted).toBe(providedMediaTypeArray) 170 | }) 171 | 172 | test('req.get can be provided', () => { 173 | const req = getMockReq({ get: providedFunction }) 174 | 175 | expect(req.get).toBeDefined() 176 | expect(req.get).toBe(providedFunction) 177 | }) 178 | 179 | test('req.header can be provided', () => { 180 | const req = getMockReq({ header: providedFunction }) 181 | 182 | expect(req.header).toBeDefined() 183 | expect(req.header).toBe(providedFunction) 184 | }) 185 | 186 | test('req.accepts can be provided', () => { 187 | const req = getMockReq({ accepts: providedFunction }) 188 | 189 | expect(req.accepts).toBeDefined() 190 | expect(req.accepts).toBe(providedFunction) 191 | }) 192 | 193 | test('req.acceptsCharsets can be provided', () => { 194 | const req = getMockReq({ acceptsCharsets: providedFunction }) 195 | 196 | expect(req.acceptsCharsets).toBeDefined() 197 | expect(req.acceptsCharsets).toBe(providedFunction) 198 | }) 199 | 200 | test('req.acceptsEncodings can be provided', () => { 201 | const req = getMockReq({ acceptsEncodings: providedFunction }) 202 | 203 | expect(req.acceptsEncodings).toBeDefined() 204 | expect(req.acceptsEncodings).toBe(providedFunction) 205 | }) 206 | 207 | test('req.acceptsLanguages can be provided', () => { 208 | const req = getMockReq({ acceptsLanguages: providedFunction }) 209 | 210 | expect(req.acceptsLanguages).toBeDefined() 211 | expect(req.acceptsLanguages).toBe(providedFunction) 212 | }) 213 | 214 | test('req.range can be provided', () => { 215 | const req = getMockReq({ range: providedFunction }) 216 | 217 | expect(req.range).toBeDefined() 218 | expect(req.range).toBe(providedFunction) 219 | }) 220 | 221 | test('req.is can be provided', () => { 222 | const req = getMockReq({ is: providedFunction }) 223 | 224 | expect(req.is).toBeDefined() 225 | expect(req.is).toBe(providedFunction) 226 | }) 227 | 228 | test('req.app can be provided', () => { 229 | const req = getMockReq({ app: providedApp }) 230 | 231 | expect(req.app).toBeDefined() 232 | expect(req.app).toBe(providedApp) 233 | }) 234 | 235 | test('req.res can be provided', () => { 236 | const req = getMockReq({ res: providedRes }) 237 | 238 | expect(req.res).toBeDefined() 239 | expect(req.res).toBe(providedRes) 240 | }) 241 | 242 | test('req.next can be provided', () => { 243 | const req = getMockReq({ next: providedFunction }) 244 | 245 | expect(req.next).toBeDefined() 246 | expect(req.next).toBe(providedFunction) 247 | }) 248 | }) 249 | -------------------------------------------------------------------------------- /src/test/request/provided/provided.http.IncomingMessage.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { 3 | providedBoolean, 4 | providedFunction, 5 | providedNumber, 6 | providedParams, 7 | providedSocket, 8 | providedString, 9 | providedStringArray, 10 | providedStringObject, 11 | } from '../../helpers/provided' 12 | 13 | // Tested Module 14 | import getMockReq from '../../../request/request' 15 | 16 | describe('request - Provided for "http.IncomingMessage" (accepts arguments and returns expected values)', () => { 17 | test('req.aborted can be provided', () => { 18 | const req = getMockReq({ aborted: providedBoolean }) 19 | 20 | expect(req.aborted).toBeDefined() 21 | expect(req.aborted).toBe(providedBoolean) 22 | }) 23 | 24 | test('req.httpVersion can be provided', () => { 25 | const req = getMockReq({ httpVersion: providedString }) 26 | 27 | expect(req.httpVersion).toBeDefined() 28 | expect(req.httpVersion).toBe(providedString) 29 | }) 30 | 31 | test('req.httpVersionMajor can be provided', () => { 32 | const req = getMockReq({ httpVersionMajor: providedNumber }) 33 | 34 | expect(req.httpVersionMajor).toBeDefined() 35 | expect(req.httpVersionMajor).toBe(providedNumber) 36 | }) 37 | 38 | test('req.httpVersionMinor can be provided', () => { 39 | const req = getMockReq({ httpVersionMinor: providedNumber }) 40 | 41 | expect(req.httpVersionMinor).toBeDefined() 42 | expect(req.httpVersionMinor).toBe(providedNumber) 43 | }) 44 | 45 | test('req.complete can be provided', () => { 46 | const req = getMockReq({ complete: providedBoolean }) 47 | 48 | expect(req.complete).toBeDefined() 49 | expect(req.complete).toBe(providedBoolean) 50 | }) 51 | 52 | test('req.connection can be provided', () => { 53 | const req = getMockReq({ connection: providedSocket }) 54 | 55 | expect(req.connection).toBeDefined() 56 | expect(req.connection).toBe(providedSocket) 57 | }) 58 | 59 | test('req.socket can be provided', () => { 60 | const req = getMockReq({ socket: providedSocket }) 61 | 62 | expect(req.socket).toBeDefined() 63 | expect(req.socket).toBe(providedSocket) 64 | }) 65 | 66 | test('req.headers can be provided', () => { 67 | const req = getMockReq({ headers: providedParams }) 68 | 69 | expect(req.headers).toBeDefined() 70 | expect(req.headers).toBe(providedParams) 71 | }) 72 | 73 | test('req.rawHeaders can be provided', () => { 74 | const req = getMockReq({ rawHeaders: providedStringArray }) 75 | 76 | expect(req.rawHeaders).toBeDefined() 77 | expect(req.rawHeaders).toBe(providedStringArray) 78 | }) 79 | 80 | test('req.trailers can be provided', () => { 81 | const req = getMockReq({ trailers: providedStringObject }) 82 | 83 | expect(req.trailers).toBeDefined() 84 | expect(req.trailers).toBe(providedStringObject) 85 | }) 86 | 87 | test('req.rawTrailers can be provided', () => { 88 | const req = getMockReq({ rawTrailers: providedStringArray }) 89 | 90 | expect(req.rawTrailers).toBeDefined() 91 | expect(req.rawTrailers).toBe(providedStringArray) 92 | }) 93 | 94 | test('req.setTimeout can be provided', () => { 95 | const req = getMockReq({ setTimeout: providedFunction }) 96 | 97 | expect(req.setTimeout).toBeDefined() 98 | expect(req.setTimeout).toBe(providedFunction) 99 | }) 100 | 101 | test('req.statusCode can be provided', () => { 102 | const req = getMockReq({ statusCode: providedNumber }) 103 | 104 | expect(req.statusCode).toBeDefined() 105 | expect(req.statusCode).toBe(providedNumber) 106 | }) 107 | 108 | test('req.statusMessage can be provided', () => { 109 | const req = getMockReq({ statusMessage: providedString }) 110 | 111 | expect(req.statusMessage).toBeDefined() 112 | expect(req.statusMessage).toBe(providedString) 113 | }) 114 | 115 | test('req.destroy can be provided', () => { 116 | const req = getMockReq({ destroy: providedFunction }) 117 | 118 | expect(req.destroy).toBeDefined() 119 | expect(req.destroy).toBe(providedFunction) 120 | }) 121 | }) 122 | -------------------------------------------------------------------------------- /src/test/request/provided/provided.stream.Readable.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedBoolean, providedFunction, providedNumber } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockReq from '../../../request/request' 6 | 7 | describe('request - Provided for "stream.Readable" (accepts arguments and returns expected values)', () => { 8 | test('req.readable can be provided', () => { 9 | const req = getMockReq({ readable: providedBoolean }) 10 | 11 | expect(req.readable).toBeDefined() 12 | expect(req.readable).toBe(providedBoolean) 13 | }) 14 | 15 | test('req.readableHighWaterMark can be provided', () => { 16 | const req = getMockReq({ readableHighWaterMark: providedNumber }) 17 | 18 | expect(req.readableHighWaterMark).toBeDefined() 19 | expect(req.readableHighWaterMark).toBe(providedNumber) 20 | }) 21 | 22 | test('req.readableLength can be provided', () => { 23 | const req = getMockReq({ readableLength: providedNumber }) 24 | 25 | expect(req.readableLength).toBeDefined() 26 | expect(req.readableLength).toBe(providedNumber) 27 | }) 28 | 29 | test('req.readableObjectMode can be provided', () => { 30 | const req = getMockReq({ readableObjectMode: providedBoolean }) 31 | 32 | expect(req.readableObjectMode).toBeDefined() 33 | expect(req.readableObjectMode).toBe(providedBoolean) 34 | }) 35 | 36 | test('req.destroyed can be provided', () => { 37 | const req = getMockReq({ destroyed: providedBoolean }) 38 | 39 | expect(req.destroyed).toBeDefined() 40 | expect(req.destroyed).toBe(providedBoolean) 41 | }) 42 | 43 | test('req.constructor can be provided', () => { 44 | const req = getMockReq({ constructor: providedFunction }) 45 | 46 | expect(req.constructor).toBeDefined() 47 | expect(req.constructor).toBe(providedFunction) 48 | }) 49 | 50 | test('req._read can be provided', () => { 51 | const req = getMockReq({ _read: providedFunction }) 52 | 53 | expect(req._read).toBeDefined() 54 | expect(req._read).toBe(providedFunction) 55 | }) 56 | 57 | test('req.read can be provided', () => { 58 | const req = getMockReq({ read: providedFunction }) 59 | 60 | expect(req.read).toBeDefined() 61 | expect(req.read).toBe(providedFunction) 62 | }) 63 | 64 | test('req.setEncoding can be provided', () => { 65 | const req = getMockReq({ setEncoding: providedFunction }) 66 | 67 | expect(req.setEncoding).toBeDefined() 68 | expect(req.setEncoding).toBe(providedFunction) 69 | }) 70 | 71 | test('req.pause can be provided', () => { 72 | const req = getMockReq({ pause: providedFunction }) 73 | 74 | expect(req.pause).toBeDefined() 75 | expect(req.pause).toBe(providedFunction) 76 | }) 77 | 78 | test('req.resume can be provided', () => { 79 | const req = getMockReq({ resume: providedFunction }) 80 | 81 | expect(req.resume).toBeDefined() 82 | expect(req.resume).toBe(providedFunction) 83 | }) 84 | 85 | test('req.isPaused can be provided', () => { 86 | const req = getMockReq({ isPaused: providedFunction }) 87 | 88 | expect(req.isPaused).toBeDefined() 89 | expect(req.isPaused).toBe(providedFunction) 90 | }) 91 | 92 | test('req.unpipe can be provided', () => { 93 | const req = getMockReq({ unpipe: providedFunction }) 94 | 95 | expect(req.unpipe).toBeDefined() 96 | expect(req.unpipe).toBe(providedFunction) 97 | }) 98 | 99 | test('req.unshift can be provided', () => { 100 | const req = getMockReq({ unshift: providedFunction }) 101 | 102 | expect(req.unshift).toBeDefined() 103 | expect(req.unshift).toBe(providedFunction) 104 | }) 105 | 106 | test('req.wrap can be provided', () => { 107 | const req = getMockReq({ wrap: providedFunction }) 108 | 109 | expect(req.wrap).toBeDefined() 110 | expect(req.wrap).toBe(providedFunction) 111 | }) 112 | 113 | test('req.push can be provided', () => { 114 | const req = getMockReq({ push: providedFunction }) 115 | 116 | expect(req.push).toBeDefined() 117 | expect(req.push).toBe(providedFunction) 118 | }) 119 | 120 | test('req._destroy can be provided', () => { 121 | const req = getMockReq({ _destroy: providedFunction }) 122 | 123 | expect(req._destroy).toBeDefined() 124 | expect(req._destroy).toBe(providedFunction) 125 | }) 126 | 127 | test('req.addListener can be provided', () => { 128 | const req = getMockReq({ addListener: providedFunction }) 129 | 130 | expect(req.addListener).toBeDefined() 131 | expect(req.addListener).toBe(providedFunction) 132 | }) 133 | 134 | test('req.emit can be provided', () => { 135 | const req = getMockReq({ emit: providedFunction }) 136 | 137 | expect(req.emit).toBeDefined() 138 | expect(req.emit).toBe(providedFunction) 139 | }) 140 | 141 | test('req.on can be provided', () => { 142 | const req = getMockReq({ on: providedFunction }) 143 | 144 | expect(req.on).toBeDefined() 145 | expect(req.on).toBe(providedFunction) 146 | }) 147 | 148 | test('req.once can be provided', () => { 149 | const req = getMockReq({ once: providedFunction }) 150 | 151 | expect(req.once).toBeDefined() 152 | expect(req.once).toBe(providedFunction) 153 | }) 154 | 155 | test('req.prependListener can be provided', () => { 156 | const req = getMockReq({ prependListener: providedFunction }) 157 | 158 | expect(req.prependListener).toBeDefined() 159 | expect(req.prependListener).toBe(providedFunction) 160 | }) 161 | 162 | test('req.prependOnceListener can be provided', () => { 163 | const req = getMockReq({ prependOnceListener: providedFunction }) 164 | 165 | expect(req.prependOnceListener).toBeDefined() 166 | expect(req.prependOnceListener).toBe(providedFunction) 167 | }) 168 | 169 | test('req.removeListener can be provided', () => { 170 | const req = getMockReq({ removeListener: providedFunction }) 171 | 172 | expect(req.removeListener).toBeDefined() 173 | expect(req.removeListener).toBe(providedFunction) 174 | }) 175 | 176 | test('req.destroy can be provided', () => { 177 | const req = getMockReq({ destroy: providedFunction }) 178 | 179 | expect(req.destroy).toBeDefined() 180 | expect(req.destroy).toBe(providedFunction) 181 | }) 182 | }) 183 | -------------------------------------------------------------------------------- /src/test/request/provided/provided.test.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Request } from 'express' 3 | 4 | // Tested Module 5 | import getMockReq from '../../../request/request' 6 | 7 | describe('request - Provided (accepts arguments and returns expected values)', () => { 8 | test('it allows custom properties', () => { 9 | interface User { 10 | id: string 11 | name: string 12 | } 13 | 14 | interface CustomRequest extends Request { 15 | user: User 16 | } 17 | 18 | const mockUser: User = { 19 | id: '123', 20 | name: 'Bob', 21 | } 22 | 23 | const req = getMockReq({ 24 | user: mockUser, 25 | query: { 26 | id: '123', 27 | limit: '10', 28 | page: '2', 29 | }, 30 | }) 31 | 32 | // req.user has the provided arguments 33 | expect(req.user).toBeDefined() 34 | expect(req.user).toBe(mockUser) 35 | 36 | // req.query has the provided arguments 37 | expect(req.query).toBeDefined() 38 | expect(req.query).toBeInstanceOf(Object) 39 | expect(Object.keys(req.query).length).toBe(3) 40 | expect(req.query['id']).toBe('123') 41 | expect(req.query['limit']).toBe('10') 42 | expect(req.query['page']).toBe('2') 43 | }) 44 | }) 45 | -------------------------------------------------------------------------------- /src/test/request/request.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockReq from '../../request/request' 3 | 4 | const DEFAULT_REQ_KEY_LENGTH = 80 5 | 6 | describe('request - General', () => { 7 | test('it returns expected object', () => { 8 | const req = getMockReq() 9 | 10 | expect(req).toBeDefined() 11 | expect(req).toBeInstanceOf(Object) 12 | expect(Object.keys(req).length).toBe(DEFAULT_REQ_KEY_LENGTH) 13 | }) 14 | }) 15 | -------------------------------------------------------------------------------- /src/test/response/defaults/defaults.event.EventEmitter.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockRes from '../../../response/response' 3 | 4 | describe('response - Defaults for "event.EventEmitter" (accepts no arguments and return default values)', () => { 5 | test('res.addListener is a mocked function', () => { 6 | const { res } = getMockRes() 7 | 8 | expect(res.addListener).toBeDefined() 9 | expect(typeof res.addListener).toBe('function') 10 | expect((res.addListener as jest.Mock).getMockName()).toBe('addListener mock default') 11 | }) 12 | 13 | test('res.addListener is chainable', () => { 14 | const { res } = getMockRes() 15 | 16 | // it returns itself (is chainable) 17 | expect(res.addListener('test', jest.fn())).toBe(res) 18 | }) 19 | 20 | test('res.on is a mocked function', () => { 21 | const { res } = getMockRes() 22 | 23 | expect(res.on).toBeDefined() 24 | expect(typeof res.on).toBe('function') 25 | expect((res.on as jest.Mock).getMockName()).toBe('on mock default') 26 | }) 27 | 28 | test('res.on is chainable', () => { 29 | const { res } = getMockRes() 30 | 31 | // it returns itself (is chainable) 32 | expect(res.on('test', jest.fn())).toBe(res) 33 | }) 34 | 35 | test('res.once is a mocked function', () => { 36 | const { res } = getMockRes() 37 | 38 | expect(res.once).toBeDefined() 39 | expect(typeof res.once).toBe('function') 40 | expect((res.once as jest.Mock).getMockName()).toBe('once mock default') 41 | }) 42 | 43 | test('res.once is chainable', () => { 44 | const { res } = getMockRes() 45 | 46 | // it returns itself (is chainable) 47 | expect(res.once('test', jest.fn())).toBe(res) 48 | }) 49 | 50 | test('res.removeListener is a mocked function', () => { 51 | const { res } = getMockRes() 52 | 53 | expect(res.removeListener).toBeDefined() 54 | expect(typeof res.removeListener).toBe('function') 55 | expect((res.removeListener as jest.Mock).getMockName()).toBe('removeListener mock default') 56 | }) 57 | 58 | test('res.removeListener is chainable', () => { 59 | const { res } = getMockRes() 60 | 61 | // it returns itself (is chainable) 62 | expect(res.removeListener('test', jest.fn())).toBe(res) 63 | }) 64 | 65 | test('res.off is a mocked function', () => { 66 | const { res } = getMockRes() 67 | 68 | expect(res.off).toBeDefined() 69 | expect(typeof res.off).toBe('function') 70 | expect((res.off as jest.Mock).getMockName()).toBe('off mock default') 71 | }) 72 | 73 | test('res.off is chainable', () => { 74 | const { res } = getMockRes() 75 | 76 | // it returns itself (is chainable) 77 | expect(res.off('test', jest.fn())).toBe(res) 78 | }) 79 | 80 | test('res.removeAllListeners is a mocked function', () => { 81 | const { res } = getMockRes() 82 | 83 | expect(res.removeAllListeners).toBeDefined() 84 | expect(typeof res.removeAllListeners).toBe('function') 85 | expect((res.removeAllListeners as jest.Mock).getMockName()).toBe('removeAllListeners mock default') 86 | }) 87 | 88 | test('res.removeAllListeners is chainable', () => { 89 | const { res } = getMockRes() 90 | 91 | // it returns itself (is chainable) 92 | expect(res.removeAllListeners('test')).toBe(res) 93 | }) 94 | 95 | test('res.setMaxListeners is a mocked function', () => { 96 | const { res } = getMockRes() 97 | 98 | expect(res.setMaxListeners).toBeDefined() 99 | expect(typeof res.setMaxListeners).toBe('function') 100 | expect((res.setMaxListeners as jest.Mock).getMockName()).toBe('setMaxListeners mock default') 101 | }) 102 | 103 | test('res.setMaxListeners is chainable', () => { 104 | const { res } = getMockRes() 105 | 106 | // it returns itself (is chainable) 107 | expect(res.setMaxListeners(10)).toBe(res) 108 | }) 109 | 110 | test('res.getMaxListeners is a mocked function', () => { 111 | const { res } = getMockRes() 112 | 113 | expect(res.getMaxListeners).toBeDefined() 114 | expect(typeof res.getMaxListeners).toBe('function') 115 | expect((res.getMaxListeners as jest.Mock).getMockName()).toBe('getMaxListeners mock default') 116 | }) 117 | 118 | test('res.getMaxListeners is not chainable', () => { 119 | const { res } = getMockRes() 120 | 121 | // it does not return itself (is not chainable) 122 | expect(res.getMaxListeners()).toBeUndefined() 123 | }) 124 | 125 | test('res.listeners is a mocked function', () => { 126 | const { res } = getMockRes() 127 | 128 | expect(res.listeners).toBeDefined() 129 | expect(typeof res.listeners).toBe('function') 130 | expect((res.listeners as jest.Mock).getMockName()).toBe('listeners mock default') 131 | }) 132 | 133 | test('res.listeners is not chainable', () => { 134 | const { res } = getMockRes() 135 | 136 | // it does not return itself (is not chainable) 137 | expect(res.listeners('test')).toBeUndefined() 138 | }) 139 | 140 | test('res.rawListeners is a mocked function', () => { 141 | const { res } = getMockRes() 142 | 143 | expect(res.rawListeners).toBeDefined() 144 | expect(typeof res.rawListeners).toBe('function') 145 | expect((res.rawListeners as jest.Mock).getMockName()).toBe('rawListeners mock default') 146 | }) 147 | 148 | test('res.rawListeners is not chainable', () => { 149 | const { res } = getMockRes() 150 | 151 | // it does not return itself (is not chainable) 152 | expect(res.rawListeners('test')).toBeUndefined() 153 | }) 154 | 155 | test('res.emit is a mocked function', () => { 156 | const { res } = getMockRes() 157 | 158 | expect(res.emit).toBeDefined() 159 | expect(typeof res.emit).toBe('function') 160 | expect((res.emit as jest.Mock).getMockName()).toBe('emit mock default') 161 | }) 162 | 163 | test('res.emit is not chainable', () => { 164 | const { res } = getMockRes() 165 | 166 | // it does not return itself (is not chainable) 167 | expect(res.emit('test')).toBeUndefined() 168 | }) 169 | 170 | test('res.listenerCount is a mocked function', () => { 171 | const { res } = getMockRes() 172 | 173 | expect(res.listenerCount).toBeDefined() 174 | expect(typeof res.listenerCount).toBe('function') 175 | expect((res.listenerCount as jest.Mock).getMockName()).toBe('listenerCount mock default') 176 | }) 177 | 178 | test('res.listenerCount is not chainable', () => { 179 | const { res } = getMockRes() 180 | 181 | // it does not return itself (is not chainable) 182 | expect(res.listenerCount('test')).toBeUndefined() 183 | }) 184 | 185 | test('res.prependListener is a mocked function', () => { 186 | const { res } = getMockRes() 187 | 188 | expect(res.prependListener).toBeDefined() 189 | expect(typeof res.prependListener).toBe('function') 190 | expect((res.prependListener as jest.Mock).getMockName()).toBe('prependListener mock default') 191 | }) 192 | 193 | test('res.prependListener is chainable', () => { 194 | const { res } = getMockRes() 195 | 196 | // it returns itself (is chainable) 197 | expect(res.prependListener('test', jest.fn())).toBe(res) 198 | }) 199 | 200 | test('res.prependOnceListener is a mocked function', () => { 201 | const { res } = getMockRes() 202 | 203 | expect(res.prependOnceListener).toBeDefined() 204 | expect(typeof res.prependOnceListener).toBe('function') 205 | expect((res.prependOnceListener as jest.Mock).getMockName()).toBe('prependOnceListener mock default') 206 | }) 207 | 208 | test('res.prependOnceListener is chainable', () => { 209 | const { res } = getMockRes() 210 | 211 | // it returns itself (is chainable) 212 | expect(res.prependOnceListener('test', jest.fn())).toBe(res) 213 | }) 214 | 215 | test('res.eventNames is a mocked function', () => { 216 | const { res } = getMockRes() 217 | 218 | expect(res.eventNames).toBeDefined() 219 | expect(typeof res.eventNames).toBe('function') 220 | expect((res.eventNames as jest.Mock).getMockName()).toBe('eventNames mock default') 221 | }) 222 | 223 | test('res.eventNames is not chainable', () => { 224 | const { res } = getMockRes() 225 | 226 | // it does not return itself (is not chainable) 227 | expect(res.eventNames()).toBeUndefined() 228 | }) 229 | }) 230 | -------------------------------------------------------------------------------- /src/test/response/defaults/defaults.express.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockRes from '../../../response/response' 3 | 4 | describe('response - Defaults from "express.Express" (accepts no arguments and return default values)', () => { 5 | test('res.status is a mocked function', () => { 6 | const { res } = getMockRes() 7 | 8 | expect(res.status).toBeDefined() 9 | expect(typeof res.status).toBe('function') 10 | expect((res.status as jest.Mock).getMockName()).toBe('status mock default') 11 | }) 12 | 13 | test('res.status is chainable', () => { 14 | const { res } = getMockRes() 15 | 16 | // it returns itself (is chainable) 17 | expect(res.status(123)).toBe(res) 18 | }) 19 | 20 | test('res.sendStatus is a mocked function', () => { 21 | const { res } = getMockRes() 22 | 23 | expect(res.sendStatus).toBeDefined() 24 | expect(typeof res.sendStatus).toBe('function') 25 | expect((res.sendStatus as jest.Mock).getMockName()).toBe('sendStatus mock default') 26 | }) 27 | 28 | test('res.sendStatus is chainable', () => { 29 | const { res } = getMockRes() 30 | 31 | // it returns itself (is chainable) 32 | expect(res.sendStatus(123)).toBe(res) 33 | }) 34 | 35 | test('res.links is a mocked function', () => { 36 | const { res } = getMockRes() 37 | 38 | expect(res.links).toBeDefined() 39 | expect(typeof res.links).toBe('function') 40 | expect((res.links as jest.Mock).getMockName()).toBe('links mock default') 41 | }) 42 | 43 | test('res.links is chainable', () => { 44 | const { res } = getMockRes() 45 | 46 | // it returns itself (is chainable) 47 | expect(res.links(1)).toBe(res) 48 | }) 49 | 50 | test('res.send is a mocked function', () => { 51 | const { res } = getMockRes() 52 | 53 | expect(res.send).toBeDefined() 54 | expect(typeof res.send).toBe('function') 55 | expect((res.send as jest.Mock).getMockName()).toBe('send mock default') 56 | }) 57 | 58 | test('res.send is chainable', () => { 59 | const { res } = getMockRes() 60 | 61 | // it returns itself (is chainable) 62 | expect(res.send()).toBe(res) 63 | }) 64 | 65 | test('res.json is a mocked function', () => { 66 | const { res } = getMockRes() 67 | 68 | expect(res.json).toBeDefined() 69 | expect(typeof res.json).toBe('function') 70 | expect((res.json as jest.Mock).getMockName()).toBe('json mock default') 71 | }) 72 | 73 | test('res.json is chainable', () => { 74 | const { res } = getMockRes() 75 | 76 | // it returns itself (is chainable) 77 | expect(res.json()).toBe(res) 78 | }) 79 | 80 | test('res.jsonp is a mocked function', () => { 81 | const { res } = getMockRes() 82 | 83 | expect(res.jsonp).toBeDefined() 84 | expect(typeof res.jsonp).toBe('function') 85 | expect((res.jsonp as jest.Mock).getMockName()).toBe('jsonp mock default') 86 | }) 87 | 88 | test('res.jsonp is chainable', () => { 89 | const { res } = getMockRes() 90 | 91 | // it returns itself (is chainable) 92 | expect(res.jsonp()).toBe(res) 93 | }) 94 | 95 | test('res.sendFile is a mocked function', () => { 96 | const { res } = getMockRes() 97 | 98 | expect(res.sendFile).toBeDefined() 99 | expect(typeof res.sendFile).toBe('function') 100 | expect((res.sendFile as jest.Mock).getMockName()).toBe('sendFile mock default') 101 | }) 102 | 103 | test('res.sendFile function is not chainable', () => { 104 | const { res } = getMockRes() 105 | 106 | // it does not return itself (is not chainable) 107 | expect(res.sendFile('test')).toBeUndefined() 108 | }) 109 | 110 | test('res.download is a mocked function', () => { 111 | const { res } = getMockRes() 112 | 113 | expect(res.download).toBeDefined() 114 | expect(typeof res.download).toBe('function') 115 | expect((res.download as jest.Mock).getMockName()).toBe('download mock default') 116 | }) 117 | 118 | test('res.download function is not chainable', () => { 119 | const { res } = getMockRes() 120 | 121 | // it does not return itself (is not chainable) 122 | expect(res.download('test')).toBeUndefined() 123 | }) 124 | 125 | test('res.contentType is a mocked function', () => { 126 | const { res } = getMockRes() 127 | 128 | expect(res.contentType).toBeDefined() 129 | expect(typeof res.contentType).toBe('function') 130 | expect((res.contentType as jest.Mock).getMockName()).toBe('contentType mock default') 131 | }) 132 | 133 | test('res.contentType is chainable', () => { 134 | const { res } = getMockRes() 135 | 136 | // it returns itself (is chainable) 137 | expect(res.contentType('test')).toBe(res) 138 | }) 139 | 140 | test('res.type is a mocked function', () => { 141 | const { res } = getMockRes() 142 | 143 | expect(res.type).toBeDefined() 144 | expect(typeof res.type).toBe('function') 145 | expect((res.type as jest.Mock).getMockName()).toBe('type mock default') 146 | }) 147 | 148 | test('res.type is chainable', () => { 149 | const { res } = getMockRes() 150 | 151 | // it returns itself (is chainable) 152 | expect(res.type('test')).toBe(res) 153 | }) 154 | 155 | test('res.format is a mocked function ', () => { 156 | const { res } = getMockRes() 157 | 158 | expect(res.format).toBeDefined() 159 | expect(typeof res.format).toBe('function') 160 | expect((res.format as jest.Mock).getMockName()).toBe('format mock default') 161 | }) 162 | 163 | test('res.format is chainable', () => { 164 | const { res } = getMockRes() 165 | 166 | expect(res.format('test')).toBe(res) 167 | }) 168 | 169 | test('res.attachment is a mocked function', () => { 170 | const { res } = getMockRes() 171 | 172 | expect(res.attachment).toBeDefined() 173 | expect(typeof res.attachment).toBe('function') 174 | expect((res.attachment as jest.Mock).getMockName()).toBe('attachment mock default') 175 | }) 176 | 177 | test('res.attachment is chainable', () => { 178 | const { res } = getMockRes() 179 | 180 | // it returns itself (is chainable) 181 | expect(res.attachment()).toBe(res) 182 | }) 183 | 184 | test('res.set is a mocked function', () => { 185 | const { res } = getMockRes() 186 | 187 | expect(res.set).toBeDefined() 188 | expect(typeof res.set).toBe('function') 189 | expect((res.set as jest.Mock).getMockName()).toBe('set mock default') 190 | }) 191 | 192 | test('res.set is chainable', () => { 193 | const { res } = getMockRes() 194 | 195 | // it returns itself (is chainable) 196 | expect(res.set('test')).toBe(res) 197 | }) 198 | 199 | test('res.header is a mocked function', () => { 200 | const { res } = getMockRes() 201 | 202 | expect(res.header).toBeDefined() 203 | expect(typeof res.header).toBe('function') 204 | expect((res.header as jest.Mock).getMockName()).toBe('header mock default') 205 | }) 206 | 207 | test('res.header is chainable', () => { 208 | const { res } = getMockRes() 209 | 210 | // it returns itself (is chainable) 211 | expect(res.header('test')).toBe(res) 212 | }) 213 | 214 | test('res.headersSent is a boolean', () => { 215 | const { res } = getMockRes() 216 | 217 | expect(res.headersSent).toBeDefined() 218 | expect(res.headersSent).toBe(false) 219 | }) 220 | 221 | test('res.get is a mocked function', () => { 222 | const { res } = getMockRes() 223 | 224 | expect(res.get).toBeDefined() 225 | expect(typeof res.get).toBe('function') 226 | expect((res.get as jest.Mock).getMockName()).toBe('get mock default') 227 | }) 228 | 229 | test('res.get is not chainable', () => { 230 | const { res } = getMockRes() 231 | 232 | // it does not return itself (is not chainable) 233 | expect(res.get('test')).toBeUndefined() 234 | }) 235 | 236 | test('res.clearCookie is a mocked function', () => { 237 | const { res } = getMockRes() 238 | 239 | expect(res.clearCookie).toBeDefined() 240 | expect(typeof res.clearCookie).toBe('function') 241 | expect((res.clearCookie as jest.Mock).getMockName()).toBe('clearCookie mock default') 242 | }) 243 | 244 | test('res.clearCookie is chainable', () => { 245 | const { res } = getMockRes() 246 | 247 | // it returns itself (is chainable) 248 | expect(res.clearCookie('test')).toBe(res) 249 | }) 250 | 251 | test('res.cookie is a mocked function ', () => { 252 | const { res } = getMockRes() 253 | 254 | expect(res.cookie).toBeDefined() 255 | expect(typeof res.cookie).toBe('function') 256 | expect((res.cookie as jest.Mock).getMockName()).toBe('cookie mock default') 257 | }) 258 | 259 | test('res.cookie is chainable', () => { 260 | const { res } = getMockRes() 261 | 262 | // it returns itself (is chainable) 263 | expect(res.cookie('test', 'test two')).toBe(res) 264 | }) 265 | 266 | test('res.location is a mocked function', () => { 267 | const { res } = getMockRes() 268 | 269 | expect(res.location).toBeDefined() 270 | expect(typeof res.location).toBe('function') 271 | expect((res.location as jest.Mock).getMockName()).toBe('location mock default') 272 | }) 273 | 274 | test('res.location is chainable', () => { 275 | const { res } = getMockRes() 276 | 277 | // it returns itself (is chainable) 278 | expect(res.location('test')).toBe(res) 279 | }) 280 | 281 | test('res.redirect is a mocked function', () => { 282 | const { res } = getMockRes() 283 | 284 | expect(res.redirect).toBeDefined() 285 | expect(typeof res.redirect).toBe('function') 286 | expect((res.redirect as jest.Mock).getMockName()).toBe('redirect mock default') 287 | }) 288 | 289 | test('res.redirect is not chainable', () => { 290 | const { res } = getMockRes() 291 | 292 | // it does not return itself (is not chainable) 293 | expect(res.redirect('test')).toBeUndefined() 294 | }) 295 | 296 | test('res.render is a mocked function', () => { 297 | const { res } = getMockRes() 298 | 299 | expect(res.render).toBeDefined() 300 | expect(typeof res.render).toBe('function') 301 | expect((res.render as jest.Mock).getMockName()).toBe('render mock default') 302 | }) 303 | 304 | test('res.render is not chainable', () => { 305 | const { res } = getMockRes() 306 | 307 | // it does not return itself (is not chainable) 308 | expect(res.render('test')).toBeUndefined() 309 | }) 310 | 311 | test('res.locals is an empty object', () => { 312 | const { res } = getMockRes() 313 | 314 | expect(res.locals).toBeDefined() 315 | expect(res.locals).toBeInstanceOf(Object) 316 | expect(Object.keys(res.locals).length).toBe(0) 317 | }) 318 | 319 | test('res.charset is an empty string', () => { 320 | const { res } = getMockRes() 321 | 322 | expect(res.charset).toBeDefined() 323 | expect(res.charset).toBe('') 324 | }) 325 | 326 | test('res.vary is a mocked function', () => { 327 | const { res } = getMockRes() 328 | 329 | expect(res.vary).toBeDefined() 330 | expect(typeof res.vary).toBe('function') 331 | expect((res.vary as jest.Mock).getMockName()).toBe('vary mock default') 332 | }) 333 | 334 | test('res.vary is chainable', () => { 335 | const { res } = getMockRes() 336 | 337 | // it returns itself (is chainable) 338 | expect(res.vary('test')).toBe(res) 339 | }) 340 | 341 | test('res.app is an empty object', () => { 342 | const { res } = getMockRes() 343 | 344 | expect(res.app).toBeDefined() 345 | expect(res.app).toBeInstanceOf(Object) 346 | expect(Object.keys(res.app).length).toBe(0) 347 | }) 348 | 349 | test('res.append is a mocked function', () => { 350 | const { res } = getMockRes() 351 | 352 | expect(res.append).toBeDefined() 353 | expect(typeof res.append).toBe('function') 354 | expect((res.append as jest.Mock).getMockName()).toBe('append mock default') 355 | }) 356 | 357 | test('res.append is chainable', () => { 358 | const { res } = getMockRes() 359 | 360 | // it returns itself (is chainable) 361 | expect(res.append('test')).toBe(res) 362 | }) 363 | 364 | test('res.req is an empty object', () => { 365 | const { res } = getMockRes() 366 | 367 | expect(res.req).toBeDefined() 368 | expect(res.req).toBeInstanceOf(Object) 369 | expect(res.req).toEqual({}) 370 | }) 371 | }) 372 | -------------------------------------------------------------------------------- /src/test/response/defaults/defaults.http.OutgoingMessage.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockRes from '../../../response/response' 3 | 4 | describe('response - Defaults for "http.OutgoingMessage" (accepts no arguments and return default values)', () => { 5 | test('res.req is an empty object', () => { 6 | const { res } = getMockRes() 7 | 8 | expect(res.req).toBeDefined() 9 | expect(res.req).toBeInstanceOf(Object) 10 | expect(res.req).toEqual({}) 11 | }) 12 | 13 | test('res.chunkedEncoding is a boolean', () => { 14 | const { res } = getMockRes() 15 | 16 | expect(res.chunkedEncoding).toBeDefined() 17 | expect(res.chunkedEncoding).toEqual(false) 18 | }) 19 | 20 | test('res.shouldKeepAlive is a boolean', () => { 21 | const { res } = getMockRes() 22 | 23 | expect(res.shouldKeepAlive).toBeDefined() 24 | expect(res.shouldKeepAlive).toEqual(false) 25 | }) 26 | 27 | test('res.useChunkedEncodingByDefault is a boolean', () => { 28 | const { res } = getMockRes() 29 | 30 | expect(res.useChunkedEncodingByDefault).toBeDefined() 31 | expect(res.useChunkedEncodingByDefault).toEqual(false) 32 | }) 33 | 34 | test('res.sendDate is a boolean', () => { 35 | const { res } = getMockRes() 36 | 37 | expect(res.sendDate).toBeDefined() 38 | expect(res.sendDate).toEqual(false) 39 | }) 40 | 41 | test('res.finished is a boolean', () => { 42 | const { res } = getMockRes() 43 | 44 | expect(res.finished).toBeDefined() 45 | expect(res.finished).toEqual(false) 46 | }) 47 | 48 | test('res.headersSent is a boolean', () => { 49 | const { res } = getMockRes() 50 | 51 | expect(res.headersSent).toBeDefined() 52 | expect(res.headersSent).toBe(false) 53 | }) 54 | 55 | test('res.connection is am empty object', () => { 56 | const { res } = getMockRes() 57 | 58 | expect(res.connection).toBeDefined() 59 | expect(res.connection).toBeInstanceOf(Object) 60 | if (res.connection) { 61 | expect(Object.keys(res.connection).length).toBe(0) 62 | } else { 63 | throw new Error('Should not get here') 64 | } 65 | }) 66 | 67 | test('res.socket is am empty object', () => { 68 | const { res } = getMockRes() 69 | 70 | expect(res.socket).toBeDefined() 71 | expect(res.socket).toBeInstanceOf(Object) 72 | if (res.socket) { 73 | expect(Object.keys(res.socket).length).toBe(0) 74 | } else { 75 | throw new Error('Should not get here') 76 | } 77 | }) 78 | 79 | test('res.setTimeout is a mocked function', () => { 80 | const { res } = getMockRes() 81 | 82 | expect(res.setTimeout).toBeDefined() 83 | expect(typeof res.setTimeout).toBe('function') 84 | expect((res.setTimeout as jest.Mock).getMockName()).toBe('setTimeout mock default') 85 | }) 86 | 87 | test('res.setTimeout is chainable', () => { 88 | const { res } = getMockRes() 89 | 90 | // it returns itself (is chainable) 91 | expect(res.setTimeout(1000)).toBe(res) 92 | }) 93 | 94 | test('res.setHeader is a mocked function', () => { 95 | const { res } = getMockRes() 96 | 97 | expect(res.setHeader).toBeDefined() 98 | expect(typeof res.setHeader).toBe('function') 99 | expect((res.setHeader as jest.Mock).getMockName()).toBe('setHeader mock default') 100 | }) 101 | 102 | test('res.setHeader is not chainable', () => { 103 | const { res } = getMockRes() 104 | 105 | // it does not return itself (is not chainable) 106 | expect(res.setHeader('test', 'test two')).toBeUndefined() 107 | }) 108 | 109 | test('res.getHeader is a mocked function', () => { 110 | const { res } = getMockRes() 111 | 112 | expect(res.getHeader).toBeDefined() 113 | expect(typeof res.getHeader).toBe('function') 114 | expect((res.getHeader as jest.Mock).getMockName()).toBe('getHeader mock default') 115 | }) 116 | 117 | test('res.getHeader is not chainable', () => { 118 | const { res } = getMockRes() 119 | 120 | // it does not return itself (is not chainable) 121 | expect(res.getHeader('test')).toBeUndefined() 122 | }) 123 | 124 | test('res.getHeaders is a mocked function', () => { 125 | const { res } = getMockRes() 126 | 127 | expect(res.getHeaders).toBeDefined() 128 | expect(typeof res.getHeaders).toBe('function') 129 | expect((res.getHeaders as jest.Mock).getMockName()).toBe('getHeaders mock default') 130 | }) 131 | 132 | test('res.getHeaders is not chainable', () => { 133 | const { res } = getMockRes() 134 | 135 | // it does not return itself (is not chainable) 136 | expect(res.getHeaders()).toBeUndefined() 137 | }) 138 | 139 | test('res.getHeaderNames is a mocked function', () => { 140 | const { res } = getMockRes() 141 | 142 | expect(res.getHeaderNames).toBeDefined() 143 | expect(typeof res.getHeaderNames).toBe('function') 144 | expect((res.getHeaderNames as jest.Mock).getMockName()).toBe('getHeaderNames mock default') 145 | }) 146 | 147 | test('res.getHeaderNames is not chainable', () => { 148 | const { res } = getMockRes() 149 | 150 | // it does not return itself (is not chainable) 151 | expect(res.getHeaderNames()).toBeUndefined() 152 | }) 153 | 154 | test('res.hasHeader is a mocked function', () => { 155 | const { res } = getMockRes() 156 | 157 | expect(res.hasHeader).toBeDefined() 158 | expect(typeof res.hasHeader).toBe('function') 159 | expect((res.hasHeader as jest.Mock).getMockName()).toBe('hasHeader mock default') 160 | }) 161 | 162 | test('res.hasHeader is not chainable', () => { 163 | const { res } = getMockRes() 164 | 165 | // it does not return itself (is not chainable) 166 | expect(res.hasHeader('test')).toBeUndefined() 167 | }) 168 | 169 | test('res.removeHeader is a mocked function', () => { 170 | const { res } = getMockRes() 171 | 172 | expect(res.removeHeader).toBeDefined() 173 | expect(typeof res.removeHeader).toBe('function') 174 | expect((res.removeHeader as jest.Mock).getMockName()).toBe('removeHeader mock default') 175 | }) 176 | 177 | test('res.removeHeader is not chainable', () => { 178 | const { res } = getMockRes() 179 | 180 | // it does not return itself (is not chainable) 181 | expect(res.removeHeader('test')).toBeUndefined() 182 | }) 183 | 184 | test('res.addTrailers is a mocked function', () => { 185 | const { res } = getMockRes() 186 | 187 | expect(res.addTrailers).toBeDefined() 188 | expect(typeof res.addTrailers).toBe('function') 189 | expect((res.addTrailers as jest.Mock).getMockName()).toBe('addTrailers mock default') 190 | }) 191 | 192 | test('res.addTrailers is not chainable', () => { 193 | const { res } = getMockRes() 194 | 195 | // it does not return itself (is not chainable) 196 | expect(res.addTrailers([])).toBeUndefined() 197 | }) 198 | 199 | test('res.flushHeaders is a mocked function', () => { 200 | const { res } = getMockRes() 201 | 202 | expect(res.flushHeaders).toBeDefined() 203 | expect(typeof res.flushHeaders).toBe('function') 204 | expect((res.flushHeaders as jest.Mock).getMockName()).toBe('flushHeaders mock default') 205 | }) 206 | 207 | test('res.flushHeaders is not chainable', () => { 208 | const { res } = getMockRes() 209 | 210 | // it does not return itself (is not chainable) 211 | expect(res.flushHeaders()).toBeUndefined() 212 | }) 213 | }) 214 | -------------------------------------------------------------------------------- /src/test/response/defaults/defaults.http.ServerResponse.test.ts: -------------------------------------------------------------------------------- 1 | // Libraries 2 | import { Socket } from 'net' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Defaults for "http.ServerResponse" (accepts no arguments and return default values)', () => { 8 | test('res.statusCode is a number', () => { 9 | const { res } = getMockRes() 10 | 11 | expect(res.statusCode).toBeDefined() 12 | expect(res.statusCode).toEqual(0) 13 | }) 14 | 15 | test('res.statusMessage is an empty string', () => { 16 | const { res } = getMockRes() 17 | 18 | expect(res.statusMessage).toBeDefined() 19 | expect(res.statusMessage).toEqual('') 20 | }) 21 | 22 | test('res.assignSocket is a mocked function', () => { 23 | const { res } = getMockRes() 24 | 25 | expect(res.assignSocket).toBeDefined() 26 | expect(typeof res.assignSocket).toBe('function') 27 | expect((res.assignSocket as jest.Mock).getMockName()).toBe('assignSocket mock default') 28 | }) 29 | 30 | test('res.assignSocket is not chainable', () => { 31 | const { res } = getMockRes() 32 | 33 | // it does not return itself (is not chainable) 34 | const socket = new Socket() 35 | expect(res.assignSocket(socket)).toBeUndefined() 36 | }) 37 | 38 | test('res.detachSocket is a mocked function', () => { 39 | const { res } = getMockRes() 40 | 41 | expect(res.detachSocket).toBeDefined() 42 | expect(typeof res.detachSocket).toBe('function') 43 | expect((res.detachSocket as jest.Mock).getMockName()).toBe('detachSocket mock default') 44 | }) 45 | 46 | test('res.detachSocket is not chainable', () => { 47 | const { res } = getMockRes() 48 | 49 | // it does not return itself (is not chainable) 50 | const socket = new Socket() 51 | expect(res.detachSocket(socket)).toBeUndefined() 52 | }) 53 | 54 | test('res.writeContinue is a mocked function', () => { 55 | const { res } = getMockRes() 56 | 57 | expect(res.writeContinue).toBeDefined() 58 | expect(typeof res.writeContinue).toBe('function') 59 | expect((res.writeContinue as jest.Mock).getMockName()).toBe('writeContinue mock default') 60 | }) 61 | 62 | test('res.writeContinue is not chainable', () => { 63 | const { res } = getMockRes() 64 | 65 | // it does not return itself (is not chainable) 66 | expect(res.writeContinue()).toBeUndefined() 67 | }) 68 | 69 | test('res.writeHead is a mocked function', () => { 70 | const { res } = getMockRes() 71 | 72 | expect(res.writeHead).toBeDefined() 73 | expect(typeof res.writeHead).toBe('function') 74 | expect((res.writeHead as jest.Mock).getMockName()).toBe('writeHead mock default') 75 | }) 76 | 77 | test('res.writeHead is chainable', () => { 78 | const { res } = getMockRes() 79 | 80 | // it returns itself (is chainable) 81 | expect(res.writeHead(200)).toBe(res) 82 | }) 83 | 84 | test('res.writeProcessing is a mocked function', () => { 85 | const { res } = getMockRes() 86 | 87 | expect(res.writeProcessing).toBeDefined() 88 | expect(typeof res.writeProcessing).toBe('function') 89 | expect((res.writeProcessing as jest.Mock).getMockName()).toBe('writeProcessing mock default') 90 | }) 91 | 92 | test('res.writeProcessing is not chainable', () => { 93 | const { res } = getMockRes() 94 | 95 | // it does not return itself (is not chainable) 96 | expect(res.writeProcessing()).toBeUndefined() 97 | }) 98 | }) 99 | -------------------------------------------------------------------------------- /src/test/response/defaults/defaults.stream.Writable.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockRes from '../../../response/response' 3 | 4 | describe('response - Defaults for "stream.Writable" (accepts no arguments and return default values)', () => { 5 | test('res.writable is a boolean', () => { 6 | const { res } = getMockRes() 7 | 8 | expect(res.writable).toBeDefined() 9 | expect(res.writable).toEqual(false) 10 | }) 11 | 12 | test('res.writableEnded is a boolean', () => { 13 | const { res } = getMockRes() 14 | 15 | expect(res.writableEnded).toBeDefined() 16 | expect(res.writableEnded).toEqual(false) 17 | }) 18 | 19 | test('res.writableFinished is a boolean', () => { 20 | const { res } = getMockRes() 21 | 22 | expect(res.writableFinished).toBeDefined() 23 | expect(res.writableFinished).toEqual(false) 24 | }) 25 | 26 | test('res.writableHighWaterMark is a number', () => { 27 | const { res } = getMockRes() 28 | 29 | expect(res.writableHighWaterMark).toBeDefined() 30 | expect(res.writableHighWaterMark).toEqual(0) 31 | }) 32 | 33 | test('res.writableLength is a number', () => { 34 | const { res } = getMockRes() 35 | 36 | expect(res.writableLength).toBeDefined() 37 | expect(res.writableLength).toEqual(0) 38 | }) 39 | 40 | test('res.writableObjectMode is a boolean', () => { 41 | const { res } = getMockRes() 42 | 43 | expect(res.writableObjectMode).toBeDefined() 44 | expect(res.writableObjectMode).toEqual(false) 45 | }) 46 | 47 | test('res.writableCorked is a number', () => { 48 | const { res } = getMockRes() 49 | 50 | expect(res.writableCorked).toBeDefined() 51 | expect(res.writableCorked).toEqual(0) 52 | }) 53 | 54 | test('res.destroyed is a boolean', () => { 55 | const { res } = getMockRes() 56 | 57 | expect(res.destroyed).toBeDefined() 58 | expect(res.destroyed).toEqual(false) 59 | }) 60 | 61 | test('res._write is a mocked function', () => { 62 | const { res } = getMockRes() 63 | 64 | expect(res._write).toBeDefined() 65 | expect(typeof res._write).toBe('function') 66 | expect((res._write as jest.Mock).getMockName()).toBe('_write mock default') 67 | }) 68 | 69 | test('res._write is not chainable', () => { 70 | const { res } = getMockRes() 71 | 72 | // it does not return itself (is not chainable) 73 | expect(res._write({}, 'base64', jest.fn())).toBeUndefined() 74 | }) 75 | 76 | test('res._writev is a mocked function', () => { 77 | const { res } = getMockRes() 78 | 79 | expect(res._writev).toBeDefined() 80 | expect(typeof res._writev).toBe('function') 81 | expect((res._writev as jest.Mock).getMockName()).toBe('_writev mock default') 82 | }) 83 | 84 | test('res._writev is not chainable', () => { 85 | const { res } = getMockRes() 86 | 87 | // it does not return itself (is not chainable) 88 | expect(res._writev && res._writev([], jest.fn())).toBeUndefined() 89 | }) 90 | 91 | test('res._destroy is a mocked function', () => { 92 | const { res } = getMockRes() 93 | 94 | expect(res._destroy).toBeDefined() 95 | expect(typeof res._destroy).toBe('function') 96 | expect((res._destroy as jest.Mock).getMockName()).toBe('_destroy mock default') 97 | }) 98 | 99 | test('res._destroy is not chainable', () => { 100 | const { res } = getMockRes() 101 | 102 | // it does not return itself (is not chainable) 103 | expect(res._destroy(null, jest.fn())).toBeUndefined() 104 | }) 105 | 106 | test('res._final is a mocked function', () => { 107 | const { res } = getMockRes() 108 | 109 | expect(res._final).toBeDefined() 110 | expect(typeof res._final).toBe('function') 111 | expect((res._final as jest.Mock).getMockName()).toBe('_final mock default') 112 | }) 113 | 114 | test('res._final is not chainable', () => { 115 | const { res } = getMockRes() 116 | 117 | // it does not return itself (is not chainable) 118 | expect(res._final(jest.fn())).toBeUndefined() 119 | }) 120 | 121 | test('res.write is a mocked function', () => { 122 | const { res } = getMockRes() 123 | 124 | expect(res.write).toBeDefined() 125 | expect(typeof res.write).toBe('function') 126 | expect((res.write as jest.Mock).getMockName()).toBe('write mock default') 127 | }) 128 | 129 | test('res.write is not chainable', () => { 130 | const { res } = getMockRes() 131 | 132 | // it does not return itself (is not chainable) 133 | expect(res.write({}, jest.fn())).toBeUndefined() 134 | }) 135 | 136 | test('res.setDefaultEncoding is a mocked function', () => { 137 | const { res } = getMockRes() 138 | 139 | expect(res.setDefaultEncoding).toBeDefined() 140 | expect(typeof res.setDefaultEncoding).toBe('function') 141 | expect((res.setDefaultEncoding as jest.Mock).getMockName()).toBe('setDefaultEncoding mock default') 142 | }) 143 | 144 | test('res.setDefaultEncoding is chainable', () => { 145 | const { res } = getMockRes() 146 | 147 | // it returns itself (is chainable) 148 | expect(res.setDefaultEncoding('base64')).toBe(res) 149 | }) 150 | 151 | test('res.end is a mocked function', () => { 152 | const { res } = getMockRes() 153 | 154 | expect(res.end).toBeDefined() 155 | expect(typeof res.end).toBe('function') 156 | expect((res.end as jest.Mock).getMockName()).toBe('end mock default') 157 | }) 158 | 159 | test('res.end is not chainable', () => { 160 | const { res } = getMockRes() 161 | 162 | // it does not return itself (is not chainable) 163 | expect(res.end()).toBeUndefined() 164 | }) 165 | 166 | test('res.cork is a mocked function', () => { 167 | const { res } = getMockRes() 168 | 169 | expect(res.cork).toBeDefined() 170 | expect(typeof res.cork).toBe('function') 171 | expect((res.cork as jest.Mock).getMockName()).toBe('cork mock default') 172 | }) 173 | 174 | test('res.cork is not chainable', () => { 175 | const { res } = getMockRes() 176 | 177 | // it does not return itself (is not chainable) 178 | expect(res.cork()).toBeUndefined() 179 | }) 180 | 181 | test('res.uncork is a mocked function', () => { 182 | const { res } = getMockRes() 183 | 184 | expect(res.uncork).toBeDefined() 185 | expect(typeof res.uncork).toBe('function') 186 | expect((res.uncork as jest.Mock).getMockName()).toBe('uncork mock default') 187 | }) 188 | 189 | test('res.uncork is not chainable', () => { 190 | const { res } = getMockRes() 191 | 192 | // it does not return itself (is not chainable) 193 | expect(res.uncork()).toBeUndefined() 194 | }) 195 | 196 | test('res.destroy is a mocked function', () => { 197 | const { res } = getMockRes() 198 | 199 | expect(res.destroy).toBeDefined() 200 | expect(typeof res.destroy).toBe('function') 201 | expect((res.destroy as jest.Mock).getMockName()).toBe('destroy mock default') 202 | }) 203 | 204 | test('res.destroy is not chainable', () => { 205 | const { res } = getMockRes() 206 | 207 | // it does not return itself (is not chainable) 208 | expect(res.destroy()).toBeUndefined() 209 | }) 210 | 211 | test('res.addListener is a mocked function', () => { 212 | const { res } = getMockRes() 213 | 214 | expect(res.addListener).toBeDefined() 215 | expect(typeof res.addListener).toBe('function') 216 | expect((res.addListener as jest.Mock).getMockName()).toBe('addListener mock default') 217 | }) 218 | 219 | test('res.addListener is chainable', () => { 220 | const { res } = getMockRes() 221 | 222 | // it returns itself (is chainable) 223 | expect(res.addListener('test', jest.fn())).toBe(res) 224 | }) 225 | 226 | test('res.emit is a mocked function', () => { 227 | const { res } = getMockRes() 228 | 229 | expect(res.emit).toBeDefined() 230 | expect(typeof res.emit).toBe('function') 231 | expect((res.emit as jest.Mock).getMockName()).toBe('emit mock default') 232 | }) 233 | 234 | test('res.emit is not chainable', () => { 235 | const { res } = getMockRes() 236 | 237 | // it does not return itself (is not chainable) 238 | expect(res.emit('test')).toBeUndefined() 239 | }) 240 | 241 | test('res.on is a mocked function', () => { 242 | const { res } = getMockRes() 243 | 244 | expect(res.on).toBeDefined() 245 | expect(typeof res.on).toBe('function') 246 | expect((res.on as jest.Mock).getMockName()).toBe('on mock default') 247 | }) 248 | 249 | test('res.on is chainable', () => { 250 | const { res } = getMockRes() 251 | 252 | // it returns itself (is chainable) 253 | expect(res.on('close', jest.fn())).toBe(res) 254 | }) 255 | 256 | test('res.once is a mocked function', () => { 257 | const { res } = getMockRes() 258 | 259 | expect(res.once).toBeDefined() 260 | expect(typeof res.once).toBe('function') 261 | expect((res.once as jest.Mock).getMockName()).toBe('once mock default') 262 | }) 263 | 264 | test('res.once is chainable', () => { 265 | const { res } = getMockRes() 266 | 267 | // it returns itself (is chainable) 268 | expect(res.once('pipe', jest.fn())).toBe(res) 269 | }) 270 | 271 | test('res.prependListener is a mocked function', () => { 272 | const { res } = getMockRes() 273 | 274 | expect(res.prependListener).toBeDefined() 275 | expect(typeof res.prependListener).toBe('function') 276 | expect((res.prependListener as jest.Mock).getMockName()).toBe('prependListener mock default') 277 | }) 278 | 279 | test('res.prependListener is chainable', () => { 280 | const { res } = getMockRes() 281 | 282 | // it returns itself (is chainable) 283 | expect(res.prependListener('drain', jest.fn())).toBe(res) 284 | }) 285 | 286 | test('res.prependOnceListener is a mocked function', () => { 287 | const { res } = getMockRes() 288 | 289 | expect(res.prependOnceListener).toBeDefined() 290 | expect(typeof res.prependOnceListener).toBe('function') 291 | expect((res.prependOnceListener as jest.Mock).getMockName()).toBe('prependOnceListener mock default') 292 | }) 293 | 294 | test('res.prependOnceListener is chainable', () => { 295 | const { res } = getMockRes() 296 | 297 | // it returns itself (is chainable) 298 | expect(res.prependOnceListener('unpipe', jest.fn())).toBe(res) 299 | }) 300 | 301 | test('res.removeListener is a mocked function', () => { 302 | const { res } = getMockRes() 303 | 304 | expect(res.removeListener).toBeDefined() 305 | expect(typeof res.removeListener).toBe('function') 306 | expect((res.removeListener as jest.Mock).getMockName()).toBe('removeListener mock default') 307 | }) 308 | 309 | test('res.removeListener is chainable', () => { 310 | const { res } = getMockRes() 311 | 312 | // it returns itself (is chainable) 313 | expect(res.removeListener('error', jest.fn())).toBe(res) 314 | }) 315 | }) 316 | -------------------------------------------------------------------------------- /src/test/response/github.test.ts: -------------------------------------------------------------------------------- 1 | // Tested Module 2 | import getMockRes from '../../response/response' 3 | 4 | describe('response - GitHub Issues', () => { 5 | test('issue #32', () => { 6 | const statusCode = 404 7 | const { res } = getMockRes() 8 | 9 | res.status(statusCode).end() 10 | 11 | // status is called 12 | expect(res.status).toBeCalledTimes(1) 13 | expect(res.status).toBeCalledWith(statusCode) 14 | // chained end is called 15 | expect(res.end).toBeCalledTimes(1) 16 | expect(res.end).toBeCalledWith() 17 | }) 18 | 19 | test('issue #58', () => { 20 | const statusCode = 204 21 | const { res } = getMockRes() 22 | 23 | res.status(204).send() 24 | 25 | // status is called 26 | expect(res.status).toBeCalledTimes(1) 27 | expect(res.status).toBeCalledWith(statusCode) 28 | // chained send is called 29 | expect(res.send).toBeCalledTimes(1) 30 | expect(res.send).toBeCalledWith() 31 | }) 32 | }) 33 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.event.EventEmitter.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedFunction } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Provided for "event.EventEmitter" (accepts arguments and returns expected values)', () => { 8 | test('res.addListener can be provided', () => { 9 | const { res } = getMockRes({ addListener: providedFunction }) 10 | 11 | expect(res.addListener).toBeDefined() 12 | expect(res.addListener).toBe(providedFunction) 13 | }) 14 | 15 | test('res.on can be provided', () => { 16 | const { res } = getMockRes({ on: providedFunction }) 17 | 18 | expect(res.on).toBeDefined() 19 | expect(res.on).toBe(providedFunction) 20 | }) 21 | 22 | test('res.once can be provided', () => { 23 | const { res } = getMockRes({ once: providedFunction }) 24 | 25 | expect(res.once).toBeDefined() 26 | expect(res.once).toBe(providedFunction) 27 | }) 28 | 29 | test('res.removeListener can be provided', () => { 30 | const { res } = getMockRes({ removeListener: providedFunction }) 31 | 32 | expect(res.removeListener).toBeDefined() 33 | expect(res.removeListener).toBe(providedFunction) 34 | }) 35 | 36 | test('res.off can be provided', () => { 37 | const { res } = getMockRes({ off: providedFunction }) 38 | 39 | expect(res.off).toBeDefined() 40 | expect(res.off).toBe(providedFunction) 41 | }) 42 | 43 | test('res.removeAllListeners can be provided', () => { 44 | const { res } = getMockRes({ removeAllListeners: providedFunction }) 45 | 46 | expect(res.removeAllListeners).toBeDefined() 47 | expect(res.removeAllListeners).toBe(providedFunction) 48 | }) 49 | 50 | test('res.setMaxListeners can be provided', () => { 51 | const { res } = getMockRes({ setMaxListeners: providedFunction }) 52 | 53 | expect(res.setMaxListeners).toBeDefined() 54 | expect(res.setMaxListeners).toBe(providedFunction) 55 | }) 56 | 57 | test('res.getMaxListeners can be provided', () => { 58 | const { res } = getMockRes({ getMaxListeners: providedFunction }) 59 | 60 | expect(res.getMaxListeners).toBeDefined() 61 | expect(res.getMaxListeners).toBe(providedFunction) 62 | }) 63 | 64 | test('res.listeners can be provided', () => { 65 | const { res } = getMockRes({ listeners: providedFunction }) 66 | 67 | expect(res.listeners).toBeDefined() 68 | expect(res.listeners).toBe(providedFunction) 69 | }) 70 | 71 | test('res.rawListeners can be provided', () => { 72 | const { res } = getMockRes({ rawListeners: providedFunction }) 73 | 74 | expect(res.rawListeners).toBeDefined() 75 | expect(res.rawListeners).toBe(providedFunction) 76 | }) 77 | 78 | test('res.emit can be provided', () => { 79 | const { res } = getMockRes({ emit: providedFunction }) 80 | 81 | expect(res.emit).toBeDefined() 82 | expect(res.emit).toBe(providedFunction) 83 | }) 84 | 85 | test('res.listenerCount can be provided', () => { 86 | const { res } = getMockRes({ listenerCount: providedFunction }) 87 | 88 | expect(res.listenerCount).toBeDefined() 89 | expect(res.listenerCount).toBe(providedFunction) 90 | }) 91 | 92 | test('res.prependListener can be provided', () => { 93 | const { res } = getMockRes({ prependListener: providedFunction }) 94 | 95 | expect(res.prependListener).toBeDefined() 96 | expect(res.prependListener).toBe(providedFunction) 97 | }) 98 | 99 | test('res.prependOnceListener can be provided', () => { 100 | const { res } = getMockRes({ prependOnceListener: providedFunction }) 101 | 102 | expect(res.prependOnceListener).toBeDefined() 103 | expect(res.prependOnceListener).toBe(providedFunction) 104 | }) 105 | 106 | test('res.eventNames can be provided', () => { 107 | const { res } = getMockRes({ eventNames: providedFunction }) 108 | 109 | expect(res.eventNames).toBeDefined() 110 | expect(res.eventNames).toBe(providedFunction) 111 | }) 112 | }) 113 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.express.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { 3 | providedApp, 4 | providedBoolean, 5 | providedFunction, 6 | providedObject, 7 | providedReq, 8 | providedString, 9 | } from '../../helpers/provided' 10 | 11 | // Tested Module 12 | import getMockRes from '../../../response/response' 13 | 14 | describe('response - Provided for "express.Express" (accepts arguments and returns expected values)', () => { 15 | test('res.status can be provided', () => { 16 | const { res } = getMockRes({ status: providedFunction }) 17 | 18 | expect(res.status).toBeDefined() 19 | expect(res.status).toBe(providedFunction) 20 | }) 21 | 22 | test('res.sendStatus can be provided', () => { 23 | const { res } = getMockRes({ sendStatus: providedFunction }) 24 | 25 | expect(res.sendStatus).toBeDefined() 26 | expect(res.sendStatus).toBe(providedFunction) 27 | }) 28 | 29 | test('res.links can be provided', () => { 30 | const { res } = getMockRes({ links: providedFunction }) 31 | 32 | expect(res.links).toBeDefined() 33 | expect(res.links).toBe(providedFunction) 34 | }) 35 | 36 | test('res.send can be provided', () => { 37 | const { res } = getMockRes({ send: providedFunction }) 38 | 39 | expect(res.send).toBeDefined() 40 | expect(res.send).toBe(providedFunction) 41 | }) 42 | 43 | test('res.json can be provided', () => { 44 | const { res } = getMockRes({ json: providedFunction }) 45 | 46 | expect(res.json).toBeDefined() 47 | expect(res.json).toBe(providedFunction) 48 | }) 49 | 50 | test('res.jsonp can be provided', () => { 51 | const { res } = getMockRes({ jsonp: providedFunction }) 52 | 53 | expect(res.jsonp).toBeDefined() 54 | expect(res.jsonp).toBe(providedFunction) 55 | }) 56 | 57 | test('res.sendFile can be provided', () => { 58 | const { res } = getMockRes({ sendFile: providedFunction }) 59 | 60 | expect(res.sendFile).toBeDefined() 61 | expect(res.sendFile).toBe(providedFunction) 62 | }) 63 | 64 | test('res.download can be provided', () => { 65 | const { res } = getMockRes({ download: providedFunction }) 66 | 67 | expect(res.download).toBeDefined() 68 | expect(res.download).toBe(providedFunction) 69 | }) 70 | 71 | test('res.contentType can be provided', () => { 72 | const { res } = getMockRes({ contentType: providedFunction }) 73 | 74 | expect(res.contentType).toBeDefined() 75 | expect(res.contentType).toBe(providedFunction) 76 | }) 77 | 78 | test('res.type can be provided', () => { 79 | const { res } = getMockRes({ type: providedFunction }) 80 | 81 | expect(res.type).toBeDefined() 82 | expect(res.type).toBe(providedFunction) 83 | }) 84 | 85 | test('res.format can be provided', () => { 86 | const { res } = getMockRes({ format: providedFunction }) 87 | 88 | expect(res.format).toBeDefined() 89 | expect(res.format).toBe(providedFunction) 90 | }) 91 | 92 | test('res.attachment can be provided', () => { 93 | const { res } = getMockRes({ attachment: providedFunction }) 94 | 95 | expect(res.attachment).toBeDefined() 96 | expect(res.attachment).toBe(providedFunction) 97 | }) 98 | 99 | test('res.set can be provided', () => { 100 | const { res } = getMockRes({ set: providedFunction }) 101 | 102 | expect(res.set).toBeDefined() 103 | expect(res.set).toBe(providedFunction) 104 | }) 105 | 106 | test('res.header can be provided', () => { 107 | const { res } = getMockRes({ header: providedFunction }) 108 | 109 | expect(res.header).toBeDefined() 110 | expect(res.header).toBe(providedFunction) 111 | }) 112 | 113 | test('res.headersSent can be provided', () => { 114 | const { res } = getMockRes({ headersSent: providedBoolean }) 115 | 116 | expect(res.headersSent).toBeDefined() 117 | expect(res.headersSent).toBe(providedBoolean) 118 | }) 119 | 120 | test('res.get can be provided', () => { 121 | const { res } = getMockRes({ get: providedFunction }) 122 | 123 | expect(res.get).toBeDefined() 124 | expect(res.get).toBe(providedFunction) 125 | }) 126 | 127 | test('res.clearCookie can be provided', () => { 128 | const { res } = getMockRes({ clearCookie: providedFunction }) 129 | 130 | expect(res.clearCookie).toBeDefined() 131 | expect(res.clearCookie).toBe(providedFunction) 132 | }) 133 | 134 | test('res.cookie can be provided', () => { 135 | const { res } = getMockRes({ cookie: providedFunction }) 136 | 137 | expect(res.cookie).toBeDefined() 138 | expect(res.cookie).toBe(providedFunction) 139 | }) 140 | 141 | test('res.location can be provided', () => { 142 | const { res } = getMockRes({ location: providedFunction }) 143 | 144 | expect(res.location).toBeDefined() 145 | expect(res.location).toBe(providedFunction) 146 | }) 147 | 148 | test('res.redirect can be provided', () => { 149 | const { res } = getMockRes({ redirect: providedFunction }) 150 | 151 | expect(res.redirect).toBeDefined() 152 | expect(res.redirect).toBe(providedFunction) 153 | }) 154 | 155 | test('res.render can be provided', () => { 156 | const { res } = getMockRes({ render: providedFunction }) 157 | 158 | expect(res.render).toBeDefined() 159 | expect(res.render).toBe(providedFunction) 160 | }) 161 | 162 | test('res.locals can be provided', () => { 163 | const { res } = getMockRes({ locals: providedObject }) 164 | 165 | expect(res.locals).toBeDefined() 166 | expect(res.locals).toBe(providedObject) 167 | }) 168 | 169 | test('res.charset can be provided', () => { 170 | const { res } = getMockRes({ charset: providedString }) 171 | 172 | expect(res.charset).toBeDefined() 173 | expect(res.charset).toBe(providedString) 174 | }) 175 | 176 | test('res.vary can be provided', () => { 177 | const { res } = getMockRes({ vary: providedFunction }) 178 | 179 | expect(res.vary).toBeDefined() 180 | expect(res.vary).toBe(providedFunction) 181 | }) 182 | 183 | test('res.app can be provided', () => { 184 | const { res } = getMockRes({ app: providedApp }) 185 | 186 | expect(res.app).toBeDefined() 187 | expect(res.app).toBe(providedApp) 188 | }) 189 | 190 | test('res.append can be provided', () => { 191 | const { res } = getMockRes({ append: providedFunction }) 192 | 193 | expect(res.append).toBeDefined() 194 | expect(res.append).toBe(providedFunction) 195 | }) 196 | 197 | test('res.req can be provided', () => { 198 | const { res } = getMockRes({ req: providedReq }) 199 | 200 | expect(res.req).toBeDefined() 201 | expect(res.req).toBe(providedReq) 202 | }) 203 | }) 204 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.http.OutgoingMessage.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedBoolean, providedFunction, providedReq, providedSocket } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Provided for "http.OutgoingMessage" (accepts arguments and returns expected values)', () => { 8 | test('res.req can be provided', () => { 9 | const { res } = getMockRes({ req: providedReq }) 10 | 11 | expect(res.req).toBeDefined() 12 | expect(res.req).toBe(providedReq) 13 | }) 14 | 15 | test('res.chunkedEncoding can be provided', () => { 16 | const { res } = getMockRes({ chunkedEncoding: providedBoolean }) 17 | 18 | expect(res.chunkedEncoding).toBeDefined() 19 | expect(res.chunkedEncoding).toBe(providedBoolean) 20 | }) 21 | 22 | test('res.shouldKeepAlive can be provided', () => { 23 | const { res } = getMockRes({ shouldKeepAlive: providedBoolean }) 24 | 25 | expect(res.shouldKeepAlive).toBeDefined() 26 | expect(res.shouldKeepAlive).toBe(providedBoolean) 27 | }) 28 | 29 | test('res.useChunkedEncodingByDefault can be provided', () => { 30 | const { res } = getMockRes({ useChunkedEncodingByDefault: providedBoolean }) 31 | 32 | expect(res.useChunkedEncodingByDefault).toBeDefined() 33 | expect(res.useChunkedEncodingByDefault).toBe(providedBoolean) 34 | }) 35 | 36 | test('res.sendDate can be provided', () => { 37 | const { res } = getMockRes({ sendDate: providedBoolean }) 38 | 39 | expect(res.sendDate).toBeDefined() 40 | expect(res.sendDate).toBe(providedBoolean) 41 | }) 42 | 43 | test('res.finished can be provided', () => { 44 | const { res } = getMockRes({ finished: providedBoolean }) 45 | 46 | expect(res.finished).toBeDefined() 47 | expect(res.finished).toBe(providedBoolean) 48 | }) 49 | 50 | test('res.headersSent can be provided', () => { 51 | const { res } = getMockRes({ headersSent: providedBoolean }) 52 | 53 | expect(res.headersSent).toBeDefined() 54 | expect(res.headersSent).toBe(providedBoolean) 55 | }) 56 | 57 | test('res.connection can be provided', () => { 58 | const { res } = getMockRes({ connection: providedSocket }) 59 | 60 | expect(res.connection).toBeDefined() 61 | expect(res.connection).toBe(providedSocket) 62 | }) 63 | 64 | test('res.socket can be provided', () => { 65 | const { res } = getMockRes({ socket: providedSocket }) 66 | 67 | expect(res.socket).toBeDefined() 68 | expect(res.socket).toBe(providedSocket) 69 | }) 70 | 71 | test('res.setTimeout can be provided', () => { 72 | const { res } = getMockRes({ setTimeout: providedFunction }) 73 | 74 | expect(res.setTimeout).toBeDefined() 75 | expect(res.setTimeout).toBe(providedFunction) 76 | }) 77 | 78 | test('res.setHeader can be provided', () => { 79 | const { res } = getMockRes({ setHeader: providedFunction }) 80 | 81 | expect(res.setHeader).toBeDefined() 82 | expect(res.setHeader).toBe(providedFunction) 83 | }) 84 | 85 | test('res.getHeader can be provided', () => { 86 | const { res } = getMockRes({ getHeader: providedFunction }) 87 | 88 | expect(res.getHeader).toBeDefined() 89 | expect(res.getHeader).toBe(providedFunction) 90 | }) 91 | 92 | test('res.getHeaders can be provided', () => { 93 | const { res } = getMockRes({ getHeaders: providedFunction }) 94 | 95 | expect(res.getHeaders).toBeDefined() 96 | expect(res.getHeaders).toBe(providedFunction) 97 | }) 98 | 99 | test('res.getHeaderNames can be provided', () => { 100 | const { res } = getMockRes({ getHeaderNames: providedFunction }) 101 | 102 | expect(res.getHeaderNames).toBeDefined() 103 | expect(res.getHeaderNames).toBe(providedFunction) 104 | }) 105 | 106 | test('res.hasHeader can be provided', () => { 107 | const { res } = getMockRes({ hasHeader: providedFunction }) 108 | 109 | expect(res.hasHeader).toBeDefined() 110 | expect(res.hasHeader).toBe(providedFunction) 111 | }) 112 | 113 | test('res.removeHeader can be provided', () => { 114 | const { res } = getMockRes({ removeHeader: providedFunction }) 115 | 116 | expect(res.removeHeader).toBeDefined() 117 | expect(res.removeHeader).toBe(providedFunction) 118 | }) 119 | 120 | test('res.addTrailers can be provided', () => { 121 | const { res } = getMockRes({ addTrailers: providedFunction }) 122 | 123 | expect(res.addTrailers).toBeDefined() 124 | expect(res.addTrailers).toBe(providedFunction) 125 | }) 126 | 127 | test('res.flushHeaders can be provided', () => { 128 | const { res } = getMockRes({ flushHeaders: providedFunction }) 129 | 130 | expect(res.flushHeaders).toBeDefined() 131 | expect(res.flushHeaders).toBe(providedFunction) 132 | }) 133 | }) 134 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.http.ServerResponse.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedFunction, providedNumber, providedString } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Provided for "http.ServerResponse" (accepts arguments and returns expected values)', () => { 8 | test('res.statusCode can be provided', () => { 9 | const { res } = getMockRes({ statusCode: providedNumber }) 10 | 11 | expect(res.statusCode).toBeDefined() 12 | expect(res.statusCode).toBe(providedNumber) 13 | }) 14 | 15 | test('res.statusMessage can be provided', () => { 16 | const { res } = getMockRes({ statusMessage: providedString }) 17 | 18 | expect(res.statusMessage).toBeDefined() 19 | expect(res.statusMessage).toBe(providedString) 20 | }) 21 | 22 | test('res.assignSocket can be provided', () => { 23 | const { res } = getMockRes({ assignSocket: providedFunction }) 24 | 25 | expect(res.assignSocket).toBeDefined() 26 | expect(res.assignSocket).toBe(providedFunction) 27 | }) 28 | 29 | test('res.detachSocket can be provided', () => { 30 | const { res } = getMockRes({ detachSocket: providedFunction }) 31 | 32 | expect(res.detachSocket).toBeDefined() 33 | expect(res.detachSocket).toBe(providedFunction) 34 | }) 35 | 36 | test('res.writeContinue can be provided', () => { 37 | const { res } = getMockRes({ writeContinue: providedFunction }) 38 | 39 | expect(res.writeContinue).toBeDefined() 40 | expect(res.writeContinue).toBe(providedFunction) 41 | }) 42 | 43 | test('res.writeHead can be provided', () => { 44 | const { res } = getMockRes({ writeHead: providedFunction }) 45 | 46 | expect(res.writeHead).toBeDefined() 47 | expect(res.writeHead).toBe(providedFunction) 48 | }) 49 | 50 | test('res.writeProcessing can be provided', () => { 51 | const { res } = getMockRes({ writeProcessing: providedFunction }) 52 | 53 | expect(res.writeProcessing).toBeDefined() 54 | expect(res.writeProcessing).toBe(providedFunction) 55 | }) 56 | }) 57 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.stream.Writable.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { providedFunction, providedNumber, providedBoolean } from '../../helpers/provided' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Provided for "stream.Writable" (accepts arguments and returns expected values)', () => { 8 | test('res.writable can be provided', () => { 9 | const { res } = getMockRes({ writable: providedBoolean }) 10 | 11 | expect(res.writable).toBeDefined() 12 | expect(res.writable).toBe(providedBoolean) 13 | }) 14 | 15 | test('res.writableEnded can be provided', () => { 16 | const { res } = getMockRes({ writableEnded: providedBoolean }) 17 | 18 | expect(res.writableEnded).toBeDefined() 19 | expect(res.writableEnded).toBe(providedBoolean) 20 | }) 21 | 22 | test('res.writableFinished can be provided', () => { 23 | const { res } = getMockRes({ writableFinished: providedBoolean }) 24 | 25 | expect(res.writableFinished).toBeDefined() 26 | expect(res.writableFinished).toBe(providedBoolean) 27 | }) 28 | 29 | test('res.writableHighWaterMark can be provided', () => { 30 | const { res } = getMockRes({ writableHighWaterMark: providedNumber }) 31 | 32 | expect(res.writableHighWaterMark).toBeDefined() 33 | expect(res.writableHighWaterMark).toBe(providedNumber) 34 | }) 35 | 36 | test('res.writableLength can be provided', () => { 37 | const { res } = getMockRes({ writableLength: providedNumber }) 38 | 39 | expect(res.writableLength).toBeDefined() 40 | expect(res.writableLength).toBe(providedNumber) 41 | }) 42 | 43 | test('res.writableObjectMode can be provided', () => { 44 | const { res } = getMockRes({ writableObjectMode: providedBoolean }) 45 | 46 | expect(res.writableObjectMode).toBeDefined() 47 | expect(res.writableObjectMode).toBe(providedBoolean) 48 | }) 49 | 50 | test('res.writableCorked can be provided', () => { 51 | const { res } = getMockRes({ writableCorked: providedNumber }) 52 | 53 | expect(res.writableCorked).toBeDefined() 54 | expect(res.writableCorked).toBe(providedNumber) 55 | }) 56 | 57 | test('res.destroyed can be provided', () => { 58 | const { res } = getMockRes({ destroyed: providedBoolean }) 59 | 60 | expect(res.destroyed).toBeDefined() 61 | expect(res.destroyed).toBe(providedBoolean) 62 | }) 63 | 64 | test('res._write can be provided', () => { 65 | const { res } = getMockRes({ _write: providedFunction }) 66 | 67 | expect(res._write).toBeDefined() 68 | expect(res._write).toBe(providedFunction) 69 | }) 70 | 71 | test('res._writev can be provided', () => { 72 | const { res } = getMockRes({ _writev: providedFunction }) 73 | 74 | expect(res._writev).toBeDefined() 75 | expect(res._writev).toBe(providedFunction) 76 | }) 77 | 78 | test('res._destroy can be provided', () => { 79 | const { res } = getMockRes({ _destroy: providedFunction }) 80 | 81 | expect(res._destroy).toBeDefined() 82 | expect(res._destroy).toBe(providedFunction) 83 | }) 84 | 85 | test('res._final can be provided', () => { 86 | const { res } = getMockRes({ _final: providedFunction }) 87 | 88 | expect(res._final).toBeDefined() 89 | expect(res._final).toBe(providedFunction) 90 | }) 91 | 92 | test('res.write can be provided', () => { 93 | const { res } = getMockRes({ write: providedFunction }) 94 | 95 | expect(res.write).toBeDefined() 96 | expect(res.write).toBe(providedFunction) 97 | }) 98 | 99 | test('res.setDefaultEncoding can be provided', () => { 100 | const { res } = getMockRes({ setDefaultEncoding: providedFunction }) 101 | 102 | expect(res.setDefaultEncoding).toBeDefined() 103 | expect(res.setDefaultEncoding).toBe(providedFunction) 104 | }) 105 | 106 | test('res.end can be provided', () => { 107 | const { res } = getMockRes({ end: providedFunction }) 108 | 109 | expect(res.end).toBeDefined() 110 | expect(res.end).toBe(providedFunction) 111 | }) 112 | 113 | test('res.cork can be provided', () => { 114 | const { res } = getMockRes({ cork: providedFunction }) 115 | 116 | expect(res.cork).toBeDefined() 117 | expect(res.cork).toBe(providedFunction) 118 | }) 119 | 120 | test('res.uncork can be provided', () => { 121 | const { res } = getMockRes({ uncork: providedFunction }) 122 | 123 | expect(res.uncork).toBeDefined() 124 | expect(res.uncork).toBe(providedFunction) 125 | }) 126 | 127 | test('res.destroy can be provided', () => { 128 | const { res } = getMockRes({ destroy: providedFunction }) 129 | 130 | expect(res.destroy).toBeDefined() 131 | expect(res.destroy).toBe(providedFunction) 132 | }) 133 | 134 | test('res.addListener can be provided', () => { 135 | const { res } = getMockRes({ addListener: providedFunction }) 136 | 137 | expect(res.addListener).toBeDefined() 138 | expect(res.addListener).toBe(providedFunction) 139 | }) 140 | 141 | test('res.emit can be provided', () => { 142 | const { res } = getMockRes({ emit: providedFunction }) 143 | 144 | expect(res.emit).toBeDefined() 145 | expect(res.emit).toBe(providedFunction) 146 | }) 147 | 148 | test('res.on can be provided', () => { 149 | const { res } = getMockRes({ on: providedFunction }) 150 | 151 | expect(res.on).toBeDefined() 152 | expect(res.on).toBe(providedFunction) 153 | }) 154 | 155 | test('res.once can be provided', () => { 156 | const { res } = getMockRes({ once: providedFunction }) 157 | 158 | expect(res.once).toBeDefined() 159 | expect(res.once).toBe(providedFunction) 160 | }) 161 | 162 | test('res.prependListener can be provided', () => { 163 | const { res } = getMockRes({ prependListener: providedFunction }) 164 | 165 | expect(res.prependListener).toBeDefined() 166 | expect(res.prependListener).toBe(providedFunction) 167 | }) 168 | 169 | test('res.prependOnceListener can be provided', () => { 170 | const { res } = getMockRes({ prependOnceListener: providedFunction }) 171 | 172 | expect(res.prependOnceListener).toBeDefined() 173 | expect(res.prependOnceListener).toBe(providedFunction) 174 | }) 175 | 176 | test('res.removeListener can be provided', () => { 177 | const { res } = getMockRes({ removeListener: providedFunction }) 178 | 179 | expect(res.removeListener).toBeDefined() 180 | expect(res.removeListener).toBe(providedFunction) 181 | }) 182 | }) 183 | -------------------------------------------------------------------------------- /src/test/response/provided/provided.test.ts: -------------------------------------------------------------------------------- 1 | // Types 2 | import type { Response } from 'express' 3 | 4 | // Tested Module 5 | import getMockRes from '../../../response/response' 6 | 7 | describe('response - Provided (accepts arguments and returns expected values)', () => { 8 | test('allows custom properties', () => { 9 | interface User { 10 | id: string 11 | name: string 12 | } 13 | 14 | interface CustomResponse extends Response { 15 | user: User 16 | } 17 | 18 | const mockUser: User = { 19 | id: '123', 20 | name: 'Bob', 21 | } 22 | 23 | // default value is not provided, but is typed 24 | const { res: defaultRes } = getMockRes() 25 | expect(defaultRes.user).toBeUndefined() 26 | 27 | // allows setting a custom property 28 | const { res } = getMockRes({ sendDate: true, user: mockUser }) 29 | 30 | // both properties are available 31 | expect(res.sendDate).toBe(true) 32 | expect(res.user).toBe(mockUser) 33 | }) 34 | 35 | test('allows locals to be typed', () => { 36 | interface CustomResponse extends Response { 37 | locals: { 38 | sessionId?: string 39 | isPremiumUser?: boolean 40 | } 41 | } 42 | 43 | const { res } = getMockRes({ 44 | locals: { 45 | sessionId: 'abcdef', 46 | isPremiumUser: false, 47 | }, 48 | }) 49 | 50 | expect(res.locals).toBeDefined() 51 | expect(res.locals.sessionId).toBe('abcdef') 52 | expect(res.locals.isPremiumUser).toBe(false) 53 | }) 54 | }) 55 | -------------------------------------------------------------------------------- /src/test/response/response.test.ts: -------------------------------------------------------------------------------- 1 | // Helpers 2 | import { callAllFunctions } from '../helpers/response' 3 | 4 | // Tested Module 5 | import getMockRes from '../../response/response' 6 | 7 | export const DEFAULT_RES_KEY_LENGTH = 84 8 | 9 | describe('response - General', () => { 10 | test('the mock res is provided and contains the expected functions', () => { 11 | const { res } = getMockRes() 12 | 13 | // res contains the expected functions 14 | expect(res).toBeDefined() 15 | expect(Object.keys(res).length).toBe(DEFAULT_RES_KEY_LENGTH) 16 | }) 17 | }) 18 | 19 | describe('response - returns the expected object', () => { 20 | test('it contains the correct amount of properties', () => { 21 | const mockRes = getMockRes() 22 | 23 | // the response contains values for res and next and clear functions 24 | expect(mockRes).toBeInstanceOf(Object) 25 | expect(Object.keys(mockRes).length).toBe(4) 26 | }) 27 | 28 | test('the res object is provided', () => { 29 | const { res } = getMockRes() 30 | 31 | expect(res).toBeDefined() 32 | expect(res).toBeInstanceOf(Object) 33 | }) 34 | 35 | test('the mock next function is provided', () => { 36 | const { next } = getMockRes() 37 | 38 | expect(next).toBeDefined() 39 | expect(typeof next).toBe('function') 40 | }) 41 | 42 | test('the mock next function can be called', () => { 43 | const { next } = getMockRes() 44 | 45 | next() 46 | 47 | expect(next).toBeCalledTimes(1) 48 | }) 49 | 50 | test('the mock clear function is provided', () => { 51 | const { mockClear } = getMockRes() 52 | 53 | expect(mockClear).toBeDefined() 54 | expect(typeof mockClear).toBe('function') 55 | }) 56 | 57 | test('the mock clear alias function is provided', () => { 58 | const { clearMockRes } = getMockRes() 59 | 60 | expect(clearMockRes).toBeDefined() 61 | expect(typeof clearMockRes).toBe('function') 62 | }) 63 | }) 64 | 65 | describe('response - the mock functions can be cleared', () => { 66 | test('mock clear clears all mocks', () => { 67 | const { res, next, mockClear } = getMockRes() 68 | 69 | // call all of the mock functions 70 | next() 71 | callAllFunctions(res) 72 | 73 | // ensure they all report as being called 74 | 75 | /* express.Response */ 76 | expect(next).toBeCalledTimes(1) 77 | expect(res.status).toBeCalledTimes(1) 78 | expect(res.sendStatus).toBeCalledTimes(1) 79 | expect(res.links).toBeCalledTimes(1) 80 | expect(res.send).toBeCalledTimes(1) 81 | expect(res.json).toBeCalledTimes(1) 82 | expect(res.jsonp).toBeCalledTimes(1) 83 | expect(res.sendFile).toBeCalledTimes(1) 84 | expect(res.download).toBeCalledTimes(1) 85 | expect(res.contentType).toBeCalledTimes(1) 86 | expect(res.type).toBeCalledTimes(1) 87 | expect(res.format).toBeCalledTimes(1) 88 | expect(res.attachment).toBeCalledTimes(1) 89 | expect(res.set).toBeCalledTimes(1) 90 | expect(res.header).toBeCalledTimes(1) 91 | expect(res.get).toBeCalledTimes(1) 92 | expect(res.clearCookie).toBeCalledTimes(1) 93 | expect(res.cookie).toBeCalledTimes(1) 94 | expect(res.location).toBeCalledTimes(1) 95 | expect(res.redirect).toBeCalledTimes(1) 96 | expect(res.render).toBeCalledTimes(1) 97 | expect(res.vary).toBeCalledTimes(1) 98 | expect(res.append).toBeCalledTimes(1) 99 | 100 | /* http. ServerResponse */ 101 | expect(res.assignSocket).toBeCalledTimes(1) 102 | expect(res.detachSocket).toBeCalledTimes(1) 103 | expect(res.writeContinue).toBeCalledTimes(1) 104 | expect(res.writeHead).toBeCalledTimes(1) 105 | expect(res.writeProcessing).toBeCalledTimes(1) 106 | 107 | /* http.OutgoingMessage */ 108 | expect(res.setTimeout).toBeCalledTimes(1) 109 | expect(res.setHeader).toBeCalledTimes(1) 110 | expect(res.getHeader).toBeCalledTimes(1) 111 | expect(res.getHeaders).toBeCalledTimes(1) 112 | expect(res.getHeaderNames).toBeCalledTimes(1) 113 | expect(res.hasHeader).toBeCalledTimes(1) 114 | expect(res.removeHeader).toBeCalledTimes(1) 115 | expect(res.addTrailers).toBeCalledTimes(1) 116 | expect(res.flushHeaders).toBeCalledTimes(1) 117 | 118 | /* stream.Writable */ 119 | expect(res._write).toBeCalledTimes(1) 120 | expect(res._writev).toBeCalledTimes(1) 121 | expect(res._destroy).toBeCalledTimes(1) 122 | expect(res._final).toBeCalledTimes(1) 123 | expect(res.write).toBeCalledTimes(1) 124 | expect(res.setDefaultEncoding).toBeCalledTimes(1) 125 | expect(res.end).toBeCalledTimes(1) 126 | expect(res.cork).toBeCalledTimes(1) 127 | expect(res.uncork).toBeCalledTimes(1) 128 | expect(res.destroy).toBeCalledTimes(1) 129 | expect(res.addListener).toBeCalledTimes(1) 130 | expect(res.emit).toBeCalledTimes(1) 131 | expect(res.on).toBeCalledTimes(1) 132 | expect(res.once).toBeCalledTimes(1) 133 | expect(res.prependListener).toBeCalledTimes(1) 134 | expect(res.prependOnceListener).toBeCalledTimes(1) 135 | expect(res.removeListener).toBeCalledTimes(1) 136 | 137 | /* event.EventEmitter */ 138 | expect(res.addListener).toBeCalledTimes(1) 139 | expect(res.on).toBeCalledTimes(1) 140 | expect(res.once).toBeCalledTimes(1) 141 | expect(res.removeListener).toBeCalledTimes(1) 142 | expect(res.off).toBeCalledTimes(1) 143 | expect(res.removeAllListeners).toBeCalledTimes(1) 144 | expect(res.setMaxListeners).toBeCalledTimes(1) 145 | expect(res.getMaxListeners).toBeCalledTimes(1) 146 | expect(res.listeners).toBeCalledTimes(1) 147 | expect(res.rawListeners).toBeCalledTimes(1) 148 | expect(res.emit).toBeCalledTimes(1) 149 | expect(res.listenerCount).toBeCalledTimes(1) 150 | expect(res.prependListener).toBeCalledTimes(1) 151 | expect(res.prependOnceListener).toBeCalledTimes(1) 152 | expect(res.eventNames).toBeCalledTimes(1) 153 | 154 | // clear the mock 155 | mockClear() 156 | 157 | // ensure they all have been cleared 158 | 159 | /* express.Response */ 160 | expect(next).not.toBeCalled() 161 | expect(next).not.toBeCalled() 162 | expect(res.status).not.toBeCalled() 163 | expect(res.sendStatus).not.toBeCalled() 164 | expect(res.links).not.toBeCalled() 165 | expect(res.send).not.toBeCalled() 166 | expect(res.json).not.toBeCalled() 167 | expect(res.jsonp).not.toBeCalled() 168 | expect(res.sendFile).not.toBeCalled() 169 | expect(res.download).not.toBeCalled() 170 | expect(res.contentType).not.toBeCalled() 171 | expect(res.type).not.toBeCalled() 172 | expect(res.format).not.toBeCalled() 173 | expect(res.attachment).not.toBeCalled() 174 | expect(res.set).not.toBeCalled() 175 | expect(res.header).not.toBeCalled() 176 | expect(res.get).not.toBeCalled() 177 | expect(res.clearCookie).not.toBeCalled() 178 | expect(res.cookie).not.toBeCalled() 179 | expect(res.location).not.toBeCalled() 180 | expect(res.redirect).not.toBeCalled() 181 | expect(res.render).not.toBeCalled() 182 | expect(res.vary).not.toBeCalled() 183 | expect(res.append).not.toBeCalled() 184 | 185 | /* http.ServerResponse */ 186 | expect(res.assignSocket).not.toBeCalled() 187 | expect(res.detachSocket).not.toBeCalled() 188 | expect(res.writeContinue).not.toBeCalled() 189 | expect(res.writeHead).not.toBeCalled() 190 | expect(res.writeProcessing).not.toBeCalled() 191 | 192 | /* http.OutgoingMessage */ 193 | expect(res.setTimeout).not.toBeCalled() 194 | expect(res.setHeader).not.toBeCalled() 195 | expect(res.getHeader).not.toBeCalled() 196 | expect(res.getHeaders).not.toBeCalled() 197 | expect(res.getHeaderNames).not.toBeCalled() 198 | expect(res.hasHeader).not.toBeCalled() 199 | expect(res.removeHeader).not.toBeCalled() 200 | expect(res.addTrailers).not.toBeCalled() 201 | expect(res.flushHeaders).not.toBeCalled() 202 | 203 | /* stream.Writable */ 204 | expect(res._write).not.toBeCalled() 205 | expect(res._writev).not.toBeCalled() 206 | expect(res._destroy).not.toBeCalled() 207 | expect(res._final).not.toBeCalled() 208 | expect(res.write).not.toBeCalled() 209 | expect(res.setDefaultEncoding).not.toBeCalled() 210 | expect(res.end).not.toBeCalled() 211 | expect(res.cork).not.toBeCalled() 212 | expect(res.uncork).not.toBeCalled() 213 | expect(res.destroy).not.toBeCalled() 214 | expect(res.addListener).not.toBeCalled() 215 | expect(res.emit).not.toBeCalled() 216 | expect(res.on).not.toBeCalled() 217 | expect(res.once).not.toBeCalled() 218 | expect(res.prependListener).not.toBeCalled() 219 | expect(res.prependOnceListener).not.toBeCalled() 220 | expect(res.removeListener).not.toBeCalled() 221 | 222 | /* event.EventEmitter */ 223 | expect(res.addListener).not.toBeCalled() 224 | expect(res.on).not.toBeCalled() 225 | expect(res.once).not.toBeCalled() 226 | expect(res.removeListener).not.toBeCalled() 227 | expect(res.off).not.toBeCalled() 228 | expect(res.removeAllListeners).not.toBeCalled() 229 | expect(res.setMaxListeners).not.toBeCalled() 230 | expect(res.getMaxListeners).not.toBeCalled() 231 | expect(res.listeners).not.toBeCalled() 232 | expect(res.rawListeners).not.toBeCalled() 233 | expect(res.emit).not.toBeCalled() 234 | expect(res.listenerCount).not.toBeCalled() 235 | expect(res.prependListener).not.toBeCalled() 236 | expect(res.prependOnceListener).not.toBeCalled() 237 | expect(res.eventNames).not.toBeCalled() 238 | }) 239 | 240 | test('clearMockRes clears all mocks', () => { 241 | const { res, next, clearMockRes } = getMockRes() 242 | 243 | // call all of the mock functions 244 | next() 245 | callAllFunctions(res) 246 | 247 | // ensure they all report as being called 248 | 249 | /* express.Response */ 250 | expect(next).toBeCalledTimes(1) 251 | expect(res.status).toBeCalledTimes(1) 252 | expect(res.sendStatus).toBeCalledTimes(1) 253 | expect(res.links).toBeCalledTimes(1) 254 | expect(res.send).toBeCalledTimes(1) 255 | expect(res.json).toBeCalledTimes(1) 256 | expect(res.jsonp).toBeCalledTimes(1) 257 | expect(res.sendFile).toBeCalledTimes(1) 258 | expect(res.download).toBeCalledTimes(1) 259 | expect(res.contentType).toBeCalledTimes(1) 260 | expect(res.type).toBeCalledTimes(1) 261 | expect(res.format).toBeCalledTimes(1) 262 | expect(res.attachment).toBeCalledTimes(1) 263 | expect(res.set).toBeCalledTimes(1) 264 | expect(res.header).toBeCalledTimes(1) 265 | expect(res.get).toBeCalledTimes(1) 266 | expect(res.clearCookie).toBeCalledTimes(1) 267 | expect(res.cookie).toBeCalledTimes(1) 268 | expect(res.location).toBeCalledTimes(1) 269 | expect(res.redirect).toBeCalledTimes(1) 270 | expect(res.render).toBeCalledTimes(1) 271 | expect(res.vary).toBeCalledTimes(1) 272 | expect(res.append).toBeCalledTimes(1) 273 | 274 | /* http.ServerResponse */ 275 | expect(res.assignSocket).toBeCalledTimes(1) 276 | expect(res.detachSocket).toBeCalledTimes(1) 277 | expect(res.writeContinue).toBeCalledTimes(1) 278 | expect(res.writeHead).toBeCalledTimes(1) 279 | expect(res.writeProcessing).toBeCalledTimes(1) 280 | 281 | /* http.OutgoingMessage */ 282 | expect(res.setTimeout).toBeCalledTimes(1) 283 | expect(res.setHeader).toBeCalledTimes(1) 284 | expect(res.getHeader).toBeCalledTimes(1) 285 | expect(res.getHeaders).toBeCalledTimes(1) 286 | expect(res.getHeaderNames).toBeCalledTimes(1) 287 | expect(res.hasHeader).toBeCalledTimes(1) 288 | expect(res.removeHeader).toBeCalledTimes(1) 289 | expect(res.addTrailers).toBeCalledTimes(1) 290 | expect(res.flushHeaders).toBeCalledTimes(1) 291 | 292 | /* stream.Writable */ 293 | expect(res._write).toBeCalledTimes(1) 294 | expect(res._writev).toBeCalledTimes(1) 295 | expect(res._destroy).toBeCalledTimes(1) 296 | expect(res._final).toBeCalledTimes(1) 297 | expect(res.write).toBeCalledTimes(1) 298 | expect(res.setDefaultEncoding).toBeCalledTimes(1) 299 | expect(res.end).toBeCalledTimes(1) 300 | expect(res.cork).toBeCalledTimes(1) 301 | expect(res.uncork).toBeCalledTimes(1) 302 | expect(res.destroy).toBeCalledTimes(1) 303 | expect(res.addListener).toBeCalledTimes(1) 304 | expect(res.emit).toBeCalledTimes(1) 305 | expect(res.on).toBeCalledTimes(1) 306 | expect(res.once).toBeCalledTimes(1) 307 | expect(res.prependListener).toBeCalledTimes(1) 308 | expect(res.prependOnceListener).toBeCalledTimes(1) 309 | expect(res.removeListener).toBeCalledTimes(1) 310 | 311 | /* event.EventEmitter */ 312 | expect(res.addListener).toBeCalledTimes(1) 313 | expect(res.on).toBeCalledTimes(1) 314 | expect(res.once).toBeCalledTimes(1) 315 | expect(res.removeListener).toBeCalledTimes(1) 316 | expect(res.off).toBeCalledTimes(1) 317 | expect(res.removeAllListeners).toBeCalledTimes(1) 318 | expect(res.setMaxListeners).toBeCalledTimes(1) 319 | expect(res.getMaxListeners).toBeCalledTimes(1) 320 | expect(res.listeners).toBeCalledTimes(1) 321 | expect(res.rawListeners).toBeCalledTimes(1) 322 | expect(res.emit).toBeCalledTimes(1) 323 | expect(res.listenerCount).toBeCalledTimes(1) 324 | expect(res.prependListener).toBeCalledTimes(1) 325 | expect(res.prependOnceListener).toBeCalledTimes(1) 326 | expect(res.eventNames).toBeCalledTimes(1) 327 | 328 | // clear the mock 329 | clearMockRes() 330 | 331 | // ensure they all have been cleared 332 | 333 | /* express.Response */ 334 | expect(next).not.toBeCalled() 335 | expect(next).not.toBeCalled() 336 | expect(res.status).not.toBeCalled() 337 | expect(res.sendStatus).not.toBeCalled() 338 | expect(res.links).not.toBeCalled() 339 | expect(res.send).not.toBeCalled() 340 | expect(res.json).not.toBeCalled() 341 | expect(res.jsonp).not.toBeCalled() 342 | expect(res.sendFile).not.toBeCalled() 343 | expect(res.download).not.toBeCalled() 344 | expect(res.contentType).not.toBeCalled() 345 | expect(res.type).not.toBeCalled() 346 | expect(res.format).not.toBeCalled() 347 | expect(res.attachment).not.toBeCalled() 348 | expect(res.set).not.toBeCalled() 349 | expect(res.header).not.toBeCalled() 350 | expect(res.get).not.toBeCalled() 351 | expect(res.clearCookie).not.toBeCalled() 352 | expect(res.cookie).not.toBeCalled() 353 | expect(res.location).not.toBeCalled() 354 | expect(res.redirect).not.toBeCalled() 355 | expect(res.render).not.toBeCalled() 356 | expect(res.vary).not.toBeCalled() 357 | expect(res.append).not.toBeCalled() 358 | 359 | /* http.ServerResponse */ 360 | expect(res.assignSocket).not.toBeCalled() 361 | expect(res.detachSocket).not.toBeCalled() 362 | expect(res.writeContinue).not.toBeCalled() 363 | expect(res.writeHead).not.toBeCalled() 364 | expect(res.writeProcessing).not.toBeCalled() 365 | 366 | /* http.OutgoingMessage */ 367 | expect(res.setTimeout).not.toBeCalled() 368 | expect(res.setHeader).not.toBeCalled() 369 | expect(res.getHeader).not.toBeCalled() 370 | expect(res.getHeaders).not.toBeCalled() 371 | expect(res.getHeaderNames).not.toBeCalled() 372 | expect(res.hasHeader).not.toBeCalled() 373 | expect(res.removeHeader).not.toBeCalled() 374 | expect(res.addTrailers).not.toBeCalled() 375 | expect(res.flushHeaders).not.toBeCalled() 376 | 377 | /* stream.Writable */ 378 | expect(res._write).not.toBeCalled() 379 | expect(res._writev).not.toBeCalled() 380 | expect(res._destroy).not.toBeCalled() 381 | expect(res._final).not.toBeCalled() 382 | expect(res.write).not.toBeCalled() 383 | expect(res.setDefaultEncoding).not.toBeCalled() 384 | expect(res.end).not.toBeCalled() 385 | expect(res.cork).not.toBeCalled() 386 | expect(res.uncork).not.toBeCalled() 387 | expect(res.destroy).not.toBeCalled() 388 | expect(res.addListener).not.toBeCalled() 389 | expect(res.emit).not.toBeCalled() 390 | expect(res.on).not.toBeCalled() 391 | expect(res.once).not.toBeCalled() 392 | expect(res.prependListener).not.toBeCalled() 393 | expect(res.prependOnceListener).not.toBeCalled() 394 | expect(res.removeListener).not.toBeCalled() 395 | 396 | /* event.EventEmitter */ 397 | expect(res.addListener).not.toBeCalled() 398 | expect(res.on).not.toBeCalled() 399 | expect(res.once).not.toBeCalled() 400 | expect(res.removeListener).not.toBeCalled() 401 | expect(res.off).not.toBeCalled() 402 | expect(res.removeAllListeners).not.toBeCalled() 403 | expect(res.setMaxListeners).not.toBeCalled() 404 | expect(res.getMaxListeners).not.toBeCalled() 405 | expect(res.listeners).not.toBeCalled() 406 | expect(res.rawListeners).not.toBeCalled() 407 | expect(res.emit).not.toBeCalled() 408 | expect(res.listenerCount).not.toBeCalled() 409 | expect(res.prependListener).not.toBeCalled() 410 | expect(res.prependOnceListener).not.toBeCalled() 411 | expect(res.eventNames).not.toBeCalled() 412 | }) 413 | }) 414 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "target": "es6", 4 | "declaration": true, 5 | "lib": ["dom", "dom.iterable", "esnext"], 6 | "allowJs": false, 7 | "skipLibCheck": true, 8 | "esModuleInterop": true, 9 | "allowSyntheticDefaultImports": true, 10 | "strict": true, 11 | "sourceMap": true, 12 | "baseUrl": ".", 13 | "noImplicitAny": true, 14 | "forceConsistentCasingInFileNames": true, 15 | "module": "commonjs", 16 | "moduleResolution": "node", 17 | "resolveJsonModule": true, 18 | "outDir": "dist" 19 | } 20 | } 21 | --------------------------------------------------------------------------------