extensions/common/url_pattern_set_unittest.cc

   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 "extensions/common/url_pattern_set.h"
   6
   7 #include <sstream>
   8
   9 #include "base/values.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "url/gurl.h"
  12
  13 namespace extensions {
  14
  15 namespace {
  16
  17 void AddPattern(URLPatternSet* set, const std::string& pattern) {
  18   int schemes = URLPattern::SCHEME_ALL;
  19   set->AddPattern(URLPattern(schemes, pattern));
  20 }
  21
  22 URLPatternSet Patterns(const std::string& pattern) {
  23   URLPatternSet set;
  24   AddPattern(&set, pattern);
  25   return set;
  26 }
  27
  28 URLPatternSet Patterns(const std::string& pattern1,
  29                        const std::string& pattern2) {
  30   URLPatternSet set;
  31   AddPattern(&set, pattern1);
  32   AddPattern(&set, pattern2);
  33   return set;
  34 }
  35
  36 }  // namespace
  37
  38 TEST(URLPatternSetTest, Empty) {
  39   URLPatternSet set;
  40   EXPECT_FALSE(set.MatchesURL(GURL("http://www.foo.com/bar")));
  41   EXPECT_FALSE(set.MatchesURL(GURL()));
  42   EXPECT_FALSE(set.MatchesURL(GURL("invalid")));
  43 }
  44
  45 TEST(URLPatternSetTest, One) {
  46   URLPatternSet set;
  47   AddPattern(&set, "http://www.google.com/*");
  48
  49   EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/")));
  50   EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/monkey")));
  51   EXPECT_FALSE(set.MatchesURL(GURL("https://www.google.com/")));
  52   EXPECT_FALSE(set.MatchesURL(GURL("https://www.microsoft.com/")));
  53 }
  54
  55 TEST(URLPatternSetTest, Two) {
  56   URLPatternSet set;
  57   AddPattern(&set, "http://www.google.com/*");
  58   AddPattern(&set, "http://www.yahoo.com/*");
  59
  60   EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/monkey")));
  61   EXPECT_TRUE(set.MatchesURL(GURL("http://www.yahoo.com/monkey")));
  62   EXPECT_FALSE(set.MatchesURL(GURL("https://www.apple.com/monkey")));
  63 }
  64
  65 TEST(URLPatternSetTest, StreamOperatorEmpty) {
  66   URLPatternSet set;
  67
  68   std::ostringstream stream;
  69   stream << set;
  70   EXPECT_EQ("{ }", stream.str());
  71 }
  72
  73 TEST(URLPatternSetTest, StreamOperatorOne) {
  74   URLPatternSet set;
  75   AddPattern(&set, "http://www.google.com/*");
  76
  77   std::ostringstream stream;
  78   stream << set;
  79   EXPECT_EQ("{ \"http://www.google.com/*\" }", stream.str());
  80 }
  81
  82 TEST(URLPatternSetTest, StreamOperatorTwo) {
  83   URLPatternSet set;
  84   AddPattern(&set, "http://www.google.com/*");
  85   AddPattern(&set, "http://www.yahoo.com/*");
  86
  87   std::ostringstream stream;
  88   stream << set;
  89   EXPECT_EQ("{ \"http://www.google.com/*\", \"http://www.yahoo.com/*\" }",
  90             stream.str());
  91 }
  92
  93 TEST(URLPatternSetTest, OverlapsWith) {
  94   URLPatternSet set1;
  95   AddPattern(&set1, "http://www.google.com/f*");
  96   AddPattern(&set1, "http://www.yahoo.com/b*");
  97
  98   URLPatternSet set2;
  99   AddPattern(&set2, "http://www.reddit.com/f*");
 100   AddPattern(&set2, "http://www.yahoo.com/z*");
 101
 102   URLPatternSet set3;
 103   AddPattern(&set3, "http://www.google.com/q/*");
 104   AddPattern(&set3, "http://www.yahoo.com/b/*");
 105
 106   EXPECT_FALSE(set1.OverlapsWith(set2));
 107   EXPECT_FALSE(set2.OverlapsWith(set1));
 108
 109   EXPECT_TRUE(set1.OverlapsWith(set3));
 110   EXPECT_TRUE(set3.OverlapsWith(set1));
 111 }
 112
 113 TEST(URLPatternSetTest, CreateDifference) {
 114   URLPatternSet expected;
 115   URLPatternSet set1;
 116   URLPatternSet set2;
 117   AddPattern(&set1, "http://www.google.com/f*");
 118   AddPattern(&set1, "http://www.yahoo.com/b*");
 119
 120   // Subtract an empty set.
 121   URLPatternSet result = URLPatternSet::CreateDifference(set1, set2);
 122   EXPECT_EQ(set1, result);
 123
 124   // Subtract a real set.
 125   AddPattern(&set2, "http://www.reddit.com/f*");
 126   AddPattern(&set2, "http://www.yahoo.com/z*");
 127   AddPattern(&set2, "http://www.google.com/f*");
 128
 129   AddPattern(&expected, "http://www.yahoo.com/b*");
 130
 131   result = URLPatternSet::CreateDifference(set1, set2);
 132   EXPECT_EQ(expected, result);
 133   EXPECT_FALSE(result.is_empty());
 134   EXPECT_TRUE(set1.Contains(result));
 135   EXPECT_FALSE(result.Contains(set2));
 136   EXPECT_FALSE(set2.Contains(result));
 137
 138   URLPatternSet intersection = URLPatternSet::CreateIntersection(result, set2);
 139   EXPECT_TRUE(intersection.is_empty());
 140 }
 141
 142 TEST(URLPatternSetTest, CreateIntersection) {
 143   URLPatternSet empty_set;
 144   URLPatternSet expected;
 145   URLPatternSet set1;
 146   AddPattern(&set1, "http://www.google.com/f*");
 147   AddPattern(&set1, "http://www.yahoo.com/b*");
 148
 149   // Intersection with an empty set.
 150   URLPatternSet result = URLPatternSet::CreateIntersection(set1, empty_set);
 151   EXPECT_EQ(expected, result);
 152   EXPECT_TRUE(result.is_empty());
 153   EXPECT_TRUE(empty_set.Contains(result));
 154   EXPECT_TRUE(result.Contains(empty_set));
 155   EXPECT_TRUE(set1.Contains(result));
 156
 157   // Intersection with a real set.
 158   URLPatternSet set2;
 159   AddPattern(&set2, "http://www.reddit.com/f*");
 160   AddPattern(&set2, "http://www.yahoo.com/z*");
 161   AddPattern(&set2, "http://www.google.com/f*");
 162
 163   AddPattern(&expected, "http://www.google.com/f*");
 164
 165   result = URLPatternSet::CreateIntersection(set1, set2);
 166   EXPECT_EQ(expected, result);
 167   EXPECT_FALSE(result.is_empty());
 168   EXPECT_TRUE(set1.Contains(result));
 169   EXPECT_TRUE(set2.Contains(result));
 170 }
 171
 172 TEST(URLPatternSetTest, CreateSemanticIntersection) {
 173   {
 174     URLPatternSet set1;
 175     AddPattern(&set1, "http://*.google.com/*");
 176     AddPattern(&set1, "http://*.yahoo.com/*");
 177
 178     URLPatternSet set2;
 179     AddPattern(&set2, "http://google.com/*");
 180
 181     // The semantic intersection should contain only those patterns that are in
 182     // both set 1 and set 2, or "http://google.com/*".
 183     URLPatternSet intersection =
 184         URLPatternSet::CreateSemanticIntersection(set1, set2);
 185     ASSERT_EQ(1u, intersection.size());
 186     EXPECT_EQ("http://google.com/*", intersection.begin()->GetAsString());
 187   }
 188
 189   {
 190     // We don't handle funny intersections, where the resultant pattern is
 191     // neither of the two compared patterns. So the intersection of these two
 192     // is not http://www.google.com/*, but rather nothing.
 193     URLPatternSet set1;
 194     AddPattern(&set1, "http://*/*");
 195     URLPatternSet set2;
 196     AddPattern(&set2, "*://www.google.com/*");
 197     EXPECT_TRUE(
 198         URLPatternSet::CreateSemanticIntersection(set1, set2).is_empty());
 199   }
 200 }
 201
 202 TEST(URLPatternSetTest, CreateUnion) {
 203   URLPatternSet empty_set;
 204
 205   URLPatternSet set1;
 206   AddPattern(&set1, "http://www.google.com/f*");
 207   AddPattern(&set1, "http://www.yahoo.com/b*");
 208
 209   URLPatternSet expected;
 210   AddPattern(&expected, "http://www.google.com/f*");
 211   AddPattern(&expected, "http://www.yahoo.com/b*");
 212
 213   // Union with an empty set.
 214   URLPatternSet result = URLPatternSet::CreateUnion(set1, empty_set);
 215   EXPECT_EQ(expected, result);
 216
 217   // Union with a real set.
 218   URLPatternSet set2;
 219   AddPattern(&set2, "http://www.reddit.com/f*");
 220   AddPattern(&set2, "http://www.yahoo.com/z*");
 221   AddPattern(&set2, "http://www.google.com/f*");
 222
 223   AddPattern(&expected, "http://www.reddit.com/f*");
 224   AddPattern(&expected, "http://www.yahoo.com/z*");
 225
 226   result = URLPatternSet::CreateUnion(set1, set2);
 227   EXPECT_EQ(expected, result);
 228 }
 229
 230 TEST(URLPatternSetTest, Contains) {
 231   URLPatternSet set1;
 232   URLPatternSet set2;
 233   URLPatternSet empty_set;
 234
 235   AddPattern(&set1, "http://www.google.com/*");
 236   AddPattern(&set1, "http://www.yahoo.com/*");
 237
 238   AddPattern(&set2, "http://www.reddit.com/*");
 239
 240   EXPECT_FALSE(set1.Contains(set2));
 241   EXPECT_TRUE(set1.Contains(empty_set));
 242   EXPECT_FALSE(empty_set.Contains(set1));
 243
 244   AddPattern(&set2, "http://www.yahoo.com/*");
 245
 246   EXPECT_FALSE(set1.Contains(set2));
 247   EXPECT_FALSE(set2.Contains(set1));
 248
 249   AddPattern(&set2, "http://www.google.com/*");
 250
 251   EXPECT_FALSE(set1.Contains(set2));
 252   EXPECT_TRUE(set2.Contains(set1));
 253
 254   // Note that this checks if individual patterns contain other patterns, not
 255   // just equality. For example:
 256   AddPattern(&set1, "http://*.reddit.com/*");
 257   EXPECT_TRUE(set1.Contains(set2));
 258   EXPECT_FALSE(set2.Contains(set1));
 259 }
 260
 261 TEST(URLPatternSetTest, Duplicates) {
 262   URLPatternSet set1;
 263   URLPatternSet set2;
 264
 265   AddPattern(&set1, "http://www.google.com/*");
 266   AddPattern(&set2, "http://www.google.com/*");
 267
 268   AddPattern(&set1, "http://www.google.com/*");
 269
 270   // The sets should still be equal after adding a duplicate.
 271   EXPECT_EQ(set2, set1);
 272 }
 273
 274 TEST(URLPatternSetTest, ToValueAndPopulate) {
 275   URLPatternSet set1;
 276   URLPatternSet set2;
 277
 278   std::vector<std::string> patterns;
 279   patterns.push_back("http://www.google.com/*");
 280   patterns.push_back("http://www.yahoo.com/*");
 281
 282   for (size_t i = 0; i < patterns.size(); ++i)
 283     AddPattern(&set1, patterns[i]);
 284
 285   std::string error;
 286   bool allow_file_access = false;
 287   scoped_ptr<base::ListValue> value(set1.ToValue());
 288   set2.Populate(*value, URLPattern::SCHEME_ALL, allow_file_access, &error);
 289   EXPECT_EQ(set1, set2);
 290
 291   set2.ClearPatterns();
 292   set2.Populate(patterns, URLPattern::SCHEME_ALL, allow_file_access, &error);
 293   EXPECT_EQ(set1, set2);
 294 }
 295
 296 TEST(URLPatternSetTest, NwayUnion) {
 297   std::string google_a = "http://www.google.com/a*";
 298   std::string google_b = "http://www.google.com/b*";
 299   std::string google_c = "http://www.google.com/c*";
 300   std::string yahoo_a = "http://www.yahoo.com/a*";
 301   std::string yahoo_b = "http://www.yahoo.com/b*";
 302   std::string yahoo_c = "http://www.yahoo.com/c*";
 303   std::string reddit_a = "http://www.reddit.com/a*";
 304   std::string reddit_b = "http://www.reddit.com/b*";
 305   std::string reddit_c = "http://www.reddit.com/c*";
 306
 307   // Empty list.
 308   {
 309     std::vector<URLPatternSet> empty;
 310
 311     URLPatternSet result = URLPatternSet::CreateUnion(empty);
 312
 313     URLPatternSet expected;
 314     EXPECT_EQ(expected, result);
 315   }
 316
 317   // Singleton list.
 318   {
 319     std::vector<URLPatternSet> test;
 320     test.push_back(Patterns(google_a));
 321
 322     URLPatternSet result = URLPatternSet::CreateUnion(test);
 323
 324     URLPatternSet expected = Patterns(google_a);
 325     EXPECT_EQ(expected, result);
 326   }
 327
 328   // List with 2 elements.
 329   {
 330     std::vector<URLPatternSet> test;
 331     test.push_back(Patterns(google_a, google_b));
 332     test.push_back(Patterns(google_b, google_c));
 333
 334     URLPatternSet result = URLPatternSet::CreateUnion(test);
 335
 336     URLPatternSet expected;
 337     AddPattern(&expected, google_a);
 338     AddPattern(&expected, google_b);
 339     AddPattern(&expected, google_c);
 340     EXPECT_EQ(expected, result);
 341   }
 342
 343   // List with 3 elements.
 344   {
 345     std::vector<URLPatternSet> test;
 346     test.push_back(Patterns(google_a, google_b));
 347     test.push_back(Patterns(google_b, google_c));
 348     test.push_back(Patterns(yahoo_a, yahoo_b));
 349
 350     URLPatternSet result = URLPatternSet::CreateUnion(test);
 351
 352     URLPatternSet expected;
 353     AddPattern(&expected, google_a);
 354     AddPattern(&expected, google_b);
 355     AddPattern(&expected, google_c);
 356     AddPattern(&expected, yahoo_a);
 357     AddPattern(&expected, yahoo_b);
 358     EXPECT_EQ(expected, result);
 359   }
 360
 361   // List with 7 elements.
 362   {
 363     std::vector<URLPatternSet> test;
 364     test.push_back(Patterns(google_a));
 365     test.push_back(Patterns(google_b));
 366     test.push_back(Patterns(google_c));
 367     test.push_back(Patterns(yahoo_a));
 368     test.push_back(Patterns(yahoo_b));
 369     test.push_back(Patterns(yahoo_c));
 370     test.push_back(Patterns(reddit_a));
 371
 372     URLPatternSet result = URLPatternSet::CreateUnion(test);
 373
 374     URLPatternSet expected;
 375     AddPattern(&expected, google_a);
 376     AddPattern(&expected, google_b);
 377     AddPattern(&expected, google_c);
 378     AddPattern(&expected, yahoo_a);
 379     AddPattern(&expected, yahoo_b);
 380     AddPattern(&expected, yahoo_c);
 381     AddPattern(&expected, reddit_a);
 382     EXPECT_EQ(expected, result);
 383   }
 384
 385   // List with 8 elements.
 386   {
 387     std::vector<URLPatternSet> test;
 388     test.push_back(Patterns(google_a));
 389     test.push_back(Patterns(google_b));
 390     test.push_back(Patterns(google_c));
 391     test.push_back(Patterns(yahoo_a));
 392     test.push_back(Patterns(yahoo_b));
 393     test.push_back(Patterns(yahoo_c));
 394     test.push_back(Patterns(reddit_a));
 395     test.push_back(Patterns(reddit_b));
 396
 397     URLPatternSet result = URLPatternSet::CreateUnion(test);
 398
 399     URLPatternSet expected;
 400     AddPattern(&expected, google_a);
 401     AddPattern(&expected, google_b);
 402     AddPattern(&expected, google_c);
 403     AddPattern(&expected, yahoo_a);
 404     AddPattern(&expected, yahoo_b);
 405     AddPattern(&expected, yahoo_c);
 406     AddPattern(&expected, reddit_a);
 407     AddPattern(&expected, reddit_b);
 408     EXPECT_EQ(expected, result);
 409   }
 410
 411   // List with 9 elements.
 412   {
 413     std::vector<URLPatternSet> test;
 414     test.push_back(Patterns(google_a));
 415     test.push_back(Patterns(google_b));
 416     test.push_back(Patterns(google_c));
 417     test.push_back(Patterns(yahoo_a));
 418     test.push_back(Patterns(yahoo_b));
 419     test.push_back(Patterns(yahoo_c));
 420     test.push_back(Patterns(reddit_a));
 421     test.push_back(Patterns(reddit_b));
 422     test.push_back(Patterns(reddit_c));
 423
 424     URLPatternSet result = URLPatternSet::CreateUnion(test);
 425
 426     URLPatternSet expected;
 427     AddPattern(&expected, google_a);
 428     AddPattern(&expected, google_b);
 429     AddPattern(&expected, google_c);
 430     AddPattern(&expected, yahoo_a);
 431     AddPattern(&expected, yahoo_b);
 432     AddPattern(&expected, yahoo_c);
 433     AddPattern(&expected, reddit_a);
 434     AddPattern(&expected, reddit_b);
 435     AddPattern(&expected, reddit_c);
 436     EXPECT_EQ(expected, result);
 437   }
 438 }
 439
 440 TEST(URLPatternSetTest, AddOrigin) {
 441   URLPatternSet set;
 442   EXPECT_TRUE(set.AddOrigin(
 443       URLPattern::SCHEME_ALL, GURL("https://www.google.com/")));
 444   EXPECT_TRUE(set.MatchesURL(GURL("https://www.google.com/foo/bar")));
 445   EXPECT_FALSE(set.MatchesURL(GURL("http://www.google.com/foo/bar")));
 446   EXPECT_FALSE(set.MatchesURL(GURL("https://en.google.com/foo/bar")));
 447   set.ClearPatterns();
 448
 449   EXPECT_TRUE(set.AddOrigin(
 450       URLPattern::SCHEME_ALL, GURL("https://google.com/")));
 451   EXPECT_FALSE(set.MatchesURL(GURL("https://www.google.com/foo/bar")));
 452   EXPECT_TRUE(set.MatchesURL(GURL("https://google.com/foo/bar")));
 453
 454   EXPECT_FALSE(set.AddOrigin(
 455       URLPattern::SCHEME_HTTP, GURL("https://google.com/")));
 456 }
 457
 458 }  // namespace extensions