extension.dart 20.4 KB
Newer Older
1 2 3 4 5
// Copyright 2016 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';
6

7
import 'package:flutter/semantics.dart';
8 9
import 'package:meta/meta.dart';

10
import 'package:flutter/cupertino.dart';
11
import 'package:flutter/foundation.dart';
12
import 'package:flutter/gestures.dart';
13
import 'package:flutter/material.dart';
14
import 'package:flutter/rendering.dart' show RendererBinding, SemanticsHandle;
15
import 'package:flutter/scheduler.dart';
16
import 'package:flutter/services.dart';
17
import 'package:flutter/widgets.dart';
18
import 'package:flutter_test/flutter_test.dart';
19

20 21 22
import '../common/error.dart';
import '../common/find.dart';
import '../common/frame_sync.dart';
23
import '../common/geometry.dart';
24 25 26 27 28 29
import '../common/gesture.dart';
import '../common/health.dart';
import '../common/message.dart';
import '../common/render_tree.dart';
import '../common/request_data.dart';
import '../common/semantics.dart';
30
import '../common/text.dart';
31

32 33
const String _extensionMethodName = 'driver';
const String _extensionMethod = 'ext.flutter.$_extensionMethodName';
34

35 36 37 38
/// Signature for the handler passed to [enableFlutterDriverExtension].
///
/// Messages are described in string form and should return a [Future] which
/// eventually completes to a string response.
39
typedef DataHandler = Future<String> Function(String message);
40

41
class _DriverBinding extends BindingBase with ServicesBinding, SchedulerBinding, GestureBinding, PaintingBinding, SemanticsBinding, RendererBinding, WidgetsBinding {
42
  _DriverBinding(this._handler, this._silenceErrors);
43 44

  final DataHandler _handler;
45
  final bool _silenceErrors;
46

47 48 49
  @override
  void initServiceExtensions() {
    super.initServiceExtensions();
50
    final FlutterDriverExtension extension = FlutterDriverExtension(_handler, _silenceErrors);
51 52
    registerServiceExtension(
      name: _extensionMethodName,
53
      callback: extension.call,
54 55 56
    );
  }
}
57 58 59 60 61 62 63 64

/// Enables Flutter Driver VM service extension.
///
/// This extension is required for tests that use `package:flutter_driver` to
/// drive applications from a separate process.
///
/// Call this function prior to running your application, e.g. before you call
/// `runApp`.
65 66 67
///
/// Optionally you can pass a [DataHandler] callback. It will be called if the
/// test calls [FlutterDriver.requestData].
68
///
Kent Boogaart's avatar
Kent Boogaart committed
69
/// `silenceErrors` will prevent exceptions from being logged. This is useful
70 71 72 73
/// for tests where exceptions are expected. Defaults to false. Any errors
/// will still be returned in the `response` field of the result json along
/// with an `isError` boolean.
void enableFlutterDriverExtension({ DataHandler handler, bool silenceErrors = false }) {
74
  assert(WidgetsBinding.instance == null);
75
  _DriverBinding(handler, silenceErrors);
76
  assert(WidgetsBinding.instance is _DriverBinding);
77 78
}

79
/// Signature for functions that handle a command and return a result.
80
typedef CommandHandlerCallback = Future<Result> Function(Command c);
81

82
/// Signature for functions that deserialize a JSON map to a command object.
83
typedef CommandDeserializerCallback = Command Function(Map<String, String> params);
84

85 86
/// Signature for functions that run the given finder and return the [Element]
/// found, if any, or null otherwise.
87
typedef FinderConstructor = Finder Function(SerializableFinder finder);
88

