Support requesting subsets of host permissions using the permissions API.

extensions/common/url_pattern_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
 #include "extensions/common/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "googleurl/src/gurl.h"
 
+namespace {
+
 // See url_pattern.h for examples of valid and invalid patterns.
 
 static const int kAllSchemes =
     URLPattern::SCHEME_HTTP |
     URLPattern::SCHEME_HTTPS |
     URLPattern::SCHEME_FILE |
     URLPattern::SCHEME_FTP |
     URLPattern::SCHEME_CHROMEUI |
     URLPattern::SCHEME_EXTENSION |
     URLPattern::SCHEME_FILESYSTEM;
@@ skipping 421 matching lines @@
   for (size_t i = 0; i < arraysize(kGetAsStringTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_SUCCESS,
               pattern.Parse(kGetAsStringTestCases[i].pattern))
         << "Error parsing " << kGetAsStringTestCases[i].pattern;
     EXPECT_EQ(kGetAsStringTestCases[i].pattern,
               pattern.GetAsString());
   }
 }
 
-void TestPatternOverlap(const URLPattern& pattern1, const URLPattern& pattern2,
-                        bool expect_overlap) {
-  EXPECT_EQ(expect_overlap, pattern1.OverlapsWith(pattern2))
-      << pattern1.GetAsString() << ", " << pattern2.GetAsString();
-  EXPECT_EQ(expect_overlap, pattern2.OverlapsWith(pattern1))
-      << pattern2.GetAsString() << ", " << pattern1.GetAsString();
+testing::AssertionResult OverlapsWith(const URLPattern& pattern1,

[Matt Perry, 2013/02/12 19:07:17]

nit: Overlap would be more accurate since it doesn't imply direction

[not at google - send to devlin, 2013/02/12 19:56:20]

Done.

+                                      const URLPattern& pattern2) {
+  if (!pattern1.OverlapsWith(pattern2)) {
+    return testing::AssertionFailure()
+        << pattern1 << " does not overlap " << pattern2;
+  }
+  if (!pattern2.OverlapsWith(pattern1)) {
+    return testing::AssertionFailure()
+        << pattern2 << " does not overlap " << pattern1;
+  }
+  return testing::AssertionSuccess()
+      << pattern1 << " overlaps with " << pattern2;
 }
 
 TEST(ExtensionURLPatternTest, OverlapsWith) {
   URLPattern pattern1(kAllSchemes, "http://www.google.com/foo/*");
   URLPattern pattern2(kAllSchemes, "https://www.google.com/foo/*");
   URLPattern pattern3(kAllSchemes, "http://*.google.com/foo/*");
   URLPattern pattern4(kAllSchemes, "http://*.yahooo.com/foo/*");
   URLPattern pattern5(kAllSchemes, "http://www.yahooo.com/bar/*");
   URLPattern pattern6(kAllSchemes,
                       "http://www.yahooo.com/bar/baz/*");
   URLPattern pattern7(kAllSchemes, "file:///*");
   URLPattern pattern8(kAllSchemes, "*://*/*");
   URLPattern pattern9(URLPattern::SCHEME_HTTPS, "*://*/*");
   URLPattern pattern10(kAllSchemes, "<all_urls>");
 
-  TestPatternOverlap(pattern1, pattern1, true);
-  TestPatternOverlap(pattern1, pattern2, false);
-  TestPatternOverlap(pattern1, pattern3, true);
-  TestPatternOverlap(pattern1, pattern4, false);
-  TestPatternOverlap(pattern3, pattern4, false);
-  TestPatternOverlap(pattern4, pattern5, false);
-  TestPatternOverlap(pattern5, pattern6, true);
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern1));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern2));
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern3));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern4));
+  EXPECT_FALSE(OverlapsWith(pattern3, pattern4));
+  EXPECT_FALSE(OverlapsWith(pattern4, pattern5));
+  EXPECT_TRUE(OverlapsWith(pattern5, pattern6));
 
   // Test that scheme restrictions work.
-  TestPatternOverlap(pattern1, pattern8, true);
-  TestPatternOverlap(pattern1, pattern9, false);
-  TestPatternOverlap(pattern1, pattern10, true);
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern8));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern9));
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern10));
 
   // Test that '<all_urls>' includes file URLs, while scheme '*' does not.
-  TestPatternOverlap(pattern7, pattern8, false);
-  TestPatternOverlap(pattern7, pattern10, true);
+  EXPECT_FALSE(OverlapsWith(pattern7, pattern8));
+  EXPECT_TRUE(OverlapsWith(pattern7, pattern10));
 
   // Test that wildcard schemes are handled correctly, especially when compared
   // to each-other.
   URLPattern pattern11(kAllSchemes, "http://example.com/*");
   URLPattern pattern12(kAllSchemes, "*://example.com/*");
   URLPattern pattern13(kAllSchemes, "*://example.com/foo/*");
   URLPattern pattern14(kAllSchemes, "*://google.com/*");
