Display DNS probe results.

chrome/browser/net/dns_probe_service_unittest.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/net/dns_probe_service.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/net/dns_probe_job.h"
 #include "chrome/common/net/net_error_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using chrome_common_net::DnsProbeResult;
+using chrome_common_net::DnsProbeStatus;
 
 namespace chrome_browser_net {
 
 namespace {
 
 class MockDnsProbeJob : public DnsProbeJob {
  public:
   MockDnsProbeJob(const CallbackType& callback,
                   DnsProbeJob::Result result)
       : weak_factory_(this) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MockDnsProbeJob::CallCallback,
                    weak_factory_.GetWeakPtr(),
                    callback,
                    result));
   }
 
   virtual ~MockDnsProbeJob() { }
 
  private:
   void CallCallback(const CallbackType& callback, Result result) {
     callback.Run(this, result);
   }
 
   base::WeakPtrFactory<MockDnsProbeJob> weak_factory_;
 };
 
-class TestDnsProbeService : public DnsProbeService {
+class MockDnsProbeJobFactory : public DnsProbeService::JobFactory {
  public:
-  TestDnsProbeService()
-      : DnsProbeService(),
-        system_job_created_(false),
-        public_job_created_(false),
-        mock_system_result_(DnsProbeJob::SERVERS_UNKNOWN),
-        mock_public_result_(DnsProbeJob::SERVERS_UNKNOWN),
-        mock_system_fail_(false) {
+  MockDnsProbeJobFactory()
+    : system_result_(DnsProbeJob::MAX_RESULT),
+      public_result_(DnsProbeJob::MAX_RESULT),
+      system_fail_(false),
+      results_set_(false),
+      system_created_(false),
+      public_created_(false) { }
+
+  virtual scoped_ptr<DnsProbeJob> CreateSystemJob(
+      const DnsProbeJob::CallbackType& job_callback) OVERRIDE {
+    DCHECK(results_set_);
+
+    system_created_ = true;
+
+    if (system_fail_)
+      return scoped_ptr<DnsProbeJob>(NULL);
+
+    return scoped_ptr<DnsProbeJob>(
+        new MockDnsProbeJob(job_callback, system_result_));
   }
 
-  virtual ~TestDnsProbeService() { }
+  virtual scoped_ptr<DnsProbeJob> CreatePublicJob(
+      const DnsProbeJob::CallbackType& job_callback) OVERRIDE {
+    DCHECK(results_set_);
 
-  void set_mock_results(
-      DnsProbeJob::Result mock_system_result,
-      DnsProbeJob::Result mock_public_result) {
-    mock_system_result_ = mock_system_result;
-    mock_public_result_ = mock_public_result;
+    public_created_ = true;
+
+    return scoped_ptr<DnsProbeJob>(
+        new MockDnsProbeJob(job_callback, public_result_));
   }
 
-  void set_mock_system_fail(bool mock_system_fail) {
-    mock_system_fail_ = mock_system_fail;
+  void Reset() {
+    system_created_ = false;
+    public_created_ = false;
   }
 
-  bool jobs_created(void) {
-    return system_job_created_ && public_job_created_;
+  void SetResults(
+      DnsProbeJob::Result system_result,
+      DnsProbeJob::Result public_result,
+      bool system_fail) {
+    system_result_ = system_result;
+    public_result_ = public_result;
+    system_fail_ = system_fail;
+    results_set_ = true;
+    system_created_ = false;
+    public_created_ = false;
   }
 
-  void ResetJobsCreated() {
-    system_job_created_ = false;
-    public_job_created_ = false;
-  }
-
-  void MockExpireResults() {
-    ExpireResults();
-  }
-
-  bool system_job_created_;
-  bool public_job_created_;
+  bool jobs_created() { return system_created_ && public_created_; }
 
  private:
-  // Override methods in DnsProbeService to return mock jobs:
-
-  virtual scoped_ptr<DnsProbeJob> CreateSystemProbeJob(
-      const DnsProbeJob::CallbackType& job_callback) OVERRIDE {
-    if (mock_system_fail_)
-      return scoped_ptr<DnsProbeJob>(NULL);
-
-    system_job_created_ = true;
-    return scoped_ptr<DnsProbeJob>(
-        new MockDnsProbeJob(job_callback,
-                            mock_system_result_));
-  }
-
-  virtual scoped_ptr<DnsProbeJob> CreatePublicProbeJob(
-      const DnsProbeJob::CallbackType& job_callback) OVERRIDE {
-    public_job_created_ = true;
-    return scoped_ptr<DnsProbeJob>(
-        new MockDnsProbeJob(job_callback,
-                            mock_public_result_));
-  }
-
-  DnsProbeJob::Result mock_system_result_;
-  DnsProbeJob::Result mock_public_result_;
-  bool mock_system_fail_;
+  DnsProbeJob::Result system_result_;
+  DnsProbeJob::Result public_result_;
+  bool system_fail_;
+  bool results_set_;
+  bool system_created_;
+  bool public_created_;
 };
 
 class DnsProbeServiceTest : public testing::Test {
  public:
   DnsProbeServiceTest()
       : callback_called_(false),
-        callback_result_(chrome_common_net::DNS_PROBE_UNKNOWN) {
+        callback_result_(chrome_common_net::DNS_PROBE_MAX) {
+    job_factory_ = new MockDnsProbeJobFactory();
+    service_ = DnsProbeService::CreateDefaultWithJobFactory(
+        scoped_ptr<DnsProbeService::JobFactory>(job_factory_));
+  }
+
+  virtual ~DnsProbeServiceTest() {
+    // job_factory_ is owned by service_, which will delete it for us.
+    delete service_;
   }
 
   void Probe() {
-    service_.ProbeDns(base::Bind(&DnsProbeServiceTest::ProbeCallback,
-                                 base::Unretained(this)));
+    service_->ProbeDns(base::Bind(&DnsProbeServiceTest::ProbeCallback,
+                                  base::Unretained(this)));
   }
 
   void RunUntilIdle() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void Reset() {
-    service_.ResetJobsCreated();
     callback_called_ = false;
+    job_factory_->Reset();
   }
 
-  MessageLoopForIO message_loop_;
-  TestDnsProbeService service_;
-  bool callback_called_;
-  DnsProbeResult callback_result_;
+  void SetJobResults(
+      DnsProbeJob::Result system_result,
+      DnsProbeJob::Result public_result,
+      bool system_fail) {
+    job_factory_->SetResults(system_result, public_result, system_fail);
+  }
+
+  void ExpireServiceResult() {
+    service_->ExpireResultForTesting();
+  }
+
+  bool jobs_created() { return job_factory_->jobs_created(); }
+
+  bool callback_called() { return callback_called_; }
+  DnsProbeStatus callback_result() { return callback_result_; }
 
  private:
-  void ProbeCallback(DnsProbeResult result) {
+  void ProbeCallback(DnsProbeStatus result) {
     callback_called_ = true;
     callback_result_ = result;
   }
+
+  // Owned by service_.
+  MockDnsProbeJobFactory* job_factory_;
+  DnsProbeService* service_;
+  bool callback_called_;
+  DnsProbeStatus callback_result_;
+  MessageLoopForIO message_loop_;
 };
 
 TEST_F(DnsProbeServiceTest, Null) {
 }
 
 TEST_F(DnsProbeServiceTest, Probe) {
-  service_.set_mock_results(DnsProbeJob::SERVERS_CORRECT,
-                            DnsProbeJob::SERVERS_CORRECT);
+  SetJobResults(DnsProbeJob::SERVERS_CORRECT,
+                DnsProbeJob::SERVERS_CORRECT,
+                false);
 
   Probe();
-  EXPECT_TRUE(service_.jobs_created());
-  EXPECT_FALSE(callback_called_);
+  EXPECT_TRUE(jobs_created());
+  EXPECT_FALSE(callback_called());
 
   RunUntilIdle();
-  EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(chrome_common_net::DNS_PROBE_NXDOMAIN, callback_result_);
+  EXPECT_TRUE(callback_called());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, callback_result());
 }
 
 TEST_F(DnsProbeServiceTest, Cache) {
-  service_.set_mock_results(DnsProbeJob::SERVERS_CORRECT,
-                            DnsProbeJob::SERVERS_CORRECT);
+  SetJobResults(DnsProbeJob::SERVERS_CORRECT,
+                DnsProbeJob::SERVERS_CORRECT,
+                false);
 
   Probe();
   RunUntilIdle();
-  Reset();
 
   // Cached NXDOMAIN result should persist.
 
+  Reset();
+
   Probe();
-  EXPECT_FALSE(service_.jobs_created());
+  EXPECT_FALSE(jobs_created());
 
   RunUntilIdle();
-  EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(chrome_common_net::DNS_PROBE_NXDOMAIN, callback_result_);
+  EXPECT_TRUE(callback_called());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, callback_result());
 }
 
 TEST_F(DnsProbeServiceTest, Expired) {
-  service_.set_mock_results(DnsProbeJob::SERVERS_CORRECT,
-                            DnsProbeJob::SERVERS_CORRECT);
+  SetJobResults(DnsProbeJob::SERVERS_CORRECT,
+                DnsProbeJob::SERVERS_CORRECT,
+                false);
 
   Probe();
-  EXPECT_TRUE(service_.jobs_created());
+  EXPECT_TRUE(jobs_created());
 
   RunUntilIdle();
-  EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(chrome_common_net::DNS_PROBE_NXDOMAIN, callback_result_);
+  EXPECT_TRUE(callback_called());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, callback_result());
 
+  ExpireServiceResult();
   Reset();
 
-  service_.MockExpireResults();
-
   Probe();
-  EXPECT_TRUE(service_.jobs_created());
+  EXPECT_TRUE(jobs_created());
 
   RunUntilIdle();
-  EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(chrome_common_net::DNS_PROBE_NXDOMAIN, callback_result_);
+  EXPECT_TRUE(callback_called());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, callback_result());
 }
 
 TEST_F(DnsProbeServiceTest, SystemFail) {
-  service_.set_mock_results(DnsProbeJob::SERVERS_CORRECT,
-                            DnsProbeJob::SERVERS_CORRECT);
-  service_.set_mock_system_fail(true);
+  SetJobResults(DnsProbeJob::SERVERS_CORRECT,
+                DnsProbeJob::SERVERS_CORRECT,
+                true);
 
   Probe();
-  EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(chrome_common_net::DNS_PROBE_UNKNOWN, callback_result_);
+  EXPECT_TRUE(callback_called());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_UNKNOWN, callback_result());
 
   Reset();
 
   RunUntilIdle();
-  EXPECT_FALSE(callback_called_);
+  EXPECT_FALSE(callback_called());
 }
 
 }  // namespace
 
 }  // namespace chrome_browser_net