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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
// Copyright 2013 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 "sync/engine/sync_directory_commit_contribution.h"
#include "base/message_loop/message_loop.h"
#include "sync/sessions/status_controller.h"
#include "sync/syncable/entry.h"
#include "sync/syncable/mutable_entry.h"
#include "sync/syncable/syncable_read_transaction.h"
#include "sync/syncable/syncable_write_transaction.h"
#include "sync/test/engine/test_directory_setter_upper.h"
#include "sync/test/engine/test_id_factory.h"
#include "sync/test/engine/test_syncable_utils.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace syncer {
class SyncDirectoryCommitContributionTest : public ::testing::Test {
public:
virtual void SetUp() OVERRIDE {
dir_maker_.SetUp();
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
CreateTypeRoot(&trans, dir(), PREFERENCES);
CreateTypeRoot(&trans, dir(), EXTENSIONS);
}
virtual void TearDown() OVERRIDE {
dir_maker_.TearDown();
}
protected:
int64 CreateUnsyncedItem(syncable::WriteTransaction* trans,
ModelType type,
const std::string& tag) {
syncable::Entry parent_entry(
trans,
syncable::GET_BY_SERVER_TAG,
ModelTypeToRootTag(type));
syncable::MutableEntry entry(
trans,
syncable::CREATE,
type,
parent_entry.GetId(),
tag);
entry.PutIsUnsynced(true);
return entry.GetMetahandle();
}
void CreateSuccessfulCommitResponse(
const sync_pb::SyncEntity& entity,
sync_pb::CommitResponse::EntryResponse* response) {
response->set_response_type(sync_pb::CommitResponse::SUCCESS);
response->set_non_unique_name(entity.name());
response->set_version(entity.version() + 1);
response->set_parent_id_string(entity.parent_id_string());
if (entity.id_string()[0] == '-') // Look for the - in 'c-1234' style IDs.
response->set_id_string(id_factory_.NewServerId().GetServerId());
else
response->set_id_string(entity.id_string());
}
syncable::Directory* dir() {
return dir_maker_.directory();
}
TestIdFactory id_factory_;
private:
base::MessageLoop loop_; // Neeed to initialize the directory.
TestDirectorySetterUpper dir_maker_;
};
// Verify that the SyncDirectoryCommitContribution contains only entries of its
// specified type.
TEST_F(SyncDirectoryCommitContributionTest, GatherByTypes) {
int64 pref1;
{
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
}
scoped_ptr<SyncDirectoryCommitContribution> cc(
SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 5));
ASSERT_EQ(2U, cc->GetNumEntries());
const std::vector<int64>& metahandles = cc->metahandles_;
EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
metahandles.end());
EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
metahandles.end());
cc->CleanUp();
}
// Verify that the SyncDirectoryCommitContributionTest builder function
// truncates if necessary.
TEST_F(SyncDirectoryCommitContributionTest, GatherAndTruncate) {
int64 pref1;
int64 pref2;
{
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
pref2 = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
}
scoped_ptr<SyncDirectoryCommitContribution> cc(
SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 1));
ASSERT_EQ(1U, cc->GetNumEntries());
int64 only_metahandle = cc->metahandles_[0];
EXPECT_TRUE(only_metahandle == pref1 || only_metahandle == pref2);
cc->CleanUp();
}
// Sanity check for building commits from SyncDirectoryCommitContributions.
// This test makes two CommitContribution objects of different types and uses
// them to initialize a commit message. Then it checks that the contents of the
// commit message match those of the directory they came from.
TEST_F(SyncDirectoryCommitContributionTest, PrepareCommit) {
{
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
}
scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
sync_pb::ClientToServerMessage message;
pref_cc->AddToCommitMessage(&message);
ext_cc->AddToCommitMessage(&message);
const sync_pb::CommitMessage& commit_message = message.commit();
std::set<syncable::Id> ids_for_commit;
ASSERT_EQ(3, commit_message.entries_size());
for (int i = 0; i < commit_message.entries_size(); ++i) {
const sync_pb::SyncEntity& entity = commit_message.entries(i);
// The entities in this test have client-style IDs since they've never been
// committed before, so we must use CreateFromClientString to re-create them
// from the commit message.
ids_for_commit.insert(syncable::Id::CreateFromClientString(
entity.id_string()));
}
ASSERT_EQ(3U, ids_for_commit.size());
{
syncable::ReadTransaction trans(FROM_HERE, dir());
for (std::set<syncable::Id>::iterator it = ids_for_commit.begin();
it != ids_for_commit.end(); ++it) {
SCOPED_TRACE(it->value());
syncable::Entry entry(&trans, syncable::GET_BY_ID, *it);
ASSERT_TRUE(entry.good());
EXPECT_TRUE(entry.GetSyncing());
}
}
pref_cc->CleanUp();
ext_cc->CleanUp();
}
// Creates some unsynced items, pretends to commit them, and hands back a
// specially crafted response to the syncer in order to test commit response
// processing. The response simulates a succesful commit scenario.
TEST_F(SyncDirectoryCommitContributionTest, ProcessCommitResponse) {
int64 pref1_handle;
int64 pref2_handle;
int64 ext1_handle;
{
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
pref1_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
pref2_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
ext1_handle = CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
}
scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
sync_pb::ClientToServerMessage message;
pref_cc->AddToCommitMessage(&message);
ext_cc->AddToCommitMessage(&message);
const sync_pb::CommitMessage& commit_message = message.commit();
ASSERT_EQ(3, commit_message.entries_size());
sync_pb::ClientToServerResponse response;
for (int i = 0; i < commit_message.entries_size(); ++i) {
sync_pb::SyncEntity entity = commit_message.entries(i);
sync_pb::CommitResponse_EntryResponse* entry_response =
response.mutable_commit()->add_entryresponse();
CreateSuccessfulCommitResponse(entity, entry_response);
}
sessions::StatusController status;
// Process these in reverse order. Just because we can.
ext_cc->ProcessCommitResponse(response, &status);
pref_cc->ProcessCommitResponse(response, &status);
{
syncable::ReadTransaction trans(FROM_HERE, dir());
syncable::Entry p1(&trans, syncable::GET_BY_HANDLE, pref1_handle);
EXPECT_TRUE(p1.GetId().ServerKnows());
EXPECT_FALSE(p1.GetSyncing());
EXPECT_LT(0, p1.GetServerVersion());
syncable::Entry p2(&trans, syncable::GET_BY_HANDLE, pref2_handle);
EXPECT_TRUE(p2.GetId().ServerKnows());
EXPECT_FALSE(p2.GetSyncing());
EXPECT_LT(0, p2.GetServerVersion());
syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, ext1_handle);
EXPECT_TRUE(e1.GetId().ServerKnows());
EXPECT_FALSE(e1.GetSyncing());
EXPECT_LT(0, e1.GetServerVersion());
}
pref_cc->CleanUp();
ext_cc->CleanUp();
}
} // namespace syncer
|
