process_test.dart 15.4 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
import 'dart:async';

7
import 'package:platform/platform.dart';
8
import 'package:flutter_tools/src/base/io.dart';
9
import 'package:flutter_tools/src/base/logger.dart';
10
import 'package:flutter_tools/src/base/process.dart';
11
import 'package:flutter_tools/src/base/terminal.dart';
12 13
import 'package:mockito/mockito.dart';
import 'package:process/process.dart';
14

15 16
import '../../src/common.dart';
import '../../src/context.dart';
17 18
import '../../src/mocks.dart' show MockProcess,
                                   MockProcessManager,
19
                                   MockStdio,
20
                                   flakyProcessFactory;
21

22
void main() {
23 24
  group('process exceptions', () {
    ProcessManager mockProcessManager;
25
    ProcessUtils processUtils;
26 27

    setUp(() {
28
      mockProcessManager = PlainMockProcessManager();
29 30
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
31
        logger: BufferLogger.test(),
32
      );
33 34
    });

35
    testWithoutContext('runAsync throwOnError: exceptions should be ProcessException objects', () async {
36 37 38
      when(mockProcessManager.run(<String>['false'])).thenAnswer(
          (Invocation invocation) => Future<ProcessResult>.value(ProcessResult(0, 1, '', '')));
      expect(() async => await processUtils.run(<String>['false'], throwOnError: true),
Dan Field's avatar
Dan Field committed
39
             throwsA(isA<ProcessException>()));
40
    });
41
  });
42

43
  group('shutdownHooks', () {
44
    testWithoutContext('runInExpectedOrder', () async {
45 46 47 48 49 50
      int i = 1;
      int serializeRecording1;
      int serializeRecording2;
      int postProcessRecording;
      int cleanup;

51
      final ShutdownHooks shutdownHooks = ShutdownHooks(logger: BufferLogger.test());
52 53

      shutdownHooks.addShutdownHook(() async {
54 55 56
        serializeRecording1 = i++;
      }, ShutdownStage.SERIALIZE_RECORDING);

57
      shutdownHooks.addShutdownHook(() async {
58 59 60
        cleanup = i++;
      }, ShutdownStage.CLEANUP);

61
      shutdownHooks.addShutdownHook(() async {
62 63 64
        postProcessRecording = i++;
      }, ShutdownStage.POST_PROCESS_RECORDING);

65
      shutdownHooks.addShutdownHook(() async {
66 67 68
        serializeRecording2 = i++;
      }, ShutdownStage.SERIALIZE_RECORDING);

69
      await shutdownHooks.runShutdownHooks();
70 71 72 73 74 75 76

      expect(serializeRecording1, lessThanOrEqualTo(2));
      expect(serializeRecording2, lessThanOrEqualTo(2));
      expect(postProcessRecording, 3);
      expect(cleanup, 4);
    });
  });
77

78 79
  group('output formatting', () {
    MockProcessManager mockProcessManager;
80 81
    ProcessUtils processUtils;
    BufferLogger mockLogger;
82 83 84

    setUp(() {
      mockProcessManager = MockProcessManager();
85 86 87
      mockLogger = BufferLogger(
        terminal: AnsiTerminal(
          stdio: MockStdio(),
88
          platform: FakePlatform(stdoutSupportsAnsi: false),
89 90 91 92 93 94 95
        ),
        outputPreferences: OutputPreferences(wrapText: true, wrapColumn: 40),
      );
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
        logger: mockLogger,
      );
96 97
    });

98 99 100 101 102 103 104 105 106
    MockProcess Function(List<String>) processMetaFactory(List<String> stdout, {
      List<String> stderr = const <String>[],
    }) {
      final Stream<List<int>> stdoutStream = Stream<List<int>>.fromIterable(
        stdout.map<List<int>>((String s) => s.codeUnits,
      ));
      final Stream<List<int>> stderrStream = Stream<List<int>>.fromIterable(
        stderr.map<List<int>>((String s) => s.codeUnits,
      ));
107 108 109
      return (List<String> command) => MockProcess(stdout: stdoutStream, stderr: stderrStream);
    }

110
    testWithoutContext('Command output is not wrapped.', () async {
111 112
      final List<String> testString = <String>['0123456789' * 10];
      mockProcessManager.processFactory = processMetaFactory(testString, stderr: testString);
113
      await processUtils.stream(<String>['command']);
114 115
      expect(mockLogger.statusText, equals('${testString[0]}\n'));
      expect(mockLogger.errorText, equals('${testString[0]}\n'));
116 117
    });
  });
