resident_web_runner_test.dart 47 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
// @dart = 2.8

7
import 'dart:async';
8
import 'dart:convert';
9
import 'dart:io';
10 11

import 'package:dwds/dwds.dart';
12
import 'package:file/memory.dart';
13
import 'package:flutter_tools/src/application_package.dart';
14
import 'package:flutter_tools/src/asset.dart';
15
import 'package:flutter_tools/src/base/common.dart';
16
import 'package:flutter_tools/src/base/dds.dart';
17
import 'package:flutter_tools/src/base/file_system.dart';
18
import 'package:flutter_tools/src/base/logger.dart';
19
import 'package:flutter_tools/src/base/platform.dart';
20
import 'package:flutter_tools/src/base/time.dart';
21
import 'package:flutter_tools/src/build_info.dart';
22 23
import 'package:flutter_tools/src/compile.dart';
import 'package:flutter_tools/src/devfs.dart';
24
import 'package:flutter_tools/src/device.dart';
25
import 'package:flutter_tools/src/globals.dart' as globals;
26 27
import 'package:flutter_tools/src/isolated/devfs_web.dart';
import 'package:flutter_tools/src/isolated/resident_web_runner.dart';
28
import 'package:flutter_tools/src/project.dart';
29
import 'package:flutter_tools/src/reporting/reporting.dart';
30
import 'package:flutter_tools/src/resident_devtools_handler.dart';
31
import 'package:flutter_tools/src/resident_runner.dart';
32
import 'package:flutter_tools/src/vmservice.dart';
33
import 'package:flutter_tools/src/web/chrome.dart';
34
import 'package:flutter_tools/src/web/web_device.dart';
35 36 37
import 'package:meta/meta.dart';
import 'package:package_config/package_config.dart';
import 'package:package_config/package_config_types.dart';
38
import 'package:test/fake.dart';
39
import 'package:vm_service/vm_service.dart' as vm_service;
40
import 'package:webkit_inspection_protocol/webkit_inspection_protocol.dart';
41 42

import '../src/common.dart';
43
import '../src/context.dart';
44
import '../src/fake_vm_services.dart';
45

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
const List<VmServiceExpectation> kAttachLogExpectations = <VmServiceExpectation>[
  FakeVmServiceRequest(
    method: 'streamListen',
    args: <String, Object>{
      'streamId': 'Stdout',
    },
  ),
  FakeVmServiceRequest(
    method: 'streamListen',
    args: <String, Object>{
      'streamId': 'Stderr',
    },
  )
];

const List<VmServiceExpectation> kAttachIsolateExpectations = <VmServiceExpectation>[
  FakeVmServiceRequest(
    method: 'streamListen',
    args: <String, Object>{
      'streamId': 'Isolate'
    }
  ),
68
  FakeVmServiceRequest(
69
    method: 'registerService',
70
    args: <String, Object>{
71 72 73
      'service': 'reloadSources',
      'alias': 'Flutter Tools',
    }
74
  ),
75 76 77
  FakeVmServiceRequest(
    method: 'registerService',
    args: <String, Object>{
78 79
      'service': 'flutterVersion',
      'alias': 'Flutter Tools',
80
    }
81 82 83 84 85 86 87 88 89 90 91 92 93 94
  ),
  FakeVmServiceRequest(
    method: 'registerService',
    args: <String, Object>{
      'service': 'flutterMemoryInfo',
      'alias': 'Flutter Tools',
    }
  ),
  FakeVmServiceRequest(
    method: 'streamListen',
    args: <String, Object>{
      'streamId': 'Extension',
    },
  ),
95 96 97 98 99 100 101
];

const List<VmServiceExpectation> kAttachExpectations = <VmServiceExpectation>[
  ...kAttachLogExpectations,
  ...kAttachIsolateExpectations,
];

