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

#include "components/collaboration/internal/collaboration_service_impl.h"

#include <memory>

#include "base/android/device_info.h"
#include "base/test/run_until.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "components/collaboration/internal/collaboration_controller.h"
#include "components/collaboration/public/pref_names.h"
#include "components/collaboration/test_support/mock_collaboration_controller_delegate.h"
#include "components/data_sharing/public/data_sharing_service.h"
#include "components/data_sharing/public/features.h"
#include "components/data_sharing/test_support/mock_data_sharing_service.h"
#include "components/saved_tab_groups/test_support/mock_tab_group_sync_service.h"
#include "components/saved_tab_groups/test_support/saved_tab_group_test_utils.h"
#include "components/signin/public/base/signin_pref_names.h"
#include "components/signin/public/identity_manager/account_info.h"
#include "components/signin/public/identity_manager/identity_test_environment.h"
#include "components/sync/base/features.h"
#include "components/sync/test/test_sync_service.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "google_apis/gaia/gaia_id.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using data_sharing::GroupData;
using data_sharing::GroupId;
using data_sharing::GroupMember;
using data_sharing::MemberRole;
using signin::PrimaryAccountChangeEvent;
using testing::_;
using testing::Return;

namespace collaboration {

namespace {

constexpr GaiaId::Literal kUserGaia("gaia_id");
constexpr GaiaId::Literal kOtherUserGaia("other_gaia_id");
constexpr char kConsumerUserEmail[] = "test@email.com";
constexpr char kOtherConsumerUserEmail[] = "other.test@email.com";
constexpr char kManagedUserEmail[] = "test@google.com";
constexpr char kGroupId[] = "/?-group_id";
constexpr char kAccessToken[] = "/?-access_token";

}  // namespace

class CollaborationServiceImplTest : public testing::Test {
 public:
  CollaborationServiceImplTest() = default;

  ~CollaborationServiceImplTest() override = default;

  void SetUp() override {
#if BUILDFLAG(IS_ANDROID)
    if (base::android::device_info::is_automotive()) {
      // TODO(crbug.com/399444939): Re-enable once automotive is supported.
      GTEST_SKIP() << "Test shouldn't run on automotive builders.";
    }
#endif
    test_sync_service_ = std::make_unique<syncer::TestSyncService>();
    profile_pref_service_.registry()->RegisterIntegerPref(
        prefs::kSharedTabGroupsManagedAccountSetting, 0 /* enabled */);
    profile_pref_service_.registry()->RegisterBooleanPref(
        ::prefs::kSigninAllowed, true);
    profile_pref_service_.registry()->RegisterBooleanPref(
        ::prefs::kSigninAllowedOnNextStartup, true);
#if BUILDFLAG(IS_IOS)
    local_pref_service_.registry()->RegisterIntegerPref(
        ::prefs::kBrowserSigninPolicy,
        static_cast<int>(BrowserSigninMode::kEnabled));
#endif
    InitService();
  }

  void TearDown() override { service_.reset(); }

  void InitService() {
    service_ = std::make_unique<CollaborationServiceImpl>(
        &mock_tab_group_sync_service_, &mock_data_sharing_service_,
        identity_test_env_.identity_manager(), &profile_pref_service_,
        &local_pref_service_);
    service_->OnSyncServiceInitialized(test_sync_service_.get());
  }