89 90 91 92 93
/// The class that manages communication between a Flutter Driver test and the
/// application being remote-controlled, on the application side.
///
/// This is not normally used directly. It is instantiated automatically when
/// calling [enableFlutterDriverExtension].
94 95
@visibleForTesting
class FlutterDriverExtension {
96
  /// Creates an object to manage a Flutter Driver connection.
97
  FlutterDriverExtension(this._requestDataHandler, this._silenceErrors) {
98 99
    _testTextInput.register();

100
    _commandHandlers.addAll(<String, CommandHandlerCallback>{
101
      'get_health': _getHealth,
102
      'get_render_tree': _getRenderTree,
103
      'enter_text': _enterText,
104
      'get_text': _getText,
105
      'request_data': _requestData,
106 107
      'scroll': _scroll,
      'scrollIntoView': _scrollIntoView,
108 109
      'set_frame_sync': _setFrameSync,
      'set_semantics': _setSemantics,
110
      'set_text_entry_emulation': _setTextEntryEmulation,
111
      'tap': _tap,
112
      'waitFor': _waitFor,
113
      'waitForAbsent': _waitForAbsent,
114
      'waitUntilNoTransientCallbacks': _waitUntilNoTransientCallbacks,
115
      'get_semantics_id': _getSemanticsId,
116
      'get_offset': _getOffset,
117
    });
118

119
    _commandDeserializers.addAll(<String, CommandDeserializerCallback>{
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
      'get_health': (Map<String, String> params) => GetHealth.deserialize(params),
      'get_render_tree': (Map<String, String> params) => GetRenderTree.deserialize(params),
      'enter_text': (Map<String, String> params) => EnterText.deserialize(params),
      'get_text': (Map<String, String> params) => GetText.deserialize(params),
      'request_data': (Map<String, String> params) => RequestData.deserialize(params),
      'scroll': (Map<String, String> params) => Scroll.deserialize(params),
      'scrollIntoView': (Map<String, String> params) => ScrollIntoView.deserialize(params),
      'set_frame_sync': (Map<String, String> params) => SetFrameSync.deserialize(params),
      'set_semantics': (Map<String, String> params) => SetSemantics.deserialize(params),
      'set_text_entry_emulation': (Map<String, String> params) => SetTextEntryEmulation.deserialize(params),
      'tap': (Map<String, String> params) => Tap.deserialize(params),
      'waitFor': (Map<String, String> params) => WaitFor.deserialize(params),
      'waitForAbsent': (Map<String, String> params) => WaitForAbsent.deserialize(params),
      'waitUntilNoTransientCallbacks': (Map<String, String> params) => WaitUntilNoTransientCallbacks.deserialize(params),
      'get_semantics_id': (Map<String, String> params) => GetSemanticsId.deserialize(params),
135
      'get_offset': (Map<String, String> params) => GetOffset.deserialize(params),
136
    });
137

138
    _finders.addAll(<String, FinderConstructor>{
139 140
      'ByText': (SerializableFinder finder) => _createByTextFinder(finder),
      'ByTooltipMessage': (SerializableFinder finder) => _createByTooltipMessageFinder(finder),
141
      'BySemanticsLabel': (SerializableFinder finder) => _createBySemanticsLabelFinder(finder),
142 143
      'ByValueKey': (SerializableFinder finder) => _createByValueKeyFinder(finder),
      'ByType': (SerializableFinder finder) => _createByTypeFinder(finder),
144
      'PageBack': (SerializableFinder finder) => _createPageBackFinder(),
145 146
      'Ancestor': (SerializableFinder finder) => _createAncestorFinder(finder),
      'Descendant': (SerializableFinder finder) => _createDescendantFinder(finder),
147
    });
148 149
  }

150 151
  final TestTextInput _testTextInput = TestTextInput();

152
  final DataHandler _requestDataHandler;
153
  final bool _silenceErrors;
154

155
  static final Logger _log = Logger('FlutterDriverExtension');
156

157
  final WidgetController _prober = LiveWidgetController(WidgetsBinding.instance);
158 159
  final Map<String, CommandHandlerCallback> _commandHandlers = <String, CommandHandlerCallback>{};
  final Map<String, CommandDeserializerCallback> _commandDeserializers = <String, CommandDeserializerCallback>{};
160
  final Map<String, FinderConstructor> _finders = <String, FinderConstructor>{};
161

162 163 164 165
  /// With [_frameSync] enabled, Flutter Driver will wait to perform an action
  /// until there are no pending frames in the app under test.
  bool _frameSync = true;

166 167 168 169 170 171 172 173 174 175
  /// Processes a driver command configured by [params] and returns a result
  /// as an arbitrary JSON object.
  ///
  /// [params] must contain key "command" whose value is a string that
  /// identifies the kind of the command and its corresponding
  /// [CommandDeserializerCallback]. Other keys and values are specific to the
  /// concrete implementation of [Command] and [CommandDeserializerCallback].
  ///
  /// The returned JSON is command specific. Generally the caller deserializes
  /// the result into a subclass of [Result], but that's not strictly required.
176
  @visibleForTesting
177
  Future<Map<String, dynamic>> call(Map<String, String> params) async {
178
    final String commandKind = params['command'];
179
    try {
180 181
      final CommandHandlerCallback commandHandler = _commandHandlers[commandKind];
      final CommandDeserializerCallback commandDeserializer =
182
          _commandDeserializers[commandKind];
183 184
      if (commandHandler == null || commandDeserializer == null)
        throw 'Extension $_extensionMethod does not support command $commandKind';
185
      final Command command = commandDeserializer(params);
186 187
      assert(WidgetsBinding.instance.isRootWidgetAttached || !command.requiresRootWidgetAttached,
          'No root widget is attached; have you remembered to call runApp()?');
188 189 190 191
      Future<Result> responseFuture = commandHandler(command);
      if (command.timeout != null)
        responseFuture = responseFuture.timeout(command.timeout);
      final Result response = await responseFuture;
192
      return _makeResponse(response?.toJson());
193
    } on TimeoutException catch (error, stackTrace) {
194
      final String msg = 'Timeout while executing $commandKind: $error\n$stackTrace';
195
      _log.error(msg);
196
      return _makeResponse(msg, isError: true);
197
    } catch (error, stackTrace) {
198
      final String msg = 'Uncaught extension error while executing $commandKind: $error\n$stackTrace';
199 200
      if (!_silenceErrors)
        _log.error(msg);
201
      return _makeResponse(msg, isError: true);
202 203 204
    }
  }

205
  Map<String, dynamic> _makeResponse(dynamic response, { bool isError = false }) {
206 207 208 209 210 211
    return <String, dynamic>{
      'isError': isError,
      'response': response,
    };
  }

212
  Future<Health> _getHealth(Command command) async => const Health(HealthStatus.ok);
213

214
  Future<RenderTree> _getRenderTree(Command command) async {
215
    return RenderTree(RendererBinding.instance?.renderView?.toStringDeep());
216 217
  }

218
  // Waits until at the end of a frame the provided [condition] is [true].
219
  Future<void> _waitUntilFrame(bool condition(), [ Completer<void> completer ]) {
220
    completer ??= Completer<void>();
221 222 223 224 225 226 227 228 229 230
    if (!condition()) {
      SchedulerBinding.instance.addPostFrameCallback((Duration timestamp) {
        _waitUntilFrame(condition, completer);
      });
    } else {
      completer.complete();
    }
    return completer.future;
  }

231
  /// Runs `finder` repeatedly until it finds one or more [Element]s.
232
  Future<Finder> _waitForElement(Finder finder) async {
233 234
    // TODO(mravn): This method depends on async execution. A refactoring
    // for sync-async semantics is tracked in https://github.com/flutter/flutter/issues/16801.
235
    await Future<void>.value(null);
236 237
    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);
238

239
    await _waitUntilFrame(() => finder.evaluate().isNotEmpty);
240 241 242 243 244

    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