102
void main() {
103
  FakeDebugConnection debugConnection;
104
  FakeChromeDevice chromeDevice;
105 106
  FakeAppConnection appConnection;
  FakeFlutterDevice flutterDevice;
107 108
  FakeWebDevFS webDevFS;
  FakeResidentCompiler residentCompiler;
109 110
  FakeChromeConnection chromeConnection;
  FakeChromeTab chromeTab;
111 112
  FakeWebServerDevice webServerDevice;
  FakeDevice mockDevice;
113
  FakeVmServiceHost fakeVmServiceHost;
114 115
  FileSystem fileSystem;
  ProcessManager processManager;
116
  TestUsage testUsage;
117 118

  setUp(() {
119
    testUsage = TestUsage();
120 121
    fileSystem = MemoryFileSystem.test();
    processManager = FakeProcessManager.any();
122 123 124
    debugConnection = FakeDebugConnection();
    mockDevice = FakeDevice();
    appConnection = FakeAppConnection();
125 126
    webDevFS = FakeWebDevFS();
    residentCompiler = FakeResidentCompiler();
127 128
    chromeConnection = FakeChromeConnection();
    chromeTab = FakeChromeTab('index.html');
129 130 131 132 133
    webServerDevice = FakeWebServerDevice();
    flutterDevice = FakeFlutterDevice()
      .._devFS = webDevFS
      ..device = mockDevice
      ..generator = residentCompiler;
134
    fileSystem.file('.packages').writeAsStringSync('\n');
135 136
  });

137
  void _setupMocks() {
138 139 140
    fileSystem.file('pubspec.yaml').createSync();
    fileSystem.file('lib/main.dart').createSync(recursive: true);
    fileSystem.file('web/index.html').createSync(recursive: true);
141
    webDevFS.report = UpdateFSReport(success: true);
142
    debugConnection.fakeVmServiceHost = () => fakeVmServiceHost;
143
    webDevFS.result = ConnectionResult(
144 145 146
      appConnection,
      debugConnection,
      debugConnection.vmService,
147
    );
148
    debugConnection.uri = 'ws://127.0.0.1/abcd/';
149
    chromeConnection.tabs.add(chromeTab);
150 151
  }

152
  testUsingContext('runner with web server device does not support debugging without --start-paused', () {
153 154
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
    flutterDevice.device = WebServerDevice(
155
      logger: BufferLogger.test(),
156
    );
157
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
158
    final ResidentRunner profileResidentWebRunner = ResidentWebRunner(
159
      flutterDevice,
160
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
161 162
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
163
      urlTunneller: null,
164 165 166 167 168
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
169 170

    expect(profileResidentWebRunner.debuggingEnabled, false);
171

172
    flutterDevice.device = FakeChromeDevice();
173

174
    expect(residentWebRunner.debuggingEnabled, true);
175
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
176 177 178 179
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
180

181
  testUsingContext('runner with web server device supports debugging with --start-paused', () {
182
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
183
    _setupMocks();
184
    flutterDevice.device = WebServerDevice(
185
      logger: BufferLogger.test(),
186
    );
187
    final ResidentRunner profileResidentWebRunner = ResidentWebRunner(
188
      flutterDevice,
189
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
190 191
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug, startPaused: true),
      ipv6: true,
192
      urlTunneller: null,
193 194 195 196
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
197 198
    );

199
    expect(profileResidentWebRunner.uri, webDevFS.baseUri);
200
    expect(profileResidentWebRunner.debuggingEnabled, true);
201 202 203 204 205
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
  testUsingContext('profile does not supportsServiceProtocol', () {
206
    final ResidentRunner residentWebRunner = ResidentWebRunner(
207
      flutterDevice,
208
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
209 210 211
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
      urlTunneller: null,
212 213 214 215 216
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
217
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
218
    flutterDevice.device = chromeDevice;
219
    final ResidentRunner profileResidentWebRunner = ResidentWebRunner(
220
      flutterDevice,
221
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
222 223
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.profile),
      ipv6: true,
224
      urlTunneller: null,
225 226 227 228
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
229 230 231 232
    );

    expect(profileResidentWebRunner.supportsServiceProtocol, false);
    expect(residentWebRunner.supportsServiceProtocol, true);
233 234 235 236
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
237

238
  testUsingContext('Can successfully run and connect to vmservice', () async {
239
    final BufferLogger logger = BufferLogger.test();
240
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
241
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
242
    _setupMocks();
243

244 245 246 247 248 249
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    final DebugConnectionInfo debugConnectionInfo = await connectionInfoCompleter.future;

250
    expect(appConnection.ranMain, true);
251
    expect(logger.statusText, contains('Debug service listening on ws://127.0.0.1/abcd/'));
252
    expect(debugConnectionInfo.wsUri.toString(), 'ws://127.0.0.1/abcd/');
253
  }, overrides: <Type, Generator>{
254 255 256
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
257

258
  testUsingContext('WebRunner copies compiled app.dill to cache during startup', () async {
259
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
260 261 262 263 264 265 266 267 268 269
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
    _setupMocks();

    residentWebRunner.artifactDirectory.childFile('app.dill').writeAsStringSync('ABC');
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

270 271 272 273 274
    expect(await fileSystem.file(fileSystem.path.join('build', 'cache.dill')).readAsString(), 'ABC');
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
275

276 277
  // Regression test for https://github.com/flutter/flutter/issues/60613
  testUsingContext('ResidentWebRunner calls appFailedToStart if initial compilation fails', () async {
278
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
279
    _setupMocks();
280
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
281 282
    fileSystem.file(globals.fs.path.join('lib', 'main.dart'))
      .createSync(recursive: true);
283
    webDevFS.report = UpdateFSReport();
284 285 286 287 288 289 290 291 292

    expect(await residentWebRunner.run(), 1);
    // Completing this future ensures that the daemon can exit correctly.
    expect(await residentWebRunner.waitForAppToFinish(), 1);
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });

293
  testUsingContext('Can successfully run without an index.html including status warning', () async {
294
    final BufferLogger logger = BufferLogger.test();
295 296
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
    _setupMocks();
297
    fileSystem.file(fileSystem.path.join('web', 'index.html'))
298
      .deleteSync();
299
    final ResidentWebRunner residentWebRunner = ResidentWebRunner(
300
      flutterDevice,
301
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
302 303 304 305
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
      stayResident: false,
      urlTunneller: null,
306 307 308 309 310
      fileSystem: fileSystem,
      logger: logger,
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
311 312

    expect(await residentWebRunner.run(), 0);
313
    expect(logger.statusText,
314
      contains('This application is not configured to build on the web'));
315 316 317 318
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
319

320
  testUsingContext('Can successfully run and disconnect with --no-resident', () async {
321
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
322
    _setupMocks();
323
    final ResidentRunner residentWebRunner = ResidentWebRunner(
324
      flutterDevice,
325
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
326 327 328
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
      stayResident: false,
329
      urlTunneller: null,
330 331 332 333 334
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
335 336

    expect(await residentWebRunner.run(), 0);
337 338 339 340
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
341

342
  testUsingContext('Listens to stdout and stderr streams before running main', () async {
343
    final BufferLogger logger = BufferLogger.test();
344
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachLogExpectations,
      FakeVmServiceStreamResponse(
        streamId: 'Stdout',
        event: vm_service.Event(
          timestamp: 0,
          kind: vm_service.EventStreams.kStdout,
          bytes: base64.encode(utf8.encode('THIS MESSAGE IS IMPORTANT'))
        ),
      ),
      FakeVmServiceStreamResponse(
        streamId: 'Stderr',
        event: vm_service.Event(
          timestamp: 0,
          kind: vm_service.EventStreams.kStderr,
          bytes: base64.encode(utf8.encode('SO IS THIS'))
        ),
      ),
      ...kAttachIsolateExpectations,
    ]);
365 366 367 368 369 370 371
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

372 373
    expect(logger.statusText, contains('THIS MESSAGE IS IMPORTANT'));
    expect(logger.statusText, contains('SO IS THIS'));
374 375 376 377
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
378

379
  testUsingContext('Listens to extension events with structured errors', () async {
380
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: testLogger);
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
    final Map<String, String> extensionData = <String, String>{
      'test': 'data',
      'renderedErrorText': 'error text',
    };
    final Map<String, String> emptyExtensionData = <String, String>{
      'test': 'data',
      'renderedErrorText': '',
    };
    final Map<String, String> nonStructuredErrorData = <String, String>{
      'other': 'other stuff',
    };
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
      FakeVmServiceStreamResponse(
        streamId: 'Extension',
        event: vm_service.Event(
          timestamp: 0,
          extensionKind: 'Flutter.Error',
          extensionData: vm_service.ExtensionData.parse(extensionData),
          kind: vm_service.EventStreams.kExtension,
        ),
      ),
      // Empty error text should not break anything.
      FakeVmServiceStreamResponse(
        streamId: 'Extension',
        event: vm_service.Event(
          timestamp: 0,
          extensionKind: 'Flutter.Error',
          extensionData: vm_service.ExtensionData.parse(emptyExtensionData),
          kind: vm_service.EventStreams.kExtension,
        ),
      ),
      // This is not Flutter.Error kind data, so it should not be logged.
      FakeVmServiceStreamResponse(
        streamId: 'Extension',
        event: vm_service.Event(
          timestamp: 0,
          extensionKind: 'Other',
          extensionData: vm_service.ExtensionData.parse(nonStructuredErrorData),
          kind: vm_service.EventStreams.kExtension,
        ),
      ),
    ]);

    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;
    await null;

    expect(testLogger.statusText, contains('\nerror text'));
    expect(testLogger.statusText, isNot(contains('other stuff')));
435 436 437 438
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
439

440
  testUsingContext('Does not run main with --start-paused', () async {
441
    final ResidentRunner residentWebRunner = ResidentWebRunner(
442
      flutterDevice,
443
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
444 445
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug, startPaused: true),
      ipv6: true,
446
      urlTunneller: null,
447 448 449 450 451
      fileSystem: fileSystem,
      logger: BufferLogger.test(),
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
452
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
453 454
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
455

456 457 458 459 460
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

461
    expect(appConnection.ranMain, false);
462 463 464 465
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
466

467
  testUsingContext('Can hot reload after attaching', () async {
468 469
    final BufferLogger logger = BufferLogger.test();
    final ResidentRunner residentWebRunner = setUpResidentRunner(
470
      flutterDevice,
471
      logger: logger,
472
      systemClock: SystemClock.fixed(DateTime(2001)),
473
    );
474 475 476 477 478 479 480 481
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
      const FakeVmServiceRequest(
        method: 'hotRestart',
        jsonResponse: <String, Object>{
          'type': 'Success',
        }
      ),
482 483 484 485 486 487
      const FakeVmServiceRequest(
        method: 'streamListen',
        args: <String, Object>{
          'streamId': 'Isolate',
        },
      ),
488
    ]);
489
    _setupMocks();
490
    final TestChromiumLauncher chromiumLauncher = TestChromiumLauncher();
491
    final Chromium chrome = Chromium(1, chromeConnection, chromiumLauncher: chromiumLauncher);
492
    chromiumLauncher.setInstance(chrome);
493

494
    flutterDevice.device = GoogleChromeDevice(
495
      fileSystem: fileSystem,
496
      chromiumLauncher: chromiumLauncher,
497
      logger: BufferLogger.test(),
498
      platform: FakePlatform(),
499
      processManager: FakeProcessManager.any(),
500
    );
501 502
    webDevFS.report = UpdateFSReport(success: true);

503 504 505 506
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
507 508 509 510
    final DebugConnectionInfo debugConnectionInfo = await connectionInfoCompleter.future;

    expect(debugConnectionInfo, isNotNull);

511
    final OperationResult result = await residentWebRunner.restart();
512

513
    expect(logger.statusText, contains('Restarted application in'));
514
    expect(result.code, 0);
515
    expect(webDevFS.mainUri.toString(), contains('entrypoint.dart'));
516 517

    // ensure that analytics are sent.
518
    expect(testUsage.events, <TestUsageEvent>[
519
      TestUsageEvent('hot', 'restart', parameters: CustomDimensions.fromMap(<String, String>{'cd27': 'web-javascript', 'cd28': '', 'cd29': 'false', 'cd30': 'true', 'cd13': '0', 'cd48': 'false'})),
520 521 522 523
    ]);
    expect(testUsage.timings, const <TestTimingEvent>[
      TestTimingEvent('hot', 'web-incremental-restart', Duration.zero),
    ]);
524
  }, overrides: <Type, Generator>{
525
    Usage: () => testUsage,
526 527 528
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
529

530
  testUsingContext('Can hot restart after attaching', () async {
531 532
    final BufferLogger logger = BufferLogger.test();
    final ResidentRunner residentWebRunner = setUpResidentRunner(
533
      flutterDevice,
534
      logger: logger,
535
      systemClock: SystemClock.fixed(DateTime(2001)),
536
    );
537 538 539 540 541 542 543 544 545
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
      const FakeVmServiceRequest(
        method: 'hotRestart',
        jsonResponse: <String, Object>{
          'type': 'Success',
        }
      ),
    ]);
546
    _setupMocks();
547
    final TestChromiumLauncher chromiumLauncher = TestChromiumLauncher();
548
    final Chromium chrome = Chromium(1, chromeConnection, chromiumLauncher: chromiumLauncher);
549
    chromiumLauncher.setInstance(chrome);
550

551
    flutterDevice.device = GoogleChromeDevice(
552
      fileSystem: fileSystem,
553
      chromiumLauncher: chromiumLauncher,
554
      logger: BufferLogger.test(),
555
      platform: FakePlatform(),
556
      processManager: FakeProcessManager.any(),
557
    );
558 559
    webDevFS.report = UpdateFSReport(success: true);

560 561 562 563 564 565 566
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;
    final OperationResult result = await residentWebRunner.restart(fullRestart: true);

567
    // Ensure that generated entrypoint is generated correctly.
568 569
    expect(webDevFS.mainUri, isNotNull);
    final String entrypointContents = fileSystem.file(webDevFS.mainUri).readAsStringSync();
570 571 572
    expect(entrypointContents, contains('// Flutter web bootstrap script'));
    expect(entrypointContents, contains("import 'dart:ui' as ui;"));
    expect(entrypointContents, contains('await ui.webOnlyInitializePlatform();'));
573

574
    expect(logger.statusText, contains('Restarted application in'));
575
    expect(result.code, 0);
576

577
	  // ensure that analytics are sent.
578
    expect(testUsage.events, <TestUsageEvent>[
579
      TestUsageEvent('hot', 'restart', parameters: CustomDimensions.fromMap(<String, String>{'cd27': 'web-javascript', 'cd28': '', 'cd29': 'false', 'cd30': 'true', 'cd13': '0', 'cd48': 'false'})),
580 581 582 583
    ]);
    expect(testUsage.timings, const <TestTimingEvent>[
      TestTimingEvent('hot', 'web-incremental-restart', Duration.zero),
    ]);
584
  }, overrides: <Type, Generator>{
585
    Usage: () => testUsage,
586 587 588
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
589

590
  testUsingContext('Can hot restart after attaching with web-server device', () async {
591 592
    final BufferLogger logger = BufferLogger.test();
    final ResidentRunner residentWebRunner = setUpResidentRunner(
593
      flutterDevice,
594
      logger: logger,
595
      systemClock: SystemClock.fixed(DateTime(2001)),
596
    );
597
    fakeVmServiceHost = FakeVmServiceHost(requests :kAttachExpectations);
598
    _setupMocks();
599
    flutterDevice.device = webServerDevice;
600 601
    webDevFS.report = UpdateFSReport(success: true);

602 603 604 605 606 607 608
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;
    final OperationResult result = await residentWebRunner.restart(fullRestart: true);

609
    expect(logger.statusText, contains('Restarted application in'));
610
    expect(result.code, 0);
611 612 613 614

	  // web-server device does not send restart analytics
    expect(testUsage.events, isEmpty);
    expect(testUsage.timings, isEmpty);
615
  }, overrides: <Type, Generator>{
616
    Usage: () => testUsage,
617 618 619
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
620

621
  testUsingContext('web resident runner is debuggable', () {
622
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
623 624
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());

625
    expect(residentWebRunner.debuggingEnabled, true);
626 627 628 629
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
630

631
  testUsingContext('Exits when initial compile fails', () async {
632
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
633
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
634
    _setupMocks();
635
    webDevFS.report = UpdateFSReport();
636

637
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
638
    unawaited(residentWebRunner.run(
639 640 641
      connectionInfoCompleter: connectionInfoCompleter,
    ));

642
    expect(await residentWebRunner.run(), 1);
643 644
    expect(testUsage.events, isEmpty);
    expect(testUsage.timings, isEmpty);
645
  }, overrides: <Type, Generator>{
646
    Usage: () => testUsage,
647 648 649
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
650

651
  testUsingContext('Faithfully displays stdout messages with leading/trailing spaces', () async {
652
    final BufferLogger logger = BufferLogger.test();
653
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
654 655 656 657 658 659 660 661 662 663 664 665 666 667
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachLogExpectations,
      FakeVmServiceStreamResponse(
        streamId: 'Stdout',
        event: vm_service.Event(
          timestamp: 0,
          kind: vm_service.EventStreams.kStdout,
          bytes: base64.encode(
            utf8.encode('    This is a message with 4 leading and trailing spaces    '),
          ),
        ),
      ),
      ...kAttachIsolateExpectations,
    ]);
668 669 670 671 672 673 674
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

675
    expect(logger.statusText,
676
      contains('    This is a message with 4 leading and trailing spaces    '));
677
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
678 679 680 681
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
682

683
  testUsingContext('Fails on compilation errors in hot restart', () async {
684
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
685
    fakeVmServiceHost = FakeVmServiceHost(requests: kAttachExpectations.toList());
686 687
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
688
    unawaited(residentWebRunner.run(
689 690 691
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;
692
    webDevFS.report = UpdateFSReport();
693 694 695 696

    final OperationResult result = await residentWebRunner.restart(fullRestart: true);

    expect(result.code, 1);
697
    expect(result.message, contains('Failed to recompile application.'));
698 699
    expect(testUsage.events, isEmpty);
    expect(testUsage.timings, isEmpty);
700
  }, overrides: <Type, Generator>{
701
    Usage: () => testUsage,
702 703 704
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
705

706
  testUsingContext('Fails non-fatally on vmservice response error for hot restart', () async {
707
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
708 709 710 711 712 713 714 715 716
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
      const FakeVmServiceRequest(
        method: 'hotRestart',
        jsonResponse: <String, Object>{
          'type': 'Failed',
        }
      )
    ]);
717 718 719 720 721 722 723
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

724
    final OperationResult result = await residentWebRunner.restart();
725

726
    expect(result.code, 0);
727 728 729 730
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
731

732
  testUsingContext('Fails fatally on Vm Service error response', () async {
733
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
734 735 736 737 738 739 740 741
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
      const FakeVmServiceRequest(
        method: 'hotRestart',
        // Failed response,
        errorCode: RPCErrorCodes.kInternalError,
      ),
    ]);
742 743 744 745 746 747
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;
748
    final OperationResult result = await residentWebRunner.restart();
749 750

    expect(result.code, 1);
751 752
    expect(result.message,
      contains(RPCErrorCodes.kInternalError.toString()));
753 754 755 756
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
757

758
  testUsingContext('printHelp without details shows hot restart help message', () async {
759
    final BufferLogger logger = BufferLogger.test();
760
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
761 762 763
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
    residentWebRunner.printHelp(details: false);

764
    expect(logger.statusText, contains('To hot restart changes'));
765 766 767 768 769
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });

770
  testUsingContext('cleanup of resources is safe to call multiple times', () async {
771
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
772 773 774
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
    ]);
775 776
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
777
    unawaited(residentWebRunner.run(
778 779 780 781 782 783
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

    await residentWebRunner.exit();
    await residentWebRunner.exit();
784

785
    expect(debugConnection.didClose, false);
786
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
787 788 789 790
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
791

792
  testUsingContext('cleans up Chrome if tab is closed', () async {
793
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
794 795 796
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
    ]);
797 798 799 800 801 802
    _setupMocks();
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    final Future<int> result = residentWebRunner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    );
    await connectionInfoCompleter.future;
803
    debugConnection.completer.complete();
804 805

    await result;
806
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
807 808 809 810
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
811

812
  testUsingContext('Prints target and device name on run', () async {
813
    final BufferLogger logger = BufferLogger.test();
814
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
815 816 817
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachExpectations,
    ]);
818
    _setupMocks();
819
    mockDevice.name = 'Chromez';
820
    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
821
    unawaited(residentWebRunner.run(
822 823 824 825
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

826
    expect(logger.statusText, contains(
827
      'Launching ${fileSystem.path.join('lib', 'main.dart')} on '
828 829 830
      'Chromez in debug mode',
    ));
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
831 832 833 834
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
835

836
  testUsingContext('Sends launched app.webLaunchUrl event for Chrome device', () async {
837
    final BufferLogger logger = BufferLogger.test();
838 839
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[
      ...kAttachLogExpectations,
840
      ...kAttachIsolateExpectations,
841
    ]);
842
    _setupMocks();
843
    final FakeChromeConnection chromeConnection = FakeChromeConnection();
844
    final TestChromiumLauncher chromiumLauncher = TestChromiumLauncher();
845
    final Chromium chrome = Chromium(1, chromeConnection, chromiumLauncher: chromiumLauncher);
846
    chromiumLauncher.setInstance(chrome);
847

848
    flutterDevice.device = GoogleChromeDevice(
849
      fileSystem: fileSystem,
850
      chromiumLauncher: chromiumLauncher,
851
      logger: logger,
852
      platform: FakePlatform(),
853
      processManager: FakeProcessManager.any(),
854
    );
855 856
    webDevFS.baseUri = Uri.parse('http://localhost:8765/app/');

857 858
    final FakeChromeTab chromeTab = FakeChromeTab('index.html');
    chromeConnection.tabs.add(chromeTab);
859

860
    final ResidentWebRunner runner = ResidentWebRunner(
861
      flutterDevice,
862
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
863 864
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
865
      urlTunneller: null,
866 867 868 869 870
      fileSystem: fileSystem,
      logger: logger,
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
871 872 873 874 875 876 877 878

    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(runner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

    // Ensure we got the URL and that it was already launched.
879
    expect(logger.eventText,
880 881 882 883 884 885 886 887
      contains(json.encode(<String, Object>{
        'name': 'app.webLaunchUrl',
        'args': <String, Object>{
          'url': 'http://localhost:8765/app/',
          'launched': true,
        },
      },
    )));
888
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
889
  }, overrides: <Type, Generator>{
890 891 892
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
893

894
  testUsingContext('Sends unlaunched app.webLaunchUrl event for Web Server device', () async {
895
    final BufferLogger logger = BufferLogger.test();
896
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
897
    _setupMocks();
898
    flutterDevice.device = WebServerDevice(
899
      logger: logger,
900
    );
901
    webDevFS.baseUri = Uri.parse('http://localhost:8765/app/');
902

903
    final ResidentWebRunner runner = ResidentWebRunner(
904
      flutterDevice,
905
      flutterProject: FlutterProject.fromDirectoryTest(fileSystem.currentDirectory),
906 907
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
      ipv6: true,
908
      urlTunneller: null,
909 910 911 912 913
      fileSystem: fileSystem,
      logger: logger,
      usage: globals.flutterUsage,
      systemClock: globals.systemClock,
    );
914 915 916 917 918 919 920 921

    final Completer<DebugConnectionInfo> connectionInfoCompleter = Completer<DebugConnectionInfo>();
    unawaited(runner.run(
      connectionInfoCompleter: connectionInfoCompleter,
    ));
    await connectionInfoCompleter.future;

    // Ensure we got the URL and that it was not already launched.
922
    expect(logger.eventText,
923 924 925 926 927 928 929 930
      contains(json.encode(<String, Object>{
        'name': 'app.webLaunchUrl',
        'args': <String, Object>{
          'url': 'http://localhost:8765/app/',
          'launched': false,
        },
      },
    )));
931
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
932
  }, overrides: <Type, Generator>{
933 934 935
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
936

937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
  // While this file should be ignored on web, generating it here will cause a
  // perf regression in hot restart.
  testUsingContext('Does not generate generated_main.dart', () async {
    // Create necessary files for [DartPluginRegistrantTarget]
    final File packageConfig = globals.fs.directory('.dart_tool')
        .childFile('package_config.json');
    packageConfig.createSync(recursive: true);
    packageConfig.writeAsStringSync('''
{
  "configVersion": 2,
  "packages": [
    {
      "name": "path_provider_linux",
      "rootUri": "../../../path_provider_linux",
      "packageUri": "lib/",
      "languageVersion": "2.12"
    }
  ]
}
''');
    // Start with a generated_main.dart file.
    globals.fs.directory('.dart_tool')
              .childDirectory('flutter_build')
              .childFile('generated_main.dart')
              .createSync(recursive: true);

    final FlutterProject project = FlutterProject.fromDirectoryTest(fileSystem.currentDirectory);

    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
    await residentWebRunner.runSourceGenerators();

    // generated_main.dart should be untouched, indicating that its
    // generation didn't run. If it had run, the file would have been removed as
    // there are no plugins in the project.
    expect(project.dartPluginRegistrant.existsSync(), true);
    expect(project.dartPluginRegistrant.readAsStringSync(), '');
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });

978
  testUsingContext('Successfully turns WebSocketException into ToolExit', () async {
979 980
    final BufferLogger logger = BufferLogger.test();
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
981
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
982
    _setupMocks();
983
    webDevFS.exception = const WebSocketException();
984

985
    await expectLater(residentWebRunner.run, throwsToolExit());
986
    expect(logger.errorText, contains('WebSocketException'));
987
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
988 989 990 991
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
992

993
  testUsingContext('Successfully turns AppConnectionException into ToolExit', () async {
994
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
995
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
996
    _setupMocks();
997
    webDevFS.exception = AppConnectionException('');
998

999
    await expectLater(residentWebRunner.run, throwsToolExit());
1000
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
1001 1002 1003 1004
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
1005

1006
  testUsingContext('Successfully turns ChromeDebugError into ToolExit', () async {
1007
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
1008 1009
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
    _setupMocks();
1010

1011
    webDevFS.exception = ChromeDebugException(<String, dynamic>{});
1012

1013
    await expectLater(residentWebRunner.run, throwsToolExit());
1014
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
1015 1016 1017 1018
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
1019

1020
  testUsingContext('Rethrows unknown Exception type from dwds', () async {
1021
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice);
1022
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
1023
    _setupMocks();
1024
    webDevFS.exception = Exception();
1025

1026
    await expectLater(residentWebRunner.run, throwsException);
1027
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
1028 1029 1030 1031
  }, overrides: <Type, Generator>{
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
1032

1033
  testUsingContext('Rethrows unknown Error type from dwds tooling', () async {
1034
    final BufferLogger logger = BufferLogger.test();
1035
    final ResidentRunner residentWebRunner = setUpResidentRunner(flutterDevice, logger: logger);
1036
    fakeVmServiceHost = FakeVmServiceHost(requests: <VmServiceExpectation>[]);
1037
    _setupMocks();
1038
    webDevFS.exception = StateError('');
1039

1040
    await expectLater(residentWebRunner.run, throwsStateError);
1041
    expect(fakeVmServiceHost.hasRemainingExpectations, false);
1042
  }, overrides: <Type, Generator>{
1043 1044 1045 1046 1047
    FileSystem: () => fileSystem,
    ProcessManager: () => processManager,
  });
}

1048 1049 1050 1051 1052
ResidentRunner setUpResidentRunner(FlutterDevice flutterDevice, {
  Logger logger,
  SystemClock systemClock,
}) {
  return ResidentWebRunner(
1053
    flutterDevice,
1054
    flutterProject: FlutterProject.fromDirectoryTest(globals.fs.currentDirectory),
1055 1056 1057
    debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
    ipv6: true,
    urlTunneller: null,
1058 1059 1060 1061
    usage: globals.flutterUsage,
    systemClock: systemClock ?? SystemClock.fixed(DateTime.now()),
    fileSystem: globals.fs,
    logger: logger ?? BufferLogger.test(),
1062
    devtoolsHandler: createNoOpHandler,
1063
  );
1064 1065
}

1066 1067 1068
// Unfortunately Device, despite not being immutable, has an `operator ==`.
// Until we fix that, we have to also ignore related lints here.
// ignore: avoid_implementing_value_types
1069
class FakeWebServerDevice extends FakeDevice implements WebServerDevice { }
1070

1071 1072 1073
// Unfortunately Device, despite not being immutable, has an `operator ==`.
// Until we fix that, we have to also ignore related lints here.
// ignore: avoid_implementing_value_types
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
class FakeDevice extends Fake implements Device {
  @override
  String name;

  int count = 0;

  @override
  Future<String> get sdkNameAndVersion async => 'SDK Name and Version';

  @override
  DartDevelopmentService dds;

  @override
  Future<LaunchResult> startApp(
    covariant ApplicationPackage package, {
    String mainPath,
    String route,
    DebuggingOptions debuggingOptions,
    Map<String, dynamic> platformArgs,
    bool prebuiltApplication = false,
    bool ipv6 = false,
    String userIdentifier,
  }) async {
    return LaunchResult.succeeded();
  }

  @override
  Future<bool> stopApp(
    covariant ApplicationPackage app, {
    String userIdentifier,
  }) async {
    if (count > 0) {
      throw StateError('stopApp called more than once.');
    }
    count += 1;
    return true;
  }
}

class FakeDebugConnection extends Fake implements DebugConnection {
  FakeVmServiceHost Function() fakeVmServiceHost;

  @override
  vm_service.VmService get vmService => fakeVmServiceHost.call().vmService.service;

  @override
  String uri;

  final Completer<void> completer = Completer<void>();
  bool didClose = false;

  @override
  Future<void> get onDone => completer.future;

  @override
  Future<void> close() async {
    didClose = true;
  }
}

class FakeAppConnection extends Fake implements AppConnection {
  bool ranMain = false;

  @override
  void runMain() {
    ranMain = true;
  }
}
1142

1143 1144 1145
// Unfortunately Device, despite not being immutable, has an `operator ==`.
// Until we fix that, we have to also ignore related lints here.
// ignore: avoid_implementing_value_types
1146
class FakeChromeDevice extends Fake implements ChromiumDevice { }
1147

1148
class FakeWipDebugger extends Fake implements WipDebugger { }
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159

class FakeResidentCompiler extends Fake implements ResidentCompiler {
  @override
  Future<CompilerOutput> recompile(
    Uri mainUri,
    List<Uri> invalidatedFiles, {
    @required String outputPath,
    @required PackageConfig packageConfig,
    @required String projectRootPath,
    @required FileSystem fs,
    bool suppressErrors = false,
1160
    bool checkDartPluginRegistry = false,
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
  }) async {
    return const CompilerOutput('foo.dill', 0, <Uri>[]);
  }

  @override
  void accept() { }

  @override
  void reset() { }

  @override
  Future<CompilerOutput> reject() async {
    return const CompilerOutput('foo.dill', 0, <Uri>[]);
  }

  @override
  void addFileSystemRoot(String root) { }
}

class FakeWebDevFS extends Fake implements WebDevFS {
  Object exception;
  ConnectionResult result;
  UpdateFSReport report;

  Uri mainUri;

  @override
  List<Uri> sources = <Uri>[];

  @override
  Uri baseUri = Uri.parse('http://localhost:12345');

  @override
  DateTime lastCompiled = DateTime.now();

  @override
  PackageConfig lastPackageConfig = PackageConfig.empty;

  @override
  Future<Uri> create() async {
    return baseUri;
  }

  @override
  Future<UpdateFSReport> update({
    @required Uri mainUri,
    @required ResidentCompiler generator,
    @required bool trackWidgetCreation,
    @required String pathToReload,
    @required List<Uri> invalidatedFiles,
    @required PackageConfig packageConfig,
    @required String dillOutputPath,
    DevFSWriter devFSWriter,
    String target,
    AssetBundle bundle,
    DateTime firstBuildTime,
    bool bundleFirstUpload = false,
    bool fullRestart = false,
    String projectRootPath,
  }) async {
    this.mainUri = mainUri;
    return report;
  }

  @override
  Future<ConnectionResult> connect(bool useDebugExtension) async {
    if (exception != null) {
      throw exception;
    }
    return result;
  }
}
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260

class FakeChromeConnection extends Fake implements ChromeConnection {
  final List<ChromeTab> tabs = <ChromeTab>[];

  @override
  Future<ChromeTab> getTab(bool Function(ChromeTab tab) accept, {Duration retryFor}) async {
    return tabs.firstWhere(accept);
  }
}

class FakeChromeTab extends Fake implements ChromeTab {
  FakeChromeTab(this.url);

  @override
  final String url;
  final FakeWipConnection connection = FakeWipConnection();

  @override
  Future<WipConnection> connect() async {
    return connection;
  }
}

class FakeWipConnection extends Fake implements WipConnection {
  @override
  final WipDebugger debugger = FakeWipDebugger();
}

1261 1262 1263 1264
/// A test implementation of the [ChromiumLauncher] that launches a fixed instance.
class TestChromiumLauncher implements ChromiumLauncher {
  TestChromiumLauncher();

1265 1266
  bool _hasInstance = false;
  void setInstance(Chromium chromium) {
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
    _hasInstance = true;
    currentCompleter.complete(chromium);
  }

  @override
  Completer<Chromium> currentCompleter = Completer<Chromium>();

  @override
  bool canFindExecutable() {
    return true;
  }

  @override
  Future<Chromium> get connectedInstance => currentCompleter.future;

  @override
  String findExecutable() {
    return 'chrome';
  }

  @override
  bool get hasChromeInstance => _hasInstance;

  @override
  Future<Chromium> launch(String url, {bool headless = false, int debugPort, bool skipCheck = false, Directory cacheDir}) async {
    return currentCompleter.future;
  }
}
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376

class FakeFlutterDevice extends Fake implements FlutterDevice {
  Uri testUri;
  UpdateFSReport report = UpdateFSReport(
    success: true,
    invalidatedSourcesCount: 1,
  );
  Object reportError;

  @override
  ResidentCompiler generator;

  @override
  Stream<Uri> get observatoryUris => Stream<Uri>.value(testUri);

  @override
  FlutterVmService vmService;

  DevFS _devFS;

  @override
  DevFS get devFS => _devFS;

  @override
  set devFS(DevFS value) { }

  @override
  Device device;

  @override
  Future<void> stopEchoingDeviceLog() async { }

  @override
  Future<void> initLogReader() async { }

  @override
  Future<Uri> setupDevFS(String fsName, Directory rootDirectory) async {
    return testUri;
  }

  @override
  Future<void> exitApps({Duration timeoutDelay = const Duration(seconds: 10)}) async { }

  @override
  Future<void> connect({
    ReloadSources reloadSources,
    Restart restart,
    CompileExpression compileExpression,
    GetSkSLMethod getSkSLMethod,
    PrintStructuredErrorLogMethod printStructuredErrorLogMethod,
    int hostVmServicePort,
    int ddsPort,
    bool disableServiceAuthCodes = false,
    bool enableDds = true,
    @required bool allowExistingDdsInstance,
    bool ipv6 = false,
  }) async { }

  @override
  Future<UpdateFSReport> updateDevFS({
    Uri mainUri,
    String target,
    AssetBundle bundle,
    DateTime firstBuildTime,
    bool bundleFirstUpload = false,
    bool bundleDirty = false,
    bool fullRestart = false,
    String projectRootPath,
    String pathToReload,
    String dillOutputPath,
    List<Uri> invalidatedFiles,
    PackageConfig packageConfig,
  }) async {
    if (reportError != null) {
      throw reportError;
    }
    return report;
  }

  @override
  Future<void> updateReloadStatus(bool wasReloadSuccessful) async { }
}