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

#include "chromeos/ash/components/phonehub/notification_processor.h"
#include <string>

#include "ash/constants/ash_features.h"
#include "base/memory/ptr_util.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "chromeos/ash/components/phonehub/fake_notification_manager.h"
#include "chromeos/ash/components/phonehub/phone_model_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/image/image_unittest_util.h"

namespace ash::phonehub {

namespace {

constexpr int64_t kNotificationIdA = 1;
constexpr int64_t kNotificationIdB = 2;
constexpr int64_t kNotificationIdC = 3;

constexpr int64_t kInlineReplyIdA = 3;
constexpr int64_t kInlineReplyIdB = 4;

constexpr int64_t kOpenableActionId = -2;
constexpr int64_t kAnswerActionId = 1;
constexpr int64_t kDeclineActionId = 2;
constexpr int64_t kHangupActionId = 3;

const char kIconDataA[] = "icon_a";
const char kIconDataB[] = "icon_b";

const char kSharedImageA[] = "shared_image_a";
const char kSharedImageB[] = "shared_image_b";

const char kContactImageA[] = "contact_image_a";
const char kContactImageB[] = "contact_image_b";

// Garbage color for the purpose of verification in these tests.
const SkColor kIconColor = SkColorSetRGB(0x12, 0x34, 0x56);

SkBitmap TestBitmap() {
  SkBitmap bitmap;
  bitmap.allocN32Pixels(1, 1);
  return bitmap;
}

gfx::Image TestImage() {
  gfx::ImageSkia image_skia = gfx::ImageSkia::CreateFrom1xBitmap(TestBitmap());
  image_skia.MakeThreadSafe();
  return gfx::Image(image_skia);
}

}  // namespace

class NotificationProcessorTest : public testing::Test {
 public:
  friend class NotificationProcessor;

  NotificationProcessorTest() {
    scoped_feature_list_.InitWithFeatures(
        /*enabled_features=*/{features::kEcheSWA,
                              features::kPhoneHubCallNotification},
        /*disabled_features=*/{});
  }
  NotificationProcessorTest(const NotificationProcessorTest&) = delete;
  NotificationProcessorTest& operator=(const NotificationProcessorTest&) =
      delete;
  ~NotificationProcessorTest() override = default;

  class FakeImageDecoderDelegate
      : public NotificationProcessor::ImageDecoderDelegate {
   public:
    using DecodeImageCallback = NotificationProcessor::DecodeImageCallback;

    FakeImageDecoderDelegate() = default;
    ~FakeImageDecoderDelegate() override = default;

    void PerformImageDecode(
        const std::string& data,
        DecodeImageCallback single_image_decoded_closure) override {
      decode_image_callbacks_.push(std::move(single_image_decoded_closure));
    }

    size_t NumberOfDecodeImageCallbacks() {
      return decode_image_callbacks_.size();
    }

    void RunNextCallback(SkBitmap bitmap) {
      std::move(decode_image_callbacks_.front()).Run(bitmap);
      decode_image_callbacks_.pop();
    }

    void RunAllCallbacks() {
      while (!decode_image_callbacks_.empty())
        RunNextCallback(TestBitmap());
    }

    void RunAllCallbacksWithEmpty() {
      while (!decode_image_callbacks_.empty())
        RunNextCallback(SkBitmap());
    }

    std::queue<DecodeImageCallback> decode_image_callbacks_;
  };

  // testing::Test:
  void SetUp() override {
    fake_notification_manager_ = std::make_unique<FakeNotificationManager>();

    notification_processor_ = base::WrapUnique(new NotificationProcessor(
        fake_notification_manager_.get(),
        std::make_unique<FakeImageDecoderDelegate>()));
  }

  FakeImageDecoderDelegate* image_decoder_delegate() {
    return static_cast<FakeImageDecoderDelegate*>(
        notification_processor_->delegate_.get());
  }

  NotificationProcessor* notification_processor() {
    return notification_processor_.get();
  }

  FakeNotificationManager* fake_notification_manager() {
    return fake_notification_manager_.get();
  }

  size_t NumPendingRequests() {
    return notification_processor()->pending_notification_requests_.size();
  }

  proto::Notification CreateNewInlineReplyableOpenableNotification(
      int64_t notification_id,
      int64_t inline_reply_id,
      Notification::InteractionBehavior behavior) {
    return CreateNewInlineReplyableNotification(
        notification_id, inline_reply_id,
        /* icon= */ std::string(),
        /* shared_image= */ std::string(),
        /* contact_image= */ std::string(), behavior);
  }

