Initial commit

Author: kevin940726

.babelrc

@@ -0,0 +1,13 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "loose": true,
+        "targets": {
+          "node": "10"
+        }
+      }
+    ]
+  ]
+}

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+/dist

index.js

@@ -0,0 +1,120 @@
+import { Console } from 'console';
+import { Writable } from 'stream';
+
+// Keep an instance of the original console and export it
+const originalConsole = global.console;
+
+export { originalConsole };
+
+const instances = new WeakMap();
+
+const LEVELS = {
+  log: [
+    'log',
+    'trace',
+    'dir',
+    'dirxml',
+    'group',
+    'groupCollapsed',
+    'debug',
+    'timeLog',
+  ],
+  info: ['count', 'info', 'timeEnd'],
+  warn: ['warn', 'countReset'],
+  error: ['error', 'assert'],
+};
+
+export function createConsole() {
+  let logs = [];
+  let levels = {
+    log: '',
+    info: '',
+    warn: '',
+    error: '',
+  };
+  let currentLevel = undefined;
+
+  const writable = new Writable({
+    write(chunk, encoding, callback) {
+      logs.push([currentLevel, chunk.toString('utf8')]);
+      if (currentLevel && currentLevel in levels) {
+        levels[currentLevel] += chunk;
+      }
+      callback();
+    },
+  });
+
+  const jestConsole = new Console({
+    stdout: writable,
+    stderr: writable,
+  });
+
+  Object.getOwnPropertyNames(jestConsole).forEach(property => {
+    if (typeof jestConsole[property] === 'function') {
+      const originalFunction = jestConsole[property];
+      jestConsole[property] = function() {
+        currentLevel = undefined;
+        Object.keys(LEVELS).forEach(level => {
+          if (LEVELS[level].includes(property)) {
+            currentLevel = level;
+          }
+        });
+
+        return originalFunction.apply(this, arguments);
+      };
+
+      if (typeof jest === 'object' && typeof jest.spyOn === 'function') {
+        jest.spyOn(jestConsole, property);
+      }
+    }
+  });
+
+  instances.set(jestConsole, {
+    get log() {
+      return logs.map(log => log[1]).join('');
+    },
+    get logs() {
+      return logs;
+    },
+    levels: {
+      get log() {
+        return levels.log;
+      },
+      get info() {
+        return levels.info;
+      },
+      get warn() {
+        return levels.warn;
+      },
+      get error() {
+        return levels.error;
+      },
+    },
+  });
+
+  return jestConsole;
+}
+
+export function mockConsole(jestConsole) {
+  const originalConsole = global.console;
+
+  global.console = jestConsole;
+
+  return () => {
+    global.console = originalConsole;
+  };
+}
+
+export function getLog(jestConsole = global.console) {
+  return instances.get(jestConsole);
+}
+
+if (typeof beforeEach === 'function' && typeof afterEach === 'function') {
+  let cleanup = () => {};
+
+  beforeEach(() => {
+    cleanup = mockConsole(createConsole());
+  });
+
+  afterEach(cleanup);
+}

package.json

@@ -0,0 +1,58 @@
+{
+  "name": "jest-console",
+  "version": "0.0.0",
+  "description": "Console mock for Jest",
+  "type": "module",
+  "main": "dist/jest-console.js",
+  "exports": {
+    ".": {
+      "require": "dist/jest-console.js",
+      "default": "index.js"
+    }
+  },
+  "repository": "https://github.com/kevin940726/jest-console.git",
+  "author": "Kai Hao",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "babel index.js -o dist/jest-console.js",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.7.4",
+    "@babel/core": "^7.7.4",
+    "@babel/preset-env": "^7.7.4",
+    "canopic": "^0.2.1"
+  },
+  "eslintConfig": {
+    "extends": "react-app"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,css,json,md,mdx,html}": [
+      "prettier --write",
+      "git add"
+    ],
+    "*.{js,jsx,ts,tsx}": [
+      "eslint --fix",
+      "git add"
+    ]
+  },
+  "prettier": {
+    "printWidth": 80,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "quoteProps": "as-needed",
+    "jsxSingleQuote": false,
+    "trailingComma": "es5",
+    "bracketSpacing": true,
+    "jsxBracketSameLine": false,
+    "arrowParens": "avoid"
+  }
+}

test.js

@@ -0,0 +1,111 @@
+const { getLog } = require('./');
+
+expect(jest.isMockFunction(console.log)).toBe(false);
+
+test('simple', () => {
+  console.log('Hello %s!', 'World');
+
+  expect(getLog().log).toMatchInlineSnapshot(`
+    "Hello World!
+    "
+  `);
+});
+
+test('advanced', () => {
+  console.log(
+    'It works with inline value: %s, as well as floating point value: %f. Pretty cool!',
+    'foobar',
+    3.14
+  );
+  console.log(
+    'Map: %o,\nSet: %o,\nSymbol: %o,\nobject: %o,\nfunction: %o',
+    new Map([['foo', 42]]),
+    new Set([42]),
+    Symbol('symbol'),
+    { foo: 42 },
+    function foo() {
+      return 42;
+    }
+  );
+  console.error('It works with error too');
+  console.warn('It works with warning too');
+
+  expect(getLog().log).toMatchInlineSnapshot(`
+    "It works with inline value: foobar, as well as floating point value: 3.14. Pretty cool!
+    Map: Map { 'foo' => 42, [size]: 1 },
+    Set: Set { 42, [size]: 1 },
+    Symbol: Symbol(symbol),
+    object: { foo: 42 },
+    function: [Function: foo] {
+      [length]: 0,
+      [name]: 'foo',
+      [prototype]: foo { [constructor]: [Circular] }
+    }
+    It works with error too
+    It works with warning too
+    "
+  `);
+  expect(getLog().logs).toMatchInlineSnapshot(`
+    Array [
+      Array [
+        "log",
+        "It works with inline value: foobar, as well as floating point value: 3.14. Pretty cool!
+    ",
+      ],
+      Array [
+        "log",
+        "Map: Map { 'foo' => 42, [size]: 1 },
+    Set: Set { 42, [size]: 1 },
+    Symbol: Symbol(symbol),
+    object: { foo: 42 },
+    function: [Function: foo] {
+      [length]: 0,
+      [name]: 'foo',
+      [prototype]: foo { [constructor]: [Circular] }
+    }
+    ",
+      ],
+      Array [
+        "error",
+        "It works with error too
+    ",
+      ],
+      Array [
+        "warn",
+        "It works with warning too
+    ",
+      ],
+    ]
+  `);
+  expect(getLog().levels.log).toMatchInlineSnapshot(`
+    "It works with inline value: foobar, as well as floating point value: 3.14. Pretty cool!
+    Map: Map { 'foo' => 42, [size]: 1 },
+    Set: Set { 42, [size]: 1 },
+    Symbol: Symbol(symbol),
+    object: { foo: 42 },
+    function: [Function: foo] {
+      [length]: 0,
+      [name]: 'foo',
+      [prototype]: foo { [constructor]: [Circular] }
+    }
+    "
+  `);
+  expect(getLog().levels.warn).toMatchInlineSnapshot(`
+    "It works with warning too
+    "
+  `);
+  expect(getLog().levels.error).toMatchInlineSnapshot(`
+    "It works with error too
+    "
+  `);
+});
+
+test('they are also mock functions', () => {
+  console.log.mockImplementationOnce(() => {});
+
+  console.log('Will not output');
+
+  expect(console.log).toHaveBeenCalledTimes(1);
+  expect(getLog().log).toBe('');
+  expect(getLog().logs).toMatchInlineSnapshot(`Array []`);
+});