DownloadQuery filters and sorts DownloadItems.

content/browser/download/download_query_unittest.cc

+// Copyright (c) 2011 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 <string>
+
+#include "base/bind.h"
+#include "base/file_path.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "content/browser/download/download_query.h"
+#include "content/browser/download/mock_download_item.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#include "base/utf_string_conversions.h"
+
+using ::testing::Return;
+using ::testing::ReturnRef;
+typedef DownloadQuery::DownloadVector DownloadVector;
+
+namespace {
+bool OnlyEvenIds(const DownloadItem& item) {
+  return item.GetId() % 2 == 0;
+}
+}
+
+class DownloadQueryTest : public testing::Test {
+ public:
+  DownloadQueryTest() {}
+  virtual ~DownloadQueryTest() {}
+  virtual void TearDown() {
+    STLDeleteElements(&mocks_);
+  }
+  void CreateMocks(int count) {
+    for (int i = 0; i < count; ++i) {
+      MockDownloadItem* mock = new MockDownloadItem();
+      mocks_.push_back(mock);
+      all_items_.push_back(mock);
+    }
+  }
+  MockDownloadItem& mock(int index) { return *mocks_[index]; }
+  DownloadQuery* query() { return &query_; }
+  DownloadVector* all_items() { return &all_items_; }
+  DownloadVector* results() { return &results_; }
+  void Search() {
+    results_.clear();
+    query()->Search(all_items_.begin(), all_items_.end(), &results_);
+  }
+
+ private:
+  std::vector<MockDownloadItem*> mocks_;
+  DownloadQuery query_;
+  DownloadVector all_items_;
+  DownloadVector results_;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadQueryTest);
+};
+
+TEST_F(DownloadQueryTest, EmptyQueryNoItems) {
+  Search();
+  EXPECT_EQ(0U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, EmptyQuerySomeItems) {
+  CreateMocks(3);
+  Search();
+  EXPECT_EQ(3U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, FilterBytesReceived) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetReceivedBytes()).WillOnce(Return(0));
+  EXPECT_CALL(mock(1), GetReceivedBytes()).WillOnce(Return(1));
+  query()->Filter(DownloadQuery::FILTER_FIELD_BYTES_RECEIVED, 1);
+  Search();
+  EXPECT_EQ(1U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, FilterUrlRegex) {
+  CreateMocks(3);
+  GURL url0("http://example.com");
+  GURL url1("http://foo.com");
+  GURL url2("http://bar.com/foo/bar");
+  EXPECT_CALL(mock(0), GetOriginalUrl()).WillOnce(ReturnRef(url0));
+  EXPECT_CALL(mock(1), GetOriginalUrl()).WillOnce(ReturnRef(url1));
+  EXPECT_CALL(mock(2), GetOriginalUrl()).WillOnce(ReturnRef(url2));
+  query()->Filter(DownloadQuery::FILTER_FIELD_URL_REGEX, std::string("fo{2}"));
+  Search();
+  EXPECT_EQ(2U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, FilterFilter) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetId()).WillOnce(Return(0));
+  EXPECT_CALL(mock(1), GetId()).WillOnce(Return(1));
+  query()->Filter(base::Bind(&OnlyEvenIds));
+  Search();
+  EXPECT_EQ(1U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, InvalidFilter) {
+  EXPECT_FALSE(query()->Filter(DownloadQuery::FILTER_FIELD_FILENAME_REGEX,
+                               std::string()));
+  EXPECT_FALSE(query()->Filter(DownloadQuery::FILTER_FIELD_URL_REGEX,
+                               string16()));
+  DownloadQuery::FilterFieldName kInvalidName =
+    static_cast<DownloadQuery::FilterFieldName>(kint32max);
+  EXPECT_FALSE(query()->Filter(kInvalidName, 0));
+  EXPECT_FALSE(query()->Filter(kInvalidName, false));
+  EXPECT_FALSE(query()->Filter(kInvalidName, std::string()));
+  EXPECT_FALSE(query()->Filter(kInvalidName, string16()));
+  EXPECT_FALSE(query()->Filter(kInvalidName, DownloadStateInfo::DANGEROUS_URL));
+  EXPECT_FALSE(query()->Filter(kInvalidName, DownloadItem::IN_PROGRESS));
+}
+
+TEST_F(DownloadQueryTest, FilterFilenameRegex) {
+  CreateMocks(2);
+  FilePath file0("/foo/bar");
+  FilePath file1("/a/b/c");
+  EXPECT_CALL(mock(0), GetFullPath()).WillOnce(ReturnRef(file0));
+  EXPECT_CALL(mock(1), GetFullPath()).WillOnce(ReturnRef(file1));
+  query()->Filter(DownloadQuery::FILTER_FIELD_FILENAME_REGEX,
+                  ASCIIToUTF16("fo{2}"));
+  Search();
+  EXPECT_EQ(1U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, SortBytesReceived) {
+  CreateMocks(3);
+  EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(2));
+  EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(2), GetReceivedBytes()).WillRepeatedly(Return(1));
+  query()->Sort(DownloadQuery::SORT_FIELD_BYTES_RECEIVED,
+                DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(3U, results()->size());
+  EXPECT_EQ(0, results()->at(0)->GetReceivedBytes());
+  EXPECT_EQ(1, results()->at(1)->GetReceivedBytes());
+  EXPECT_EQ(2, results()->at(2)->GetReceivedBytes());
+
+  // Automatically sort secondarily by Id.
+  CreateMocks(3);
+  EXPECT_CALL(mock(3), GetReceivedBytes()).WillRepeatedly(Return(2));
+  EXPECT_CALL(mock(4), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(5), GetReceivedBytes()).WillRepeatedly(Return(1));
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_CALL(mock(i), GetId()).WillRepeatedly(Return(i));
+  }
+  Search();
+  EXPECT_EQ(6U, results()->size());
+  EXPECT_EQ(1, results()->at(0)->GetId());
+  EXPECT_EQ(4, results()->at(1)->GetId());
+  EXPECT_EQ(2, results()->at(2)->GetId());
+  EXPECT_EQ(5, results()->at(3)->GetId());
+  EXPECT_EQ(0, results()->at(4)->GetId());
+  EXPECT_EQ(3, results()->at(5)->GetId());
+}