renderer/net/net_error_helper_unittest.cc

// Copyright 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 "chrome/renderer/net/net_error_helper.h"

#include "base/logging.h"
#include "chrome/common/net/net_error_info.h"
#include "testing/gtest/include/gtest/gtest.h"

using chrome_common_net::DnsProbeStatus;
using chrome_common_net::DnsProbeStatusToString;

// NetErrorHelperTest cases consist of a string of these steps.
enum TestStep {
  // Simulate a provisional load start, fail, commit or a finish-load event.
  // (Start and fail differentiate between normal and error pages.)
  LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START,
  LOAD_COMMIT, LOAD_FINISH,

  // Simulate an IPC from the browser with DNS_PROBE_STARTED, _NOT_RUN, or
  // _FINISHED_NXDOMAIN.
  STATUS_STARTED, STATUS_NOT_RUN, STATUS_FINISHED,

  // Expect that the *next* step will cause an update.  (Any step that is not
  // prefixed by this pseudo-step is expected *not* to cause an update.)
  EXPECT_UPDATE
};

class TestNetErrorHelper : public NetErrorHelper {
 public:
  TestNetErrorHelper()
      : NetErrorHelper(NULL),
        mock_page_update_count_(0),
        mock_displayed_probe_status_(chrome_common_net::DNS_PROBE_MAX) {}

  virtual ~TestNetErrorHelper() {}

  void StartLoad(bool is_main_frame, bool is_error_page) {
    OnStartLoad(is_main_frame, is_error_page);
  }

  void FailLoad(bool is_main_frame, bool is_dns_error) {
    OnFailLoad(is_main_frame, is_dns_error);
  }

  void CommitLoad(bool is_main_frame) {
    OnCommitLoad(is_main_frame);
  }

  void FinishLoad(bool is_main_frame) {
    OnFinishLoad(is_main_frame);
  }

  void ReceiveProbeStatus(DnsProbeStatus status) {
    OnNetErrorInfo(static_cast<int>(status));
  }

  int mock_page_update_count() const { return mock_page_update_count_;  }
  DnsProbeStatus mock_displayed_probe_status() const {
    return mock_displayed_probe_status_;
  }

 protected:
  virtual void UpdateErrorPage() OVERRIDE {
    DVLOG(1) << "Updating error page with status "
             << DnsProbeStatusToString(last_probe_status_);
    mock_page_update_count_++;
    mock_displayed_probe_status_ = last_probe_status_;
  }

 private:
  int mock_page_update_count_;
  DnsProbeStatus mock_displayed_probe_status_;
};

class NetErrorHelperTest : public testing::Test {
 protected:
  enum MainFrame { SUB_FRAME, MAIN_FRAME };
  enum ErrorPage { NORMAL_PAGE, ERROR_PAGE };
  enum ErrorType { OTHER_ERROR, DNS_ERROR };

  void StartLoad(MainFrame main_frame, ErrorPage error_page) {
    helper_.StartLoad(main_frame == MAIN_FRAME, error_page == ERROR_PAGE);
  }

  void FailLoad(MainFrame main_frame, ErrorType error_type) {
    helper_.FailLoad(main_frame == MAIN_FRAME, error_type == DNS_ERROR);
  }

  void CommitLoad(MainFrame main_frame) {
    helper_.CommitLoad(main_frame == MAIN_FRAME);
  }

  void FinishLoad(MainFrame main_frame) {
    helper_.FinishLoad(main_frame == MAIN_FRAME);
  }

  void ReceiveProbeStatus(DnsProbeStatus status) {
    helper_.ReceiveProbeStatus(status);
  }

  void RunTest(const TestStep steps[], int step_count);

  int page_update_count() const { return helper_.mock_page_update_count(); }
  DnsProbeStatus displayed_probe_status() const {
    return helper_.mock_displayed_probe_status();
  }

 private:
  TestNetErrorHelper helper_;
};

