device_test.dart 20.3 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
import 'package:flutter_tools/src/base/common.dart';
6
import 'package:flutter_tools/src/base/logger.dart';
7
import 'package:flutter_tools/src/base/terminal.dart';
8
import 'package:flutter_tools/src/base/user_messages.dart';
9
import 'package:flutter_tools/src/build_info.dart';
10
import 'package:flutter_tools/src/device.dart';
11
import 'package:flutter_tools/src/project.dart';
12
import 'package:meta/meta.dart';
13
import 'package:mockito/mockito.dart';
14
import 'package:fake_async/fake_async.dart';
15

16 17
import '../src/common.dart';
import '../src/context.dart';
18
import '../src/fake_devices.dart';
19
import '../src/mocks.dart';
20

21
void main() {
22
  group('DeviceManager', () {
23
    testWithoutContext('getDevices', () async {
24 25 26 27
      final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
      final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
      final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
      final List<Device> devices = <Device>[device1, device2, device3];
28 29 30 31 32 33 34

      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );

35
      expect(await deviceManager.getDevices(), devices);
36
    });
37

38
    testWithoutContext('getDeviceById exact matcher', () async {
39 40 41
      final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
      final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
      final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
42
      final List<Device> devices = <Device>[device1, device2, device3];
43
      final BufferLogger logger = BufferLogger.test();
44 45 46 47 48 49 50 51 52

      // Include different device discoveries:
      // 1. One that never completes to prove the first exact match is
      // returned quickly.
      // 2. One that throws, to prove matches can return when some succeed
      // and others fail.
      // 3. A device discoverer that succeeds.
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
53 54 55 56
        deviceDiscoveryOverrides: <DeviceDiscovery>[
          ThrowingPollingDeviceDiscovery(),
          LongPollingDeviceDiscovery(),
        ],
57 58
        logger: logger,
        terminal: Terminal.test(),
59
      );
60

61
      Future<void> expectDevice(String id, List<Device> expected) async {
62
        expect(await deviceManager.getDevicesById(id), expected);
63
      }
64
      await expectDevice('01abfc49119c410e', <Device>[device2]);
65
      expect(logger.traceText, contains('Ignored error discovering 01abfc49119c410e'));
66
      await expectDevice('Nexus 5X', <Device>[device2]);
67
      expect(logger.traceText, contains('Ignored error discovering Nexus 5X'));
68
      await expectDevice('0553790d0a4e726f', <Device>[device1]);
69 70 71
      expect(logger.traceText, contains('Ignored error discovering 0553790d0a4e726f'));
    });

72
    testWithoutContext('getDeviceById prefix matcher', () async {
73 74 75 76
      final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
      final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
      final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
      final List<Device> devices = <Device>[device1, device2, device3];
77
      final BufferLogger logger = BufferLogger.test();
78 79 80 81 82 83 84

      // Include different device discoveries:
      // 1. One that throws, to prove matches can return when some succeed
      // and others fail.
      // 2. A device discoverer that succeeds.
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
85 86 87
        deviceDiscoveryOverrides: <DeviceDiscovery>[
          ThrowingPollingDeviceDiscovery(),
        ],
88 89
        logger: logger,
        terminal: Terminal.test(),
90 91 92 93 94
      );

      Future<void> expectDevice(String id, List<Device> expected) async {
        expect(await deviceManager.getDevicesById(id), expected);
      }
95
      await expectDevice('Nexus 5', <Device>[device1]);
96
      expect(logger.traceText, contains('Ignored error discovering Nexus 5'));
97
      await expectDevice('0553790', <Device>[device1]);
98
      expect(logger.traceText, contains('Ignored error discovering 0553790'));
99
      await expectDevice('Nexus', <Device>[device1, device2]);
100
      expect(logger.traceText, contains('Ignored error discovering Nexus'));
101
    });
102

103
    testWithoutContext('getAllConnectedDevices caches', () async {
104
      final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
105 106 107 108 109
      final TestDeviceManager deviceManager = TestDeviceManager(
        <Device>[device1],
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
110 111
      expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);

112
      final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
113 114 115 116
      deviceManager.resetDevices(<Device>[device2]);
      expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);
    });

117
    testWithoutContext('refreshAllConnectedDevices does not cache', () async {
118
      final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
119 120 121 122 123
      final TestDeviceManager deviceManager = TestDeviceManager(
        <Device>[device1],
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
124 125
      expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device1]);

126
      final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
127 128 129
      deviceManager.resetDevices(<Device>[device2]);
      expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device2]);
    });