    return finder;
245 246
  }

247 248 249 250 251
  /// Runs `finder` repeatedly until it finds zero [Element]s.
  Future<Finder> _waitForAbsentElement(Finder finder) async {
    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

252
    await _waitUntilFrame(() => finder.evaluate().isEmpty);
253 254 255 256 257 258 259

    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

    return finder;
  }

260 261
  Finder _createByTextFinder(ByText arguments) {
    return find.text(arguments.text);
262 263
  }

264 265
  Finder _createByTooltipMessageFinder(ByTooltipMessage arguments) {
    return find.byElementPredicate((Element element) {
266
      final Widget widget = element.widget;
267 268 269
      if (widget is Tooltip)
        return widget.message == arguments.text;
      return false;
270
    }, description: 'widget with text tooltip "${arguments.text}"');
271 272
  }

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  Finder _createBySemanticsLabelFinder(BySemanticsLabel arguments) {
    return find.byElementPredicate((Element element) {
      if (element is! RenderObjectElement) {
        return false;
      }
      final String semanticsLabel = element.renderObject?.debugSemantics?.label;
      if (semanticsLabel == null) {
        return false;
      }
      final Pattern label = arguments.label;
      return label is RegExp
          ? label.hasMatch(semanticsLabel)
          : label == semanticsLabel;
    }, description: 'widget with semantic label "${arguments.label}"');
  }

289
  Finder _createByValueKeyFinder(ByValueKey arguments) {
290 291
    switch (arguments.keyValueType) {
      case 'int':
292
        return find.byKey(ValueKey<int>(arguments.keyValue));
293
      case 'String':
294
        return find.byKey(ValueKey<String>(arguments.keyValue));
295 296 297
      default:
        throw 'Unsupported ByValueKey type: ${arguments.keyValueType}';
    }
298 299
  }

