chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_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 "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.h"
   6
   7 #include <set>
   8
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/test/values_test_util.h"
  11 #include "base/values.h"
  12 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
  13 #include "components/url_matcher/url_matcher_constants.h"
  14 #include "content/public/browser/resource_request_info.h"
  15 #include "net/base/request_priority.h"
  16 #include "net/url_request/url_request_test_util.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 using url_matcher::URLMatcher;
  20 using url_matcher::URLMatcherConditionSet;
  21
  22 namespace extensions {
  23
  24 TEST(WebRequestConditionTest, CreateCondition) {
  25   // Necessary for TestURLRequest.
  26   base::MessageLoopForIO message_loop;
  27   URLMatcher matcher;
  28
  29   std::string error;
  30   scoped_ptr<WebRequestCondition> result;
  31
  32   // Test wrong condition name passed.
  33   error.clear();
  34   result = WebRequestCondition::Create(
  35       NULL,
  36       matcher.condition_factory(),
  37       *base::test::ParseJson(
  38            "{ \"invalid\": \"foobar\", \n"
  39            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
  40            "}"),
  41       &error);
  42   EXPECT_FALSE(error.empty());
  43   EXPECT_FALSE(result.get());
  44
  45   // Test wrong datatype in host_suffix.
  46   error.clear();
  47   result = WebRequestCondition::Create(
  48       NULL,
  49       matcher.condition_factory(),
  50       *base::test::ParseJson(
  51            "{ \n"
  52            "  \"url\": [], \n"
  53            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
  54            "}"),
  55       &error);
  56   EXPECT_FALSE(error.empty());
  57   EXPECT_FALSE(result.get());
  58
  59   // Test success (can we support multiple criteria?)
  60   error.clear();
  61   result = WebRequestCondition::Create(
  62       NULL,
  63       matcher.condition_factory(),
  64       *base::test::ParseJson(
  65            "{ \n"
  66            "  \"resourceType\": [\"main_frame\"], \n"
  67            "  \"url\": { \"hostSuffix\": \"example.com\" }, \n"
  68            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
  69            "}"),
  70       &error);
  71   EXPECT_EQ("", error);
  72   ASSERT_TRUE(result.get());
  73
  74   URLMatcherConditionSet::Vector url_matcher_condition_set;
  75   result->GetURLMatcherConditionSets(&url_matcher_condition_set);
  76   matcher.AddConditionSets(url_matcher_condition_set);
  77
  78   net::TestURLRequestContext context;
  79   const GURL http_url("http://www.example.com");
  80   net::TestURLRequest match_request(
  81       http_url, net::DEFAULT_PRIORITY, NULL, &context);
  82   WebRequestData data(&match_request, ON_BEFORE_REQUEST);
  83   WebRequestDataWithMatchIds request_data(&data);
  84   request_data.url_match_ids = matcher.MatchURL(http_url);
  85   EXPECT_EQ(1u, request_data.url_match_ids.size());
  86   content::ResourceRequestInfo::AllocateForTesting(
  87       &match_request, ResourceType::MAIN_FRAME, NULL, -1, -1, -1, false);
  88   EXPECT_TRUE(result->IsFulfilled(request_data));
  89
  90   const GURL https_url("https://www.example.com");
  91   net::TestURLRequest wrong_resource_type(
  92       https_url, net::DEFAULT_PRIORITY, NULL, &context);
  93   data.request = &wrong_resource_type;
  94   request_data.url_match_ids = matcher.MatchURL(http_url);
  95   // Make sure IsFulfilled does not fail because of URL matching.
  96   EXPECT_EQ(1u, request_data.url_match_ids.size());
  97   content::ResourceRequestInfo::AllocateForTesting(
  98       &wrong_resource_type, ResourceType::SUB_FRAME, NULL, -1, -1, -1, false);
  99   EXPECT_FALSE(result->IsFulfilled(request_data));
 100 }
 101
 102 TEST(WebRequestConditionTest, CreateConditionFirstPartyForCookies) {
 103   // Necessary for TestURLRequest.
 104   base::MessageLoopForIO message_loop;
 105   URLMatcher matcher;
 106
 107   std::string error;
 108   scoped_ptr<WebRequestCondition> result;
 109
 110   result = WebRequestCondition::Create(
 111       NULL,
 112       matcher.condition_factory(),
 113       *base::test::ParseJson(
 114            "{ \n"
 115            "  \"firstPartyForCookiesUrl\": { \"hostPrefix\": \"fpfc\"}, \n"
 116            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 117            "}"),
 118       &error);
 119   EXPECT_EQ("", error);
 120   ASSERT_TRUE(result.get());
 121
 122   URLMatcherConditionSet::Vector url_matcher_condition_set;
 123   result->GetURLMatcherConditionSets(&url_matcher_condition_set);
 124   matcher.AddConditionSets(url_matcher_condition_set);
 125
 126   net::TestURLRequestContext context;
 127   const GURL http_url("http://www.example.com");
 128   const GURL first_party_url("http://fpfc.example.com");
 129   net::TestURLRequest match_request(
 130       http_url, net::DEFAULT_PRIORITY, NULL, &context);
 131   WebRequestData data(&match_request, ON_BEFORE_REQUEST);
 132   WebRequestDataWithMatchIds request_data(&data);
 133   request_data.url_match_ids = matcher.MatchURL(http_url);
 134   EXPECT_EQ(0u, request_data.url_match_ids.size());
 135   request_data.first_party_url_match_ids = matcher.MatchURL(first_party_url);
 136   EXPECT_EQ(1u, request_data.first_party_url_match_ids.size());
 137   content::ResourceRequestInfo::AllocateForTesting(
 138       &match_request, ResourceType::MAIN_FRAME, NULL, -1, -1, -1, false);
 139   EXPECT_TRUE(result->IsFulfilled(request_data));
 140 }
 141
 142 // Conditions without UrlFilter attributes need to be independent of URL
 143 // matching results. We test here that:
 144 //   1. A non-empty condition without UrlFilter attributes is fulfilled iff its
 145 //      attributes are fulfilled.
 146 //   2. An empty condition (in particular, without UrlFilter attributes) is
 147 //      always fulfilled.
 148 TEST(WebRequestConditionTest, NoUrlAttributes) {
 149   // Necessary for TestURLRequest.
 150   base::MessageLoopForIO message_loop;
 151   URLMatcher matcher;
 152   std::string error;
 153
 154   // The empty condition.
 155   error.clear();
 156   scoped_ptr<WebRequestCondition> condition_empty = WebRequestCondition::Create(
 157       NULL,
 158       matcher.condition_factory(),
 159       *base::test::ParseJson(
 160            "{ \n"
 161            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 162            "}"),
 163       &error);
 164   EXPECT_EQ("", error);
 165   ASSERT_TRUE(condition_empty.get());
 166
 167   // A condition without a UrlFilter attribute, which is always true.
 168   error.clear();
 169   scoped_ptr<WebRequestCondition> condition_no_url_true =
 170       WebRequestCondition::Create(
 171           NULL,
 172           matcher.condition_factory(),
 173           *base::test::ParseJson(
 174                "{ \n"
 175                "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", "
 176                "\n"
 177                // There is no "1st party for cookies" URL in the requests below,
 178                // therefore all requests are considered first party for cookies.
 179                "  \"thirdPartyForCookies\": false, \n"
 180                "}"),
 181           &error);
 182   EXPECT_EQ("", error);
 183   ASSERT_TRUE(condition_no_url_true.get());
 184
 185   // A condition without a UrlFilter attribute, which is always false.
 186   error.clear();
 187   scoped_ptr<WebRequestCondition> condition_no_url_false =
 188       WebRequestCondition::Create(
 189           NULL,
 190           matcher.condition_factory(),
 191           *base::test::ParseJson(
 192                "{ \n"
 193                "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", "
 194                "\n"
 195                "  \"thirdPartyForCookies\": true, \n"
 196                "}"),
 197           &error);
 198   EXPECT_EQ("", error);
 199   ASSERT_TRUE(condition_no_url_false.get());
 200
 201   net::TestURLRequestContext context;
 202   net::TestURLRequest https_request(
 203       GURL("https://www.example.com"), net::DEFAULT_PRIORITY, NULL, &context);
 204
 205   // 1. A non-empty condition without UrlFilter attributes is fulfilled iff its
 206   //    attributes are fulfilled.
 207   WebRequestData data(&https_request, ON_BEFORE_REQUEST);
 208   EXPECT_FALSE(
 209       condition_no_url_false->IsFulfilled(WebRequestDataWithMatchIds(&data)));
 210
 211   data = WebRequestData(&https_request, ON_BEFORE_REQUEST);
 212   EXPECT_TRUE(
 213       condition_no_url_true->IsFulfilled(WebRequestDataWithMatchIds(&data)));
 214
 215   // 2. An empty condition (in particular, without UrlFilter attributes) is
 216   //    always fulfilled.
 217   data = WebRequestData(&https_request, ON_BEFORE_REQUEST);
 218   EXPECT_TRUE(condition_empty->IsFulfilled(WebRequestDataWithMatchIds(&data)));
 219 }
 220
 221 TEST(WebRequestConditionTest, CreateConditionSet) {
 222   // Necessary for TestURLRequest.
 223   base::MessageLoopForIO message_loop;
 224   URLMatcher matcher;
 225
 226   WebRequestConditionSet::AnyVector conditions;
 227   conditions.push_back(linked_ptr<base::Value>(base::test::ParseJson(
 228       "{ \n"
 229       "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 230       "  \"url\": { \n"
 231       "    \"hostSuffix\": \"example.com\", \n"
 232       "    \"schemes\": [\"http\"], \n"
 233       "  }, \n"
 234       "}").release()));
 235   conditions.push_back(linked_ptr<base::Value>(base::test::ParseJson(
 236       "{ \n"
 237       "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 238       "  \"url\": { \n"
 239       "    \"hostSuffix\": \"example.com\", \n"
 240       "    \"hostPrefix\": \"www\", \n"
 241       "    \"schemes\": [\"https\"], \n"
 242       "  }, \n"
 243       "}").release()));
 244
 245   // Test insertion
 246   std::string error;
 247   scoped_ptr<WebRequestConditionSet> result = WebRequestConditionSet::Create(
 248       NULL, matcher.condition_factory(), conditions, &error);
 249   EXPECT_EQ("", error);
 250   ASSERT_TRUE(result.get());
 251   EXPECT_EQ(2u, result->conditions().size());
 252
 253   // Tell the URLMatcher about our shiny new patterns.
 254   URLMatcherConditionSet::Vector url_matcher_condition_set;
 255   result->GetURLMatcherConditionSets(&url_matcher_condition_set);
 256   matcher.AddConditionSets(url_matcher_condition_set);
 257
 258   // Test that the result is correct and matches http://www.example.com and
 259   // https://www.example.com
 260   GURL http_url("http://www.example.com");
 261   net::TestURLRequestContext context;
 262   net::TestURLRequest http_request(
 263       http_url, net::DEFAULT_PRIORITY, NULL, &context);
 264   WebRequestData data(&http_request, ON_BEFORE_REQUEST);
 265   WebRequestDataWithMatchIds request_data(&data);
 266   request_data.url_match_ids = matcher.MatchURL(http_url);
 267   EXPECT_EQ(1u, request_data.url_match_ids.size());
 268   EXPECT_TRUE(result->IsFulfilled(*(request_data.url_match_ids.begin()),
 269                                   request_data));
 270
 271   GURL https_url("https://www.example.com");
 272   request_data.url_match_ids = matcher.MatchURL(https_url);
 273   EXPECT_EQ(1u, request_data.url_match_ids.size());
 274   net::TestURLRequest https_request(
 275       https_url, net::DEFAULT_PRIORITY, NULL, &context);
 276   data.request = &https_request;
 277   EXPECT_TRUE(result->IsFulfilled(*(request_data.url_match_ids.begin()),
 278                                   request_data));
 279
 280   // Check that both, hostPrefix and hostSuffix are evaluated.
 281   GURL https_foo_url("https://foo.example.com");
 282   request_data.url_match_ids = matcher.MatchURL(https_foo_url);
 283   EXPECT_EQ(0u, request_data.url_match_ids.size());
 284   net::TestURLRequest https_foo_request(
 285       https_foo_url, net::DEFAULT_PRIORITY, NULL, &context);
 286   data.request = &https_foo_request;
 287   EXPECT_FALSE(result->IsFulfilled(-1, request_data));
 288 }
 289
 290 TEST(WebRequestConditionTest, TestPortFilter) {
 291   // Necessary for TestURLRequest.
 292   base::MessageLoopForIO message_loop;
 293   URLMatcher matcher;
 294
 295   WebRequestConditionSet::AnyVector conditions;
 296   conditions.push_back(linked_ptr<base::Value>(base::test::ParseJson(
 297       "{ \n"
 298       "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 299       "  \"url\": { \n"
 300       "    \"ports\": [80, [1000, 1010]], \n"  // Allow 80;1000-1010.
 301       "    \"hostSuffix\": \"example.com\", \n"
 302       "  }, \n"
 303       "}").release()));
 304
 305   // Test insertion
 306   std::string error;
 307   scoped_ptr<WebRequestConditionSet> result = WebRequestConditionSet::Create(
 308       NULL, matcher.condition_factory(), conditions, &error);
 309   EXPECT_EQ("", error);
 310   ASSERT_TRUE(result.get());
 311   EXPECT_EQ(1u, result->conditions().size());
 312
 313   // Tell the URLMatcher about our shiny new patterns.
 314   URLMatcherConditionSet::Vector url_matcher_condition_set;
 315   result->GetURLMatcherConditionSets(&url_matcher_condition_set);
 316   matcher.AddConditionSets(url_matcher_condition_set);
 317
 318   std::set<URLMatcherConditionSet::ID> url_match_ids;
 319
 320   // Test various URLs.
 321   GURL http_url("http://www.example.com");
 322   net::TestURLRequestContext context;
 323   net::TestURLRequest http_request(
 324       http_url, net::DEFAULT_PRIORITY, NULL, &context);
 325   url_match_ids = matcher.MatchURL(http_url);
 326   ASSERT_EQ(1u, url_match_ids.size());
 327
 328   GURL http_url_80("http://www.example.com:80");
 329   net::TestURLRequest http_request_80(
 330       http_url_80, net::DEFAULT_PRIORITY, NULL, &context);
 331   url_match_ids = matcher.MatchURL(http_url_80);
 332   ASSERT_EQ(1u, url_match_ids.size());
 333
 334   GURL http_url_1000("http://www.example.com:1000");
 335   net::TestURLRequest http_request_1000(
 336       http_url_1000, net::DEFAULT_PRIORITY, NULL, &context);
 337   url_match_ids = matcher.MatchURL(http_url_1000);
 338   ASSERT_EQ(1u, url_match_ids.size());
 339
 340   GURL http_url_2000("http://www.example.com:2000");
 341   net::TestURLRequest http_request_2000(
 342       http_url_2000, net::DEFAULT_PRIORITY, NULL, &context);
 343   url_match_ids = matcher.MatchURL(http_url_2000);
 344   ASSERT_EQ(0u, url_match_ids.size());
 345 }
 346
 347 // Create a condition with two attributes: one on the request header and one on
 348 // the response header. The Create() method should fail and complain that it is
 349 // impossible that both conditions are fulfilled at the same time.
 350 TEST(WebRequestConditionTest, ConditionsWithConflictingStages) {
 351   // Necessary for TestURLRequest.
 352   base::MessageLoopForIO message_loop;
 353   URLMatcher matcher;
 354
 355   std::string error;
 356   scoped_ptr<WebRequestCondition> result;
 357
 358   // Test error on incompatible application stages for involved attributes.
 359   error.clear();
 360   result = WebRequestCondition::Create(
 361       NULL,
 362       matcher.condition_factory(),
 363       *base::test::ParseJson(
 364            "{ \n"
 365            "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
 366            // Pass a JS array with one empty object to each of the header
 367            // filters.
 368            "  \"requestHeaders\": [{}], \n"
 369            "  \"responseHeaders\": [{}], \n"
 370            "}"),
 371       &error);
 372   EXPECT_FALSE(error.empty());
 373   EXPECT_FALSE(result.get());
 374 }
 375
 376 }  // namespace extensions