 protected:
  base::test::SingleThreadTaskEnvironment task_environment_;
  sync_preferences::TestingPrefServiceSyncable profile_pref_service_;
  sync_preferences::TestingPrefServiceSyncable local_pref_service_;
  signin::IdentityTestEnvironment identity_test_env_;
  std::unique_ptr<syncer::TestSyncService> test_sync_service_;
  tab_groups::MockTabGroupSyncService mock_tab_group_sync_service_;
  data_sharing::MockDataSharingService mock_data_sharing_service_;
  std::unique_ptr<CollaborationServiceImpl> service_;
};

TEST_F(CollaborationServiceImplTest, ConstructionAndEmptyServiceCheck) {
  EXPECT_FALSE(service_->IsEmptyService());
}

TEST_F(CollaborationServiceImplTest, GetCurrentUserRoleForGroup) {
  GroupData group_data = GroupData();
  GroupMember group_member = GroupMember();
  group_member.gaia_id = kUserGaia;
  group_member.role = MemberRole::kOwner;
  group_data.members.push_back(group_member);

  data_sharing::GroupId group_id = data_sharing::GroupId(kGroupId);

  // Empty or non existent group should return unknown role.
  EXPECT_CALL(mock_data_sharing_service_, ReadGroup(group_id))
      .WillOnce(Return(std::nullopt));

  EXPECT_EQ(service_->GetCurrentUserRoleForGroup(group_id),
            MemberRole::kUnknown);

  // No current primary account should return unknown role.
  EXPECT_CALL(mock_data_sharing_service_, ReadGroup(group_id))
      .WillRepeatedly(Return(group_data));
  EXPECT_EQ(service_->GetCurrentUserRoleForGroup(group_id),
            MemberRole::kUnknown);

  identity_test_env_.MakeAccountAvailable(
      kConsumerUserEmail,
      {.primary_account_consent_level = signin::ConsentLevel::kSignin,
       .gaia_id = kUserGaia});
  EXPECT_EQ(service_->GetCurrentUserRoleForGroup(group_id), MemberRole::kOwner);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_Disabled) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({},
                                {data_sharing::features::kDataSharingFeature,
                                 data_sharing::features::kDataSharingJoinOnly});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kDisabled);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_JoinOnly) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({data_sharing::features::kDataSharingJoinOnly},
                                {data_sharing::features::kDataSharingFeature});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kAllowedToJoin);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_Create) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({data_sharing::features::kDataSharingFeature},
                                {data_sharing::features::kDataSharingJoinOnly});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kEnabledCreateAndJoin);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_CreateOverridesJoinOnly) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({data_sharing::features::kDataSharingJoinOnly,
                                 data_sharing::features::kDataSharingFeature},
                                {});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kEnabledCreateAndJoin);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_SigninDisabledByUser) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(
      data_sharing::features::kDataSharingFeature);

  // Set signin preference to disable signin.
  profile_pref_service_.SetBoolean(::prefs::kSigninAllowed, false);
  profile_pref_service_.SetBoolean(::prefs::kSigninAllowedOnNextStartup, false);

  InitService();

  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kSigninDisabled);
  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kEnabledCreateAndJoin);
  EXPECT_EQ(service_->GetServiceStatus().IsAllowedToJoin(), true);
  EXPECT_EQ(service_->GetServiceStatus().IsAllowedToCreate(), false);
}

#if !BUILDFLAG(IS_IOS)
TEST_F(CollaborationServiceImplTest, GetServiceStatus_SigninDisabledByPolicy) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(
      data_sharing::features::kDataSharingFeature);

#if BUILDFLAG(IS_ANDROID)
  profile_pref_service_.SetBoolean(::prefs::kSigninAllowed, false);
  profile_pref_service_.SetManagedPref(::prefs::kSigninAllowed,
                                       base::Value(false));
#else
  profile_pref_service_.SetBoolean(::prefs::kSigninAllowedOnNextStartup, false);
  profile_pref_service_.SetManagedPref(::prefs::kSigninAllowedOnNextStartup,
                                       base::Value(false));
#endif

  InitService();
  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kDisabledForPolicy);
}
#endif

TEST_F(CollaborationServiceImplTest, GetServiceStatus_ManagedAccount) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(
      data_sharing::features::kDataSharingFeature);
  InitService();
  profile_pref_service_.SetInteger(prefs::kSharedTabGroupsManagedAccountSetting,
                                   1 /* disabled */);

  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kNotSignedIn);
  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kEnabledCreateAndJoin);

  // Signin a managed account.
  identity_test_env_.MakePrimaryAccountAvailable(kManagedUserEmail,
                                                 signin::ConsentLevel::kSignin);
  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kSignedIn);
  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kDisabledForPolicy);

  // Signin a consumer account re-enable the feature.
  identity_test_env_.MakePrimaryAccountAvailable(kConsumerUserEmail,
                                                 signin::ConsentLevel::kSignin);
  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kEnabledCreateAndJoin);
}

