Reland r140188: CommandLine Page Cycler

chrome/browser/page_cycler/page_cycler_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 "base/file_util.h"
+#include "base/path_service.h"
+#include "base/string_split.h"
+#include "base/string_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/page_cycler/page_cycler.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/url_constants.h"
+#include "chrome/test/base/browser_with_test_window_test.h"
+#include "chrome/test/base/testing_pref_service.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/test/test_browser_thread.h"
+#include "net/base/net_errors.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Invoke;
+using content::RenderViewHost;
+using content::TestBrowserThread;
+using content::WebContentsObserver;
+using file_util::ContentsEqual;
+using file_util::PathExists;
+
+namespace {
+const int kFrameID = 1;
+const bool kIsMainFrame = true;
+const GURL kAboutURL = GURL(chrome::kAboutBlankURL);
+const int kSingleIteration = 1;
+}  // namespace
+
+class MockPageCycler : public PageCycler {
+ public:
+  MockPageCycler(Browser* browser, FilePath urls_file, FilePath errors_file)
+      : PageCycler(browser, urls_file) {
+    set_errors_file(errors_file);
+  }
+
+  MockPageCycler(Browser* browser,
+                 FilePath urls_file,
+                 FilePath errors_file,
+                 FilePath stats_file)
+      : PageCycler(browser, urls_file) {
+    set_stats_file(stats_file);
+    set_errors_file(errors_file);
+  }
+
+  MOCK_METHOD3(DidFinishLoad, void(int64 frame_id,
+                                   const GURL& validated_url,
+                                   bool is_main_frame));
+  MOCK_METHOD6(DidFailProvisionalLoad, void(int64 frame_id,
+                                            bool is_main_frame,
+                                            const GURL& validated_url,
+                                            int error_code,
+                                            const string16& error_description,
+                                            RenderViewHost* render_view_host));
+  MOCK_METHOD1(RenderViewGone, void(base::TerminationStatus status));
+
+  void PageCyclerDidFailProvisionalLoad(
+      int64 frame_id,
+      bool is_main_frame,
+      const GURL& validated_url,
+      int error_code,
+      const string16& error_description,
+      RenderViewHost* render_view_host) {
+    PageCycler::DidFailProvisionalLoad(frame_id, is_main_frame,
+                                       validated_url,
+                                       error_code, error_description,
+                                       render_view_host);
+  }
+
+  void PageCyclerDidFinishLoad(int64 frame_id,
+                               const GURL& validated_url,
+                               bool is_main_frame) {
+    PageCycler::DidFinishLoad(frame_id, validated_url, is_main_frame);
+  }
+
+ private:
+
+  // We need to override Finish() because the calls to exit the browser in a
+  // real PageCycler do not work in unittests (they interfere with later tests).
+  virtual void Finish() OVERRIDE {
+    BrowserList::RemoveObserver(this);
+    Release();
+  }
+
+  virtual ~MockPageCycler() {}\
+
+  DISALLOW_COPY_AND_ASSIGN(MockPageCycler);
+};
+
+class PageCyclerTest : public BrowserWithTestWindowTest {
+ public:
+  PageCyclerTest() {
+  }
+
+  virtual ~PageCyclerTest() {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
+    test_data_dir_ = test_data_dir_.AppendASCII("page_cycler");
+
+    BrowserWithTestWindowTest::SetUp();
+    AddTab(browser(), kAboutURL);
+    ASSERT_FALSE(browser()->GetSelectedWebContents() == NULL);
+  }
+
+  void InitFilePaths(const FilePath& temp_path) {
+    errors_file_ = temp_path.AppendASCII("errors_file");
+    stats_file_ = temp_path.AppendASCII("stats_file");
+
+    CHECK(!file_util::PathExists(errors_file_));
+    CHECK(!file_util::PathExists(stats_file_));
+  }
+
+  void FailProvisionalLoad(int error_code, string16& error_description) {
+    FOR_EACH_OBSERVER(
+        WebContentsObserver,
+        observers_,
+        DidFailProvisionalLoad(kFrameID, kIsMainFrame, kAboutURL, error_code,
+                               error_description, NULL));
+    PumpLoop();
+  }
+
+  void FinishLoad() {
+    FOR_EACH_OBSERVER(
+        WebContentsObserver,
+        observers_,
+        DidFinishLoad(kFrameID, kAboutURL, kIsMainFrame));
+    PumpLoop();
+  }
+
+  void RunPageCycler(int total_iterations) {
+    page_cycler_->Run(total_iterations);
+    PumpLoop();
+  }
+
+  void PumpLoop() {
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    message_loop()->RunAllPending();
+  }
+
+  void CloseBrowser() {
+    DestroyBrowser();
+    PumpLoop();
+  }
+
+  MockPageCycler* page_cycler() {
+    return page_cycler_.get();
+  }
+
+  void set_page_cycler(MockPageCycler* page_cycler) {
+    page_cycler_ = page_cycler;
+    observers_.AddObserver(page_cycler);
+  }
+
+  const std::vector<GURL>* urls_for_test() {
+    return page_cycler_->urls_for_test();
+  }
+
+  FilePath stats_file() {
+    return stats_file_;
+  }
+
+  FilePath errors_file() {
+    return errors_file_;
+  }
+
+  FilePath urls_file() {
+    return test_data_dir_.AppendASCII("about_url");
+  }
+
+  FilePath test_data_dir() {
+    return test_data_dir_;
+  }
+
+ private:
+  ObserverList<WebContentsObserver> observers_;
+  scoped_refptr<MockPageCycler> page_cycler_;
+  FilePath test_data_dir_;
+  FilePath stats_file_;
+  FilePath errors_file_;
+  FilePath urls_file_;
+};
+
+TEST_F(PageCyclerTest, FailProvisionalLoads) {
+  const FilePath errors_expected_file =
+      test_data_dir().AppendASCII("errors_expected");
+
+  ScopedTempDir temp;
+  ASSERT_TRUE(temp.CreateUniqueTempDir());
+  InitFilePaths(temp.path());
+
+  ASSERT_TRUE(PathExists(errors_expected_file));
+  ASSERT_TRUE(PathExists(urls_file()));
+
+  set_page_cycler(new MockPageCycler(browser(),
+                                     urls_file(),
+                                     errors_file()));
+  RunPageCycler(kSingleIteration);
+
+  // Page cycler expects browser to automatically start loading the first page.
+  EXPECT_CALL(*page_cycler(), DidFinishLoad(kFrameID, kAboutURL, kIsMainFrame))
+      .WillOnce(Invoke(page_cycler(),
+                       &MockPageCycler::PageCyclerDidFinishLoad));
+  FinishLoad();
+
+  // DNS server fail error message.
+  string16 error_string =
+      string16(ASCIIToUTF16(net::ErrorToString(net::ERR_DNS_SERVER_FAILED)));
+  EXPECT_CALL(*page_cycler(),
+              DidFailProvisionalLoad(kFrameID, kIsMainFrame, _,
+                                     net::ERR_DNS_SERVER_FAILED, error_string,
+                                     _))
+      .WillOnce(Invoke(page_cycler(),
+                       &MockPageCycler::PageCyclerDidFailProvisionalLoad));
+  FailProvisionalLoad(net::ERR_DNS_SERVER_FAILED, error_string);
+
+  // DNS time-out error message.
+  error_string = string16(
+      ASCIIToUTF16(net::ErrorToString(net::ERR_DNS_TIMED_OUT)));
+  EXPECT_CALL(*page_cycler(),
+              DidFailProvisionalLoad(kFrameID,
+                                     kIsMainFrame, _, net::ERR_DNS_TIMED_OUT,
+                                     error_string, _))
+      .WillOnce(Invoke(page_cycler(),
+                       &MockPageCycler::PageCyclerDidFailProvisionalLoad));
+
+  FailProvisionalLoad(net::ERR_DNS_TIMED_OUT, error_string);
+
+  // DNS time-out error message.
+  error_string = string16(
+      ASCIIToUTF16(net::ErrorToString(net::ERR_INVALID_URL)));
+  EXPECT_CALL(*page_cycler(),
+              DidFailProvisionalLoad(kFrameID, kIsMainFrame, _,
+                                     net::ERR_INVALID_URL, error_string, _))
+      .WillOnce(Invoke(page_cycler(),
+                       &MockPageCycler::PageCyclerDidFailProvisionalLoad));
+  FailProvisionalLoad(net::ERR_INVALID_URL, error_string);
+
+  PumpLoop();
+
+  std::string errors_output;
+  std::string errors_expected;
+  ASSERT_TRUE(file_util::ReadFileToString(errors_file(),
+                                          &errors_output));
+  ASSERT_TRUE(file_util::ReadFileToString(errors_expected_file,
+                                          &errors_expected));
+  ASSERT_EQ(errors_output, errors_expected);
+}
+
+TEST_F(PageCyclerTest, StatsFile) {
+  const int kNumLoads = 4;
+
+  ScopedTempDir temp;
+  ASSERT_TRUE(temp.CreateUniqueTempDir());
+  InitFilePaths(temp.path());
+
+  ASSERT_TRUE(PathExists(urls_file()));
+
+  set_page_cycler(new MockPageCycler(browser(), urls_file(),
+                                     errors_file()));
+  page_cycler()->set_stats_file(stats_file());
+  RunPageCycler(kSingleIteration);
+
+  for (int i = 0; i < kNumLoads; ++i) {
+    EXPECT_CALL(*page_cycler(), DidFinishLoad(
+        kFrameID, kAboutURL, kIsMainFrame))
+        .WillOnce(Invoke(page_cycler(),
+                         &MockPageCycler::PageCyclerDidFinishLoad));
+    FinishLoad();
+  }
+
+  PumpLoop();
+  EXPECT_FALSE(PathExists(errors_file()));
+  ASSERT_TRUE(PathExists(stats_file()));
+}
+
+TEST_F(PageCyclerTest, KillBrowserAndAbort) {
+  const FilePath errors_expected_file =
+      test_data_dir().AppendASCII("abort_expected");
+
+  ScopedTempDir temp;
+  ASSERT_TRUE(temp.CreateUniqueTempDir());
+  InitFilePaths(temp.path());
+
+  ASSERT_TRUE(PathExists(errors_expected_file));
+  ASSERT_TRUE(PathExists(urls_file()));
+
+  set_page_cycler(new MockPageCycler(browser(),
+                                     urls_file(),
+                                     errors_file()));
+  RunPageCycler(kSingleIteration);
+
+  EXPECT_CALL(*page_cycler(), DidFinishLoad(kFrameID, kAboutURL, kIsMainFrame))
+      .WillOnce(Invoke(page_cycler(),
+                       &MockPageCycler::PageCyclerDidFinishLoad));
+  message_loop()->RunAllPending();
+
+  FinishLoad();
+
+  CloseBrowser();
+  PumpLoop();
+
+  std::string errors_output;
+  std::string errors_expected;
+  ASSERT_TRUE(file_util::ReadFileToString(errors_file(),
+                                          &errors_output));
+  ASSERT_TRUE(file_util::ReadFileToString(errors_expected_file,
+                                          &errors_expected));
+  ASSERT_EQ(errors_output, errors_expected);
+}
+
+TEST_F(PageCyclerTest, MultipleIterations) {
+  const int kMultipleIterations = 3;
+  const int kNumLoads = 10;
+
+  ScopedTempDir temp;
+  ASSERT_TRUE(temp.CreateUniqueTempDir());
+  InitFilePaths(temp.path());
+
+  ASSERT_TRUE(PathExists(urls_file()));
+
+  set_page_cycler(new MockPageCycler(browser(),
+                                     urls_file(),
+                                     errors_file()));
+  page_cycler()->set_stats_file(stats_file());
+  RunPageCycler(kMultipleIterations);
+
+  EXPECT_CALL(*page_cycler(), DidFinishLoad(kFrameID, kAboutURL, kIsMainFrame))
+      .WillRepeatedly(Invoke(page_cycler(),
+                             &MockPageCycler::PageCyclerDidFinishLoad));
+
+  for (int i = 0; i < kNumLoads; ++i)
+    FinishLoad();
+
+  PumpLoop();
+  EXPECT_FALSE(PathExists(errors_file()));
+  ASSERT_TRUE(PathExists(stats_file()));
+}