OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 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 "components/offline_pages/core/cached_offline_page_utils.h" | |
6 | |
7 #include <stdint.h> | |
8 #include <map> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/memory/weak_ptr.h" | |
12 #include "base/test/simple_test_clock.h" | |
13 #include "base/time/time.h" | |
14 #include "components/offline_pages/core/client_policy_controller.h" | |
15 #include "components/offline_pages/core/offline_page_item.h" | |
16 #include "components/offline_pages/core/offline_page_model_query.h" | |
17 #include "components/offline_pages/core/offline_page_types.h" | |
18 #include "components/offline_pages/core/stub_offline_page_model.h" | |
19 #include "testing/gtest/include/gtest/gtest.h" | |
20 | |
21 namespace offline_pages { | |
22 | |
23 namespace { | |
24 // Constants for test OfflinePageItems. | |
25 const char kTemporaryNamespace[] = "temporary_namespace"; | |
26 const char kPersistentNamespace[] = "persistent_namespace"; | |
27 const GURL kTestUrl("http://foo.com/bar.html"); | |
28 const GURL kTestUrl2("http://bar.com/foo"); | |
29 const GURL kTestUrl3("http://42.com"); | |
30 const int64_t kOfflineId1 = 1234LL; | |
31 const int64_t kOfflineId2 = 5678LL; | |
32 const int64_t kOfflineId3 = 42LL; | |
33 const int64_t kOfflineId4 = 123LL; | |
34 const ClientId kTempClientId1(kTemporaryNamespace, "1234"); | |
35 const ClientId kTempClientId2(kTemporaryNamespace, "5678"); | |
36 const ClientId kTempClientId3(kTemporaryNamespace, "123"); | |
37 const ClientId kPersistentClientId(kPersistentNamespace, "42"); | |
38 const int64_t kTestFileSize1 = 131415LL; | |
39 const int64_t kTestFileSize2 = 666666LL; | |
40 const int64_t kTestFileSize3 = 500000LL; | |
41 const base::FilePath kTestFilePath = | |
42 base::FilePath(FILE_PATH_LITERAL("file_path")); | |
43 } // namespace | |
44 | |
45 class CachedOfflinePageTestModel : public StubOfflinePageModel { | |
dewittj
2017/05/03 21:40:51
no action required: I think we are overdue for a n
romax
2017/05/04 04:20:37
Acknowledged.
| |
46 public: | |
47 CachedOfflinePageTestModel(); | |
48 ~CachedOfflinePageTestModel() override; | |
49 | |
50 void GetPagesMatchingQuery( | |
51 std::unique_ptr<OfflinePageModelQuery> query, | |
52 const MultipleOfflinePageItemCallback& callback) override; | |
53 void GetAllPages(const MultipleOfflinePageItemCallback& callback) override; | |
54 | |
55 ClientPolicyController* GetPolicyController() override; | |
56 | |
57 void AddOfflinePage(const OfflinePageItem& page); | |
58 | |
59 private: | |
60 std::map<int64_t, OfflinePageItem> offline_pages_; | |
61 std::unique_ptr<ClientPolicyController> policy_controller_; | |
62 }; | |
63 | |
64 CachedOfflinePageTestModel::CachedOfflinePageTestModel() | |
65 : policy_controller_(new ClientPolicyController()) { | |
66 // Adds the policies for test namespaces. | |
67 policy_controller_->AddPolicyForTest( | |
68 kTemporaryNamespace, | |
69 OfflinePageClientPolicyBuilder(kTemporaryNamespace, | |
70 LifetimePolicy::LifetimeType::TEMPORARY, | |
71 kUnlimitedPages, kUnlimitedPages)); | |
72 policy_controller_->AddPolicyForTest( | |
73 kPersistentNamespace, | |
74 OfflinePageClientPolicyBuilder(kPersistentNamespace, | |
75 LifetimePolicy::LifetimeType::PERSISTENT, | |
76 kUnlimitedPages, kUnlimitedPages) | |
77 .SetIsRemovedOnCacheReset(false)); | |
78 } | |
79 | |
80 CachedOfflinePageTestModel::~CachedOfflinePageTestModel() {} | |
81 | |
82 void CachedOfflinePageTestModel::GetPagesMatchingQuery( | |
83 std::unique_ptr<OfflinePageModelQuery> query, | |
84 const MultipleOfflinePageItemCallback& callback) { | |
85 MultipleOfflinePageItemResult result; | |
86 for (const auto& page : offline_pages_) { | |
87 if (query->Matches(page.second)) | |
88 result.push_back(page.second); | |
89 } | |
90 callback.Run(result); | |
91 } | |
92 | |
93 void CachedOfflinePageTestModel::GetAllPages( | |
94 const MultipleOfflinePageItemCallback& callback) { | |
95 MultipleOfflinePageItemResult result; | |
96 for (const auto& page : offline_pages_) | |
97 result.push_back(page.second); | |
98 callback.Run(result); | |
99 } | |
100 | |
101 ClientPolicyController* CachedOfflinePageTestModel::GetPolicyController() { | |
102 return policy_controller_.get(); | |
103 } | |
104 | |
105 void CachedOfflinePageTestModel::AddOfflinePage(const OfflinePageItem& page) { | |
106 offline_pages_[page.offline_id] = page; | |
107 } | |
108 | |
109 class CachedOfflinePageUtilsTest | |
110 : public testing::Test, | |
111 public base::SupportsWeakPtr<CachedOfflinePageUtilsTest> { | |
112 public: | |
113 CachedOfflinePageUtilsTest(); | |
114 | |
115 // testing::Test | |
116 void SetUp() override; | |
117 void TearDown() override; | |
118 | |
119 void AddPage(const GURL& url, | |
120 const int64_t offline_id, | |
121 const ClientId& client_id, | |
122 const base::FilePath& path, | |
123 const int64_t file_size, | |
124 const base::Time& creation_time); | |
125 MultipleOfflinePageItemResult GetAllPages(); | |
126 | |
127 void OnSizeCalculated(int64_t size); | |
128 void OnGetMultipleOfflinePageItemsResult( | |
129 MultipleOfflinePageItemResult* storage, | |
130 const MultipleOfflinePageItemResult& result); | |
131 | |
132 OfflinePageModel* model() { return model_.get(); } | |
133 base::SimpleTestClock* clock() { return clock_.get(); } | |
134 | |
135 int64_t last_cache_size() { return last_cache_size_; } | |
136 | |
137 private: | |
138 std::unique_ptr<CachedOfflinePageTestModel> model_; | |
dewittj
2017/05/03 21:40:53
I think this doesn't need to be a unique_ptr, just
romax
2017/05/04 04:20:37
Done.
| |
139 std::unique_ptr<base::SimpleTestClock> clock_; | |
dewittj
2017/05/03 21:40:53
same, don't think unique_ptr is necessary.
romax
2017/05/04 04:20:37
Done.
| |
140 int64_t last_cache_size_; | |
141 }; | |
142 | |
143 CachedOfflinePageUtilsTest::CachedOfflinePageUtilsTest() | |
144 : model_(new CachedOfflinePageTestModel), | |
145 clock_(new base::SimpleTestClock()), | |
146 last_cache_size_(0) {} | |
147 | |
148 void CachedOfflinePageUtilsTest::SetUp() { | |
149 // Add 3 pages to the model used for test cases. | |
150 clock_->SetNow(base::Time::Now()); | |
151 // Time 00:00:00. | |
152 AddPage(kTestUrl, kOfflineId1, kTempClientId1, kTestFilePath, kTestFileSize1, | |
153 clock()->Now()); | |
154 // time 02:00:00. | |
155 clock()->Advance(base::TimeDelta::FromHours(2)); | |
156 AddPage(kTestUrl, kOfflineId2, kPersistentClientId, kTestFilePath, | |
157 kTestFileSize1, clock()->Now()); | |
158 // time 03:00:00. | |
159 clock()->Advance(base::TimeDelta::FromHours(1)); | |
160 AddPage(kTestUrl2, kOfflineId3, kTempClientId2, kTestFilePath, kTestFileSize2, | |
161 clock()->Now()); | |
162 // Add a temporary page to test boundary at base::Time::Max(). | |
163 AddPage(kTestUrl3, kOfflineId4, kTempClientId3, kTestFilePath, kTestFileSize3, | |
164 base::Time::Max()); | |
carlosk
2017/05/03 21:54:35
Time::Max is not a good time for an entry; it shou
romax
2017/05/04 04:20:37
Done.
| |
165 ASSERT_EQ(4UL, GetAllPages().size()); | |
dewittj
2017/05/03 21:40:51
ASSERT in SetUp seems strange to me.
carlosk
2017/05/03 21:54:35
I disagree. This is testing an assumption that all
romax
2017/05/04 04:20:37
THere's no easy way (and no one did) to get all pa
| |
166 } | |
167 | |
168 void CachedOfflinePageUtilsTest::TearDown() { | |
169 model_.reset(); | |
dewittj
2017/05/03 21:40:52
Don't think this is necessary.
romax
2017/05/04 04:20:37
Done.
| |
170 clock_.reset(); | |
171 } | |
172 | |
173 void CachedOfflinePageUtilsTest::AddPage(const GURL& url, | |
174 const int64_t offline_id, | |
175 const ClientId& client_id, | |
176 const base::FilePath& path, | |
177 const int64_t file_size, | |
178 const base::Time& creation_time) { | |
179 OfflinePageItem page(url, offline_id, client_id, path, file_size, | |
180 creation_time); | |
181 model_->AddOfflinePage(page); | |
182 } | |
183 | |
184 MultipleOfflinePageItemResult CachedOfflinePageUtilsTest::GetAllPages() { | |
185 MultipleOfflinePageItemResult result; | |
186 model()->GetAllPages(base::Bind( | |
187 &CachedOfflinePageUtilsTest::OnGetMultipleOfflinePageItemsResult, | |
188 AsWeakPtr(), base::Unretained(&result))); | |
189 return result; | |
190 } | |
191 | |
192 void CachedOfflinePageUtilsTest::OnSizeCalculated(int64_t size) { | |
dewittj
2017/05/03 21:40:52
why do you have multiple paradigms for the callbac
romax
2017/05/04 04:20:37
Done.
| |
193 last_cache_size_ = size; | |
194 } | |
195 | |
196 void CachedOfflinePageUtilsTest::OnGetMultipleOfflinePageItemsResult( | |
197 MultipleOfflinePageItemResult* storage, | |
198 const MultipleOfflinePageItemResult& result) { | |
199 *storage = result; | |
200 } | |
201 | |
202 TEST_F(CachedOfflinePageUtilsTest, TestGetCachedOfflinePageSizeBetween) { | |
dewittj
2017/05/03 21:40:51
nit: moar tests plz, eg:
* no pages in model
* no
romax
2017/05/04 04:20:37
Done.
| |
203 // Advance the clock so that we don't hit the time check boundary. | |
204 clock()->Advance(base::TimeDelta::FromMinutes(5)); | |
205 | |
206 // Get the size of cached offline pages between 01:05:00 and 03:05:00. | |
207 GetCachedOfflinePageSizeBetween( | |
208 model(), | |
209 base::Bind(&CachedOfflinePageUtilsTest::OnSizeCalculated, AsWeakPtr()), | |
210 clock()->Now() - base::TimeDelta::FromHours(2), clock()->Now()); | |
211 EXPECT_EQ(last_cache_size(), kTestFileSize2); | |
212 } | |
213 | |
214 } // namespace offline_pages | |
OLD | NEW |