OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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/sessions/sync_session.h" | |
6 #include "chrome/browser/sync/test/engine/test_id_factory.h" | |
7 #include "testing/gtest/include/gtest/gtest.h" | |
8 | |
9 namespace browser_sync { | |
10 namespace sessions { | |
11 | |
12 class StatusControllerTest : public testing::Test { | |
13 public: | |
14 virtual void SetUp() { | |
15 routes_[syncable::BOOKMARKS] = GROUP_UI; | |
16 } | |
17 protected: | |
18 ModelSafeRoutingInfo routes_; | |
19 }; | |
20 | |
21 TEST_F(StatusControllerTest, GetsDirty) { | |
22 StatusController status(routes_); | |
23 status.set_num_server_changes_remaining(30); | |
24 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
25 | |
26 status.set_invalid_store(true); | |
27 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
28 status.set_invalid_store(false); | |
29 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
30 | |
31 status.increment_num_successful_commits(); | |
32 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
33 status.increment_num_successful_commits(); | |
34 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
35 | |
36 { | |
37 ScopedModelSafeGroupRestriction r(&status, GROUP_UI); | |
38 status.mutable_conflict_progress()-> | |
39 AddSimpleConflictingItemById(syncable::Id()); | |
40 } | |
41 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
42 | |
43 std::vector<int64> v; | |
44 v.push_back(1); | |
45 status.set_unsynced_handles(v); | |
46 EXPECT_TRUE(status.TestAndClearIsDirty()); | |
47 std::vector<int64> v2; | |
48 v2.push_back(1); | |
49 status.set_unsynced_handles(v2); | |
50 EXPECT_FALSE(status.TestAndClearIsDirty()); // Test for deep comparison. | |
51 } | |
52 | |
53 TEST_F(StatusControllerTest, StaysClean) { | |
54 StatusController status(routes_); | |
55 status.update_conflicts_resolved(true); | |
56 EXPECT_FALSE(status.TestAndClearIsDirty()); | |
57 | |
58 status.set_items_committed(); | |
59 EXPECT_FALSE(status.TestAndClearIsDirty()); | |
60 | |
61 OrderedCommitSet commits(routes_); | |
62 commits.AddCommitItem(0, syncable::Id(), syncable::BOOKMARKS); | |
63 status.set_commit_set(commits); | |
64 EXPECT_FALSE(status.TestAndClearIsDirty()); | |
65 } | |
66 | |
67 // This test is useful, as simple as it sounds, due to the copy-paste prone | |
68 // nature of status_controller.cc (we have had bugs in the past where a set_foo | |
69 // method was actually setting |bar_| instead!). | |
70 TEST_F(StatusControllerTest, ReadYourWrites) { | |
71 StatusController status(routes_); | |
72 status.set_num_server_changes_remaining(13); | |
73 EXPECT_EQ(13, status.num_server_changes_remaining()); | |
74 | |
75 EXPECT_FALSE(status.syncer_status().invalid_store); | |
76 status.set_invalid_store(true); | |
77 EXPECT_TRUE(status.syncer_status().invalid_store); | |
78 | |
79 EXPECT_FALSE(status.conflicts_resolved()); | |
80 status.update_conflicts_resolved(true); | |
81 EXPECT_TRUE(status.conflicts_resolved()); | |
82 | |
83 status.set_last_download_updates_result(SYNCER_OK); | |
84 EXPECT_EQ(SYNCER_OK, status.error().last_download_updates_result); | |
85 | |
86 status.set_last_post_commit_result(SYNC_AUTH_ERROR); | |
87 EXPECT_EQ(SYNC_AUTH_ERROR, status.error().last_post_commit_result); | |
88 | |
89 status.set_last_process_commit_response_result(SYNC_SERVER_ERROR); | |
90 EXPECT_EQ(SYNC_SERVER_ERROR, | |
91 status.error().last_process_commit_response_result); | |
92 | |
93 for (int i = 0; i < 14; i++) | |
94 status.increment_num_successful_commits(); | |
95 EXPECT_EQ(14, status.syncer_status().num_successful_commits); | |
96 | |
97 std::vector<int64> v; | |
98 v.push_back(16); | |
99 status.set_unsynced_handles(v); | |
100 EXPECT_EQ(16, v[0]); | |
101 } | |
102 | |
103 TEST_F(StatusControllerTest, HasConflictingUpdates) { | |
104 StatusController status(routes_); | |
105 EXPECT_FALSE(status.HasConflictingUpdates()); | |
106 { | |
107 ScopedModelSafeGroupRestriction r(&status, GROUP_UI); | |
108 EXPECT_FALSE(status.update_progress()); | |
109 status.mutable_update_progress()->AddAppliedUpdate(SUCCESS, | |
110 syncable::Id()); | |
111 status.mutable_update_progress()->AddAppliedUpdate(CONFLICT_SIMPLE, | |
112 syncable::Id()); | |
113 EXPECT_TRUE(status.update_progress()->HasConflictingUpdates()); | |
114 } | |
115 | |
116 EXPECT_TRUE(status.HasConflictingUpdates()); | |
117 | |
118 { | |
119 ScopedModelSafeGroupRestriction r(&status, GROUP_PASSIVE); | |
120 EXPECT_FALSE(status.update_progress()); | |
121 } | |
122 } | |
123 | |
124 TEST_F(StatusControllerTest, HasConflictingUpdates_NonBlockingUpdates) { | |
125 StatusController status(routes_); | |
126 EXPECT_FALSE(status.HasConflictingUpdates()); | |
127 { | |
128 ScopedModelSafeGroupRestriction r(&status, GROUP_UI); | |
129 EXPECT_FALSE(status.update_progress()); | |
130 status.mutable_update_progress()->AddAppliedUpdate(SUCCESS, | |
131 syncable::Id()); | |
132 status.mutable_update_progress()->AddAppliedUpdate(CONFLICT_HIERARCHY, | |
133 syncable::Id()); | |
134 EXPECT_TRUE(status.update_progress()->HasConflictingUpdates()); | |
135 } | |
136 | |
137 EXPECT_TRUE(status.HasConflictingUpdates()); | |
138 } | |
139 | |
140 TEST_F(StatusControllerTest, CountUpdates) { | |
141 StatusController status(routes_); | |
142 EXPECT_EQ(0, status.CountUpdates()); | |
143 ClientToServerResponse* response(status.mutable_updates_response()); | |
144 sync_pb::SyncEntity* entity1 = response->mutable_get_updates()->add_entries(); | |
145 sync_pb::SyncEntity* entity2 = response->mutable_get_updates()->add_entries(); | |
146 ASSERT_TRUE(entity1 != NULL && entity2 != NULL); | |
147 EXPECT_EQ(2, status.CountUpdates()); | |
148 } | |
149 | |
150 // Test TotalNumConflictingItems | |
151 TEST_F(StatusControllerTest, TotalNumConflictingItems) { | |
152 StatusController status(routes_); | |
153 TestIdFactory f; | |
154 { | |
155 ScopedModelSafeGroupRestriction r(&status, GROUP_UI); | |
156 EXPECT_FALSE(status.conflict_progress()); | |
157 status.mutable_conflict_progress()-> | |
158 AddSimpleConflictingItemById(f.NewLocalId()); | |
159 status.mutable_conflict_progress()-> | |
160 AddSimpleConflictingItemById(f.NewLocalId()); | |
161 EXPECT_EQ(2, status.conflict_progress()->SimpleConflictingItemsSize()); | |
162 } | |
163 EXPECT_EQ(2, status.TotalNumConflictingItems()); | |
164 { | |
165 ScopedModelSafeGroupRestriction r(&status, GROUP_DB); | |
166 EXPECT_FALSE(status.conflict_progress()); | |
167 status.mutable_conflict_progress()-> | |
168 AddSimpleConflictingItemById(f.NewLocalId()); | |
169 status.mutable_conflict_progress()-> | |
170 AddSimpleConflictingItemById(f.NewLocalId()); | |
171 EXPECT_EQ(2, status.conflict_progress()->SimpleConflictingItemsSize()); | |
172 } | |
173 EXPECT_EQ(4, status.TotalNumConflictingItems()); | |
174 } | |
175 | |
176 // Basic test that non group-restricted state accessors don't cause violations. | |
177 TEST_F(StatusControllerTest, Unrestricted) { | |
178 StatusController status(routes_); | |
179 const UpdateProgress* progress = | |
180 status.GetUnrestrictedUpdateProgress(GROUP_UI); | |
181 EXPECT_FALSE(progress); | |
182 status.mutable_commit_message(); | |
183 status.commit_response(); | |
184 status.mutable_commit_response(); | |
185 status.updates_response(); | |
186 status.mutable_updates_response(); | |
187 status.error(); | |
188 status.syncer_status(); | |
189 status.num_server_changes_remaining(); | |
190 status.commit_ids(); | |
191 status.HasBookmarkCommitActivity(); | |
192 status.download_updates_succeeded(); | |
193 status.ServerSaysNothingMoreToDownload(); | |
194 status.group_restriction(); | |
195 } | |
196 | |
197 } // namespace sessions | |
198 } // namespace browser_sync | |
OLD | NEW |