6 | }
7 | }
--------------------------------------------------------------------------------
/test/fixtures/babel-syntax/webpack.config.js:
--------------------------------------------------------------------------------
1 | const FriendlyErrorsWebpackPlugin = require('../../../index');
2 |
3 | module.exports = {
4 | mode: 'production',
5 | entry: __dirname + "/index.js",
6 | output: {
7 | path: __dirname + "/dist",
8 | filename: "bundle.js"
9 | },
10 | plugins: [
11 | new FriendlyErrorsWebpackPlugin()
12 | ],
13 | module: {
14 | rules: [
15 | {
16 | test: /\.jsx?$/,
17 | loader: 'babel-loader',
18 | exclude: /node_modules/
19 | }
20 | ]
21 | }
22 | };
--------------------------------------------------------------------------------
/test/fixtures/eslint-warnings/.eslintrc:
--------------------------------------------------------------------------------
1 | {
2 | "root": true,
3 | "parser": "babel-eslint",
4 | "env": {
5 | "browser": true,
6 | "commonjs": true,
7 | "es6": true,
8 | "jest": true,
9 | "node": true
10 | },
11 | "parserOptions": {
12 | "ecmaVersion": 6,
13 | "sourceType": "module"
14 | },
15 | "rules": {
16 | "no-unused-expressions": "warn",
17 | "no-unused-labels": "warn",
18 | "no-unused-vars": ["warn", { "vars": "local", "args": "none" }]
19 | }
20 | }
--------------------------------------------------------------------------------
/test/fixtures/eslint-warnings/index.js:
--------------------------------------------------------------------------------
1 | require('./module');
2 |
3 | const unused = 'I am unused';
4 | const unused2 = 'I am unused too';
5 |
--------------------------------------------------------------------------------
/test/fixtures/eslint-warnings/module.js:
--------------------------------------------------------------------------------
1 | const unused = 'I am unused';
2 |
--------------------------------------------------------------------------------
/test/fixtures/eslint-warnings/webpack.config.js:
--------------------------------------------------------------------------------
1 | const FriendlyErrorsWebpackPlugin = require('../../../index');
2 |
3 | module.exports = {
4 | mode: 'production',
5 | entry: __dirname + "/index.js",
6 | output: {
7 | path: __dirname + "/dist",
8 | filename: "bundle.js"
9 | },
10 | plugins: [
11 | new FriendlyErrorsWebpackPlugin(),
12 |
13 | ],
14 | module: {
15 | rules: [
16 | {
17 | test: /\.js$/,
18 | loader: 'eslint-loader',
19 | enforce: 'pre',
20 | include: __dirname,
21 | options: {
22 | ignore: false
23 | }
24 | },
25 | {
26 | test: /\.jsx?$/,
27 | loader: 'babel-loader',
28 | exclude: /node_modules/
29 | }
30 | ]
31 | }
32 | };
33 |
--------------------------------------------------------------------------------
/test/fixtures/module-errors/index.js:
--------------------------------------------------------------------------------
1 | require('not-found');
2 | require('./non-existing');
3 | require('../non-existing');
4 |
--------------------------------------------------------------------------------
/test/fixtures/module-errors/webpack.config.js:
--------------------------------------------------------------------------------
1 |
2 | const FriendlyErrorsWebpackPlugin = require('../../../index');
3 |
4 | module.exports = {
5 | mode: 'production',
6 | entry: __dirname + "/index.js",
7 | output: {
8 | path: __dirname + "/dist",
9 | filename: "bundle.js"
10 | },
11 | plugins: [
12 | new FriendlyErrorsWebpackPlugin()
13 | ]
14 | };
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-module-errors/index.js:
--------------------------------------------------------------------------------
1 | require('./non-existing');
2 |
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-module-errors/index2.js:
--------------------------------------------------------------------------------
1 | require('not-found');
2 |
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-module-errors/webpack.config.js:
--------------------------------------------------------------------------------
1 | module.exports = [
2 | {
3 | mode: 'production',
4 | entry: __dirname + "/index.js",
5 | output: {
6 | path: __dirname + "/dist",
7 | filename: "bundle.js"
8 | }
9 | },
10 | {
11 | mode: 'production',
12 | entry: __dirname + "/index2.js",
13 | output: {
14 | path: __dirname + "/dist",
15 | filename: "bundle2.js"
16 | }
17 | }
18 | ];
19 |
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-success/index.js:
--------------------------------------------------------------------------------
1 | module.exports = 'I am an entry point';
2 |
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-success/index2.js:
--------------------------------------------------------------------------------
1 | module.exports = 'I am another entry point';
2 |
--------------------------------------------------------------------------------
/test/fixtures/multi-compiler-success/webpack.config.js:
--------------------------------------------------------------------------------
1 | module.exports = [
2 | {
3 | mode: 'production',
4 | entry: __dirname + "/index.js",
5 | output: {
6 | path: __dirname + "/dist",
7 | filename: "bundle.js"
8 | }
9 | },
10 | {
11 | mode: 'production',
12 | entry: __dirname + "/index2.js",
13 | output: {
14 | path: __dirname + "/dist",
15 | filename: "bundle2.js"
16 | }
17 | }
18 | ];
19 |
--------------------------------------------------------------------------------
/test/fixtures/success/index.js:
--------------------------------------------------------------------------------
1 | module.exports = 'I am an entry point';
2 |
--------------------------------------------------------------------------------
/test/fixtures/success/webpack.config.js:
--------------------------------------------------------------------------------
1 | const FriendlyErrorsWebpackPlugin = require('../../../index');
2 |
3 | module.exports = {
4 | mode: 'production',
5 | entry: __dirname + "/index.js",
6 | output: {
7 | path: __dirname + "/dist",
8 | filename: "bundle.js"
9 | },
10 | plugins: [
11 | new FriendlyErrorsWebpackPlugin()
12 | ]
13 | };
14 |
--------------------------------------------------------------------------------
/test/integration.spec.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const webpack = require('webpack')
4 | const FriendlyErrorsWebpackPlugin = require('../src/friendly-errors-plugin')
5 | const MemoryFileSystem = require('memory-fs')
6 | const path = require('path')
7 | const { captureReports } = require('./utils')
8 |
9 | const webpackPromise = function (config, globalPlugins) {
10 | const compiler = webpack(config)
11 | compiler.outputFileSystem = new MemoryFileSystem()
12 | if (Array.isArray(globalPlugins)) {
13 | globalPlugins.forEach(p => p.apply(compiler))
14 | }
15 |
16 | return new Promise((resolve, reject) => {
17 | compiler.run(err => {
18 | if (err) {
19 | reject(err)
20 | }
21 | resolve()
22 | })
23 | })
24 | }
25 |
26 | async function executeAndGetLogs (fixture, globalPlugins, reporter) {
27 | const config = require(fixture)
28 | reporter = (globalPlugins || config.plugins)[0].reporter
29 | return captureReports(reporter, () => webpackPromise(config, globalPlugins))
30 | }
31 |
32 | it('integration : success', async () => {
33 | const logs = await executeAndGetLogs('./fixtures/success/webpack.config')
34 |
35 | expect(logs.join('\n')).toMatch(/DONE {2}Compiled successfully in (.\d*)ms/)
36 | })
37 |
38 | it('integration : module-errors', async () => {
39 | const logs = await executeAndGetLogs('./fixtures/module-errors/webpack.config.js')
40 |
41 | expect(logs).toEqual([
42 | 'ERROR Failed to compile with 3 errors',
43 | '',
44 | 'This dependency was not found:',
45 | '',
46 | '* not-found in ./test/fixtures/module-errors/index.js',
47 | '',
48 | 'To install it, you can run: npm install --save not-found',
49 | '',
50 | '',
51 | 'These relative modules were not found:',
52 | '',
53 | '* ../non-existing in ./test/fixtures/module-errors/index.js',
54 | '* ./non-existing in ./test/fixtures/module-errors/index.js'
55 | ])
56 | })
57 |
58 | function filename (filePath) {
59 | return path.join(__dirname, path.normalize(filePath))
60 | }
61 |
62 | it('integration : should display eslint warnings', async () => {
63 | const logs = await executeAndGetLogs('./fixtures/eslint-warnings/webpack.config.js')
64 |
65 | expect(logs.join('\n')).toEqual(
66 | `WARN Compiled with 2 warnings
67 |
68 | Module Warning (from ./node_modules/eslint-loader/index.js):
69 |
70 | ${filename('fixtures/eslint-warnings/index.js')}
71 | 3:7 warning 'unused' is assigned a value but never used no-unused-vars
72 | 4:7 warning 'unused2' is assigned a value but never used no-unused-vars
73 |
74 | ✖ 2 problems (0 errors, 2 warnings)
75 |
76 | Module Warning (from ./node_modules/eslint-loader/index.js):
77 |
78 | ${filename('fixtures/eslint-warnings/module.js')}
79 | 1:7 warning 'unused' is assigned a value but never used no-unused-vars
80 |
81 | ✖ 1 problem (0 errors, 1 warning)
82 |
83 | You may use special comments to disable some warnings.
84 | Use // eslint-disable-next-line to ignore the next line.
85 | Use /* eslint-disable */ to ignore all warnings in a file.`
86 | )
87 | })
88 |
89 | it('integration : babel syntax error', async () => {
90 | const logs = await executeAndGetLogs('./fixtures/babel-syntax/webpack.config')
91 |
92 | expect(logs).toEqual([
93 | 'ERROR Failed to compile with 1 errors',
94 | '',
95 | 'error in ./test/fixtures/babel-syntax/index.js',
96 | '',
97 | `Syntax Error: Unexpected token (5:11)
98 |
99 | 3 |${' '}
100 | 4 | render() {
101 | > 5 | return
102 | | ^
103 | 6 | }
104 | 7 | }`,
105 | ''
106 | ])
107 | })
108 |
109 | it('integration : webpack multi compiler : success', async () => {
110 | // We apply the plugin directly to the compiler when targeting multi-compiler
111 | let globalPlugins = [new FriendlyErrorsWebpackPlugin()]
112 | const logs = await executeAndGetLogs('./fixtures/multi-compiler-success/webpack.config', globalPlugins)
113 |
114 | expect(logs.join('\n')).toMatch(/DONE {2}Compiled successfully in (.\d*)ms/)
115 | })
116 |
117 | it('integration : webpack multi compiler : module-errors', async () => {
118 | // We apply the plugin directly to the compiler when targeting multi-compiler
119 | let globalPlugins = [new FriendlyErrorsWebpackPlugin()]
120 | const logs = await executeAndGetLogs('./fixtures/multi-compiler-module-errors/webpack.config', globalPlugins)
121 |
122 | expect(logs).toEqual([
123 | 'ERROR Failed to compile with 2 errors',
124 | '',
125 | 'This dependency was not found:',
126 | '',
127 | '* not-found in ./test/fixtures/multi-compiler-module-errors/index2.js',
128 | '',
129 | 'To install it, you can run: npm install --save not-found',
130 | '',
131 | '',
132 | 'This relative module was not found:',
133 | '',
134 | '* ./non-existing in ./test/fixtures/multi-compiler-module-errors/index.js'
135 | ])
136 | })
137 |
--------------------------------------------------------------------------------
/test/unit/formatErrors.spec.js:
--------------------------------------------------------------------------------
1 | const formatErrors = require('../../src/core/formatErrors')
2 | const expect = require('expect')
3 |
4 | const simple = (errors) => errors
5 | .filter(error => !error.type).map(e => e.message)
6 |
7 | const allCaps = (errors) => errors
8 | .filter(error => error.type === 'other').map(e => e.message.toUpperCase())
9 |
10 | const notFound = (errors) => errors
11 | .filter(error => error.type === 'not-found').map(() => 'Not found')
12 |
13 | it('formats the error based on the matching formatters', () => {
14 | const errors = [
15 | { message: 'Error 1', type: undefined },
16 | { message: 'Error 2', type: 'other' },
17 | { message: 'Error 3', type: 'not-found' }
18 | ]
19 |
20 | expect(formatErrors(errors, [simple, allCaps, notFound], 'Error')).toEqual([
21 | 'Error 1',
22 | 'ERROR 2',
23 | 'Not found'
24 | ])
25 | })
26 |
--------------------------------------------------------------------------------
/test/unit/formatters/defaultError.spec.js:
--------------------------------------------------------------------------------
1 | const defaultError = require('../../../src/formatters/defaultError')
2 | const expect = require('expect')
3 | const stripAnsi = require('strip-ansi')
4 |
5 | const noColor = (arr) => arr.map(stripAnsi)
6 | const error = { message: 'Error message', file: './src/index.js' }
7 |
8 | it('Formats errors with no type', () => {
9 | expect(noColor(defaultError([error], 'Warning'))).toEqual([
10 | [ 'Warning', 'in ./src/index.js' ],
11 | 'Error message',
12 | ''
13 | ])
14 | })
15 |
16 | it('Does not format other errors', () => {
17 | const otherError = { type: 'other-error' }
18 | expect(noColor(defaultError([otherError], 'Error'))).toEqual([])
19 | })
20 |
--------------------------------------------------------------------------------
/test/unit/formatters/moduleNotFound.spec.js:
--------------------------------------------------------------------------------
1 | const moduleNotFound = require('../../../src/formatters/moduleNotFound')
2 | const expect = require('expect')
3 |
4 | it('Formats module-not-found errors', () => {
5 | const error = { type: 'module-not-found', module: 'redux' }
6 | expect(moduleNotFound([error])).toEqual([
7 | 'This dependency was not found:',
8 | '',
9 | '* redux',
10 | '',
11 | 'To install it, you can run: npm install --save redux'
12 | ])
13 | })
14 |
15 | it('Groups all module-not-found into one', () => {
16 | const reduxError = { type: 'module-not-found', module: 'redux' }
17 | const reactError = { type: 'module-not-found', module: 'react' }
18 | expect(moduleNotFound([reduxError, reactError])).toEqual([
19 | 'These dependencies were not found:',
20 | '',
21 | '* redux',
22 | '* react',
23 | '',
24 | 'To install them, you can run: npm install --save redux react'
25 | ])
26 | })
27 |
28 | it('Groups same module in module-not-found with 2 files', () => {
29 | const reduxError = { type: 'module-not-found', module: 'redux' }
30 | const reactError1 = { type: 'module-not-found', module: 'react', file: './src/file1.js' }
31 | const reactError2 = { type: 'module-not-found', module: 'react', file: '../src/file2.js' }
32 | expect(moduleNotFound([reduxError, reactError1, reactError2])).toEqual([
33 | 'These dependencies were not found:',
34 | '',
35 | '* redux',
36 | '* react in ./src/file1.js, ../src/file2.js',
37 | '',
38 | 'To install them, you can run: npm install --save redux react'
39 | ])
40 | })
41 |
42 | it('Groups same module in module-not-found with 3 files', () => {
43 | const reduxError = { type: 'module-not-found', module: 'redux' }
44 | const reactError1 = { type: 'module-not-found', module: 'react', file: './src/file1.js' }
45 | const reactError2 = { type: 'module-not-found', module: 'react', file: './src/file2.js' }
46 | const reactError3 = { type: 'module-not-found', module: 'react', file: './src/file3.js' }
47 | expect(moduleNotFound([reduxError, reactError1, reactError2, reactError3])).toEqual([
48 | 'These dependencies were not found:',
49 | '',
50 | '* redux',
51 | '* react in ./src/file1.js, ./src/file2.js and 1 other',
52 | '',
53 | 'To install them, you can run: npm install --save redux react'
54 | ])
55 | })
56 |
57 | it('Groups same module in module-not-found with 4 files', () => {
58 | const reduxError = { type: 'module-not-found', module: 'redux' }
59 | const reactError1 = { type: 'module-not-found', module: 'react', file: './src/file1.js' }
60 | const reactError2 = { type: 'module-not-found', module: 'react', file: './src/file2.js' }
61 | const reactError3 = { type: 'module-not-found', module: 'react', file: './src/file3.js' }
62 | const reactError4 = { type: 'module-not-found', module: 'react', file: './src/file4.js' }
63 | expect(moduleNotFound([reduxError, reactError1, reactError2, reactError3, reactError4])).toEqual([
64 | 'These dependencies were not found:',
65 | '',
66 | '* redux',
67 | '* react in ./src/file1.js, ./src/file2.js and 2 others',
68 | '',
69 | 'To install them, you can run: npm install --save redux react'
70 | ])
71 | })
72 |
73 | it('Does not format other errors', () => {
74 | const otherError = { type: 'other-error', module: 'foo' }
75 | expect(moduleNotFound([otherError])).toEqual([])
76 | })
77 |
--------------------------------------------------------------------------------
/test/unit/plugin/friendlyErrors.spec.js:
--------------------------------------------------------------------------------
1 | const expect = require('expect')
2 | const EventEmitter = require('events')
3 | const Stats = require('webpack/lib/Stats')
4 | const MultiStats = require('webpack/lib/MultiStats')
5 | const { captureReports } = require('../../utils')
6 | EventEmitter.prototype.plugin = EventEmitter.prototype.on
7 |
8 | const FriendlyErrorsPlugin = require('../../../index')
9 |
10 | let notifierPlugin = new FriendlyErrorsPlugin()
11 | let mockCompiler = new EventEmitter()
12 | let reporter = notifierPlugin.reporter
13 |
14 | beforeEach(() => {
15 | notifierPlugin = new FriendlyErrorsPlugin()
16 | mockCompiler = new EventEmitter()
17 | reporter = notifierPlugin.reporter
18 |
19 | mockCompiler.hooks = {
20 | done: {
21 | tap (name, handler) {
22 | mockCompiler.plugin('done', handler)
23 | }
24 | },
25 | invalid: {
26 | tap (name, handler) {
27 | mockCompiler.plugin('invalid', handler)
28 | }
29 | }
30 | }
31 | notifierPlugin.apply(mockCompiler)
32 | })
33 |
34 | it('friendlyErrors : capture invalid message', async () => {
35 | const logs = await captureReports(reporter, () => mockCompiler.emit('invalid'))
36 | expect(logs).toEqual([
37 | 'WAIT Compiling...',
38 | ''
39 | ])
40 | })
41 |
42 | it('friendlyErrors : capture compilation without errors', async () => {
43 | const stats = successfulCompilationStats()
44 | const logs = await captureReports(reporter, () => mockCompiler.emit('done', stats))
45 | expect(logs).toEqual([
46 | 'DONE Compiled successfully in 100ms',
47 | ''
48 | ])
49 | })
50 |
51 | it('friendlyErrors : default clearConsole option', () => {
52 | const plugin = new FriendlyErrorsPlugin()
53 | expect(plugin.shouldClearConsole).toBeTruthy()
54 | })
55 |
56 | it('friendlyErrors : clearConsole option', () => {
57 | const plugin = new FriendlyErrorsPlugin({ clearConsole: false })
58 | expect(plugin.shouldClearConsole).toBeFalsy()
59 | })
60 |
61 | describe('friendlyErrors : multicompiler', () => {
62 | it('supplies the correct max compile time across multiple stats', async () => {
63 | const stats1 = successfulCompilationStats({ startTime: 0, endTime: 1000 })
64 | const stats2 = successfulCompilationStats({ startTime: 2, endTime: 2002 })
65 | const multistats = new MultiStats([stats1, stats2])
66 |
67 | const logs = await captureReports(reporter, () => {
68 | mockCompiler.emit('done', multistats)
69 | })
70 |
71 | expect(logs).toEqual([
72 | 'DONE Compiled successfully in 2000ms',
73 | ''
74 | ])
75 | })
76 |
77 | it('supplies the correct recompile time with rebuild', async () => {
78 | // Test that rebuilds do not use the prior "max" value when recompiling just one stats object.
79 | // This ensures the user does not get incorrect build times in watch mode.
80 | const stats1 = successfulCompilationStats({ startTime: 0, endTime: 1000 })
81 | const stats2 = successfulCompilationStats({ startTime: 0, endTime: 500 })
82 | const stats2Rebuild = successfulCompilationStats({ startTime: 1020, endTime: 1050 })
83 |
84 | const multistats = new MultiStats([stats1, stats2])
85 | const multistatsRecompile = new MultiStats([stats1, stats2Rebuild])
86 |
87 | const logs = await captureReports(reporter, () => {
88 | mockCompiler.emit('done', multistats)
89 | mockCompiler.emit('done', multistatsRecompile)
90 | })
91 |
92 | expect(logs).toEqual([
93 | 'DONE Compiled successfully in 1000ms',
94 | '',
95 | 'DONE Compiled successfully in 30ms',
96 | ''
97 | ])
98 | })
99 | })
100 |
101 | function successfulCompilationStats (opts) {
102 | const options = Object.assign({ startTime: 0, endTime: 100 }, opts)
103 |
104 | const compilation = {
105 | errors: [],
106 | warnings: [],
107 | children: []
108 | }
109 | const stats = new Stats(compilation)
110 | stats.startTime = options.startTime
111 | stats.endTime = options.endTime
112 | return stats
113 | }
114 |
--------------------------------------------------------------------------------
/test/unit/transformers/babelSyntax.spec.js:
--------------------------------------------------------------------------------
1 | const babelSyntax = require('../../../src/transformers/babelSyntax')
2 | const expect = require('expect')
3 |
4 | it('Sets severity to 1000', () => {
5 | const error = { name: 'ModuleBuildError', message: 'SyntaxError' }
6 | expect(babelSyntax(error).severity).toEqual(1000)
7 | })
8 |
9 | it('Does not set type (it should be handle by the default formatter)', () => {
10 | const error = { name: 'ModuleBuildError', message: 'SyntaxError' }
11 | expect(babelSyntax(error).type).toEqual(undefined)
12 | })
13 |
14 | it('Ignores other errors', () => {
15 | const error = { name: 'OtherError' }
16 | expect(babelSyntax(error)).toEqual(error)
17 | })
18 |
--------------------------------------------------------------------------------
/test/unit/transformers/moduleNotFound.spec.js:
--------------------------------------------------------------------------------
1 | const moduleNotFound = require('../../../src/transformers/moduleNotFound')
2 | const expect = require('expect')
3 | const RequireContextDependency = require('webpack/lib/dependencies/RequireContextDependency')
4 |
5 | const error = {
6 | name: 'ModuleNotFoundError',
7 | message: 'Module not found : redux',
8 | webpackError: {
9 | dependencies: [{ request: 'redux' }]
10 | }
11 | }
12 |
13 | it('Sets severity to 900', () => {
14 | expect(moduleNotFound(error).severity).toEqual(900)
15 | })
16 |
17 | it('Sets module name', () => {
18 | expect(moduleNotFound(error).module).toEqual('redux')
19 | })
20 |
21 | it('Sets the appropiate message', () => {
22 | const message = 'Module not found redux'
23 | expect(moduleNotFound(error).message).toEqual(message)
24 | })
25 |
26 | it('Sets the appropiate type', () => {
27 | expect(moduleNotFound({
28 | name: 'ModuleNotFoundError',
29 | message: 'Module not found',
30 | webpackError: error.webpackError
31 | }).type).toEqual('module-not-found')
32 | })
33 |
34 | it('Ignores other errors', () => {
35 | const error = { name: 'OtherError' }
36 | expect(moduleNotFound(error)).toEqual(error)
37 | })
38 |
39 | it('Sets the correct message with a RequireContextDependency', () => {
40 | const message = 'Module not found redux'
41 |
42 | expect(moduleNotFound({
43 | name: 'ModuleNotFoundError',
44 | message: 'Module not found : redux',
45 | webpackError: {
46 | dependencies: [ new RequireContextDependency({ request: 'redux', regExp: {} }) ]
47 | }
48 | }).message).toEqual(message)
49 | })
50 |
--------------------------------------------------------------------------------
/test/unit/utils/utils.spec.js:
--------------------------------------------------------------------------------
1 | const utils = require('../../../src/utils')
2 |
3 | const concat = utils.concat
4 | const uniqueBy = utils.uniqueBy
5 |
6 | it('concat should concat removing undefined and null values', () => {
7 | const result = concat(1, undefined, '', null)
8 | expect(result).toEqual(
9 | [1, '']
10 | )
11 | })
12 |
13 | it('concat should handle arrays', () => {
14 | const result = concat(1, [2, 3], null)
15 | expect(result).toEqual(
16 | [1, 2, 3]
17 | )
18 | })
19 |
20 | it('uniqueBy should dedupe based on criterion returned from iteratee function', () => {
21 | const result = uniqueBy([{ id: 1 }, { id: 2 }, { id: 3 }, { id: 3 }], function (val) {
22 | return val.id
23 | })
24 | expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
25 | })
26 |
--------------------------------------------------------------------------------
/test/utils/index.js:
--------------------------------------------------------------------------------
1 | const stripAnsi = require('strip-ansi')
2 |
3 | module.exports = {
4 | captureReports: async (output, callback) => {
5 | output.log = jest.fn()
6 | output.clearConsole = jest.fn()
7 | const logs = []
8 |
9 | await callback()
10 |
11 | for (const args of output.log.mock.calls) {
12 | logs.push(stripAnsi(args.join(' ')).trim())
13 | }
14 | return logs
15 | }
16 | }
17 |
--------------------------------------------------------------------------------