TEST_F(CollaborationServiceImplTest, StartJoinFlow) {
  GURL url("http://www.example.com/");

  // Invalid url parsing starts a join flow with empty GroupToken.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate_invalid =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_invalid_ptr =
      mock_delegate_invalid.get();
  EXPECT_CALL(*mock_delegate_invalid, OnFlowFinished());
  service_->StartJoinFlow(std::move(mock_delegate_invalid), url);
  // Wait for post tasks.
  EXPECT_TRUE(base::test::RunUntil(
      [&]() { return service_->GetJoinControllersForTesting().size() == 1; }));
  const std::map<data_sharing::GroupToken,
                 std::unique_ptr<CollaborationController>>& join_flows =
      service_->GetJoinControllersForTesting();
  EXPECT_TRUE(join_flows.find(data_sharing::GroupToken()) != join_flows.end());

  // New join flow will be appended with a valid url parsing and will stop all
  // conflicting flows.
  url = GURL(data_sharing::features::kDataSharingURL.Get() + "?g=" + kGroupId +
             "&t=" + kAccessToken);
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  EXPECT_CALL(*mock_delegate, OnFlowFinished());

  bool invalid_cancel_called = false;
  EXPECT_CALL(*delegate_invalid_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        invalid_cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });

  service_->StartJoinFlow(std::move(mock_delegate), url);

  // Wait for post tasks.
  EXPECT_TRUE(base::test::RunUntil(
      [&]() { return service_->GetJoinControllersForTesting().size() == 1; }));

  EXPECT_TRUE(invalid_cancel_called);

  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });

  // Existing join flow will stop all conflicting flows and will be appended
  // similar to a new join flow.
  service_->StartJoinFlow(
      std::make_unique<MockCollaborationControllerDelegate>(), url);
  EXPECT_EQ(service_->GetJoinControllersForTesting().size(), 1u);
  EXPECT_TRUE(cancel_called);
}

TEST_F(CollaborationServiceImplTest, SyncStatusChanges) {
  // By default the test sync service is signed in with sync and every DataType
  // enabled.
  EXPECT_EQ(service_->GetServiceStatus().sync_status, SyncStatus::kSyncEnabled);

  // Remove user's tab group setting.
  test_sync_service_->GetUserSettings()->SetSelectedTypes(
      /*sync_everything=*/false,
      /*types=*/{});
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status,
            SyncStatus::kSyncWithoutTabGroup);

  if (base::FeatureList::IsEnabled(
          syncer::kReplaceSyncPromosWithSignInPromos)) {
    // If sync-the-feature is not required, kNotSyncing is never happening.
    test_sync_service_->SetSignedOut();
    test_sync_service_->FireStateChanged();
    EXPECT_EQ(service_->GetServiceStatus().sync_status,
              SyncStatus::kSyncWithoutTabGroup);
  } else {
    // Sign out removes sync consent.
    test_sync_service_->SetSignedOut();
    test_sync_service_->FireStateChanged();
    EXPECT_EQ(service_->GetServiceStatus().sync_status,
              SyncStatus::kNotSyncing);
  }
}

TEST_F(CollaborationServiceImplTest, SyncTypeDisabledByEnterprise) {
#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID)
  // Set up a policy to disable Tabs.
  test_sync_service_->GetUserSettings()->SetTypeIsManagedByPolicy(
      syncer::UserSelectableType::kTabs, true);
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status,
            SyncStatus::kSyncDisabledByEnterprise);

  // Reset the policy.
  test_sync_service_->GetUserSettings()->SetTypeIsManagedByPolicy(
      syncer::UserSelectableType::kTabs, false);
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status, SyncStatus::kSyncEnabled);

  // Set up a policy to disable History.
  test_sync_service_->GetUserSettings()->SetTypeIsManagedByPolicy(
      syncer::UserSelectableType::kHistory, true);
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status,
            SyncStatus::kSyncDisabledByEnterprise);
#else
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(syncer::kReplaceSyncPromosWithSignInPromos);

  // Set up a policy to disable Saved Tab Groups.
  test_sync_service_->GetUserSettings()->SetTypeIsManagedByPolicy(
      syncer::UserSelectableType::kSavedTabGroups, true);
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status,
            SyncStatus::kSyncDisabledByEnterprise);
