test cases for server directed error handling code.

net/tools/testserver/chromiumsync.py

 #!/usr/bin/python2.4
 # Copyright (c) 2011 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.
 
 """An implementation of the server side of the Chromium sync protocol.
 
 The details of the protocol are described mostly by comments in the protocol
 buffer definition at chrome/browser/sync/protocol/sync.proto.
 """
@@ skipping 87 matching lines @@
 
 
 class StoreBirthdayError(Error):
   """The client sent a birthday that doesn't correspond to this server."""
 
 
 class TransientError(Error):
   """The client would be sent a transient error."""
 
 
+class SyncInducedError(Error):
+  """The client would be sent an error."""
+
+
 def GetEntryType(entry):
   """Extract the sync type from a SyncEntry.
 
   Args:
     entry: A SyncEntity protobuf object whose type to determine.
   Returns:
     An enum value from ALL_TYPES if the entry's type can be determined, or None
     if the type cannot be determined.
   Raises:
     ProtobufExtensionNotUnique: More than one type was indicated by the entry.
@@ skipping 290 matching lines @@
     self._version = 0
 
     # The definitive copy of this client's items: a map from ID string to a
     # SyncEntity protocol buffer.
     self._entries = {}
 
     self.ResetStoreBirthday()
 
     self.migration_history = MigrationHistory()
 
+    self.induced_error = sync_pb2.ClientToServerResponse.Error()
+
   def _SaveEntry(self, entry):
     """Insert or update an entry in the change log, and give it a new version.
 
     The ID fields of this entry are assumed to be valid server IDs.  This
     entry will be updated with a new version number and sync_timestamp.
 
     Args:
       entry: The entry to be added or updated.
     """
     self._version += 1
@@ skipping 445 matching lines @@
     nigori_tag = "google_chrome_nigori"
     nigori_original = self._entries.get(self._ServerTagToId(nigori_tag))
     if (nigori_original.specifics.Extensions[nigori_specifics_pb2.nigori].
         sync_tabs):
       return
     nigori_new = copy.deepcopy(nigori_original)
     nigori_new.specifics.Extensions[nigori_specifics_pb2.nigori].sync_tabs = (
         True)
     self._SaveEntry(nigori_new)
 
+  def SetInducedError(self, error):
+    self.induced_error = error
+
+  def GetInducedError(self):
+    return self.induced_error
+
 
 class TestServer(object):
   """An object to handle requests for one (and only one) Chrome Sync account.
 
   TestServer consumes the sync command messages that are the outermost
   layers of the protocol, performs the corresponding actions on its
   SyncDataModel, and constructs an appropropriate response message.
   """
 
   def __init__(self):
@@ skipping 22 matching lines @@
     if not request.HasField('store_birthday'):
       return
     if self.account.StoreBirthday() != request.store_birthday:
       raise StoreBirthdayError
 
   def CheckTransientError(self):
     """Raises TransientError if transient_error variable is set."""
     if self.transient_error:
       raise TransientError
 
+  def CheckSendError(self):
+     """Raises SyncInducedError if needed."""
+     if self.account.induced_error.error_type !=\
+        sync_pb2.ClientToServerResponse.UNKNOWN:
+       raise SyncInducedError
+
   def HandleMigrate(self, path):
     query = urlparse.urlparse(path)[4]
     code = 200
     self.account_lock.acquire()
     try:
       datatypes = [DataTypeStringToSyncTypeLoose(x)
                    for x in urlparse.parse_qs(query).get('type',[])]
       if datatypes:
         self.account.TriggerMigration(datatypes)
         response = 'Migrated datatypes %s' % (
             ' and '.join(SyncTypeToString(x).upper() for x in datatypes))
       else:
         response = 'Please specify one or more <i>type=name</i> parameters'
         code = 400
     except DataTypeIdNotRecognized, error:
       response = 'Could not interpret datatype name'
       code = 400
     finally:
       self.account_lock.release()
     return (code, '<html><title>Migration: %d</title><H1>%d %s</H1></html>' %
                 (code, code, response))
 
+  def HandleSetInducedError(self, path):
+     query = urlparse.urlparse(path)[4]
+     self.account_lock.acquire()
+     code = 200;
+     response = 'Success'
+     error = sync_pb2.ClientToServerResponse.Error()
+     try:
+       error_type = urlparse.parse_qs(query)['error']
+       action = urlparse.parse_qs(query)['action']
+       error.error_type = int(error_type[0])
+       error.action = int(action[0])
+       try:
+         error.url = (urlparse.parse_qs(query)['url'])[0]
+       except KeyError:
+         error.url = ''
+       try:
+         error.error_description = \
+         (urlparse.parse_qs(query)['error_description'])[0]
+       except KeyError:
+         error.error_description = ''
+       self.account.SetInducedError(error)
+       response = ('Error = %d, action = %d, url = %s, description = %s' %
+                   (error.error_type, error.action,
+                    error.url,
+                    error.error_description))
+     except error:
+       response = 'Could not parse url'
+       code = 400
+     finally:
+       self.account_lock.release()
+     return (code, '<html><title>SetError: %d</title><H1>%d %s</H1></html>' %
+                (code, code, response))
+
   def HandleCreateBirthdayError(self):
     self.account.ResetStoreBirthday()
     return (
         200,
         '<html><title>Birthday error</title><H1>Birthday error</H1></html>')
 
   def HandleSetTransientError(self):
     self.transient_error = True
     return (
         200,
@@ skipping 28 matching lines @@
     try:
       request = sync_pb2.ClientToServerMessage()
       request.MergeFromString(raw_request)
       contents = request.message_contents
 
       response = sync_pb2.ClientToServerResponse()
       response.error_code = sync_pb2.ClientToServerResponse.SUCCESS
       self.CheckStoreBirthday(request)
       response.store_birthday = self.account.store_birthday
       self.CheckTransientError();
+      self.CheckSendError();
 
       print_context('->')
 
       if contents == sync_pb2.ClientToServerMessage.AUTHENTICATE:
         print 'Authenticate'
         # We accept any authentication token, and support only one account.
         # TODO(nick): Mock out the GAIA authentication as well; hook up here.
         response.authenticate.user.email = 'syncjuser@chromium'
         response.authenticate.user.display_name = 'Sync J User'
       elif contents == sync_pb2.ClientToServerMessage.COMMIT:
@@ skipping 18 matching lines @@
           SyncTypeToProtocolDataTypeId(x) for x in error.datatypes]
       return (200, response.SerializeToString())
     except StoreBirthdayError, error:
       print_context('<-')
       print 'NOT_MY_BIRTHDAY'
       response = sync_pb2.ClientToServerResponse()
       response.store_birthday = self.account.store_birthday
       response.error_code = sync_pb2.ClientToServerResponse.NOT_MY_BIRTHDAY
       return (200, response.SerializeToString())
     except TransientError, error:
+      ### This is deprecated now. Would be remvoved once test cases are removed.

[Raghu Simha, 2011/09/22 21:57:41]

This comment still doesn't follow the style guide.

       print_context('<-')
       print 'TRANSIENT_ERROR'
       response.store_birthday = self.account.store_birthday
       response.error_code = sync_pb2.ClientToServerResponse.TRANSIENT_ERROR
       return (200, response.SerializeToString())
+    except SyncInducedError, error:
+      print_context('<-')
+      print 'INDUCED_ERROR'
+      response.store_birthday = self.account.store_birthday
+      error = self.account.GetInducedError()
+      response.error.error_type = error.error_type
+      response.error.url = error.url
+      response.error.error_description = error.error_description
+      response.error.action = error.action
+      return (200, response.SerializeToString())
     finally:
       self.account_lock.release()
 
   def HandleCommit(self, commit_message, commit_response):
     """Respond to a Commit request by updating the user's account state.
 
     Commit attempts stop after the first error, returning a CONFLICT result
     for any unattempted entries.
 
     Args:
@@ skipping 54 matching lines @@
 
     update_sieve.CheckMigrationState()
 
     new_timestamp, entries, remaining = self.account.GetChanges(update_sieve)
 
     update_response.changes_remaining = remaining
     for entry in entries:
       reply = update_response.entries.add()
       reply.CopyFrom(entry)
     update_sieve.SaveProgress(new_timestamp, update_response)