Create DeclarativeConditionSet, DeclarativeActionSet, and DeclarativeRule templates

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_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 "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 
 #include <vector>
 
+#include "base/json/json_reader.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
+#include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
-#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
-#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
-#include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const char kExtensionId[] = "ext1";
 const char kExtensionId2[] = "ext2";
 const char kRuleId1[] = "rule1";
 const char kRuleId2[] = "rule2";
 const char kRuleId3[] = "rule3";
 const char kRuleId4[] = "rule4";
 }  // namespace
 
 namespace extensions {
 
+using testing::HasSubstr;
+
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = declarative_webrequest_constants;
 namespace keys2 = url_matcher_constants;
 
 class TestWebRequestRulesRegistry : public WebRequestRulesRegistry {
  public:
   TestWebRequestRulesRegistry()
       : WebRequestRulesRegistry(NULL, NULL),
         num_clear_cache_calls_(0) {}
 
@@ skipping 182 matching lines @@
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<WebRequestRule::GlobalRuleId> matches;
 
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
   net::TestURLRequest http_request(http_url, NULL, &context);
   matches = registry->GetMatches(
-      WebRequestRule::RequestData(&http_request, ON_BEFORE_REQUEST));
+      DeclarativeWebRequestData(&http_request, ON_BEFORE_REQUEST));
   EXPECT_EQ(2u, matches.size());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId1)) !=
       matches.end());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId2)) !=
       matches.end());
 
   GURL foobar_url("http://www.foobar.com");
   net::TestURLRequest foobar_request(foobar_url, NULL, &context);
   matches = registry->GetMatches(
-      WebRequestRule::RequestData(&foobar_request, ON_BEFORE_REQUEST));
+      DeclarativeWebRequestData(&foobar_request, ON_BEFORE_REQUEST));
   EXPECT_EQ(1u, matches.size());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId2)) !=
       matches.end());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
 
@@ skipping 103 matching lines @@
   rules_to_add_2[0] = CreateRedirectRule("http://www.bar.com");
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com");
   net::TestURLRequestContext context;
   net::TestURLRequest request(url, NULL, &context);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(
           NULL,
-          WebRequestRule::RequestData(&request, ON_BEFORE_REQUEST),
+          DeclarativeWebRequestData(&request, ON_BEFORE_REQUEST),
           false);
 
   // The second extension is installed later and will win for this reason
   // in conflict resolution.
   ASSERT_EQ(2u, deltas.size());
   deltas.sort(&helpers::InDecreasingExtensionInstallationTimeOrder);
 
   std::list<LinkedPtrEventResponseDelta>::iterator i = deltas.begin();
   LinkedPtrEventResponseDelta winner = *i++;
   LinkedPtrEventResponseDelta loser = *i;
@@ skipping 29 matching lines @@
   rules_to_add_3[0] = CreateIgnoreRule();
   error = registry->AddRules(kExtensionId, rules_to_add_3);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com/index.html");
   net::TestURLRequestContext context;
   net::TestURLRequest request(url, NULL, &context);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(
           NULL,
-          WebRequestRule::RequestData(&request, ON_BEFORE_REQUEST),
+          DeclarativeWebRequestData(&request, ON_BEFORE_REQUEST),
           false);
 
   // The redirect by the first extension is ignored due to the ignore rule.
   ASSERT_EQ(1u, deltas.size());
   LinkedPtrEventResponseDelta effective_rule = *(deltas.begin());
 
   EXPECT_EQ(kExtensionId2, effective_rule->extension_id);
   EXPECT_EQ(base::Time() + base::TimeDelta::FromDays(2),
             effective_rule->extension_install_time);
   EXPECT_EQ(GURL("http://www.bar.com"), effective_rule->new_url);
 }
+
+TEST_F(WebRequestRulesRegistryTest, CheckConsistency) {
+  // The contentType condition can only be evaluated during ON_HEADERS_RECEIVED
+  // but the redirect action can only be executed during ON_BEFORE_REQUEST.
+  // Therefore, this is an inconsistent rule that needs to be flagged.
+  const char kRule[] =
+      "{                                                                 \n"
+      "  \"id\": \"rule1\",                                              \n"
+      "  \"conditions\": [                                               \n"
+      "    {                                                             \n"
+      "      \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
+      "      \"url\": {\"hostSuffix\": \"foo.com\"},                     \n"
+      "      \"contentType\": [\"image/jpeg\"]                           \n"
+      "    }                                                             \n"
+      "  ],                                                              \n"
+      "  \"actions\": [                                                  \n"
+      "    {                                                             \n"
+      "      \"instanceType\": \"declarativeWebRequest.RedirectRequest\",\n"
+      "      \"redirectUrl\": \"http://bar.com\"                         \n"
+      "    }                                                             \n"
+      "  ],                                                              \n"
+      "  \"priority\": 200                                               \n"
+      "}                                                                 ";
+
+  scoped_ptr<Value> value(base::JSONReader::Read(kRule));
+  ASSERT_TRUE(value.get());
+
+  std::vector<linked_ptr<RulesRegistry::Rule> > rules;
+  rules.push_back(make_linked_ptr(new RulesRegistry::Rule));
+  ASSERT_TRUE(RulesRegistry::Rule::Populate(*value, rules.back().get()));
+
+  scoped_refptr<WebRequestRulesRegistry> registry(
+      new TestWebRequestRulesRegistry());
+
+  URLMatcher matcher;
+  std::string error = registry->AddRulesImpl(kExtensionId, rules);
+  EXPECT_THAT(error, HasSubstr("no time in the request life-cycle"));
+  EXPECT_TRUE(registry->IsEmpty());
+}
+
 }  // namespace extensions