ftl_messaging_client_unittest.cc

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "remoting/signaling/ftl_messaging_client.h"

#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/task/thread_pool.h"
#include "base/test/bind.h"
#include "base/test/mock_callback.h"
#include "base/test/task_environment.h"
#include "remoting/base/fake_oauth_token_getter.h"
#include "remoting/base/protobuf_http_client.h"
#include "remoting/base/protobuf_http_status.h"
#include "remoting/base/protobuf_http_test_responder.h"
#include "remoting/base/scoped_protobuf_http_request.h"
#include "remoting/proto/ftl/v1/ftl_messages.pb.h"
#include "remoting/signaling/ftl_services_context.h"
#include "remoting/signaling/message_reception_channel.h"
#include "remoting/signaling/registration_manager.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace remoting {

namespace {

using ::testing::_;
using ::testing::Invoke;
using ::testing::Property;
using ::testing::Return;
using ::testing::Truly;

constexpr char kFakeServerEndpoint[] = "test.com";
constexpr char kFakeSenderId[] = "fake_sender@gmail.com";
constexpr char kFakeSenderRegId[] = "fake_sender_reg_id";
constexpr char kFakeReceiverId[] = "fake_receiver@gmail.com";
constexpr char kMessage1Id[] = "msg_1";
constexpr char kMessage2Id[] = "msg_2";
constexpr char kMessage1Text[] = "Message 1";
constexpr char kMessage2Text[] = "Message 2";

MATCHER(IsFakeSenderId, "") {
  return arg.id() == kFakeSenderId;
}

ftl::ChromotingMessage CreateXmppMessage(const std::string& message_text) {
  ftl::ChromotingMessage crd_message;
  crd_message.mutable_xmpp()->set_stanza(message_text);
  return crd_message;
}

ftl::InboxMessage CreateInboxMessage(const std::string& message_id,
                                     const std::string& message_text) {
  ftl::InboxMessage message;
  message.mutable_sender_id()->set_id(kFakeSenderId);
  message.mutable_receiver_id()->set_id(kFakeReceiverId);
  message.set_sender_registration_id(kFakeSenderRegId);
  message.set_message_type(ftl::InboxMessage_MessageType_CHROMOTING_MESSAGE);
  message.set_message_id(message_id);
  ftl::ChromotingMessage crd_message = CreateXmppMessage(message_text);
  std::string serialized_message;
  bool succeeded = crd_message.SerializeToString(&serialized_message);
  EXPECT_TRUE(succeeded);
  message.set_message(serialized_message);
  return message;
}

base::OnceCallback<void(const ProtobufHttpStatus&)>
CheckStatusThenQuitRunLoopCallback(
    const base::Location& from_here,
    ProtobufHttpStatus::Code expected_status_code,
    base::RunLoop* run_loop) {
  return base::BindLambdaForTesting([=](const ProtobufHttpStatus& status) {
    ASSERT_EQ(expected_status_code, status.error_code())
        << "Incorrect status code. Location: " << from_here.ToString();
    run_loop->QuitWhenIdle();
  });
}

std::string GetChromotingMessageText(const ftl::InboxMessage& message) {
  EXPECT_EQ(ftl::InboxMessage_MessageType_CHROMOTING_MESSAGE,
            message.message_type());
  ftl::ChromotingMessage chromoting_message;
  chromoting_message.ParseFromString(message.message());
  return chromoting_message.xmpp().stanza();
}

class MockMessageReceptionChannel : public MessageReceptionChannel {
 public:
  MockMessageReceptionChannel() = default;

  MockMessageReceptionChannel(const MockMessageReceptionChannel&) = delete;
  MockMessageReceptionChannel& operator=(const MockMessageReceptionChannel&) =
      delete;

  ~MockMessageReceptionChannel() override = default;

  // MessageReceptionChannel implementations.
  void Initialize(const StreamOpener& stream_opener,
                  const MessageCallback& on_incoming_msg) override {
    stream_opener_ = stream_opener;
    on_incoming_msg_ = on_incoming_msg;
  }

