@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/docs/docs/api/MockAgent.md

@@ -1,84 +1,36 @@
-# MockAgent
+# Class: MockAgent
 
-<!--introduced_in=v4.0.0-->
-<!--type=module-->
-<!-- source_link=lib/mock/mock-agent.js -->
+Extends: `undici.Dispatcher`
 
-> Stability: 2 - Stable
+A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead.
 
-A `MockAgent` is a {Dispatcher} that intercepts HTTP requests made through
-undici and replies with programmed mock responses instead of contacting the
-network. It is useful for testing code that performs HTTP requests without
-relying on a live server.
+## `new MockAgent([options])`
 
-A `MockAgent` does not intercept requests on its own. Mock responses are
-registered on the {MockClient} or {MockPool} instances returned by
-[`mockAgent.get(origin)`][], and requests are routed through them once the
-`MockAgent` is set as the dispatcher (for example through
-[`setGlobalDispatcher()`][] or a per-request `dispatcher` option).
+Arguments:
 
-> [!NOTE]
-> [`setGlobalDispatcher()`][] only affects undici APIs that use the global
-> dispatcher, such as `request()` and `fetch()`. It does not replace or
-> monkeypatch {Pool} or {Client} instances that were created separately. To test
-> code that accepts or creates a pool/client directly, pass the {MockPool} or
-> {MockClient} returned by [`mockAgent.get(origin)`][] into that code.
+* **options** `MockAgentOptions` (optional) - It extends the `Agent` options.
 
-```mjs
-import { MockAgent } from 'undici'
-
-const mockAgent = new MockAgent()
-```
-
-## Class: `MockAgent`
-
-<!-- YAML
-added: v4.0.0
--->
+Returns: `MockAgent`
 
-* Extends: {Dispatcher}
+### Parameter: `MockAgentOptions`
 
-Intercepts HTTP requests made through undici and returns mocked responses.
+Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)
 
-### `new MockAgent([options])`
+* **agent** `Agent` (optional) - Default: `new Agent([options])` - a custom agent encapsulated by the MockAgent.
 
-<!-- YAML
-added: v4.0.0
-changes:
-  - version: v7.16.0
-    pr-url: https://github.com/nodejs/undici/pull/4479
-    description: Mock options are always normalized to an object internally.
--->
+### Example - Basic MockAgent instantiation
 
-* `options` {MockAgentOptions} (optional)
-* Returns: {MockAgent}
+This will instantiate the MockAgent. It will not do anything until registered as the agent to use with requests and mock interceptions are added.
 
-When instantiated, a `MockAgent` is automatically activated. It does not
-intercept any request until mock interceptors are registered on the dispatchers
-returned by [`mockAgent.get(origin)`][].
-
-#### Parameter: `MockAgentOptions`
-
-* Extends: {AgentOptions}
-* `agent` {Dispatcher} (optional) A custom agent to be encapsulated by the
-  `MockAgent`. It must implement the `Agent` API (that is, expose a `dispatch`
-  function). **Default:** a new {Agent} constructed from `options`.
-* `ignoreTrailingSlash` {boolean} (optional) Whether trailing slashes in the
-  request path are ignored when matching interceptors. **Default:** `false`.
-* `acceptNonStandardSearchParameters` {boolean} (optional) Whether the matcher
-  also accepts URLs using non-standard search-parameter syntaxes, such as
-  multi-value items written with `[]` (for example `param[]=1&param[]=2`) or
-  comma-separated values (for example `param=1,2,3`). **Default:** `false`.
-* `enableCallHistory` {boolean} (optional) Whether call history recording is
-  enabled. See [`mockAgent.getCallHistory()`][]. **Default:** `false`.
-
-```mjs displayName="Basic instantiation"
+```js
 import { MockAgent } from 'undici'
 
 const mockAgent = new MockAgent()
 ```
 
-```mjs displayName="Instantiation with a custom agent"
+### Example - Basic MockAgent instantiation with custom agent
+
+```js
 import { Agent, MockAgent } from 'undici'
 
 const agent = new Agent()
@@ -86,30 +38,34 @@ const agent = new Agent()
 const mockAgent = new MockAgent({ agent })
 ```
 
-### `mockAgent.get(origin)`
+## Instance Methods
+
+### `MockAgent.get(origin)`
 
