Basic implementation of the Sync C++ fake server

chrome/browser/sync/test/integration/sync_test.cc

 // 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.
 
 #include "chrome/browser/sync/test/integration/sync_test.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/engine/sync_scheduler_impl.h"
+#include "sync/internal_api/public/test/fake_server.h"
+#include "sync/internal_api/public/test/fake_server_network_resources.h"
 #include "sync/notifier/p2p_invalidator.h"
 #include "sync/protocol/sync.pb.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using invalidation::InvalidationServiceFactory;
 
 namespace switches {
 const char kPasswordFileForTest[] = "password-file-for-test";
 const char kSyncUserForTest[] = "sync-user-for-test";
@@ skipping 65 matching lines @@
     ReadPasswordFile();
   } else if (cl->HasSwitch(switches::kSyncUserForTest) &&
              cl->HasSwitch(switches::kSyncPasswordForTest)) {
     username_ = cl->GetSwitchValueASCII(switches::kSyncUserForTest);
     password_ = cl->GetSwitchValueASCII(switches::kSyncPasswordForTest);
   } else {
     username_ = "user@gmail.com";
     password_ = "password";
   }
 
-  if (!cl->HasSwitch(switches::kSyncServiceURL) &&
-      !cl->HasSwitch(switches::kSyncServerCommandLine)) {
-    // If neither a sync server URL nor a sync server command line is
-    // provided, start up a local python sync test server and point Chrome
-    // to its URL.  This is the most common configuration, and the only
-    // one that makes sense for most developers.
-    server_type_ = LOCAL_PYTHON_SERVER;
-  } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
-             cl->HasSwitch(switches::kSyncServerCommandLine)) {
-    // If a sync server URL and a sync server command line are provided,
-    // start up a local sync server by running the command line. Chrome
-    // will connect to the server at the URL that was provided.
-    server_type_ = LOCAL_LIVE_SERVER;
-  } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
-             !cl->HasSwitch(switches::kSyncServerCommandLine)) {
-    // If a sync server URL is provided, but not a server command line,
-    // it is assumed that the server is already running. Chrome will
-    // automatically connect to it at the URL provided. There is nothing
-    // to do here.
-    server_type_ = EXTERNAL_LIVE_SERVER;
-  } else {
-    // If a sync server command line is provided, but not a server URL,
-    // we flag an error.
-    LOG(FATAL) << "Can't figure out how to run a server.";
+  // Only set |server_type_| if it hasn't already been set. This allows for
+  // FAKE_SERVER tests to set this value in each test class.
+  if (server_type_ == SERVER_TYPE_UNDECIDED) {
+    if (!cl->HasSwitch(switches::kSyncServiceURL) &&
+        !cl->HasSwitch(switches::kSyncServerCommandLine)) {
+      // If neither a sync server URL nor a sync server command line is
+      // provided, start up a local python sync test server and point Chrome
+      // to its URL.  This is the most common configuration, and the only
+      // one that makes sense for most developers.
+      server_type_ = LOCAL_PYTHON_SERVER;
+    } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
+               cl->HasSwitch(switches::kSyncServerCommandLine)) {
+      // If a sync server URL and a sync server command line are provided,
+      // start up a local sync server by running the command line. Chrome
+      // will connect to the server at the URL that was provided.
+      server_type_ = LOCAL_LIVE_SERVER;
+    } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
+               !cl->HasSwitch(switches::kSyncServerCommandLine)) {
+      // If a sync server URL is provided, but not a server command line,
+      // it is assumed that the server is already running. Chrome will
+      // automatically connect to it at the URL provided. There is nothing
+      // to do here.
+      server_type_ = EXTERNAL_LIVE_SERVER;
+    } else {
+      // If a sync server command line is provided, but not a server URL,
+      // we flag an error.
+      LOG(FATAL) << "Can't figure out how to run a server.";
+    }
   }
 
   if (username_.empty() || password_.empty())
     LOG(FATAL) << "Cannot run sync tests without GAIA credentials.";
 
   // Mock the Mac Keychain service.  The real Keychain can block on user input.
 #if defined(OS_MACOSX)
   Encryptor::UseMockKeychain(true);
 #endif
 
@@ skipping 129 matching lines @@
                                           << index << ".";
 
   invalidation::P2PInvalidationService* p2p_invalidation_service =
       InvalidationServiceFactory::GetInstance()->
           BuildAndUseP2PInvalidationServiceForTest(GetProfile(index));
   p2p_invalidation_service->UpdateCredentials(username_, password_);
 
   // Make sure the ProfileSyncService has been created before creating the
   // ProfileSyncServiceHarness - some tests expect the ProfileSyncService to
   // already exist.
-  ProfileSyncServiceFactory::GetForProfile(GetProfile(index));
+  ProfileSyncService* profile_sync_service =
+      ProfileSyncServiceFactory::GetForProfile(GetProfile(index));
+
+  if (server_type_ == FAKE_SERVER) {
+    profile_sync_service->OverrideNetworkResourcesForTest(
+        make_scoped_ptr<syncer::NetworkResources>(
+            new syncer::FakeServerNetworkResources(fake_server_.get())));
+  }
 
   clients_[index] =
       ProfileSyncServiceHarness::CreateForIntegrationTest(
           GetProfile(index),
           username_,
           password_,
           p2p_invalidation_service);
   EXPECT_FALSE(GetClient(index) == NULL) << "Could not create Client "
                                          << index << ".";
 
@@ skipping 165 matching lines @@
   if (server_type_ == LOCAL_PYTHON_SERVER) {
     if (!SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python sync and XMPP servers";
     SetupMockGaiaResponses();
   } else if (server_type_ == LOCAL_LIVE_SERVER) {
     // Using mock gaia credentials requires the use of a mock XMPP server.
     if (username_ == "user@gmail.com" && !SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python XMPP server";
     if (!SetUpLocalTestServer())
       LOG(FATAL) << "Failed to set up local test server";
+  } else if (server_type_ == FAKE_SERVER) {
+    fake_server_.reset(new syncer::FakeServer());
+    if (!fake_server_->Init())
+      LOG(FATAL) << "Failed to initialize fake server.";
+    // Similar to LOCAL_LIVE_SERVER, we must start this for XMPP.
+    SetUpLocalPythonTestServer();
+    SetupMockGaiaResponses();
   } else if (server_type_ == EXTERNAL_LIVE_SERVER) {
     // Nothing to do; we'll just talk to the URL we were given.
   } else {
     LOG(FATAL) << "Don't know which server environment to run test in.";
   }
 }
 
 bool SyncTest::SetUpLocalPythonTestServer() {
   EXPECT_TRUE(sync_server_.Start())
       << "Could not launch local python test server.";
@@ skipping 333 matching lines @@
 
 void SyncTest::SetProxyConfig(net::URLRequestContextGetter* context_getter,
                               const net::ProxyConfig& proxy_config) {
   base::WaitableEvent done(false, false);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SetProxyConfigCallback, &done,
                  make_scoped_refptr(context_getter), proxy_config));
   done.Wait();
 }
+
+void SyncTest::UseFakeServer() {
+  server_type_ = FAKE_SERVER;

[rlarocque, 2013/12/18 20:22:01]

Can you somehow DCHECK that SetUp() hasn't been called yet?  Maybe
DCHECK_EQ(SERVER_TYPE_UNDECIDED, server_type_) would do the trick?

[pval...(no longer on Chromium), 2013/12/19 01:16:56]

Great idea. Thanks.

+}