syncer_proto_util_unittest.cc revision c407dc5cd9bdc5668497f21b26b09d988ab439de 
1// Copyright (c) 2006-2008 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 "chrome/browser/sync/engine/syncer_proto_util.h"
6
7#include "base/basictypes.h"
8#include "chrome/browser/sync/engine/syncproto.h"
9#include "chrome/browser/sync/syncable/blob.h"
10#include "chrome/browser/sync/syncable/directory_manager.h"
11#include "chrome/browser/sync/syncable/syncable.h"
12#include "chrome/test/sync/engine/mock_connection_manager.h"
13#include "chrome/test/sync/engine/test_directory_setter_upper.h"
14
15#include "testing/gtest/include/gtest/gtest.h"
16
17using syncable::Blob;
18using syncable::ScopedDirLookup;
19using syncable::SyncName;
20
21namespace browser_sync {
22
23TEST(SyncerProtoUtil, TestBlobToProtocolBufferBytesUtilityFunctions) {
24  unsigned char test_data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 4, 2, 9};
25  unsigned char test_data2[] = {1, 99, 3, 4, 5, 6, 7, 8, 0, 1, 4, 2, 9};
26  unsigned char test_data3[] = {99, 2, 3, 4, 5, 6, 7, 8};
27
28  syncable::Blob test_blob1, test_blob2, test_blob3;
29  for (size_t i = 0; i < arraysize(test_data1); ++i)
30    test_blob1.push_back(test_data1[i]);
31  for (size_t i = 0; i < arraysize(test_data2); ++i)
32    test_blob2.push_back(test_data2[i]);
33  for (size_t i = 0; i < arraysize(test_data3); ++i)
34    test_blob3.push_back(test_data3[i]);
35
36  string test_message1(reinterpret_cast<char*>(test_data1),
37      arraysize(test_data1));
38  string test_message2(reinterpret_cast<char*>(test_data2),
39      arraysize(test_data2));
40  string test_message3(reinterpret_cast<char*>(test_data3),
41      arraysize(test_data3));
42
43  EXPECT_TRUE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message1,
44                                                    test_blob1));
45  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message1,
46                                                     test_blob2));
47  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message1,
48                                                     test_blob3));
49  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message2,
50                                                     test_blob1));
51  EXPECT_TRUE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message2,
52                                                    test_blob2));
53  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message2,
54                                                     test_blob3));
55  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message3,
56                                                     test_blob1));
57  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message3,
58                                                     test_blob2));
59  EXPECT_TRUE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message3,
60                                                    test_blob3));
61
62  Blob blob1_copy;
63  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message1,
64                                                     blob1_copy));
65  SyncerProtoUtil::CopyProtoBytesIntoBlob(test_message1, &blob1_copy);
66  EXPECT_TRUE(SyncerProtoUtil::ProtoBytesEqualsBlob(test_message1,
67                                                    blob1_copy));
68
69  std::string message2_copy;
70  EXPECT_FALSE(SyncerProtoUtil::ProtoBytesEqualsBlob(message2_copy,
71                                                     test_blob2));
72  SyncerProtoUtil::CopyBlobIntoProtoBytes(test_blob2, &message2_copy);
73  EXPECT_TRUE(SyncerProtoUtil::ProtoBytesEqualsBlob(message2_copy,
74                                                    test_blob2));
75}
76
77// Tests NameFromSyncEntity and NameFromCommitEntryResponse when only the name
78// field is provided.
79TEST(SyncerProtoUtil, NameExtractionOneName) {
80  SyncEntity one_name_entity;
81  CommitResponse_EntryResponse one_name_response;
82
83  const std::string one_name_string("Eggheadednesses");
84  one_name_entity.set_name(one_name_string);
85  one_name_response.set_name(one_name_string);
86
87  const std::string name_a =
88      SyncerProtoUtil::NameFromSyncEntity(one_name_entity);
89  EXPECT_EQ(one_name_string, name_a);
90}
91
92TEST(SyncerProtoUtil, NameExtractionOneUniqueName) {
93  SyncEntity one_name_entity;
94  CommitResponse_EntryResponse one_name_response;
95
96  const std::string one_name_string("Eggheadednesses");
97
98  one_name_entity.set_non_unique_name(one_name_string);
99  one_name_response.set_non_unique_name(one_name_string);
100
101  const std::string name_a =
102      SyncerProtoUtil::NameFromSyncEntity(one_name_entity);
103  EXPECT_EQ(one_name_string, name_a);
104}
105
106// Tests NameFromSyncEntity and NameFromCommitEntryResponse when both the name
107// field and the non_unique_name fields are provided.
108// Should prioritize non_unique_name.
109TEST(SyncerProtoUtil, NameExtractionTwoNames) {
110  SyncEntity two_name_entity;
111  CommitResponse_EntryResponse two_name_response;
112
113  const std::string neuro("Neuroanatomists");
114  const std::string oxyphen("Oxyphenbutazone");
115
116  two_name_entity.set_name(oxyphen);
117  two_name_entity.set_non_unique_name(neuro);
118
119  two_name_response.set_name(oxyphen);
120  two_name_response.set_non_unique_name(neuro);
121
122  const std::string name_a =
123      SyncerProtoUtil::NameFromSyncEntity(two_name_entity);
124  EXPECT_EQ(neuro, name_a);
125}
126
127class SyncerProtoUtilTest : public testing::Test {
128 public:
129  virtual void SetUp() {
130    setter_upper_.SetUp();
131  }
132
133  virtual void TearDown() {
134    setter_upper_.TearDown();
135  }
136
137 protected:
138  browser_sync::TestDirectorySetterUpper setter_upper_;
139};
140
141TEST_F(SyncerProtoUtilTest, VerifyResponseBirthday) {
142  ScopedDirLookup lookup(setter_upper_.manager(), setter_upper_.name());
143  ASSERT_TRUE(lookup.good());
144
145  // Both sides empty
146  EXPECT_TRUE(lookup->store_birthday().empty());
147  ClientToServerResponse response;
148  EXPECT_FALSE(SyncerProtoUtil::VerifyResponseBirthday(lookup, &response));
149
150  // Remote set, local empty
151  response.set_store_birthday("flan");
152  EXPECT_TRUE(SyncerProtoUtil::VerifyResponseBirthday(lookup, &response));
153  EXPECT_EQ(lookup->store_birthday(), "flan");
154
155  // Remote empty, local set.
156  response.clear_store_birthday();
157  EXPECT_TRUE(SyncerProtoUtil::VerifyResponseBirthday(lookup, &response));
158  EXPECT_EQ(lookup->store_birthday(), "flan");
159
160  // Doesn't match
161  response.set_store_birthday("meat");
162  EXPECT_FALSE(SyncerProtoUtil::VerifyResponseBirthday(lookup, &response));
163
164  response.set_error_code(ClientToServerResponse::CLEAR_PENDING);
165  EXPECT_FALSE(SyncerProtoUtil::VerifyResponseBirthday(lookup, &response));
166}
167
168TEST_F(SyncerProtoUtilTest, AddRequestBirthday) {
169  ScopedDirLookup lookup(setter_upper_.manager(), setter_upper_.name());
170  ASSERT_TRUE(lookup.good());
171
172  EXPECT_TRUE(lookup->store_birthday().empty());
173  ClientToServerMessage msg;
174  SyncerProtoUtil::AddRequestBirthday(lookup, &msg);
175  EXPECT_FALSE(msg.has_store_birthday());
176
177  lookup->set_store_birthday("meat");
178  SyncerProtoUtil::AddRequestBirthday(lookup, &msg);
179  EXPECT_EQ(msg.store_birthday(), "meat");
180}
181
182class DummyConnectionManager : public browser_sync::ServerConnectionManager {
183 public:
184  DummyConnectionManager()
185      : ServerConnectionManager("unused", 0, false, "version", "id"),
186        send_error_(false),
187        access_denied_(false) {}
188
189  virtual ~DummyConnectionManager() {}
190  virtual bool PostBufferWithCachedAuth(const PostBufferParams* params,
191                                        ScopedServerStatusWatcher* watcher) {
192    if (send_error_) {
193      return false;
194    }
195
196    ClientToServerResponse response;
197    if (access_denied_) {
198      response.set_error_code(ClientToServerResponse::ACCESS_DENIED);
199    }
200    response.SerializeToString(params->buffer_out);
201
202    return true;
203  }
204
205  void set_send_error(bool send) {
206    send_error_ = send;
207  }
208
209  void set_access_denied(bool denied) {
210    access_denied_ = denied;
211  }
212
213 private:
214  bool send_error_;
215  bool access_denied_;
216};
217
218TEST_F(SyncerProtoUtilTest, PostAndProcessHeaders) {
219  DummyConnectionManager dcm;
220  ClientToServerMessage msg;
221  msg.set_share("required");
222  msg.set_message_contents(ClientToServerMessage::GET_UPDATES);
223  ClientToServerResponse response;
224
225  dcm.set_send_error(true);
226  EXPECT_FALSE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
227      msg, &response));
228
229  dcm.set_send_error(false);
230  EXPECT_TRUE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
231      msg, &response));
232
233  dcm.set_access_denied(true);
234  EXPECT_FALSE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
235      msg, &response));
236}
237
238}  // namespace browser_sync
239