-<!-- YAML
-added: v4.0.0
--->
+This method creates and retrieves MockPool or MockClient instances which can then be used to intercept HTTP requests. If the number of connections on the mock agent is set to 1, a MockClient instance is returned. Otherwise a MockPool instance is returned.
 
-* `origin` {string|RegExp|Function} A matcher for the origin to retrieve. The
-  function form has the signature `(origin) => boolean`.
-* Returns: {MockClient|MockPool}
+For subsequent `MockAgent.get` calls on the same origin, the same mock instance will be returned.
 
-Creates and retrieves the mock dispatcher used to intercept requests for the
-given origin. When the `connections` option of the `MockAgent` is `1`, a
-{MockClient} is returned; otherwise a {MockPool} is returned. Subsequent calls
-with the same origin return the same instance.
+Arguments:
 
-The way `origin` is matched against incoming requests depends on its type:
+* **origin** `string | RegExp | (value) => boolean` - a matcher for the pool origin to be retrieved from the MockAgent.
 
-| Matcher type | Condition to pass            |
-| :----------: | ---------------------------- |
-| `string`     | Exact match against the value |
-| `RegExp`     | The regular expression matches |
-| `Function`   | The function returns `true`  |
+| Matcher type | Condition to pass          |
+|:------------:| -------------------------- |
+| `string`     | Exact match against string |
+| `RegExp`     | Regex must pass            |
+| `Function`   | Function must return true  |
 
-```mjs displayName="Basic mocked request"
+Returns: `MockClient | MockPool`.
+
+| `MockAgentOptions`   | Mock instance returned |
+| -------------------- | ---------------------- |
+| `connections === 1`  | `MockClient`           |
+| `connections` > `1`  | `MockPool`             |
+
+#### Example - Basic Mocked Request
+
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -127,7 +83,9 @@ for await (const data of body) {
 }
 ```
 
-```mjs displayName="Mocked request using a local dispatcher"
+#### Example - Basic Mocked Request with local mock agent dispatcher
+
+```js
 import { MockAgent, request } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -135,9 +93,10 @@ const mockAgent = new MockAgent()
 const mockPool = mockAgent.get('http://localhost:3000')
 mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
 
-const { statusCode, body } = await request('http://localhost:3000/foo', {
-  dispatcher: mockAgent
-})
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo', { dispatcher: mockAgent })
 
 console.log('response received', statusCode) // response received 200
 
@@ -146,27 +105,31 @@ for await (const data of body) {
 }
 ```
 
-```mjs displayName="Testing code that accepts a pool"
-import { MockAgent } from 'undici'
-
-async function getStatus (pool) {
-  const { statusCode } = await pool.request({
-    path: '/foo',
-    method: 'GET'
-  })
+#### Example - Basic Mocked Request with local mock pool dispatcher
 
-  return statusCode
-}
+```js
+import { MockAgent, request } from 'undici'
 
 const mockAgent = new MockAgent()
+
 const mockPool = mockAgent.get('http://localhost:3000')
+mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
+
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo', { dispatcher: mockPool })
 
-mockPool.intercept({ path: '/foo', method: 'GET' }).reply(200)
+console.log('response received', statusCode) // response received 200
 
-console.log(await getStatus(mockPool)) // 200
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
 ```
 
-```mjs displayName="Returning a MockClient"
+#### Example - Basic Mocked Request with local mock client dispatcher
+
+```js
 import { MockAgent, request } from 'undici'
 
 const mockAgent = new MockAgent({ connections: 1 })
@@ -174,9 +137,10 @@ const mockAgent = new MockAgent({ connections: 1 })
 const mockClient = mockAgent.get('http://localhost:3000')
 mockClient.intercept({ path: '/foo' }).reply(200, 'foo')
 
-const { statusCode, body } = await request('http://localhost:3000/foo', {
-  dispatcher: mockClient
-})
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo', { dispatcher: mockClient })
 
 console.log('response received', statusCode) // response received 200
 
@@ -185,64 +149,129 @@ for await (const data of body) {
 }
 ```
 
-```mjs displayName="Matching the origin with a regular expression"
+#### Example - Basic Mocked requests with multiple intercepts
+
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
 setGlobalDispatcher(mockAgent)
 
-const mockPool = mockAgent.get(new RegExp('http://localhost:3000'))
+const mockPool = mockAgent.get('http://localhost:3000')
 mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
+mockPool.intercept({ path: '/hello'}).reply(200, 'hello')
 
-const { statusCode } = await request('http://localhost:3000/foo')
+const result1 = await request('http://localhost:3000/foo')
 
