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 "base/strings/utf_string_conversions.h"
6#include "chrome/common/extensions/features/feature_channel.h"
7#include "chrome/common/extensions/manifest_handlers/automation.h"
8#include "chrome/common/extensions/manifest_tests/chrome_manifest_test.h"
9#include "chrome/grit/generated_resources.h"
10#include "extensions/common/error_utils.h"
11#include "extensions/common/manifest_constants.h"
12#include "extensions/common/permissions/permissions_data.h"
13#include "testing/gtest/include/gtest/gtest.h"
14#include "ui/base/l10n/l10n_util.h"
15
16namespace extensions {
17
18class AutomationManifestTest : public ChromeManifestTest {
19 public:
20  AutomationManifestTest() : channel_(chrome::VersionInfo::CHANNEL_UNKNOWN) {}
21
22 protected:
23  AutomationInfo* GetAutomationInfo(scoped_refptr<Extension> extension) {
24    return static_cast<AutomationInfo*>(
25        extension->GetManifestData(manifest_keys::kAutomation));
26  }
27
28 private:
29  ScopedCurrentChannel channel_;
30};
31
32TEST_F(AutomationManifestTest, AsBooleanFalse) {
33  scoped_refptr<Extension> extension =
34      LoadAndExpectSuccess("automation_boolean_false.json");
35  ASSERT_TRUE(extension.get());
36
37  std::vector<base::string16> warnings =
38      extension->permissions_data()->GetPermissionMessageStrings();
39  EXPECT_EQ(0u, warnings.size());
40
41  const AutomationInfo* info = AutomationInfo::Get(extension.get());
42  ASSERT_FALSE(info);
43}
44
45TEST_F(AutomationManifestTest, AsBooleanTrue) {
46  scoped_refptr<Extension> extension =
47      LoadAndExpectSuccess("automation_boolean_true.json");
48  ASSERT_TRUE(extension.get());
49
50  std::vector<base::string16> warnings =
51      extension->permissions_data()->GetPermissionMessageStrings();
52  ASSERT_EQ(1u, warnings.size());
53  EXPECT_EQ("Read and change your data on www.google.com",
54            base::UTF16ToUTF8(warnings[0]));
55
56  const AutomationInfo* info = AutomationInfo::Get(extension.get());
57  ASSERT_TRUE(info);
58
59  EXPECT_FALSE(info->desktop);
60  EXPECT_FALSE(info->interact);
61  EXPECT_TRUE(info->matches.is_empty());
62}
63
64TEST_F(AutomationManifestTest, InteractTrue) {
65  scoped_refptr<Extension> extension =
66      LoadAndExpectSuccess("automation_interact_true.json");
67  ASSERT_TRUE(extension.get());
68
69  std::vector<base::string16> warnings =
70      extension->permissions_data()->GetPermissionMessageStrings();
71  ASSERT_EQ(1u, warnings.size());
72  EXPECT_EQ("Read and change your data on www.google.com",
73            base::UTF16ToUTF8(warnings[0]));
74
75  const AutomationInfo* info = AutomationInfo::Get(extension.get());
76  ASSERT_TRUE(info);
77
78  EXPECT_FALSE(info->desktop);
79  EXPECT_TRUE(info->interact);
80  EXPECT_TRUE(info->matches.is_empty());
81}
82
83TEST_F(AutomationManifestTest, Matches) {
84  scoped_refptr<Extension> extension = LoadAndExpectWarning(
85      "automation_matches.json",
86      ErrorUtils::FormatErrorMessage(
87          automation_errors::kErrorInvalidMatch,
88          "www.badpattern.com",
89          URLPattern::GetParseResultString(
90              URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR)));
91  ASSERT_TRUE(extension.get());
92
93  std::vector<base::string16> warnings =
94      extension->permissions_data()->GetPermissionMessageStrings();
95  ASSERT_EQ(1u, warnings.size());
96  EXPECT_EQ("Read and change your data on www.google.com and www.twitter.com",
97            base::UTF16ToUTF8(warnings[0]));
98
99  const AutomationInfo* info = AutomationInfo::Get(extension.get());
100  ASSERT_TRUE(info);
101
102  EXPECT_FALSE(info->desktop);
103  EXPECT_FALSE(info->interact);
104  EXPECT_FALSE(info->matches.is_empty());
105
106  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com/")));
107  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.google.com")));
108  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.twitter.com/")));
109  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.twitter.com")));
110
111  EXPECT_FALSE(info->matches.MatchesURL(GURL("http://www.bing.com/")));
112  EXPECT_FALSE(info->matches.MatchesURL(GURL("http://www.bing.com")));
113}
114
115TEST_F(AutomationManifestTest, MatchesAndPermissions) {
116  scoped_refptr<Extension> extension =
117      LoadAndExpectSuccess("automation_matches_and_permissions.json");
118  ASSERT_TRUE(extension.get());
119
120  std::vector<base::string16> warnings =
121      extension->permissions_data()->GetPermissionMessageStrings();
122  ASSERT_EQ(2u, warnings.size());
123  EXPECT_EQ("Read and change your data on www.google.com",
124            base::UTF16ToUTF8(warnings[0]));
125  EXPECT_EQ("Read and change your data on www.twitter.com",
126            base::UTF16ToUTF8(warnings[1]));
127
128  const AutomationInfo* info = AutomationInfo::Get(extension.get());
129  ASSERT_TRUE(info);
130
131  EXPECT_FALSE(info->desktop);
132  EXPECT_FALSE(info->interact);
133  EXPECT_FALSE(info->matches.is_empty());
134
135  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.twitter.com/")));
136  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://www.twitter.com")));
137}
138
139TEST_F(AutomationManifestTest, EmptyMatches) {
140  scoped_refptr<Extension> extension =
141      LoadAndExpectWarning("automation_empty_matches.json",
142                           automation_errors::kErrorNoMatchesProvided);
143  ASSERT_TRUE(extension.get());
144
145  std::vector<base::string16> warnings =
146      extension->permissions_data()->GetPermissionMessageStrings();
147  EXPECT_EQ(0u, warnings.size());
148
149  const AutomationInfo* info = AutomationInfo::Get(extension.get());
150  ASSERT_TRUE(info);
151
152  EXPECT_FALSE(info->desktop);
153  EXPECT_FALSE(info->interact);
154  EXPECT_TRUE(info->matches.is_empty());
155}
156
157TEST_F(AutomationManifestTest, NoValidMatches) {
158  std::string error;
159  scoped_refptr<Extension> extension =
160      LoadExtension(ManifestData("automation_no_valid_matches.json"), &error);
161  ASSERT_TRUE(extension.get());
162  EXPECT_EQ("", error);
163  EXPECT_EQ(2u, extension->install_warnings().size());
164  EXPECT_EQ(ErrorUtils::FormatErrorMessage(
165                automation_errors::kErrorInvalidMatch,
166                "www.badpattern.com",
167                URLPattern::GetParseResultString(
168                    URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR)),
169            extension->install_warnings()[0].message);
170  EXPECT_EQ(automation_errors::kErrorNoMatchesProvided,
171            extension->install_warnings()[1].message);
172
173  std::vector<base::string16> warnings =
174      extension->permissions_data()->GetPermissionMessageStrings();
175  ASSERT_EQ(0u, warnings.size());
176
177  const AutomationInfo* info = AutomationInfo::Get(extension.get());
178  ASSERT_TRUE(info);
179
180  EXPECT_FALSE(info->desktop);
181  EXPECT_FALSE(info->interact);
182  EXPECT_TRUE(info->matches.is_empty());
183}
184
185TEST_F(AutomationManifestTest, DesktopFalse) {
186  scoped_refptr<Extension> extension =
187      LoadAndExpectSuccess("automation_desktop_false.json");
188  ASSERT_TRUE(extension.get());
189
190  std::vector<base::string16> warnings =
191      extension->permissions_data()->GetPermissionMessageStrings();
192  ASSERT_EQ(1u, warnings.size());
193  EXPECT_EQ("Read and change your data on www.google.com",
194            base::UTF16ToUTF8(warnings[0]));
195
196  const AutomationInfo* info = AutomationInfo::Get(extension.get());
197  ASSERT_TRUE(info);
198
199  EXPECT_FALSE(info->desktop);
200  EXPECT_FALSE(info->interact);
201  EXPECT_TRUE(info->matches.is_empty());
202}
203
204TEST_F(AutomationManifestTest, DesktopTrue) {
205  scoped_refptr<Extension> extension =
206      LoadAndExpectSuccess("automation_desktop_true.json");
207  ASSERT_TRUE(extension.get());
208
209  std::vector<base::string16> warnings =
210      extension->permissions_data()->GetPermissionMessageStrings();
211  ASSERT_EQ(1u, warnings.size());
212  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS),
213            warnings[0]);
214
215  const AutomationInfo* info = AutomationInfo::Get(extension.get());
216  ASSERT_TRUE(info);
217
218  EXPECT_TRUE(info->desktop);
219  EXPECT_TRUE(info->interact);
220  EXPECT_TRUE(info->matches.is_empty());
221}
222
223TEST_F(AutomationManifestTest, Desktop_InteractTrue) {
224  scoped_refptr<Extension> extension =
225      LoadAndExpectSuccess("automation_desktop_interact_true.json");
226  ASSERT_TRUE(extension.get());
227  std::vector<base::string16> warnings =
228      extension->permissions_data()->GetPermissionMessageStrings();
229  ASSERT_EQ(1u, warnings.size());
230  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS),
231            warnings[0]);
232
233  const AutomationInfo* info = AutomationInfo::Get(extension.get());
234  ASSERT_TRUE(info);
235
236  EXPECT_TRUE(info->desktop);
237  EXPECT_TRUE(info->interact);
238  EXPECT_TRUE(info->matches.is_empty());
239}
240
241TEST_F(AutomationManifestTest, Desktop_InteractFalse) {
242  scoped_refptr<Extension> extension =
243      LoadAndExpectWarning("automation_desktop_interact_false.json",
244                           automation_errors::kErrorDesktopTrueInteractFalse);
245  ASSERT_TRUE(extension.get());
246
247  std::vector<base::string16> warnings =
248      extension->permissions_data()->GetPermissionMessageStrings();
249  ASSERT_EQ(1u, warnings.size());
250  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS),
251            warnings[0]);
252
253  const AutomationInfo* info = AutomationInfo::Get(extension.get());
254  ASSERT_TRUE(info);
255
256  EXPECT_TRUE(info->desktop);
257  EXPECT_TRUE(info->interact);
258  EXPECT_TRUE(info->matches.is_empty());
259}
260
261TEST_F(AutomationManifestTest, Desktop_MatchesSpecified) {
262  scoped_refptr<Extension> extension = LoadAndExpectWarning(
263      "automation_desktop_matches_specified.json",
264      automation_errors::kErrorDesktopTrueMatchesSpecified);
265  ASSERT_TRUE(extension.get());
266
267  std::vector<base::string16> warnings =
268      extension->permissions_data()->GetPermissionMessageStrings();
269  ASSERT_EQ(1u, warnings.size());
270  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS),
271            warnings[0]);
272
273  const AutomationInfo* info = AutomationInfo::Get(extension.get());
274  ASSERT_TRUE(info);
275
276  EXPECT_TRUE(info->desktop);
277  EXPECT_TRUE(info->interact);
278  EXPECT_TRUE(info->matches.is_empty());
279}
280
281}  // namespace extensions
282