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 "sync/api/attachments/fake_attachment_store.h"
6
7 #include "base/bind.h"
8 #include "base/memory/ref_counted_memory.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/thread_task_runner_handle.h"
12 #include "sync/api/attachments/attachment.h"
13 #include "sync/protocol/sync.pb.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace syncer {
17
18 const char kTestData1[] = "test data 1";
19 const char kTestData2[] = "test data 2";
20
21 class FakeAttachmentStoreTest : public testing::Test {
22 protected:
23 base::MessageLoop message_loop;
24 scoped_refptr<FakeAttachmentStore> store;
25 AttachmentStore::Result result;
26 scoped_ptr<AttachmentMap> attachments;
27 scoped_ptr<AttachmentIdList> failed_attachment_ids;
28
29 AttachmentStore::ReadCallback read_callback;
30 AttachmentStore::WriteCallback write_callback;
31 AttachmentStore::DropCallback drop_callback;
32
33 scoped_refptr<base::RefCountedString> some_data1;
34 scoped_refptr<base::RefCountedString> some_data2;
35
FakeAttachmentStoreTest()36 FakeAttachmentStoreTest()
37 : store(new FakeAttachmentStore(base::ThreadTaskRunnerHandle::Get())) {}
38
SetUp()39 virtual void SetUp() {
40 Clear();
41 read_callback = base::Bind(&FakeAttachmentStoreTest::CopyResultAttachments,
42 base::Unretained(this),
43 &result,
44 &attachments,
45 &failed_attachment_ids);
46 write_callback = base::Bind(
47 &FakeAttachmentStoreTest::CopyResult, base::Unretained(this), &result);
48 drop_callback = write_callback;
49
50 some_data1 = new base::RefCountedString;
51 some_data1->data() = kTestData1;
52
53 some_data2 = new base::RefCountedString;
54 some_data2->data() = kTestData2;
55 }
56
ClearAndPumpLoop()57 virtual void ClearAndPumpLoop() {
58 Clear();
59 message_loop.RunUntilIdle();
60 }
61
62 private:
Clear()63 void Clear() {
64 result = AttachmentStore::UNSPECIFIED_ERROR;
65 attachments.reset();
66 failed_attachment_ids.reset();
67 }
68
CopyResult(AttachmentStore::Result * destination_result,const AttachmentStore::Result & source_result)69 void CopyResult(AttachmentStore::Result* destination_result,
70 const AttachmentStore::Result& source_result) {
71 *destination_result = source_result;
72 }
73
CopyResultAttachments(AttachmentStore::Result * destination_result,scoped_ptr<AttachmentMap> * destination_attachments,scoped_ptr<AttachmentIdList> * destination_failed_attachment_ids,const AttachmentStore::Result & source_result,scoped_ptr<AttachmentMap> source_attachments,scoped_ptr<AttachmentIdList> source_failed_attachment_ids)74 void CopyResultAttachments(
75 AttachmentStore::Result* destination_result,
76 scoped_ptr<AttachmentMap>* destination_attachments,
77 scoped_ptr<AttachmentIdList>* destination_failed_attachment_ids,
78 const AttachmentStore::Result& source_result,
79 scoped_ptr<AttachmentMap> source_attachments,
80 scoped_ptr<AttachmentIdList> source_failed_attachment_ids) {
81 CopyResult(destination_result, source_result);
82 *destination_attachments = source_attachments.Pass();
83 *destination_failed_attachment_ids = source_failed_attachment_ids.Pass();
84 }
85 };
86
87 // Verify that we do not overwrite existing attachments and that we do not treat
88 // it as an error.
TEST_F(FakeAttachmentStoreTest,Write_NoOverwriteNoError)89 TEST_F(FakeAttachmentStoreTest, Write_NoOverwriteNoError) {
90 // Create two attachments with the same id but different data.
91 Attachment attachment1 = Attachment::Create(some_data1);
92 Attachment attachment2 =
93 Attachment::CreateWithId(attachment1.GetId(), some_data2);
94
95 // Write the first one.
96 AttachmentList some_attachments;
97 some_attachments.push_back(attachment1);
98 store->Write(some_attachments, write_callback);
99 ClearAndPumpLoop();
100 EXPECT_EQ(result, AttachmentStore::SUCCESS);
101
102 // Write the second one.
103 some_attachments.clear();
104 some_attachments.push_back(attachment2);
105 store->Write(some_attachments, write_callback);
106 ClearAndPumpLoop();
107 EXPECT_EQ(result, AttachmentStore::SUCCESS);
108
109 // Read it back and see that it was not overwritten.
110 AttachmentIdList some_attachment_ids;
111 some_attachment_ids.push_back(attachment1.GetId());
112 store->Read(some_attachment_ids, read_callback);
113 ClearAndPumpLoop();
114 EXPECT_EQ(result, AttachmentStore::SUCCESS);
115 EXPECT_EQ(attachments->size(), 1U);
116 EXPECT_EQ(failed_attachment_ids->size(), 0U);
117 AttachmentMap::const_iterator a1 = attachments->find(attachment1.GetId());
118 EXPECT_TRUE(a1 != attachments->end());
119 EXPECT_TRUE(attachment1.GetData()->Equals(a1->second.GetData()));
120 }
121
122 // Verify that we can write some attachments and read them back.
TEST_F(FakeAttachmentStoreTest,Write_RoundTrip)123 TEST_F(FakeAttachmentStoreTest, Write_RoundTrip) {
124 Attachment attachment1 = Attachment::Create(some_data1);
125 Attachment attachment2 = Attachment::Create(some_data2);
126 AttachmentList some_attachments;
127 some_attachments.push_back(attachment1);
128 some_attachments.push_back(attachment2);
129
130 store->Write(some_attachments, write_callback);
131 ClearAndPumpLoop();
132 EXPECT_EQ(result, AttachmentStore::SUCCESS);
133
134 AttachmentIdList some_attachment_ids;
135 some_attachment_ids.push_back(attachment1.GetId());
136 some_attachment_ids.push_back(attachment2.GetId());
137 store->Read(some_attachment_ids, read_callback);
138 ClearAndPumpLoop();
139 EXPECT_EQ(result, AttachmentStore::SUCCESS);
140 EXPECT_EQ(attachments->size(), 2U);
141 EXPECT_EQ(failed_attachment_ids->size(), 0U);
142
143 AttachmentMap::const_iterator a1 = attachments->find(attachment1.GetId());
144 EXPECT_TRUE(a1 != attachments->end());
145 EXPECT_TRUE(attachment1.GetData()->Equals(a1->second.GetData()));
146
147 AttachmentMap::const_iterator a2 = attachments->find(attachment2.GetId());
148 EXPECT_TRUE(a2 != attachments->end());
149 EXPECT_TRUE(attachment2.GetData()->Equals(a2->second.GetData()));
150 }
151
152 // Try to read two attachments when only one exists.
TEST_F(FakeAttachmentStoreTest,Read_OneNotFound)153 TEST_F(FakeAttachmentStoreTest, Read_OneNotFound) {
154 Attachment attachment1 = Attachment::Create(some_data1);
155 Attachment attachment2 = Attachment::Create(some_data2);
156
157 AttachmentList some_attachments;
158 // Write attachment1 only.
159 some_attachments.push_back(attachment1);
160 store->Write(some_attachments, write_callback);
161 ClearAndPumpLoop();
162 EXPECT_EQ(result, AttachmentStore::SUCCESS);
163
164 // Try to read both attachment1 and attachment2.
165 AttachmentIdList ids;
166 ids.push_back(attachment1.GetId());
167 ids.push_back(attachment2.GetId());
168 store->Read(ids, read_callback);
169 ClearAndPumpLoop();
170
171 // See that only attachment1 was read.
172 EXPECT_EQ(result, AttachmentStore::UNSPECIFIED_ERROR);
173 EXPECT_EQ(attachments->size(), 1U);
174 EXPECT_EQ(failed_attachment_ids->size(), 1U);
175 }
176
177 // Try to drop two attachments when only one exists. Verify that no error occurs
178 // and that the existing attachment was dropped.
TEST_F(FakeAttachmentStoreTest,Drop_DropTwoButOnlyOneExists)179 TEST_F(FakeAttachmentStoreTest, Drop_DropTwoButOnlyOneExists) {
180 // First, create two attachments.
181 Attachment attachment1 = Attachment::Create(some_data1);
182 Attachment attachment2 = Attachment::Create(some_data2);
183 AttachmentList some_attachments;
184 some_attachments.push_back(attachment1);
185 some_attachments.push_back(attachment2);
186 store->Write(some_attachments, write_callback);
187 ClearAndPumpLoop();
188 EXPECT_EQ(result, AttachmentStore::SUCCESS);
189
190 // Drop attachment1 only.
191 AttachmentIdList ids;
192 ids.push_back(attachment1.GetId());
193 store->Drop(ids, drop_callback);
194 ClearAndPumpLoop();
195 EXPECT_EQ(result, AttachmentStore::SUCCESS);
196
197 // See that attachment1 is gone.
198 store->Read(ids, read_callback);
199 ClearAndPumpLoop();
200 EXPECT_EQ(result, AttachmentStore::UNSPECIFIED_ERROR);
201 EXPECT_EQ(attachments->size(), 0U);
202 EXPECT_EQ(failed_attachment_ids->size(), 1U);
203 EXPECT_EQ((*failed_attachment_ids)[0], attachment1.GetId());
204
205 // Drop both attachment1 and attachment2.
206 ids.clear();
207 ids.push_back(attachment1.GetId());
208 ids.push_back(attachment2.GetId());
209 store->Drop(ids, drop_callback);
210 ClearAndPumpLoop();
211 EXPECT_EQ(result, AttachmentStore::SUCCESS);
212
213 // See that attachment2 is now gone.
214 ids.clear();
215 ids.push_back(attachment2.GetId());
216 store->Read(ids, read_callback);
217 ClearAndPumpLoop();
218 EXPECT_EQ(result, AttachmentStore::UNSPECIFIED_ERROR);
219 EXPECT_EQ(attachments->size(), 0U);
220 EXPECT_EQ(failed_attachment_ids->size(), 1U);
221 EXPECT_EQ((*failed_attachment_ids)[0], attachment2.GetId());
222 }
223
224 // Verify that attempting to drop an attachment that does not exist is not an
225 // error.
TEST_F(FakeAttachmentStoreTest,Drop_DoesNotExist)226 TEST_F(FakeAttachmentStoreTest, Drop_DoesNotExist) {
227 Attachment attachment1 = Attachment::Create(some_data1);
228 AttachmentList some_attachments;
229 some_attachments.push_back(attachment1);
230 store->Write(some_attachments, write_callback);
231 ClearAndPumpLoop();
232 EXPECT_EQ(result, AttachmentStore::SUCCESS);
233
234 // Drop the attachment.
235 AttachmentIdList ids;
236 ids.push_back(attachment1.GetId());
237 store->Drop(ids, drop_callback);
238 ClearAndPumpLoop();
239 EXPECT_EQ(result, AttachmentStore::SUCCESS);
240
241 // See that it's gone.
242 store->Read(ids, read_callback);
243 ClearAndPumpLoop();
244 EXPECT_EQ(result, AttachmentStore::UNSPECIFIED_ERROR);
245 EXPECT_EQ(attachments->size(), 0U);
246 EXPECT_EQ(failed_attachment_ids->size(), 1U);
247 EXPECT_EQ((*failed_attachment_ids)[0], attachment1.GetId());
248
249 // Drop again, see that no error occurs.
250 ids.clear();
251 ids.push_back(attachment1.GetId());
252 store->Drop(ids, drop_callback);
253 ClearAndPumpLoop();
254 EXPECT_EQ(result, AttachmentStore::SUCCESS);
255 }
256
257 } // namespace syncer
258