130
  });
131

132 133 134 135 136
  testWithoutContext('PollingDeviceDiscovery startPolling', () {
    FakeAsync().run((FakeAsync time) {
      final FakePollingDeviceDiscovery pollingDeviceDiscovery = FakePollingDeviceDiscovery();
      pollingDeviceDiscovery.startPolling();
      time.elapse(const Duration(milliseconds: 4001));
137

138 139 140
      // First check should use the default polling timeout
      // to quickly populate the list.
      expect(pollingDeviceDiscovery.lastPollingTimeout, isNull);
141

142
      time.elapse(const Duration(milliseconds: 4001));
143

144 145 146
      // Subsequent polling should be much longer.
      expect(pollingDeviceDiscovery.lastPollingTimeout, const Duration(seconds: 30));
      pollingDeviceDiscovery.stopPolling();
147
    });
148 149
  });

150
  group('Filter devices', () {
151 152 153 154 155 156 157 158 159 160 161
    final FakeDevice ephemeralOne = FakeDevice('ephemeralOne', 'ephemeralOne', true);
    final FakeDevice ephemeralTwo = FakeDevice('ephemeralTwo', 'ephemeralTwo', true);
    final FakeDevice nonEphemeralOne = FakeDevice('nonEphemeralOne', 'nonEphemeralOne', false);
    final FakeDevice nonEphemeralTwo = FakeDevice('nonEphemeralTwo', 'nonEphemeralTwo', false);
    final FakeDevice unsupported = FakeDevice('unsupported', 'unsupported', true, false);
    final FakeDevice webDevice = FakeDevice('webby', 'webby')
      ..targetPlatform = Future<TargetPlatform>.value(TargetPlatform.web_javascript);
    final FakeDevice fuchsiaDevice = FakeDevice('fuchsiay', 'fuchsiay')
      ..targetPlatform = Future<TargetPlatform>.value(TargetPlatform.fuchsia_x64);

    testWithoutContext('chooses ephemeral device', () async {
162
      final List<Device> devices = <Device>[
163
        ephemeralOne,
164 165 166 167 168
        nonEphemeralOne,
        nonEphemeralTwo,
        unsupported,
      ];

169 170 171 172 173 174
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
175

176
      expect(filtered.single, ephemeralOne);
177 178
    });

179
    testWithoutContext('choose first non-ephemeral device', () async {
180 181 182 183
      final List<Device> devices = <Device>[
        nonEphemeralOne,
        nonEphemeralTwo,
      ];
184 185 186 187 188 189 190
      final MockTerminal mockTerminal = MockTerminal();
      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', 'q', 'Q'],
        displayAcceptedCharacters: false,
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => '0');
191

192 193 194 195 196 197
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
198 199 200 201 202 203

      expect(filtered, <Device>[
        nonEphemeralOne
      ]);
    });

204
    testWithoutContext('choose second non-ephemeral device', () async {
205 206 207 208
      final List<Device> devices = <Device>[
        nonEphemeralOne,
        nonEphemeralTwo,
      ];
209
      final MockTerminal mockTerminal = MockTerminal();
210

211 212 213 214 215 216
      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', 'q', 'Q'],
        displayAcceptedCharacters: false,
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => '1');
217

218 219 220 221 222 223
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
224 225 226 227 228 229

      expect(filtered, <Device>[
        nonEphemeralTwo
      ]);
    });

230
    testWithoutContext('choose first ephemeral device', () async {
231 232 233 234 235
      final List<Device> devices = <Device>[
        ephemeralOne,
        ephemeralTwo,
      ];

236 237 238 239 240 241 242 243
      final MockTerminal mockTerminal = MockTerminal();

      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', 'q', 'Q'],
        displayAcceptedCharacters: false,
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => '0');
244

245 246 247 248 249 250
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
251 252 253 254 255 256

      expect(filtered, <Device>[
        ephemeralOne
      ]);
    });

257
    testWithoutContext('choose second ephemeral device', () async {
258 259 260 261
      final List<Device> devices = <Device>[
        ephemeralOne,
        ephemeralTwo,
      ];
262
      final MockTerminal mockTerminal = MockTerminal();
263

264 265 266 267 268 269
      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', 'q', 'Q'],
        displayAcceptedCharacters: false,
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => '1');
270

271 272 273 274 275 276
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
277 278

      expect(filtered, <Device>[
279 280 281 282
        ephemeralTwo
      ]);
    });

