Domain Reliability: Mark beacons from previous networks.

components/domain_reliability/context_unittest.cc

 // Copyright 2014 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/domain_reliability/context.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 21 matching lines @@
   beacon.protocol = "HTTP";
   beacon.http_response_code = 200;
   beacon.elapsed = base::TimeDelta::FromMilliseconds(250);
   beacon.start_time = time->NowTicks() - beacon.elapsed;
   return beacon;
 }
 
 class DomainReliabilityContextTest : public testing::Test {
  protected:
   DomainReliabilityContextTest()
-      : dispatcher_(&time_),
+      : last_network_change_time_(time_.NowTicks()),
+        dispatcher_(&time_),
         params_(MakeTestSchedulerParams()),
         uploader_(base::Bind(&DomainReliabilityContextTest::OnUploadRequest,
                              base::Unretained(this))),
         upload_reporter_string_("test-reporter"),
         context_(&time_,
                  params_,
                  upload_reporter_string_,
+                 &last_network_change_time_,
                  &dispatcher_,
                  &uploader_,
                  MakeTestConfig().Pass()),
-        upload_pending_(false) {}
+        upload_pending_(false) {
+    // Make sure that the last network change does not overlap requests
+    // made in test cases, which start 250ms in the past (see |MakeBeacon|).
+    last_network_change_time_ = time_.NowTicks();
+    time_.Advance(base::TimeDelta::FromSeconds(1));
+  }
 
   TimeDelta min_delay() const { return params_.minimum_upload_delay; }
   TimeDelta max_delay() const { return params_.maximum_upload_delay; }
   TimeDelta retry_interval() const { return params_.upload_retry_interval; }
   TimeDelta zero_delta() const { return TimeDelta::FromMicroseconds(0); }
 
   bool upload_pending() { return upload_pending_; }
 
   const std::string& upload_report() {
     DCHECK(upload_pending_);
@@ skipping 19 matching lines @@
 
   bool CheckCounts(size_t index,
                    unsigned expected_successful,
                    unsigned expected_failed) {
     unsigned successful, failed;
     context_.GetRequestCountsForTesting(index, &successful, &failed);
     return successful == expected_successful && failed == expected_failed;
   }
 
   MockTime time_;
+  base::TimeTicks last_network_change_time_;
   DomainReliabilityDispatcher dispatcher_;
   DomainReliabilityScheduler::Params params_;
   MockUploader uploader_;
   std::string upload_reporter_string_;
   DomainReliabilityContext context_;
 
  private:
   void OnUploadRequest(
       const std::string& report_json,
       const GURL& upload_url,
@@ skipping 76 matching lines @@
   EXPECT_TRUE(upload_pending());
   EXPECT_EQ(kExpectedReport, upload_report());
   EXPECT_EQ(GURL("https://exampleuploader/upload"), upload_url());
   CallUploadCallback(true);
 
   EXPECT_TRUE(CheckNoBeacons());
   EXPECT_TRUE(CheckCounts(0, 0, 0));
   EXPECT_TRUE(CheckCounts(1, 0, 0));
 }
 
+TEST_F(DomainReliabilityContextTest, ReportUpload_NetworkChanged) {
+  GURL url("http://example/always_report");
+  DomainReliabilityBeacon beacon = MakeBeacon(&time_);
+  context_.OnBeacon(url, beacon);
+
+  BeaconVector beacons;
+  context_.GetQueuedBeaconsForTesting(&beacons);
+  EXPECT_EQ(1u, beacons.size());
+  EXPECT_TRUE(CheckCounts(0, 1, 0));
+  EXPECT_TRUE(CheckCounts(1, 0, 0));
+
+  // N.B.: Assumes max_delay is 5 minutes.
+  const char* kExpectedReport = "{"
+      "\"config_version\":\"1\","
+      "\"entries\":[{\"domain\":\"localhost\","
+          "\"http_response_code\":200,\"network_changed\":true,"
+          "\"protocol\":\"HTTP\",\"request_age_ms\":300250,"
+          "\"request_elapsed_ms\":250,\"resource\":\"always_report\","
+          "\"server_ip\":\"127.0.0.1\",\"status\":\"ok\"}],"
+      "\"reporter\":\"test-reporter\","
+      "\"resources\":[{\"failed_requests\":0,\"name\":\"always_report\","
+          "\"successful_requests\":1}]}";
+
+  // Simulate a network change after the request but before the upload.
+  last_network_change_time_ = time_.NowTicks();
+  time_.Advance(max_delay());
+
+  EXPECT_TRUE(upload_pending());
+  EXPECT_EQ(kExpectedReport, upload_report());
+  EXPECT_EQ(GURL("https://exampleuploader/upload"), upload_url());
+  CallUploadCallback(true);
+
+  EXPECT_TRUE(CheckNoBeacons());
+  EXPECT_TRUE(CheckCounts(0, 0, 0));
+  EXPECT_TRUE(CheckCounts(1, 0, 0));
+}
+
 }  // namespace
 }  // namespace domain_reliability