Improve error triggering in sync_integration_tests

sync/test/fake_server/fake_server.cc

 // Copyright 2014 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.
 
 #include "sync/test/fake_server/fake_server.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 132 matching lines @@
   return scoped_ptr<UpdateSieve>(
       new UpdateSieve(request_from_version, min_version));
 }
 
 }  // namespace
 
 FakeServer::FakeServer() : version_(0),
                            store_birthday_(kDefaultStoreBirthday),
                            authenticated_(true),
                            error_type_(sync_pb::SyncEnums::SUCCESS),
+                           alternate_triggered_errors_(false),
+                           request_counter_(0),
                            network_enabled_(true) {
   keystore_keys_.push_back(kDefaultKeystoreKey);
   CHECK(CreateDefaultPermanentItems());
 }
 
 FakeServer::~FakeServer() {
   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
@@ skipping 53 matching lines @@
   entity->SetVersion(++version_);
   entities_[entity->GetId()] = entity;
 }
 
 void FakeServer::HandleCommand(const string& request,
                                const HandleCommandCallback& callback) {
   if (!network_enabled_) {
     callback.Run(net::ERR_FAILED, net::ERR_FAILED, string());
     return;
   }
+  request_counter_++;
 
   if (!authenticated_) {
     callback.Run(0, net::HTTP_UNAUTHORIZED, string());
     return;
   }
 
   sync_pb::ClientToServerMessage message;
   bool parsed = message.ParseFromString(request);
   CHECK(parsed) << "Unable to parse the ClientToServerMessage.";
 
   sync_pb::ClientToServerResponse response_proto;
 
   if (message.has_store_birthday() &&
       message.store_birthday() != store_birthday_) {
     response_proto.set_error_code(sync_pb::SyncEnums::NOT_MY_BIRTHDAY);
-  } else if (error_type_ != sync_pb::SyncEnums::SUCCESS) {
+  } else if (error_type_ != sync_pb::SyncEnums::SUCCESS &&
+             ShouldSendTriggeredError()) {
     response_proto.set_error_code(error_type_);
-  } else if (triggered_actionable_error_.get()) {
+  } else if (triggered_actionable_error_.get() && ShouldSendTriggeredError()) {
     sync_pb::ClientToServerResponse_Error* error =
         response_proto.mutable_error();
     error->CopyFrom(*(triggered_actionable_error_.get()));
   } else {
     bool success = false;
     switch (message.message_contents()) {
       case sync_pb::ClientToServerMessage::GET_UPDATES:
         success = HandleGetUpdatesRequest(message.get_updates(),
                                           response_proto.mutable_get_updates());
         break;
@@ skipping 250 matching lines @@
 }
 
 void FakeServer::SetAuthenticated() {
   authenticated_ = true;
 }
 
 void FakeServer::SetUnauthenticated() {
   authenticated_ = false;
 }
 
-void FakeServer::TriggerError(const sync_pb::SyncEnums::ErrorType& error_type) {
-  CHECK(!triggered_actionable_error_.get())
-      << "Only one type of error can be triggered at any given time.";
+bool FakeServer::TriggerError(const sync_pb::SyncEnums::ErrorType& error_type) {
+  if (triggered_actionable_error_.get()) {
+    DVLOG(1) << "Only one type of error can be triggered at any given time.";
+    return false;
+  }
+
   error_type_ = error_type;
+  return true;
 }
 
 bool FakeServer::TriggerActionableError(
     const sync_pb::SyncEnums::ErrorType& error_type,
     const string& description,
     const string& url,
     const sync_pb::SyncEnums::Action& action) {
   if (error_type_ != sync_pb::SyncEnums::SUCCESS) {
     DVLOG(1) << "Only one type of error can be triggered at any given time.";
     return false;
   }
 
   sync_pb::ClientToServerResponse_Error* error =
       new sync_pb::ClientToServerResponse_Error();
   error->set_error_type(error_type);
   error->set_error_description(description);
   error->set_url(url);
   error->set_action(action);
   triggered_actionable_error_.reset(error);
   return true;
 }
 
+bool FakeServer::EnableAlternatingTriggeredErrors() {
+  if (error_type_ == sync_pb::SyncEnums::SUCCESS &&
+      !triggered_actionable_error_.get()) {
+    DVLOG(1) << "No triggered error set. Alternating can't be enabled.";
+    return false;
+  }
+
+  alternate_triggered_errors_ = true;
+  // Reset the counter so that the the first request yields a triggered error.
+  request_counter_ = 0;
+  return true;
+}
+
+bool FakeServer::ShouldSendTriggeredError() const {
+  if (!alternate_triggered_errors_)
+    return true;
+
+  // Check that the counter is odd so that we trigger an error on the first
+  // request after alternating is enabled.
+  return request_counter_ % 2 != 0;
+}
+
 void FakeServer::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeServer::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void FakeServer::EnableNetwork() {
   network_enabled_ = true;
 }
 
 void FakeServer::DisableNetwork() {
   network_enabled_ = false;
 }
 
 }  // namespace fake_server