TestingModule

A compiled testing module, which runs handlers as the bot does and resolves the classes it built.

Use invoke to run a handler you name, dispatch to send an input through the bot's routing, and emit for a gateway event. getResponse then reports what a handler sent.

The module's ThemeCache: the instance its classes inject, holding what themeFor, or overrideThemeFor, looked up in this module's calls. Clear a result to have the next call look it up again. Each module has its own.

Runs the onShutdown hooks of every class and provided value the module has constructed, once, as the bot does when it stops: one at a time, in reverse, so a class stops before the classes and providers it uses. A factory's value, such as a connection pool init() made, is closed after everything that injects it, whether or not init({ ready: true }) ran. Nothing is constructed just to be shut down. Every hook runs even when one fails. Calling it again does nothing more.

It first gives up the theme read outside calls, if init({ ready: true }) made it this module's; reads outside calls then return MeoCord's defaults until another module or app is ready.

The cooldown store and what it injects shut down last, in the same sequence as the bot's. When any of them has an onShutdown, the calls invoke, dispatch and emit have under way finish first, then the store operations they started, so the store's last writes still reach it. The module stops waiting for the whole sequence after its shutdownTimeout, 10 seconds unless set, and logs that it did. Give a test whose fake store never answers, or whose onShutdown never settles, a short shutdownTimeout.

Once every hook has run. Rejects with the error of a hook that failed, or an AggregateError naming each when several did.

Sends an interaction, a message or a reaction through the bot's own dispatch: routed over the module's controllers and its app's message options exactly as the bot routes it, then run through the full pipeline of each handler it reaches. What the user is sent is sent to the mock, as the bot sends it: the handler's answer, a usage reply, or the built-in fallback's answer to an error no filter handles. Inputs the bot skips, such as a message from a bot, reach nothing. The module waits for its observers.

dispatch tests what the bot does with an input: which handler it reaches, with what params, and what the user sees. To test one handler you name, whatever would route to it, use invoke.

Every handler reached, in the order it ran, whether any ran, and the first error a call ended with. An error the fallback answers as the user's own outcome resolves: a usage reply, an unknown command, or a guard's, a cooldown's, a validation's or a UserError's refusal, as the fallback answers each for an interaction or a message. Any other error no filter handles rejects the call once the fallback has answered and every handler has run: with that error, or an AggregateError when several were left unhandled.

Every handler reached, in the order it ran, whether any ran, and the first error a call ended with. An error the fallback answers as the user's own outcome resolves: a usage reply, an unknown command, or a guard's, a cooldown's, a validation's or a UserError's refusal, as the fallback answers each for an interaction or a message. Any other error no filter handles rejects the call once the fallback has answered and every handler has run: with that error, or an AggregateError when several were left unhandled.

Emits a client event to the module's @On and @Once handlers, through the same pipeline the app runs them in: the global guards of the module's app, then each handler's own. Handlers on the module's controllers, class providers and their dependencies all receive it. A @Once handler handles only the first event, as it would on a client.

How many handlers ran. Rejects once every handler has settled if any threw: with that error when one handler failed, or an AggregateError of them when several did.

Resolves an instance from the module, as the bot would inject it.

The instance, with its dependencies and overrides applied.

Resolves the module's useFactory providers, awaiting those that return a promise, in dependency order. invoke, dispatch and emit call it first; call it yourself before get resolves anything that depends on an asynchronous factory. Calling it again does nothing more.

With { ready: true }, it then runs every onReady hook once, as the bot does once it is online: one at a time, each class after the classes and providers it injects, the observers' last. Every hook runs even when one fails. Pair it with close, which runs the onShutdown hooks.

Ready, the module's app theme is also the one useTheme() reads outside any call, as a bot's is once it is online, unless another module or app in the process was ready first: that one keeps it, and this module's theme reaches its own calls only. close gives it up; nothing takes it over.

The module, once every factory has made its value and every onReady hook asked for has run. Rejects with the error of a factory or a hook that failed, or an AggregateError of the hooks when several did.

Runs a handler through the same pipeline dispatch runs: @Defer's acknowledgement, the global guards of the module's app, then the handler's own, in order and once each; then the interceptors, the app's first, around validation, pipes, cooldowns and the handler; all inside the handler's exception filters. Guards resolve from this module, so overrideGuard stubs apply and guards that inject ExecutionContext receive it. overrideInterceptor and overrideFilter stubs apply the same way.

Calling the controller method directly runs its guards but no interceptors, validation or filters; invoke is the way to test everything dispatch runs around a handler.

invoke tests one handler you name, and an error no filter handles rejects the call. That includes the errors the bot answers the user with: a guard's GuardDeniedError, a UserError and a CooldownError reject invoke, where dispatch resolves { ran, error } and sends the answer. To test what the bot does with an input, which handler it reaches and what the user is sent, use dispatch.

Whether the handler ran, and the error a filter handled, if any. Rejects with an error no filter handles, or with the error a filter throws: the built-in fallback, which answers such errors in the bot, does not run here. Rejects before running anything with an interaction or a message the handler's route does not match, naming both.