summaryrefslogtreecommitdiffstats
path: root/chrome/browser/extensions/api/declarative_content/content_condition_unittest.cc
blob: a26bf4c22398ba5e6ffad568915b2fc90f7cf39d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// 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_content/content_condition.h"

#include <set>

#include "base/message_loop.h"
#include "base/test/values_test_util.h"
#include "base/values.h"
#include "chrome/browser/extensions/api/declarative_content/content_constants.h"
#include "chrome/common/extensions/matcher/url_matcher.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace extensions {
namespace {

using testing::ElementsAre;
using testing::HasSubstr;

TEST(DeclarativeContentConditionTest, ErroneousCondition) {
  URLMatcher matcher;

  std::string error;
  scoped_ptr<ContentCondition> result;

  // Test unknown condition name passed.
  error.clear();
  result = ContentCondition::Create(
      matcher.condition_factory(),
      *base::test::ParseJson(
          "{\n"
          "  \"invalid\": \"foobar\",\n"
          "  \"instanceType\": \"declarativeContent.PageStateMatcher\",\n"
          "}"),
      &error);
  EXPECT_THAT(error, HasSubstr("Unknown condition attribute"));
  EXPECT_FALSE(result);

  // Test wrong datatype in pageUrl.
  error.clear();
  result = ContentCondition::Create(
      matcher.condition_factory(),
      *base::test::ParseJson(
          "{\n"
          "  \"pageUrl\": [],\n"
          "  \"instanceType\": \"declarativeContent.PageStateMatcher\",\n"
          "}"),
      &error);
  EXPECT_THAT(error, HasSubstr("invalid type"));
  EXPECT_FALSE(result);

  EXPECT_TRUE(matcher.IsEmpty()) << "Errors shouldn't add URL conditions";
}

TEST(DeclarativeContentConditionTest, ConditionWithUrlAndCss) {
  URLMatcher matcher;

  std::string error;
  scoped_ptr<ContentCondition> result = ContentCondition::Create(
      matcher.condition_factory(),
      *base::test::ParseJson(
          "{\n"
          "  \"instanceType\": \"declarativeContent.PageStateMatcher\",\n"
          "  \"pageUrl\": {\"hostSuffix\": \"example.com\"},\n"
          "  \"css\": [\"input\"],\n"
          "}"),
      &error);
  EXPECT_EQ("", error);
  ASSERT_TRUE(result);

  URLMatcherConditionSet::Vector all_new_condition_sets;
  result->GetURLMatcherConditionSets(&all_new_condition_sets);
  matcher.AddConditionSets(all_new_condition_sets);
  EXPECT_FALSE(matcher.IsEmpty());

  RendererContentMatchData match_data;
  match_data.css_selectors.insert("input");

  EXPECT_THAT(matcher.MatchURL(GURL("http://google.com/")),
              ElementsAre(/*empty*/));
  match_data.page_url_matches = matcher.MatchURL(
      GURL("http://www.example.com/foobar"));
  EXPECT_THAT(match_data.page_url_matches,
              ElementsAre(result->url_matcher_condition_set_id()));

  EXPECT_TRUE(result->IsFulfilled(match_data));

  match_data.css_selectors.clear();
  match_data.css_selectors.insert("body");
  EXPECT_FALSE(result->IsFulfilled(match_data));
}

}  // namespace
}  // namespace extensions