300 301 302 303 304 305
  Finder _createByTypeFinder(ByType arguments) {
    return find.byElementPredicate((Element element) {
      return element.widget.runtimeType.toString() == arguments.type;
    }, description: 'widget with runtimeType "${arguments.type}"');
  }

306 307 308 309 310 311 312 313 314 315 316
  Finder _createPageBackFinder() {
    return find.byElementPredicate((Element element) {
      final Widget widget = element.widget;
      if (widget is Tooltip)
        return widget.message == 'Back';
      if (widget is CupertinoNavigationBarBackButton)
        return true;
      return false;
    }, description: 'Material or Cupertino back button');
  }

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
  Finder _createAncestorFinder(Ancestor arguments) {
    return find.ancestor(
      of: _createFinder(arguments.of),
      matching: _createFinder(arguments.matching),
      matchRoot: arguments.matchRoot,
    );
  }

  Finder _createDescendantFinder(Descendant arguments) {
    return find.descendant(
      of: _createFinder(arguments.of),
      matching: _createFinder(arguments.matching),
      matchRoot: arguments.matchRoot,
    );
  }

333
  Finder _createFinder(SerializableFinder finder) {
334
    final FinderConstructor constructor = _finders[finder.finderType];
335

336
    if (constructor == null)
337 338
      throw 'Unsupported finder type: ${finder.finderType}';

339
    return constructor(finder);
340 341
  }

342
  Future<TapResult> _tap(Command command) async {
343
    final Tap tapCommand = command;
344 345 346 347
    final Finder computedFinder = await _waitForElement(
      _createFinder(tapCommand.finder).hitTestable()
    );
    await _prober.tap(computedFinder);
348
    return const TapResult();
349 350
  }

351
  Future<WaitForResult> _waitFor(Command command) async {
352
    final WaitFor waitForCommand = command;
353
    await _waitForElement(_createFinder(waitForCommand.finder));
354
    return const WaitForResult();
355 356
  }

357 358 359
  Future<WaitForAbsentResult> _waitForAbsent(Command command) async {
    final WaitForAbsent waitForAbsentCommand = command;
    await _waitForAbsentElement(_createFinder(waitForAbsentCommand.finder));
360
    return const WaitForAbsentResult();
361 362
  }

363
  Future<Result> _waitUntilNoTransientCallbacks(Command command) async {
364 365
    if (SchedulerBinding.instance.transientCallbackCount != 0)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);
366
    return null;
367 368
  }