-  TestPatternOverlap(pattern8, pattern12, true);
-  TestPatternOverlap(pattern9, pattern12, true);
-  TestPatternOverlap(pattern10, pattern12, true);
-  TestPatternOverlap(pattern11, pattern12, true);
-  TestPatternOverlap(pattern12, pattern13, true);
-  TestPatternOverlap(pattern11, pattern13, true);
-  TestPatternOverlap(pattern14, pattern12, false);
-  TestPatternOverlap(pattern14, pattern13, false);
+  EXPECT_TRUE(OverlapsWith(pattern8, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern9, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern10, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern11, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern12, pattern13));
+  EXPECT_TRUE(OverlapsWith(pattern11, pattern13));
+  EXPECT_FALSE(OverlapsWith(pattern14, pattern12));
+  EXPECT_FALSE(OverlapsWith(pattern14, pattern13));
 }
 
 TEST(ExtensionURLPatternTest, ConvertToExplicitSchemes) {
   URLPatternList all_urls(URLPattern(
       kAllSchemes,
       "<all_urls>").ConvertToExplicitSchemes());
 
   URLPatternList all_schemes(URLPattern(
       kAllSchemes,
       "*://google.com/foo").ConvertToExplicitSchemes());
@@ skipping 137 matching lines @@
 
   EXPECT_FALSE(pattern2.MatchesURL(GURL("http://bb.com/path")));
   EXPECT_TRUE(pattern2.MatchesURL(GURL("http://aa.com/path")));
   EXPECT_FALSE(pattern2.MatchesURL(GURL("http://sub.aa.com/path")));
 
   URLPattern pattern3(URLPattern::SCHEME_ALL, "http://aa.com/*");
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern3.Parse("http://aa.com:88/*"));
   EXPECT_FALSE(pattern3.MatchesURL(GURL("http://aa.com/path")));
   EXPECT_TRUE(pattern3.MatchesURL(GURL("http://aa.com:88/path")));
 }
+
+// Returns success if neither |a| nor |b| encompasses the other.
+testing::AssertionResult NeitherEncompasses(const URLPattern& a,
+                                            const URLPattern& b) {
+  if (a.Encompasses(b))
+    return testing::AssertionFailure() << a << " encompasses " << b;
+  if (b.Encompasses(a))
+    return testing::AssertionFailure() << b << " encompasses " << a;
+  return testing::AssertionSuccess() <<
+      "Neither " << a << " nor " << b << " encompass the other";
+}
+
+// Returns success if |a| encompasses |b| but not the other way around.
+testing::AssertionResult StrictlyEncompasses(const URLPattern& a,
+                                             const URLPattern& b) {
+  if (!a.Encompasses(b))
+    return testing::AssertionFailure() << a << " does not encompass " << b;
+  if (b.Encompasses(a))
+    return testing::AssertionFailure() << b << " encompasses " << a;
+  return testing::AssertionSuccess() << a << " strictly encompasses " << b;
+}
+
+TEST(ExtensionURLPatternTest, Subset) {
+  URLPattern pattern1(kAllSchemes, "http://www.google.com/foo/*");
+  URLPattern pattern2(kAllSchemes, "https://www.google.com/foo/*");
+  URLPattern pattern3(kAllSchemes, "http://*.google.com/foo/*");
+  URLPattern pattern4(kAllSchemes, "http://*.yahooo.com/foo/*");
+  URLPattern pattern5(kAllSchemes, "http://www.yahooo.com/bar/*");
+  URLPattern pattern6(kAllSchemes, "http://www.yahooo.com/bar/baz/*");
+  URLPattern pattern7(kAllSchemes, "file:///*");
+  URLPattern pattern8(kAllSchemes, "*://*/*");
+  URLPattern pattern9(URLPattern::SCHEME_HTTPS, "*://*/*");
+  URLPattern pattern10(kAllSchemes, "<all_urls>");
+  URLPattern pattern11(kAllSchemes, "http://example.com/*");
+  URLPattern pattern12(kAllSchemes, "*://example.com/*");
+  URLPattern pattern13(kAllSchemes, "*://example.com/foo/*");
+
+  // All patterns should encompass themselves.
+  EXPECT_TRUE(pattern1.Encompasses(pattern1));
+  EXPECT_TRUE(pattern2.Encompasses(pattern2));
+  EXPECT_TRUE(pattern3.Encompasses(pattern3));
+  EXPECT_TRUE(pattern4.Encompasses(pattern4));
+  EXPECT_TRUE(pattern5.Encompasses(pattern5));
+  EXPECT_TRUE(pattern6.Encompasses(pattern6));
+  EXPECT_TRUE(pattern7.Encompasses(pattern7));
+  EXPECT_TRUE(pattern8.Encompasses(pattern8));
+  EXPECT_TRUE(pattern9.Encompasses(pattern9));
+  EXPECT_TRUE(pattern10.Encompasses(pattern10));
+  EXPECT_TRUE(pattern11.Encompasses(pattern11));
+  EXPECT_TRUE(pattern12.Encompasses(pattern12));
+  EXPECT_TRUE(pattern13.Encompasses(pattern13));
+
+  // pattern1's relationship to the other patterns.
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern3, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern4));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern5));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern6));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern8, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern12));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern13));
+
+  // pattern2's relationship to the other patterns.
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern3));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern4));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern5));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern6));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern8, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern9, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern2));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern12));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern13));
+
+  // Specifically test file:// URLs.
+  EXPECT_TRUE(NeitherEncompasses(pattern7, pattern8));
+  EXPECT_TRUE(NeitherEncompasses(pattern7, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern7));
+
+  // <all_urls> encompasses everything.
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern1));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern3));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern4));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern5));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern6));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern8));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern11));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern12));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern13));
+
+  // More...
+  EXPECT_TRUE(StrictlyEncompasses(pattern12, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern11, pattern13));
+  EXPECT_TRUE(StrictlyEncompasses(pattern12, pattern13));
+}
+
+}  // namespace