118

119
  group('run', () {
120 121
    const Duration delay = Duration(seconds: 2);
    MockProcessManager flakyProcessManager;
122
    ProcessManager mockProcessManager;
123 124
    ProcessUtils processUtils;
    ProcessUtils flakyProcessUtils;
125 126 127 128 129

    setUp(() {
      // MockProcessManager has an implementation of start() that returns the
      // result of processFactory.
      flakyProcessManager = MockProcessManager();
130
      mockProcessManager = MockProcessManager();
131 132
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
133
        logger: BufferLogger.test(),
134 135 136
      );
      flakyProcessUtils = ProcessUtils(
        processManager: flakyProcessManager,
137
        logger: BufferLogger.test(),
138
      );
139 140
    });

141
    testWithoutContext(' succeeds on success', () async {
142 143 144 145 146 147
      when(mockProcessManager.run(<String>['whoohoo'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 0, '', ''));
      });
      expect((await processUtils.run(<String>['whoohoo'])).exitCode, 0);
    });

148
    testWithoutContext(' fails on failure', () async {
149 150 151 152 153 154
      when(mockProcessManager.run(<String>['boohoo'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 1, '', ''));
      });
      expect((await processUtils.run(<String>['boohoo'])).exitCode, 1);
    });

155
    testWithoutContext(' throws on failure with throwOnError', () async {
156 157 158 159 160 161 162
      when(mockProcessManager.run(<String>['kaboom'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 1, '', ''));
      });
      expect(() => processUtils.run(<String>['kaboom'], throwOnError: true),
             throwsA(isA<ProcessException>()));
    });

163
    testWithoutContext(' does not throw on failure with whitelist', () async {
164 165 166 167 168 169 170 171 172
      when(mockProcessManager.run(<String>['kaboom'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 1, '', ''));
      });
      expect(
        (await processUtils.run(
          <String>['kaboom'],
          throwOnError: true,
          whiteListFailures: (int c) => c == 1,
        )).exitCode,
173 174
        1,
      );
175 176
    });

177
    testWithoutContext(' throws on failure when not in whitelist', () async {
178 179 180 181 182 183 184 185 186
      when(mockProcessManager.run(<String>['kaboom'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 2, '', ''));
      });
      expect(
        () => processUtils.run(
          <String>['kaboom'],
          throwOnError: true,
          whiteListFailures: (int c) => c == 1,
        ),
187 188
        throwsA(isA<ProcessException>()),
      );
189 190
    });

191
    testWithoutContext(' flaky process fails without retry', () async {
192 193 194 195
      flakyProcessManager.processFactory = flakyProcessFactory(
        flakes: 1,
        delay: delay,
      );
196
      final RunResult result = await flakyProcessUtils.run(
197 198 199 200 201 202
        <String>['dummy'],
        timeout: delay + const Duration(seconds: 1),
      );
      expect(result.exitCode, -9);
    });

203
    testWithoutContext(' flaky process succeeds with retry', () async {
204 205 206 207
      flakyProcessManager.processFactory = flakyProcessFactory(
        flakes: 1,
        delay: delay,
      );
208
      final RunResult result = await flakyProcessUtils.run(
209 210 211 212 213 214 215
        <String>['dummy'],
        timeout: delay - const Duration(milliseconds: 500),
        timeoutRetries: 1,
      );
      expect(result.exitCode, 0);
    });

216
    testWithoutContext(' flaky process generates ProcessException on timeout', () async {
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
      final Completer<List<int>> flakyStderr = Completer<List<int>>();
      final Completer<List<int>> flakyStdout = Completer<List<int>>();
      flakyProcessManager.processFactory = flakyProcessFactory(
        flakes: 1,
        delay: delay,
        stderr: () => Stream<List<int>>.fromFuture(flakyStderr.future),
        stdout: () => Stream<List<int>>.fromFuture(flakyStdout.future),
      );
      when(flakyProcessManager.killPid(any)).thenAnswer((_) {
        // Don't let the stderr stream stop until the process is killed. This
        // ensures that runAsync() does not delay killing the process until
        // stdout and stderr are drained (which won't happen).
        flakyStderr.complete(<int>[]);
        flakyStdout.complete(<int>[]);
        return true;
      });
233
      expect(() => flakyProcessUtils.run(
234 235 236
        <String>['dummy'],
        timeout: delay - const Duration(milliseconds: 500),
        timeoutRetries: 0,
Dan Field's avatar
Dan Field committed
237
      ), throwsA(isA<ProcessException>()));
238 239
    });
  });
