Sanitize PrefStore interface.

chrome/browser/net/pref_proxy_config_service_unittest.cc

 // 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.
 
 #include "chrome/browser/net/pref_proxy_config_service.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "chrome/browser/prefs/command_line_pref_store.h"
+#include "chrome/browser/prefs/testing_pref_store.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_pref_service.h"
 #include "net/proxy/proxy_config_service_common_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
@@ skipping 39 matching lines @@
   MOCK_METHOD1(OnProxyConfigChanged, void(const net::ProxyConfig&));
 };
 
 template<typename TESTBASE>
 class PrefProxyConfigServiceTestBase : public TESTBASE {
  protected:
   PrefProxyConfigServiceTestBase()
       : ui_thread_(BrowserThread::UI, &loop_),
         io_thread_(BrowserThread::IO, &loop_) {}
 
-  virtual void SetUp() {
-    ASSERT_TRUE(pref_service_.get());
-    ChromeURLRequestContextGetter::RegisterUserPrefs(pref_service_.get());
+  virtual void Init(PrefService* pref_service) {
+    ASSERT_TRUE(pref_service);
+    ChromeURLRequestContextGetter::RegisterUserPrefs(pref_service);
     fixed_config_.set_pac_url(GURL(kFixedPacUrl));
     delegate_service_ = new TestProxyConfigService(fixed_config_);
-    proxy_config_tracker_ = new PrefProxyConfigTracker(pref_service_.get());
+    proxy_config_tracker_ = new PrefProxyConfigTracker(pref_service);
     proxy_config_service_.reset(
         new PrefProxyConfigService(proxy_config_tracker_.get(),
                                    delegate_service_));
   }
 
   virtual void TearDown() {
     proxy_config_tracker_->DetachFromPrefService();
     loop_.RunAllPending();
     proxy_config_service_.reset();
-    pref_service_.reset();
   }
 
   MessageLoop loop_;
   TestProxyConfigService* delegate_service_; // weak
-  scoped_ptr<TestingPrefService> pref_service_;
   scoped_ptr<PrefProxyConfigService> proxy_config_service_;
   net::ProxyConfig fixed_config_;
 
  private:
   scoped_refptr<PrefProxyConfigTracker> proxy_config_tracker_;
   BrowserThread ui_thread_;
   BrowserThread io_thread_;
 };
 
 class PrefProxyConfigServiceTest
     : public PrefProxyConfigServiceTestBase<testing::Test> {
  protected:
   virtual void SetUp() {
-    pref_service_.reset(new TestingPrefService);
-    PrefProxyConfigServiceTestBase<testing::Test>::SetUp();
+    pref_service_.reset(new TestingPrefService());
+    Init(pref_service_.get());
   }
+
+  scoped_ptr<TestingPrefService> pref_service_;
 };
 
 TEST_F(PrefProxyConfigServiceTest, BaseConfiguration) {
   net::ProxyConfig actual_config;
   proxy_config_service_->GetLatestProxyConfig(&actual_config);
   EXPECT_EQ(GURL(kFixedPacUrl), actual_config.pac_url());
 }
 
 TEST_F(PrefProxyConfigServiceTest, DynamicPrefOverrides) {
   pref_service_->SetManagedPref(
@@ skipping 118 matching lines @@
 
   virtual void SetUp() {
     for (size_t i = 0; i < arraysize(GetParam().switches); i++) {
       const char* name = GetParam().switches[i].name;
       const char* value = GetParam().switches[i].value;
       if (name && value)
         command_line_.AppendSwitchASCII(name, value);
       else if (name)
         command_line_.AppendSwitch(name);
     }
-    pref_service_.reset(new TestingPrefService(NULL, NULL, &command_line_));
-    PrefProxyConfigServiceTestBase<
-        testing::TestWithParam<CommandLineTestParams> >::SetUp();
+    pref_service_.reset(new PrefServiceMock(&command_line_));
+    Init(pref_service_.get());
   }
 
  private:
+  class PrefServiceMock : public PrefService {

[danno, 2010/12/08 13:08:45]

Here it's called a PrefServiceMock, in test_extension_prefs it's a
MockPrefService. Perhaps consistency in names and slightly more descriptive
ones, even if they are in different namespaces?

[Mattias Nissler (ping if slow), 2010/12/09 10:20:20]

Solution: Throw design patterns at it :) I introduced PrefServiceMockBuilder
which solves the problem of creating customized PrefService instances for tests.

+   public:
+    explicit PrefServiceMock(const CommandLine* command_line)
+        : PrefService(NULL,
+                      NULL,
+                      NULL,
+                      new CommandLinePrefStore(command_line),
+                      new TestingPrefStore(),
+                      NULL,
+                      NULL) {}
+  };
+
   CommandLine command_line_;
+  scoped_ptr<PrefServiceMock> pref_service_;
 };
 
 TEST_P(PrefProxyConfigServiceCommandLineTest, CommandLine) {
   net::ProxyConfig config;
   proxy_config_service_->GetLatestProxyConfig(&config);
 
   if (GetParam().is_null) {
     EXPECT_EQ(GURL(kFixedPacUrl), config.pac_url());
   } else {
     EXPECT_NE(GURL(kFixedPacUrl), config.pac_url());
@@ skipping 115 matching lines @@
     net::ProxyRulesExpectation::Empty(),
   },
 };
 
 INSTANTIATE_TEST_CASE_P(
     PrefProxyConfigServiceCommandLineTestInstance,
     PrefProxyConfigServiceCommandLineTest,
     testing::ValuesIn(kCommandLineTestParams));
 
 }  // namespace