1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/value_store/value_store_frontend.h"
#include <memory>
#include <utility>
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/path_service.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/task_environment.h"
#include "components/value_store/test_value_store_factory.h"
#include "components/value_store/value_store_task_runner.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace value_store {
class ValueStoreFrontendTest : public testing::Test {
public:
ValueStoreFrontendTest() = default;
void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
base::FilePath test_data_dir;
ASSERT_TRUE(
base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &test_data_dir));
base::FilePath src_db(
test_data_dir.AppendASCII("components/test/data/value_store"));
db_path_ = temp_dir_.GetPath().AppendASCII("temp_db");
base::CopyDirectory(src_db, db_path_, true);
factory_ = new TestValueStoreFactory(db_path_);
ResetStorage();
}
void TearDown() override {
RunUntilIdle();
storage_.reset();
}
// Reset the value store, reloading the DB from disk.
void ResetStorage() {
storage_ = std::make_unique<ValueStoreFrontend>(
factory_, base::FilePath(FILE_PATH_LITERAL("Test dir")),
"test_uma_name", base::SingleThreadTaskRunner::GetCurrentDefault(),
value_store::GetValueStoreTaskRunner());
}
bool Get(const std::string& key, std::optional<base::Value>* output) {
storage_->Get(key, base::BindOnce(&ValueStoreFrontendTest::GetAndWait,
base::Unretained(this), output));
RunUntilIdle();
return output->has_value();
}
protected:
void RunUntilIdle() { task_environment_.RunUntilIdle(); }
void GetAndWait(std::optional<base::Value>* output,
std::optional<base::Value> result) {
*output = std::move(result);
}
base::test::TaskEnvironment task_environment_;
scoped_refptr<TestValueStoreFactory> factory_;
std::unique_ptr<ValueStoreFrontend> storage_;
base::ScopedTempDir temp_dir_;
base::FilePath db_path_;
};
TEST_F(ValueStoreFrontendTest, GetExistingData) {
std::optional<base::Value> value;
ASSERT_FALSE(Get("key0", &value));
// Test existing keys in the DB.
{
ASSERT_TRUE(Get("key1", &value));
ASSERT_TRUE(value->is_string());
EXPECT_EQ("value1", value->GetString());
}
{
ASSERT_TRUE(Get("key2", &value));
ASSERT_TRUE(value->is_int());
EXPECT_EQ(2, value->GetInt());
}
}
TEST_F(ValueStoreFrontendTest, ChangesPersistAfterReload) {
storage_->Set("key0", base::Value(0));
storage_->Set("key1", base::Value("new1"));
storage_->Remove("key2");
// Reload the DB and test our changes.
ResetStorage();
std::optional<base::Value> value;
{
ASSERT_TRUE(Get("key0", &value));
ASSERT_TRUE(value->is_int());
EXPECT_EQ(0, value->GetInt());
}
{
ASSERT_TRUE(Get("key1", &value));
ASSERT_TRUE(value->is_string());
EXPECT_EQ("new1", value->GetString());
}
ASSERT_FALSE(Get("key2", &value));
}
} // namespace value_store
|
