kevin940726

console-testing-library

  "description": "Testing console the right way",

  "main": "dist/console-testing-library.js",

      "require": "dist/console-testing-library.js",

  "repository": "https://github.com/kevin940726/console-testing-library.git",

    "build": "babel index.js -o dist/console-testing-library.js",

    "*.{js,jsx,ts,tsx,css,json,md,mdx,html}": [

It's rare to have `console` in your code, it's more often seen in libraries to provide helpful debugging warnings. When trying to mock `console` in tests, we often just `spyOn` the methods being used and observe the mock calls. This works great if your message is simple, but it can also have false-negative.

Consider a situation where we want to log inspectable objects, to make it prettily printed in TTY environments, and interactable in browser's console. There are only 2 options we can do in order to achieve with the current console API. Either by string substitution or with arguments concatenation.

console.error('I want to log this object: %o, and make it inspectable', obj);

console.error('I want to log this object:', obj, ', and make it inspectable');

We could use Jest's `toHaveBeenCalledWith` here, but the tests would look like this.

expect(console.error).toHaveBeenCalledWith(

  'I want to log this object: %o, and make it inspectable',

Either way is not ideal, we are just repeating the source code here, we're not testing what the user really sees, but what the code looks like. Every time when the message changed, we have to update the test too, which makes it a fragile test. In addition, what if `obj` is not inspectable? Or not valid? Or simply not what we want? We cannot be sure without actually logging the message.

A better solution would be to get the actual output of the logs and test it against the expected output.

  'I want to log this object: { "foo": 42 }, and make it inspectable'

With `console-testing-library`, we can easily do that without extra hassles.

import { getLog } from 'console-testing-library';

With the help of Jest's `toMatchInlineSnapshot`, we can even let it generate the log snapshot inline.

expect(getLog().log).toMatchInlineSnapshot();

expect(console.log).toMatchInlineSnapshot();

Just import it before calling `console.log` or the family.

  // No logs will be output to the console

If you want to get the current logs, import the `getLog` helper.

  // Note that in real world console.log will output a new line character in the end,

  // but in our case, we remove that since we don't really care about it.

  expect(getLog().log).toBe('Hello World!');

All the methods in `console` are available and automatically mocked.

If your tests run with Jest then the `global.console` is automatically mocked. If you wish to have more control and manually mock it, then import the package from `pure` entry.

import { createConsole, mockConsole } from 'console-testing-library/pure';

  restore = mockConsole(createConsole());

It's often recommended to use `console-testing-library` with Jest's [`toMatchInlineSnapshot`](https://jestjs.io/docs/en/expect#tomatchinlinesnapshotpropertymatchers-inlinesnapshot) matcher. It makes it really easy to test the console output with confidence.

We also support custom `toMatchInlineSnapshot` matcher to test against mocked `console[method]` and `console`.

// expect(getLog().log).toMatchInlineSnapshot();

// is basically `expect(console.log).toHaveBeenCalledWith` for actual output,

// it will only get the logs calling from `log` method.

By default, the console is mocked to be silent. That is, calling `console.log` would not output any actual log to the console, but swallowed into `getLog()`. If you still want to log the output, you can call `silenceConsole`.

import { silenceConsole } from 'console-testing-library';

console.log('It should be silent.'); // No output

silenceConsole(false); // Set to be not silent

console.log('It should now output the log to console'); // Has output

silenceConsole(true); // Can set it back to be silent

If the `console` is created by `createConsole`, `silenceConsole` can be called like below.

		{
		"name": "console-testing-library",
		"version": "0.2.2",
		"version": "0.3.0",
		"description": "Testing console the right way",
		"type": "module",
		"main": "dist/console-testing-library.js",
		"main": "dist/index.js",
		"typings": "index.d.ts",
		"exports": {
		".": {
		"require": "dist/console-testing-library.js",
		"default": "index.js"
		"require": "dist/index.js",
		"default": "src/index.js"
		},
		"./pure": {
		"require": "dist/pure.js",
		"default": "src/pure.js"
		}
		@@ -19,3 +23,3 @@ },
		"scripts": {
		"build": "babel index.js -o dist/console-testing-library.js",
		"build": "babel src -d dist",
		"test": "jest",
		@@ -22,0 +26,0 @@ "prepare": "yarn build && yarn test"

		@@ -179,2 +179,18 @@ # `console-testing-library`

		## Manually mocking with Jest

		If your tests run with Jest then the `global.console` is automatically mocked. If you wish to have more control and manually mock it, then import the package from `pure` entry.

		```js
		import { createConsole, mockConsole } from 'console-testing-library/pure';

		let restore = () => {};

		beforeEach(() => {
		restore = mockConsole(createConsole());
		});

		afterEach(() => restore());
		```

		## Custom matchers
		@@ -181,0 +197,0 @@

New alerts

Improved metrics

Worsened metrics