chrome/browser/android/offline_pages/offline_page_mhtml_archiver_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
   6
   7 #include "base/bind.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/thread_task_runner_handle.h"
  16 #include "chrome/browser/android/offline_pages/offline_page_web_contents_observer.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace offline_pages {
  20
  21 namespace {
  22
  23 const char kTestURL[] = "http://example.com/";
  24 const base::FilePath::CharType kTestFilePath[] = FILE_PATH_LITERAL(
  25     "/archive_dir/offline_page.mhtml");
  26 const int64 kTestFileSize = 123456LL;
  27
  28 class TestMHTMLArchiver : public OfflinePageMHTMLArchiver {
  29  public:
  30   enum class TestScenario {
  31     SUCCESS,
  32     NOT_ABLE_TO_ARCHIVE,
  33     WEB_CONTENTS_MISSING,
  34   };
  35
  36   TestMHTMLArchiver(
  37       const GURL& url,
  38       const TestScenario test_scenario,
  39       const base::FilePath& archive_dir);
  40   ~TestMHTMLArchiver() override;
  41
  42  private:
  43   void GenerateMHTML() override;
  44
  45   const GURL url_;
  46   const base::FilePath file_path_;
  47   const TestScenario test_scenario_;
  48
  49   DISALLOW_COPY_AND_ASSIGN(TestMHTMLArchiver);
  50 };
  51
  52 TestMHTMLArchiver::TestMHTMLArchiver(
  53     const GURL& url,
  54     const TestScenario test_scenario,
  55     const base::FilePath& archive_dir)
  56     : OfflinePageMHTMLArchiver(archive_dir),
  57       url_(url),
  58       file_path_(archive_dir),
  59       test_scenario_(test_scenario) {
  60 }
  61
  62 TestMHTMLArchiver::~TestMHTMLArchiver() {
  63 }
  64
  65 void TestMHTMLArchiver::GenerateMHTML() {
  66   if (test_scenario_ == TestScenario::WEB_CONTENTS_MISSING) {
  67     ReportFailure(ArchiverResult::ERROR_CONTENT_UNAVAILABLE);
  68     return;
  69   }
  70
  71   if (test_scenario_ == TestScenario::NOT_ABLE_TO_ARCHIVE) {
  72     ReportFailure(ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED);
  73     return;
  74   }
  75
  76   base::ThreadTaskRunnerHandle::Get()->PostTask(
  77       FROM_HERE,
  78       base::Bind(&TestMHTMLArchiver::OnGenerateMHTMLDone,
  79                  base::Unretained(this),
  80                  url_,
  81                  base::FilePath(kTestFilePath),
  82                  kTestFileSize));
  83 }
  84
  85 }  // namespace
  86
  87 class OfflinePageMHTMLArchiverTest : public testing::Test {
  88  public:
  89   OfflinePageMHTMLArchiverTest();
  90   ~OfflinePageMHTMLArchiverTest() override;
  91
  92   // Creates an archiver for testing and specifies a scenario to be used.
  93   scoped_ptr<TestMHTMLArchiver> CreateArchiver(
  94       const GURL& url,
  95       TestMHTMLArchiver::TestScenario scenario);
  96
  97   // Test tooling methods.
  98   void PumpLoop();
  99
 100   base::FilePath GetTestFilePath() const {
 101     return base::FilePath(kTestFilePath);
 102   }
 103
 104   const OfflinePageArchiver* last_archiver() const { return last_archiver_; }
 105   OfflinePageArchiver::ArchiverResult last_result() const {
 106     return last_result_;
 107   }
 108   const base::FilePath& last_file_path() const { return last_file_path_; }
 109   int64 last_file_size() const { return last_file_size_; }
 110
 111   const OfflinePageArchiver::CreateArchiveCallback callback() {
 112     return base::Bind(&OfflinePageMHTMLArchiverTest::OnCreateArchiveDone,
 113                       base::Unretained(this));
 114   }
 115
 116  private:
 117   void OnCreateArchiveDone(OfflinePageArchiver* archiver,
 118                            OfflinePageArchiver::ArchiverResult result,
 119                            const GURL& url,
 120                            const base::FilePath& file_path,
 121                            int64 file_size);
 122
 123   OfflinePageArchiver* last_archiver_;
 124   OfflinePageArchiver::ArchiverResult last_result_;
 125   GURL last_url_;
 126   base::FilePath last_file_path_;
 127   int64 last_file_size_;
 128
 129   base::MessageLoop message_loop_;
 130   scoped_ptr<base::RunLoop> run_loop_;
 131
 132   DISALLOW_COPY_AND_ASSIGN(OfflinePageMHTMLArchiverTest);
 133 };
 134
 135 OfflinePageMHTMLArchiverTest::OfflinePageMHTMLArchiverTest()
 136     : last_archiver_(nullptr),
 137       last_result_(OfflinePageArchiver::ArchiverResult::
 138                        ERROR_ARCHIVE_CREATION_FAILED),
 139       last_file_size_(0L) {
 140 }
 141
 142 OfflinePageMHTMLArchiverTest::~OfflinePageMHTMLArchiverTest() {
 143 }
 144
 145 scoped_ptr<TestMHTMLArchiver> OfflinePageMHTMLArchiverTest::CreateArchiver(
 146     const GURL& url,
 147     TestMHTMLArchiver::TestScenario scenario) {
 148   return scoped_ptr<TestMHTMLArchiver>(
 149       new TestMHTMLArchiver(url, scenario, GetTestFilePath()));
 150 }
 151
 152 void OfflinePageMHTMLArchiverTest::OnCreateArchiveDone(
 153     OfflinePageArchiver* archiver,
 154     OfflinePageArchiver::ArchiverResult result,
 155     const GURL& url,
 156     const base::FilePath& file_path,
 157     int64 file_size) {
 158   if (run_loop_)
 159     run_loop_->Quit();
 160   last_url_ = url;
 161   last_archiver_ = archiver;
 162   last_result_ = result;
 163   last_file_path_ = file_path;
 164   last_file_size_ = file_size;
 165 }
 166
 167 void OfflinePageMHTMLArchiverTest::PumpLoop() {
 168   run_loop_.reset(new base::RunLoop());
 169   run_loop_->Run();
 170 }
 171
 172 // Tests that creation of an archiver fails when web contents is missing.
 173 TEST_F(OfflinePageMHTMLArchiverTest, WebContentsMissing) {
 174   GURL page_url = GURL(kTestURL);
 175   scoped_ptr<TestMHTMLArchiver> archiver(
 176       CreateArchiver(page_url,
 177                      TestMHTMLArchiver::TestScenario::WEB_CONTENTS_MISSING));
 178   archiver->CreateArchive(callback());
 179
 180   EXPECT_EQ(archiver.get(), last_archiver());
 181   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::ERROR_CONTENT_UNAVAILABLE,
 182             last_result());
 183   EXPECT_EQ(base::FilePath(), last_file_path());
 184 }
 185
 186 // Tests for successful creation of the offline page archive.
 187 TEST_F(OfflinePageMHTMLArchiverTest, NotAbleToGenerateArchive) {
 188   GURL page_url = GURL(kTestURL);
 189   scoped_ptr<TestMHTMLArchiver> archiver(
 190       CreateArchiver(page_url,
 191                      TestMHTMLArchiver::TestScenario::NOT_ABLE_TO_ARCHIVE));
 192   archiver->CreateArchive(callback());
 193
 194   EXPECT_EQ(archiver.get(), last_archiver());
 195   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED,
 196             last_result());
 197   EXPECT_EQ(base::FilePath(), last_file_path());
 198   EXPECT_EQ(0LL, last_file_size());
 199 }
 200
 201 // Tests for successful creation of the offline page archive.
 202 TEST_F(OfflinePageMHTMLArchiverTest, SuccessfullyCreateOfflineArchive) {
 203   GURL page_url = GURL(kTestURL);
 204   scoped_ptr<TestMHTMLArchiver> archiver(
 205       CreateArchiver(page_url,
 206                      TestMHTMLArchiver::TestScenario::SUCCESS));
 207   archiver->CreateArchive(callback());
 208   PumpLoop();
 209
 210   EXPECT_EQ(archiver.get(), last_archiver());
 211   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 212             last_result());
 213   EXPECT_EQ(GetTestFilePath(), last_file_path());
 214   EXPECT_EQ(kTestFileSize, last_file_size());
 215 }
 216
 217 }  // namespace offline_pages