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