  proto::Notification CreateNewInlineReplyableNotification(
      int64_t notification_id,
      int64_t inline_reply_id,
      std::string icon = std::string(),
      std::string shared_image = std::string(),
      std::string contact_image = std::string(),
      Notification::InteractionBehavior behavior =
          Notification::InteractionBehavior::kNone,
      proto::AppStreamabilityStatus app_streamability_status =
          proto::AppStreamabilityStatus::STREAMABLE) {
    auto origin_app = std::make_unique<proto::App>();
    origin_app->set_icon(icon);
    origin_app->set_app_streamability_status(app_streamability_status);

    proto::Notification notification;
    notification.set_id(notification_id);
    notification.set_allocated_origin_app(origin_app.release());
    notification.set_contact_image(contact_image);
    notification.set_shared_image(shared_image);
    notification.set_category(
        proto::Notification::Category::Notification_Category_CONVERSATION);

    notification.add_actions();
    proto::Action* mutable_action = notification.mutable_actions(0);
    mutable_action->set_id(inline_reply_id);
    mutable_action->set_type(proto::Action_InputType::Action_InputType_TEXT);

    if (behavior == Notification::InteractionBehavior::kOpenable) {
      notification.add_actions();
      proto::Action* open_action = notification.mutable_actions(1);
      open_action->set_id(kOpenableActionId);
      open_action->set_type(proto::Action_InputType::Action_InputType_OPEN);
    }
    return notification;
  }

  proto::Notification CreateNewInlineReplyableMonochromeIconNotification(
      int64_t notification_id,
      int64_t inline_reply_id,
      std::optional<SkColor> icon_color = std::nullopt,
      std::string icon = std::string()) {
    proto::Notification notification = CreateNewInlineReplyableNotification(
        notification_id, inline_reply_id, icon);
    proto::App* origin_app = notification.mutable_origin_app();
    origin_app->set_monochrome_icon_mask(icon);
    if (icon_color != std::nullopt) {
      auto color_rgb = std::make_unique<proto::ColorRgb>();
      color_rgb->set_red(SkColorGetR(*icon_color));
      color_rgb->set_green(SkColorGetG(*icon_color));
      color_rgb->set_blue(SkColorGetB(*icon_color));
      origin_app->set_allocated_monochrome_icon_color(color_rgb.release());
    }
    return notification;
  }

  proto::Notification CreateNonTextTypeNotification(
      int64_t notification_id,
      int64_t inline_reply_id,
      std::string icon = std::string()) {
    auto origin_app = std::make_unique<proto::App>();
    origin_app->set_icon(icon);

    proto::Notification notification;
    notification.set_id(notification_id);
    notification.set_allocated_origin_app(origin_app.release());

    notification.add_actions();
    proto::Action* open_action = notification.mutable_actions(0);
    open_action->set_id(kOpenableActionId);
    open_action->set_type(proto::Action_InputType::Action_InputType_OPEN);

    return notification;
  }

  proto::Notification CreateIncomingCallNotification(int64_t notification_id) {
    auto origin_app = std::make_unique<proto::App>();
    origin_app->set_icon(std::string());

    proto::Notification notification;
    notification.set_id(notification_id);
    notification.set_allocated_origin_app(origin_app.release());
    notification.set_contact_image(std::string());
    notification.set_shared_image(std::string());
    notification.set_category(
        proto::Notification::Category::Notification_Category_INCOMING_CALL);

    notification.add_actions();
    proto::Action* answer_action = notification.mutable_actions(0);
    answer_action->set_id(kAnswerActionId);
    answer_action->set_call_action(
        proto::Action_CallAction::Action_CallAction_ANSWER);

    notification.add_actions();
    proto::Action* decline_action = notification.mutable_actions(1);
    decline_action->set_id(kDeclineActionId);
    decline_action->set_call_action(
        proto::Action_CallAction::Action_CallAction_DECLINE);

    return notification;
  }

