[DeviceSync v2] Track inputs for FakeDeviceSyncClient

Store input parameters to FakeDeviceSyncClient methods
  * SetSoftwareFeatureState(),
  * SetFeatureStatus(),
  * FindEligibleDevice(), and
  * NotifyDevices().
Update tests to verify these inputs.

Note: We change std::queue to base::circular_deque because Chromium best
practices recommends using base::queue and base::circular_deque instead
of std::queue and std::deque, respectively. Also, we use circular_deque
because of its random access support.

Bug: 951969
Change-Id: I785db3c09e0d02de47085cee1f2e91326fdadf74
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1970572Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: Josh Nohle <nohle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#725652}

chromeos/services/device_sync/public/cpp/fake_device_sync_client.h

@@ -6,11 +6,11 @@
 #define CHROMEOS_SERVICES_DEVICE_SYNC_PUBLIC_CPP_FAKE_DEVICE_SYNC_CLIENT_H_
 
 #include <memory>
-#include <queue>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "chromeos/components/multidevice/remote_device_ref.h"
@@ -28,16 +28,92 @@ namespace device_sync {
 // Test double implementation of DeviceSyncClient.
 class FakeDeviceSyncClient : public DeviceSyncClient {
  public:
+  struct SetSoftwareFeatureStateInputs {
+    SetSoftwareFeatureStateInputs(
+        const std::string& public_key,
+        multidevice::SoftwareFeature software_feature,
+        bool enabled,
+        bool is_exclusive,
+        mojom::DeviceSync::SetSoftwareFeatureStateCallback callback);
+    SetSoftwareFeatureStateInputs(SetSoftwareFeatureStateInputs&&);
+    ~SetSoftwareFeatureStateInputs();
+
+    const std::string public_key;
+    const multidevice::SoftwareFeature software_feature;
+    const bool enabled;
+    const bool is_exclusive;
+    mojom::DeviceSync::SetSoftwareFeatureStateCallback callback;
+  };
+
+  struct SetFeatureStatusInputs {
+    SetFeatureStatusInputs(
+        const std::string& device_instance_id,
+        multidevice::SoftwareFeature feature,
+        FeatureStatusChange status_change,
+        mojom::DeviceSync::SetFeatureStatusCallback callback);
+    SetFeatureStatusInputs(SetFeatureStatusInputs&&);
+    ~SetFeatureStatusInputs();
+
+    const std::string device_instance_id;
+    const multidevice::SoftwareFeature feature;
+    const FeatureStatusChange status_change;
+    mojom::DeviceSync::SetFeatureStatusCallback callback;
+  };
+
+  struct FindEligibleDevicesInputs {
+    FindEligibleDevicesInputs(multidevice::SoftwareFeature software_feature,
+                              FindEligibleDevicesCallback callback);
+    FindEligibleDevicesInputs(FindEligibleDevicesInputs&&);
+    ~FindEligibleDevicesInputs();
+
+    const multidevice::SoftwareFeature software_feature;
+    FindEligibleDevicesCallback callback;
+  };
+
+  struct NotifyDevicesInputs {
+    NotifyDevicesInputs(const std::vector<std::string>& device_instance_ids,
+                        cryptauthv2::TargetService target_service,
+                        multidevice::SoftwareFeature feature,
+                        mojom::DeviceSync::NotifyDevicesCallback callback);
+    NotifyDevicesInputs(NotifyDevicesInputs&&);
+    ~NotifyDevicesInputs();
+
+    const std::vector<std::string> device_instance_ids;
+    const cryptauthv2::TargetService target_service;
+    const multidevice::SoftwareFeature feature;
+    mojom::DeviceSync::NotifyDevicesCallback callback;
+  };
+
   FakeDeviceSyncClient();
   ~FakeDeviceSyncClient() override;
 
-  int GetForceEnrollmentNowCallbackQueueSize();
-  int GetForceSyncNowCallbackQueueSize();
-  int GetSetSoftwareFeatureStateCallbackQueueSize();
-  int GetSetFeatureStatusCallbackQueueSize();
-  int GetFindEligibleDevicesCallbackQueueSize();
-  int GetNotifyDevicesCallbackQueueSize();
-  int GetGetDebugInfoCallbackQueueSize();
+  const base::circular_deque<SetSoftwareFeatureStateInputs>&
+  set_software_feature_state_inputs_queue() const {
+    return set_software_feature_state_inputs_queue_;
+  }
+
+  const base::circular_deque<SetFeatureStatusInputs>&
+  set_feature_status_inputs_queue() const {
+    return set_feature_status_inputs_queue_;
+  }
+
+  const base::circular_deque<FindEligibleDevicesInputs>&
+  find_eligible_devices_inputs_queue() const {
+    return find_eligible_devices_inputs_queue_;
+  }
+
+  const base::circular_deque<NotifyDevicesInputs>& notify_devices_inputs_queue()
+      const {
+    return notify_devices_inputs_queue_;
+  }
+
+  int GetForceEnrollmentNowCallbackQueueSize() const;
+  int GetForceSyncNowCallbackQueueSize() const;
+  int GetSetSoftwareFeatureStateInputsQueueSize() const;
+  int GetSetFeatureStatusInputsQueueSize() const;
+  int GetFindEligibleDevicesInputsQueueSize() const;
+  int GetNotifyDevicesInputsQueueSize() const;
+  int GetGetDebugInfoCallbackQueueSize() const;
 
   void InvokePendingForceEnrollmentNowCallback(bool success);
   void InvokePendingForceSyncNowCallback(bool success);
@@ -103,20 +179,19 @@ class FakeDeviceSyncClient : public DeviceSyncClient {
   multidevice::RemoteDeviceRefList synced_devices_;
   base::Optional<multidevice::RemoteDeviceRef> local_device_metadata_;
 
-  std::queue<mojom::DeviceSync::ForceEnrollmentNowCallback>
+  base::circular_deque<mojom::DeviceSync::ForceEnrollmentNowCallback>
       force_enrollment_now_callback_queue_;
-  std::queue<mojom::DeviceSync::ForceSyncNowCallback>
+  base::circular_deque<mojom::DeviceSync::ForceSyncNowCallback>
       force_sync_now_callback_queue_;
-  std::queue<mojom::DeviceSync::SetSoftwareFeatureStateCallback>
-      set_software_feature_state_callback_queue_;
-  std::queue<mojom::DeviceSync::SetFeatureStatusCallback>
-      set_feature_status_callback_queue_;
-  std::queue<FindEligibleDevicesCallback> find_eligible_devices_callback_queue_;
-  std::queue<mojom::DeviceSync::NotifyDevicesCallback>
-      notify_devices_callback_queue_;
-  std::queue<mojom::DeviceSync::GetDevicesActivityStatusCallback>
+  base::circular_deque<SetSoftwareFeatureStateInputs>
+      set_software_feature_state_inputs_queue_;
+  base::circular_deque<SetFeatureStatusInputs> set_feature_status_inputs_queue_;
+  base::circular_deque<FindEligibleDevicesInputs>
+      find_eligible_devices_inputs_queue_;
+  base::circular_deque<NotifyDevicesInputs> notify_devices_inputs_queue_;
+  base::circular_deque<mojom::DeviceSync::GetDevicesActivityStatusCallback>
       get_devices_activity_status_callback_queue_;
-  std::queue<mojom::DeviceSync::GetDebugInfoCallback>
+  base::circular_deque<mojom::DeviceSync::GetDebugInfoCallback>
       get_debug_info_callback_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDeviceSyncClient);

chromeos/services/multidevice_setup/grandfathered_easy_unlock_host_disabler_unittest.cc

@@ -147,7 +147,7 @@ TEST_F(
             GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 
   fake_device_sync_client()->InvokePendingSetSoftwareFeatureStateCallback(
       device_sync::mojom::NetworkRequestResult::kSuccess);
@@ -180,7 +180,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 // Situation #3:
@@ -208,7 +208,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
             GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 
   fake_device_sync_client()->InvokePendingSetSoftwareFeatureStateCallback(
       device_sync::mojom::NetworkRequestResult::kSuccess);
@@ -228,7 +228,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
             GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 // Situation #1 where device A is removed from list of synced devices:
@@ -252,7 +252,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 // Situation #1 with failure:
@@ -272,12 +272,12 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
 
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   fake_device_sync_client()->InvokePendingSetSoftwareFeatureStateCallback(
       device_sync::mojom::NetworkRequestResult::kInternalServerError);
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 
   EXPECT_EQ(test_devices()[0].GetDeviceId(),
             GetEasyUnlockHostIdToDisablePrefValue());
@@ -287,7 +287,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
 
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
@@ -299,7 +299,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
@@ -312,7 +312,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
@@ -325,7 +325,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 }
 
 // Simulate:
@@ -344,7 +344,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
 
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   fake_device_sync_client()->InvokePendingSetSoftwareFeatureStateCallback(
       device_sync::mojom::NetworkRequestResult::kInternalServerError);
 
@@ -354,7 +354,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
 
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   EXPECT_FALSE(mock_timer()->IsRunning());
   EXPECT_EQ(kNoDevice, GetEasyUnlockHostIdToDisablePrefValue());
 }
@@ -380,7 +380,7 @@ TEST_F(MultiDeviceSetupGrandfatheredEasyUnlockHostDisablerTest,
 
   EXPECT_EQ(
       2,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   EXPECT_EQ(test_devices()[1].GetDeviceId(),
             GetEasyUnlockHostIdToDisablePrefValue());
 

chromeos/services/multidevice_setup/host_backend_delegate_impl_unittest.cc

@@ -127,10 +127,9 @@ class MultiDeviceSetupHostBackendDelegateImplTest
 
   int GetSetHostNetworkRequestCallbackQueueSize() {
     return DoTestDevicesHaveInstanceIds()
-               ? fake_device_sync_client_
-                     ->GetSetFeatureStatusCallbackQueueSize()
+               ? fake_device_sync_client_->GetSetFeatureStatusInputsQueueSize()
                : fake_device_sync_client_
-                     ->GetSetSoftwareFeatureStateCallbackQueueSize();
+                     ->GetSetSoftwareFeatureStateInputsQueueSize();
   }
 
   void InvokePendingSetHostNetworkRequestCallback(
@@ -196,8 +195,10 @@ class MultiDeviceSetupHostBackendDelegateImplTest
 
   void AttemptToSetMultiDeviceHostOnBackend(
       const base::Optional<multidevice::RemoteDeviceRef>& host_device) {
+    base::Optional<multidevice::RemoteDeviceRef> host_before_call =
+        delegate_->GetMultiDeviceHostFromBackend();
     bool attempting_to_set_host_which_already_exists =
-        host_device == delegate_->GetMultiDeviceHostFromBackend();
+        host_device == host_before_call;
     size_t num_pending_host_request_change_events_before_call =
         observer_->num_pending_host_request_changes();
     bool was_request_for_same_device_as_pending_request =
@@ -225,9 +226,15 @@ class MultiDeviceSetupHostBackendDelegateImplTest
                 observer_->num_pending_host_request_changes());
     }
 
-    // TODO(khorimoto): Check that the parameters passed to
-    // |fake_device_sync_client_| are correct. Currently, FakeDeviceSyncClient
-    // does provide a mechanism for checking these parameters.
+    // Verify that the correct parameters were passed to
+    // SetSoftwareFeatureState() or SetFeatureStatus().
+    if (host_device) {
+      VerifyLatestSetHostNetworkRequest(*host_device, true /* should_enable */);
+    } else {
+      ASSERT_TRUE(host_before_call);
+      VerifyLatestSetHostNetworkRequest(*host_before_call,
+                                        false /* should_enable */);
+    }
   }
 
   void SetHostInDeviceSyncClient(
@@ -267,6 +274,40 @@ class MultiDeviceSetupHostBackendDelegateImplTest
   }
 
  private:
+  void VerifyLatestSetHostNetworkRequest(
+      const multidevice::RemoteDeviceRef expected_host,
+      bool expected_should_enable) {
+    // Verify inputs to SetSoftwareFeatureState().
+    if (expected_host.instance_id().empty()) {
+      ASSERT_FALSE(
+          fake_device_sync_client_->set_software_feature_state_inputs_queue()
+              .empty());
+      const device_sync::FakeDeviceSyncClient::SetSoftwareFeatureStateInputs&
+          inputs = fake_device_sync_client_
+                       ->set_software_feature_state_inputs_queue()
+                       .back();
+      EXPECT_EQ(expected_host.public_key(), inputs.public_key);
+      EXPECT_EQ(multidevice::SoftwareFeature::kBetterTogetherHost,
+                inputs.software_feature);
+      EXPECT_EQ(expected_should_enable, inputs.enabled);
+      EXPECT_EQ(expected_should_enable, inputs.is_exclusive);
+      return;
+    }
+
+    // Verify inputs to SetFeatureStatus().
+    ASSERT_FALSE(
+        fake_device_sync_client_->set_feature_status_inputs_queue().empty());
+    const device_sync::FakeDeviceSyncClient::SetFeatureStatusInputs& inputs =
+        fake_device_sync_client_->set_feature_status_inputs_queue().back();
+    EXPECT_EQ(expected_host.instance_id(), inputs.device_instance_id);
+    EXPECT_EQ(multidevice::SoftwareFeature::kBetterTogetherHost,
+              inputs.feature);
+    EXPECT_EQ(expected_should_enable
+                  ? device_sync::FeatureStatusChange::kEnableExclusively
+                  : device_sync::FeatureStatusChange::kDisable,
+              inputs.status_change);
+  }
+
   multidevice::RemoteDeviceRefList test_devices_;
 
   std::unique_ptr<FakeEligibleHostDevicesProvider>
@@ -303,7 +344,7 @@ TEST_P(MultiDeviceSetupHostBackendDelegateImplTest, Success) {
   EXPECT_FALSE(delegate()->HasPendingHostRequest());
   EXPECT_EQ(test_devices()[0], delegate()->GetMultiDeviceHostFromBackend());
 
-  // Remove device 0 such that there is no longer a host..
+  // Remove device 0 such that there is no longer a host.
   AttemptToSetMultiDeviceHostOnBackend(base::nullopt);
   EXPECT_EQ(1, GetSetHostNetworkRequestCallbackQueueSize());
   InvokePendingSetHostNetworkRequestCallback(
@@ -634,8 +675,7 @@ TEST_P(MultiDeviceSetupHostBackendDelegateImplTest, V1andV2DeviceSync) {
   EXPECT_TRUE(delegate()->HasPendingHostRequest());
   EXPECT_EQ(test_devices()[0], delegate()->GetPendingHostRequest());
   EXPECT_EQ(base::nullopt, delegate()->GetMultiDeviceHostFromBackend());
-  EXPECT_EQ(1,
-            fake_device_sync_client()->GetSetFeatureStatusCallbackQueueSize());
+  EXPECT_EQ(1, fake_device_sync_client()->GetSetFeatureStatusInputsQueueSize());
 
   // Now, attempt to set device 1, which does not have an Instance ID. Device 1
   // is now the pending host, but no SetSoftwareFeatureState call was made since
@@ -646,7 +686,7 @@ TEST_P(MultiDeviceSetupHostBackendDelegateImplTest, V1andV2DeviceSync) {
   EXPECT_EQ(base::nullopt, delegate()->GetMultiDeviceHostFromBackend());
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
 
   // Fire the callback for device 0 and have it succeed. This should affect the
   // value of GetMultiDeviceHostFromBackend(); however, because device 0 is not
@@ -657,11 +697,10 @@ TEST_P(MultiDeviceSetupHostBackendDelegateImplTest, V1andV2DeviceSync) {
   // HostBackendDelegate implementation.
   fake_device_sync_client()->InvokePendingSetFeatureStatusCallback(
       device_sync::mojom::NetworkRequestResult::kSuccess);
-  EXPECT_EQ(0,
-            fake_device_sync_client()->GetSetFeatureStatusCallbackQueueSize());
+  EXPECT_EQ(0, fake_device_sync_client()->GetSetFeatureStatusInputsQueueSize());
   EXPECT_EQ(
       1,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   SimulateNewHostDevicesSynced(test_devices()[0] /* host_device_after_sync */,
                                false /* expected_to_fulfill_pending_request */);
   EXPECT_TRUE(delegate()->HasPendingHostRequest());
@@ -671,11 +710,10 @@ TEST_P(MultiDeviceSetupHostBackendDelegateImplTest, V1andV2DeviceSync) {
   // Fire the callback for device 1, and have it succeed.
   fake_device_sync_client()->InvokePendingSetSoftwareFeatureStateCallback(
       device_sync::mojom::NetworkRequestResult::kSuccess);
-  EXPECT_EQ(0,
-            fake_device_sync_client()->GetSetFeatureStatusCallbackQueueSize());
+  EXPECT_EQ(0, fake_device_sync_client()->GetSetFeatureStatusInputsQueueSize());
   EXPECT_EQ(
       0,
-      fake_device_sync_client()->GetSetSoftwareFeatureStateCallbackQueueSize());
+      fake_device_sync_client()->GetSetSoftwareFeatureStateInputsQueueSize());
   SimulateNewHostDevicesSynced(test_devices()[1] /* host_device_after_sync */,
                                true /* expected_to_fulfill_pending_request */);
   EXPECT_FALSE(delegate()->HasPendingHostRequest());

chromeos/services/multidevice_setup/host_verifier_impl.cc

@@ -13,6 +13,7 @@
 #include "base/no_destructor.h"
 #include "chromeos/components/multidevice/logging/logging.h"
 #include "chromeos/components/multidevice/software_feature.h"
+#include "chromeos/services/device_sync/proto/cryptauth_common.pb.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 

chromeos/services/multidevice_setup/host_verifier_impl_unittest.cc

@@ -14,6 +14,7 @@
 #include "chromeos/components/multidevice/remote_device_test_util.h"
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/components/multidevice/software_feature_state.h"
+#include "chromeos/services/device_sync/proto/cryptauth_common.pb.h"
 #include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h"
 #include "chromeos/services/multidevice_setup/fake_host_backend_delegate.h"
 #include "chromeos/services/multidevice_setup/fake_host_verifier.h"
@@ -151,6 +152,12 @@ class MultiDeviceSetupHostVerifierImplTest
 
   void InvokePendingDeviceNotificationCall(bool success) {
     if (test_device_.instance_id().empty()) {
+      // Verify input parameters to FindEligibleDevices().
+      EXPECT_EQ(multidevice::SoftwareFeature::kBetterTogetherHost,
+                fake_device_sync_client_->find_eligible_devices_inputs_queue()
+                    .front()
+                    .software_feature);
+
       fake_device_sync_client_->InvokePendingFindEligibleDevicesCallback(
           success
               ? device_sync::mojom::NetworkRequestResult::kSuccess
@@ -160,6 +167,20 @@ class MultiDeviceSetupHostVerifierImplTest
       return;
     }
 
+    // Verify input parameters to NotifyDevices().
+    EXPECT_EQ(std::vector<std::string>{test_device_.instance_id()},
+              fake_device_sync_client_->notify_devices_inputs_queue()
+                  .front()
+                  .device_instance_ids);
+    EXPECT_EQ(cryptauthv2::TargetService::DEVICE_SYNC,
+              fake_device_sync_client_->notify_devices_inputs_queue()
+                  .front()
+                  .target_service);
+    EXPECT_EQ(multidevice::SoftwareFeature::kBetterTogetherHost,
+              fake_device_sync_client_->notify_devices_inputs_queue()
+                  .front()
+                  .feature);
+
     fake_device_sync_client_->InvokePendingNotifyDevicesCallback(
         success
             ? device_sync::mojom::NetworkRequestResult::kSuccess