1 files changed, 186 insertions, 0 deletions
diff --git a/chromium/components/policy/core/common/cloud/mock_device_management_service.h b/chromium/components/policy/core/common/cloud/mock_device_management_service.h
new file mode 100644
index 00000000000..131908f3237
--- /dev/null
+++ b/chromium/components/policy/core/common/cloud/mock_device_management_service.h
@@ -0,0 +1,186 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_POLICY_CORE_COMMON_CLOUD_MOCK_DEVICE_MANAGEMENT_SERVICE_H_
+#define COMPONENTS_POLICY_CORE_COMMON_CLOUD_MOCK_DEVICE_MANAGEMENT_SERVICE_H_
+
+#include <string>
+
+#include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
+#include "components/policy/core/common/cloud/device_management_service.h"
+#include "components/policy/core/common/cloud/dm_auth.h"
+#include "components/policy/core/common/cloud/dmserver_job_configurations.h"
+#include "components/policy/proto/device_management_backend.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace network {
+class SharedURLLoaderFactory;
+}
+
+namespace policy {
+
+class MockDeviceManagementServiceConfiguration
+    : public DeviceManagementService::Configuration {
+ public:
+  MockDeviceManagementServiceConfiguration();
+  explicit MockDeviceManagementServiceConfiguration(
+      const std::string& server_url);
+  MockDeviceManagementServiceConfiguration(
+      const MockDeviceManagementServiceConfiguration&) = delete;
+  MockDeviceManagementServiceConfiguration& operator=(
+      const MockDeviceManagementServiceConfiguration&) = delete;
+  ~MockDeviceManagementServiceConfiguration() override;
+
+  std::string GetDMServerUrl() const override;
+  std::string GetAgentParameter() const override;
+  std::string GetPlatformParameter() const override;
+  std::string GetRealtimeReportingServerUrl() const override;
+  std::string GetEncryptedReportingServerUrl() const override;
+  std::string GetReportingConnectorServerUrl(
+      content::BrowserContext* context) const override;
+
+ private:
+  const std::string server_url_;
+};
+
+class MockJobCreationHandler {
+ public:
+  MockJobCreationHandler();
+  MockJobCreationHandler(const MockJobCreationHandler&) = delete;
+  MockJobCreationHandler& operator=(const MockJobCreationHandler&) = delete;
+  ~MockJobCreationHandler();
+
+  MOCK_METHOD(void,
+              OnJobCreation,
+              (const DeviceManagementService::JobForTesting&));
+};
+
+class FakeDeviceManagementService : public DeviceManagementService {
+ public:
+  using JobAction = testing::Action<void(const JobForTesting&)>;
+
+  explicit FakeDeviceManagementService(
+      MockJobCreationHandler* creation_handler);
+  FakeDeviceManagementService(std::unique_ptr<Configuration> config,
+                              MockJobCreationHandler* creation_handler);
+  FakeDeviceManagementService(const FakeDeviceManagementService&) = delete;
+  FakeDeviceManagementService& operator=(const FakeDeviceManagementService&) =
+      delete;
+  ~FakeDeviceManagementService() override;
+
+  // Convenience actions to obtain the respective data from the job's
+  // configuration.
+  JobAction CaptureAuthData(DMAuth* auth_data);
+  JobAction CaptureJobType(
+      DeviceManagementService::JobConfiguration::JobType* job_type);
+  JobAction CapturePayload(std::string* payload);
+  JobAction CaptureQueryParams(
+      std::map<std::string, std::string>* query_params);
+  JobAction CaptureRequest(
+      enterprise_management::DeviceManagementRequest* request);
+
+  // Convenience actions to post a task which will call |SetResponseForTesting|
+  // on the job.
+  JobAction SendJobResponseAsync(
+      int net_error,
+      int response_code,
+      const std::string& response = "",
+      const std::string& mime_type = "application/x-protobuffer",
+      bool was_fetched_via_proxy = false);
+
+  JobAction SendJobResponseAsync(
+      int net_error,
+      int response_code,
+      const enterprise_management::DeviceManagementResponse& response,
+      const std::string& mime_type = "application/x-protobuffer",
+      bool was_fetched_via_proxy = false);
+
+  JobAction SendJobOKAsync(const std::string& response);
+
+  JobAction SendJobOKAsync(
+      const enterprise_management::DeviceManagementResponse& response);
+
+  // Convenience wrappers around |job->SetResponseForTesting()|
+  void SendJobResponseNow(
+      DeviceManagementService::JobForTesting* job,
+      int net_error,
+      int response_code,
+      const std::string& response = "",
+      const std::string& mime_type = "application/x-protobuffer",
+      bool was_fetched_via_proxy = false);
+
+  void SendJobResponseNow(
+      DeviceManagementService::JobForTesting* job,
+      int net_error,
+      int response_code,
+      const enterprise_management::DeviceManagementResponse& response,
+      const std::string& mime_type = "application/x-protobuffer",
+      bool was_fetched_via_proxy = false);
+
+  void SendJobOKNow(DeviceManagementService::JobForTesting* job,
+                    const std::string& response);
+
+  void SendJobOKNow(
+      DeviceManagementService::JobForTesting* job,
+      const enterprise_management::DeviceManagementResponse& response);
+
+ private:
+  std::unique_ptr<Job> CreateJob(
+      std::unique_ptr<JobConfiguration> config) override;
+
+  raw_ptr<MockJobCreationHandler> creation_handler_;
+};
+
+// A fake implementation of DMServerJobConfiguration that can be used in tests
+// to set arbitrary request payloads for network requests.
+class FakeJobConfiguration : public DMServerJobConfiguration {
+ public:
+  typedef base::OnceCallback<void(DeviceManagementService::Job* job,
+                                  DeviceManagementStatus code,
+                                  int net_error,
+                                  const std::string&)>
+      FakeCallback;
+
+  typedef base::RepeatingCallback<void(int response_code,
+                                       const std::string& response_body)>
+      RetryCallback;
+
+  explicit FakeJobConfiguration(DeviceManagementService* service);
+  FakeJobConfiguration(
+      DeviceManagementService* service,
+      JobType type,
+      const std::string& client_id,
+      bool critical,
+      DMAuth auth_data,
+      absl::optional<std::string> oauth_token,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      FakeCallback callback,
+      RetryCallback retry_callback,
+      RetryCallback should_retry_callback);
+  ~FakeJobConfiguration() override;
+
+  void SetRequestPayload(const std::string& request_payload);
+  void SetShouldRetryResponse(DeviceManagementService::Job::RetryMethod method);
+
+ private:
+  DeviceManagementService::Job::RetryMethod ShouldRetry(
+      int response_code,
+      const std::string& response_body) override;
+  void OnBeforeRetry(int response_code,
+                     const std::string& response_body) override;
+  void OnURLLoadComplete(DeviceManagementService::Job* job,
+                         int net_error,
+                         int response_code,
+                         const std::string& response_body) override;
+
+  DeviceManagementService::Job::RetryMethod should_retry_response_;
+  FakeCallback callback_;
+  RetryCallback retry_callback_;
+  RetryCallback should_retry_callback_;
+};
+
+}  // namespace policy
+
+#endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_MOCK_DEVICE_MANAGEMENT_SERVICE_H_