Cleanup and minor refactoring of LogDnsClient

components/certificate_transparency/log_dns_client_unittest.cc

 // Copyright 2016 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 "components/certificate_transparency/log_dns_client.h"
 
 #include <memory>
 #include <numeric>
 #include <string>
 #include <utility>
@@ skipping 271 matching lines @@
 
     ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
         base::StringPrintf("%zu.123456.999999.tree.ct.test.", nodes_begin),
         audit_proof.begin() + nodes_begin, audit_proof.begin() + nodes_end));
   }
 
   net::ct::MerkleAuditProof proof;
   ASSERT_THAT(QueryAuditProof("ct.test", kLeafHashes[0], 999999, &proof),
               IsOk());
   EXPECT_THAT(proof.leaf_index, Eq(123456u));
-  // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-  // EXPECT_THAT(proof.tree_size, Eq(999999));
+  EXPECT_THAT(proof.tree_size, Eq(999999u));
   EXPECT_THAT(proof.nodes, Eq(audit_proof));
 }
 
 TEST_P(LogDnsClientTest, QueryAuditProofHandlesResponsesWithShortAuditPaths) {
   const std::vector<std::string> audit_proof = GetSampleAuditProof(20);
 
   // Expect a leaf index query first, to map the leaf hash to a leaf index.
   ASSERT_TRUE(
       mock_dns_.ExpectLeafIndexRequestAndResponse(kLeafIndexQnames[0], 123456));
 
@@ skipping 14 matching lines @@
       "10.123456.999999.tree.ct.test.", audit_proof.begin() + 10,
       audit_proof.begin() + 13));
   ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
       "13.123456.999999.tree.ct.test.", audit_proof.begin() + 13,
       audit_proof.end()));
 
   net::ct::MerkleAuditProof proof;
   ASSERT_THAT(QueryAuditProof("ct.test", kLeafHashes[0], 999999, &proof),
               IsOk());
   EXPECT_THAT(proof.leaf_index, Eq(123456u));
