fl_event_channel_test.cc

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Included first as it collides with the X11 headers.
#include "gtest/gtest.h"

#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_event_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
#include "flutter/shell/platform/linux/testing/mock_renderer.h"

// Data passed in tests.
typedef struct {
  GMainLoop* loop;
  int count;
} TestData;

// Creates a mock engine that responds to platform messages.
static FlEngine* make_mock_engine() {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlMockRenderer) renderer = fl_mock_renderer_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_renderer(project, FL_RENDERER(renderer));
  g_autoptr(GError) engine_error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &engine_error));
  EXPECT_EQ(engine_error, nullptr);

  return static_cast<FlEngine*>(g_object_ref(engine));
}

// Triggers the engine to start listening to the channel.
static void listen_channel(FlBinaryMessenger* messenger, FlValue* args) {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      messenger, "test/standard-method", FL_METHOD_CODEC(codec));

  // Trigger the engine to make a method call.
  g_autoptr(FlValue) invoke_args = fl_value_new_list();
  fl_value_append_take(invoke_args, fl_value_new_string("test/standard-event"));
  fl_value_append_take(invoke_args, fl_value_new_string("listen"));
  g_autoptr(FlValue) value =
      args != nullptr ? fl_value_ref(args) : fl_value_new_null();
  fl_value_append(invoke_args, value);
  fl_method_channel_invoke_method(channel, "InvokeMethod", invoke_args, nullptr,
                                  nullptr, nullptr);
}

// Triggers the engine to cancel the subscription to the channel.
static void cancel_channel(FlBinaryMessenger* messenger, FlValue* args) {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      messenger, "test/standard-method", FL_METHOD_CODEC(codec));

  // Trigger the engine to make a method call.
  g_autoptr(FlValue) invoke_args = fl_value_new_list();
  fl_value_append_take(invoke_args, fl_value_new_string("test/standard-event"));
  fl_value_append_take(invoke_args, fl_value_new_string("cancel"));
  g_autoptr(FlValue) value =
      args != nullptr ? fl_value_ref(args) : fl_value_new_null();
  fl_value_append(invoke_args, value);
  fl_method_channel_invoke_method(channel, "InvokeMethod", invoke_args, nullptr,
                                  nullptr, nullptr);
}

// Called when the remote end starts listening on the channel.
static FlMethodErrorResponse* listen_listen_cb(FlEventChannel* channel,
                                               FlValue* args,
                                               gpointer user_data) {
  EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);

  g_main_loop_quit(static_cast<GMainLoop*>(user_data));

  return nullptr;
}

// Checks we detect a listen event.
TEST(FlEventChannelTest, Listen) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, listen_listen_cb, nullptr, loop,
                                       nullptr);

  listen_channel(messenger, nullptr);

  // Blocks here until listen_listen_cb called.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Called when the remote end starts listening on the channel.
static FlMethodErrorResponse* listen_exception_listen_cb(
    FlEventChannel* channel,
    FlValue* args,
    gpointer user_data) {
  return fl_method_error_response_new("LISTEN-ERROR", "LISTEN-ERROR-MESSAGE",
                                      nullptr);
}

// Called when a the test engine notifies us what response we sent in the
// ListenException test.
static void listen_exception_response_cb(
    FlBinaryMessenger* messenger,
    const gchar* channel,
    GBytes* message,
    FlBinaryMessengerResponseHandle* response_handle,
    gpointer user_data) {
  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);

  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);

  EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
  EXPECT_STREQ(
      fl_method_error_response_get_code(FL_METHOD_ERROR_RESPONSE(response)),
      "LISTEN-ERROR");
  EXPECT_STREQ(
      fl_method_error_response_get_message(FL_METHOD_ERROR_RESPONSE(response)),
      "LISTEN-ERROR-MESSAGE");

  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

// Checks we can generate a listen exception.
TEST(FlEventChannelTest, ListenException) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, listen_exception_listen_cb,
                                       nullptr, loop, nullptr);

  // Listen for response to the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/responses", listen_exception_response_cb, loop, nullptr);

  listen_channel(messenger, nullptr);

  // Blocks here until listen_exception_response_cb called.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Called when the remote end cancels their subscription.
static FlMethodErrorResponse* cancel_cancel_cb(FlEventChannel* channel,
                                               FlValue* args,
                                               gpointer user_data) {
  EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);

  g_main_loop_quit(static_cast<GMainLoop*>(user_data));

  return nullptr;
}

// Checks we detect a cancel event.
TEST(FlEventChannelTest, Cancel) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, nullptr, cancel_cancel_cb, loop,
                                       nullptr);

  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);

  // Blocks here until cancel_cancel_cb called.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Called when the remote end cancels their subscription.
static FlMethodErrorResponse* cancel_exception_cancel_cb(
    FlEventChannel* channel,
    FlValue* args,
    gpointer user_data) {
  return fl_method_error_response_new("CANCEL-ERROR", "CANCEL-ERROR-MESSAGE",
                                      nullptr);
}