#endif
}

TEST_F(CollaborationServiceImplTest, SyncDisabledByEnterprise) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(syncer::kReplaceSyncPromosWithSignInPromos);

  // Disable sync by enterprise policy.
  test_sync_service_->SetAllowedByEnterprisePolicy(false);
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status,
            SyncStatus::kSyncDisabledByEnterprise);
}

TEST_F(CollaborationServiceImplTest, SyncStatusChanges_SettingInProgress) {
  // By default the test sync service is signed in with sync and every DataType
  // enabled.
  EXPECT_EQ(service_->GetServiceStatus().sync_status, SyncStatus::kSyncEnabled);

  // Setup in progress does not change sync status.
  test_sync_service_->SetSetupInProgress();
  test_sync_service_->SetSignedOut();
  test_sync_service_->FireStateChanged();
  EXPECT_EQ(service_->GetServiceStatus().sync_status, SyncStatus::kSyncEnabled);
}

TEST_F(CollaborationServiceImplTest, ConsumerSigninChanges) {
  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kNotSignedIn);

  identity_test_env_.SetPrimaryAccount(kConsumerUserEmail,
                                       signin::ConsentLevel::kSignin);
  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kSignedInPaused);

  identity_test_env_.SetRefreshTokenForPrimaryAccount();
  EXPECT_EQ(service_->GetServiceStatus().signin_status,
            SigninStatus::kSignedIn);
}

TEST_F(CollaborationServiceImplTest, DeleteGroup) {
  data_sharing::GroupId group_id = data_sharing::GroupId(kGroupId);
  EXPECT_CALL(mock_tab_group_sync_service_,
              OnCollaborationRemoved(syncer::CollaborationId(kGroupId)));
  EXPECT_CALL(mock_data_sharing_service_, DeleteGroup(group_id, _))
      .WillOnce(
          [](const data_sharing::GroupId&,
             base::OnceCallback<void(
                 data_sharing::DataSharingService::PeopleGroupActionOutcome)>
                 callback) {
            std::move(callback).Run(data_sharing::DataSharingService::
                                        PeopleGroupActionOutcome::kSuccess);
          });

  base::RunLoop run_loop;
  service_->DeleteGroup(group_id,
                        base::BindOnce(
                            [](base::RunLoop* run_loop, bool success) {
                              ASSERT_TRUE(success);
                              run_loop->Quit();
                            },
                            &run_loop));
  run_loop.Run();
}

TEST_F(CollaborationServiceImplTest, LeaveGroup) {
  data_sharing::GroupId group_id = data_sharing::GroupId(kGroupId);
  EXPECT_CALL(mock_tab_group_sync_service_,
              OnCollaborationRemoved(syncer::CollaborationId(kGroupId)));
  EXPECT_CALL(mock_data_sharing_service_, LeaveGroup(group_id, _))
      .WillOnce(
          [](const data_sharing::GroupId&,
             base::OnceCallback<void(
                 data_sharing::DataSharingService::PeopleGroupActionOutcome)>
                 callback) {
            std::move(callback).Run(data_sharing::DataSharingService::
                                        PeopleGroupActionOutcome::kSuccess);
          });

  base::RunLoop run_loop;
  service_->LeaveGroup(group_id, base::BindOnce(
                                     [](base::RunLoop* run_loop, bool success) {
                                       ASSERT_TRUE(success);
                                       run_loop->Quit();
                                     },
                                     &run_loop));
  run_loop.Run();
}

