OLD | NEW |
| (Empty) |
1 // Copyright 2013 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/extensions/api/mdns/dns_sd_registry.h" | |
6 #include "chrome/browser/extensions/api/mdns/dns_sd_delegate.h" | |
7 #include "chrome/browser/extensions/api/mdns/dns_sd_device_lister.h" | |
8 #include "testing/gmock/include/gmock/gmock.h" | |
9 #include "testing/gtest/include/gtest/gtest.h" | |
10 | |
11 namespace extensions { | |
12 | |
13 class MockDnsSdDeviceLister : public DnsSdDeviceLister { | |
14 public: | |
15 MockDnsSdDeviceLister() : DnsSdDeviceLister(NULL, NULL, "") {} | |
16 ~MockDnsSdDeviceLister() override {} | |
17 | |
18 MOCK_METHOD1(Discover, void(bool force_update)); | |
19 }; | |
20 | |
21 class TestDnsSdRegistry : public DnsSdRegistry { | |
22 public: | |
23 TestDnsSdRegistry() : DnsSdRegistry(NULL), delegate_(NULL) {} | |
24 ~TestDnsSdRegistry() override {} | |
25 | |
26 MockDnsSdDeviceLister* GetListerForService(const std::string& service_type) { | |
27 return listers_[service_type]; | |
28 } | |
29 | |
30 int GetServiceListenerCount(const std::string& service_type) { | |
31 if (service_data_map_.find(service_type) == service_data_map_.end()) | |
32 return 0; | |
33 | |
34 return service_data_map_[service_type]->GetListenerCount(); | |
35 } | |
36 | |
37 MockDnsSdDeviceLister* GetLister(const std::string& service_type) { | |
38 return listers_.find(service_type) != listers_.end() | |
39 ? listers_[service_type] | |
40 : nullptr; | |
41 } | |
42 | |
43 DnsSdDelegate* GetDelegate() { | |
44 return delegate_; | |
45 } | |
46 | |
47 protected: | |
48 DnsSdDeviceLister* CreateDnsSdDeviceLister( | |
49 DnsSdDelegate* delegate, | |
50 const std::string& service_type, | |
51 local_discovery::ServiceDiscoverySharedClient* discovery_client) | |
52 override { | |
53 delegate_ = delegate; | |
54 MockDnsSdDeviceLister* lister = new MockDnsSdDeviceLister(); | |
55 listers_[service_type] = lister; | |
56 return lister; | |
57 }; | |
58 | |
59 private: | |
60 std::map<std::string, MockDnsSdDeviceLister*> listers_; | |
61 // The last delegate used or NULL. | |
62 DnsSdDelegate* delegate_; | |
63 }; | |
64 | |
65 class MockDnsSdObserver : public DnsSdRegistry::DnsSdObserver { | |
66 public: | |
67 MOCK_METHOD2(OnDnsSdEvent, void(const std::string&, | |
68 const DnsSdRegistry::DnsSdServiceList&)); | |
69 }; | |
70 | |
71 class DnsSdRegistryTest : public testing::Test { | |
72 public: | |
73 DnsSdRegistryTest() {} | |
74 ~DnsSdRegistryTest() override {} | |
75 | |
76 void SetUp() override { | |
77 registry_.reset(new TestDnsSdRegistry()); | |
78 registry_->AddObserver(&observer_); | |
79 } | |
80 | |
81 protected: | |
82 std::unique_ptr<TestDnsSdRegistry> registry_; | |
83 MockDnsSdObserver observer_; | |
84 }; | |
85 | |
86 // Tests registering 2 listeners and removing one. The device lister should | |
87 // not be destroyed. | |
88 TEST_F(DnsSdRegistryTest, RegisterUnregisterListeners) { | |
89 const std::string service_type = "_testing._tcp.local"; | |
90 | |
91 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, | |
92 DnsSdRegistry::DnsSdServiceList())).Times(2); | |
93 | |
94 registry_->RegisterDnsSdListener(service_type); | |
95 registry_->RegisterDnsSdListener(service_type); | |
96 registry_->UnregisterDnsSdListener(service_type); | |
97 EXPECT_EQ(1, registry_->GetServiceListenerCount(service_type)); | |
98 | |
99 registry_->UnregisterDnsSdListener(service_type); | |
100 EXPECT_EQ(0, registry_->GetServiceListenerCount(service_type)); | |
101 } | |
102 | |
103 // Tests that verify calls to ForceDiscovery() are propagated to registered | |
104 // listeners. | |
105 TEST_F(DnsSdRegistryTest, ForceDiscovery) { | |
106 const std::string service_type1 = "_testing1._tcp.local"; | |
107 const std::string service_type2 = "_testing2._tcp.local"; | |
108 | |
109 EXPECT_CALL(observer_, | |
110 OnDnsSdEvent(service_type1, DnsSdRegistry::DnsSdServiceList())); | |
111 EXPECT_CALL(observer_, | |
112 OnDnsSdEvent(service_type2, DnsSdRegistry::DnsSdServiceList())); | |
113 | |
114 registry_->RegisterDnsSdListener(service_type1); | |
115 registry_->RegisterDnsSdListener(service_type2); | |
116 EXPECT_EQ(1, registry_->GetServiceListenerCount(service_type1)); | |
117 EXPECT_EQ(1, registry_->GetServiceListenerCount(service_type2)); | |
118 | |
119 EXPECT_CALL(*registry_->GetLister(service_type1), Discover(false)); | |
120 EXPECT_CALL(*registry_->GetLister(service_type2), Discover(false)); | |
121 registry_->ForceDiscovery(); | |
122 } | |
123 | |
124 // Tests registering a listener and receiving an added and updated event. | |
125 TEST_F(DnsSdRegistryTest, AddAndUpdate) { | |
126 const std::string service_type = "_testing._tcp.local"; | |
127 const std::string ip_address1 = "192.168.0.100"; | |
128 const std::string ip_address2 = "192.168.0.101"; | |
129 | |
130 DnsSdService service; | |
131 service.service_name = "_myDevice." + service_type; | |
132 service.ip_address = ip_address1; | |
133 | |
134 DnsSdRegistry::DnsSdServiceList service_list; | |
135 | |
136 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
137 | |
138 // Add first service. | |
139 service_list.push_back(service); | |
140 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
141 | |
142 // Clear services and add same one with different IP address. | |
143 service_list.clear(); | |
144 service.ip_address = ip_address2; | |
145 service_list.push_back(service); | |
146 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
147 | |
148 registry_->RegisterDnsSdListener(service_type); | |
149 service.ip_address = ip_address1; | |
150 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
151 service.ip_address = ip_address2; | |
152 registry_->GetDelegate()->ServiceChanged(service_type, false, service); | |
153 } | |
154 | |
155 // Tests registering a listener and receiving an added and removed event. | |
156 TEST_F(DnsSdRegistryTest, AddAndRemove) { | |
157 const std::string service_type = "_testing._tcp.local"; | |
158 | |
159 DnsSdService service; | |
160 service.service_name = "_myDevice." + service_type; | |
161 service.ip_address = "192.168.0.100"; | |
162 | |
163 DnsSdRegistry::DnsSdServiceList service_list; | |
164 // Expect to be called twice with empty list (once on register, once after | |
165 // removing). | |
166 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)).Times(2); | |
167 service_list.push_back(service); | |
168 // Expect to be called twice with 1 item (once after adding, once after adding | |
169 // again after removal). | |
170 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)).Times(2); | |
171 | |
172 registry_->RegisterDnsSdListener(service_type); | |
173 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
174 registry_->GetDelegate()->ServiceRemoved(service_type, service.service_name); | |
175 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
176 } | |
177 | |
178 // Tests adding multiple services. | |
179 TEST_F(DnsSdRegistryTest, AddMultipleServices) { | |
180 const std::string service_type = "_testing._tcp.local"; | |
181 | |
182 DnsSdService service; | |
183 service.service_name = "_myDevice." + service_type; | |
184 service.ip_address = "192.168.0.100"; | |
185 | |
186 DnsSdService service2; | |
187 service.service_name = "_myDevice2." + service_type; | |
188 service.ip_address = "192.168.0.101"; | |
189 | |
190 DnsSdRegistry::DnsSdServiceList service_list; | |
191 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
192 service_list.push_back(service); | |
193 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
194 service_list.push_back(service2); | |
195 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
196 | |
197 registry_->RegisterDnsSdListener(service_type); | |
198 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
199 registry_->GetDelegate()->ServiceChanged(service_type, true, service2); | |
200 } | |
201 | |
202 // Tests adding multiple services and handling a flush event. | |
203 TEST_F(DnsSdRegistryTest, FlushCache) { | |
204 testing::InSequence s; | |
205 const std::string service_type = "_testing._tcp.local"; | |
206 | |
207 DnsSdService service; | |
208 service.service_name = "_myDevice." + service_type; | |
209 service.ip_address = "192.168.0.100"; | |
210 | |
211 DnsSdService service2; | |
212 service.service_name = "_myDevice2." + service_type; | |
213 service.ip_address = "192.168.0.101"; | |
214 | |
215 DnsSdRegistry::DnsSdServiceList service_list; | |
216 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
217 service_list.push_back(service); | |
218 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
219 service_list.push_back(service2); | |
220 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
221 service_list.clear(); | |
222 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
223 | |
224 registry_->RegisterDnsSdListener(service_type); | |
225 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
226 registry_->GetDelegate()->ServiceChanged(service_type, true, service2); | |
227 registry_->GetDelegate()->ServicesFlushed(service_type); | |
228 } | |
229 | |
230 // Tests receiving an update from the DnsSdDelegate that does not change the | |
231 // service object does not notify the observer. | |
232 TEST_F(DnsSdRegistryTest, UpdateOnlyIfChanged) { | |
233 const std::string service_type = "_testing._tcp.local"; | |
234 const std::string ip_address = "192.168.0.100"; | |
235 | |
236 DnsSdService service; | |
237 service.service_name = "_myDevice." + service_type; | |
238 service.ip_address = ip_address; | |
239 | |
240 DnsSdRegistry::DnsSdServiceList service_list; | |
241 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
242 | |
243 // Expect service_list with initial service. | |
244 service_list.push_back(service); | |
245 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
246 | |
247 // Expect service_list with updated service. | |
248 service_list.clear(); | |
249 service.ip_address = "192.168.0.101"; | |
250 service_list.push_back(service); | |
251 EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)); | |
252 // No more calls to observer_. | |
253 | |
254 registry_->RegisterDnsSdListener(service_type); | |
255 service.ip_address = "192.168.0.100"; | |
256 registry_->GetDelegate()->ServiceChanged(service_type, true, service); | |
257 // Update with changed ip address. | |
258 service.ip_address = "192.168.0.101"; | |
259 registry_->GetDelegate()->ServiceChanged(service_type, false, service); | |
260 // Update with no changes to the service. | |
261 registry_->GetDelegate()->ServiceChanged(service_type, false, service); | |
262 } | |
263 | |
264 } // namespace extensions | |
OLD | NEW |