| 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 "base/macros.h" | |
| 6 #include "components/filesystem/public/interfaces/directory.mojom.h" | |
| 7 #include "components/filesystem/public/interfaces/file_system.mojom.h" | |
| 8 #include "components/filesystem/public/interfaces/types.mojom.h" | |
| 9 #include "components/leveldb/public/interfaces/leveldb.mojom.h" | |
| 10 #include "mojo/common/common_type_converters.h" | |
| 11 #include "mojo/public/cpp/bindings/binding_set.h" | |
| 12 #include "mojo/shell/public/cpp/application_test_base.h" | |
| 13 #include "mojo/shell/public/cpp/shell_connection.h" | |
| 14 #include "mojo/util/capture_util.h" | |
| 15 | |
| 16 using filesystem::FileError; | |
| 17 using mojo::Capture; | |
| 18 | |
| 19 namespace leveldb { | |
| 20 namespace { | |
| 21 | |
| 22 class LevelDBApptest : public mojo::test::ApplicationTestBase { | |
| 23 public: | |
| 24 LevelDBApptest() {} | |
| 25 ~LevelDBApptest() override {} | |
| 26 | |
| 27 protected: | |
| 28 // Overridden from mojo::test::ApplicationTestBase: | |
| 29 void SetUp() override { | |
| 30 ApplicationTestBase::SetUp(); | |
| 31 connector()->ConnectToInterface("mojo:filesystem", &files_); | |
| 32 connector()->ConnectToInterface("mojo:leveldb", &leveldb_); | |
| 33 } | |
| 34 | |
| 35 // Note: This has an out parameter rather than returning the |DirectoryPtr|, | |
| 36 // since |ASSERT_...()| doesn't work with return values. | |
| 37 void GetUserDataDir(filesystem::DirectoryPtr* directory) { | |
| 38 FileError error = FileError::FAILED; | |
| 39 files()->OpenPersistentFileSystem(GetProxy(directory), | |
| 40 mojo::Capture(&error)); | |
| 41 ASSERT_TRUE(files().WaitForIncomingResponse()); | |
| 42 ASSERT_EQ(FileError::OK, error); | |
| 43 } | |
| 44 | |
| 45 filesystem::FileSystemPtr& files() { return files_; } | |
| 46 LevelDBServicePtr& leveldb() { return leveldb_; } | |
| 47 | |
| 48 private: | |
| 49 filesystem::FileSystemPtr files_; | |
| 50 LevelDBServicePtr leveldb_; | |
| 51 | |
| 52 DISALLOW_COPY_AND_ASSIGN(LevelDBApptest); | |
| 53 }; | |
| 54 | |
| 55 #if defined(OS_LINUX) | |
| 56 // Flaky on Linux: http://crbug.com/594977, | |
| 57 #define MAYBE_Basic DISABLED_Basic | |
| 58 #else | |
| 59 #define MAYBE_Basic Basic | |
| 60 #endif | |
| 61 TEST_F(LevelDBApptest, MAYBE_Basic) { | |
| 62 filesystem::DirectoryPtr directory; | |
| 63 GetUserDataDir(&directory); | |
| 64 | |
| 65 DatabaseError error; | |
| 66 LevelDBDatabasePtr database; | |
| 67 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 68 Capture(&error)); | |
| 69 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 70 EXPECT_EQ(DatabaseError::OK, error); | |
| 71 | |
| 72 // Write a key to the database. | |
| 73 error = DatabaseError::INVALID_ARGUMENT; | |
| 74 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | |
| 75 mojo::Array<uint8_t>::From(std::string("value")), | |
| 76 Capture(&error)); | |
| 77 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 78 EXPECT_EQ(DatabaseError::OK, error); | |
| 79 | |
| 80 // Read the key back from the database. | |
| 81 error = DatabaseError::INVALID_ARGUMENT; | |
| 82 mojo::Array<uint8_t> value; | |
| 83 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | |
| 84 Capture(&error, &value)); | |
| 85 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 86 EXPECT_EQ(DatabaseError::OK, error); | |
| 87 EXPECT_EQ("value", value.To<std::string>()); | |
| 88 | |
| 89 // Delete the key from the database. | |
| 90 error = DatabaseError::INVALID_ARGUMENT; | |
| 91 database->Delete(mojo::Array<uint8_t>::From(std::string("key")), | |
| 92 Capture(&error)); | |
| 93 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 94 EXPECT_EQ(DatabaseError::OK, error); | |
| 95 | |
| 96 // Read the key back from the database. | |
| 97 error = DatabaseError::INVALID_ARGUMENT; | |
| 98 value.SetToEmpty(); | |
| 99 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | |
| 100 Capture(&error, &value)); | |
| 101 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 102 EXPECT_EQ(DatabaseError::NOT_FOUND, error); | |
| 103 EXPECT_EQ("", value.To<std::string>()); | |
| 104 } | |
| 105 | |
| 106 TEST_F(LevelDBApptest, WriteBatch) { | |
| 107 filesystem::DirectoryPtr directory; | |
| 108 GetUserDataDir(&directory); | |
| 109 | |
| 110 DatabaseError error; | |
| 111 LevelDBDatabasePtr database; | |
| 112 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 113 Capture(&error)); | |
| 114 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 115 EXPECT_EQ(DatabaseError::OK, error); | |
| 116 | |
| 117 // Write a key to the database. | |
| 118 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | |
| 119 mojo::Array<uint8_t>::From(std::string("value")), | |
| 120 Capture(&error)); | |
| 121 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 122 EXPECT_EQ(DatabaseError::OK, error); | |
| 123 | |
| 124 // Create a batched operation which both deletes "key" and adds another write. | |
| 125 mojo::Array<BatchedOperationPtr> operations; | |
| 126 BatchedOperationPtr item = BatchedOperation::New(); | |
| 127 item->type = BatchOperationType::DELETE_KEY; | |
| 128 item->key = mojo::Array<uint8_t>::From(std::string("key")); | |
| 129 operations.push_back(std::move(item)); | |
| 130 | |
| 131 item = BatchedOperation::New(); | |
| 132 item->type = BatchOperationType::PUT_KEY; | |
| 133 item->key = mojo::Array<uint8_t>::From(std::string("other")); | |
| 134 item->value = mojo::Array<uint8_t>::From(std::string("more")); | |
| 135 operations.push_back(std::move(item)); | |
| 136 | |
| 137 database->Write(std::move(operations), Capture(&error)); | |
| 138 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 139 EXPECT_EQ(DatabaseError::OK, error); | |
| 140 | |
| 141 // Reading "key" should be invalid now. | |
| 142 error = DatabaseError::INVALID_ARGUMENT; | |
| 143 mojo::Array<uint8_t> value; | |
| 144 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | |
| 145 Capture(&error, &value)); | |
| 146 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 147 EXPECT_EQ(DatabaseError::NOT_FOUND, error); | |
| 148 EXPECT_EQ("", value.To<std::string>()); | |
| 149 | |
| 150 // Reading "other" should return "more" | |
| 151 error = DatabaseError::INVALID_ARGUMENT; | |
| 152 database->Get(mojo::Array<uint8_t>::From(std::string("other")), | |
| 153 Capture(&error, &value)); | |
| 154 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 155 EXPECT_EQ(DatabaseError::OK, error); | |
| 156 EXPECT_EQ("more", value.To<std::string>()); | |
| 157 } | |
| 158 | |
| 159 TEST_F(LevelDBApptest, Reconnect) { | |
| 160 DatabaseError error; | |
| 161 | |
| 162 { | |
| 163 filesystem::DirectoryPtr directory; | |
| 164 GetUserDataDir(&directory); | |
| 165 | |
| 166 LevelDBDatabasePtr database; | |
| 167 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 168 Capture(&error)); | |
| 169 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 170 EXPECT_EQ(DatabaseError::OK, error); | |
| 171 | |
| 172 // Write a key to the database. | |
| 173 error = DatabaseError::INVALID_ARGUMENT; | |
| 174 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | |
| 175 mojo::Array<uint8_t>::From(std::string("value")), | |
| 176 Capture(&error)); | |
| 177 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 178 EXPECT_EQ(DatabaseError::OK, error); | |
| 179 | |
| 180 // The database should go out of scope here. | |
| 181 } | |
| 182 | |
| 183 { | |
| 184 filesystem::DirectoryPtr directory; | |
| 185 GetUserDataDir(&directory); | |
| 186 | |
| 187 // Reconnect to the database. | |
| 188 LevelDBDatabasePtr database; | |
| 189 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 190 Capture(&error)); | |
| 191 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 192 EXPECT_EQ(DatabaseError::OK, error); | |
| 193 | |
| 194 // We should still be able to read the key back from the database. | |
| 195 error = DatabaseError::INVALID_ARGUMENT; | |
| 196 mojo::Array<uint8_t> value; | |
| 197 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | |
| 198 Capture(&error, &value)); | |
| 199 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 200 EXPECT_EQ(DatabaseError::OK, error); | |
| 201 EXPECT_EQ("value", value.To<std::string>()); | |
| 202 } | |
| 203 } | |
| 204 | |
| 205 TEST_F(LevelDBApptest, GetSnapshotSimple) { | |
| 206 DatabaseError error; | |
| 207 | |
| 208 filesystem::DirectoryPtr directory; | |
| 209 GetUserDataDir(&directory); | |
| 210 | |
| 211 LevelDBDatabasePtr database; | |
| 212 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 213 Capture(&error)); | |
| 214 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 215 EXPECT_EQ(DatabaseError::OK, error); | |
| 216 | |
| 217 uint64_t snapshot_id = 0; | |
| 218 database->GetSnapshot(Capture(&snapshot_id)); | |
| 219 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 220 EXPECT_NE(static_cast<uint64_t>(0), snapshot_id); | |
| 221 } | |
| 222 | |
| 223 TEST_F(LevelDBApptest, GetFromSnapshots) { | |
| 224 DatabaseError error; | |
| 225 | |
| 226 filesystem::DirectoryPtr directory; | |
| 227 GetUserDataDir(&directory); | |
| 228 | |
| 229 LevelDBDatabasePtr database; | |
| 230 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 231 Capture(&error)); | |
| 232 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 233 EXPECT_EQ(DatabaseError::OK, error); | |
| 234 | |
| 235 // Write a key to the database. | |
| 236 error = DatabaseError::INVALID_ARGUMENT; | |
| 237 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | |
| 238 mojo::Array<uint8_t>::From(std::string("value")), | |
| 239 Capture(&error)); | |
| 240 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 241 EXPECT_EQ(DatabaseError::OK, error); | |
| 242 | |
| 243 // Take a snapshot where key=value. | |
| 244 uint64_t key_value_snapshot = 0; | |
| 245 database->GetSnapshot(Capture(&key_value_snapshot)); | |
| 246 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 247 | |
| 248 // Change key to "yek". | |
| 249 error = DatabaseError::INVALID_ARGUMENT; | |
| 250 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | |
| 251 mojo::Array<uint8_t>::From(std::string("yek")), | |
| 252 Capture(&error)); | |
| 253 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 254 EXPECT_EQ(DatabaseError::OK, error); | |
| 255 | |
| 256 // (Ensure this change is live on the database.) | |
| 257 error = DatabaseError::INVALID_ARGUMENT; | |
| 258 mojo::Array<uint8_t> value; | |
| 259 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | |
| 260 Capture(&error, &value)); | |
| 261 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 262 EXPECT_EQ(DatabaseError::OK, error); | |
| 263 EXPECT_EQ("yek", value.To<std::string>()); | |
| 264 | |
| 265 // But if we were to read from the snapshot, we'd still get value. | |
| 266 error = DatabaseError::INVALID_ARGUMENT; | |
| 267 value.SetToEmpty(); | |
| 268 database->GetFromSnapshot( | |
| 269 key_value_snapshot, | |
| 270 mojo::Array<uint8_t>::From(std::string("key")), | |
| 271 Capture(&error, &value)); | |
| 272 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 273 EXPECT_EQ(DatabaseError::OK, error); | |
| 274 EXPECT_EQ("value", value.To<std::string>()); | |
| 275 } | |
| 276 | |
| 277 #if defined(OS_LINUX) | |
| 278 // Flaky on Linux: http://crbug.com/594977, | |
| 279 #define MAYBE_InvalidArgumentOnInvalidSnapshot DISABLED_InvalidArgumentOnInvalid
Snapshot | |
| 280 #else | |
| 281 #define MAYBE_InvalidArgumentOnInvalidSnapshot InvalidArgumentOnInvalidSnapshot | |
| 282 #endif | |
| 283 TEST_F(LevelDBApptest, InvalidArgumentOnInvalidSnapshot) { | |
| 284 filesystem::DirectoryPtr directory; | |
| 285 GetUserDataDir(&directory); | |
| 286 | |
| 287 LevelDBDatabasePtr database; | |
| 288 DatabaseError error = DatabaseError::INVALID_ARGUMENT; | |
| 289 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | |
| 290 Capture(&error)); | |
| 291 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
| 292 EXPECT_EQ(DatabaseError::OK, error); | |
| 293 | |
| 294 uint64_t invalid_snapshot = 8; | |
| 295 | |
| 296 error = DatabaseError::OK; | |
| 297 mojo::Array<uint8_t> value; | |
| 298 database->GetFromSnapshot( | |
| 299 invalid_snapshot, | |
| 300 mojo::Array<uint8_t>::From(std::string("key")), | |
| 301 Capture(&error, &value)); | |
| 302 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
| 303 EXPECT_EQ(DatabaseError::INVALID_ARGUMENT, error); | |
| 304 } | |
| 305 | |
| 306 } // namespace | |
| 307 } // namespace leveldb | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1812263004:
Convert leveldb_apptests to unit tests. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master