mirror of
https://github.com/flutter/flutter
synced 2024-10-13 19:52:53 +00:00
c082f8d8a3
* Revert f9e6242db
* fix pubspec
* finish pubspec upgrade
512 lines
18 KiB
Dart
512 lines
18 KiB
Dart
// Copyright 2018 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'dart:async';
|
|
|
|
import 'package:file/memory.dart';
|
|
import 'package:flutter_tools/src/base/common.dart';
|
|
import 'package:flutter_tools/src/base/file_system.dart';
|
|
import 'package:flutter_tools/src/base/logger.dart';
|
|
import 'package:flutter_tools/src/base/platform.dart';
|
|
import 'package:flutter_tools/src/base/terminal.dart';
|
|
import 'package:flutter_tools/src/cache.dart';
|
|
import 'package:flutter_tools/src/commands/attach.dart';
|
|
import 'package:flutter_tools/src/device.dart';
|
|
import 'package:flutter_tools/src/resident_runner.dart';
|
|
import 'package:flutter_tools/src/run_hot.dart';
|
|
import 'package:meta/meta.dart';
|
|
import 'package:mockito/mockito.dart';
|
|
|
|
import '../src/common.dart';
|
|
import '../src/context.dart';
|
|
import '../src/mocks.dart';
|
|
|
|
void main() {
|
|
final StreamLogger logger = StreamLogger();
|
|
group('attach', () {
|
|
final FileSystem testFileSystem = MemoryFileSystem(
|
|
style: platform.isWindows ? FileSystemStyle.windows : FileSystemStyle
|
|
.posix,
|
|
);
|
|
|
|
setUp(() {
|
|
Cache.disableLocking();
|
|
testFileSystem.directory('lib').createSync();
|
|
testFileSystem.file('lib/main.dart').createSync();
|
|
});
|
|
|
|
group('with one device and no specified target file', () {
|
|
const int devicePort = 499;
|
|
const int hostPort = 42;
|
|
|
|
MockDeviceLogReader mockLogReader;
|
|
MockPortForwarder portForwarder;
|
|
MockAndroidDevice device;
|
|
|
|
setUp(() {
|
|
mockLogReader = MockDeviceLogReader();
|
|
portForwarder = MockPortForwarder();
|
|
device = MockAndroidDevice();
|
|
when(device.getLogReader()).thenAnswer((_) {
|
|
// Now that the reader is used, start writing messages to it.
|
|
Timer.run(() {
|
|
mockLogReader.addLine('Foo');
|
|
mockLogReader.addLine('Observatory listening on http://127.0.0.1:$devicePort');
|
|
});
|
|
|
|
return mockLogReader;
|
|
});
|
|
when(device.portForwarder)
|
|
.thenReturn(portForwarder);
|
|
when(portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')))
|
|
.thenAnswer((_) async => hostPort);
|
|
when(portForwarder.forwardedPorts)
|
|
.thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
|
|
when(portForwarder.unforward(any))
|
|
.thenAnswer((_) async => null);
|
|
|
|
// We cannot add the device to a device manager because that is
|
|
// only enabled by the context of each testUsingContext call.
|
|
//
|
|
// Instead each test will add the device to the device manager
|
|
// on its own.
|
|
});
|
|
|
|
tearDown(() {
|
|
mockLogReader.dispose();
|
|
});
|
|
|
|
testUsingContext('finds observatory port and forwards', () async {
|
|
testDeviceManager.addDevice(device);
|
|
final Completer<void> completer = Completer<void>();
|
|
final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
|
|
if (message == '[stdout] Done.') {
|
|
// The "Done." message is output by the AttachCommand when it's done.
|
|
completer.complete();
|
|
}
|
|
});
|
|
final Future<void> task = createTestCommandRunner(AttachCommand()).run(<String>['attach']);
|
|
await completer.future;
|
|
verify(
|
|
portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')),
|
|
).called(1);
|
|
await expectLoggerInterruptEndsTask(task, logger);
|
|
await loggerSubscription.cancel();
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Logger: () => logger,
|
|
});
|
|
|
|
testUsingContext('accepts filesystem parameters', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
const String filesystemScheme = 'foo';
|
|
const String filesystemRoot = '/build-output/';
|
|
const String projectRoot = '/build-output/project-root';
|
|
const String outputDill = '/tmp/output.dill';
|
|
|
|
final MockHotRunner mockHotRunner = MockHotRunner();
|
|
when(mockHotRunner.attach()).thenAnswer((_) async => 0);
|
|
|
|
final MockHotRunnerFactory mockHotRunnerFactory = MockHotRunnerFactory();
|
|
when(
|
|
mockHotRunnerFactory.build(
|
|
any,
|
|
target: anyNamed('target'),
|
|
projectRootPath: anyNamed('projectRootPath'),
|
|
dillOutputPath: anyNamed('dillOutputPath'),
|
|
debuggingOptions: anyNamed('debuggingOptions'),
|
|
packagesFilePath: anyNamed('packagesFilePath'),
|
|
usesTerminalUI: anyNamed('usesTerminalUI'),
|
|
ipv6: false,
|
|
),
|
|
).thenReturn(mockHotRunner);
|
|
|
|
final AttachCommand command = AttachCommand(
|
|
hotRunnerFactory: mockHotRunnerFactory,
|
|
);
|
|
await createTestCommandRunner(command).run(<String>[
|
|
'attach',
|
|
'--filesystem-scheme',
|
|
filesystemScheme,
|
|
'--filesystem-root',
|
|
filesystemRoot,
|
|
'--project-root',
|
|
projectRoot,
|
|
'--output-dill',
|
|
outputDill,
|
|
'-v', // enables verbose logging
|
|
]);
|
|
|
|
// Validate the attach call built a mock runner with the right
|
|
// project root and output dill.
|
|
final VerificationResult verificationResult = verify(
|
|
mockHotRunnerFactory.build(
|
|
captureAny,
|
|
target: anyNamed('target'),
|
|
projectRootPath: projectRoot,
|
|
dillOutputPath: outputDill,
|
|
debuggingOptions: anyNamed('debuggingOptions'),
|
|
packagesFilePath: anyNamed('packagesFilePath'),
|
|
usesTerminalUI: anyNamed('usesTerminalUI'),
|
|
ipv6: false,
|
|
),
|
|
)..called(1);
|
|
|
|
final List<FlutterDevice> flutterDevices = verificationResult.captured.first;
|
|
expect(flutterDevices, hasLength(1));
|
|
|
|
// Validate that the attach call built a flutter device with the right
|
|
// output dill, filesystem scheme, and filesystem root.
|
|
final FlutterDevice flutterDevice = flutterDevices.first;
|
|
|
|
expect(flutterDevice.dillOutputPath, outputDill);
|
|
expect(flutterDevice.fileSystemScheme, filesystemScheme);
|
|
expect(flutterDevice.fileSystemRoots, const <String>[filesystemRoot]);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
});
|
|
|
|
testUsingContext('exits when ipv6 is specified and debug-port is not', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final AttachCommand command = AttachCommand();
|
|
await expectLater(
|
|
createTestCommandRunner(command).run(<String>['attach', '--ipv6']),
|
|
throwsToolExit(
|
|
message: 'When the --debug-port is unknown, this command determines '
|
|
'the value of --ipv6 on its own.',
|
|
),
|
|
);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
},);
|
|
|
|
testUsingContext('exits when observatory-port is specified and debug-port is not', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final AttachCommand command = AttachCommand();
|
|
await expectLater(
|
|
createTestCommandRunner(command).run(<String>['attach', '--observatory-port', '100']),
|
|
throwsToolExit(
|
|
message: 'When the --debug-port is unknown, this command does not use '
|
|
'the value of --observatory-port.',
|
|
),
|
|
);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
},);
|
|
});
|
|
|
|
|
|
testUsingContext('selects specified target', () async {
|
|
const int devicePort = 499;
|
|
const int hostPort = 42;
|
|
final MockDeviceLogReader mockLogReader = MockDeviceLogReader();
|
|
final MockPortForwarder portForwarder = MockPortForwarder();
|
|
final MockAndroidDevice device = MockAndroidDevice();
|
|
final MockHotRunner mockHotRunner = MockHotRunner();
|
|
final MockHotRunnerFactory mockHotRunnerFactory = MockHotRunnerFactory();
|
|
when(device.portForwarder)
|
|
.thenReturn(portForwarder);
|
|
when(portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')))
|
|
.thenAnswer((_) async => hostPort);
|
|
when(portForwarder.forwardedPorts)
|
|
.thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
|
|
when(portForwarder.unforward(any))
|
|
.thenAnswer((_) async => null);
|
|
when(mockHotRunner.attach())
|
|
.thenAnswer((_) async => 0);
|
|
when(mockHotRunnerFactory.build(
|
|
any,
|
|
target: anyNamed('target'),
|
|
debuggingOptions: anyNamed('debuggingOptions'),
|
|
packagesFilePath: anyNamed('packagesFilePath'),
|
|
usesTerminalUI: anyNamed('usesTerminalUI'),
|
|
ipv6: false,
|
|
)).thenReturn(mockHotRunner);
|
|
|
|
testDeviceManager.addDevice(device);
|
|
when(device.getLogReader())
|
|
.thenAnswer((_) {
|
|
// Now that the reader is used, start writing messages to it.
|
|
Timer.run(() {
|
|
mockLogReader.addLine('Foo');
|
|
mockLogReader.addLine(
|
|
'Observatory listening on http://127.0.0.1:$devicePort');
|
|
});
|
|
return mockLogReader;
|
|
});
|
|
final File foo = fs.file('lib/foo.dart')
|
|
..createSync();
|
|
|
|
// Delete the main.dart file to be sure that attach works without it.
|
|
fs.file('lib/main.dart').deleteSync();
|
|
|
|
final AttachCommand command = AttachCommand(hotRunnerFactory: mockHotRunnerFactory);
|
|
await createTestCommandRunner(command).run(<String>['attach', '-t', foo.path, '-v']);
|
|
|
|
verify(mockHotRunnerFactory.build(
|
|
any,
|
|
target: foo.path,
|
|
debuggingOptions: anyNamed('debuggingOptions'),
|
|
packagesFilePath: anyNamed('packagesFilePath'),
|
|
usesTerminalUI: anyNamed('usesTerminalUI'),
|
|
ipv6: false,
|
|
)).called(1);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
});
|
|
|
|
group('forwarding to given port', () {
|
|
const int devicePort = 499;
|
|
const int hostPort = 42;
|
|
MockPortForwarder portForwarder;
|
|
MockAndroidDevice device;
|
|
|
|
setUp(() {
|
|
portForwarder = MockPortForwarder();
|
|
device = MockAndroidDevice();
|
|
|
|
when(device.portForwarder)
|
|
.thenReturn(portForwarder);
|
|
when(portForwarder.forward(devicePort))
|
|
.thenAnswer((_) async => hostPort);
|
|
when(portForwarder.forwardedPorts)
|
|
.thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
|
|
when(portForwarder.unforward(any))
|
|
.thenAnswer((_) async => null);
|
|
});
|
|
|
|
testUsingContext('succeeds in ipv4 mode', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final Completer<void> completer = Completer<void>();
|
|
final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
|
|
if (message == '[verbose] Connecting to service protocol: http://127.0.0.1:42/') {
|
|
// Wait until resident_runner.dart tries to connect.
|
|
// There's nothing to connect _to_, so that's as far as we care to go.
|
|
completer.complete();
|
|
}
|
|
});
|
|
final Future<void> task = createTestCommandRunner(AttachCommand())
|
|
.run(<String>['attach', '--debug-port', '$devicePort']);
|
|
await completer.future;
|
|
verify(portForwarder.forward(devicePort)).called(1);
|
|
|
|
await expectLoggerInterruptEndsTask(task, logger);
|
|
await loggerSubscription.cancel();
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Logger: () => logger,
|
|
});
|
|
|
|
testUsingContext('succeeds in ipv6 mode', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final Completer<void> completer = Completer<void>();
|
|
final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
|
|
if (message == '[verbose] Connecting to service protocol: http://[::1]:42/') {
|
|
// Wait until resident_runner.dart tries to connect.
|
|
// There's nothing to connect _to_, so that's as far as we care to go.
|
|
completer.complete();
|
|
}
|
|
});
|
|
final Future<void> task = createTestCommandRunner(AttachCommand())
|
|
.run(<String>['attach', '--debug-port', '$devicePort', '--ipv6']);
|
|
await completer.future;
|
|
verify(portForwarder.forward(devicePort)).called(1);
|
|
|
|
await expectLoggerInterruptEndsTask(task, logger);
|
|
await loggerSubscription.cancel();
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Logger: () => logger,
|
|
});
|
|
|
|
testUsingContext('skips in ipv4 mode with a provided observatory port', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final Completer<void> completer = Completer<void>();
|
|
final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
|
|
if (message == '[verbose] Connecting to service protocol: http://127.0.0.1:42/') {
|
|
// Wait until resident_runner.dart tries to connect.
|
|
// There's nothing to connect _to_, so that's as far as we care to go.
|
|
completer.complete();
|
|
}
|
|
});
|
|
final Future<void> task = createTestCommandRunner(AttachCommand()).run(
|
|
<String>[
|
|
'attach',
|
|
'--debug-port',
|
|
'$devicePort',
|
|
'--observatory-port',
|
|
'$hostPort',
|
|
],
|
|
);
|
|
await completer.future;
|
|
verifyNever(portForwarder.forward(devicePort));
|
|
|
|
await expectLoggerInterruptEndsTask(task, logger);
|
|
await loggerSubscription.cancel();
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Logger: () => logger,
|
|
});
|
|
|
|
testUsingContext('skips in ipv6 mode with a provided observatory port', () async {
|
|
testDeviceManager.addDevice(device);
|
|
|
|
final Completer<void> completer = Completer<void>();
|
|
final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
|
|
if (message == '[verbose] Connecting to service protocol: http://[::1]:42/') {
|
|
// Wait until resident_runner.dart tries to connect.
|
|
// There's nothing to connect _to_, so that's as far as we care to go.
|
|
completer.complete();
|
|
}
|
|
});
|
|
final Future<void> task = createTestCommandRunner(AttachCommand()).run(
|
|
<String>[
|
|
'attach',
|
|
'--debug-port',
|
|
'$devicePort',
|
|
'--observatory-port',
|
|
'$hostPort',
|
|
'--ipv6',
|
|
],
|
|
);
|
|
await completer.future;
|
|
verifyNever(portForwarder.forward(devicePort));
|
|
|
|
await expectLoggerInterruptEndsTask(task, logger);
|
|
await loggerSubscription.cancel();
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Logger: () => logger,
|
|
});
|
|
});
|
|
|
|
testUsingContext('exits when no device connected', () async {
|
|
final AttachCommand command = AttachCommand();
|
|
await expectLater(
|
|
createTestCommandRunner(command).run(<String>['attach']),
|
|
throwsA(isInstanceOf<ToolExit>()),
|
|
);
|
|
expect(testLogger.statusText, contains('No connected devices'));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
});
|
|
|
|
testUsingContext('exits when multiple devices connected', () async {
|
|
Device aDeviceWithId(String id) {
|
|
final MockAndroidDevice device = MockAndroidDevice();
|
|
when(device.name).thenReturn('d$id');
|
|
when(device.id).thenReturn(id);
|
|
when(device.isLocalEmulator).thenAnswer((_) async => false);
|
|
when(device.sdkNameAndVersion).thenAnswer((_) async => 'Android 46');
|
|
return device;
|
|
}
|
|
|
|
final AttachCommand command = AttachCommand();
|
|
testDeviceManager.addDevice(aDeviceWithId('xx1'));
|
|
testDeviceManager.addDevice(aDeviceWithId('yy2'));
|
|
await expectLater(
|
|
createTestCommandRunner(command).run(<String>['attach']),
|
|
throwsA(isInstanceOf<ToolExit>()),
|
|
);
|
|
expect(testLogger.statusText, contains('More than one device'));
|
|
expect(testLogger.statusText, contains('xx1'));
|
|
expect(testLogger.statusText, contains('yy2'));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
});
|
|
});
|
|
}
|
|
|
|
class MockPortForwarder extends Mock implements DevicePortForwarder {}
|
|
|
|
class MockHotRunner extends Mock implements HotRunner {}
|
|
|
|
class MockHotRunnerFactory extends Mock implements HotRunnerFactory {}
|
|
|
|
class StreamLogger extends Logger {
|
|
@override
|
|
bool get isVerbose => true;
|
|
|
|
@override
|
|
void printError(
|
|
String message, {
|
|
StackTrace stackTrace,
|
|
bool emphasis,
|
|
TerminalColor color,
|
|
int indent,
|
|
int hangingIndent,
|
|
bool wrap,
|
|
}) {
|
|
_log('[stderr] $message');
|
|
}
|
|
|
|
@override
|
|
void printStatus(
|
|
String message, {
|
|
bool emphasis,
|
|
TerminalColor color,
|
|
bool newline,
|
|
int indent,
|
|
int hangingIndent,
|
|
bool wrap,
|
|
}) {
|
|
_log('[stdout] $message');
|
|
}
|
|
|
|
@override
|
|
void printTrace(String message) {
|
|
_log('[verbose] $message');
|
|
}
|
|
|
|
@override
|
|
Status startProgress(
|
|
String message, {
|
|
@required Duration timeout,
|
|
String progressId,
|
|
bool multilineOutput = false,
|
|
int progressIndicatorPadding = kDefaultStatusPadding,
|
|
}) {
|
|
_log('[progress] $message');
|
|
return SilentStatus(timeout: timeout)..start();
|
|
}
|
|
|
|
bool _interrupt = false;
|
|
|
|
void interrupt() {
|
|
_interrupt = true;
|
|
}
|
|
|
|
final StreamController<String> _controller = StreamController<String>.broadcast();
|
|
|
|
void _log(String message) {
|
|
_controller.add(message);
|
|
if (_interrupt) {
|
|
_interrupt = false;
|
|
throw const LoggerInterrupted();
|
|
}
|
|
}
|
|
|
|
Stream<String> get stream => _controller.stream;
|
|
}
|
|
|
|
class LoggerInterrupted implements Exception {
|
|
const LoggerInterrupted();
|
|
}
|
|
|
|
Future<void> expectLoggerInterruptEndsTask(Future<void> task, StreamLogger logger) async {
|
|
logger.interrupt(); // an exception during the task should cause it to fail...
|
|
try {
|
|
await task;
|
|
expect(false, isTrue); // (shouldn't reach here)
|
|
} on ToolExit catch (error) {
|
|
expect(error.exitCode, 2); // ...with exit code 2.
|
|
}
|
|
}
|