fl_platform_handler_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.

#include <gtk/gtk.h>

#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/fl_platform_handler.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_method_codec.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_codec.h"
#include "flutter/shell/platform/linux/testing/fl_test.h"
#include "flutter/shell/platform/linux/testing/mock_binary_messenger.h"
#include "flutter/testing/testing.h"

#include "gmock/gmock.h"
#include "gtest/gtest.h"

MATCHER_P(SuccessResponse, result, "") {
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), arg, nullptr);
  if (fl_value_equal(fl_method_response_get_result(response, nullptr),
                     result)) {
    return true;
  }
  *result_listener << ::testing::PrintToString(response);
  return false;
}

class MethodCallMatcher {
 public:
  using is_gtest_matcher = void;

  explicit MethodCallMatcher(::testing::Matcher<std::string> name,
                             ::testing::Matcher<FlValue*> args)
      : name_(std::move(name)), args_(std::move(args)) {}

  bool MatchAndExplain(GBytes* method_call,
                       ::testing::MatchResultListener* result_listener) const {
    g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
    g_autoptr(GError) error = nullptr;
    g_autofree gchar* name = nullptr;
    g_autoptr(FlValue) args = nullptr;
    gboolean result = fl_method_codec_decode_method_call(
        FL_METHOD_CODEC(codec), method_call, &name, &args, &error);
    if (!result) {
      *result_listener << ::testing::PrintToString(error->message);
      return false;
    }
    if (!name_.MatchAndExplain(name, result_listener)) {
      *result_listener << " where the name doesn't match: \"" << name << "\"";
      return false;
    }
    if (!args_.MatchAndExplain(args, result_listener)) {
      *result_listener << " where the args don't match: "
                       << ::testing::PrintToString(args);
      return false;
    }
    return true;
  }

  void DescribeTo(std::ostream* os) const {
    *os << "method name ";
    name_.DescribeTo(os);
    *os << " and args ";
    args_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "method name ";
    name_.DescribeNegationTo(os);
    *os << " or args ";
    args_.DescribeNegationTo(os);
  }

 private:
  ::testing::Matcher<std::string> name_;
  ::testing::Matcher<FlValue*> args_;
};

static ::testing::Matcher<GBytes*> MethodCall(
    const std::string& name,
    ::testing::Matcher<FlValue*> args) {
  return MethodCallMatcher(::testing::StrEq(name), std::move(args));
}

MATCHER_P(FlValueEq, value, "equal to " + ::testing::PrintToString(value)) {
  return fl_value_equal(arg, value);
}

G_DECLARE_FINAL_TYPE(FlTestApplication,
                     fl_test_application,
                     FL,
                     TEST_APPLICATION,
                     GtkApplication)

struct _FlTestApplication {
  GtkApplication parent_instance;
  gboolean* dispose_called;
};

G_DEFINE_TYPE(FlTestApplication,
              fl_test_application,
              gtk_application_get_type())

static void fl_test_application_startup(GApplication* application) {
  G_APPLICATION_CLASS(fl_test_application_parent_class)->startup(application);

  // Add a window to this application, which will hold a reference to the
  // application and stop it disposing. See
  // https://gitlab.gnome.org/GNOME/gtk/-/issues/6190
  gtk_application_window_new(GTK_APPLICATION(application));
}

static void fl_test_application_activate(GApplication* application) {
  G_APPLICATION_CLASS(fl_test_application_parent_class)->activate(application);

  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  g_autoptr(FlPlatformHandler) handler = fl_platform_handler_new(messenger);
  EXPECT_NE(handler, nullptr);
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();

  g_autoptr(FlValue) exit_result = fl_value_new_map();
  fl_value_set_string_take(exit_result, "response",
                           fl_value_new_string("exit"));
  EXPECT_CALL(messenger,
              fl_binary_messenger_send_response(
                  ::testing::Eq<FlBinaryMessenger*>(messenger), ::testing::_,
                  SuccessResponse(exit_result), ::testing::_))
      .WillOnce(::testing::Return(true));

  // Request app exit.
  g_autoptr(FlValue) args = fl_value_new_map();
  fl_value_set_string_take(args, "type", fl_value_new_string("required"));
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "System.exitApplication", args, nullptr);
  messenger.ReceiveMessage("flutter/platform", message);
}

static void fl_test_application_dispose(GObject* object) {
  FlTestApplication* self = FL_TEST_APPLICATION(object);

  *self->dispose_called = true;

  G_OBJECT_CLASS(fl_test_application_parent_class)->dispose(object);
}

static void fl_test_application_class_init(FlTestApplicationClass* klass) {
  G_OBJECT_CLASS(klass)->dispose = fl_test_application_dispose;
  G_APPLICATION_CLASS(klass)->startup = fl_test_application_startup;
  G_APPLICATION_CLASS(klass)->activate = fl_test_application_activate;
}

static void fl_test_application_init(FlTestApplication* self) {}

FlTestApplication* fl_test_application_new(gboolean* dispose_called) {
  FlTestApplication* self = FL_TEST_APPLICATION(
      g_object_new(fl_test_application_get_type(), nullptr));

  // Don't try and register on D-Bus.
  g_application_set_application_id(G_APPLICATION(self), "dev.flutter.GtkTest");
  g_application_set_flags(G_APPLICATION(self), G_APPLICATION_NON_UNIQUE);

  // Added to stop compiler complaining about an unused function.
  FL_IS_TEST_APPLICATION(self);

  self->dispose_called = dispose_called;

  return self;
}

TEST(FlPlatformHandlerTest, PlaySound) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;

  g_autoptr(FlPlatformHandler) handler = fl_platform_handler_new(messenger);
  EXPECT_NE(handler, nullptr);

  g_autoptr(FlValue) args = fl_value_new_string("SystemSoundType.alert");
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "SystemSound.play", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/platform", message);
}

TEST(FlPlatformHandlerTest, ExitApplication) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;

  g_autoptr(FlPlatformHandler) handler = fl_platform_handler_new(messenger);
  EXPECT_NE(handler, nullptr);
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();

  g_autoptr(FlValue) null = fl_value_new_null();
  ON_CALL(messenger, fl_binary_messenger_send_response(
                         ::testing::Eq<FlBinaryMessenger*>(messenger),
                         ::testing::_, SuccessResponse(null), ::testing::_))
      .WillByDefault(testing::Return(TRUE));

  // Indicate that the binding is initialized.
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) init_message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "System.initializationComplete", nullptr, &error);
  messenger.ReceiveMessage("flutter/platform", init_message);

  g_autoptr(FlValue) request_args = fl_value_new_map();
  fl_value_set_string_take(request_args, "type",
                           fl_value_new_string("cancelable"));
  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/platform"),
                  MethodCall("System.requestAppExit", FlValueEq(request_args)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_autoptr(FlValue) args = fl_value_new_map();
  fl_value_set_string_take(args, "type", fl_value_new_string("cancelable"));
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "System.exitApplication", args, nullptr);
  messenger.ReceiveMessage("flutter/platform", message);
}

TEST(FlPlatformHandlerTest, ExitApplicationDispose) {
  gtk_init(0, nullptr);

  gboolean dispose_called = false;
  FlTestApplication* application = fl_test_application_new(&dispose_called);

  // Run the application, it will quit after startup.
  g_application_run(G_APPLICATION(application), 0, nullptr);

  EXPECT_FALSE(dispose_called);
  g_object_unref(application);
  EXPECT_TRUE(dispose_called);
}