Skip to content

Commit ac668c7

Browse files
gustavohenkegustavohenke
committed
logger: use subscribeSpyTo in tests
1 parent a61ef39 commit ac668c7

1 file changed

Lines changed: 56 additions & 55 deletions

File tree

‎src/logger.spec.ts‎

Lines changed: 56 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,9 @@
1+
import { subscribeSpyTo } from '@hirez_io/observer-spy';
12
import chalk from 'chalk';
23

34
import { FakeCommand } from './fixtures/fake-command';
45
import { Logger } from './logger';
56

6-
let emitSpy: jest.SpyInstance;
7-
87
beforeEach(() => {
98
// Force chalk to use colors, otherwise tests may pass when they were supposed to be failing.
109
chalk.level = 3;
@@ -13,58 +12,60 @@ beforeEach(() => {
1312
const createLogger = (...options: ConstructorParameters<typeof Logger>) => {
1413
const logger = new Logger(...options);
1514
jest.spyOn(logger, 'log');
16-
emitSpy = jest.spyOn(logger, 'emit');
17-
return logger;
15+
const spy = subscribeSpyTo(logger.output);
16+
return { logger, spy };
1817
};
1918

2019
describe('#log()', () => {
21-
it('writes prefix + text to the output stream', () => {
22-
const logger = createLogger({});
20+
it('emits prefix + text in the output stream', () => {
21+
const { logger, spy } = createLogger({});
2322
logger.log('foo', 'bar');
2423

25-
expect(logger.emit).toHaveBeenCalledTimes(2);
26-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'foo');
27-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'bar');
24+
const values = spy.getValues();
25+
expect(values).toHaveLength(2);
26+
expect(values[0]).toEqual({ command: undefined, text: 'foo' });
27+
expect(values[1]).toEqual({ command: undefined, text: 'bar' });
2828
});
2929

30-
it('writes multiple lines of text with prefix on each', () => {
31-
const logger = createLogger({});
30+
it('emits multiple lines of text with prefix on each', () => {
31+
const { logger, spy } = createLogger({});
3232
logger.log('foo', 'bar\nbaz\n');
3333

34-
expect(logger.emit).toHaveBeenCalledTimes(2);
35-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'foo');
36-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'bar\nfoobaz\n');
34+
const values = spy.getValues();
35+
expect(values).toHaveLength(2);
36+
expect(values[0]).toEqual({ command: undefined, text: 'foo' });
37+
expect(values[1]).toEqual({ command: undefined, text: 'bar\nfoobaz\n' });
3738
});
3839

39-
it('does not prepend prefix if last call did not finish with a LF', () => {
40-
const logger = createLogger({});
40+
it('does not emit prefix if last call did not finish with a LF', () => {
41+
const { logger, spy } = createLogger({});
4142
logger.log('foo', 'bar');
42-
emitSpy.mockClear();
4343
logger.log('foo', 'baz');
4444

45-
expect(logger.emit).toHaveBeenCalledTimes(1);
46-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'baz');
45+
expect(spy.getValuesLength()).toBe(3);
46+
expect(spy.getLastValue()).toEqual({ command: undefined, text: 'baz' });
4747
});
4848

49-
it('does not prepend prefix or handle text if logger is in raw mode', () => {
50-
const logger = createLogger({ raw: true });
49+
it('does not emit prefix nor handle text if logger is in raw mode', () => {
50+
const { logger, spy } = createLogger({ raw: true });
5151
logger.log('foo', 'bar\nbaz\n');
5252

53-
expect(logger.emit).toHaveBeenCalledTimes(1);
54-
expect(logger.emit).toHaveBeenCalledWith(undefined, 'bar\nbaz\n');
53+
const values = spy.getValues();
54+
expect(values).toHaveLength(1);
55+
expect(values[0]).toEqual({ command: undefined, text: 'bar\nbaz\n' });
5556
});
5657
});
5758

5859
describe('#logGlobalEvent()', () => {
5960
it('does nothing if in raw mode', () => {
60-
const logger = createLogger({ raw: true });
61+
const { logger } = createLogger({ raw: true });
6162
logger.logGlobalEvent('foo');
6263

6364
expect(logger.log).not.toHaveBeenCalled();
6465
});
6566

6667
it('logs in gray dim style with arrow prefix', () => {
67-
const logger = createLogger({});
68+
const { logger } = createLogger({});
6869
logger.logGlobalEvent('foo');
6970

7071
expect(logger.log).toHaveBeenCalledWith(
@@ -76,23 +77,23 @@ describe('#logGlobalEvent()', () => {
7677

7778
describe('#logCommandText()', () => {
7879
it('logs with name if no prefixFormat is set', () => {
79-
const logger = createLogger({});
80+
const { logger } = createLogger({});
8081
const cmd = new FakeCommand('bla');
8182
logger.logCommandText('foo', cmd);
8283

8384
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[bla]') + ' ', 'foo', cmd);
8485
});
8586

8687
it('logs with index if no prefixFormat is set, and command has no name', () => {
87-
const logger = createLogger({});
88+
const { logger } = createLogger({});
8889
const cmd = new FakeCommand('', undefined, 2);
8990
logger.logCommandText('foo', cmd);
9091

9192
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[2]') + ' ', 'foo', cmd);
9293
});
9394

9495
it('logs with prefixFormat set to pid', () => {
95-
const logger = createLogger({ prefixFormat: 'pid' });
96+
const { logger } = createLogger({ prefixFormat: 'pid' });
9697
const cmd = new FakeCommand();
9798
cmd.pid = 123;
9899
logger.logCommandText('foo', cmd);
@@ -101,23 +102,23 @@ describe('#logCommandText()', () => {
101102
});
102103

103104
it('logs with prefixFormat set to name', () => {
104-
const logger = createLogger({ prefixFormat: 'name' });
105+
const { logger } = createLogger({ prefixFormat: 'name' });
105106
const cmd = new FakeCommand('bar');
106107
logger.logCommandText('foo', cmd);
107108

108109
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[bar]') + ' ', 'foo', cmd);
109110
});
110111

111112
it('logs with prefixFormat set to index', () => {
112-
const logger = createLogger({ prefixFormat: 'index' });
113+
const { logger } = createLogger({ prefixFormat: 'index' });
113114
const cmd = new FakeCommand(undefined, undefined, 3);
114115
logger.logCommandText('foo', cmd);
115116

116117
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[3]') + ' ', 'foo', cmd);
117118
});
118119

119120
it('logs with prefixFormat set to time (with timestampFormat)', () => {
120-
const logger = createLogger({ prefixFormat: 'time', timestampFormat: 'yyyy' });
121+
const { logger } = createLogger({ prefixFormat: 'time', timestampFormat: 'yyyy' });
121122
const cmd = new FakeCommand();
122123
logger.logCommandText('foo', cmd);
123124

@@ -126,47 +127,47 @@ describe('#logCommandText()', () => {
126127
});
127128

128129
it('logs with templated prefixFormat', () => {
129-
const logger = createLogger({ prefixFormat: '{index}-{name}' });
130+
const { logger } = createLogger({ prefixFormat: '{index}-{name}' });
130131
const cmd = new FakeCommand('bar');
131132
logger.logCommandText('foo', cmd);
132133

133134
expect(logger.log).toHaveBeenCalledWith(chalk.reset('0-bar') + ' ', 'foo', cmd);
134135
});
135136

136137
it('does not strip spaces from beginning or end of prefixFormat', () => {
137-
const logger = createLogger({ prefixFormat: ' {index}-{name} ' });
138+
const { logger } = createLogger({ prefixFormat: ' {index}-{name} ' });
138139
const cmd = new FakeCommand('bar');
139140
logger.logCommandText('foo', cmd);
140141

141142
expect(logger.log).toHaveBeenCalledWith(chalk.reset(' 0-bar ') + ' ', 'foo', cmd);
142143
});
143144

144145
it('logs with no prefix', () => {
145-
const logger = createLogger({ prefixFormat: 'none' });
146+
const { logger } = createLogger({ prefixFormat: 'none' });
146147
const cmd = new FakeCommand();
147148
logger.logCommandText('foo', cmd);
148149

149150
expect(logger.log).toHaveBeenCalledWith(chalk.reset(''), 'foo', cmd);
150151
});
151152

152153
it('logs prefix using command line itself', () => {
153-
const logger = createLogger({ prefixFormat: 'command' });
154+
const { logger } = createLogger({ prefixFormat: 'command' });
154155
const cmd = new FakeCommand();
155156
logger.logCommandText('foo', cmd);
156157

157158
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[echo foo]') + ' ', 'foo', cmd);
158159
});
159160

160161
it('logs prefix using command line itself, capped at prefixLength bytes', () => {
161-
const logger = createLogger({ prefixFormat: 'command', prefixLength: 6 });
162+
const { logger } = createLogger({ prefixFormat: 'command', prefixLength: 6 });
162163
const cmd = new FakeCommand();
163164
logger.logCommandText('foo', cmd);
164165

165166
expect(logger.log).toHaveBeenCalledWith(chalk.reset('[ec..oo]') + ' ', 'foo', cmd);
166167
});
167168

168169
it('logs prefix using prefixColor from command', () => {
169-
const logger = createLogger({});
170+
const { logger } = createLogger({});
170171
const cmd = new FakeCommand('', undefined, 1, {
171172
prefixColor: 'blue',
172173
});
@@ -176,7 +177,7 @@ describe('#logCommandText()', () => {
176177
});
177178

178179
it('logs prefix in gray dim if prefixColor from command does not exist', () => {
179-
const logger = createLogger({});
180+
const { logger } = createLogger({});
180181
const cmd = new FakeCommand('', undefined, 1, {
181182
prefixColor: 'blue.fake',
182183
});
@@ -186,7 +187,7 @@ describe('#logCommandText()', () => {
186187
});
187188

188189
it('logs prefix using prefixColor from command if prefixColor is a hex value', () => {
189-
const logger = createLogger({});
190+
const { logger } = createLogger({});
190191
const prefixColor = '#32bd8a';
191192
const cmd = new FakeCommand('', undefined, 1, {
192193
prefixColor,
@@ -197,15 +198,15 @@ describe('#logCommandText()', () => {
197198
});
198199

199200
it('does nothing if command is hidden by name', () => {
200-
const logger = createLogger({ hide: ['abc'] });
201+
const { logger } = createLogger({ hide: ['abc'] });
201202
const cmd = new FakeCommand('abc');
202203
logger.logCommandText('foo', cmd);
203204

204205
expect(logger.log).not.toHaveBeenCalled();
205206
});
206207

207208
it('does nothing if command is hidden by index', () => {
208-
const logger = createLogger({ hide: [3] });
209+
const { logger } = createLogger({ hide: [3] });
209210
const cmd = new FakeCommand('', undefined, 3);
210211
logger.logCommandText('foo', cmd);
211212

@@ -215,30 +216,30 @@ describe('#logCommandText()', () => {
215216

216217
describe('#logCommandEvent()', () => {
217218
it('does nothing if in raw mode', () => {
218-
const logger = createLogger({ raw: true });
219+
const { logger } = createLogger({ raw: true });
219220
logger.logCommandEvent('foo', new FakeCommand());
220221

221222
expect(logger.log).not.toHaveBeenCalled();
222223
});
223224

224225
it('does nothing if command is hidden by name', () => {
225-
const logger = createLogger({ hide: ['abc'] });
226+
const { logger } = createLogger({ hide: ['abc'] });
226227
const cmd = new FakeCommand('abc');
227228
logger.logCommandEvent('foo', cmd);
228229

229230
expect(logger.log).not.toHaveBeenCalled();
230231
});
231232

232233
it('does nothing if command is hidden by index', () => {
233-
const logger = createLogger({ hide: [3] });
234+
const { logger } = createLogger({ hide: [3] });
234235
const cmd = new FakeCommand('', undefined, 3);
235236
logger.logCommandEvent('foo', cmd);
236237

237238
expect(logger.log).not.toHaveBeenCalled();
238239
});
239240

240241
it('logs text in gray dim', () => {
241-
const logger = createLogger({});
242+
const { logger } = createLogger({});
242243
const cmd = new FakeCommand('', undefined, 1);
243244
logger.logCommandEvent('foo', cmd);
244245

@@ -252,14 +253,14 @@ describe('#logCommandEvent()', () => {
252253

253254
describe('#logTable()', () => {
254255
it('does not log anything in raw mode', () => {
255-
const logger = createLogger({ raw: true });
256+
const { logger } = createLogger({ raw: true });
256257
logger.logTable([{ foo: 1, bar: 2 }]);
257258

258259
expect(logger.log).not.toHaveBeenCalled();
259260
});
260261

261262
it('does not log anything if value is not an array', () => {
262-
const logger = createLogger({});
263+
const { logger } = createLogger({});
263264
logger.logTable({} as never);
264265
logger.logTable(null as never);
265266
logger.logTable(0 as never);
@@ -269,21 +270,21 @@ describe('#logTable()', () => {
269270
});
270271

271272
it('does not log anything if array is empy', () => {
272-
const logger = createLogger({});
273+
const { logger } = createLogger({});
273274
logger.logTable([]);
274275

275276
expect(logger.log).not.toHaveBeenCalled();
276277
});
277278

278279
it('does not log anything if array items have no properties', () => {
279-
const logger = createLogger({});
280+
const { logger } = createLogger({});
280281
logger.logTable([{}]);
281282

282283
expect(logger.log).not.toHaveBeenCalled();
283284
});
284285

285286
it("logs a header for each item's properties", () => {
286-
const logger = createLogger({});
287+
const { logger } = createLogger({});
287288
logger.logTable([{ foo: 1, bar: 2 }]);
288289

289290
expect(logger.log).toHaveBeenCalledWith(
@@ -293,7 +294,7 @@ describe('#logTable()', () => {
293294
});
294295

295296
it("logs padded headers according to longest column's value", () => {
296-
const logger = createLogger({});
297+
const { logger } = createLogger({});
297298
logger.logTable([{ a: 'foo', b: 'barbaz' }]);
298299

299300
expect(logger.log).toHaveBeenCalledWith(
@@ -303,7 +304,7 @@ describe('#logTable()', () => {
303304
});
304305

305306
it("logs each items's values", () => {
306-
const logger = createLogger({});
307+
const { logger } = createLogger({});
307308
logger.logTable([{ foo: 123 }, { foo: 456 }]);
308309

309310
expect(logger.log).toHaveBeenCalledWith(
@@ -317,7 +318,7 @@ describe('#logTable()', () => {
317318
});
318319

319320
it("logs each items's values with empty column", () => {
320-
const logger = createLogger({});
321+
const { logger } = createLogger({});
321322
logger.logTable([{ foo: 123 }, { foo: null }]);
322323

323324
expect(logger.log).toHaveBeenCalledWith(
@@ -331,7 +332,7 @@ describe('#logTable()', () => {
331332
});
332333

333334
it("logs each items's values padded according to longest column's value", () => {
334-
const logger = createLogger({});
335+
const { logger } = createLogger({});
335336
logger.logTable([{ foo: 1 }, { foo: 123 }]);
336337

337338
expect(logger.log).toHaveBeenCalledWith(
@@ -341,7 +342,7 @@ describe('#logTable()', () => {
341342
});
342343

343344
it('logs items with different properties in each', () => {
344-
const logger = createLogger({});
345+
const { logger } = createLogger({});
345346
logger.logTable([{ foo: 1 }, { bar: 2 }]);
346347

347348
expect(logger.log).toHaveBeenCalledWith(

0 commit comments

Comments
 (0)