  MOCK_METHOD2(StartReceivingMessages, void(base::OnceClosure, DoneCallback));
  MOCK_METHOD0(StopReceivingMessages, void());
  MOCK_CONST_METHOD0(IsReceivingMessages, bool());

  StreamOpener* stream_opener() { return &stream_opener_; }

  MessageCallback* on_incoming_msg() { return &on_incoming_msg_; }

 private:
  StreamOpener stream_opener_;
  MessageCallback on_incoming_msg_;
};

class MockRegistrationManager : public RegistrationManager {
 public:
  MockRegistrationManager() = default;
  ~MockRegistrationManager() override = default;

  MOCK_METHOD1(SignInGaia, void(DoneCallback));
  MOCK_METHOD0(SignOut, void());
  MOCK_CONST_METHOD0(IsSignedIn, bool());
  MOCK_CONST_METHOD0(GetRegistrationId, std::string());
  MOCK_CONST_METHOD0(GetFtlAuthToken, std::string());
};

decltype(auto) StanzaTextMatches(const std::string& expected_stanza) {
  return Truly([=](const ftl::ChromotingMessage& message) {
    return expected_stanza == message.xmpp().stanza();
  });
}

}  // namespace

class FtlMessagingClientTest : public testing::Test {
 public:
  void SetUp() override;
  void TearDown() override;

 protected:
  ProtobufHttpTestResponder test_responder_;
  FakeOAuthTokenGetter token_getter_{OAuthTokenGetter::Status::SUCCESS, "", ""};
  std::unique_ptr<FtlMessagingClient> messaging_client_;
  raw_ptr<MockMessageReceptionChannel> mock_message_reception_channel_;

 private:
  base::test::TaskEnvironment task_environment_;
  MockRegistrationManager mock_registration_manager_;
};

void FtlMessagingClientTest::SetUp() {
  EXPECT_CALL(mock_registration_manager_, GetFtlAuthToken())
      .WillRepeatedly(Return("fake_auth_token"));
  auto channel = std::make_unique<MockMessageReceptionChannel>();
  mock_message_reception_channel_ = channel.get();
  messaging_client_ = std::unique_ptr<FtlMessagingClient>(
      new FtlMessagingClient(std::make_unique<ProtobufHttpClient>(
                                 kFakeServerEndpoint, &token_getter_,
                                 test_responder_.GetUrlLoaderFactory()),
                             &mock_registration_manager_, std::move(channel)));
}

void FtlMessagingClientTest::TearDown() {
  mock_message_reception_channel_ = nullptr;
  messaging_client_.reset();
}

TEST_F(FtlMessagingClientTest, TestSendMessage_Unauthenticated) {
  base::RunLoop run_loop;
  messaging_client_->SendMessage(
      kFakeReceiverId, kFakeSenderRegId, CreateXmppMessage(kMessage1Text),
      CheckStatusThenQuitRunLoopCallback(
          FROM_HERE, ProtobufHttpStatus::Code::UNAUTHENTICATED, &run_loop));
  test_responder_.AddErrorToMostRecentRequestUrl(ProtobufHttpStatus(
      ProtobufHttpStatus::Code::UNAUTHENTICATED, "Unauthenticated"));
  run_loop.Run();
}

TEST_F(FtlMessagingClientTest, TestSendMessage_SendOneMessageWithoutRegId) {
  base::RunLoop run_loop;
  messaging_client_->SendMessage(
      kFakeReceiverId, "", CreateXmppMessage(kMessage1Text),
      CheckStatusThenQuitRunLoopCallback(
          FROM_HERE, ProtobufHttpStatus::Code::OK, &run_loop));

  ftl::InboxSendRequest request;
  ASSERT_TRUE(test_responder_.GetMostRecentRequestMessage(&request));
  EXPECT_EQ(0, request.dest_registration_ids_size());
  EXPECT_LT(0, request.time_to_live());
  EXPECT_EQ(kFakeReceiverId, request.dest_id().id());
  EXPECT_FALSE(request.message().message_id().empty());
  EXPECT_EQ(kMessage1Text, GetChromotingMessageText(request.message()));

  test_responder_.AddResponseToMostRecentRequestUrl(ftl::InboxSendResponse());
  run_loop.Run();
}

