1// Copyright 2013 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/common/extensions/manifest_handlers/settings_overrides_handler.h"
6
7#include "base/json/json_string_value_serializer.h"
8#include "base/strings/utf_string_conversions.h"
9#include "chrome/common/extensions/manifest_url_handler.h"
10#include "extensions/common/error_utils.h"
11#include "extensions/common/extension.h"
12#include "extensions/common/manifest_constants.h"
13#include "testing/gtest/include/gtest/gtest.h"
14
15namespace {
16
17const char kManifest[] = "{"
18    " \"version\" : \"1.0.0.0\","
19    " \"name\" : \"Test\","
20    " \"chrome_settings_overrides\" : {"
21    "   \"homepage\" : \"http://www.homepage.com\","
22    "   \"search_provider\" : {"
23    "        \"name\" : \"first\","
24    "        \"keyword\" : \"firstkey\","
25    "        \"search_url\" : \"http://www.foo.com/s?q={searchTerms}\","
26    "        \"favicon_url\" : \"http://www.foo.com/favicon.ico\","
27    "        \"suggest_url\" : \"http://www.foo.com/s?q={searchTerms}\","
28    "        \"encoding\" : \"UTF-8\","
29    "        \"is_default\" : true"
30    "    },"
31    "   \"startup_pages\" : [\"http://www.startup.com\"]"
32    "  }"
33    "}";
34
35const char kPrepopulatedManifest[] =
36    "{"
37    " \"version\" : \"1.0.0.0\","
38    " \"name\" : \"Test\","
39    " \"chrome_settings_overrides\" : {"
40    "   \"search_provider\" : {"
41    "        \"search_url\" : \"http://www.foo.com/s?q={searchTerms}\","
42    "        \"prepopulated_id\" : 3,"
43    "        \"is_default\" : true"
44    "    }"
45    "  }"
46    "}";
47
48const char kBrokenManifest[] = "{"
49    " \"version\" : \"1.0.0.0\","
50    " \"name\" : \"Test\","
51    " \"chrome_settings_overrides\" : {"
52    "   \"homepage\" : \"{invalid}\","
53    "   \"search_provider\" : {"
54    "        \"name\" : \"first\","
55    "        \"keyword\" : \"firstkey\","
56    "        \"search_url\" : \"{invalid}/s?q={searchTerms}\","
57    "        \"favicon_url\" : \"{invalid}/favicon.ico\","
58    "        \"encoding\" : \"UTF-8\","
59    "        \"is_default\" : true"
60    "    },"
61    "   \"startup_pages\" : [\"{invalid}\"]"
62    "  }"
63    "}";
64
65using extensions::api::manifest_types::ChromeSettingsOverrides;
66using extensions::Extension;
67using extensions::Manifest;
68using extensions::SettingsOverrides;
69namespace manifest_keys = extensions::manifest_keys;
70
71class OverrideSettingsTest : public testing::Test {
72};
73
74
75TEST_F(OverrideSettingsTest, ParseManifest) {
76  std::string manifest(kManifest);
77  JSONStringValueSerializer json(&manifest);
78  std::string error;
79  scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
80  ASSERT_TRUE(root);
81  ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
82  scoped_refptr<Extension> extension = Extension::Create(
83      base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
84      Manifest::INVALID_LOCATION,
85      *static_cast<base::DictionaryValue*>(root.get()),
86      Extension::NO_FLAGS,
87      &error);
88  ASSERT_TRUE(extension.get());
89#if defined(OS_WIN)
90  ASSERT_TRUE(extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
91
92  SettingsOverrides* settings_override = static_cast<SettingsOverrides*>(
93      extension->GetManifestData(manifest_keys::kSettingsOverride));
94  ASSERT_TRUE(settings_override);
95  ASSERT_TRUE(settings_override->search_engine);
96  EXPECT_TRUE(settings_override->search_engine->is_default);
97  const ChromeSettingsOverrides::Search_provider* search_engine =
98      settings_override->search_engine.get();
99  EXPECT_EQ("first", *search_engine->name);
100  EXPECT_EQ("firstkey", *search_engine->keyword);
101  EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", search_engine->search_url);
102  EXPECT_EQ("http://www.foo.com/favicon.ico", *search_engine->favicon_url);
103  EXPECT_EQ("http://www.foo.com/s?q={searchTerms}",
104            *search_engine->suggest_url);
105  EXPECT_EQ("UTF-8", *search_engine->encoding);
106
107  EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.com")),
108            settings_override->startup_pages);
109
110  ASSERT_TRUE(settings_override->homepage);
111  EXPECT_EQ(GURL("http://www.homepage.com"), *settings_override->homepage);
112#else
113  EXPECT_FALSE(
114      extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
115#endif
116}
117
118TEST_F(OverrideSettingsTest, ParsePrepopulatedId) {
119  std::string manifest(kPrepopulatedManifest);
120  JSONStringValueSerializer json(&manifest);
121  std::string error;
122  scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
123  ASSERT_TRUE(root);
124  ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
125  scoped_refptr<Extension> extension =
126      Extension::Create(base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
127                        Manifest::INVALID_LOCATION,
128                        *static_cast<base::DictionaryValue*>(root.get()),
129                        Extension::NO_FLAGS,
130                        &error);
131  ASSERT_TRUE(extension.get());
132#if defined(OS_WIN)
133  ASSERT_TRUE(extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
134
135  SettingsOverrides* settings_override = static_cast<SettingsOverrides*>(
136      extension->GetManifestData(manifest_keys::kSettingsOverride));
137  ASSERT_TRUE(settings_override);
138  ASSERT_TRUE(settings_override->search_engine);
139  EXPECT_TRUE(settings_override->search_engine->is_default);
140  const ChromeSettingsOverrides::Search_provider* search_engine =
141      settings_override->search_engine.get();
142  ASSERT_TRUE(search_engine->prepopulated_id);
143  EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", search_engine->search_url);
144  EXPECT_EQ(3, *search_engine->prepopulated_id);
145#else
146  EXPECT_FALSE(
147      extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
148#endif
149}
150
151TEST_F(OverrideSettingsTest, ParseBrokenManifest) {
152  std::string manifest(kBrokenManifest);
153  JSONStringValueSerializer json(&manifest);
154  std::string error;
155  scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
156  ASSERT_TRUE(root);
157  ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
158  scoped_refptr<Extension> extension = Extension::Create(
159      base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
160      Manifest::INVALID_LOCATION,
161      *static_cast<base::DictionaryValue*>(root.get()),
162      Extension::NO_FLAGS,
163      &error);
164#if defined(OS_WIN)
165  EXPECT_FALSE(extension);
166  EXPECT_EQ(
167      extensions::ErrorUtils::FormatErrorMessage(
168          extensions::manifest_errors::kInvalidEmptyDictionary,
169          extensions::manifest_keys::kSettingsOverride),
170      error);
171#else
172  EXPECT_TRUE(extension.get());
173  EXPECT_FALSE(
174      extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
175#endif
176}
177
178}  // namespace
179