void NetErrorHelperTest::RunTest(const TestStep steps[], int step_count) {
  // Whether the next instruction is expected to cause an update (since the
  // step right before it was EXPECT_UPDATE) or not.
  bool update_expected = false;
  int expected_update_count = page_update_count();
  // The last status that the test simulated receiving from the browser.
  // When an update is expected, the status is expected to match this.
  chrome_common_net::DnsProbeStatus last_status_received =
      chrome_common_net::DNS_PROBE_POSSIBLE;

  for (int i = 0; i < step_count; i++) {
    switch (steps[i]) {
    case LOAD_NORMAL_START:
      StartLoad(MAIN_FRAME, NORMAL_PAGE);
      break;
    case LOAD_NORMAL_FAIL:
      FailLoad(MAIN_FRAME, DNS_ERROR);
      break;
    case LOAD_ERROR_START:
      StartLoad(MAIN_FRAME, ERROR_PAGE);
      break;
    case LOAD_COMMIT:
      CommitLoad(MAIN_FRAME);
      break;
    case LOAD_FINISH:
      FinishLoad(MAIN_FRAME);
      break;
    case STATUS_STARTED:
      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_STARTED);
      last_status_received = chrome_common_net::DNS_PROBE_STARTED;
      break;
    case STATUS_NOT_RUN:
      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_NOT_RUN);
      last_status_received = chrome_common_net::DNS_PROBE_NOT_RUN;
      break;
    case STATUS_FINISHED:
      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
      last_status_received = chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN;
      break;
    case EXPECT_UPDATE:
      ASSERT_FALSE(update_expected);
      update_expected = true;
      // Skip to next step to see if it updates the status, instead of
      // checking whether EXPECT_UPDATE itself caused an update.
      continue;
    }

    if (update_expected) {
      DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, last_status_received);
      ++expected_update_count;

      EXPECT_EQ(last_status_received, displayed_probe_status());
      if (displayed_probe_status() != last_status_received) {
        LOG(ERROR) << "Unexpected status at step " << i << ".";
        return;
      }
    }

    EXPECT_EQ(expected_update_count, page_update_count());
    if (page_update_count() != expected_update_count) {
      LOG(ERROR) << (update_expected ? "Missing" : "Spurious")
                 << " update at step " << i << ".";
      return;
    }

    update_expected = false;
  }

  DCHECK(!update_expected);
}

TEST_F(NetErrorHelperTest, Null) {
  // Test that we can simply create and destroy a NetErrorHelper.
}

TEST_F(NetErrorHelperTest, SuccessfulPageLoad) {
  StartLoad(MAIN_FRAME, NORMAL_PAGE);
  CommitLoad(MAIN_FRAME);
  FinishLoad(MAIN_FRAME);

  // Ignore spurious status.
  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
  EXPECT_EQ(0, page_update_count());
}

TEST_F(NetErrorHelperTest, MainFrameNonDnsError) {
  StartLoad(MAIN_FRAME, NORMAL_PAGE);
  FailLoad(MAIN_FRAME, OTHER_ERROR);
  StartLoad(MAIN_FRAME, ERROR_PAGE);
  CommitLoad(MAIN_FRAME);
  FinishLoad(MAIN_FRAME);

  // Ignore spurious status.
  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
  EXPECT_EQ(0, page_update_count());
}

TEST_F(NetErrorHelperTest, SubFrameDnsError) {
  StartLoad(SUB_FRAME, NORMAL_PAGE);
  FailLoad(SUB_FRAME, DNS_ERROR);
  StartLoad(SUB_FRAME, ERROR_PAGE);
  CommitLoad(SUB_FRAME);
  FinishLoad(SUB_FRAME);

  // Ignore spurious status.
  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
  EXPECT_EQ(0, page_update_count());
}

TEST_F(NetErrorHelperTest, FinishedAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_FINISHED, LOAD_ERROR_START,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFail_StartedAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, STATUS_FINISHED,
    LOAD_ERROR_START, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_FINISHED,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterStart_StartedAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterStart_StartedAfterStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterCommit) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    LOAD_COMMIT, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_STARTED,
    LOAD_ERROR_START, LOAD_COMMIT, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterCommit) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    STATUS_STARTED, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFinish) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_STARTED,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterCommit) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    STATUS_STARTED, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterFinish) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, EXPECT_UPDATE, STATUS_STARTED, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterNewStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, LOAD_NORMAL_START, EXPECT_UPDATE, STATUS_FINISHED,
    LOAD_COMMIT, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, NotRunAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_NOT_RUN, LOAD_ERROR_START,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, NotRunAfterStart) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_NOT_RUN,
    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, NotRunAfterCommit) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    STATUS_NOT_RUN, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, NotRunAfterFinish) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, EXPECT_UPDATE, STATUS_NOT_RUN
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterNewCommit) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, LOAD_NORMAL_START, LOAD_COMMIT, STATUS_FINISHED, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

TEST_F(NetErrorHelperTest, FinishedAfterNewFinish) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, LOAD_NORMAL_START, LOAD_COMMIT, LOAD_FINISH, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}

// Two iterations of FinishedAfterStart_StartAfterFail
TEST_F(NetErrorHelperTest, TwoProbes_FinishedAfterStart_StartAfterFail) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH,
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
  };
  RunTest(steps, arraysize(steps));
}

// Two iterations of FinishedAfterFinish
TEST_F(NetErrorHelperTest, TwoProbes_FinishedAfterFinish) {
  const TestStep steps[] = {
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED,
    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
    LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
  };
  RunTest(steps, arraysize(steps));
}