Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Revert "[flutter_test] Adds method to mock EventChannels" #124401

Merged
merged 1 commit into from
Apr 7, 2023
Merged

Revert "[flutter_test] Adds method to mock EventChannels" #124401

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
71 changes: 45 additions & 26 deletions packages/flutter/test/services/platform_channel_test.dart
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -265,50 +265,69 @@ void main() {
});

group('EventChannel', () {
const MessageCodec<dynamic> jsonMessage = JSONMessageCodec();
const MethodCodec jsonMethod = JSONMethodCodec();
const EventChannel channel = EventChannel('ch', jsonMethod);

void emitEvent(ByteData? event) {
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.handlePlatformMessage(
'ch',
event,
(ByteData? reply) {},
);
}
test('can receive event stream', () async {
bool canceled = false;
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockStreamHandler(
channel,
MockStreamHandler.inline(
onListen: (Object? arguments, MockStreamHandlerEventSink events) {
events.success('${arguments}1');
events.success('${arguments}2');
events.endOfStream();
},
onCancel: (Object? arguments) {
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMessageHandler(
'ch',
(ByteData? message) async {
final Map<dynamic, dynamic> methodCall = jsonMessage.decodeMessage(message) as Map<dynamic, dynamic>;
if (methodCall['method'] == 'listen') {
final String argument = methodCall['args'] as String;
emitEvent(jsonMethod.encodeSuccessEnvelope('${argument}1'));
emitEvent(jsonMethod.encodeSuccessEnvelope('${argument}2'));
emitEvent(null);
return jsonMethod.encodeSuccessEnvelope(null);
} else if (methodCall['method'] == 'cancel') {
canceled = true;
},
),
return jsonMethod.encodeSuccessEnvelope(null);
} else {
fail('Expected listen or cancel');
}
},
);
final List<Object?> events = await channel.receiveBroadcastStream('hello').toList();
final List<dynamic> events = await channel.receiveBroadcastStream('hello').toList();
expect(events, orderedEquals(<String>['hello1', 'hello2']));
await Future<void>.delayed(Duration.zero);
expect(canceled, isTrue);
});

test('can receive error event', () async {
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockStreamHandler(
channel,
MockStreamHandler.inline(
onListen: (Object? arguments, MockStreamHandlerEventSink events) {
events.error(code: '404', message: 'Not Found.', details: arguments);
},
),
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMessageHandler(
'ch',
(ByteData? message) async {
final Map<dynamic, dynamic> methodCall = jsonMessage.decodeMessage(message) as Map<dynamic, dynamic>;
if (methodCall['method'] == 'listen') {
final String argument = methodCall['args'] as String;
emitEvent(jsonMethod.encodeErrorEnvelope(code: '404', message: 'Not Found.', details: argument));
return jsonMethod.encodeSuccessEnvelope(null);
} else if (methodCall['method'] == 'cancel') {
return jsonMethod.encodeSuccessEnvelope(null);
} else {
fail('Expected listen or cancel');
}
},
);
final List<Object?> events = <Object?>[];
final List<Object?> errors = <Object?>[];
final List<dynamic> events = <dynamic>[];
final List<dynamic> errors = <dynamic>[];
channel.receiveBroadcastStream('hello').listen(events.add, onError: errors.add);
await Future<void>.delayed(Duration.zero);
expect(events, isEmpty);
expect(errors, hasLength(1));
expect(errors[0], isA<PlatformException>());
final PlatformException? error = errors[0] as PlatformException?;
expect(error?.code, '404');
expect(error?.message, 'Not Found.');
expect(error?.details, 'hello');
final PlatformException error = errors[0] as PlatformException;
expect(error.code, '404');
expect(error.message, 'Not Found.');
expect(error.details, 'hello');
});
});
}
1 change: 0 additions & 1 deletion packages/flutter_test/lib/flutter_test.dart
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,6 @@ export 'src/frame_timing_summarizer.dart';
export 'src/goldens.dart';
export 'src/image.dart';
export 'src/matchers.dart';
export 'src/mock_event_channel.dart';
export 'src/nonconst.dart';
export 'src/platform.dart';
export 'src/restoration.dart';
Expand Down
79 changes: 0 additions & 79 deletions packages/flutter_test/lib/src/mock_event_channel.dart
View file
Open in desktop

This file was deleted.

84 changes: 0 additions & 84 deletions packages/flutter_test/lib/src/test_default_binary_messenger.dart
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,9 +8,6 @@ import 'dart:ui' as ui;
import 'package:fake_async/fake_async.dart';
import 'package:flutter/services.dart';

import 'mock_event_channel.dart';
import 'widget_tester.dart';

/// A function which takes the name of the method channel, it's handler,
/// platform message and asynchronously returns an encoded response.
typedef AllMessagesHandler = Future<ByteData?>? Function(
Expand Down Expand Up @@ -200,9 +197,6 @@ class TestDefaultBinaryMessenger extends BinaryMessenger {
///
/// * [setMockMethodCallHandler], which wraps this method but decodes
/// the messages using a [MethodCodec].
///
/// * [setMockStreamHandler], which wraps [setMockMethodCallHandler] to
/// handle [EventChannel] messages.
void setMockMessageHandler(String channel, MessageHandler? handler, [ Object? identity ]) {
if (handler == null) {
_outboundHandlers.remove(channel);
Expand Down Expand Up @@ -243,9 +237,6 @@ class TestDefaultBinaryMessenger extends BinaryMessenger {
///
/// * [setMockMethodCallHandler], which is similar but decodes
/// the messages using a [MethodCodec].
///
/// * [setMockStreamHandler], which wraps [setMockMethodCallHandler] to
/// handle [EventChannel] messages.
void setMockDecodedMessageHandler<T>(BasicMessageChannel<T> channel, Future<T> Function(T? message)? handler) {
if (handler == null) {
setMockMessageHandler(channel.name, null);
Expand Down Expand Up @@ -311,81 +302,6 @@ class TestDefaultBinaryMessenger extends BinaryMessenger {
}, handler);
}

/// Set a handler for intercepting stream events sent to the
/// platform on the given channel.
///
/// Intercepted method calls are not forwarded to the platform.
///
/// The given handler will replace the currently registered
/// handler for that channel, if any. To stop intercepting messages
/// at all, pass null as the handler.
///
/// Events are decoded using the codec of the channel.
///
/// The handler's stream messages are used as a response, after encoding
/// them using the channel's codec.
///
/// To send an error, pass the error information to the handler's event sink.
///
/// {@macro flutter.flutter_test.TestDefaultBinaryMessenger.handlePlatformMessage.asyncHandlers}
///
/// Registered handlers are cleared after each test.
///
/// See also:
///
/// * [setMockMethodCallHandler], which is the similar method for
/// [MethodChannel].
///
/// * [setMockMessageHandler], which is similar but provides raw
/// access to the underlying bytes.
///
/// * [setMockDecodedMessageHandler], which is similar but decodes
/// the messages using a [MessageCodec].
void setMockStreamHandler(EventChannel channel, MockStreamHandler? handler) {
if (handler == null) {
setMockMessageHandler(channel.name, null);
return;
}

final StreamController<Object?> controller = StreamController<Object?>();
addTearDown(controller.close);

setMockMethodCallHandler(MethodChannel(channel.name, channel.codec), (MethodCall call) async {
switch (call.method) {
case 'listen':
return handler.onListen(call.arguments, MockStreamHandlerEventSink(controller.sink));
case 'cancel':
return handler.onCancel(call.arguments);
default:
throw UnimplementedError('Method ${call.method} not implemented');
}
});

final StreamSubscription<Object?> sub = controller.stream.listen(
(Object? e) => channel.binaryMessenger.handlePlatformMessage(
channel.name,
channel.codec.encodeSuccessEnvelope(e),
null,
),
);
addTearDown(sub.cancel);
sub.onError((Object? e) {
if (e is! PlatformException) {
throw ArgumentError('Stream error must be a PlatformException');
}
channel.binaryMessenger.handlePlatformMessage(
channel.name,
channel.codec.encodeErrorEnvelope(
code: e.code,
message: e.message,
details: e.details,
),
null,
);
});
sub.onDone(() => channel.binaryMessenger.handlePlatformMessage(channel.name, null, null));
}

/// Returns true if the `handler` argument matches the `handler`
/// previously passed to [setMockMessageHandler],
/// [setMockDecodedMessageHandler], or [setMockMethodCallHandler].
Expand Down
26 changes: 0 additions & 26 deletions packages/flutter_test/test/test_default_binary_messenger_test.dart
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,32 +69,6 @@ void main() {
expect(result?.buffer.asUint8List(), Uint8List.fromList(<int>[2, 3, 4]));
});

test('Mock StreamHandler is set correctly', () async {
const EventChannel channel = EventChannel('');
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockStreamHandler(
channel,
MockStreamHandler.inline(onListen: (Object? arguments, MockStreamHandlerEventSink events) {
events.success(arguments);
events.error(code: 'code', message: 'message', details: 'details');
events.endOfStream();
})
);

expect(
channel.receiveBroadcastStream('argument'),
emitsInOrder(<Object?>[
'argument',
emitsError(
isA<PlatformException>()
.having((PlatformException e) => e.code, 'code', 'code')
.having((PlatformException e) => e.message, 'message', 'message')
.having((PlatformException e) => e.details, 'details', 'details'),
),
emitsDone,
]),
);
});

testWidgets('Mock AllMessagesHandler is set correctly',
(WidgetTester tester) async {
final TestDefaultBinaryMessenger binaryMessenger =
Expand Down