-  // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-  // EXPECT_THAT(proof.tree_size, Eq(999999));
+  EXPECT_THAT(proof.tree_size, Eq(999999u));
   EXPECT_THAT(proof.nodes, Eq(audit_proof));
 }
 
 TEST_P(LogDnsClientTest,
        QueryAuditProofReportsThatAuditProofQnameDoesNotExist) {
   ASSERT_TRUE(
       mock_dns_.ExpectLeafIndexRequestAndResponse(kLeafIndexQnames[0], 123456));
   ASSERT_TRUE(mock_dns_.ExpectRequestAndErrorResponse(
       "0.123456.999999.tree.ct.test.", net::dns_protocol::kRcodeNXDOMAIN));
 
@@ skipping 223 matching lines @@
   config.attempts = 123;
   mock_dns_.SetDnsConfig(config);
   // The new config is distributed asynchronously via NetworkChangeNotifier.
   // Config change shouldn't have taken effect yet.
   ASSERT_NE(123, dns_client->GetConfig()->attempts);
 
   // Wait for the query to complete, then check that it was successful.
   // The DNS config should be updated during this time.
   ASSERT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_THAT(proof.leaf_index, Eq(123456u));
-  // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-  // EXPECT_THAT(proof.tree_size, Eq(999999));
+  EXPECT_THAT(proof.tree_size, Eq(999999u));
   EXPECT_THAT(proof.nodes, Eq(audit_proof));
 
   // Check that the DNS config change was adopted.
   ASSERT_EQ(123, dns_client->GetConfig()->attempts);
 }
 
 TEST_P(LogDnsClientTest, CanPerformQueriesInParallel) {
   // Check that 3 queries can be performed in parallel.
   constexpr size_t kNumOfParallelQueries = 3;
   ASSERT_THAT(kNumOfParallelQueries,
@@ skipping 62 matching lines @@
         << "query #" << i;
   }
 
   // Wait for each query to complete and check its results.
   for (size_t i = 0; i < kNumOfParallelQueries; ++i) {
     net::TestCompletionCallback& callback = callbacks[i];
 
     SCOPED_TRACE(testing::Message() << "callbacks[" << i << "]");
     EXPECT_THAT(callback.WaitForResult(), IsOk());
     EXPECT_THAT(proofs[i].leaf_index, Eq(kLeafIndices[i]));
-    // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-    // EXPECT_THAT(proofs[i].tree_size, kTreeSizes[i]);
+    EXPECT_THAT(proofs[i].tree_size, Eq(kTreeSizes[i]));
     EXPECT_THAT(proofs[i].nodes, Eq(audit_proofs[i]));
   }
 }
 
 TEST_P(LogDnsClientTest, CanBeThrottledToOneQueryAtATime) {
   // Check that queries can be rate-limited to one at a time.
   // The second query, initiated while the first is in progress, should fail.
   const std::vector<std::string> audit_proof = GetSampleAuditProof(20);
 
   // Expect the first query to send leaf index and audit proof requests, but the
@@ skipping 28 matching lines @@
 
   net::ct::MerkleAuditProof proof2;
   net::TestCompletionCallback callback2;
   ASSERT_THAT(log_client->QueryAuditProof("ct.test", kLeafHashes[1], 999999,
                                           &proof2, callback2.callback()),
               IsError(net::ERR_TEMPORARILY_THROTTLED));
 
   // Check that the first query succeeded.
   EXPECT_THAT(callback1.WaitForResult(), IsOk());
   EXPECT_THAT(proof1.leaf_index, Eq(123456u));
-  // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-  // EXPECT_THAT(proof1.tree_size, Eq(999999));
+  EXPECT_THAT(proof1.tree_size, Eq(999999u));
   EXPECT_THAT(proof1.nodes, Eq(audit_proof));
 
   // Try a third query, which should succeed now that the first is finished.
   ASSERT_TRUE(
       mock_dns_.ExpectLeafIndexRequestAndResponse(kLeafIndexQnames[2], 666));
   ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
       "0.666.999999.tree.ct.test.", audit_proof.begin(),
       audit_proof.begin() + 7));
   ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
       "7.666.999999.tree.ct.test.", audit_proof.begin() + 7,
       audit_proof.begin() + 14));
   ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
       "14.666.999999.tree.ct.test.", audit_proof.begin() + 14,
       audit_proof.end()));
 
   net::ct::MerkleAuditProof proof3;
   net::TestCompletionCallback callback3;
   ASSERT_THAT(log_client->QueryAuditProof("ct.test", kLeafHashes[2], 999999,
                                           &proof3, callback3.callback()),
               IsError(net::ERR_IO_PENDING));
 
   // Check that the third query succeeded.
   EXPECT_THAT(callback3.WaitForResult(), IsOk());
   EXPECT_THAT(proof3.leaf_index, Eq(666u));
-  // TODO(robpercival): Enable this once MerkleAuditProof has tree_size.
-  // EXPECT_THAT(proof3.tree_size, Eq(999999));
+  EXPECT_THAT(proof3.tree_size, Eq(999999u));
   EXPECT_THAT(proof3.nodes, Eq(audit_proof));
 }
 
 TEST_P(LogDnsClientTest, NotifiesWhenNoLongerThrottled) {
   const std::vector<std::string> audit_proof = GetSampleAuditProof(20);
 
   ASSERT_TRUE(
       mock_dns_.ExpectLeafIndexRequestAndResponse(kLeafIndexQnames[0], 123456));
   ASSERT_TRUE(mock_dns_.ExpectAuditProofRequestAndResponse(
       "0.123456.999999.tree.ct.test.", audit_proof.begin(),
@@ skipping 47 matching lines @@
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(not_throttled_callback.have_result());
 }
 
 INSTANTIATE_TEST_CASE_P(ReadMode,
                         LogDnsClientTest,
                         ::testing::Values(net::IoMode::ASYNC,
                                           net::IoMode::SYNCHRONOUS));
 
 }  // namespace certificate_transparency