Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(377)

Side by Side Diff: chrome/browser/managed_mode/managed_user_service_unittest.cc

Issue 23868042: Mark supervised profiles as such immediately when they're created. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: . Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/path_service.h" 5 #include "base/path_service.h"
6 #include "base/prefs/pref_service.h" 6 #include "base/prefs/pref_service.h"
7 #include "base/strings/utf_string_conversions.h" 7 #include "base/strings/utf_string_conversions.h"
8 #include "chrome/browser/chrome_notification_types.h" 8 #include "chrome/browser/chrome_notification_types.h"
9 #include "chrome/browser/extensions/extension_service_unittest.h" 9 #include "chrome/browser/extensions/extension_service_unittest.h"
10 #include "chrome/browser/extensions/unpacked_installer.h" 10 #include "chrome/browser/extensions/unpacked_installer.h"
11 #include "chrome/browser/managed_mode/managed_user_service.h" 11 #include "chrome/browser/managed_mode/managed_user_service.h"
12 #include "chrome/browser/managed_mode/managed_user_service_factory.h" 12 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
13 #include "chrome/browser/prefs/scoped_user_pref_update.h" 13 #include "chrome/browser/prefs/scoped_user_pref_update.h"
14 #include "chrome/browser/profiles/profile.h" 14 #include "chrome/browser/profiles/profile.h"
15 #include "chrome/browser/ui/browser_list.h" 15 #include "chrome/browser/ui/browser_list.h"
16 #include "chrome/common/chrome_paths.h" 16 #include "chrome/common/chrome_paths.h"
17 #include "chrome/common/extensions/extension.h" 17 #include "chrome/common/extensions/extension.h"
18 #include "chrome/common/extensions/extension_builder.h" 18 #include "chrome/common/extensions/extension_builder.h"
19 #include "chrome/common/pref_names.h" 19 #include "chrome/common/pref_names.h"
20 #include "chrome/test/base/testing_profile.h" 20 #include "chrome/test/base/testing_profile.h"
21 #include "content/public/test/test_browser_thread.h" 21 #include "content/public/test/test_browser_thread_bundle.h"
22 #include "content/public/test/test_utils.h" 22 #include "content/public/test/test_utils.h"
23 #include "extensions/common/manifest_constants.h" 23 #include "extensions/common/manifest_constants.h"
24 #include "testing/gtest/include/gtest/gtest.h" 24 #include "testing/gtest/include/gtest/gtest.h"
25 25
26 using content::MessageLoopRunner; 26 using content::MessageLoopRunner;
27 27
28 namespace { 28 namespace {
29 29
30 class ManagedModeURLFilterObserver : public ManagedModeURLFilter::Observer { 30 class ManagedModeURLFilterObserver : public ManagedModeURLFilter::Observer {
31 public: 31 public:
(...skipping 21 matching lines...) Expand all
53 void Reset() { 53 void Reset() {
54 message_loop_runner_ = new MessageLoopRunner; 54 message_loop_runner_ = new MessageLoopRunner;
55 } 55 }
56 56
57 ManagedModeURLFilter* url_filter_; 57 ManagedModeURLFilter* url_filter_;
58 scoped_refptr<MessageLoopRunner> message_loop_runner_; 58 scoped_refptr<MessageLoopRunner> message_loop_runner_;
59 }; 59 };
60 60
61 class ManagedUserServiceTest : public ::testing::Test { 61 class ManagedUserServiceTest : public ::testing::Test {
62 public: 62 public:
63 ManagedUserServiceTest() : ui_thread_(content::BrowserThread::UI, 63 ManagedUserServiceTest() {
64 &message_loop_) {
65 managed_user_service_ = ManagedUserServiceFactory::GetForProfile(&profile_); 64 managed_user_service_ = ManagedUserServiceFactory::GetForProfile(&profile_);
66 } 65 }
67 66
68 virtual ~ManagedUserServiceTest() {} 67 virtual ~ManagedUserServiceTest() {}
69 68
70 protected: 69 protected:
71 base::MessageLoop message_loop_; 70 content::TestBrowserThreadBundle thread_bundle_;
72 content::TestBrowserThread ui_thread_;
73 TestingProfile profile_; 71 TestingProfile profile_;
74 ManagedUserService* managed_user_service_; 72 ManagedUserService* managed_user_service_;
75 }; 73 };
76 74
77 } // namespace 75 } // namespace
78 76
79 TEST_F(ManagedUserServiceTest, GetManualExceptionsForHost) { 77 TEST_F(ManagedUserServiceTest, GetManualExceptionsForHost) {
80 GURL kExampleFooURL("http://www.example.com/foo"); 78 GURL kExampleFooURL("http://www.example.com/foo");
81 GURL kExampleBarURL("http://www.example.com/bar"); 79 GURL kExampleBarURL("http://www.example.com/bar");
82 GURL kExampleFooNoWWWURL("http://example.com/foo"); 80 GURL kExampleFooNoWWWURL("http://example.com/foo");
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
126 managed_user_service_->GetManualBehaviorForURL(kExampleBarURL)); 124 managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
127 EXPECT_EQ(ManagedUserService::MANUAL_ALLOW, 125 EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
128 managed_user_service_->GetManualBehaviorForURL( 126 managed_user_service_->GetManualBehaviorForURL(
129 kExampleFooNoWWWURL)); 127 kExampleFooNoWWWURL));
130 EXPECT_EQ(ManagedUserService::MANUAL_ALLOW, 128 EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
131 managed_user_service_->GetManualBehaviorForURL(kBlurpURL)); 129 managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
132 EXPECT_EQ(ManagedUserService::MANUAL_NONE, 130 EXPECT_EQ(ManagedUserService::MANUAL_NONE,
133 managed_user_service_->GetManualBehaviorForURL(kMooseURL)); 131 managed_user_service_->GetManualBehaviorForURL(kMooseURL));
134 } 132 }
135 133
136 class ManagedUserServiceExtensionTest : public ExtensionServiceTestBase { 134 class ManagedUserServiceExtensionTestBase : public ExtensionServiceTestBase {
137 public: 135 public:
138 ManagedUserServiceExtensionTest() {} 136 explicit ManagedUserServiceExtensionTestBase(bool is_managed)
139 virtual ~ManagedUserServiceExtensionTest() {} 137 : is_managed_(is_managed) {}
138 virtual ~ManagedUserServiceExtensionTestBase() {}
140 139
141 virtual void SetUp() OVERRIDE { 140 virtual void SetUp() OVERRIDE {
142 ExtensionServiceTestBase::SetUp(); 141 ExtensionServiceTestBase::SetUp();
143 InitializeEmptyExtensionService(); 142 ExtensionServiceTestBase::ExtensionServiceInitParams params;
144 } 143 params.profile_is_managed = is_managed_;
145 144 InitializeExtensionServiceParams(&params);
146 virtual void TearDown() OVERRIDE { 145 InitializeExtensionService(params);
147 ExtensionServiceTestBase::TearDown(); 146 ManagedUserServiceFactory::GetForProfile(profile_.get())->Init();
148 } 147 }
149 148
150 protected: 149 protected:
151 ScopedVector<ManagedModeSiteList> GetActiveSiteLists( 150 ScopedVector<ManagedModeSiteList> GetActiveSiteLists(
152 ManagedUserService* managed_user_service) { 151 ManagedUserService* managed_user_service) {
153 return managed_user_service->GetActiveSiteLists(); 152 return managed_user_service->GetActiveSiteLists();
154 } 153 }
155 154
156 scoped_refptr<extensions::Extension> MakeThemeExtension() { 155 scoped_refptr<extensions::Extension> MakeThemeExtension() {
157 scoped_ptr<DictionaryValue> source(new DictionaryValue()); 156 scoped_ptr<DictionaryValue> source(new DictionaryValue());
158 source->SetString(extensions::manifest_keys::kName, "Theme"); 157 source->SetString(extensions::manifest_keys::kName, "Theme");
159 source->Set(extensions::manifest_keys::kTheme, new DictionaryValue()); 158 source->Set(extensions::manifest_keys::kTheme, new DictionaryValue());
160 source->SetString(extensions::manifest_keys::kVersion, "1.0"); 159 source->SetString(extensions::manifest_keys::kVersion, "1.0");
161 extensions::ExtensionBuilder builder; 160 extensions::ExtensionBuilder builder;
162 scoped_refptr<extensions::Extension> extension = 161 scoped_refptr<extensions::Extension> extension =
163 builder.SetManifest(source.Pass()).Build(); 162 builder.SetManifest(source.Pass()).Build();
164 return extension; 163 return extension;
165 } 164 }
166 165
167 scoped_refptr<extensions::Extension> MakeExtension() { 166 scoped_refptr<extensions::Extension> MakeExtension() {
168 scoped_ptr<DictionaryValue> manifest = extensions::DictionaryBuilder() 167 scoped_ptr<DictionaryValue> manifest = extensions::DictionaryBuilder()
169 .Set(extensions::manifest_keys::kName, "Extension") 168 .Set(extensions::manifest_keys::kName, "Extension")
170 .Set(extensions::manifest_keys::kVersion, "1.0") 169 .Set(extensions::manifest_keys::kVersion, "1.0")
171 .Build(); 170 .Build();
172 extensions::ExtensionBuilder builder; 171 extensions::ExtensionBuilder builder;
173 scoped_refptr<extensions::Extension> extension = 172 scoped_refptr<extensions::Extension> extension =
174 builder.SetManifest(manifest.Pass()).Build(); 173 builder.SetManifest(manifest.Pass()).Build();
175 return extension; 174 return extension;
176 } 175 }
176
177 bool is_managed_;
177 }; 178 };
178 179
179 TEST_F(ManagedUserServiceExtensionTest, 180 class ManagedUserServiceExtensionTestUnmanaged
180 ExtensionManagementPolicyProviderUnmanaged) { 181 : public ManagedUserServiceExtensionTestBase {
182 public:
183 ManagedUserServiceExtensionTestUnmanaged()
184 : ManagedUserServiceExtensionTestBase(false) {}
185 };
186
187 class ManagedUserServiceExtensionTest
188 : public ManagedUserServiceExtensionTestBase {
189 public:
190 ManagedUserServiceExtensionTest()
191 : ManagedUserServiceExtensionTestBase(true) {}
192 };
193
194 TEST_F(ManagedUserServiceExtensionTestUnmanaged,
195 ExtensionManagementPolicyProvider) {
181 ManagedUserService* managed_user_service = 196 ManagedUserService* managed_user_service =
182 ManagedUserServiceFactory::GetForProfile(profile_.get()); 197 ManagedUserServiceFactory::GetForProfile(profile_.get());
183 EXPECT_FALSE(profile_->IsManaged()); 198 EXPECT_FALSE(profile_->IsManaged());
184 199
185 scoped_refptr<extensions::Extension> extension = MakeExtension(); 200 scoped_refptr<extensions::Extension> extension = MakeExtension();
186 string16 error_1; 201 string16 error_1;
187 EXPECT_TRUE(managed_user_service->UserMayLoad(extension.get(), &error_1)); 202 EXPECT_TRUE(managed_user_service->UserMayLoad(extension.get(), &error_1));
188 EXPECT_EQ(string16(), error_1); 203 EXPECT_EQ(string16(), error_1);
189 204
190 string16 error_2; 205 string16 error_2;
191 EXPECT_TRUE( 206 EXPECT_TRUE(
192 managed_user_service->UserMayModifySettings(extension.get(), &error_2)); 207 managed_user_service->UserMayModifySettings(extension.get(), &error_2));
193 EXPECT_EQ(string16(), error_2); 208 EXPECT_EQ(string16(), error_2);
194 } 209 }
195 210
196 TEST_F(ManagedUserServiceExtensionTest, 211 TEST_F(ManagedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
197 ExtensionManagementPolicyProviderManaged) {
198 ManagedUserService* managed_user_service = 212 ManagedUserService* managed_user_service =
199 ManagedUserServiceFactory::GetForProfile(profile_.get()); 213 ManagedUserServiceFactory::GetForProfile(profile_.get());
200 managed_user_service->InitForTesting();
201 ManagedModeURLFilterObserver observer( 214 ManagedModeURLFilterObserver observer(
202 managed_user_service->GetURLFilterForUIThread()); 215 managed_user_service->GetURLFilterForUIThread());
203 EXPECT_TRUE(profile_->IsManaged()); 216 EXPECT_TRUE(profile_->IsManaged());
204 // Wait for the initial update to finish (otherwise we'll get leaks). 217 // Wait for the initial update to finish (otherwise we'll get leaks).
205 observer.Wait(); 218 observer.Wait();
206 219
207 // Check that a supervised user can install a theme. 220 // Check that a supervised user can install a theme.
208 scoped_refptr<extensions::Extension> theme = MakeThemeExtension(); 221 scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
209 string16 error_1; 222 string16 error_1;
210 EXPECT_TRUE(managed_user_service->UserMayLoad(theme.get(), &error_1)); 223 EXPECT_TRUE(managed_user_service->UserMayLoad(theme.get(), &error_1));
(...skipping 10 matching lines...) Expand all
221 string16 error_2; 234 string16 error_2;
222 EXPECT_FALSE( 235 EXPECT_FALSE(
223 managed_user_service->UserMayModifySettings(extension.get(), &error_2)); 236 managed_user_service->UserMayModifySettings(extension.get(), &error_2));
224 EXPECT_FALSE(error_2.empty()); 237 EXPECT_FALSE(error_2.empty());
225 238
226 #ifndef NDEBUG 239 #ifndef NDEBUG
227 EXPECT_FALSE(managed_user_service->GetDebugPolicyProviderName().empty()); 240 EXPECT_FALSE(managed_user_service->GetDebugPolicyProviderName().empty());
228 #endif 241 #endif
229 } 242 }
230 243
231
232 TEST_F(ManagedUserServiceExtensionTest, NoContentPacks) { 244 TEST_F(ManagedUserServiceExtensionTest, NoContentPacks) {
233 ManagedUserService* managed_user_service = 245 ManagedUserService* managed_user_service =
234 ManagedUserServiceFactory::GetForProfile(profile_.get()); 246 ManagedUserServiceFactory::GetForProfile(profile_.get());
235 managed_user_service->Init();
236 ManagedModeURLFilter* url_filter = 247 ManagedModeURLFilter* url_filter =
237 managed_user_service->GetURLFilterForUIThread(); 248 managed_user_service->GetURLFilterForUIThread();
238 249
239 GURL url("http://youtube.com"); 250 GURL url("http://youtube.com");
240 ScopedVector<ManagedModeSiteList> site_lists = 251 ScopedVector<ManagedModeSiteList> site_lists =
241 GetActiveSiteLists(managed_user_service); 252 GetActiveSiteLists(managed_user_service);
242 ASSERT_EQ(0u, site_lists.size()); 253 ASSERT_EQ(0u, site_lists.size());
243 EXPECT_EQ(ManagedModeURLFilter::ALLOW, 254 EXPECT_EQ(ManagedModeURLFilter::ALLOW,
244 url_filter->GetFilteringBehaviorForURL(url)); 255 url_filter->GetFilteringBehaviorForURL(url));
245 } 256 }
246 257
247 TEST_F(ManagedUserServiceExtensionTest, InstallContentPacks) { 258 TEST_F(ManagedUserServiceExtensionTest, InstallContentPacks) {
248 ManagedUserService* managed_user_service = 259 ManagedUserService* managed_user_service =
249 ManagedUserServiceFactory::GetForProfile(profile_.get()); 260 ManagedUserServiceFactory::GetForProfile(profile_.get());
250 managed_user_service->InitForTesting();
251 ManagedModeURLFilter* url_filter = 261 ManagedModeURLFilter* url_filter =
252 managed_user_service->GetURLFilterForUIThread(); 262 managed_user_service->GetURLFilterForUIThread();
253 ManagedModeURLFilterObserver observer(url_filter); 263 ManagedModeURLFilterObserver observer(url_filter);
254 observer.Wait(); 264 observer.Wait();
255 265
256 GURL example_url("http://example.com"); 266 GURL example_url("http://example.com");
257 GURL moose_url("http://moose.org"); 267 GURL moose_url("http://moose.org");
258 EXPECT_EQ(ManagedModeURLFilter::ALLOW, 268 EXPECT_EQ(ManagedModeURLFilter::ALLOW,
259 url_filter->GetFilteringBehaviorForURL(example_url)); 269 url_filter->GetFilteringBehaviorForURL(example_url));
260 270
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
344 sites.clear(); 354 sites.clear();
345 site_lists[0]->GetSites(&sites); 355 site_lists[0]->GetSites(&sites);
346 ASSERT_EQ(1u, sites.size()); 356 ASSERT_EQ(1u, sites.size());
347 EXPECT_EQ(ASCIIToUTF16("Moose"), sites[0].name); 357 EXPECT_EQ(ASCIIToUTF16("Moose"), sites[0].name);
348 358
349 EXPECT_EQ(ManagedModeURLFilter::WARN, 359 EXPECT_EQ(ManagedModeURLFilter::WARN,
350 url_filter->GetFilteringBehaviorForURL(example_url)); 360 url_filter->GetFilteringBehaviorForURL(example_url));
351 EXPECT_EQ(ManagedModeURLFilter::ALLOW, 361 EXPECT_EQ(ManagedModeURLFilter::ALLOW,
352 url_filter->GetFilteringBehaviorForURL(moose_url)); 362 url_filter->GetFilteringBehaviorForURL(moose_url));
353 } 363 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698