283
    testWithoutContext('choose non-ephemeral device', () async {
284 285 286
      final List<Device> devices = <Device>[
        ephemeralOne,
        ephemeralTwo,
287 288
        nonEphemeralOne,
        nonEphemeralTwo,
289 290
      ];

291 292 293 294
      final MockTerminal mockTerminal = MockTerminal();

      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', '2', '3', 'q', 'Q'],
295
        displayAcceptedCharacters: false,
296 297 298
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => '2');
299

300 301 302 303 304 305 306
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );

      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
307 308 309

      expect(filtered, <Device>[
        nonEphemeralOne
310 311
      ]);
    });
312

313
    testWithoutContext('exit from choose one of available devices', () async {
314 315 316 317 318
      final List<Device> devices = <Device>[
        ephemeralOne,
        ephemeralTwo,
      ];

319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
      final MockTerminal mockTerminal = MockTerminal();

      when(mockTerminal.stdinHasTerminal).thenReturn(true);
      when(mockTerminal.promptForCharInput(<String>['0', '1', 'q', 'Q'],
        displayAcceptedCharacters: false,
        logger: anyNamed('logger'),
        prompt: anyNamed('prompt'),
      )).thenAnswer((Invocation invocation) async => 'q');

      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: mockTerminal,
      );
      await expectLater(
        () async => await deviceManager.findTargetDevices(FakeFlutterProject()),
        throwsA(isA<ToolExit>())
      );
337 338
    });

339
    testWithoutContext('Removes a single unsupported device', () async {
340 341 342 343
      final List<Device> devices = <Device>[
        unsupported,
      ];

344 345 346 347 348 349
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
350 351 352 353

      expect(filtered, <Device>[]);
    });

354
    testWithoutContext('Does not remove an unsupported device if FlutterProject is null', () async {
355 356 357 358
      final List<Device> devices = <Device>[
        unsupported,
      ];

359 360 361 362 363
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
364 365 366 367 368
      final List<Device> filtered = await deviceManager.findTargetDevices(null);

      expect(filtered, <Device>[unsupported]);
    });

369
    testWithoutContext('Removes web and fuchsia from --all', () async {
370 371 372 373
      final List<Device> devices = <Device>[
        webDevice,
        fuchsiaDevice,
      ];
374 375 376 377 378
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
379 380
      deviceManager.specifiedDeviceId = 'all';

381
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
382 383 384 385

      expect(filtered, <Device>[]);
    });

386
    testWithoutContext('Removes unsupported devices from --all', () async {
387 388 389 390 391
      final List<Device> devices = <Device>[
        nonEphemeralOne,
        nonEphemeralTwo,
        unsupported,
      ];
392 393 394 395 396
      final DeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
397 398
      deviceManager.specifiedDeviceId = 'all';

399
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
400 401 402 403 404 405

      expect(filtered, <Device>[
        nonEphemeralOne,
        nonEphemeralTwo,
      ]);
    });
406

407
    testWithoutContext('uses DeviceManager.isDeviceSupportedForProject instead of device.isSupportedForProject', () async {
408 409 410
      final List<Device> devices = <Device>[
        unsupported,
      ];
411 412 413 414 415
      final TestDeviceManager deviceManager = TestDeviceManager(
        devices,
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
416 417
      deviceManager.isAlwaysSupportedOverride = true;

418
      final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
419 420 421 422 423

      expect(filtered, <Device>[
        unsupported,
      ]);
    });
424

425
    testWithoutContext('does not refresh device cache without a timeout', () async {
426 427 428 429 430 431 432
      final List<Device> devices = <Device>[
        ephemeralOne,
      ];
      final MockDeviceDiscovery mockDeviceDiscovery = MockDeviceDiscovery();
      when(mockDeviceDiscovery.supportsPlatform).thenReturn(true);
      when(mockDeviceDiscovery.devices).thenAnswer((_) async => devices);

433 434 435 436 437 438 439 440
      final DeviceManager deviceManager = TestDeviceManager(
        <Device>[],
        deviceDiscoveryOverrides: <DeviceDiscovery>[
          mockDeviceDiscovery
        ],
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
441 442
      deviceManager.specifiedDeviceId = ephemeralOne.id;
      final List<Device> filtered = await deviceManager.findTargetDevices(
443
        FakeFlutterProject(),
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
      );

      expect(filtered.single, ephemeralOne);
      verify(mockDeviceDiscovery.devices).called(1);
      verifyNever(mockDeviceDiscovery.discoverDevices(timeout: anyNamed('timeout')));
    });

    testUsingContext('refreshes device cache with a timeout', () async {
      final List<Device> devices = <Device>[
        ephemeralOne,
      ];
      const Duration timeout = Duration(seconds: 2);
      final MockDeviceDiscovery mockDeviceDiscovery = MockDeviceDiscovery();
      when(mockDeviceDiscovery.supportsPlatform).thenReturn(true);
      when(mockDeviceDiscovery.discoverDevices(timeout: timeout)).thenAnswer((_) async => devices);
      when(mockDeviceDiscovery.devices).thenAnswer((_) async => devices);

461 462 463 464 465 466 467 468
      final DeviceManager deviceManager = TestDeviceManager(
        <Device>[],
        deviceDiscoveryOverrides: <DeviceDiscovery>[
          mockDeviceDiscovery
        ],
        logger: BufferLogger.test(),
        terminal: Terminal.test(),
      );
469 470
      deviceManager.specifiedDeviceId = ephemeralOne.id;
      final List<Device> filtered = await deviceManager.findTargetDevices(
471
        FakeFlutterProject(),
472 473 474 475 476 477 478
        timeout: timeout,
      );

      expect(filtered.single, ephemeralOne);
      verify(mockDeviceDiscovery.devices).called(1);
      verify(mockDeviceDiscovery.discoverDevices(timeout: anyNamed('timeout'))).called(1);
    });
479
  });
