Display DNS probe results.

chrome/browser/net/dns_probe_runner_unittest.cc

+// Copyright (c) 2013 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 "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
+#include "base/run_loop.h"
+#include "chrome/browser/net/dns_probe_runner.h"
+#include "net/dns/dns_client.h"
+#include "net/dns/dns_config_service.h"
+#include "net/dns/dns_protocol.h"
+#include "net/dns/dns_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+using base::MessageLoopForIO;
+using base::RunLoop;
+using net::DnsClient;
+using net::DnsConfig;
+using net::IPAddressNumber;
+using net::IPEndPoint;
+using net::MockDnsClientRule;
+using net::MockDnsClientRuleList;
+using net::ParseIPLiteralToNumber;
+
+class TestDnsProbeRunnerCallback {
+ public:
+  TestDnsProbeRunnerCallback(DnsProbeRunner::Type type);
+  const DnsProbeRunner::ProbeCallback& callback() const;
+  bool called() const;
+  DnsProbeRunner::Result result() const;
+
+ private:
+  void OnCalled(DnsProbeRunner::Type type, DnsProbeRunner::Result result);
+
+  base::WeakPtrFactory<TestDnsProbeRunnerCallback> weak_factory_;
+  DnsProbeRunner::Type type_;
+  DnsProbeRunner::ProbeCallback callback_;
+  bool called_;
+  DnsProbeRunner::Result result_;
+};
+
+TestDnsProbeRunnerCallback::TestDnsProbeRunnerCallback(
+    DnsProbeRunner::Type type)
+    : weak_factory_(this),
+      type_(type),
+      callback_(base::Bind(&TestDnsProbeRunnerCallback::OnCalled,
+                           weak_factory_.GetWeakPtr())),
+      called_(false),
+      result_(DnsProbeRunner::UNKNOWN) {}
+
+const DnsProbeRunner::ProbeCallback&
+    TestDnsProbeRunnerCallback::callback() const {
+  return callback_;
+}
+
+bool TestDnsProbeRunnerCallback::called() const {
+  return called_;
+}
+
+DnsProbeRunner::Result TestDnsProbeRunnerCallback::result() const {
+  DCHECK(called_);
+  return result_;
+}
+
+void TestDnsProbeRunnerCallback::OnCalled(DnsProbeRunner::Type type,
+                                          DnsProbeRunner::Result result) {
+  DCHECK(!called_);
+  EXPECT_EQ(type_, type);
+  called_ = true;
+  result_ = result;
+}
+
+class DnsProbeRunnerTest : public testing::Test {
+ protected:
+  void SetResults(DnsProbeRunner::Result system_result,
+                  DnsProbeRunner::Result public_result);
+  void SetUpClients(MockDnsClientRule::Result system_good_result,
+                    MockDnsClientRule::Result public_good_result);
+  void RunUntilIdle();
+
+  MessageLoopForIO message_loop_;
+  DnsProbeRunner runner_;
+};
+
+void DnsProbeRunnerTest::SetResults(DnsProbeRunner::Result system_result,
+                                    DnsProbeRunner::Result public_result) {
+  runner_.SetResultsForTesting(system_result, public_result);
+}
+
+void DnsProbeRunnerTest::SetUpClients(
+    MockDnsClientRule::Result system_good_result,
+    MockDnsClientRule::Result public_good_result) {
+  DnsConfig config;
+  config.nameservers.clear();
+  IPAddressNumber dns_ip;
+  ParseIPLiteralToNumber("192.168.1.1", &dns_ip);
+  const uint16 kDnsPort = net::dns_protocol::kDefaultPort;
+  config.nameservers.push_back(IPEndPoint(dns_ip, kDnsPort));
+
+  const uint16 kTypeA = net::dns_protocol::kTypeA;
+
+  MockDnsClientRuleList system_rules;
+  system_rules.push_back(
+      MockDnsClientRule("google.com", kTypeA, system_good_result));
+  scoped_ptr<DnsClient> system_client =
+      CreateMockDnsClient(config, system_rules);
+
+  MockDnsClientRuleList public_rules;
+  public_rules.push_back(
+      MockDnsClientRule("google.com", kTypeA, public_good_result));
+  scoped_ptr<DnsClient> public_client =
+      CreateMockDnsClient(config, public_rules);
+
+  runner_.SetClientsForTesting(system_client.Pass(), public_client.Pass());
+}
+
+
+void DnsProbeRunnerTest::RunUntilIdle() {
+  RunLoop run_loop;
+  run_loop.RunUntilIdle();
+}
+
+TEST_F(DnsProbeRunnerTest, Null) {}
+
+TEST_F(DnsProbeRunnerTest, MockResults_Null) {
+  SetResults(DnsProbeRunner::CORRECT, DnsProbeRunner::UNREACHABLE);
+}
+
+TEST_F(DnsProbeRunnerTest, MockResults_Basic) {
+  SetResults(DnsProbeRunner::CORRECT, DnsProbeRunner::UNREACHABLE);
+  {
+    TestDnsProbeRunnerCallback cb(DnsProbeRunner::SYSTEM);
+    runner_.RunProbe(DnsProbeRunner::SYSTEM, cb.callback());
+    RunUntilIdle();
+    EXPECT_TRUE(cb.called());
+    EXPECT_EQ(DnsProbeRunner::CORRECT, cb.result());
+  }
+  {
+    TestDnsProbeRunnerCallback cb(DnsProbeRunner::PUBLIC);
+    runner_.RunProbe(DnsProbeRunner::PUBLIC, cb.callback());
+    RunUntilIdle();
+    EXPECT_TRUE(cb.called());
+    EXPECT_EQ(DnsProbeRunner::UNREACHABLE, cb.result());
+  }
+}
+
+TEST_F(DnsProbeRunnerTest, MockClients_Null) {
+  SetUpClients(MockDnsClientRule::OK, MockDnsClientRule::FAIL_SYNC);
+}
+
+TEST_F(DnsProbeRunnerTest, MockClients_Basic) {
+  SetUpClients(MockDnsClientRule::OK, MockDnsClientRule::FAIL_SYNC);
+  {
+    TestDnsProbeRunnerCallback cb(DnsProbeRunner::SYSTEM);
+    runner_.RunProbe(DnsProbeRunner::SYSTEM, cb.callback());
+    RunUntilIdle();
+    EXPECT_TRUE(cb.called());
+    EXPECT_EQ(DnsProbeRunner::CORRECT, cb.result());
+  }
+  {
+    TestDnsProbeRunnerCallback cb(DnsProbeRunner::PUBLIC);
+    runner_.RunProbe(DnsProbeRunner::PUBLIC, cb.callback());
+    RunUntilIdle();
+    EXPECT_TRUE(cb.called());
+    EXPECT_EQ(DnsProbeRunner::UNREACHABLE, cb.result());
+  }
+}
+
+TEST_F(DnsProbeRunnerTest, MockClients_Parallel) {
+  SetUpClients(MockDnsClientRule::OK, MockDnsClientRule::TIMEOUT);
+
+  TestDnsProbeRunnerCallback system_cb(DnsProbeRunner::SYSTEM);
+  TestDnsProbeRunnerCallback public_cb(DnsProbeRunner::PUBLIC);
+
+  runner_.RunProbe(DnsProbeRunner::SYSTEM, system_cb.callback());
+  runner_.RunProbe(DnsProbeRunner::PUBLIC, public_cb.callback());
+
+  EXPECT_FALSE(system_cb.called());
+  EXPECT_FALSE(public_cb.called());
+
+  RunUntilIdle();
+
+  EXPECT_TRUE(system_cb.called());
+  EXPECT_TRUE(public_cb.called());
+  EXPECT_EQ(DnsProbeRunner::CORRECT, system_cb.result());
+  EXPECT_EQ(DnsProbeRunner::UNREACHABLE, public_cb.result());
+}
+
+}  // namespace