Policy test server can simulate errors in more requests

PolicyTestServer can now simulate errors for device_attribute_update
and policy fetch requests.

Bug: 950471
Change-Id: I3b9bf3c84dbe500dec34254b8e8ebf06225c359e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1556811
Commit-Queue: Denis Kuznetsov <antrim@chromium.org>
Reviewed-by: Roman Sorokin [CET] <rsorokin@chromium.org>
Reviewed-by: Alexander Alekseev <alemate@chromium.org>
Cr-Commit-Position: refs/heads/master@{#649083}

chrome/browser/chromeos/login/enrollment/enrollment_local_policy_server_browsertest.cc

@@ -325,6 +325,67 @@ IN_PROC_BROWSER_TEST_F(EnrollmentLocalPolicyServerBase,
   EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
 }
 
+// Error during enrollment : Can not update device attributes
+IN_PROC_BROWSER_TEST_F(EnrollmentLocalPolicyServerBase,
+                       EnrollmentErrorUploadingDeviceAttributes) {
+  policy_server_.SetUpdateDeviceAttributesPermission(true);
+  policy_server_.SetExpectedDeviceAttributeUpdateError(500);
+
+  TriggerEnrollmentAndSignInSuccessfully();
+
+  enrollment_ui_.WaitForStep(test::ui::kEnrollmentStepDeviceAttributes);
+  enrollment_ui_.SubmitDeviceAttributes(test::values::kAssetId,
+                                        test::values::kLocation);
+
+  enrollment_ui_.WaitForStep(test::ui::kEnrollmentStepDeviceAttributesError);
+  EXPECT_TRUE(StartupUtils::IsDeviceRegistered());
+  enrollment_ui_.LeaveDeviceAttributeErrorScreen();
+  OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
+}
+
+// Error during enrollment : Error fetching policy : 500 server error.
+IN_PROC_BROWSER_TEST_F(EnrollmentLocalPolicyServerBase,
+                       EnrollmentErrorFetchingPolicyTransient) {
+  policy_server_.SetExpectedPolicyFetchError(500);
+
+  TriggerEnrollmentAndSignInSuccessfully();
+
+  enrollment_ui_.WaitForStep(test::ui::kEnrollmentStepError);
+  enrollment_ui_.ExpectErrorMessage(IDS_POLICY_DM_STATUS_TEMPORARY_UNAVAILABLE,
+                                    /* can retry */ true);
+  EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
+  enrollment_ui_.RetryAfterError();
+}
+
+// Error during enrollment : Error fetching policy : 902 - policy not found.
+IN_PROC_BROWSER_TEST_F(EnrollmentLocalPolicyServerBase,
+                       EnrollmentErrorFetchingPolicyNotFound) {
+  policy_server_.SetExpectedPolicyFetchError(902);
+
+  TriggerEnrollmentAndSignInSuccessfully();
+
+  enrollment_ui_.WaitForStep(test::ui::kEnrollmentStepError);
+  enrollment_ui_.ExpectErrorMessage(
+      IDS_POLICY_DM_STATUS_SERVICE_POLICY_NOT_FOUND,
+      /* can retry */ true);
+  EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
+  enrollment_ui_.RetryAfterError();
+}
+
+// Error during enrollment : Error fetching policy : 903 - deprovisioned.
+IN_PROC_BROWSER_TEST_F(EnrollmentLocalPolicyServerBase,
+                       EnrollmentErrorFetchingPolicyDeprovisioned) {
+  policy_server_.SetExpectedPolicyFetchError(903);
+
+  TriggerEnrollmentAndSignInSuccessfully();
+
+  enrollment_ui_.WaitForStep(test::ui::kEnrollmentStepError);
+  enrollment_ui_.ExpectErrorMessage(IDS_POLICY_DM_STATUS_SERVICE_DEPROVISIONED,
+                                    /* can retry */ true);
+  EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
+  enrollment_ui_.RetryAfterError();
+}
+
 // No state keys on the server. Auto enrollment check should proceed to login.
 IN_PROC_BROWSER_TEST_F(AutoEnrollmentLocalPolicyServer, AutoEnrollmentCheck) {
   host()->StartWizard(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);

chrome/browser/chromeos/login/test/enrollment_ui_mixin.cc

@@ -17,10 +17,11 @@ namespace ui {
 const char kEnrollmentStepSignin[] = "signin";
 const char kEnrollmentStepWorking[] = "working";
 const char kEnrollmentStepSuccess[] = "success";
-const char kEnrollmentStepError[] = "error";
 const char kEnrollmentStepLicenses[] = "license";
 const char kEnrollmentStepDeviceAttributes[] = "attribute-prompt";
 const char kEnrollmentStepADJoin[] = "ad-join";
+const char kEnrollmentStepError[] = "error";
+const char kEnrollmentStepDeviceAttributesError[] = "attribute-prompt-error";
 const char kEnrollmentStepADJoinError[] = "active-directory-join-error";
 
 }  // namespace ui
@@ -38,11 +39,15 @@ const char kLocation[] = "location";
 
 namespace {
 
-const char* const kAllSteps[] = {
-    ui::kEnrollmentStepSignin,   ui::kEnrollmentStepWorking,
-    ui::kEnrollmentStepLicenses, ui::kEnrollmentStepDeviceAttributes,
-    ui::kEnrollmentStepSuccess,  ui::kEnrollmentStepADJoin,
-    ui::kEnrollmentStepError,    ui::kEnrollmentStepADJoinError};
+const char* const kAllSteps[] = {ui::kEnrollmentStepSignin,
+                                 ui::kEnrollmentStepWorking,
+                                 ui::kEnrollmentStepLicenses,
+                                 ui::kEnrollmentStepDeviceAttributes,
+                                 ui::kEnrollmentStepSuccess,
+                                 ui::kEnrollmentStepADJoin,
+                                 ui::kEnrollmentStepError,
+                                 ui::kEnrollmentStepADJoinError,
+                                 ui::kEnrollmentStepDeviceAttributesError};
 
 std::string StepVisibleExpression(const std::string& step) {
   return "document.getElementsByClassName('oauth-enroll-state-" + step +
@@ -52,6 +57,10 @@ std::string StepVisibleExpression(const std::string& step) {
 const std::initializer_list<base::StringPiece> kEnrollmentErrorRetryButtonPath =
     {"oauth-enroll-error-card", "submitButton"};
 
+const std::initializer_list<base::StringPiece>
+    kEnrollmentDeviceAttributesErrorButtonPath = {
+        "oauth-enroll-attribute-prompt-error-card", "submitButton"};
+
 }  // namespace
 
 EnrollmentUIMixin::EnrollmentUIMixin(InProcessBrowserTestMixinHost* host)
@@ -102,6 +111,10 @@ void EnrollmentUIMixin::RetryAfterError() {
   WaitForStep(ui::kEnrollmentStepSignin);
 }
 
+void EnrollmentUIMixin::LeaveDeviceAttributeErrorScreen() {
+  OobeJS().TapOnPath(kEnrollmentDeviceAttributesErrorButtonPath);
+}
+
 void EnrollmentUIMixin::SubmitDeviceAttributes(const std::string& asset_id,
                                                const std::string& location) {
   OobeJS().TypeIntoPath(asset_id, {"oauth-enroll-asset-id"});

chrome/browser/chromeos/login/test/enrollment_ui_mixin.h

@@ -22,6 +22,7 @@ extern const char kEnrollmentStepDeviceAttributes[];
 extern const char kEnrollmentStepSuccess[];
 extern const char kEnrollmentStepADJoin[];
 extern const char kEnrollmentStepError[];
+extern const char kEnrollmentStepDeviceAttributesError[];
 extern const char kEnrollmentStepADJoinError[];
 
 }  // namespace ui
@@ -58,6 +59,8 @@ class EnrollmentUIMixin : public InProcessBrowserTestMixin {
   void SubmitDeviceAttributes(const std::string& asset_id,
                               const std::string& location);
 
+  void LeaveDeviceAttributeErrorScreen();
+
   // Selects enrollment license.
   void SelectEnrollmentLicense(const std::string& license_type);
 

chrome/browser/chromeos/login/test/local_policy_test_server_mixin.cc

@@ -85,8 +85,22 @@ void LocalPolicyTestServerMixin::SetUpdateDeviceAttributesPermission(
 
 void LocalPolicyTestServerMixin::SetExpectedDeviceEnrollmentError(
     int net_error_code) {
-  server_config_.SetKey("device_register_http_error",
-                        base::Value(net_error_code));
+  server_config_.SetPath({"request_errors", "register"},
+                         base::Value(net_error_code));
+  policy_test_server_->SetConfig(server_config_);
+}
+
+void LocalPolicyTestServerMixin::SetExpectedDeviceAttributeUpdateError(
+    int net_error_code) {
+  server_config_.SetPath({"request_errors", "device_attribute_update"},
+                         base::Value(net_error_code));
+  policy_test_server_->SetConfig(server_config_);
+}
+
+void LocalPolicyTestServerMixin::SetExpectedPolicyFetchError(
+    int net_error_code) {
+  server_config_.SetPath({"request_errors", "policy"},
+                         base::Value(net_error_code));
   policy_test_server_->SetConfig(server_config_);
 }
 

chrome/browser/chromeos/login/test/local_policy_test_server_mixin.h

@@ -41,10 +41,11 @@ class LocalPolicyTestServerMixin : public InProcessBrowserTestMixin {
 
   void SetUpdateDeviceAttributesPermission(bool allowed);
 
-  // Configures server to respond with particular error code during device
-  // registration.
+  // Configures server to respond with particular error code during requests.
   // |net_error_code| - error code from device_management_service.cc.
   void SetExpectedDeviceEnrollmentError(int net_error_code);
+  void SetExpectedDeviceAttributeUpdateError(int net_error_code);
+  void SetExpectedPolicyFetchError(int net_error_code);
 
   // Set response for DeviceStateRetrievalRequest. Returns that if finds state
   // key passed in the request. State keys could be set by RegisterClient call

chrome/browser/policy/test/policy_testserver.py

@@ -58,7 +58,9 @@ Example:
       "token": "abcd-ef01-123123123",
       "username": "admin@example.com"
    },
-   "device_register_http_error" : 902,
+   "expected_errors": {
+     "register": 500,
+   }
    "allow_set_device_attributes" : false,
 }
 
@@ -307,6 +309,11 @@ class PolicyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
         (self.GetUniqueParam('deviceid') is not None and
          len(self.GetUniqueParam('deviceid')) >= 64)):
       return (400, 'Invalid request parameter')
+
+    expected_error = self.GetExpectedError(request_type)
+    if expected_error:
+      return expected_error
+
     if request_type == 'register':
       response = self.ProcessRegister(rmsg.register_request)
     elif request_type == 'certificate_based_register':
@@ -429,9 +436,6 @@ class PolicyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     if not auth:
       return (403, 'No authorization')
 
-    if 'device_register_http_error' in policy:
-      return (policy['device_register_http_error'], 'Preconfigured error')
-
     if ('managed_users' not in policy):
       return (500, 'Error in config - no managed users')
     username = self.server.ResolveUser(auth)
@@ -1228,6 +1232,21 @@ class PolicyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     """Helper for logging an ASCII dump of a protobuf message."""
     logging.debug('%s\n%s' % (label, str(msg)))
 
+  def GetExpectedError(self, request):
+    """
+    Returns the preset HTTP error for |request| if it is defined in
+    configuration.
+
+    Returns:
+      A tuple of HTTP status code and response data to send to the client or
+      None if no error was defined.
+    """
+    policy = self.server.GetPolicies()
+    if 'request_errors' in policy:
+      errors = policy['request_errors']
+      if (request in errors) and (errors[request] > 0):
+        return errors[request], 'Preconfigured error'
+    return None
 
 class PolicyTestServer(testserver_base.BrokenPipeHandlerMixIn,
                        testserver_base.StoppableHTTPServer):