// Called when a the test engine notifies us what response we sent in the
// CancelException test.
static void cancel_exception_response_cb(
    FlBinaryMessenger* messenger,
    const gchar* channel,
    GBytes* message,
    FlBinaryMessengerResponseHandle* response_handle,
    gpointer user_data) {
  TestData* data = static_cast<TestData*>(user_data);

  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);

  data->count++;
  if (data->count == 2) {
    g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
    g_autoptr(GError) error = nullptr;
    g_autoptr(FlMethodResponse) response = fl_method_codec_decode_response(
        FL_METHOD_CODEC(codec), message, &error);
    EXPECT_NE(response, nullptr);
    EXPECT_EQ(error, nullptr);

    EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
    EXPECT_STREQ(
        fl_method_error_response_get_code(FL_METHOD_ERROR_RESPONSE(response)),
        "CANCEL-ERROR");
    EXPECT_STREQ(fl_method_error_response_get_message(
                     FL_METHOD_ERROR_RESPONSE(response)),
                 "CANCEL-ERROR-MESSAGE");

    g_main_loop_quit(data->loop);
  }
}

// Checks we can generate a cancel exception.
TEST(FlEventChannelTest, CancelException) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(
      channel, nullptr, cancel_exception_cancel_cb, &data, nullptr);

  // Listen for response to the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/responses", cancel_exception_response_cb, &data,
      nullptr);

  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);

  // Blocks here until cancel_exception_response_cb called.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Called when the remote end starts listening on the channel.
static FlMethodErrorResponse* args_listen_cb(FlEventChannel* channel,
                                             FlValue* args,
                                             gpointer user_data) {
  g_autoptr(FlValue) expected_args = fl_value_new_string("LISTEN-ARGS");
  EXPECT_TRUE(fl_value_equal(args, expected_args));

  return nullptr;
}

// Called when the remote end cancels their subscription.
static FlMethodErrorResponse* args_cancel_cb(FlEventChannel* channel,
                                             FlValue* args,
                                             gpointer user_data) {
  g_autoptr(FlValue) expected_args = fl_value_new_string("CANCEL-ARGS");
  EXPECT_TRUE(fl_value_equal(args, expected_args));

  g_main_loop_quit(static_cast<GMainLoop*>(user_data));

  return nullptr;
}

// Checks args are passed to listen/cancel.
TEST(FlEventChannelTest, Args) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, args_listen_cb, args_cancel_cb,
                                       loop, nullptr);

  g_autoptr(FlValue) listen_args = fl_value_new_string("LISTEN-ARGS");
  listen_channel(messenger, listen_args);
  g_autoptr(FlValue) cancel_args = fl_value_new_string("CANCEL-ARGS");
  cancel_channel(messenger, cancel_args);

  // Blocks here until args_cancel_cb called.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Called when the remote end starts listening on the channel.
static FlMethodErrorResponse* send_events_listen_cb(FlEventChannel* channel,
                                                    FlValue* args,
                                                    gpointer user_data) {
  // Send some events.
  for (int i = 0; i < 5; i++) {
    g_autoptr(FlValue) event = fl_value_new_int(i);
    g_autoptr(GError) error = nullptr;
    EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
    EXPECT_EQ(error, nullptr);
  }

  return nullptr;
}

// Called when a the test engine notifies us what event we sent in the
// Test test.
static void send_events_events_cb(
    FlBinaryMessenger* messenger,
    const gchar* channel,
    GBytes* message,
    FlBinaryMessengerResponseHandle* response_handle,
    gpointer user_data) {
  TestData* data = static_cast<TestData*>(user_data);

  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);

  FlValue* result = fl_method_response_get_result(response, &error);
  EXPECT_NE(result, nullptr);
  EXPECT_EQ(error, nullptr);

  EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_INT);
  EXPECT_EQ(fl_value_get_int(result), data->count);
  data->count++;

  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);

  // Got all the results!
  if (data->count == 5) {
    g_main_loop_quit(data->loop);
  }
}

// Checks can send events.
TEST(FlEventChannelTest, Test) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;

  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, send_events_listen_cb, nullptr,
                                       &data, nullptr);

  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);

  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);

  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);

  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

// Check can register an event channel with the same name as one previously
// used.
TEST(FlEventChannelTest, ReuseChannel) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;

  // Register an event channel.
  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel1 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel1, send_events_listen_cb, nullptr,
                                       &data, nullptr);

  // Remove this channel
  g_object_unref(channel1);

  // Register a second channel with the same name.
  g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel2, send_events_listen_cb, nullptr,
                                       &data, nullptr);

  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);

  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);

  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);
}

// Check can register an event channel replacing an existing one.
TEST(FlEventChannelTest, ReplaceChannel) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;

  // Register an event channel.
  g_autoptr(FlEngine) engine = make_mock_engine();
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel1 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel1, send_events_listen_cb, nullptr,
                                       &data, nullptr);

  // Register a second channel with the same name.
  g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel2, send_events_listen_cb, nullptr,
                                       &data, nullptr);

  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);

  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);

  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);
}