TEST_F(FtlMessagingClientTest, TestSendMessage_SendOneMessageWithRegId) {
  base::RunLoop run_loop;
  messaging_client_->SendMessage(
      kFakeReceiverId, kFakeSenderRegId, CreateXmppMessage(kMessage1Text),
      CheckStatusThenQuitRunLoopCallback(
          FROM_HERE, ProtobufHttpStatus::Code::OK, &run_loop));

  ftl::InboxSendRequest request;
  ASSERT_TRUE(test_responder_.GetMostRecentRequestMessage(&request));
  EXPECT_EQ(1, request.dest_registration_ids_size());
  EXPECT_EQ(kFakeSenderRegId, request.dest_registration_ids(0));
  EXPECT_LT(0, request.time_to_live());
  EXPECT_EQ(kFakeReceiverId, request.dest_id().id());
  EXPECT_FALSE(request.message().message_id().empty());
  EXPECT_EQ(kMessage1Text, GetChromotingMessageText(request.message()));

  test_responder_.AddResponseToMostRecentRequestUrl(ftl::InboxSendResponse());
  run_loop.Run();
}

TEST_F(FtlMessagingClientTest, TestStartReceivingMessages_CallbacksForwarded) {
  base::RunLoop run_loop;

  EXPECT_CALL(*mock_message_reception_channel_, StartReceivingMessages(_, _))
      .WillOnce(Invoke([&](base::OnceClosure on_ready,
                           FtlMessagingClient::DoneCallback on_closed) {
        std::move(on_ready).Run();
        std::move(on_closed).Run(
            ProtobufHttpStatus(ProtobufHttpStatus::Code::UNAUTHENTICATED, ""));
      }));

  base::MockCallback<base::OnceClosure> mock_on_ready_closure;
  EXPECT_CALL(mock_on_ready_closure, Run()).WillOnce(Return());

  messaging_client_->StartReceivingMessages(
      mock_on_ready_closure.Get(),
      base::BindLambdaForTesting([&](const ProtobufHttpStatus& status) {
        ASSERT_EQ(ProtobufHttpStatus::Code::UNAUTHENTICATED,
                  status.error_code());
        run_loop.Quit();
      }));

  run_loop.Run();
}

TEST_F(FtlMessagingClientTest, TestStopReceivingMessages_CallForwarded) {
  EXPECT_CALL(*mock_message_reception_channel_, StopReceivingMessages())
      .WillOnce(Return());
  messaging_client_->StopReceivingMessages();
}

TEST_F(FtlMessagingClientTest,
       TestStreamOpener_StreamsTwoMessagesThenCloseByServer) {
  base::RunLoop run_loop;

  std::unique_ptr<ScopedProtobufHttpRequest> scoped_stream;

  ftl::ReceiveMessagesResponse response_1;
  response_1.mutable_inbox_message()->set_message_id(kMessage1Id);
  ftl::ReceiveMessagesResponse response_2;
  response_2.mutable_pong();

  base::MockCallback<base::RepeatingCallback<void(
      std::unique_ptr<ftl::ReceiveMessagesResponse>)>>
      mock_on_incoming_msg;
  EXPECT_CALL(mock_on_incoming_msg, Run(_))
      .WillOnce([&](std::unique_ptr<ftl::ReceiveMessagesResponse> response) {
        ASSERT_EQ(kMessage1Id, response->inbox_message().message_id());
      })
      .WillOnce([&](std::unique_ptr<ftl::ReceiveMessagesResponse> response) {
        ASSERT_TRUE(response->has_pong());
      });

  base::MockCallback<base::OnceClosure> on_channel_ready;
  EXPECT_CALL(on_channel_ready, Run()).Times(1);

  scoped_stream = mock_message_reception_channel_->stream_opener()->Run(
      on_channel_ready.Get(), mock_on_incoming_msg.Get(),
      CheckStatusThenQuitRunLoopCallback(
          FROM_HERE, ProtobufHttpStatus::Code::OK, &run_loop));

  test_responder_.AddStreamResponseToMostRecentRequestUrl(
      {&response_1, &response_2}, ProtobufHttpStatus::OK());

  run_loop.Run();
}