  proto::Notification CreateOngoingCallNotification(int64_t notification_id) {
    auto origin_app = std::make_unique<proto::App>();
    origin_app->set_icon(std::string());

    proto::Notification notification;
    notification.set_id(notification_id);
    notification.set_allocated_origin_app(origin_app.release());
    notification.set_contact_image(std::string());
    notification.set_shared_image(std::string());
    notification.set_category(
        proto::Notification::Category::Notification_Category_ONGOING_CALL);

    notification.add_actions();
    proto::Action* hangup_action = notification.mutable_actions(0);
    hangup_action->set_id(kHangupActionId);
    hangup_action->set_call_action(
        proto::Action_CallAction::Action_CallAction_HANGUP);

    notification.add_actions();
    proto::Action* open_action = notification.mutable_actions(1);
    open_action->set_id(kOpenableActionId);
    open_action->set_type(proto::Action_InputType::Action_InputType_OPEN);

    return notification;
  }

 private:
  std::unique_ptr<FakeNotificationManager> fake_notification_manager_;
  std::unique_ptr<NotificationProcessor> notification_processor_;

  base::test::ScopedFeatureList scoped_feature_list_;
  base::test::SingleThreadTaskEnvironment task_environment_;
};

TEST_F(NotificationProcessorTest, FailedToDecodeImage) {
  std::vector<proto::Notification> first_set_of_notifications;

  // The icon should be an empty image as the decoder failed to decode the
  // image to be used as both the color_icon and monochrome_icon_mask.
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunNextCallback(SkBitmap());
  image_decoder_delegate()->RunNextCallback(SkBitmap());

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(notification->app_metadata().color_icon.IsEmpty());
  EXPECT_TRUE(notification->app_metadata().monochrome_icon_mask.has_value());
  EXPECT_FALSE(notification->shared_image().has_value());
  EXPECT_FALSE(notification->contact_image().has_value());
}

TEST_F(NotificationProcessorTest, ShouldSkipDecodeImageIfNotAvailable) {
  std::vector<proto::Notification> first_set_of_notifications;

  first_set_of_notifications.emplace_back(CreateNonTextTypeNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);

  EXPECT_EQ(0u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());
  image_decoder_delegate()->RunAllCallbacks();

  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());
}

TEST_F(NotificationProcessorTest, MonochromeIconFieldsPopulatedCorrectly) {
  std::vector<proto::Notification> first_set_of_notifications;

  // Legacy notifications don't supply color and should not be filled in.
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_FALSE(notification->app_metadata().icon_color.has_value());

  // Monochrome notifications without a color should not have icon_color filled.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableMonochromeIconNotification(
          kNotificationIdA, kInlineReplyIdA, std::nullopt, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(notification->app_metadata().icon_is_monochrome);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_FALSE(notification->app_metadata().icon_color.has_value());

  // Monochrome notifications with a color should have icon_color filled.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableMonochromeIconNotification(
          kNotificationIdA, kInlineReplyIdA, kIconColor, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(notification->app_metadata().icon_is_monochrome);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_TRUE(notification->app_metadata().icon_color.has_value());
  EXPECT_TRUE(*notification->app_metadata().icon_color == kIconColor);

  // Monochrome notifications without an icon should not fill in color.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableMonochromeIconNotification(
          kNotificationIdA, kInlineReplyIdA, kIconColor,
          /*icon=*/std::string()));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacksWithEmpty();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(notification->app_metadata().icon_is_monochrome);
  EXPECT_TRUE(notification->app_metadata().color_icon.IsEmpty());
  EXPECT_FALSE(notification->app_metadata().icon_color.has_value());
}

TEST_F(NotificationProcessorTest, ImageFieldPopulatedCorrectly) {
  std::vector<proto::Notification> first_set_of_notifications;

  // The icon should be populated. The shared and contact image should be null.
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_FALSE(notification->shared_image().has_value());
  EXPECT_FALSE(notification->contact_image().has_value());

  // The icon and shared image should be populated. The contact image should be
  // null.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, kSharedImageA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_TRUE(
      gfx::test::AreImagesEqual(*notification->shared_image(), TestImage()));
  EXPECT_FALSE(notification->contact_image().has_value());

  // The icon and contact image should be populated. The shared image should be
  // null.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, std::string(),
      kContactImageA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_FALSE(notification->shared_image().has_value());
  EXPECT_TRUE(
      gfx::test::AreImagesEqual(*notification->contact_image(), TestImage()));

  // All images should be should be populated.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, kSharedImageA,
      kContactImageA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();
  EXPECT_TRUE(gfx::test::AreImagesEqual(notification->app_metadata().color_icon,
                                        TestImage()));
  EXPECT_TRUE(
      gfx::test::AreImagesEqual(*notification->shared_image(), TestImage()));
  EXPECT_TRUE(
      gfx::test::AreImagesEqual(*notification->contact_image(), TestImage()));
}

