OLD | NEW |
1 // Copyright (c) 2011 The Chromium OS Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <deque> | 5 #include <deque> |
6 #include <string> | 6 #include <string> |
7 | 7 |
8 #include <gtest/gtest.h> | 8 #include <gtest/gtest.h> |
9 | 9 |
10 #include "update_engine/chrome_browser_proxy_resolver.h" | 10 #include "update_engine/chrome_browser_proxy_resolver.h" |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 SendReplyArgs* args = reinterpret_cast<SendReplyArgs*>(data); | 100 SendReplyArgs* args = reinterpret_cast<SendReplyArgs*>(data); |
101 ChromeBrowserProxyResolver::StaticFilterMessage( | 101 ChromeBrowserProxyResolver::StaticFilterMessage( |
102 args->connection, | 102 args->connection, |
103 args->message, | 103 args->message, |
104 args->resolver); | 104 args->resolver); |
105 return FALSE; // Don't keep calling this function | 105 return FALSE; // Don't keep calling this function |
106 } | 106 } |
107 | 107 |
108 // chrome_replies should be set to whether or not we fake a reply from | 108 // chrome_replies should be set to whether or not we fake a reply from |
109 // chrome. If there's no reply, the resolver should time out. | 109 // chrome. If there's no reply, the resolver should time out. |
110 void RunTest(bool chrome_replies) { | 110 // If chrome_alive is false, assume that sending to chrome fails. |
| 111 void RunTest(bool chrome_replies, bool chrome_alive) { |
111 long number = 1; | 112 long number = 1; |
112 DBusGConnection* kMockSystemGBus = | 113 DBusGConnection* kMockSystemGBus = |
113 reinterpret_cast<DBusGConnection*>(number++); | 114 reinterpret_cast<DBusGConnection*>(number++); |
114 DBusConnection* kMockSystemBus = | 115 DBusConnection* kMockSystemBus = |
115 reinterpret_cast<DBusConnection*>(number++); | 116 reinterpret_cast<DBusConnection*>(number++); |
116 DBusGProxy* kMockDbusProxy = | 117 DBusGProxy* kMockDbusProxy = |
117 reinterpret_cast<DBusGProxy*>(number++); | 118 reinterpret_cast<DBusGProxy*>(number++); |
118 DBusMessage* kMockDbusMessage = | 119 DBusMessage* kMockDbusMessage = |
119 reinterpret_cast<DBusMessage*>(number++); | 120 reinterpret_cast<DBusMessage*>(number++); |
120 | 121 |
121 const char kUrl[] = "http://example.com/blah"; | 122 const char kUrl[] = "http://example.com/blah"; |
122 | 123 |
123 MockDbusGlib dbus_iface; | 124 MockDbusGlib dbus_iface; |
124 | 125 |
125 EXPECT_CALL(dbus_iface, BusGet(_, _)) | 126 EXPECT_CALL(dbus_iface, BusGet(_, _)) |
126 .Times(3) | 127 .Times(chrome_alive ? 3 : 2) |
127 .WillRepeatedly(Return(kMockSystemGBus)); | 128 .WillRepeatedly(Return(kMockSystemGBus)); |
128 EXPECT_CALL(dbus_iface, | 129 EXPECT_CALL(dbus_iface, |
129 ConnectionGetConnection(kMockSystemGBus)) | 130 ConnectionGetConnection(kMockSystemGBus)) |
130 .Times(2) | 131 .Times(chrome_alive ? 2 : 1) |
131 .WillRepeatedly(Return(kMockSystemBus)); | 132 .WillRepeatedly(Return(kMockSystemBus)); |
132 EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _)); | 133 EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _)); |
133 EXPECT_CALL(dbus_iface, | 134 EXPECT_CALL(dbus_iface, |
134 DbusConnectionAddFilter(kMockSystemBus, _, _, _)) | 135 DbusConnectionAddFilter(kMockSystemBus, _, _, _)) |
135 .WillOnce(Return(1)); | 136 .WillOnce(Return(1)); |
136 EXPECT_CALL(dbus_iface, | 137 EXPECT_CALL(dbus_iface, |
137 ProxyNewForNameOwner(kMockSystemGBus, | 138 ProxyNewForNameOwner(kMockSystemGBus, |
138 StrEq(kLibCrosServiceName), | 139 StrEq(kLibCrosServiceName), |
139 StrEq(kLibCrosServicePath), | 140 StrEq(kLibCrosServicePath), |
140 StrEq(kLibCrosServiceInterface), | 141 StrEq(kLibCrosServiceInterface), |
141 _)) | 142 _)) |
142 .WillOnce(Return(kMockDbusProxy)); | 143 .WillOnce(Return(chrome_alive ? kMockDbusProxy : NULL)); |
143 EXPECT_CALL(dbus_iface, ProxyCall( | 144 if (chrome_alive) |
144 kMockDbusProxy, | 145 EXPECT_CALL(dbus_iface, ProxyCall( |
145 StrEq(kLibCrosServiceResolveNetworkProxyMethodName), | 146 kMockDbusProxy, |
146 _, | 147 StrEq(kLibCrosServiceResolveNetworkProxyMethodName), |
147 G_TYPE_STRING, StrEq(kUrl), | 148 _, |
148 G_TYPE_STRING, StrEq(kLibCrosProxyResolveSignalInterface), | 149 G_TYPE_STRING, StrEq(kUrl), |
149 G_TYPE_STRING, StrEq(kLibCrosProxyResolveName), | 150 G_TYPE_STRING, StrEq(kLibCrosProxyResolveSignalInterface), |
150 G_TYPE_INVALID)) | 151 G_TYPE_STRING, StrEq(kLibCrosProxyResolveName), |
151 .WillOnce(Return(TRUE)); | 152 G_TYPE_INVALID)) |
| 153 .WillOnce(Return(chrome_alive ? TRUE : FALSE)); |
152 EXPECT_CALL(dbus_iface, | 154 EXPECT_CALL(dbus_iface, |
153 DbusConnectionRemoveFilter(kMockSystemBus, _, _)); | 155 DbusConnectionRemoveFilter(kMockSystemBus, _, _)); |
154 if (chrome_replies) { | 156 if (chrome_replies) { |
155 EXPECT_CALL(dbus_iface, | 157 EXPECT_CALL(dbus_iface, |
156 DbusMessageIsSignal(kMockDbusMessage, | 158 DbusMessageIsSignal(kMockDbusMessage, |
157 kLibCrosProxyResolveSignalInterface, | 159 kLibCrosProxyResolveSignalInterface, |
158 kLibCrosProxyResolveName)) | 160 kLibCrosProxyResolveName)) |
159 .WillOnce(Return(1)); | 161 .WillOnce(Return(1)); |
160 EXPECT_CALL(dbus_iface, | 162 EXPECT_CALL(dbus_iface, |
161 DbusMessageGetArgs(kMockDbusMessage, _, | 163 DbusMessageGetArgs(kMockDbusMessage, _, |
162 DBUS_TYPE_STRING, _, | 164 DBUS_TYPE_STRING, _, |
163 DBUS_TYPE_STRING, _, | 165 DBUS_TYPE_STRING, _, |
164 DBUS_TYPE_STRING, _, | 166 DBUS_TYPE_STRING, _, |
165 DBUS_TYPE_INVALID)) | 167 DBUS_TYPE_INVALID)) |
166 .WillOnce(DoAll(SetArgumentPointee<3>(strdup(kUrl)), | 168 .WillOnce(DoAll(SetArgumentPointee<3>(strdup(kUrl)), |
167 SetArgumentPointee<5>( | 169 SetArgumentPointee<5>( |
168 strdup("SOCKS5 192.168.52.83:5555;DIRECT")), | 170 strdup("SOCKS5 192.168.52.83:5555;DIRECT")), |
169 Return(TRUE))); | 171 Return(TRUE))); |
170 } | 172 } |
171 | 173 |
172 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); | 174 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
173 | 175 |
174 ChromeBrowserProxyResolver resolver(&dbus_iface); | 176 ChromeBrowserProxyResolver resolver(&dbus_iface); |
175 EXPECT_TRUE(resolver.Init()); | 177 EXPECT_EQ(chrome_alive, resolver.Init()); |
176 resolver.set_timeout(1); | 178 resolver.set_timeout(1); |
177 SendReplyArgs args = { | 179 SendReplyArgs args = { |
178 kMockSystemBus, | 180 kMockSystemBus, |
179 kMockDbusMessage, | 181 kMockDbusMessage, |
180 &resolver | 182 &resolver |
181 }; | 183 }; |
182 if (chrome_replies) | 184 if (chrome_replies) |
183 g_idle_add(SendReply, &args); | 185 g_idle_add(SendReply, &args); |
184 EXPECT_TRUE(resolver.GetProxiesForUrl(kUrl, | 186 EXPECT_TRUE(resolver.GetProxiesForUrl(kUrl, |
185 chrome_replies ? | 187 chrome_replies ? |
186 &DbusInterfaceTestResolved : | 188 &DbusInterfaceTestResolved : |
187 &DbusInterfaceTestResolvedNoReply, | 189 &DbusInterfaceTestResolvedNoReply, |
188 loop)); | 190 loop)); |
189 g_main_loop_run(loop); | 191 g_main_loop_run(loop); |
190 g_main_loop_unref(loop); | 192 g_main_loop_unref(loop); |
191 } | 193 } |
192 } // namespace {} | 194 } // namespace {} |
193 | 195 |
194 TEST(ChromeBrowserProxyResolverTest, SuccessTest) { | 196 TEST(ChromeBrowserProxyResolverTest, SuccessTest) { |
195 RunTest(true); | 197 RunTest(true, true); |
196 } | 198 } |
197 | 199 |
198 TEST(ChromeBrowserProxyResolverTest, NoReplyTest) { | 200 TEST(ChromeBrowserProxyResolverTest, NoReplyTest) { |
199 RunTest(false); | 201 RunTest(false, true); |
200 } | 202 } |
201 | 203 |
202 TEST(ChromeBrowserProxyResolverTest, NoChromeTest) { | 204 TEST(ChromeBrowserProxyResolverTest, NoChromeTest) { |
203 long number = 1; | 205 RunTest(false, false); |
204 DBusGConnection* kMockSystemGBus = | |
205 reinterpret_cast<DBusGConnection*>(number++); | |
206 DBusConnection* kMockSystemBus = | |
207 reinterpret_cast<DBusConnection*>(number++); | |
208 | |
209 const char kUrl[] = "http://example.com/blah"; | |
210 | |
211 MockDbusGlib dbus_iface; | |
212 | |
213 EXPECT_CALL(dbus_iface, BusGet(_, _)) | |
214 .Times(2) | |
215 .WillRepeatedly(Return(kMockSystemGBus)); | |
216 EXPECT_CALL(dbus_iface, | |
217 ConnectionGetConnection(kMockSystemGBus)) | |
218 .Times(1) | |
219 .WillOnce(Return(kMockSystemBus)); | |
220 EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _)); | |
221 EXPECT_CALL(dbus_iface, | |
222 DbusConnectionAddFilter(kMockSystemBus, _, _, _)) | |
223 .WillOnce(Return(1)); | |
224 EXPECT_CALL(dbus_iface, | |
225 ProxyNewForNameOwner(kMockSystemGBus, | |
226 StrEq(kLibCrosServiceName), | |
227 StrEq(kLibCrosServicePath), | |
228 StrEq(kLibCrosServiceInterface), | |
229 _)) | |
230 .WillOnce(Return(static_cast<DBusGProxy*>(NULL))); | |
231 EXPECT_CALL(dbus_iface, | |
232 DbusConnectionRemoveFilter(kMockSystemBus, _, _)); | |
233 ChromeBrowserProxyResolver resolver(&dbus_iface); | |
234 EXPECT_FALSE(resolver.Init()); | |
235 EXPECT_FALSE(resolver.GetProxiesForUrl(kUrl, NULL, NULL)); | |
236 } | 206 } |
237 | 207 |
238 } // namespace chromeos_update_engine | 208 } // namespace chromeos_update_engine |
OLD | NEW |