Move login event validation to reporting_test_utils

Bug: 390419758
Change-Id: Icaf0c7bda27f125d80612a8f542487b180ceea6b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6304446
Reviewed-by: Dominique Fauteux-Chapleau <domfc@chromium.org>
Commit-Queue: Nancy Xiao <nancylanxiao@google.com>
Cr-Commit-Position: refs/heads/main@{#1425347}

chrome/browser/enterprise/connectors/test/deep_scanning_test_utils.cc

@@ -461,32 +461,6 @@ void EventReportValidator::ExpectDangerousDownloadEvent(
           });
 }
 
-void EventReportValidator::ExpectLoginEvent(
-    const std::string& expected_url,
-    const bool expected_is_federated,
-    const std::string& expected_federated_origin,
-    const std::string& expected_profile_username,
-    const std::string& expected_profile_identifier,
-    const std::u16string& expected_login_username) {
-  event_key_ = enterprise_connectors::kKeyLoginEvent;
-  url_ = expected_url;
-  is_federated_ = expected_is_federated;
-  federated_origin_ = expected_federated_origin;
-  username_ = expected_profile_username;
-  profile_identifier_ = expected_profile_identifier;
-  login_user_name_ = expected_login_username;
-  EXPECT_CALL(*client_, UploadSecurityEventReport)
-      .WillOnce(
-          [this](bool include_device_info, base::Value::Dict report,
-                 base::OnceCallback<void(policy::CloudPolicyClient::Result)>
-                     callback) {
-            ValidateReport(&report);
-            if (!done_closure_.is_null()) {
-              done_closure_.Run();
-            }
-          });
-}
-
 void EventReportValidator::ExpectPasswordBreachEvent(
     const std::string& expected_trigger,
     const std::vector<std::pair<std::string, std::u16string>>&
@@ -746,10 +720,6 @@ void EventReportValidator::ValidateDataMaskingAttributes(
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
-void EventReportValidator::ExpectNoReport() {
-  EXPECT_CALL(*client_, UploadSecurityEventReport).Times(0);
-}
-
 void EventReportValidator::SetDoneClosure(base::RepeatingClosure closure) {
   done_closure_ = std::move(closure);
 }

chrome/browser/enterprise/connectors/test/deep_scanning_test_utils.h

@@ -197,13 +197,6 @@ class EventReportValidator : public EventReportValidatorBase {
       const std::string& expected_profile_username,
       const std::string& expected_profile_identifier);
 
-  void ExpectLoginEvent(const std::string& expected_url,
-                        bool expected_is_federated,
-                        const std::string& expected_federated_origin,
-                        const std::string& expected_profile_username,
-                        const std::string& expected_profile_identifier,
-                        const std::u16string& expected_login_username);
-
   void ExpectPasswordBreachEvent(
       const std::string& expected_trigger,
       const std::vector<std::pair<std::string, std::u16string>>&
@@ -211,8 +204,6 @@ class EventReportValidator : public EventReportValidatorBase {
       const std::string& expected_profile_username,
       const std::string& expected_profile_identifier);
 
-  void ExpectNoReport();
-
   // Closure to run once all expected events are validated.
   void SetDoneClosure(base::RepeatingClosure closure);
 

components/enterprise/connectors/core/reporting_test_utils.cc

@@ -46,6 +46,10 @@ constexpr char kKeyTriggeredRuleId[] = "ruleId";
 constexpr char kKeyUrlCategory[] = "urlCategory";
 constexpr char kKeyAction[] = "action";
 constexpr char kKeyHasWatermarking[] = "hasWatermarking";
+constexpr char kKeyIsFederated[] = "isFederated";
+constexpr char kKeyFederatedOrigin[] = "federatedOrigin";
+const char kKeyProfileUserName[] = "profileUserName";
+constexpr char kKeyLoginUserName[] = "loginUserName";
 
 }  // namespace
 
@@ -93,6 +97,10 @@ EventReportValidatorBase::~EventReportValidatorBase() {
   testing::Mock::VerifyAndClearExpectations(client_);
 }
 
+void EventReportValidatorBase::ExpectNoReport() {
+  EXPECT_CALL(*client_, UploadSecurityEventReport).Times(0);
+}
+
 void EventReportValidatorBase::ExpectURLFilteringInterstitialEvent(
     chrome::cros::reporting::proto::UrlFilteringInterstitialEvent
         expected_urlf_event) {
@@ -137,6 +145,48 @@ void EventReportValidatorBase::ExpectURLFilteringInterstitialEvent(
       });
 }
 
+void EventReportValidatorBase::ExpectLoginEvent(
+    const std::string& expected_url,
+    const bool expected_is_federated,
+    const std::string& expected_federated_origin,
+    const std::string& expected_profile_username,
+    const std::string& expected_profile_identifier,
+    const std::u16string& expected_login_username) {
+  EXPECT_CALL(*client_, UploadSecurityEventReport)
+      .WillOnce([this, expected_url, expected_is_federated,
+                 expected_federated_origin, expected_profile_username,
+                 expected_profile_identifier, expected_login_username](
+                    bool include_device_info, base::Value::Dict report,
+                    base::OnceCallback<void(policy::CloudPolicyClient::Result)>
+                        callback) {
+        // Extract the event list.
+        const base::Value::List* event_list = report.FindList(
+            policy::RealtimeReportingJobConfiguration::kEventListKey);
+        ASSERT_TRUE(event_list);
+
+        // There should only be 1 event per test.
+        ASSERT_EQ(1u, event_list->size());
+        const base::Value::Dict& wrapper = (*event_list)[0].GetDict();
+        const base::Value::Dict* event =
+            wrapper.FindDict(enterprise_connectors::kKeyLoginEvent);
+        ASSERT_TRUE(event);
+
+        ValidateField(event, kKeyURL, expected_url);
+        ValidateField(event, kKeyIsFederated, expected_is_federated);
+        ValidateFederatedOrigin(event, expected_federated_origin);
+        ValidateField(event, kKeyProfileUserName, expected_profile_username);
+        ValidateField(event,
+                      enterprise_connectors::RealtimeReportingClientBase::
+                          kKeyProfileIdentifier,
+                      expected_profile_identifier);
+        ValidateField(event, kKeyLoginUserName, expected_login_username);
+
+        if (!done_closure_.is_null()) {
+          done_closure_.Run();
+        }
+      });
+}
+
 void EventReportValidatorBase::ValidateField(
     const base::Value::Dict* value,
     const std::string& field_key,
@@ -181,14 +231,13 @@ void EventReportValidatorBase::ValidateField(
       << "\nExpected value: " << expected_value.value();
 }
 
-void EventReportValidatorBase::ValidateField(
-    const base::Value::Dict* value,
-    const std::string& field_key,
-    const std::optional<bool>& expected_value) {
+void EventReportValidatorBase::ValidateField(const base::Value::Dict* value,
+                                             const std::string& field_key,
+                                             bool expected_value) {
   ASSERT_EQ(value->FindBool(field_key), expected_value)
       << "Mismatch in field " << field_key
       << "\nActual value: " << value->FindBool(field_key).value()
-      << "\nExpected value: " << expected_value.value();
+      << "\nExpected value: " << expected_value;
 }
 
 void EventReportValidatorBase::ValidateThreatInfo(
@@ -203,7 +252,20 @@ void EventReportValidatorBase::ValidateThreatInfo(
                 chrome::cros::reporting::proto::TriggeredRuleInfo::Action_Name(
                     expected_rule_info.action()));
   if (expected_rule_info.has_watermarking()) {
-    ValidateField(value, kKeyHasWatermarking, std::optional<bool>(true));
+    ValidateField(value, kKeyHasWatermarking, true);
+  }
+}
+
+void EventReportValidatorBase::ValidateFederatedOrigin(
+    const base::Value::Dict* value,
+    const std::string& expected_federated_origin) {
+  std::optional<bool> is_federated = value->FindBool(kKeyIsFederated);
+  const std::string* federated_origin = value->FindString(kKeyFederatedOrigin);
+  if (is_federated.has_value() && is_federated.value()) {
+    EXPECT_NE(nullptr, federated_origin);
+    EXPECT_EQ(expected_federated_origin, *federated_origin);
+  } else {
+    EXPECT_EQ(nullptr, federated_origin);
   }
 }
 

components/enterprise/connectors/core/reporting_test_utils.h

@@ -31,9 +31,20 @@ class EventReportValidatorBase {
   explicit EventReportValidatorBase(policy::MockCloudPolicyClient* client);
   ~EventReportValidatorBase();
 
+  void ExpectNoReport();
+
   void ExpectURLFilteringInterstitialEvent(
       chrome::cros::reporting::proto::UrlFilteringInterstitialEvent event);
 
+  // TODO(crbug.com/396438091): Use login event proto instead of raw json string
+  // for validation.
+  void ExpectLoginEvent(const std::string& expected_url,
+                        const bool expected_is_federated,
+                        const std::string& expected_federated_origin,
+                        const std::string& expected_profile_username,
+                        const std::string& expected_profile_identifier,
+                        const std::u16string& expected_login_username);
+
  protected:
   void ValidateField(const base::Value::Dict* value,
                      const std::string& field_key,
@@ -46,11 +57,13 @@ class EventReportValidatorBase {
                      const std::optional<int>& expected_value);
   void ValidateField(const base::Value::Dict* value,
                      const std::string& field_key,
-                     const std::optional<bool>& expected_value);
+                     bool expected_value);
   void ValidateThreatInfo(
       const base::Value::Dict* value,
       const chrome::cros::reporting::proto::TriggeredRuleInfo
           expected_rule_info);
+  void ValidateFederatedOrigin(const base::Value::Dict* value,
+                               const std::string& expected_federated_origin);
 
   raw_ptr<policy::MockCloudPolicyClient> client_;
   base::RepeatingClosure done_closure_;