-console.log('response received', statusCode) // response received 200
+console.log('response received', result1.statusCode) // response received 200
+
+for await (const data of result1.body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+
+const result2 = await request('http://localhost:3000/hello')
+
+console.log('response received', result2.statusCode) // response received 200
+
+for await (const data of result2.body) {
+  console.log('data', data.toString('utf8')) // data hello
+}
 ```
+#### Example - Mock different requests within the same file
+```js
+const { MockAgent, setGlobalDispatcher } = require('undici');
+const agent = new MockAgent();
+agent.disableNetConnect();
+setGlobalDispatcher(agent);
+describe('Test', () => {
+  it('200', async () => {
+    const mockAgent = agent.get('http://test.com');
+    // your test
+  });
+  it('200', async () => {
+    const mockAgent = agent.get('http://testing.com');
+    // your test
+  });
+});
+```
+
+#### Example - Mocked request with query body, headers and trailers
 
-```mjs displayName="Matching the origin with a function"
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
 setGlobalDispatcher(mockAgent)
 
-const mockPool = mockAgent.get((origin) => origin === 'http://localhost:3000')
-mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
+const mockPool = mockAgent.get('http://localhost:3000')
 
-const { statusCode } = await request('http://localhost:3000/foo')
+mockPool.intercept({
+  path: '/foo?hello=there&see=ya',
+  method: 'POST',
+  body: 'form1=data1&form2=data2'
+}).reply(200, { foo: 'bar' }, {
+  headers: { 'content-type': 'application/json' },
+  trailers: { 'Content-MD5': 'test' }
+})
+
+const {
+  statusCode,
+  headers,
+  trailers,
+  body
+} = await request('http://localhost:3000/foo?hello=there&see=ya', {
+  method: 'POST',
+  body: 'form1=data1&form2=data2'
+})
 
 console.log('response received', statusCode) // response received 200
+console.log('headers', headers) // { 'content-type': 'application/json' }
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // '{"foo":"bar"}'
+}
+
+console.log('trailers', trailers) // { 'content-md5': 'test' }
 ```
 
-### `mockAgent.dispatch(options, handler)`
+#### Example - Mocked request with origin regex
 
-<!-- YAML
-added: v4.0.0
--->
+```js
+import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
-* `options` {AgentDispatchOptions}
-* `handler` {DispatchHandler}
-* Returns: {boolean}
+const mockAgent = new MockAgent()
+setGlobalDispatcher(mockAgent)
 
-Dispatches a mocked request. This implements
-[`Dispatcher.dispatch()`][] for the encapsulated agent: it ensures the mock
-dispatcher for `options.origin` exists, records the call in the call history
-when enabled, and forwards the request to the underlying agent. It is normally
-invoked indirectly through higher-level methods such as
-[`mockAgent.request()`][].
+const mockPool = mockAgent.get(new RegExp('http://localhost:3000'))
+mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
 
-```mjs displayName="Using mockAgent.request()"
-import { MockAgent } from 'undici'
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo')
+
+console.log('response received', statusCode) // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+#### Example - Mocked request with origin function
+
+```js
+import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
+setGlobalDispatcher(mockAgent)
 
-const mockPool = mockAgent.get('http://localhost:3000')
+const mockPool = mockAgent.get((origin) => origin === 'http://localhost:3000')
 mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
 
-const { statusCode, body } = await mockAgent.request({
-  origin: 'http://localhost:3000',
-  path: '/foo',
-  method: 'GET'
-})
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo')
 
 console.log('response received', statusCode) // response received 200
 
@@ -251,19 +280,15 @@ for await (const data of body) {
 }
 ```
 
-### `mockAgent.close()`
+### `MockAgent.close()`
 
-<!-- YAML
-added: v4.0.0
--->
+Closes the mock agent and waits for registered mock pools and clients to also close before resolving.
 
-* Returns: {Promise<void>} Resolves once the agent and its registered mock pools
-  and clients have closed.
+Returns: `Promise<void>`
 
-Clears the call history, closes the encapsulated agent, and waits for all
-registered mock pools and clients to close.
+#### Example - clean up after tests are complete
 
-```mjs displayName="Clean up after tests"
+```js
 import { MockAgent, setGlobalDispatcher } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -272,18 +297,49 @@ setGlobalDispatcher(mockAgent)
 await mockAgent.close()
 ```
 
