extensions/common/manifest_handlers/externally_connectable_unittest.cc

   1 // Copyright 2014 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 <algorithm>
   6
   7 #include "chrome/common/extensions/features/feature_channel.h"
   8 #include "chrome/common/extensions/manifest_tests/extension_manifest_test.h"
   9 #include "extensions/common/error_utils.h"
  10 #include "extensions/common/manifest_constants.h"
  11 #include "extensions/common/manifest_handlers/externally_connectable.h"
  12 #include "extensions/common/permissions/permissions_data.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 using testing::ElementsAre;
  17
  18 namespace extensions {
  19
  20 namespace errors = externally_connectable_errors;
  21
  22 class ExternallyConnectableTest : public ExtensionManifestTest {
  23  public:
  24   ExternallyConnectableTest() : channel_(chrome::VersionInfo::CHANNEL_DEV) {}
  25
  26  protected:
  27   ExternallyConnectableInfo* GetExternallyConnectableInfo(
  28       scoped_refptr<Extension> extension) {
  29     return static_cast<ExternallyConnectableInfo*>(
  30         extension->GetManifestData(manifest_keys::kExternallyConnectable));
  31   }
  32
  33  private:
  34   ScopedCurrentChannel channel_;
  35 };
  36
  37 TEST_F(ExternallyConnectableTest, IDsAndMatches) {
  38   scoped_refptr<Extension> extension =
  39       LoadAndExpectSuccess("externally_connectable_ids_and_matches.json");
  40   ASSERT_TRUE(extension.get());
  41
  42   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
  43       APIPermission::kWebConnectable));
  44
  45   ExternallyConnectableInfo* info =
  46       ExternallyConnectableInfo::Get(extension.get());
  47   ASSERT_TRUE(info);
  48
  49   EXPECT_THAT(info->ids,
  50               ElementsAre("abcdefghijklmnopabcdefghijklmnop",
  51                           "ponmlkjihgfedcbaponmlkjihgfedcba"));
  52
  53   EXPECT_FALSE(info->all_ids);
  54
  55   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://example.com")));
  56   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://example.com/")));
  57   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://example.com/index.html")));
  58
  59   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com")));
  60   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com/")));
  61   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com/index.html")));
  62   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com")));
  63   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com/")));
  64   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://google.com")));
  65   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://google.com/")));
  66
  67   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
  68   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org/")));
  69   EXPECT_TRUE(
  70       info->matches.MatchesURL(GURL("http://build.chromium.org/index.html")));
  71   EXPECT_FALSE(info->matches.MatchesURL(GURL("https://build.chromium.org")));
  72   EXPECT_FALSE(info->matches.MatchesURL(GURL("https://build.chromium.org/")));
  73   EXPECT_FALSE(
  74       info->matches.MatchesURL(GURL("http://foo.chromium.org/index.html")));
  75
  76   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://yahoo.com")));
  77   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://yahoo.com/")));
  78
  79   // TLD-style patterns should match just the TLD.
  80   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://appspot.com/foo.html")));
  81   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://com")));
  82   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://go/here")));
  83
  84   // TLD-style patterns should *not* match any subdomains of the TLD.
  85   EXPECT_FALSE(
  86       info->matches.MatchesURL(GURL("http://codereview.appspot.com/foo.html")));
  87   EXPECT_FALSE(
  88       info->matches.MatchesURL(GURL("http://chromium.com/index.html")));
  89   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://here.go/somewhere")));
  90
  91   // Paths that don't have any wildcards should match the exact domain, but
  92   // ignore the trailing slash. This is kind of a corner case, so let's test it.
  93   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://no.wildcard.path")));
  94   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://no.wildcard.path/")));
  95   EXPECT_FALSE(
  96       info->matches.MatchesURL(GURL("http://no.wildcard.path/index.html")));
  97 }
  98
  99 TEST_F(ExternallyConnectableTest, IDs) {
 100   scoped_refptr<Extension> extension =
 101       LoadAndExpectSuccess("externally_connectable_ids.json");
 102   ASSERT_TRUE(extension.get());
 103
 104   EXPECT_FALSE(extension->permissions_data()->HasAPIPermission(
 105       APIPermission::kWebConnectable));
 106
 107   ExternallyConnectableInfo* info =
 108       ExternallyConnectableInfo::Get(extension.get());
 109   ASSERT_TRUE(info);
 110
 111   EXPECT_THAT(info->ids,
 112               ElementsAre("abcdefghijklmnopabcdefghijklmnop",
 113                           "ponmlkjihgfedcbaponmlkjihgfedcba"));
 114
 115   EXPECT_FALSE(info->all_ids);
 116
 117   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://google.com/index.html")));
 118 }
 119
 120 TEST_F(ExternallyConnectableTest, Matches) {
 121   scoped_refptr<Extension> extension =
 122       LoadAndExpectSuccess("externally_connectable_matches.json");
 123   ASSERT_TRUE(extension.get());
 124
 125   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
 126       APIPermission::kWebConnectable));
 127
 128   ExternallyConnectableInfo* info =
 129       ExternallyConnectableInfo::Get(extension.get());
 130   ASSERT_TRUE(info);
 131
 132   EXPECT_THAT(info->ids, ElementsAre());
 133
 134   EXPECT_FALSE(info->all_ids);
 135
 136   EXPECT_FALSE(info->accepts_tls_channel_id);
 137
 138   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://example.com")));
 139   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://example.com/")));
 140   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://example.com/index.html")));
 141
 142   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com")));
 143   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com/")));
 144   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://google.com/index.html")));
 145   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com")));
 146   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com/")));
 147   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://google.com")));
 148   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://google.com/")));
 149
 150   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 151   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org/")));
 152   EXPECT_TRUE(
 153       info->matches.MatchesURL(GURL("http://build.chromium.org/index.html")));
 154   EXPECT_FALSE(info->matches.MatchesURL(GURL("https://build.chromium.org")));
 155   EXPECT_FALSE(info->matches.MatchesURL(GURL("https://build.chromium.org/")));
 156   EXPECT_FALSE(
 157       info->matches.MatchesURL(GURL("http://foo.chromium.org/index.html")));
 158
 159   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://yahoo.com")));
 160   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://yahoo.com/")));
 161 }
 162
 163 TEST_F(ExternallyConnectableTest, MatchesWithTlsChannelId) {
 164   scoped_refptr<Extension> extension = LoadAndExpectSuccess(
 165       "externally_connectable_matches_tls_channel_id.json");
 166   ASSERT_TRUE(extension.get());
 167
 168   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
 169       APIPermission::kWebConnectable));
 170
 171   ExternallyConnectableInfo* info =
 172       ExternallyConnectableInfo::Get(extension.get());
 173   ASSERT_TRUE(info);
 174
 175   EXPECT_THAT(info->ids, ElementsAre());
 176
 177   EXPECT_FALSE(info->all_ids);
 178
 179   EXPECT_TRUE(info->accepts_tls_channel_id);
 180
 181   // The matches portion of the manifest is identical to those in
 182   // externally_connectable_matches, so only a subset of the Matches tests is
 183   // repeated here.
 184   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://example.com")));
 185   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://example.com/index.html")));
 186 }
 187
 188 TEST_F(ExternallyConnectableTest, AllIDs) {
 189   scoped_refptr<Extension> extension =
 190       LoadAndExpectSuccess("externally_connectable_all_ids.json");
 191   ASSERT_TRUE(extension.get());
 192
 193   EXPECT_FALSE(extension->permissions_data()->HasAPIPermission(
 194       APIPermission::kWebConnectable));
 195
 196   ExternallyConnectableInfo* info =
 197       ExternallyConnectableInfo::Get(extension.get());
 198   ASSERT_TRUE(info);
 199
 200   EXPECT_THAT(info->ids,
 201               ElementsAre("abcdefghijklmnopabcdefghijklmnop",
 202                           "ponmlkjihgfedcbaponmlkjihgfedcba"));
 203
 204   EXPECT_TRUE(info->all_ids);
 205
 206   EXPECT_FALSE(info->matches.MatchesURL(GURL("http://google.com/index.html")));
 207 }
 208
 209 TEST_F(ExternallyConnectableTest, IdCanConnect) {
 210   // Not in order to test that ExternallyConnectableInfo sorts it.
 211   std::string matches_ids_array[] = {"g", "h", "c", "i", "a", "z", "b"};
 212   std::vector<std::string> matches_ids(
 213       matches_ids_array, matches_ids_array + arraysize(matches_ids_array));
 214
 215   std::string nomatches_ids_array[] = {"2", "3", "1"};
 216
 217   // all_ids = false.
 218   {
 219     ExternallyConnectableInfo info(URLPatternSet(), matches_ids, false, false);
 220     for (size_t i = 0; i < matches_ids.size(); ++i)
 221       EXPECT_TRUE(info.IdCanConnect(matches_ids[i]));
 222     for (size_t i = 0; i < arraysize(nomatches_ids_array); ++i)
 223       EXPECT_FALSE(info.IdCanConnect(nomatches_ids_array[i]));
 224   }
 225
 226   // all_ids = true.
 227   {
 228     ExternallyConnectableInfo info(URLPatternSet(), matches_ids, true, false);
 229     for (size_t i = 0; i < matches_ids.size(); ++i)
 230       EXPECT_TRUE(info.IdCanConnect(matches_ids[i]));
 231     for (size_t i = 0; i < arraysize(nomatches_ids_array); ++i)
 232       EXPECT_TRUE(info.IdCanConnect(nomatches_ids_array[i]));
 233   }
 234 }
 235
 236 TEST_F(ExternallyConnectableTest, ErrorWrongFormat) {
 237   LoadAndExpectError("externally_connectable_error_wrong_format.json",
 238                      "expected dictionary, got string");
 239 }
 240
 241 TEST_F(ExternallyConnectableTest, ErrorBadID) {
 242   LoadAndExpectError(
 243       "externally_connectable_bad_id.json",
 244       ErrorUtils::FormatErrorMessage(errors::kErrorInvalidId, "badid"));
 245 }
 246
 247 TEST_F(ExternallyConnectableTest, ErrorBadMatches) {
 248   LoadAndExpectError("externally_connectable_error_bad_matches.json",
 249                      ErrorUtils::FormatErrorMessage(
 250                          errors::kErrorInvalidMatchPattern, "www.yahoo.com"));
 251 }
 252
 253 TEST_F(ExternallyConnectableTest, WarningNoAllURLs) {
 254   scoped_refptr<Extension> extension = LoadAndExpectWarning(
 255       "externally_connectable_error_all_urls.json",
 256       ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
 257                                      "<all_urls>"));
 258   ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
 259   EXPECT_FALSE(info->matches.ContainsPattern(
 260       URLPattern(URLPattern::SCHEME_ALL, "<all_urls>")));
 261   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
 262   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 263 }
 264
 265 TEST_F(ExternallyConnectableTest, WarningWildcardHost) {
 266   scoped_refptr<Extension> extension = LoadAndExpectWarning(
 267       "externally_connectable_error_wildcard_host.json",
 268       ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
 269                                      "http://*/*"));
 270   ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
 271   EXPECT_FALSE(info->matches.ContainsPattern(
 272       URLPattern(URLPattern::SCHEME_ALL, "http://*/*")));
 273   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
 274   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 275 }
 276
 277 TEST_F(ExternallyConnectableTest, WarningNoTLD) {
 278   scoped_refptr<Extension> extension = LoadAndExpectWarning(
 279       "externally_connectable_error_tld.json",
 280       ErrorUtils::FormatErrorMessage(errors::kErrorTopLevelDomainsNotAllowed,
 281                                      "co.uk",
 282                                      "http://*.co.uk/*"));
 283   ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
 284   EXPECT_FALSE(info->matches.ContainsPattern(
 285       URLPattern(URLPattern::SCHEME_ALL, "http://*.co.uk/*")));
 286   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
 287   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 288 }
 289
 290 TEST_F(ExternallyConnectableTest, WarningNoEffectiveTLD) {
 291   scoped_refptr<Extension> extension = LoadAndExpectWarning(
 292       "externally_connectable_error_effective_tld.json",
 293       ErrorUtils::FormatErrorMessage(errors::kErrorTopLevelDomainsNotAllowed,
 294                                      "appspot.com",
 295                                      "http://*.appspot.com/*"));
 296   ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
 297   EXPECT_FALSE(info->matches.ContainsPattern(
 298       URLPattern(URLPattern::SCHEME_ALL, "http://*.appspot.com/*")));
 299   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
 300   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 301 }
 302
 303 TEST_F(ExternallyConnectableTest, WarningUnknownTLD) {
 304   scoped_refptr<Extension> extension = LoadAndExpectWarning(
 305       "externally_connectable_error_unknown_tld.json",
 306       ErrorUtils::FormatErrorMessage(errors::kErrorTopLevelDomainsNotAllowed,
 307                                      "notatld",
 308                                      "http://*.notatld/*"));
 309   ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
 310   EXPECT_FALSE(info->matches.ContainsPattern(
 311       URLPattern(URLPattern::SCHEME_ALL, "http://*.notatld/*")));
 312   EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
 313   EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 314 }
 315
 316 TEST_F(ExternallyConnectableTest, WarningNothingSpecified) {
 317   LoadAndExpectWarning("externally_connectable_nothing_specified.json",
 318                        errors::kErrorNothingSpecified);
 319 }
 320
 321 }  // namespace extensions