TEST_F(FtlMessagingClientTest,
       TestOnMessageReceived_MessagePassedToSubscriberAndAcked) {
  base::RunLoop run_loop;
  base::MockCallback<FtlMessagingClient::MessageCallback> mock_on_incoming_msg;
  EXPECT_CALL(mock_on_incoming_msg, Run(IsFakeSenderId(), kFakeSenderRegId,
                                        StanzaTextMatches(kMessage1Text)))
      .WillOnce([&](const ftl::Id&, const std::string&,
                    const ftl::ChromotingMessage&) { run_loop.Quit(); });

  auto subscription =
      messaging_client_->RegisterMessageCallback(mock_on_incoming_msg.Get());
  ftl::InboxMessage message = CreateInboxMessage(kMessage1Id, kMessage1Text);
  mock_message_reception_channel_->on_incoming_msg()->Run(message);

  ftl::BatchAckMessagesRequest request;
  ASSERT_TRUE(test_responder_.GetMostRecentRequestMessage(&request));
  EXPECT_EQ(1, request.message_ids_size());
  EXPECT_EQ(kMessage1Id, request.message_ids(0));
  test_responder_.AddResponseToMostRecentRequestUrl(
      ftl::BatchAckMessagesResponse());

  run_loop.Run();
}

TEST_F(FtlMessagingClientTest, ReceivedDuplicatedMessage_AckAndDrop) {
  base::RunLoop run_loop;

  base::MockCallback<FtlMessagingClient::MessageCallback> mock_on_incoming_msg;
  EXPECT_CALL(mock_on_incoming_msg, Run(IsFakeSenderId(), kFakeSenderRegId, _))
      .WillOnce([](const ftl::Id&, const std::string&,
                   const ftl::ChromotingMessage& message) {
        EXPECT_EQ(kMessage1Text, message.xmpp().stanza());
      })
      .WillOnce([](const ftl::Id&, const std::string&,
                   const ftl::ChromotingMessage& message) {
        EXPECT_EQ(kMessage2Text, message.xmpp().stanza());
      });

  EXPECT_CALL(test_responder_.GetMockInterceptor(), Run(_))
      .WillOnce([](const network::ResourceRequest& request) {
        ftl::BatchAckMessagesRequest message;
        ProtobufHttpTestResponder::ParseRequestMessage(request, &message);
        EXPECT_EQ(1, message.message_ids_size());
        EXPECT_EQ(kMessage1Id, message.message_ids(0));
      })
      .WillOnce([](const network::ResourceRequest& request) {
        ftl::BatchAckMessagesRequest message;
        ProtobufHttpTestResponder::ParseRequestMessage(request, &message);
        EXPECT_EQ(1, message.message_ids_size());
        EXPECT_EQ(kMessage1Id, message.message_ids(0));
      })
      .WillOnce([&](const network::ResourceRequest& request) {
        ftl::BatchAckMessagesRequest message;
        ProtobufHttpTestResponder::ParseRequestMessage(request, &message);
        EXPECT_EQ(1, message.message_ids_size());
        EXPECT_EQ(kMessage2Id, message.message_ids(0));
        run_loop.Quit();
      });

  auto subscription =
      messaging_client_->RegisterMessageCallback(mock_on_incoming_msg.Get());
  ftl::InboxMessage message_1 = CreateInboxMessage(kMessage1Id, kMessage1Text);
  mock_message_reception_channel_->on_incoming_msg()->Run(message_1);

  ftl::InboxMessage message_2 = CreateInboxMessage(kMessage1Id, kMessage1Text);
  mock_message_reception_channel_->on_incoming_msg()->Run(message_2);

  ftl::InboxMessage message_3 = CreateInboxMessage(kMessage2Id, kMessage2Text);
  mock_message_reception_channel_->on_incoming_msg()->Run(message_3);

  run_loop.Run();
}

}  // namespace remoting