| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 <stdint.h> | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/files/file_path.h" | |
| 11 #include "base/location.h" | |
| 12 #include "base/run_loop.h" | |
| 13 #include "base/single_thread_task_runner.h" | |
| 14 #include "base/strings/utf_string_conversions.h" | |
| 15 #include "base/threading/thread_task_runner_handle.h" | |
| 16 #include "net/base/completion_callback.h" | |
| 17 #include "net/base/net_errors.h" | |
| 18 #include "storage/browser/database/database_quota_client.h" | |
| 19 #include "storage/browser/database/database_tracker.h" | |
| 20 #include "storage/browser/database/database_util.h" | |
| 21 #include "storage/common/database/database_identifier.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 | |
| 24 using storage::DatabaseQuotaClient; | |
| 25 using storage::DatabaseTracker; | |
| 26 using storage::OriginInfo; | |
| 27 | |
| 28 namespace content { | |
| 29 | |
| 30 // Declared to shorten the line lengths. | |
| 31 static const storage::StorageType kTemp = storage::kStorageTypeTemporary; | |
| 32 static const storage::StorageType kPerm = storage::kStorageTypePersistent; | |
| 33 | |
| 34 // Mock tracker class the mocks up those methods of the tracker | |
| 35 // that are used by the QuotaClient. | |
| 36 class MockDatabaseTracker : public DatabaseTracker { | |
| 37 public: | |
| 38 MockDatabaseTracker() | |
| 39 : DatabaseTracker(base::FilePath(), false, NULL, NULL, NULL), | |
| 40 delete_called_count_(0), | |
| 41 async_delete_(false) {} | |
| 42 | |
| 43 bool GetOriginInfo(const std::string& origin_identifier, | |
| 44 OriginInfo* info) override { | |
| 45 std::map<GURL, MockOriginInfo>::const_iterator found = | |
| 46 mock_origin_infos_.find( | |
| 47 storage::GetOriginFromIdentifier(origin_identifier)); | |
| 48 if (found == mock_origin_infos_.end()) | |
| 49 return false; | |
| 50 *info = OriginInfo(found->second); | |
| 51 return true; | |
| 52 } | |
| 53 | |
| 54 bool GetAllOriginIdentifiers( | |
| 55 std::vector<std::string>* origins_identifiers) override { | |
| 56 std::map<GURL, MockOriginInfo>::const_iterator iter; | |
| 57 for (iter = mock_origin_infos_.begin(); | |
| 58 iter != mock_origin_infos_.end(); | |
| 59 ++iter) { | |
| 60 origins_identifiers->push_back(iter->second.GetOriginIdentifier()); | |
| 61 } | |
| 62 return true; | |
| 63 } | |
| 64 | |
| 65 bool GetAllOriginsInfo(std::vector<OriginInfo>* origins_info) override { | |
| 66 std::map<GURL, MockOriginInfo>::const_iterator iter; | |
| 67 for (iter = mock_origin_infos_.begin(); | |
| 68 iter != mock_origin_infos_.end(); | |
| 69 ++iter) { | |
| 70 origins_info->push_back(OriginInfo(iter->second)); | |
| 71 } | |
| 72 return true; | |
| 73 } | |
| 74 | |
| 75 int DeleteDataForOrigin(const std::string& origin_identifier, | |
| 76 const net::CompletionCallback& callback) override { | |
| 77 ++delete_called_count_; | |
| 78 if (async_delete()) { | |
| 79 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
| 80 FROM_HERE, base::Bind(&MockDatabaseTracker::AsyncDeleteDataForOrigin, | |
| 81 this, callback)); | |
| 82 return net::ERR_IO_PENDING; | |
| 83 } | |
| 84 return net::OK; | |
| 85 } | |
| 86 | |
| 87 void AsyncDeleteDataForOrigin(const net::CompletionCallback& callback) { | |
| 88 callback.Run(net::OK); | |
| 89 } | |
| 90 | |
| 91 void AddMockDatabase(const GURL& origin, const char* name, int size) { | |
| 92 MockOriginInfo& info = mock_origin_infos_[origin]; | |
| 93 info.set_origin(storage::GetIdentifierFromOrigin(origin)); | |
| 94 info.AddMockDatabase(base::ASCIIToUTF16(name), size); | |
| 95 } | |
| 96 | |
| 97 int delete_called_count() { return delete_called_count_; } | |
| 98 bool async_delete() { return async_delete_; } | |
| 99 void set_async_delete(bool async) { async_delete_ = async; } | |
| 100 | |
| 101 protected: | |
| 102 ~MockDatabaseTracker() override {} | |
| 103 | |
| 104 private: | |
| 105 class MockOriginInfo : public OriginInfo { | |
| 106 public: | |
| 107 void set_origin(const std::string& origin_identifier) { | |
| 108 origin_identifier_ = origin_identifier; | |
| 109 } | |
| 110 | |
| 111 void AddMockDatabase(const base::string16& name, int size) { | |
| 112 EXPECT_TRUE(database_info_.find(name) == database_info_.end()); | |
| 113 database_info_[name].first = size; | |
| 114 total_size_ += size; | |
| 115 } | |
| 116 }; | |
| 117 | |
| 118 int delete_called_count_; | |
| 119 bool async_delete_; | |
| 120 std::map<GURL, MockOriginInfo> mock_origin_infos_; | |
| 121 }; | |
| 122 | |
| 123 | |
| 124 // Base class for our test fixtures. | |
| 125 class DatabaseQuotaClientTest : public testing::Test { | |
| 126 public: | |
| 127 const GURL kOriginA; | |
| 128 const GURL kOriginB; | |
| 129 const GURL kOriginOther; | |
| 130 | |
| 131 DatabaseQuotaClientTest() | |
| 132 : kOriginA("http://host"), | |
| 133 kOriginB("http://host:8000"), | |
| 134 kOriginOther("http://other"), | |
| 135 usage_(0), | |
| 136 mock_tracker_(new MockDatabaseTracker), | |
| 137 weak_factory_(this) { | |
| 138 } | |
| 139 | |
| 140 int64_t GetOriginUsage(storage::QuotaClient* client, | |
| 141 const GURL& origin, | |
| 142 storage::StorageType type) { | |
| 143 usage_ = 0; | |
| 144 client->GetOriginUsage( | |
| 145 origin, type, | |
| 146 base::Bind(&DatabaseQuotaClientTest::OnGetOriginUsageComplete, | |
| 147 weak_factory_.GetWeakPtr())); | |
| 148 base::RunLoop().RunUntilIdle(); | |
| 149 return usage_; | |
| 150 } | |
| 151 | |
| 152 const std::set<GURL>& GetOriginsForType(storage::QuotaClient* client, | |
| 153 storage::StorageType type) { | |
| 154 origins_.clear(); | |
| 155 client->GetOriginsForType( | |
| 156 type, | |
| 157 base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete, | |
| 158 weak_factory_.GetWeakPtr())); | |
| 159 base::RunLoop().RunUntilIdle(); | |
| 160 return origins_; | |
| 161 } | |
| 162 | |
| 163 const std::set<GURL>& GetOriginsForHost(storage::QuotaClient* client, | |
| 164 storage::StorageType type, | |
| 165 const std::string& host) { | |
| 166 origins_.clear(); | |
| 167 client->GetOriginsForHost( | |
| 168 type, host, | |
| 169 base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete, | |
| 170 weak_factory_.GetWeakPtr())); | |
| 171 base::RunLoop().RunUntilIdle(); | |
| 172 return origins_; | |
| 173 } | |
| 174 | |
| 175 bool DeleteOriginData(storage::QuotaClient* client, | |
| 176 storage::StorageType type, | |
| 177 const GURL& origin) { | |
| 178 delete_status_ = storage::kQuotaStatusUnknown; | |
| 179 client->DeleteOriginData( | |
| 180 origin, type, | |
| 181 base::Bind(&DatabaseQuotaClientTest::OnDeleteOriginDataComplete, | |
| 182 weak_factory_.GetWeakPtr())); | |
| 183 base::RunLoop().RunUntilIdle(); | |
| 184 return delete_status_ == storage::kQuotaStatusOk; | |
| 185 } | |
| 186 | |
| 187 MockDatabaseTracker* mock_tracker() { return mock_tracker_.get(); } | |
| 188 | |
| 189 | |
| 190 private: | |
| 191 void OnGetOriginUsageComplete(int64_t usage) { usage_ = usage; } | |
| 192 | |
| 193 void OnGetOriginsComplete(const std::set<GURL>& origins) { | |
| 194 origins_ = origins; | |
| 195 } | |
| 196 | |
| 197 void OnDeleteOriginDataComplete(storage::QuotaStatusCode status) { | |
| 198 delete_status_ = status; | |
| 199 } | |
| 200 | |
| 201 base::MessageLoop message_loop_; | |
| 202 int64_t usage_; | |
| 203 std::set<GURL> origins_; | |
| 204 storage::QuotaStatusCode delete_status_; | |
| 205 scoped_refptr<MockDatabaseTracker> mock_tracker_; | |
| 206 base::WeakPtrFactory<DatabaseQuotaClientTest> weak_factory_; | |
| 207 }; | |
| 208 | |
| 209 | |
| 210 TEST_F(DatabaseQuotaClientTest, GetOriginUsage) { | |
| 211 DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(), | |
| 212 mock_tracker()); | |
| 213 | |
| 214 EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kTemp)); | |
| 215 EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm)); | |
| 216 | |
| 217 mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000); | |
| 218 EXPECT_EQ(1000, GetOriginUsage(&client, kOriginA, kTemp)); | |
| 219 EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm)); | |
| 220 | |
| 221 EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kPerm)); | |
| 222 EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kTemp)); | |
| 223 } | |
| 224 | |
| 225 TEST_F(DatabaseQuotaClientTest, GetOriginsForHost) { | |
| 226 DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(), | |
| 227 mock_tracker()); | |
| 228 | |
| 229 EXPECT_EQ(kOriginA.host(), kOriginB.host()); | |
| 230 EXPECT_NE(kOriginA.host(), kOriginOther.host()); | |
| 231 | |
| 232 std::set<GURL> origins = GetOriginsForHost(&client, kTemp, kOriginA.host()); | |
| 233 EXPECT_TRUE(origins.empty()); | |
| 234 | |
| 235 mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000); | |
| 236 origins = GetOriginsForHost(&client, kTemp, kOriginA.host()); | |
| 237 EXPECT_EQ(origins.size(), 1ul); | |
| 238 EXPECT_TRUE(origins.find(kOriginA) != origins.end()); | |
| 239 | |
| 240 mock_tracker()->AddMockDatabase(kOriginB, "barDB", 1000); | |
| 241 origins = GetOriginsForHost(&client, kTemp, kOriginA.host()); | |
| 242 EXPECT_EQ(origins.size(), 2ul); | |
| 243 EXPECT_TRUE(origins.find(kOriginA) != origins.end()); | |
| 244 EXPECT_TRUE(origins.find(kOriginB) != origins.end()); | |
| 245 | |
| 246 EXPECT_TRUE(GetOriginsForHost(&client, kPerm, kOriginA.host()).empty()); | |
| 247 EXPECT_TRUE(GetOriginsForHost(&client, kTemp, kOriginOther.host()).empty()); | |
| 248 } | |
| 249 | |
| 250 TEST_F(DatabaseQuotaClientTest, GetOriginsForType) { | |
| 251 DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(), | |
| 252 mock_tracker()); | |
| 253 | |
| 254 EXPECT_TRUE(GetOriginsForType(&client, kTemp).empty()); | |
| 255 EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty()); | |
| 256 | |
| 257 mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000); | |
| 258 std::set<GURL> origins = GetOriginsForType(&client, kTemp); | |
| 259 EXPECT_EQ(origins.size(), 1ul); | |
| 260 EXPECT_TRUE(origins.find(kOriginA) != origins.end()); | |
| 261 | |
| 262 EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty()); | |
| 263 } | |
| 264 | |
| 265 TEST_F(DatabaseQuotaClientTest, DeleteOriginData) { | |
| 266 DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(), | |
| 267 mock_tracker()); | |
| 268 | |
| 269 // Perm deletions are short circuited in the Client and | |
| 270 // should not reach the DatabaseTracker. | |
| 271 EXPECT_TRUE(DeleteOriginData(&client, kPerm, kOriginA)); | |
| 272 EXPECT_EQ(0, mock_tracker()->delete_called_count()); | |
| 273 | |
| 274 mock_tracker()->set_async_delete(false); | |
| 275 EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA)); | |
| 276 EXPECT_EQ(1, mock_tracker()->delete_called_count()); | |
| 277 | |
| 278 mock_tracker()->set_async_delete(true); | |
| 279 EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA)); | |
| 280 EXPECT_EQ(2, mock_tracker()->delete_called_count()); | |
| 281 } | |
| 282 | |
| 283 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2776253002:
Move some database tests next to the files they cover. (Closed)