-### `mockAgent.deactivate()`
+### `MockAgent.dispatch(options, handlers)`
+
+Implements [`Agent.dispatch(options, handlers)`](Agent.md#parameter-agentdispatchoptions).
+
+### `MockAgent.request(options[, callback])`
+
+See [`Dispatcher.request(options [, callback])`](Dispatcher.md#dispatcherrequestoptions-callback).
+
+#### Example - MockAgent request
 
-<!-- YAML
-added: v4.0.0
--->
+```js
+import { MockAgent } from 'undici'
 
-* Returns: {undefined}
+const mockAgent = new MockAgent()
 
-Disables mocking on the `MockAgent`. While deactivated, requests are no longer
-intercepted.
+const mockPool = mockAgent.get('http://localhost:3000')
+mockPool.intercept({ path: '/foo' }).reply(200, 'foo')
 
-```mjs displayName="Deactivate mocking"
+const {
+  statusCode,
+  body
+} = await mockAgent.request({
+  origin: 'http://localhost:3000',
+  path: '/foo',
+  method: 'GET'
+})
+
+console.log('response received', statusCode) // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+### `MockAgent.deactivate()`
+
+This method disables mocking in MockAgent.
+
+Returns: `void`
+
+#### Example - Deactivate Mocking
+
+```js
 import { MockAgent, setGlobalDispatcher } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -292,19 +348,15 @@ setGlobalDispatcher(mockAgent)
 mockAgent.deactivate()
 ```
 
-### `mockAgent.activate()`
+### `MockAgent.activate()`
 
-<!-- YAML
-added: v4.0.0
--->
+This method enables mocking in a MockAgent instance. When instantiated, a MockAgent is automatically activated. Therefore, this method is only effective after `MockAgent.deactivate` has been called.
 
-* Returns: {undefined}
+Returns: `void`
 
-Enables mocking on the `MockAgent`. A `MockAgent` is activated automatically
-when instantiated, so this method is only required after
-[`mockAgent.deactivate()`][] has been called.
+#### Example - Activate Mocking
 
-```mjs displayName="Re-activate mocking"
+```js
 import { MockAgent, setGlobalDispatcher } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -317,23 +369,21 @@ mockAgent.deactivate()
 mockAgent.activate()
 ```
 
-### `mockAgent.enableNetConnect([matcher])`
+### `MockAgent.enableNetConnect([host])`
+
+When requests are not matched in a MockAgent intercept, a real HTTP request is attempted. We can control this further through the use of `enableNetConnect`. This is achieved by defining host matchers so only matching requests will be attempted.
 
-<!-- YAML
-added: v4.0.0
--->
+When using a string, it should only include the **hostname and optionally, the port**. In addition, calling this method multiple times with a string will allow all HTTP requests that match these values.
 
-* `matcher` {string|RegExp|Function} (optional) A host matcher. When a string is
-  used it should only contain the hostname and, optionally, the port. The
-  function form has the signature `(host) => boolean`. When omitted, all
-  non-matching requests are allowed to perform a real request.
-* Returns: {undefined}
+Arguments:
 
-Defines host matchers so that requests that are not intercepted by a mock
-dispatcher are allowed to perform a real HTTP request. Calling this method
-multiple times with a string appends each value to the list of allowed hosts.
+* **host** `string | RegExp | (value) => boolean` - (optional)
 
-```mjs displayName="Allow all non-matching requests"
+Returns: `void`
+
+#### Example - Allow all non-matching urls to be dispatched in a real HTTP request
+
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -345,7 +395,9 @@ await request('http://example.com')
 // A real request is made
 ```
 
-```mjs displayName="Allow requests matching specific hosts"
+#### Example - Allow requests matching a host string to make real requests
+
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
@@ -364,167 +416,75 @@ await request('http://example-3.com')
 // Will throw
 ```
 
-```mjs displayName="Allow requests matching a regular expression or function"
+#### Example - Allow requests matching a host regex to make real requests
+
+```js
 import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
 setGlobalDispatcher(mockAgent)
 
 mockAgent.enableNetConnect(new RegExp('example.com'))
-mockAgent.enableNetConnect((host) => host === 'example.org')
 
 await request('http://example.com')
 // A real request is made
 ```
 
-### `mockAgent.disableNetConnect()`
-
-<!-- YAML
-added: v4.0.0
--->
+#### Example - Allow requests matching a host function to make real requests
 
-* Returns: {undefined}
-
-Causes every request that is not matched by a mock interceptor to throw,
-disallowing real HTTP requests.
-
-```mjs displayName="Throw on every non-matching request"
-import { MockAgent, request } from 'undici'
+```js
+import { MockAgent, setGlobalDispatcher, request } from 'undici'
 
 const mockAgent = new MockAgent()
+setGlobalDispatcher(mockAgent)
 
-mockAgent.disableNetConnect()
+mockAgent.enableNetConnect((value) => value === 'example.com')
 
 await request('http://example.com')
-// Will throw
+// A real request is made
 ```
 
-### `mockAgent.enableCallHistory()`
+### `MockAgent.disableNetConnect()`
 
-<!-- YAML
-added: v7.5.0
--->
+This method causes all requests to throw when requests are not matched in a MockAgent intercept.
 
-* Returns: {MockAgent} The same `MockAgent` instance, for chaining.
+Returns: `void`
 
-Enables call history recording. Once enabled, subsequent calls are registered
-and can be retrieved through [`mockAgent.getCallHistory()`][]. Call history can
-also be enabled at construction time with the `enableCallHistory` option.
+#### Example - Disable all non-matching requests by throwing an error for each
 
-```mjs
-import { MockAgent } from 'undici'
+```js
+import { MockAgent, request } from 'undici'
 
 const mockAgent = new MockAgent()
 
-mockAgent.enableCallHistory()
-```
-
-### `mockAgent.disableCallHistory()`
-
-<!-- YAML
-added: v7.5.0
--->
-
-* Returns: {MockAgent} The same `MockAgent` instance, for chaining.
-
-Disables call history recording. Subsequent calls are no longer registered.
-
-```mjs
-import { MockAgent } from 'undici'
-
-const mockAgent = new MockAgent({ enableCallHistory: true })
-
-mockAgent.disableCallHistory()
-```
-
-### `mockAgent.getCallHistory()`
-
-<!-- YAML
-added: v7.5.0
--->
-
-* Returns: {MockCallHistory|undefined} The {MockCallHistory} instance, or
-  `undefined` when call history is not enabled.
-
-Returns the call history instance, which records every request made through the
-`MockAgent` (whether intercepted or not). Call history is not enabled by
-default; enable it with the `enableCallHistory` option or
-[`mockAgent.enableCallHistory()`][].
-
-```mjs displayName="Inspect recorded calls"
-import { MockAgent, setGlobalDispatcher, request } from 'undici'
-
-const mockAgent = new MockAgent({ enableCallHistory: true })
-setGlobalDispatcher(mockAgent)
-
-await request('http://example.com', { query: { item: 1 } })
-
-mockAgent.getCallHistory()?.firstCall()
-// Returns
-// MockCallHistoryLog {
-//   body: undefined,
-//   headers: undefined,
-//   method: 'GET',
-//   origin: 'http://example.com',
-//   fullUrl: 'http://example.com/?item=1',
-//   path: '/',
-//   searchParams: { item: '1' },
-//   protocol: 'http:',
-//   host: 'example.com',
-//   port: ''
-// }
-```
-
-### `mockAgent.clearCallHistory()`
-
-<!-- YAML
-added: v7.5.0
--->
-
-* Returns: {undefined}
-
-Clears the call history, deleting every recorded {MockCallHistoryLog} on the
-{MockCallHistory} instance. It is a no-op when call history has never been
-enabled.
-
-```mjs
-import { MockAgent } from 'undici'
-
-const mockAgent = new MockAgent({ enableCallHistory: true })
+mockAgent.disableNetConnect()
 
-mockAgent.clearCallHistory()
+await request('http://example.com')
+// Will throw
 ```
 
-### `mockAgent.pendingInterceptors()`
+### `MockAgent.pendingInterceptors()`
 
-<!-- YAML
-added: v5.1.0
--->
+This method returns any pending interceptors registered on a mock agent. A pending interceptor meets one of the following criteria:
 
-* Returns: {PendingInterceptor[]} A `PendingInterceptor` is a `MockDispatch`
-  with an additional `origin` {string} property.
+- Is registered with neither `.times(<number>)` nor `.persist()`, and has not been invoked;
+- Is persistent (i.e., registered with `.persist()`) and has not been invoked;
+- Is registered with `.times(<number>)` and has not been invoked `<number>` of times.
 
-Returns the interceptors registered on the `MockAgent` that are still pending.
-An interceptor is pending when it meets one of the following criteria:
+Returns: `PendingInterceptor[]` (where `PendingInterceptor` is a `MockDispatch` with an additional `origin: string`)
 
-* It is registered with neither `.times(<number>)` nor `.persist()` and has not
-  been invoked.
-* It is persistent (registered with `.persist()`) and has not been invoked.
-* It is registered with `.times(<number>)` and has not been invoked `<number>`
-  times.
+#### Example - List all pending inteceptors
 
-```mjs displayName="List pending interceptors"
-import { MockAgent } from 'undici'
+```js
+const agent = new MockAgent()
+agent.disableNetConnect()
 
-const mockAgent = new MockAgent()
-mockAgent.disableNetConnect()
-
-mockAgent
+agent
   .get('https://example.com')
   .intercept({ method: 'GET', path: '/' })
   .reply(200)
 
-const pendingInterceptors = mockAgent.pendingInterceptors()
+const pendingInterceptors = agent.pendingInterceptors()
 // Returns [
 //   {
 //     timesInvoked: 0,
@@ -548,35 +508,26 @@ const pendingInterceptors = mockAgent.pendingInterceptors()
 // ]
 ```
 
-### `mockAgent.assertNoPendingInterceptors([options])`
+### `MockAgent.assertNoPendingInterceptors([options])`
 
-<!-- YAML
-added: v5.1.0
--->
+This method throws if the mock agent has any pending interceptors. A pending interceptor meets one of the following criteria:
 
-* `options` {Object} (optional)
-  * `pendingInterceptorsFormatter` {Object} An object exposing a
-    `format(pendingInterceptors)` method used to render the pending interceptors
-    in the thrown error message. **Default:** a built-in formatter that prints a
-    table.
-* Returns: {undefined}
+- Is registered with neither `.times(<number>)` nor `.persist()`, and has not been invoked;
+- Is persistent (i.e., registered with `.persist()`) and has not been invoked;
+- Is registered with `.times(<number>)` and has not been invoked `<number>` of times.
 
-Throws an {UndiciError} when the `MockAgent` has any pending interceptors. The
-criteria for an interceptor being pending are the same as for
-[`mockAgent.pendingInterceptors()`][].
+#### Example - Check that there are no pending interceptors
 
-```mjs displayName="Assert there are no pending interceptors"
-import { MockAgent } from 'undici'
-
-const mockAgent = new MockAgent()
-mockAgent.disableNetConnect()
+```js
+const agent = new MockAgent()
+agent.disableNetConnect()
 
-mockAgent
+agent
   .get('https://example.com')
   .intercept({ method: 'GET', path: '/' })
   .reply(200)
 
-mockAgent.assertNoPendingInterceptors()
+agent.assertNoPendingInterceptors()
 // Throws an UndiciError with the following message:
 //
 // 1 interceptor is pending:
@@ -587,36 +538,3 @@ mockAgent.assertNoPendingInterceptors()
 // │    0    │ 'GET'  │ 'https://example.com' │ '/'  │     200     │    '❌'    │      0      │     1     │
 // └─────────┴────────┴───────────────────────┴──────┴─────────────┴────────────┴─────────────┴───────────┘
 ```
-
-### `mockAgent.isMockActive`
-
-<!-- YAML
-added: v5.3.0
--->
-
-* Type: {boolean} `true` while mocking is active, `false` after
-  [`mockAgent.deactivate()`][] has been called.
-
-A read-only property indicating whether mocking is currently active on the
-`MockAgent`.
-
-```mjs
-import { MockAgent } from 'undici'
-
-const mockAgent = new MockAgent()
-
-console.log(mockAgent.isMockActive) // true
-
-mockAgent.deactivate()
-
-console.log(mockAgent.isMockActive) // false
-```
-
-[`Dispatcher.dispatch()`]: Dispatcher.md#dispatcherdispatchoptions-handler
-[`mockAgent.deactivate()`]: #mockagentdeactivate
-[`mockAgent.enableCallHistory()`]: #mockagentenablecallhistory
-[`mockAgent.get(origin)`]: #mockagentgetorigin
-[`mockAgent.getCallHistory()`]: #mockagentgetcallhistory
-[`mockAgent.pendingInterceptors()`]: #mockagentpendinginterceptors
-[`mockAgent.request()`]: Dispatcher.md#dispatcherrequestoptions-callback
-[`setGlobalDispatcher()`]: Dispatcher.md#setglobaldispatcherdispatcher