chrome/browser/download/download_item_model_unittest.cc

   1 // Copyright (c) 2012 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/download/download_item_model.h"
   6
   7 #include <vector>
   8
   9 #include "base/i18n/rtl.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/string16.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "content/public/test/mock_download_item.h"
  16 #include "extensions/common/extension.h"
  17 #include "grit/generated_resources.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21 #include "ui/base/resource/resource_bundle.h"
  22 #include "ui/base/text/bytes_formatting.h"
  23 #include "ui/gfx/font_list.h"
  24 #include "ui/gfx/text_utils.h"
  25
  26 using content::DownloadItem;
  27 using ::testing::Mock;
  28 using ::testing::NiceMock;
  29 using ::testing::Return;
  30 using ::testing::ReturnRefOfCopy;
  31 using ::testing::SetArgPointee;
  32 using ::testing::_;
  33
  34 namespace {
  35
  36 // Create a char array that has as many elements as there are download
  37 // interrupt reasons. We can then use that in a COMPILE_ASSERT to make sure
  38 // that all the interrupt reason codes are accounted for. The reason codes are
  39 // unfortunately sparse, making this necessary.
  40 char kInterruptReasonCounter[] = {
  41   0,                                // content::DOWNLOAD_INTERRUPT_REASON_NONE
  42 #define INTERRUPT_REASON(name,value) 0,
  43 #include "content/public/browser/download_interrupt_reason_values.h"
  44 #undef INTERRUPT_REASON
  45 };
  46 const size_t kInterruptReasonCount = ARRAYSIZE_UNSAFE(kInterruptReasonCounter);
  47
  48 // Default target path for a mock download item in DownloadItemModelTest.
  49 const base::FilePath::CharType kDefaultTargetFilePath[] =
  50     FILE_PATH_LITERAL("/foo/bar/foo.bar");
  51
  52 const base::FilePath::CharType kDefaultDisplayFileName[] =
  53     FILE_PATH_LITERAL("foo.bar");
  54
  55 // Default URL for a mock download item in DownloadItemModelTest.
  56 const char kDefaultURL[] = "http://example.com/foo.bar";
  57
  58 class DownloadItemModelTest : public testing::Test {
  59  public:
  60   DownloadItemModelTest()
  61       : model_(&item_) {}
  62
  63   virtual ~DownloadItemModelTest() {
  64   }
  65
  66  protected:
  67   // Sets up defaults for the download item and sets |model_| to a new
  68   // DownloadItemModel that uses the mock download item.
  69   void SetupDownloadItemDefaults() {
  70     ON_CALL(item_, GetReceivedBytes()).WillByDefault(Return(1));
  71     ON_CALL(item_, GetTotalBytes()).WillByDefault(Return(2));
  72     ON_CALL(item_, TimeRemaining(_)).WillByDefault(Return(false));
  73     ON_CALL(item_, GetMimeType()).WillByDefault(Return("text/html"));
  74     ON_CALL(item_, AllDataSaved()).WillByDefault(Return(false));
  75     ON_CALL(item_, GetOpenWhenComplete()).WillByDefault(Return(false));
  76     ON_CALL(item_, GetFileExternallyRemoved()).WillByDefault(Return(false));
  77     ON_CALL(item_, GetState())
  78         .WillByDefault(Return(DownloadItem::IN_PROGRESS));
  79     ON_CALL(item_, GetURL())
  80         .WillByDefault(ReturnRefOfCopy(GURL(kDefaultURL)));
  81     ON_CALL(item_, GetFileNameToReportUser())
  82         .WillByDefault(Return(base::FilePath(kDefaultDisplayFileName)));
  83     ON_CALL(item_, GetTargetFilePath())
  84         .WillByDefault(ReturnRefOfCopy(base::FilePath(kDefaultTargetFilePath)));
  85     ON_CALL(item_, GetTargetDisposition())
  86         .WillByDefault(
  87             Return(DownloadItem::TARGET_DISPOSITION_OVERWRITE));
  88     ON_CALL(item_, IsPaused()).WillByDefault(Return(false));
  89   }
  90
  91   void SetupInterruptedDownloadItem(content::DownloadInterruptReason reason) {
  92     EXPECT_CALL(item_, GetLastReason()).WillRepeatedly(Return(reason));
  93     EXPECT_CALL(item_, GetState())
  94         .WillRepeatedly(Return(
  95             (reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
  96                 DownloadItem::IN_PROGRESS :
  97                 DownloadItem::INTERRUPTED));
  98   }
  99
 100   content::MockDownloadItem& item() {
 101     return item_;
 102   }
 103
 104   DownloadItemModel& model() {
 105     return model_;
 106   }
 107
 108  private:
 109   NiceMock<content::MockDownloadItem> item_;
 110   DownloadItemModel model_;
 111 };
 112
 113 }  // namespace
 114
 115 TEST_F(DownloadItemModelTest, InterruptedStatus) {
 116   // Test that we have the correct interrupt status message for downloads that
 117   // are in the INTERRUPTED state.
 118   const struct TestCase {
 119     // The reason.
 120     content::DownloadInterruptReason reason;
 121
 122     // Expected status string. This will include the progress as well.
 123     const char* expected_status;
 124   } kTestCases[] = {
 125     { content::DOWNLOAD_INTERRUPT_REASON_NONE,
 126       "1/2 B" },
 127     { content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
 128       "Failed - Download error" },
 129     { content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
 130       "Failed - Insufficient permissions" },
 131     { content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
 132       "Failed - Disk full" },
 133     { content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
 134       "Failed - Path too long" },
 135     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TOO_LARGE,
 136       "Failed - File too large" },
 137     { content::DOWNLOAD_INTERRUPT_REASON_FILE_VIRUS_INFECTED,
 138       "Failed - Virus detected" },
 139     { content::DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED,
 140       "Failed - Blocked" },
 141     { content::DOWNLOAD_INTERRUPT_REASON_FILE_SECURITY_CHECK_FAILED,
 142       "Failed - Virus scan failed" },
 143     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT,
 144       "Failed - File truncated" },
 145     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR,
 146       "Failed - System busy" },
 147     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED,
 148       "Failed - Network error" },
 149     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT,
 150       "Failed - Network timeout" },
 151     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED,
 152       "Failed - Network disconnected" },
 153     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_SERVER_DOWN,
 154       "Failed - Server unavailable" },
 155     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST,
 156       "Failed - Network error" },
 157     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
 158       "Failed - Server problem" },
 159     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE,
 160       "Failed - Download error" },
 161     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION,
 162       "Failed - Download error" },
 163     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
 164       "Failed - No file" },
 165     { content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED,
 166       "Cancelled" },
 167     { content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN,
 168       "Failed - Shutdown" },
 169     { content::DOWNLOAD_INTERRUPT_REASON_CRASH,
 170       "Failed - Crash" },
 171   };
 172   COMPILE_ASSERT(kInterruptReasonCount == ARRAYSIZE_UNSAFE(kTestCases),
 173                  interrupt_reason_mismatch);
 174
 175   SetupDownloadItemDefaults();
 176   for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 177     const TestCase& test_case = kTestCases[i];
 178     SetupInterruptedDownloadItem(test_case.reason);
 179     EXPECT_STREQ(test_case.expected_status,
 180                  base::UTF16ToUTF8(model().GetStatusText()).c_str());
 181   }
 182 }
 183
 184 // Note: This test is currently skipped on Android. See http://crbug.com/139398
 185 TEST_F(DownloadItemModelTest, InterruptTooltip) {
 186   // Test that we have the correct interrupt tooltip for downloads that are in
 187   // the INTERRUPTED state.
 188   const struct TestCase {
 189     // The reason.
 190     content::DownloadInterruptReason reason;
 191
 192     // Expected tooltip text. The tooltip text for interrupted downloads
 193     // typically consist of two lines. One for the filename and one for the
 194     // interrupt reason. The returned string contains a newline.
 195     const char* expected_tooltip;
 196   } kTestCases[] = {
 197     { content::DOWNLOAD_INTERRUPT_REASON_NONE,
 198       "foo.bar" },
 199     { content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
 200       "foo.bar\nDownload error" },
 201     { content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
 202       "foo.bar\nInsufficient permissions" },
 203     { content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
 204       "foo.bar\nDisk full" },
 205     { content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
 206       "foo.bar\nPath too long" },
 207     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TOO_LARGE,
 208       "foo.bar\nFile too large" },
 209     { content::DOWNLOAD_INTERRUPT_REASON_FILE_VIRUS_INFECTED,
 210       "foo.bar\nVirus detected" },
 211     { content::DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED,
 212       "foo.bar\nBlocked" },
 213     { content::DOWNLOAD_INTERRUPT_REASON_FILE_SECURITY_CHECK_FAILED,
 214       "foo.bar\nVirus scan failed" },
 215     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT,
 216       "foo.bar\nFile truncated" },
 217     { content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR,
 218       "foo.bar\nSystem busy" },
 219     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED,
 220       "foo.bar\nNetwork error" },
 221     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT,
 222       "foo.bar\nNetwork timeout" },
 223     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED,
 224       "foo.bar\nNetwork disconnected" },
 225     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_SERVER_DOWN,
 226       "foo.bar\nServer unavailable" },
 227     { content::DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST,
 228       "foo.bar\nNetwork error" },
 229     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
 230       "foo.bar\nServer problem" },
 231     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE,
 232       "foo.bar\nDownload error" },
 233     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION,
 234       "foo.bar\nDownload error" },
 235     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
 236       "foo.bar\nNo file" },
 237     { content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED,
 238       "foo.bar" },
 239     { content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN,
 240       "foo.bar\nShutdown" },
 241     { content::DOWNLOAD_INTERRUPT_REASON_CRASH,
 242       "foo.bar\nCrash" },
 243   };
 244   COMPILE_ASSERT(kInterruptReasonCount == ARRAYSIZE_UNSAFE(kTestCases),
 245                  interrupt_reason_mismatch);
 246
 247   // Large tooltip width. Should be large enough to accommodate the entire
 248   // tooltip without truncation.
 249   const int kLargeTooltipWidth = 1000;
 250
 251   // Small tooltip width. Small enough to require truncation of most
 252   // tooltips. Used to test eliding logic.
 253   const int kSmallTooltipWidth = 40;
 254
 255   const gfx::FontList& font_list =
 256       ui::ResourceBundle::GetSharedInstance().GetFontList(
 257           ui::ResourceBundle::BaseFont);
 258   SetupDownloadItemDefaults();
 259   for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 260     const TestCase& test_case = kTestCases[i];
 261     SetupInterruptedDownloadItem(test_case.reason);
 262
 263     // GetTooltipText() elides the tooltip so that the text would fit within a
 264     // given width. The following test would fail if kLargeTooltipWidth isn't
 265     // large enough to accomodate all the strings.
 266     EXPECT_STREQ(
 267         test_case.expected_tooltip,
 268         base::UTF16ToUTF8(model().GetTooltipText(font_list,
 269                                                  kLargeTooltipWidth)).c_str());
 270
 271     // Check that if the width is small, the returned tooltip only contains
 272     // lines of the given width or smaller.
 273     std::vector<base::string16> lines;
 274     base::string16 truncated_tooltip =
 275         model().GetTooltipText(font_list, kSmallTooltipWidth);
 276     Tokenize(truncated_tooltip, base::ASCIIToUTF16("\n"), &lines);
 277     for (unsigned i = 0; i < lines.size(); ++i)
 278       EXPECT_GE(kSmallTooltipWidth, gfx::GetStringWidth(lines[i], font_list));
 279   }
 280 }
 281
 282 TEST_F(DownloadItemModelTest, InProgressStatus) {
 283   const struct TestCase {
 284     int64 received_bytes;               // Return value of GetReceivedBytes().
 285     int64 total_bytes;                  // Return value of GetTotalBytes().
 286     bool  time_remaining_known;         // If TimeRemaining() is known.
 287     bool  open_when_complete;           // GetOpenWhenComplete().
 288     bool  is_paused;                    // IsPaused().
 289     const char* expected_status;        // Expected status text.
 290   } kTestCases[] = {
 291     // These are all the valid combinations of the above fields for a download
 292     // that is in IN_PROGRESS state. Go through all of them and check the return
 293     // value of DownloadItemModel::GetStatusText(). The point isn't to lock down
 294     // the status strings, but to make sure we end up with something sane for
 295     // all the circumstances we care about.
 296     //
 297     // For GetReceivedBytes()/GetTotalBytes(), we only check whether each is
 298     // non-zero. In addition, if |total_bytes| is zero, then
 299     // |time_remaining_known| is also false.
 300     //
 301     //         .-- .TimeRemaining() is known.
 302     //        |       .-- .GetOpenWhenComplete()
 303     //        |      |      .---- .IsPaused()
 304     { 0, 0, false, false, false, "Starting..." },
 305     { 1, 0, false, false, false, "1 B" },
 306     { 0, 2, false, false, false, "Starting..." },
 307     { 1, 2, false, false, false, "1/2 B" },
 308     { 0, 2, true,  false, false, "0/2 B, 10 secs left" },
 309     { 1, 2, true,  false, false, "1/2 B, 10 secs left" },
 310     { 0, 0, false, true,  false, "Opening when complete" },
 311     { 1, 0, false, true,  false, "Opening when complete" },
 312     { 0, 2, false, true,  false, "Opening when complete" },
 313     { 1, 2, false, true,  false, "Opening when complete" },
 314     { 0, 2, true,  true,  false, "Opening in 10 secs..." },
 315     { 1, 2, true,  true,  false, "Opening in 10 secs..." },
 316     { 0, 0, false, false, true,  "0 B, Paused" },
 317     { 1, 0, false, false, true,  "1 B, Paused" },
 318     { 0, 2, false, false, true,  "0/2 B, Paused" },
 319     { 1, 2, false, false, true,  "1/2 B, Paused" },
 320     { 0, 2, true,  false, true,  "0/2 B, Paused" },
 321     { 1, 2, true,  false, true,  "1/2 B, Paused" },
 322     { 0, 0, false, true,  true,  "0 B, Paused" },
 323     { 1, 0, false, true,  true,  "1 B, Paused" },
 324     { 0, 2, false, true,  true,  "0/2 B, Paused" },
 325     { 1, 2, false, true,  true,  "1/2 B, Paused" },
 326     { 0, 2, true,  true,  true,  "0/2 B, Paused" },
 327     { 1, 2, true,  true,  true,  "1/2 B, Paused" },
 328   };
 329
 330   SetupDownloadItemDefaults();
 331
 332   for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
 333     const TestCase& test_case = kTestCases[i];
 334     Mock::VerifyAndClearExpectations(&item());
 335     Mock::VerifyAndClearExpectations(&model());
 336     EXPECT_CALL(item(), GetReceivedBytes())
 337         .WillRepeatedly(Return(test_case.received_bytes));
 338     EXPECT_CALL(item(), GetTotalBytes())
 339         .WillRepeatedly(Return(test_case.total_bytes));
 340     EXPECT_CALL(item(), TimeRemaining(_))
 341         .WillRepeatedly(testing::DoAll(
 342             testing::SetArgPointee<0>(base::TimeDelta::FromSeconds(10)),
 343             Return(test_case.time_remaining_known)));
 344     EXPECT_CALL(item(), GetOpenWhenComplete())
 345         .WillRepeatedly(Return(test_case.open_when_complete));
 346     EXPECT_CALL(item(), IsPaused())
 347         .WillRepeatedly(Return(test_case.is_paused));
 348
 349     EXPECT_STREQ(test_case.expected_status,
 350                  base::UTF16ToUTF8(model().GetStatusText()).c_str());
 351   }
 352 }
 353
 354 TEST_F(DownloadItemModelTest, ShouldShowInShelf) {
 355   SetupDownloadItemDefaults();
 356
 357   // By default the download item should be displayable on the shelf.
 358   EXPECT_TRUE(model().ShouldShowInShelf());
 359
 360   // Once explicitly set, ShouldShowInShelf() should return the explicit value.
 361   model().SetShouldShowInShelf(false);
 362   EXPECT_FALSE(model().ShouldShowInShelf());
 363
 364   model().SetShouldShowInShelf(true);
 365   EXPECT_TRUE(model().ShouldShowInShelf());
 366 }
 367
 368 TEST_F(DownloadItemModelTest, ShouldRemoveFromShelfWhenComplete) {
 369   const struct TestCase {
 370     DownloadItem::DownloadState state;
 371     bool is_dangerous;  // Expectation for IsDangerous().
 372     bool is_auto_open;  // Expectation for GetOpenWhenComplete().
 373     bool auto_opened;   // Whether the download was successfully
 374                         // auto-opened. Expecation for GetAutoOpened().
 375     bool expected_result;
 376   } kTestCases[] = {
 377     // All the valid combinations of state, is_dangerous, is_auto_open and
 378     // auto_opened.
 379     //
 380     //                              .--- Is dangerous.
 381     //                             |       .--- Auto open or temporary.
 382     //                             |      |      .--- Auto opened.
 383     //                             |      |      |      .--- Expected result.
 384     { DownloadItem::IN_PROGRESS, false, false, false, false},
 385     { DownloadItem::IN_PROGRESS, false, true , false, true },
 386     { DownloadItem::IN_PROGRESS, true , false, false, false},
 387     { DownloadItem::IN_PROGRESS, true , true , false, false},
 388     { DownloadItem::COMPLETE,    false, false, false, false},
 389     { DownloadItem::COMPLETE,    false, true , false, false},
 390     { DownloadItem::COMPLETE,    false, false, true , true },
 391     { DownloadItem::COMPLETE,    false, true , true , true },
 392     { DownloadItem::CANCELLED,   false, false, false, false},
 393     { DownloadItem::CANCELLED,   false, true , false, false},
 394     { DownloadItem::CANCELLED,   true , false, false, false},
 395     { DownloadItem::CANCELLED,   true , true , false, false},
 396     { DownloadItem::INTERRUPTED, false, false, false, false},
 397     { DownloadItem::INTERRUPTED, false, true , false, false},
 398     { DownloadItem::INTERRUPTED, true , false, false, false},
 399     { DownloadItem::INTERRUPTED, true , true , false, false}
 400   };
 401
 402   SetupDownloadItemDefaults();
 403
 404   for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
 405     const TestCase& test_case = kTestCases[i];
 406     EXPECT_CALL(item(), GetOpenWhenComplete())
 407         .WillRepeatedly(Return(test_case.is_auto_open));
 408     EXPECT_CALL(item(), GetState())
 409         .WillRepeatedly(Return(test_case.state));
 410     EXPECT_CALL(item(), IsDangerous())
 411         .WillRepeatedly(Return(test_case.is_dangerous));
 412     EXPECT_CALL(item(), GetAutoOpened())
 413         .WillRepeatedly(Return(test_case.auto_opened));
 414
 415     EXPECT_EQ(test_case.expected_result,
 416               model().ShouldRemoveFromShelfWhenComplete())
 417         << "Test case: " << i;
 418     Mock::VerifyAndClearExpectations(&item());
 419     Mock::VerifyAndClearExpectations(&model());
 420   }
 421 }