Simple offline startup integration test.

net/tools/testserver/chromiumsync.py

 #!/usr/bin/python2.4
 # Copyright (c) 2010 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 574 matching lines @@
 
   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):
     # The implementation supports exactly one account; its state is here.
     self.account = SyncDataModel()
     self.account_lock = threading.Lock()
+    self.account_user_email = 'syncjuser@chromium.org'
+
+  def HandleConfigure(self, config):
+    """Handles various test configuration parameters sent from the client.
+
+    Args:
+      config: Dictionary of configuration parameters.
+    Returns:
+      True if configuration was successful.
+    """
+    if config.has_key('user_email'):
+      self.account_user_email = config['user_email'][0]
+    return True
 
   def HandleCommand(self, raw_request):
     """Decode and handle a sync command from a raw input of bytes.
 
     This is the main entry point for this class.  It is safe to call this
     method from multiple threads.
 
     Args:
       raw_request: An iterable byte sequence to be interpreted as a sync
         protocol command.
     Returns:
       A tuple (response_code, raw_response); the first value is an HTTP
       result code, while the second value is a string of bytes which is the
       serialized reply to the command.
     """
     self.account_lock.acquire()
     try:
       request = sync_pb2.ClientToServerMessage()
       request.MergeFromString(raw_request)
       contents = request.message_contents
 
       response = sync_pb2.ClientToServerResponse()
       response.error_code = sync_pb2.ClientToServerResponse.SUCCESS
       response.store_birthday = self.account.store_birthday
 
       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.email = self.account_user_email
         response.authenticate.user.display_name = 'Sync J User'
       elif contents == sync_pb2.ClientToServerMessage.COMMIT:
         print 'Commit'
         self.HandleCommit(request.commit, response.commit)
       elif contents == sync_pb2.ClientToServerMessage.GET_UPDATES:
         print ('GetUpdates from timestamp %d' %
             request.get_updates.from_timestamp)
         self.HandleGetUpdates(request.get_updates, response.get_updates)
       return (200, response.SerializeToString())
     finally:
@@ skipping 57 matching lines @@
     new_timestamp, entries = self.account.GetChangesFromTimestamp(
         requested_types, update_request.from_timestamp)
 
     # If the client is up to date, we are careful not to set the
     # new_timestamp field.
     if new_timestamp != update_request.from_timestamp:
       update_response.new_timestamp = new_timestamp
       for e in entries:
         reply = update_response.entries.add()
         reply.CopyFrom(e)