TEST_F(CollaborationServiceImplTest, CancelAllFlows) {
  GURL url = GURL(data_sharing::features::kDataSharingURL.Get() +
                  "?g=" + kGroupId + "&t=" + kAccessToken);

  // New join flow will be appended with a valid url parsing and will stop all
  // conflicting flows.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  EXPECT_CALL(*mock_delegate, OnFlowFinished());
  service_->StartJoinFlow(std::move(mock_delegate), url);

  // Wait for post tasks.
  EXPECT_TRUE(base::test::RunUntil(
      [&]() { return service_->GetJoinControllersForTesting().size() == 1; }));

  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });
  service_->CancelAllFlows();

  EXPECT_TRUE(cancel_called);

  // Wait for post tasks.
  EXPECT_TRUE(service_->GetJoinControllersForTesting().size() == 0);
  EXPECT_TRUE(service_->GetDeletingControllersCountForTesting() == 1);
  EXPECT_TRUE(base::test::RunUntil([&]() {
    return service_->GetDeletingControllersCountForTesting() == 0;
  }));
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_NoChange_DoesntCancelJoin) {
  // Start a join flow.
  GURL url = GURL(data_sharing::features::kDataSharingURL.Get() +
                  "?g=" + kGroupId + "&t=" + kAccessToken);
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartJoinFlow(std::move(mock_delegate), url);
  EXPECT_CALL(*delegate_ptr, Cancel(_)).Times(0);
  // Prepare a kNoChange event.
  PrimaryAccountChangeEvent::State state;
  PrimaryAccountChangeEvent event_details(
      state, state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_NoChange_DoesntCancelShare) {
  // Start a share flow.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartShareOrManageFlow(
      std::move(mock_delegate), tab_groups::test::GenerateRandomTabGroupID(),
      CollaborationServiceShareOrManageEntryPoint::kUnknown);
  EXPECT_CALL(*delegate_ptr, Cancel(_)).Times(0);
  // Prepare a kNoChange event.
  PrimaryAccountChangeEvent::State state;
  PrimaryAccountChangeEvent event_details(
      state, state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_SigningInFromUnsignedIn_DoesntCancelJoin) {
  // Start a join flow.
  GURL url = GURL(data_sharing::features::kDataSharingURL.Get() +
                  "?g=" + kGroupId + "&t=" + kAccessToken);
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartJoinFlow(std::move(mock_delegate), url);
  EXPECT_CALL(*delegate_ptr, Cancel(_)).Times(0);
  // Prepare a kSet event from unsigned in to signed in.
  PrimaryAccountChangeEvent::State previous_state;
  CoreAccountInfo account_info;
  account_info.gaia = kUserGaia;
  account_info.account_id = CoreAccountId::FromGaiaId(account_info.gaia);
  account_info.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State current_state(account_info,
                                                 signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_SigningInFromUnsignedIn_DoesntCancelShare) {
  // Start a share flow.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartShareOrManageFlow(
      std::move(mock_delegate), tab_groups::test::GenerateRandomTabGroupID(),
      CollaborationServiceShareOrManageEntryPoint::kUnknown);
  EXPECT_CALL(*delegate_ptr, Cancel(_)).Times(0);
  // Prepare a kSet event from unsigned in to signed in.
  PrimaryAccountChangeEvent::State previous_state;
  CoreAccountInfo account_info;
  account_info.gaia = kUserGaia;
  account_info.account_id = CoreAccountId::FromGaiaId(account_info.gaia);
  account_info.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State current_state(account_info,
                                                 signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_SwitchingAccount_CancelsJoin) {
  // Start a join flow.
  GURL url = GURL(data_sharing::features::kDataSharingURL.Get() +
                  "?g=" + kGroupId + "&t=" + kAccessToken);
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartJoinFlow(std::move(mock_delegate), url);
  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });
  // Prepare a kSet event, switching accounts.
  CoreAccountInfo account_info_1;
  account_info_1.gaia = kUserGaia;
  account_info_1.account_id = CoreAccountId::FromGaiaId(account_info_1.gaia);
  account_info_1.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State previous_state(
      account_info_1, signin::ConsentLevel::kSignin);
  CoreAccountInfo account_info_2;
  account_info_2.gaia = kOtherUserGaia;
  account_info_2.account_id = CoreAccountId::FromGaiaId(account_info_2.gaia);
  account_info_2.email = kOtherConsumerUserEmail;
  PrimaryAccountChangeEvent::State current_state(account_info_2,
                                                 signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);

  EXPECT_TRUE(cancel_called);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_SwitchingAccount_CancelsShare) {
  // Start a share flow.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartShareOrManageFlow(
      std::move(mock_delegate), tab_groups::test::GenerateRandomTabGroupID(),
      CollaborationServiceShareOrManageEntryPoint::kUnknown);
  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });
  // Prepare a kSet event, switching accounts.
  CoreAccountInfo account_info_1;
  account_info_1.gaia = kUserGaia;
  account_info_1.account_id = CoreAccountId::FromGaiaId(account_info_1.gaia);
  account_info_1.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State previous_state(
      account_info_1, signin::ConsentLevel::kSignin);
  CoreAccountInfo account_info_2;
  account_info_2.gaia = kOtherUserGaia;
  account_info_2.account_id = CoreAccountId::FromGaiaId(account_info_2.gaia);
  account_info_2.email = kOtherConsumerUserEmail;
  PrimaryAccountChangeEvent::State current_state(account_info_2,
                                                 signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::AccessPoint::kUnknown);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);

  EXPECT_TRUE(cancel_called);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_Cleared_CancelsJoin) {
  // Start a join flow.
  GURL url = GURL(data_sharing::features::kDataSharingURL.Get() +
                  "?g=" + kGroupId + "&t=" + kAccessToken);
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartJoinFlow(std::move(mock_delegate), url);
  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });
  // Prepare a kCleared event.
  CoreAccountInfo account_info;
  account_info.gaia = kUserGaia;
  account_info.account_id = CoreAccountId::FromGaiaId(account_info.gaia);
  account_info.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State previous_state(
      account_info, signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent::State current_state;
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::ProfileSignout::kTest);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);

  EXPECT_TRUE(cancel_called);
}