240 241 242

  group('runSync', () {
    ProcessManager mockProcessManager;
243 244
    ProcessUtils processUtils;
    BufferLogger testLogger;
245 246 247

    setUp(() {
      mockProcessManager = MockProcessManager();
248 249 250
      testLogger = BufferLogger(
        terminal: AnsiTerminal(
          stdio: MockStdio(),
251
          platform: FakePlatform(stdinSupportsAnsi: false),
252 253 254 255 256 257 258
        ),
        outputPreferences: OutputPreferences(wrapText: true, wrapColumn: 40),
      );
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
        logger: testLogger,
      );
259 260
    });

261
    testWithoutContext(' succeeds on success', () async {
262 263 264 265 266 267
      when(mockProcessManager.runSync(<String>['whoohoo'])).thenReturn(
        ProcessResult(0, 0, '', '')
      );
      expect(processUtils.runSync(<String>['whoohoo']).exitCode, 0);
    });

268
    testWithoutContext(' fails on failure', () async {
269 270 271 272 273 274
      when(mockProcessManager.runSync(<String>['boohoo'])).thenReturn(
        ProcessResult(0, 1, '', '')
      );
      expect(processUtils.runSync(<String>['boohoo']).exitCode, 1);
    });

275
    testWithoutContext(' throws on failure with throwOnError', () async {
276 277 278 279 280 281 282
      when(mockProcessManager.runSync(<String>['kaboom'])).thenReturn(
        ProcessResult(0, 1, '', '')
      );
      expect(() => processUtils.runSync(<String>['kaboom'], throwOnError: true),
             throwsA(isA<ProcessException>()));
    });

283
    testWithoutContext(' does not throw on failure with whitelist', () async {
284 285 286 287 288 289 290 291 292 293 294 295
      when(mockProcessManager.runSync(<String>['kaboom'])).thenReturn(
        ProcessResult(0, 1, '', '')
      );
      expect(
        processUtils.runSync(
          <String>['kaboom'],
          throwOnError: true,
          whiteListFailures: (int c) => c == 1,
        ).exitCode,
        1);
    });

296
    testWithoutContext(' throws on failure when not in whitelist', () async {
297 298 299 300 301 302 303 304 305 306 307 308
      when(mockProcessManager.runSync(<String>['kaboom'])).thenReturn(
        ProcessResult(0, 2, '', '')
      );
      expect(
        () => processUtils.runSync(
          <String>['kaboom'],
          throwOnError: true,
          whiteListFailures: (int c) => c == 1,
        ),
        throwsA(isA<ProcessException>()));
    });

309
    testWithoutContext(' prints stdout and stderr to trace on success', () async {
310 311 312 313 314 315 316 317
      when(mockProcessManager.runSync(<String>['whoohoo'])).thenReturn(
        ProcessResult(0, 0, 'stdout', 'stderr')
      );
      expect(processUtils.runSync(<String>['whoohoo']).exitCode, 0);
      expect(testLogger.traceText, contains('stdout'));
      expect(testLogger.traceText, contains('stderr'));
    });

318
    testWithoutContext(' prints stdout to status and stderr to error on failure with throwOnError', () async {
319 320 321 322 323 324 325 326 327
      when(mockProcessManager.runSync(<String>['kaboom'])).thenReturn(
        ProcessResult(0, 1, 'stdout', 'stderr')
      );
      expect(() => processUtils.runSync(<String>['kaboom'], throwOnError: true),
             throwsA(isA<ProcessException>()));
      expect(testLogger.statusText, contains('stdout'));
      expect(testLogger.errorText, contains('stderr'));
    });

328
    testWithoutContext(' does not print stdout with hideStdout', () async {
329 330 331 332 333 334 335 336 337 338
      when(mockProcessManager.runSync(<String>['whoohoo'])).thenReturn(
        ProcessResult(0, 0, 'stdout', 'stderr')
      );
      expect(processUtils.runSync(<String>['whoohoo'], hideStdout: true).exitCode, 0);
      expect(testLogger.traceText.contains('stdout'), isFalse);
      expect(testLogger.traceText, contains('stderr'));
    });
  });

  group('exitsHappySync', () {
339
    MockProcessManager mockProcessManager;
340
    ProcessUtils processUtils;
341 342 343

    setUp(() {
      mockProcessManager = MockProcessManager();
344 345
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
346
        logger: BufferLogger.test(),
347
      );
348 349
    });

350
    testWithoutContext(' succeeds on success', () async {
351 352 353 354 355 356
      when(mockProcessManager.runSync(<String>['whoohoo'])).thenReturn(
        ProcessResult(0, 0, '', '')
      );
      expect(processUtils.exitsHappySync(<String>['whoohoo']), isTrue);
    });

357
    testWithoutContext(' fails on failure', () async {
358 359 360 361 362
      when(mockProcessManager.runSync(<String>['boohoo'])).thenReturn(
        ProcessResult(0, 1, '', '')
      );
      expect(processUtils.exitsHappySync(<String>['boohoo']), isFalse);
    });
363 364 365 366 367 368 369 370

    testWithoutContext('catches Exception and returns false', () {
      when(mockProcessManager.runSync(<String>['boohoo'])).thenThrow(
        const ProcessException('Process failed', <String>[]),
      );
      expect(processUtils.exitsHappySync(<String>['boohoo']), isFalse);
    });

371 372
    testWithoutContext('does not throw Exception and returns false if binary cannot run', () {
      mockProcessManager.canRunSucceeds = false;
373
      expect(processUtils.exitsHappySync(<String>['nonesuch']), isFalse);
374 375 376 377 378 379 380 381 382 383 384 385 386
      verifyNever(
        mockProcessManager.runSync(any, environment: anyNamed('environment')),
      );
    });

    testWithoutContext('does not catch ArgumentError', () async {
      when(mockProcessManager.runSync(<String>['invalid'])).thenThrow(
        ArgumentError('Bad input'),
      );
      expect(
        () => processUtils.exitsHappySync(<String>['invalid']),
        throwsArgumentError,
      );
387
    });
388 389 390
  });

  group('exitsHappy', () {
391
    MockProcessManager mockProcessManager;
392
    ProcessUtils processUtils;
393 394 395

    setUp(() {
      mockProcessManager = MockProcessManager();
396 397
      processUtils = ProcessUtils(
        processManager: mockProcessManager,
398
        logger: BufferLogger.test(),
399
      );
400 401
    });

402
    testWithoutContext('succeeds on success', () async {
403 404 405 406 407 408
      when(mockProcessManager.run(<String>['whoohoo'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 0, '', ''));
      });
      expect(await processUtils.exitsHappy(<String>['whoohoo']), isTrue);
    });

409
    testWithoutContext('fails on failure', () async {
410 411 412 413 414
      when(mockProcessManager.run(<String>['boohoo'])).thenAnswer((_) {
        return Future<ProcessResult>.value(ProcessResult(0, 1, '', ''));
      });
      expect(await processUtils.exitsHappy(<String>['boohoo']), isFalse);
    });
415 416 417 418 419 420 421 422

    testWithoutContext('catches Exception and returns false', () async {
      when(mockProcessManager.run(<String>['boohoo'])).thenThrow(
        const ProcessException('Process failed', <String>[]),
      );
      expect(await processUtils.exitsHappy(<String>['boohoo']), isFalse);
    });

423 424
    testWithoutContext('does not throw Exception and returns false if binary cannot run', () async {
      mockProcessManager.canRunSucceeds = false;
425
      expect(await processUtils.exitsHappy(<String>['nonesuch']), isFalse);
426 427 428 429 430 431 432 433 434 435 436 437 438
      verifyNever(
        mockProcessManager.runSync(any, environment: anyNamed('environment')),
      );
    });

    testWithoutContext('does not catch ArgumentError', () async {
      when(mockProcessManager.run(<String>['invalid'])).thenThrow(
        ArgumentError('Bad input'),
      );
      expect(
        () async => await processUtils.exitsHappy(<String>['invalid']),
        throwsArgumentError,
      );
439
    });
440 441
  });

442
}
443

444
class PlainMockProcessManager extends Mock implements ProcessManager {}