480

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
  group('ForwardedPort', () {
    group('dispose()', () {
      testUsingContext('does not throw exception if no process is present', () {
        final ForwardedPort forwardedPort = ForwardedPort(123, 456);
        expect(forwardedPort.context, isNull);
        forwardedPort.dispose();
      });

      testUsingContext('kills process if process was available', () {
        final MockProcess mockProcess = MockProcess();
        final ForwardedPort forwardedPort = ForwardedPort.withContext(123, 456, mockProcess);
        forwardedPort.dispose();
        expect(forwardedPort.context, isNotNull);
        verify(mockProcess.kill());
      });
    });
  });
498 499 500 501 502 503 504 505 506 507 508

  group('JSON encode devices', () {
    testUsingContext('Consistency of JSON representation', () async {
      expect(
        // This tests that fakeDevices is a list of tuples where "second" is the
        // correct JSON representation of the "first". Actual values are irrelevant
        await Future.wait(fakeDevices.map((FakeDeviceJsonData d) => d.dev.toJson())),
        fakeDevices.map((FakeDeviceJsonData d) => d.json)
      );
    });
  });
509 510 511 512 513 514 515

  testWithoutContext('computeDartVmFlags handles various combinations of Dart VM flags and null_assertions', () {
    expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: null)), '');
    expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: '--foo')), '--foo');
    expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: '', nullAssertions: true)), '--null_assertions');
    expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: '--foo', nullAssertions: true)), '--foo,--null_assertions');
  });
516
}
517

518
class TestDeviceManager extends DeviceManager {
519
    TestDeviceManager(List<Device> allDevices, {
520
    List<DeviceDiscovery> deviceDiscoveryOverrides,
521 522 523
    @required Logger logger,
    @required Terminal terminal,
  }) : super(logger: logger, terminal: terminal, userMessages: UserMessages()) {
524 525 526
    _fakeDeviceDiscoverer = FakePollingDeviceDiscovery();
    _deviceDiscoverers = <DeviceDiscovery>[
      _fakeDeviceDiscoverer,
527 528
      if (deviceDiscoveryOverrides != null)
        ...deviceDiscoveryOverrides
529
    ];
530 531 532
    resetDevices(allDevices);
  }
  @override
533 534 535
  List<DeviceDiscovery> get deviceDiscoverers => _deviceDiscoverers;
  List<DeviceDiscovery> _deviceDiscoverers;
  FakePollingDeviceDiscovery _fakeDeviceDiscoverer;
536

537
  void resetDevices(List<Device> allDevices) {
538
    _fakeDeviceDiscoverer.setDevices(allDevices);
539
  }
540

541
  bool isAlwaysSupportedOverride;
542 543 544 545 546 547 548 549

  @override
  bool isDeviceSupportedForProject(Device device, FlutterProject flutterProject) {
    if (isAlwaysSupportedOverride != null) {
      return isAlwaysSupportedOverride;
    }
    return super.isDeviceSupportedForProject(device, flutterProject);
  }
550 551
}

552
class MockTerminal extends Mock implements AnsiTerminal {}
553
class MockDeviceDiscovery extends Mock implements DeviceDiscovery {}
554
class FakeFlutterProject extends Fake implements FlutterProject {}