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 "base/pickle.h"
6 #include "base/values.h"
7 #include "extensions/common/extension_messages.h"
8 #include "extensions/common/permissions/manifest_permission.h"
9 #include "extensions/common/permissions/manifest_permission_set.h"
10 #include "ipc/ipc_message.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 namespace extensions {
14
15 class MockManifestPermission : public ManifestPermission {
16 public:
MockManifestPermission(const std::string & name)17 MockManifestPermission(const std::string& name)
18 : name_(name) {
19 }
20
name() const21 virtual std::string name() const OVERRIDE {
22 return name_;
23 }
24
id() const25 virtual std::string id() const OVERRIDE {
26 return name();
27 }
28
HasMessages() const29 virtual bool HasMessages() const OVERRIDE {
30 return false;
31 }
32
GetMessages() const33 virtual PermissionMessages GetMessages() const OVERRIDE {
34 return PermissionMessages();
35 }
36
FromValue(const base::Value * value)37 virtual bool FromValue(const base::Value* value) OVERRIDE {
38 return false;
39 }
40
ToValue() const41 virtual scoped_ptr<base::Value> ToValue() const OVERRIDE {
42 return scoped_ptr<base::Value>(base::Value::CreateNullValue());
43 }
44
Clone() const45 virtual ManifestPermission* Clone() const OVERRIDE {
46 return new MockManifestPermission(name_);
47 }
48
Diff(const ManifestPermission * rhs) const49 virtual ManifestPermission* Diff(const ManifestPermission* rhs)
50 const OVERRIDE {
51 const MockManifestPermission* other =
52 static_cast<const MockManifestPermission*>(rhs);
53 EXPECT_EQ(name_, other->name_);
54 return NULL;
55 }
56
Union(const ManifestPermission * rhs) const57 virtual ManifestPermission* Union(const ManifestPermission* rhs)
58 const OVERRIDE {
59 const MockManifestPermission* other =
60 static_cast<const MockManifestPermission*>(rhs);
61 EXPECT_EQ(name_, other->name_);
62 return new MockManifestPermission(name_);
63 }
64
Intersect(const ManifestPermission * rhs) const65 virtual ManifestPermission* Intersect(const ManifestPermission* rhs)
66 const OVERRIDE {
67 const MockManifestPermission* other =
68 static_cast<const MockManifestPermission*>(rhs);
69 EXPECT_EQ(name_, other->name_);
70 return new MockManifestPermission(name_);
71 }
72
Contains(const ManifestPermission * rhs) const73 virtual bool Contains(const ManifestPermission* rhs) const OVERRIDE {
74 const MockManifestPermission* other =
75 static_cast<const MockManifestPermission*>(rhs);
76 EXPECT_EQ(name_, other->name_);
77 return true;
78 }
79
Equal(const ManifestPermission * rhs) const80 virtual bool Equal(const ManifestPermission* rhs) const OVERRIDE {
81 const MockManifestPermission* other =
82 static_cast<const MockManifestPermission*>(rhs);
83 EXPECT_EQ(name_, other->name_);
84 return true;
85 }
86
Write(IPC::Message * m) const87 virtual void Write(IPC::Message* m) const OVERRIDE {
88 IPC::WriteParam(m, name_);
89 }
90
Read(const IPC::Message * m,PickleIterator * iter)91 virtual bool Read(const IPC::Message* m, PickleIterator* iter) OVERRIDE {
92 std::string read_name;
93 bool result = IPC::ReadParam(m, iter, &read_name);
94 if (!result)
95 return result;
96 EXPECT_EQ(read_name, name_);
97 return true;
98 }
99
Log(std::string * log) const100 virtual void Log(std::string* log) const OVERRIDE {
101 }
102
103 private:
104 std::string name_;
105 };
106
TEST(ManifestPermissionSetTest,General)107 TEST(ManifestPermissionSetTest, General) {
108 ManifestPermissionSet set;
109 set.insert(new MockManifestPermission("p1"));
110 set.insert(new MockManifestPermission("p2"));
111 set.insert(new MockManifestPermission("p3"));
112 set.insert(new MockManifestPermission("p4"));
113 set.insert(new MockManifestPermission("p5"));
114
115 EXPECT_EQ(set.find("p1")->id(), "p1");
116 EXPECT_TRUE(set.find("p10") == set.end());
117
118 EXPECT_EQ(set.size(), 5u);
119
120 EXPECT_EQ(set.erase("p1"), 1u);
121 EXPECT_EQ(set.size(), 4u);
122
123 EXPECT_EQ(set.erase("p1"), 0u);
124 EXPECT_EQ(set.size(), 4u);
125 }
126
TEST(ManifestPermissionSetTest,CreateUnion)127 TEST(ManifestPermissionSetTest, CreateUnion) {
128 ManifestPermissionSet permissions1;
129 ManifestPermissionSet permissions2;
130 ManifestPermissionSet expected_permissions;
131 ManifestPermissionSet result;
132
133 ManifestPermission* permission = new MockManifestPermission("p3");
134
135 // Union with an empty set.
136 permissions1.insert(new MockManifestPermission("p1"));
137 permissions1.insert(new MockManifestPermission("p2"));
138 permissions1.insert(permission->Clone());
139 expected_permissions.insert(new MockManifestPermission("p1"));
140 expected_permissions.insert(new MockManifestPermission("p2"));
141 expected_permissions.insert(permission);
142
143 ManifestPermissionSet::Union(permissions1, permissions2, &result);
144
145 EXPECT_TRUE(permissions1.Contains(permissions2));
146 EXPECT_TRUE(permissions1.Contains(result));
147 EXPECT_FALSE(permissions2.Contains(permissions1));
148 EXPECT_FALSE(permissions2.Contains(result));
149 EXPECT_TRUE(result.Contains(permissions1));
150 EXPECT_TRUE(result.Contains(permissions2));
151
152 EXPECT_EQ(expected_permissions, result);
153
154 // Now use a real second set.
155 permissions2.insert(new MockManifestPermission("p1"));
156 permissions2.insert(new MockManifestPermission("p2"));
157 permissions2.insert(new MockManifestPermission("p33"));
158 permissions2.insert(new MockManifestPermission("p4"));
159 permissions2.insert(new MockManifestPermission("p5"));
160
161 expected_permissions.insert(new MockManifestPermission("p1"));
162 expected_permissions.insert(new MockManifestPermission("p2"));
163 expected_permissions.insert(new MockManifestPermission("p3"));
164 expected_permissions.insert(new MockManifestPermission("p4"));
165 expected_permissions.insert(new MockManifestPermission("p5"));
166 expected_permissions.insert(new MockManifestPermission("p33"));
167
168 ManifestPermissionSet::Union(permissions1, permissions2, &result);
169
170 {
171 ManifestPermissionSet set1;
172 set1.insert(new MockManifestPermission("p1"));
173 set1.insert(new MockManifestPermission("p2"));
174 ManifestPermissionSet set2;
175 set2.insert(new MockManifestPermission("p3"));
176
177 EXPECT_FALSE(set1.Contains(set2));
178 EXPECT_FALSE(set2.Contains(set1));
179 }
180
181 EXPECT_FALSE(permissions1.Contains(permissions2));
182 EXPECT_FALSE(permissions1.Contains(result));
183 EXPECT_FALSE(permissions2.Contains(permissions1));
184 EXPECT_FALSE(permissions2.Contains(result));
185 EXPECT_TRUE(result.Contains(permissions1));
186 EXPECT_TRUE(result.Contains(permissions2));
187
188 EXPECT_EQ(expected_permissions, result);
189 }
190
TEST(ManifestPermissionSetTest,CreateIntersection)191 TEST(ManifestPermissionSetTest, CreateIntersection) {
192 ManifestPermissionSet permissions1;
193 ManifestPermissionSet permissions2;
194 ManifestPermissionSet expected_permissions;
195 ManifestPermissionSet result;
196
197 // Intersection with an empty set.
198 permissions1.insert(new MockManifestPermission("p1"));
199 permissions1.insert(new MockManifestPermission("p2"));
200 permissions1.insert(new MockManifestPermission("p3"));
201
202 ManifestPermissionSet::Intersection(permissions1, permissions2, &result);
203 EXPECT_TRUE(permissions1.Contains(result));
204 EXPECT_TRUE(permissions2.Contains(result));
205 EXPECT_TRUE(permissions1.Contains(permissions2));
206 EXPECT_FALSE(permissions2.Contains(permissions1));
207 EXPECT_FALSE(result.Contains(permissions1));
208 EXPECT_TRUE(result.Contains(permissions2));
209
210 EXPECT_TRUE(result.empty());
211 EXPECT_EQ(expected_permissions, result);
212
213 // Now use a real second set.
214 permissions2.insert(new MockManifestPermission("p1"));
215 permissions2.insert(new MockManifestPermission("p3"));
216 permissions2.insert(new MockManifestPermission("p4"));
217 permissions2.insert(new MockManifestPermission("p5"));
218
219 expected_permissions.insert(new MockManifestPermission("p1"));
220 expected_permissions.insert(new MockManifestPermission("p3"));
221
222 ManifestPermissionSet::Intersection(permissions1, permissions2, &result);
223
224 EXPECT_TRUE(permissions1.Contains(result));
225 EXPECT_TRUE(permissions2.Contains(result));
226 EXPECT_FALSE(permissions1.Contains(permissions2));
227 EXPECT_FALSE(permissions2.Contains(permissions1));
228 EXPECT_FALSE(result.Contains(permissions1));
229 EXPECT_FALSE(result.Contains(permissions2));
230
231 EXPECT_EQ(expected_permissions, result);
232 }
233
TEST(ManifestPermissionSetTest,CreateDifference)234 TEST(ManifestPermissionSetTest, CreateDifference) {
235 ManifestPermissionSet permissions1;
236 ManifestPermissionSet permissions2;
237 ManifestPermissionSet expected_permissions;
238 ManifestPermissionSet result;
239
240 // Difference with an empty set.
241 permissions1.insert(new MockManifestPermission("p1"));
242 permissions1.insert(new MockManifestPermission("p2"));
243 permissions1.insert(new MockManifestPermission("p3"));
244
245 ManifestPermissionSet::Difference(permissions1, permissions2, &result);
246
247 EXPECT_EQ(permissions1, result);
248
249 // Now use a real second set.
250 permissions2.insert(new MockManifestPermission("p1"));
251 permissions2.insert(new MockManifestPermission("p2"));
252 permissions2.insert(new MockManifestPermission("p4"));
253 permissions2.insert(new MockManifestPermission("p5"));
254 permissions2.insert(new MockManifestPermission("p6"));
255
256 expected_permissions.insert(new MockManifestPermission("p3"));
257
258 ManifestPermissionSet::Difference(permissions1, permissions2, &result);
259
260 EXPECT_TRUE(permissions1.Contains(result));
261 EXPECT_FALSE(permissions2.Contains(result));
262
263 EXPECT_EQ(expected_permissions, result);
264
265 // |result| = |permissions1| - |permissions2| -->
266 // |result| intersect |permissions2| == empty_set
267 ManifestPermissionSet result2;
268 ManifestPermissionSet::Intersection(result, permissions2, &result2);
269 EXPECT_TRUE(result2.empty());
270 }
271
272 } // namespace extensions
273