2019-11-27 23:04:02 +00:00
|
|
|
// Copyright 2014 The Flutter Authors. All rights reserved.
|
2016-01-27 22:03:41 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2020-09-03 00:30:04 +00:00
|
|
|
import 'package:flutter_tools/src/base/common.dart';
|
2020-07-24 23:15:44 +00:00
|
|
|
import 'package:flutter_tools/src/base/logger.dart';
|
2020-07-08 16:41:02 +00:00
|
|
|
import 'package:flutter_tools/src/base/terminal.dart';
|
2020-10-08 19:28:58 +00:00
|
|
|
import 'package:flutter_tools/src/base/user_messages.dart';
|
2019-07-08 22:58:38 +00:00
|
|
|
import 'package:flutter_tools/src/build_info.dart';
|
2016-01-27 22:03:41 +00:00
|
|
|
import 'package:flutter_tools/src/device.dart';
|
2019-06-26 17:09:14 +00:00
|
|
|
import 'package:flutter_tools/src/project.dart';
|
2020-10-08 19:28:58 +00:00
|
|
|
import 'package:meta/meta.dart';
|
2019-10-09 23:30:27 +00:00
|
|
|
import 'package:mockito/mockito.dart';
|
2020-08-12 02:36:05 +00:00
|
|
|
import 'package:fake_async/fake_async.dart';
|
2016-01-27 22:03:41 +00:00
|
|
|
|
2019-07-13 18:51:44 +00:00
|
|
|
import '../src/common.dart';
|
|
|
|
import '../src/context.dart';
|
2020-04-09 16:14:16 +00:00
|
|
|
import '../src/fake_devices.dart';
|
2020-03-16 21:15:00 +00:00
|
|
|
import '../src/mocks.dart';
|
2016-02-07 03:19:50 +00:00
|
|
|
|
2016-03-10 01:43:14 +00:00
|
|
|
void main() {
|
2016-01-27 22:03:41 +00:00
|
|
|
group('DeviceManager', () {
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('getDevices', () async {
|
2020-06-03 18:48:37 +00:00
|
|
|
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];
|
2020-10-08 19:28:58 +00:00
|
|
|
|
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
|
|
|
|
2020-06-03 18:48:37 +00:00
|
|
|
expect(await deviceManager.getDevices(), devices);
|
2016-01-27 22:03:41 +00:00
|
|
|
});
|
2016-08-30 18:11:54 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('getDeviceById exact matcher', () async {
|
2020-04-09 16:14:16 +00:00
|
|
|
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
|
|
|
|
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
|
|
|
|
final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
|
2017-03-04 01:50:46 +00:00
|
|
|
final List<Device> devices = <Device>[device1, device2, device3];
|
2020-10-08 19:28:58 +00:00
|
|
|
final BufferLogger logger = BufferLogger.test();
|
2020-07-24 23:15:44 +00:00
|
|
|
|
|
|
|
// 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,
|
2020-09-02 22:38:52 +00:00
|
|
|
deviceDiscoveryOverrides: <DeviceDiscovery>[
|
|
|
|
ThrowingPollingDeviceDiscovery(),
|
|
|
|
LongPollingDeviceDiscovery(),
|
|
|
|
],
|
2020-10-08 19:28:58 +00:00
|
|
|
logger: logger,
|
|
|
|
terminal: Terminal.test(),
|
2020-07-24 23:15:44 +00:00
|
|
|
);
|
2016-08-30 18:11:54 +00:00
|
|
|
|
2018-10-05 05:54:56 +00:00
|
|
|
Future<void> expectDevice(String id, List<Device> expected) async {
|
2020-02-20 01:40:24 +00:00
|
|
|
expect(await deviceManager.getDevicesById(id), expected);
|
2016-08-30 18:11:54 +00:00
|
|
|
}
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('01abfc49119c410e', <Device>[device2]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering 01abfc49119c410e'));
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('Nexus 5X', <Device>[device2]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering Nexus 5X'));
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('0553790d0a4e726f', <Device>[device1]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering 0553790d0a4e726f'));
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('getDeviceById prefix matcher', () async {
|
2020-07-24 23:15:44 +00:00
|
|
|
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];
|
2020-10-08 19:28:58 +00:00
|
|
|
final BufferLogger logger = BufferLogger.test();
|
2020-07-24 23:15:44 +00:00
|
|
|
|
|
|
|
// 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,
|
2020-09-02 22:38:52 +00:00
|
|
|
deviceDiscoveryOverrides: <DeviceDiscovery>[
|
|
|
|
ThrowingPollingDeviceDiscovery(),
|
|
|
|
],
|
2020-10-08 19:28:58 +00:00
|
|
|
logger: logger,
|
|
|
|
terminal: Terminal.test(),
|
2020-07-24 23:15:44 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
Future<void> expectDevice(String id, List<Device> expected) async {
|
|
|
|
expect(await deviceManager.getDevicesById(id), expected);
|
|
|
|
}
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('Nexus 5', <Device>[device1]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering Nexus 5'));
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('0553790', <Device>[device1]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering 0553790'));
|
2018-08-31 03:57:44 +00:00
|
|
|
await expectDevice('Nexus', <Device>[device1, device2]);
|
2020-07-24 23:15:44 +00:00
|
|
|
expect(logger.traceText, contains('Ignored error discovering Nexus'));
|
2016-08-30 18:11:54 +00:00
|
|
|
});
|
2020-03-16 21:15:00 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('getAllConnectedDevices caches', () async {
|
2020-04-09 16:14:16 +00:00
|
|
|
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
|
2020-10-08 19:28:58 +00:00
|
|
|
final TestDeviceManager deviceManager = TestDeviceManager(
|
|
|
|
<Device>[device1],
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2020-03-16 21:15:00 +00:00
|
|
|
expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);
|
|
|
|
|
2020-04-09 16:14:16 +00:00
|
|
|
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
|
2020-03-16 21:15:00 +00:00
|
|
|
deviceManager.resetDevices(<Device>[device2]);
|
|
|
|
expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('refreshAllConnectedDevices does not cache', () async {
|
2020-04-09 16:14:16 +00:00
|
|
|
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
|
2020-10-08 19:28:58 +00:00
|
|
|
final TestDeviceManager deviceManager = TestDeviceManager(
|
|
|
|
<Device>[device1],
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2020-03-16 21:15:00 +00:00
|
|
|
expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device1]);
|
|
|
|
|
2020-04-09 16:14:16 +00:00
|
|
|
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
|
2020-03-16 21:15:00 +00:00
|
|
|
deviceManager.resetDevices(<Device>[device2]);
|
|
|
|
expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device2]);
|
|
|
|
});
|
2016-01-27 22:03:41 +00:00
|
|
|
});
|
2019-06-26 17:09:14 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('PollingDeviceDiscovery startPolling', () {
|
|
|
|
FakeAsync().run((FakeAsync time) {
|
|
|
|
final FakePollingDeviceDiscovery pollingDeviceDiscovery = FakePollingDeviceDiscovery();
|
|
|
|
pollingDeviceDiscovery.startPolling();
|
|
|
|
time.elapse(const Duration(milliseconds: 4001));
|
2020-10-03 04:12:50 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
// First check should use the default polling timeout
|
|
|
|
// to quickly populate the list.
|
|
|
|
expect(pollingDeviceDiscovery.lastPollingTimeout, isNull);
|
2020-05-14 18:00:51 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
time.elapse(const Duration(milliseconds: 4001));
|
2020-10-03 04:12:50 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
// Subsequent polling should be much longer.
|
|
|
|
expect(pollingDeviceDiscovery.lastPollingTimeout, const Duration(seconds: 30));
|
|
|
|
pollingDeviceDiscovery.stopPolling();
|
2020-10-03 04:12:50 +00:00
|
|
|
});
|
2020-05-14 18:00:51 +00:00
|
|
|
});
|
|
|
|
|
2019-06-26 17:09:14 +00:00
|
|
|
group('Filter devices', () {
|
2020-10-08 19:28:58 +00:00
|
|
|
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 {
|
2019-06-26 17:09:14 +00:00
|
|
|
final List<Device> devices = <Device>[
|
2020-07-08 16:41:02 +00:00
|
|
|
ephemeralOne,
|
2019-06-26 17:09:14 +00:00
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
|
|
|
unsupported,
|
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-06-26 17:09:14 +00:00
|
|
|
|
2020-07-08 16:41:02 +00:00
|
|
|
expect(filtered.single, ephemeralOne);
|
2019-06-26 17:09:14 +00:00
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('choose first non-ephemeral device', () async {
|
2019-06-26 17:09:14 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
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');
|
2019-06-26 17:09:14 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: mockTerminal,
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2020-07-08 16:41:02 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
nonEphemeralOne
|
|
|
|
]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('choose second non-ephemeral device', () async {
|
2020-07-08 16:41:02 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
final MockTerminal mockTerminal = MockTerminal();
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
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');
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: mockTerminal,
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2020-07-08 16:41:02 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
nonEphemeralTwo
|
|
|
|
]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('choose first ephemeral device', () async {
|
2020-07-08 16:41:02 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
ephemeralOne,
|
|
|
|
ephemeralTwo,
|
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
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');
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: mockTerminal,
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2020-07-08 16:41:02 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
ephemeralOne
|
|
|
|
]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('choose second ephemeral device', () async {
|
2020-07-08 16:41:02 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
ephemeralOne,
|
|
|
|
ephemeralTwo,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
final MockTerminal mockTerminal = MockTerminal();
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
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');
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: mockTerminal,
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-06-26 17:09:14 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
2020-07-08 16:41:02 +00:00
|
|
|
ephemeralTwo
|
|
|
|
]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('choose non-ephemeral device', () async {
|
2020-07-08 16:41:02 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
ephemeralOne,
|
|
|
|
ephemeralTwo,
|
2019-06-26 17:09:14 +00:00
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
2020-07-08 16:41:02 +00:00
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final MockTerminal mockTerminal = MockTerminal();
|
|
|
|
|
|
|
|
when(mockTerminal.stdinHasTerminal).thenReturn(true);
|
|
|
|
when(mockTerminal.promptForCharInput(<String>['0', '1', '2', '3', 'q', 'Q'],
|
2020-09-03 00:30:04 +00:00
|
|
|
displayAcceptedCharacters: false,
|
2020-10-08 19:28:58 +00:00
|
|
|
logger: anyNamed('logger'),
|
|
|
|
prompt: anyNamed('prompt'),
|
|
|
|
)).thenAnswer((Invocation invocation) async => '2');
|
2020-07-08 16:41:02 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: mockTerminal,
|
|
|
|
);
|
|
|
|
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2020-07-08 16:41:02 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
nonEphemeralOne
|
2019-06-26 17:09:14 +00:00
|
|
|
]);
|
|
|
|
});
|
2019-07-08 22:58:38 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('exit from choose one of available devices', () async {
|
2020-09-03 00:30:04 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
ephemeralOne,
|
|
|
|
ephemeralTwo,
|
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
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>())
|
|
|
|
);
|
2020-09-03 00:30:04 +00:00
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('Removes a single unsupported device', () async {
|
2019-08-30 04:39:38 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
unsupported,
|
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-08-30 04:39:38 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('Does not remove an unsupported device if FlutterProject is null', () async {
|
2020-10-03 04:12:50 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
unsupported,
|
|
|
|
];
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2020-10-03 04:12:50 +00:00
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(null);
|
|
|
|
|
|
|
|
expect(filtered, <Device>[unsupported]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('Removes web and fuchsia from --all', () async {
|
2019-07-08 22:58:38 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
webDevice,
|
|
|
|
fuchsiaDevice,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2019-07-08 22:58:38 +00:00
|
|
|
deviceManager.specifiedDeviceId = 'all';
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-07-08 22:58:38 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[]);
|
|
|
|
});
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('Removes unsupported devices from --all', () async {
|
2019-07-08 22:58:38 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
|
|
|
unsupported,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2019-07-08 22:58:38 +00:00
|
|
|
deviceManager.specifiedDeviceId = 'all';
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-07-08 22:58:38 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
nonEphemeralOne,
|
|
|
|
nonEphemeralTwo,
|
|
|
|
]);
|
|
|
|
});
|
2019-07-15 23:10:39 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('uses DeviceManager.isDeviceSupportedForProject instead of device.isSupportedForProject', () async {
|
2019-07-15 23:10:39 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
unsupported,
|
|
|
|
];
|
2020-10-08 19:28:58 +00:00
|
|
|
final TestDeviceManager deviceManager = TestDeviceManager(
|
|
|
|
devices,
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2019-07-15 23:10:39 +00:00
|
|
|
deviceManager.isAlwaysSupportedOverride = true;
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
|
2019-07-15 23:10:39 +00:00
|
|
|
|
|
|
|
expect(filtered, <Device>[
|
|
|
|
unsupported,
|
|
|
|
]);
|
|
|
|
});
|
2020-09-02 22:38:52 +00:00
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
testWithoutContext('does not refresh device cache without a timeout', () async {
|
2020-09-02 22:38:52 +00:00
|
|
|
final List<Device> devices = <Device>[
|
|
|
|
ephemeralOne,
|
|
|
|
];
|
|
|
|
final MockDeviceDiscovery mockDeviceDiscovery = MockDeviceDiscovery();
|
|
|
|
when(mockDeviceDiscovery.supportsPlatform).thenReturn(true);
|
|
|
|
when(mockDeviceDiscovery.devices).thenAnswer((_) async => devices);
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
<Device>[],
|
|
|
|
deviceDiscoveryOverrides: <DeviceDiscovery>[
|
|
|
|
mockDeviceDiscovery
|
|
|
|
],
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2020-09-02 22:38:52 +00:00
|
|
|
deviceManager.specifiedDeviceId = ephemeralOne.id;
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(
|
2020-10-08 19:28:58 +00:00
|
|
|
FakeFlutterProject(),
|
2020-09-02 22:38:52 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2020-10-08 19:28:58 +00:00
|
|
|
final DeviceManager deviceManager = TestDeviceManager(
|
|
|
|
<Device>[],
|
|
|
|
deviceDiscoveryOverrides: <DeviceDiscovery>[
|
|
|
|
mockDeviceDiscovery
|
|
|
|
],
|
|
|
|
logger: BufferLogger.test(),
|
|
|
|
terminal: Terminal.test(),
|
|
|
|
);
|
2020-09-02 22:38:52 +00:00
|
|
|
deviceManager.specifiedDeviceId = ephemeralOne.id;
|
|
|
|
final List<Device> filtered = await deviceManager.findTargetDevices(
|
2020-10-08 19:28:58 +00:00
|
|
|
FakeFlutterProject(),
|
2020-09-02 22:38:52 +00:00
|
|
|
timeout: timeout,
|
|
|
|
);
|
|
|
|
|
|
|
|
expect(filtered.single, ephemeralOne);
|
|
|
|
verify(mockDeviceDiscovery.devices).called(1);
|
|
|
|
verify(mockDeviceDiscovery.discoverDevices(timeout: anyNamed('timeout'))).called(1);
|
|
|
|
});
|
2019-06-26 17:09:14 +00:00
|
|
|
});
|
2020-09-02 22:38:52 +00:00
|
|
|
|
2019-10-09 23:30:27 +00:00
|
|
|
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());
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2020-04-09 16:14:16 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
);
|
|
|
|
});
|
|
|
|
});
|
2020-08-11 18:36:03 +00:00
|
|
|
|
|
|
|
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');
|
|
|
|
});
|
2016-01-27 22:03:41 +00:00
|
|
|
}
|
2016-08-30 18:11:54 +00:00
|
|
|
|
2016-09-01 16:37:58 +00:00
|
|
|
class TestDeviceManager extends DeviceManager {
|
2020-07-24 23:15:44 +00:00
|
|
|
TestDeviceManager(List<Device> allDevices, {
|
2020-09-02 22:38:52 +00:00
|
|
|
List<DeviceDiscovery> deviceDiscoveryOverrides,
|
2020-10-08 19:28:58 +00:00
|
|
|
@required Logger logger,
|
|
|
|
@required Terminal terminal,
|
|
|
|
}) : super(logger: logger, terminal: terminal, userMessages: UserMessages()) {
|
2020-07-24 23:15:44 +00:00
|
|
|
_fakeDeviceDiscoverer = FakePollingDeviceDiscovery();
|
|
|
|
_deviceDiscoverers = <DeviceDiscovery>[
|
|
|
|
_fakeDeviceDiscoverer,
|
2020-09-02 22:38:52 +00:00
|
|
|
if (deviceDiscoveryOverrides != null)
|
|
|
|
...deviceDiscoveryOverrides
|
2020-07-24 23:15:44 +00:00
|
|
|
];
|
2020-03-16 21:15:00 +00:00
|
|
|
resetDevices(allDevices);
|
|
|
|
}
|
|
|
|
@override
|
2020-07-24 23:15:44 +00:00
|
|
|
List<DeviceDiscovery> get deviceDiscoverers => _deviceDiscoverers;
|
|
|
|
List<DeviceDiscovery> _deviceDiscoverers;
|
|
|
|
FakePollingDeviceDiscovery _fakeDeviceDiscoverer;
|
2016-09-01 16:37:58 +00:00
|
|
|
|
2020-03-16 21:15:00 +00:00
|
|
|
void resetDevices(List<Device> allDevices) {
|
2020-07-24 23:15:44 +00:00
|
|
|
_fakeDeviceDiscoverer.setDevices(allDevices);
|
2020-03-16 21:15:00 +00:00
|
|
|
}
|
2018-10-04 05:28:07 +00:00
|
|
|
|
2020-03-16 21:15:00 +00:00
|
|
|
bool isAlwaysSupportedOverride;
|
2019-07-15 23:10:39 +00:00
|
|
|
|
|
|
|
@override
|
|
|
|
bool isDeviceSupportedForProject(Device device, FlutterProject flutterProject) {
|
|
|
|
if (isAlwaysSupportedOverride != null) {
|
|
|
|
return isAlwaysSupportedOverride;
|
|
|
|
}
|
|
|
|
return super.isDeviceSupportedForProject(device, flutterProject);
|
|
|
|
}
|
2016-09-01 16:37:58 +00:00
|
|
|
}
|
|
|
|
|
2020-07-08 16:41:02 +00:00
|
|
|
class MockTerminal extends Mock implements AnsiTerminal {}
|
2020-09-02 22:38:52 +00:00
|
|
|
class MockDeviceDiscovery extends Mock implements DeviceDiscovery {}
|
2020-10-08 19:28:58 +00:00
|
|
|
class FakeFlutterProject extends Fake implements FlutterProject {}
|