369 370 371 372 373 374 375 376 377 378 379
  Future<GetSemanticsIdResult> _getSemanticsId(Command command) async {
    final GetSemanticsId semanticsCommand = command;
    final Finder target = await _waitForElement(_createFinder(semanticsCommand.finder));
    final Element element = target.evaluate().single;
    RenderObject renderObject = element.renderObject;
    SemanticsNode node;
    while (renderObject != null && node == null) {
      node = renderObject.debugSemantics;
      renderObject = renderObject.parent;
    }
    if (node == null)
380 381
      throw StateError('No semantics data found');
    return GetSemanticsIdResult(node.id);
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
  Future<GetOffsetResult> _getOffset(Command command) async {
    final GetOffset getOffsetCommand = command;
    final Finder finder = await _waitForElement(_createFinder(getOffsetCommand.finder));
    final Element element = finder.evaluate().single;
    final RenderBox box = element.renderObject;
    Offset localPoint;
    switch (getOffsetCommand.offsetType) {
      case OffsetType.topLeft:
        localPoint = Offset.zero;
        break;
      case OffsetType.topRight:
        localPoint = box.size.topRight(Offset.zero);
        break;
      case OffsetType.bottomLeft:
        localPoint = box.size.bottomLeft(Offset.zero);
        break;
      case OffsetType.bottomRight:
        localPoint = box.size.bottomRight(Offset.zero);
        break;
      case OffsetType.center:
        localPoint = box.size.center(Offset.zero);
        break;
    }
    final Offset globalPoint = box.localToGlobal(localPoint);
    return GetOffsetResult(dx: globalPoint.dx, dy: globalPoint.dy);
  }

411
  Future<ScrollResult> _scroll(Command command) async {
412 413
    final Scroll scrollCommand = command;
    final Finder target = await _waitForElement(_createFinder(scrollCommand.finder));
414
    final int totalMoves = scrollCommand.duration.inMicroseconds * scrollCommand.frequency ~/ Duration.microsecondsPerSecond;
415
    final Offset delta = Offset(scrollCommand.dx, scrollCommand.dy) / totalMoves.toDouble();
416
    final Duration pause = scrollCommand.duration ~/ totalMoves;
417 418
    final Offset startLocation = _prober.getCenter(target);
    Offset currentLocation = startLocation;
419 420
    final TestPointer pointer = TestPointer(1);
    final HitTestResult hitTest = HitTestResult();
421

422 423
    _prober.binding.hitTest(hitTest, startLocation);
    _prober.binding.dispatchEvent(pointer.down(startLocation), hitTest);
424
    await Future<void>.value(); // so that down and move don't happen in the same microtask
425
    for (int moves = 0; moves < totalMoves; moves += 1) {
426
      currentLocation = currentLocation + delta;
427
      _prober.binding.dispatchEvent(pointer.move(currentLocation), hitTest);
428
      await Future<void>.delayed(pause);
429
    }
430
    _prober.binding.dispatchEvent(pointer.up(), hitTest);
431

432
    return const ScrollResult();
433 434
  }

435
  Future<ScrollResult> _scrollIntoView(Command command) async {
436 437
    final ScrollIntoView scrollIntoViewCommand = command;
    final Finder target = await _waitForElement(_createFinder(scrollIntoViewCommand.finder));
Adam Barth's avatar
Adam Barth committed
438
    await Scrollable.ensureVisible(target.evaluate().single, duration: const Duration(milliseconds: 100), alignment: scrollIntoViewCommand.alignment ?? 0.0);
439
    return const ScrollResult();
440 441
  }

442
  Future<GetTextResult> _getText(Command command) async {
443 444
    final GetText getTextCommand = command;
    final Finder target = await _waitForElement(_createFinder(getTextCommand.finder));
445
    // TODO(yjbanov): support more ways to read text
446
    final Text text = target.evaluate().single.widget;
447
    return GetTextResult(text.data);
448
  }
449

450 451 452 453 454 455 456
  Future<SetTextEntryEmulationResult> _setTextEntryEmulation(Command command) async {
    final SetTextEntryEmulation setTextEntryEmulationCommand = command;
    if (setTextEntryEmulationCommand.enabled) {
      _testTextInput.register();
    } else {
      _testTextInput.unregister();
    }
457
    return const SetTextEntryEmulationResult();
458 459
  }

460
  Future<EnterTextResult> _enterText(Command command) async {
461 462 463 464
    if (!_testTextInput.isRegistered) {
      throw 'Unable to fulfill `FlutterDriver.enterText`. Text emulation is '
            'disabled. You can enable it using `FlutterDriver.setTextEntryEmulation`.';
    }
465 466
    final EnterText enterTextCommand = command;
    _testTextInput.enterText(enterTextCommand.text);
467
    return const EnterTextResult();
468 469
  }

470 471
  Future<RequestDataResult> _requestData(Command command) async {
    final RequestData requestDataCommand = command;
472
    return RequestDataResult(_requestDataHandler == null ? 'No requestData Extension registered' : await _requestDataHandler(requestDataCommand.message));
473 474
  }

475
  Future<SetFrameSyncResult> _setFrameSync(Command command) async {
476
    final SetFrameSync setFrameSyncCommand = command;
477
    _frameSync = setFrameSyncCommand.enabled;
478
    return const SetFrameSyncResult();
479
  }
480 481 482 483 484 485 486 487 488 489 490

  SemanticsHandle _semantics;
  bool get _semanticsIsEnabled => RendererBinding.instance.pipelineOwner.semanticsOwner != null;

  Future<SetSemanticsResult> _setSemantics(Command command) async {
    final SetSemantics setSemanticsCommand = command;
    final bool semanticsWasEnabled = _semanticsIsEnabled;
    if (setSemanticsCommand.enabled && _semantics == null) {
      _semantics = RendererBinding.instance.pipelineOwner.ensureSemantics();
      if (!semanticsWasEnabled) {
        // wait for the first frame where semantics is enabled.
491
        final Completer<void> completer = Completer<void>();
492 493 494 495 496 497 498 499 500
        SchedulerBinding.instance.addPostFrameCallback((Duration d) {
          completer.complete();
        });
        await completer.future;
      }
    } else if (!setSemanticsCommand.enabled && _semantics != null) {
      _semantics.dispose();
      _semantics = null;
    }
501
    return SetSemanticsResult(semanticsWasEnabled != _semanticsIsEnabled);
502
  }
503
}