TEST_F(NotificationProcessorTest, StreamabilityStatus) {
  std::vector<proto::Notification> first_set_of_notifications;

  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, std::string(),
      std::string(), Notification::InteractionBehavior::kNone,
      proto::AppStreamabilityStatus::BLOCK_LISTED));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(proto::AppStreamabilityStatus::BLOCK_LISTED,
            notification->app_metadata().app_streamability_status);
}

TEST_F(NotificationProcessorTest, AddRemoveClearWithoutRace) {
  // Add 2 notifications with all images populated.
  std::vector<proto::Notification> first_set_of_notifications;
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, kSharedImageA,
      kContactImageA));
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdB, kInlineReplyIdB, kIconDataB, kSharedImageB,
      kContactImageB));

  notification_processor()->AddNotifications(first_set_of_notifications);

  // 8 image decode callbacks will occur for kIconDataA, data for icons twice
  // for each notification, kSharedImageA, kContactImageA, kIconDataB,
  // kSharedImageB, and kContactImageB.
  EXPECT_EQ(8u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());
  image_decoder_delegate()->RunAllCallbacks();

  EXPECT_EQ(2u, fake_notification_manager()->num_notifications());
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdA));
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdB));

  // Remove notification with id kNotificationIdA.
  base::flat_set<int64_t> ids_of_notifications_to_remove;
  ids_of_notifications_to_remove.emplace(kNotificationIdA);
  notification_processor()->RemoveNotifications(ids_of_notifications_to_remove);
  EXPECT_EQ(1u, fake_notification_manager()->num_notifications());
  EXPECT_FALSE(fake_notification_manager()->GetNotification(kNotificationIdA));
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdB));

  // Clear all notifications.
  notification_processor()->ClearNotificationsAndPendingUpdates();
  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());
}

TEST_F(NotificationProcessorTest, AddRemoveWithRace) {
  // Add 2 notifications.
  std::vector<proto::Notification> first_set_of_notifications;
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, kSharedImageA));
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdB, kInlineReplyIdB, kIconDataB));

  notification_processor()->AddNotifications(first_set_of_notifications);

  // One pending requests because |first_set_of_notifications| processing
  // occurred immediately.
  EXPECT_EQ(1u, NumPendingRequests());

  // Remove notification with id kNotificationIdA while
  // |first_set_of_notifications| is still being processed.
  base::flat_set<int64_t> ids_of_notifications_to_remove;
  ids_of_notifications_to_remove.emplace(kNotificationIdA);
  notification_processor()->RemoveNotifications(ids_of_notifications_to_remove);

  // Pending delete request, first in the queue.
  EXPECT_EQ(2u, NumPendingRequests());
  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());

  // Add a set of notifications such that only one image needs to be decoded,
  // when neither the first set has completed processing more the remove request
  // has been fully processed.
  std::vector<proto::Notification> second_set_of_notifications;
  second_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA));
  notification_processor()->AddNotifications(second_set_of_notifications);

  // Pending add request, second in the queue.
  EXPECT_EQ(3u, NumPendingRequests());
  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());

  // 5 image decode callbacks will occur (two icons, two monochrome icons, and a
  // shared image). When the last image decode callback is finished running,
  // which in this case is original icon2, it will cause the next notification
  // edit request to be executed.
  EXPECT_EQ(5u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());
  EXPECT_EQ(3u, NumPendingRequests());
  image_decoder_delegate()->RunNextCallback(TestBitmap());

  EXPECT_EQ(4u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());
  EXPECT_EQ(3u, NumPendingRequests());
  image_decoder_delegate()->RunNextCallback(TestBitmap());

  EXPECT_EQ(3u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());
  EXPECT_EQ(3u, NumPendingRequests());

  // The scheduled remove callback will occur, then subsequently the add
  // notification with 1 image.
  image_decoder_delegate()->RunNextCallback(TestBitmap());
  image_decoder_delegate()->RunNextCallback(TestBitmap());
  image_decoder_delegate()->RunNextCallback(TestBitmap());
  EXPECT_EQ(1u, NumPendingRequests());
  EXPECT_EQ(2u, image_decoder_delegate()->NumberOfDecodeImageCallbacks());

  EXPECT_EQ(1u, fake_notification_manager()->num_notifications());
  EXPECT_FALSE(fake_notification_manager()->GetNotification(kNotificationIdA));
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdB));

  // 1 image decode callback will occur.
  image_decoder_delegate()->RunAllCallbacks();
  EXPECT_EQ(0u, NumPendingRequests());
  EXPECT_EQ(2u, fake_notification_manager()->num_notifications());
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdA));
  EXPECT_TRUE(fake_notification_manager()->GetNotification(kNotificationIdB));
}

