Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(75)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc

Issue 217263002: Move sockets manifest types to //extensions. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/common/extensions/api/sockets/sockets_manifest_permission.cc ('k') | chrome/common/extensions/chrome_manifest_handlers.cc » ('j') | extensions/common/api/manifest_types.json » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 <set>
6
7 #include "base/json/json_reader.h"
8 #include "base/pickle.h"
9 #include "base/values.h"
10 #include "chrome/common/extensions/api/sockets/sockets_manifest_permission.h"
11 #include "extensions/common/extension_messages.h"
12 #include "extensions/common/manifest_constants.h"
13 #include "ipc/ipc_message.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 using content::SocketPermissionRequest;
17
18 namespace extensions {
19
20 namespace {
21
22 const char kUdpBindPermission[]=
23 "{ \"udp\": { \"bind\": [\"127.0.0.1:3007\", \"a.com:80\"] } }";
24
25 const char kUdpSendPermission[]=
26 "{ \"udp\": { \"send\": [\"\", \"a.com:80\"] } }";
27
28 const char kTcpConnectPermission[]=
29 "{ \"tcp\": { \"connect\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
30
31 const char kTcpServerListenPermission[]=
32 "{ \"tcpServer\": { \"listen\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
33
34 static void AssertEmptyPermission(const SocketsManifestPermission* permission) {
35 EXPECT_TRUE(permission);
36 EXPECT_EQ(std::string(extensions::manifest_keys::kSockets), permission->id());
37 EXPECT_EQ(permission->id(), permission->name());
38 EXPECT_FALSE(permission->HasMessages());
39 EXPECT_EQ(0u, permission->entries().size());
40 }
41
42 static scoped_ptr<base::Value> ParsePermissionJSON(const std::string& json) {
43 scoped_ptr<base::Value> result(base::JSONReader::Read(json));
44 EXPECT_TRUE(result) << "Invalid JSON string: " << json;
45 return result.Pass();
46 }
47
48 static scoped_ptr<SocketsManifestPermission> PermissionFromValue(
49 const base::Value& value) {
50 base::string16 error16;
51 scoped_ptr<SocketsManifestPermission> permission(
52 SocketsManifestPermission::FromValue(value, &error16));
53 EXPECT_TRUE(permission)
54 << "Error parsing Value into permission: " << error16;
55 return permission.Pass();
56 }
57
58 static scoped_ptr<SocketsManifestPermission> PermissionFromJSON(
59 const std::string& json) {
60 scoped_ptr<base::Value> value(ParsePermissionJSON(json));
61 return PermissionFromValue(*value);
62 }
63
64 struct CheckFormatEntry {
65 CheckFormatEntry(SocketPermissionRequest::OperationType operation_type,
66 std::string host_pattern)
67 : operation_type(operation_type),
68 host_pattern(host_pattern) {
69 }
70
71 // operators <, == are needed by container std::set and algorithms
72 // std::set_includes and std::set_differences.
73 bool operator<(const CheckFormatEntry& rhs) const {
74 if (operation_type == rhs.operation_type)
75 return host_pattern < rhs.host_pattern;
76
77 return operation_type < rhs.operation_type;
78 }
79
80 bool operator==(const CheckFormatEntry& rhs) const {
81 return operation_type == rhs.operation_type &&
82 host_pattern == rhs.host_pattern;
83 }
84
85 SocketPermissionRequest::OperationType operation_type;
86 std::string host_pattern;
87 };
88
89 static testing::AssertionResult CheckFormat(
90 std::multiset<CheckFormatEntry> permissions,
91 const std::string& json) {
92 scoped_ptr<SocketsManifestPermission> permission(PermissionFromJSON(json));
93 if (!permission)
94 return testing::AssertionFailure() << "Invalid permission " << json;
95
96 if (permissions.size() != permission->entries().size()) {
97 return testing::AssertionFailure()
98 << "Incorrect # of entries in json: " << json;
99 }
100
101 // Note: We use multiset because SocketsManifestPermission does not have to
102 // store entries in the order found in the json message.
103 std::multiset<CheckFormatEntry> parsed_permissions;
104 for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator
105 it = permission->entries().begin(); it != permission->entries().end();
106 ++it) {
107 parsed_permissions.insert(
108 CheckFormatEntry(it->pattern().type, it->GetHostPatternAsString()));
109 }
110
111 if (!std::equal(permissions.begin(), permissions.end(),
112 parsed_permissions.begin())) {
113 return testing::AssertionFailure() << "Incorrect socket operations.";
114 }
115 return testing::AssertionSuccess();
116 }
117
118 static testing::AssertionResult CheckFormat(const std::string& json) {
119 return CheckFormat(std::multiset<CheckFormatEntry>(), json);
120 }
121
122 static testing::AssertionResult CheckFormat(
123 const std::string& json,
124 const CheckFormatEntry& op1) {
125 CheckFormatEntry entries[] = {
126 op1
127 };
128 return CheckFormat(std::multiset<CheckFormatEntry>(
129 entries, entries + arraysize(entries)), json);
130 }
131
132 static testing::AssertionResult CheckFormat(
133 const std::string& json,
134 const CheckFormatEntry& op1,
135 const CheckFormatEntry& op2) {
136 CheckFormatEntry entries[] = {
137 op1, op2
138 };
139 return CheckFormat(std::multiset<CheckFormatEntry>(
140 entries, entries + arraysize(entries)), json);
141 }
142
143 static testing::AssertionResult CheckFormat(
144 const std::string& json,
145 const CheckFormatEntry& op1,
146 const CheckFormatEntry& op2,
147 const CheckFormatEntry& op3,
148 const CheckFormatEntry& op4,
149 const CheckFormatEntry& op5,
150 const CheckFormatEntry& op6,
151 const CheckFormatEntry& op7,
152 const CheckFormatEntry& op8,
153 const CheckFormatEntry& op9) {
154 CheckFormatEntry entries[] = {
155 op1, op2, op3, op4, op5, op6, op7, op8, op9
156 };
157 return CheckFormat(std::multiset<CheckFormatEntry>(
158 entries, entries + arraysize(entries)), json);
159 }
160
161 } // namespace
162
163 TEST(SocketsManifestPermissionTest, Empty) {
164 // Construction
165 scoped_ptr<SocketsManifestPermission> permission(
166 new SocketsManifestPermission());
167 AssertEmptyPermission(permission.get());
168
169 // Clone()/Equal()
170 scoped_ptr<SocketsManifestPermission> clone(
171 static_cast<SocketsManifestPermission*>(permission->Clone()));
172 AssertEmptyPermission(clone.get());
173
174 EXPECT_TRUE(permission->Equal(clone.get()));
175
176 // ToValue()/FromValue()
177 scoped_ptr<const base::Value> value(permission->ToValue());
178 EXPECT_TRUE(value.get());
179
180 scoped_ptr<SocketsManifestPermission> permission2(
181 new SocketsManifestPermission());
182 EXPECT_TRUE(permission2->FromValue(value.get()));
183 AssertEmptyPermission(permission2.get());
184
185 // Union/Diff/Intersection
186 scoped_ptr<SocketsManifestPermission> diff_perm(
187 static_cast<SocketsManifestPermission*>(permission->Diff(clone.get())));
188 AssertEmptyPermission(diff_perm.get());
189
190 scoped_ptr<SocketsManifestPermission> union_perm(
191 static_cast<SocketsManifestPermission*>(permission->Union(clone.get())));
192 AssertEmptyPermission(union_perm.get());
193
194 scoped_ptr<SocketsManifestPermission> intersect_perm(
195 static_cast<SocketsManifestPermission*>(
196 permission->Intersect(clone.get())));
197 AssertEmptyPermission(intersect_perm.get());
198
199 // IPC
200 scoped_ptr<SocketsManifestPermission> ipc_perm(
201 new SocketsManifestPermission());
202 scoped_ptr<SocketsManifestPermission> ipc_perm2(
203 new SocketsManifestPermission());
204
205 IPC::Message m;
206 ipc_perm->Write(&m);
207 PickleIterator iter(m);
208 EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
209 AssertEmptyPermission(ipc_perm2.get());
210 }
211
212 TEST(SocketsManifestPermissionTest, JSONFormats) {
213 EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":\"\"}}",
214 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
215 EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[]}}"));
216 EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"\"]}}",
217 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
218 EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"a:80\", \"b:10\"]}}",
219 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
220 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10")));
221
222 EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":\"\"}}",
223 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
224 EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[]}}"));
225 EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[\"\"]}}",
226 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
227 EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[\"a:80\", \"b:10\"]}}",
228 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
229 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10")));
230
231 EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":\"\"}}",
232 CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
233 EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[]}}"));
234 EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[\"\"]}}",
235 CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
236 EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[\"\", \"\"]}}",
237 CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
238
239 EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":\"\"}}",
240 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
241 EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[]}}"));
242 EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[\"\"]}}",
243 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
244 EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]}}",
245 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
246 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10")));
247
248 EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":\"\"}}",
249 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
250 EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[]}}"));
251 EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"\"]}}",
252 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
253 EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}}",
254 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
255 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
256
257 EXPECT_TRUE(CheckFormat(
258 "{"
259 "\"udp\":{"
260 "\"send\":[\"a:80\", \"b:10\"],"
261 "\"bind\":[\"a:80\", \"b:10\"],"
262 "\"multicastMembership\":\"\""
263 "},"
264 "\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]},"
265 "\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}"
266 "}",
267 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
268 CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10"),
269 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
270 CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10"),
271 CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, ""),
272 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
273 CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10"),
274 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
275 CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
276
277 }
278
279 TEST(SocketsManifestPermissionTest, FromToValue) {
280 scoped_ptr<base::Value> udp_send(ParsePermissionJSON(kUdpBindPermission));
281 scoped_ptr<base::Value> udp_bind(ParsePermissionJSON(kUdpSendPermission));
282 scoped_ptr<base::Value> tcp_connect(
283 ParsePermissionJSON(kTcpConnectPermission));
284 scoped_ptr<base::Value> tcp_server_listen(
285 ParsePermissionJSON(kTcpServerListenPermission));
286
287 // FromValue()
288 scoped_ptr<SocketsManifestPermission> permission1(
289 new SocketsManifestPermission());
290 EXPECT_TRUE(permission1->FromValue(udp_send.get()));
291 EXPECT_EQ(2u, permission1->entries().size());
292
293 scoped_ptr<SocketsManifestPermission> permission2(
294 new SocketsManifestPermission());
295 EXPECT_TRUE(permission2->FromValue(udp_bind.get()));
296 EXPECT_EQ(2u, permission2->entries().size());
297
298 scoped_ptr<SocketsManifestPermission> permission3(
299 new SocketsManifestPermission());
300 EXPECT_TRUE(permission3->FromValue(tcp_connect.get()));
301 EXPECT_EQ(2u, permission3->entries().size());
302
303 scoped_ptr<SocketsManifestPermission> permission4(
304 new SocketsManifestPermission());
305 EXPECT_TRUE(permission4->FromValue(tcp_server_listen.get()));
306 EXPECT_EQ(2u, permission4->entries().size());
307
308 // ToValue()
309 scoped_ptr<base::Value> value1 = permission1->ToValue();
310 EXPECT_TRUE(value1);
311 scoped_ptr<SocketsManifestPermission> permission1_1(
312 new SocketsManifestPermission());
313 EXPECT_TRUE(permission1_1->FromValue(value1.get()));
314 EXPECT_TRUE(permission1->Equal(permission1_1.get()));
315
316 scoped_ptr<base::Value> value2 = permission2->ToValue();
317 EXPECT_TRUE(value2);
318 scoped_ptr<SocketsManifestPermission> permission2_1(
319 new SocketsManifestPermission());
320 EXPECT_TRUE(permission2_1->FromValue(value2.get()));
321 EXPECT_TRUE(permission2->Equal(permission2_1.get()));
322
323 scoped_ptr<base::Value> value3 = permission3->ToValue();
324 EXPECT_TRUE(value3);
325 scoped_ptr<SocketsManifestPermission> permission3_1(
326 new SocketsManifestPermission());
327 EXPECT_TRUE(permission3_1->FromValue(value3.get()));
328 EXPECT_TRUE(permission3->Equal(permission3_1.get()));
329
330 scoped_ptr<base::Value> value4 = permission4->ToValue();
331 EXPECT_TRUE(value4);
332 scoped_ptr<SocketsManifestPermission> permission4_1(
333 new SocketsManifestPermission());
334 EXPECT_TRUE(permission4_1->FromValue(value4.get()));
335 EXPECT_TRUE(permission4->Equal(permission4_1.get()));
336 }
337
338 TEST(SocketsManifestPermissionTest, SetOperations) {
339 scoped_ptr<SocketsManifestPermission> permission1(
340 PermissionFromJSON(kUdpBindPermission));
341 scoped_ptr<SocketsManifestPermission> permission2(
342 PermissionFromJSON(kUdpSendPermission));
343 scoped_ptr<SocketsManifestPermission> permission3(
344 PermissionFromJSON(kTcpConnectPermission));
345 scoped_ptr<SocketsManifestPermission> permission4(
346 PermissionFromJSON(kTcpServerListenPermission));
347
348 // Union
349 scoped_ptr<SocketsManifestPermission> union_perm(
350 static_cast<SocketsManifestPermission*>(
351 permission1->Union(permission2.get())));
352 EXPECT_TRUE(union_perm);
353 EXPECT_EQ(4u, union_perm->entries().size());
354
355 EXPECT_TRUE(union_perm->Contains(permission1.get()));
356 EXPECT_TRUE(union_perm->Contains(permission2.get()));
357 EXPECT_FALSE(union_perm->Contains(permission3.get()));
358 EXPECT_FALSE(union_perm->Contains(permission4.get()));
359
360 // Diff
361 scoped_ptr<SocketsManifestPermission> diff_perm1(
362 static_cast<SocketsManifestPermission*>(
363 permission1->Diff(permission2.get())));
364 EXPECT_TRUE(diff_perm1);
365 EXPECT_EQ(2u, diff_perm1->entries().size());
366
367 EXPECT_TRUE(permission1->Equal(diff_perm1.get()));
368 EXPECT_TRUE(diff_perm1->Equal(permission1.get()));
369
370 scoped_ptr<SocketsManifestPermission> diff_perm2(
371 static_cast<SocketsManifestPermission*>(
372 permission1->Diff(union_perm.get())));
373 EXPECT_TRUE(diff_perm2);
374 AssertEmptyPermission(diff_perm2.get());
375
376 // Intersection
377 scoped_ptr<SocketsManifestPermission> intersect_perm1(
378 static_cast<SocketsManifestPermission*>(
379 union_perm->Intersect(permission1.get())));
380 EXPECT_TRUE(intersect_perm1);
381 EXPECT_EQ(2u, intersect_perm1->entries().size());
382
383 EXPECT_TRUE(permission1->Equal(intersect_perm1.get()));
384 EXPECT_TRUE(intersect_perm1->Equal(permission1.get()));
385 }
386
387 TEST(SocketsManifestPermissionTest, IPC) {
388 scoped_ptr<SocketsManifestPermission> permission(
389 PermissionFromJSON(kUdpBindPermission));
390
391 scoped_ptr<SocketsManifestPermission> ipc_perm(
392 static_cast<SocketsManifestPermission*>(permission->Clone()));
393 scoped_ptr<SocketsManifestPermission> ipc_perm2(
394 new SocketsManifestPermission());
395
396 IPC::Message m;
397 ipc_perm->Write(&m);
398 PickleIterator iter(m);
399 EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
400 EXPECT_TRUE(permission->Equal(ipc_perm2.get()));
401 }
402
403 } // namespace extensions
OLDNEW
« no previous file with comments | « chrome/common/extensions/api/sockets/sockets_manifest_permission.cc ('k') | chrome/common/extensions/chrome_manifest_handlers.cc » ('j') | extensions/common/api/manifest_types.json » ('J')

Powered by Google App Engine
This is Rietveld 408576698