TEST_F(CollaborationServiceImplTest,
       OnPrimaryAccountChanged_Cleared_CancelsShare) {
  // Start a share flow.
  std::unique_ptr<MockCollaborationControllerDelegate> mock_delegate =
      std::make_unique<MockCollaborationControllerDelegate>();
  MockCollaborationControllerDelegate* delegate_ptr = mock_delegate.get();
  service_->StartShareOrManageFlow(
      std::move(mock_delegate), tab_groups::test::GenerateRandomTabGroupID(),
      CollaborationServiceShareOrManageEntryPoint::kUnknown);
  bool cancel_called = false;
  EXPECT_CALL(*delegate_ptr, Cancel(_))
      .WillOnce([&](CollaborationControllerDelegate::ResultCallback result) {
        cancel_called = true;
        std::move(result).Run(
            CollaborationControllerDelegate::Outcome::kSuccess);
        return true;
      });
  // Prepare a kCleared event.
  CoreAccountInfo account_info;
  account_info.gaia = kUserGaia;
  account_info.account_id = CoreAccountId::FromGaiaId(account_info.gaia);
  account_info.email = kConsumerUserEmail;
  PrimaryAccountChangeEvent::State previous_state(
      account_info, signin::ConsentLevel::kSignin);
  PrimaryAccountChangeEvent::State current_state;
  PrimaryAccountChangeEvent event_details(
      previous_state, current_state, signin_metrics::ProfileSignout::kTest);

  // Process the event.
  service_->OnPrimaryAccountChanged(event_details);

  EXPECT_TRUE(cancel_called);
}

TEST_F(CollaborationServiceImplTest,
       GetServiceStatus_VersionOutOfDateShowUpdateChromeUi) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures(
      {data_sharing::features::kDataSharingFeature,
       data_sharing::features::kDataSharingEnableUpdateChromeUI,
       data_sharing::features::kSharedDataTypesKillSwitch},
      {data_sharing::features::kDataSharingJoinOnly});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kVersionOutOfDateShowUpdateChromeUi);
}

TEST_F(CollaborationServiceImplTest, GetServiceStatus_VersionOutOfDate) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures(
      {
          data_sharing::features::kDataSharingJoinOnly,
          data_sharing::features::kSharedDataTypesKillSwitch,
      },
      {data_sharing::features::kDataSharingFeature,
       data_sharing::features::kDataSharingEnableUpdateChromeUI});
  InitService();

  EXPECT_EQ(service_->GetServiceStatus().collaboration_status,
            CollaborationStatus::kVersionOutOfDate);
}

}  // namespace collaboration