TEST_F(NotificationProcessorTest, AddClearAllWithRace) {
  std::vector<proto::Notification> first_set_of_notifications;
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdA, kInlineReplyIdA, kIconDataA, kSharedImageA));
  first_set_of_notifications.emplace_back(CreateNewInlineReplyableNotification(
      kNotificationIdB, kInlineReplyIdB, kIconDataA));

  notification_processor()->AddNotifications(first_set_of_notifications);

  // Clearing Notifications will invalidate all callbacks in process and
  // immediately clear all pointers.
  notification_processor()->ClearNotificationsAndPendingUpdates();
  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());
  image_decoder_delegate()->RunAllCallbacks();
  EXPECT_EQ(0u, NumPendingRequests());
  EXPECT_EQ(0u, fake_notification_manager()->num_notifications());
  EXPECT_FALSE(fake_notification_manager()->GetNotification(kNotificationIdA));
  EXPECT_FALSE(fake_notification_manager()->GetNotification(kNotificationIdB));
}

TEST_F(NotificationProcessorTest, InteractionBehaviorPopulatedCorrectly) {
  std::vector<proto::Notification> first_set_of_notifications;

  // The notification should be openable if a OPEN action is specified.
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableOpenableNotification(
          kNotificationIdA, kInlineReplyIdA,
          Notification::InteractionBehavior::kOpenable));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(Notification::InteractionBehavior::kOpenable,
            notification->interaction_behavior());
  EXPECT_EQ(Notification::Category::kConversation, notification->category());

  // The notification should not specify interaction behaviors if none are
  // available.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableNotification(kNotificationIdA, kInlineReplyIdA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(Notification::InteractionBehavior::kNone,
            notification->interaction_behavior());
  EXPECT_EQ(Notification::Category::kConversation, notification->category());

  // The notification has IncomingCall category if answer action is
  // found.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateIncomingCallNotification(kNotificationIdA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(Notification::Category::kIncomingCall, notification->category());

  // The notification has OngoingCall category if hangup action is
  // found.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateOngoingCallNotification(kNotificationIdC));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdC);
  EXPECT_EQ(Notification::Category::kOngoingCall, notification->category());
}

TEST_F(NotificationProcessorTest, ActionIdMapPopulatedCorrectly) {
  std::vector<proto::Notification> first_set_of_notifications;

  // The inline reply notification should have reply action id.
  first_set_of_notifications.emplace_back(
      CreateNewInlineReplyableNotification(kNotificationIdA, kInlineReplyIdA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  const Notification* notification =
      fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(1u, notification->action_id_map().size());
  EXPECT_EQ(kInlineReplyIdA, notification->action_id_map().at(
                                 Notification::ActionType::kInlineReply));

  // The incoming call notification should have answer and decline action ids.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateIncomingCallNotification(kNotificationIdA));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdA);
  EXPECT_EQ(2u, notification->action_id_map().size());
  EXPECT_EQ(kAnswerActionId, notification->action_id_map().at(
                                 Notification::ActionType::kAnswer));
  EXPECT_EQ(kDeclineActionId, notification->action_id_map().at(
                                  Notification::ActionType::kDecline));

  // The ongoing call notification should have hangup action id.
  first_set_of_notifications.clear();
  first_set_of_notifications.emplace_back(
      CreateOngoingCallNotification(kNotificationIdC));
  notification_processor()->AddNotifications(first_set_of_notifications);
  image_decoder_delegate()->RunAllCallbacks();

  notification = fake_notification_manager()->GetNotification(kNotificationIdC);
  EXPECT_EQ(1u, notification->action_id_map().size());
  EXPECT_EQ(kHangupActionId, notification->action_id_map().at(
                                 Notification::ActionType::kHangup));
}

}  // namespace ash::phonehub