chrome/browser/managed_mode/managed_user_service_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "base/path_service.h"
   6 #include "base/prefs/pref_service.h"
   7 #include "base/prefs/scoped_user_pref_update.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/extensions/extension_service_unittest.h"
  11 #include "chrome/browser/extensions/unpacked_installer.h"
  12 #include "chrome/browser/managed_mode/custodian_profile_downloader_service.h"
  13 #include "chrome/browser/managed_mode/custodian_profile_downloader_service_factory.h"
  14 #include "chrome/browser/managed_mode/managed_user_service.h"
  15 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
  18 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  19 #include "chrome/browser/ui/browser_list.h"
  20 #include "chrome/common/chrome_paths.h"
  21 #include "chrome/common/extensions/features/feature_channel.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "chrome/test/base/testing_profile.h"
  24 #include "content/public/test/test_browser_thread_bundle.h"
  25 #include "content/public/test/test_utils.h"
  26 #include "extensions/common/extension.h"
  27 #include "extensions/common/extension_builder.h"
  28 #include "extensions/common/manifest_constants.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30
  31 using content::MessageLoopRunner;
  32
  33 namespace {
  34
  35 void OnProfileDownloadedFail(const base::string16& full_name) {
  36   ASSERT_TRUE(false) << "Profile download should not have succeeded.";
  37 }
  38
  39 class ManagedModeURLFilterObserver : public ManagedModeURLFilter::Observer {
  40  public:
  41   explicit ManagedModeURLFilterObserver(ManagedModeURLFilter* url_filter)
  42       : url_filter_(url_filter) {
  43     Reset();
  44     url_filter_->AddObserver(this);
  45   }
  46
  47   ~ManagedModeURLFilterObserver() {
  48     url_filter_->RemoveObserver(this);
  49   }
  50
  51   void Wait() {
  52     message_loop_runner_->Run();
  53     Reset();
  54   }
  55
  56   // ManagedModeURLFilter::Observer
  57   virtual void OnSiteListUpdated() OVERRIDE {
  58     message_loop_runner_->Quit();
  59   }
  60
  61  private:
  62   void Reset() {
  63     message_loop_runner_ = new MessageLoopRunner;
  64   }
  65
  66   ManagedModeURLFilter* url_filter_;
  67   scoped_refptr<MessageLoopRunner> message_loop_runner_;
  68 };
  69
  70 class ManagedUserServiceTest : public ::testing::Test {
  71  public:
  72   ManagedUserServiceTest() {}
  73
  74   virtual void SetUp() OVERRIDE {
  75     TestingProfile::Builder builder;
  76     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
  77                               FakeProfileOAuth2TokenService::Build);
  78     profile_ = builder.Build();
  79     managed_user_service_ =
  80         ManagedUserServiceFactory::GetForProfile(profile_.get());
  81   }
  82
  83   virtual void TearDown() OVERRIDE {
  84     profile_.reset();
  85   }
  86
  87   virtual ~ManagedUserServiceTest() {}
  88
  89  protected:
  90   content::TestBrowserThreadBundle thread_bundle_;
  91   scoped_ptr<TestingProfile> profile_;
  92   ManagedUserService* managed_user_service_;
  93 };
  94
  95 }  // namespace
  96
  97 TEST_F(ManagedUserServiceTest, GetManualExceptionsForHost) {
  98   GURL kExampleFooURL("http://www.example.com/foo");
  99   GURL kExampleBarURL("http://www.example.com/bar");
 100   GURL kExampleFooNoWWWURL("http://example.com/foo");
 101   GURL kBlurpURL("http://blurp.net/bla");
 102   GURL kMooseURL("http://moose.org/baz");
 103   {
 104     DictionaryPrefUpdate update(profile_->GetPrefs(),
 105                                 prefs::kManagedModeManualURLs);
 106     base::DictionaryValue* dict = update.Get();
 107     dict->SetBooleanWithoutPathExpansion(kExampleFooURL.spec(), true);
 108     dict->SetBooleanWithoutPathExpansion(kExampleBarURL.spec(), false);
 109     dict->SetBooleanWithoutPathExpansion(kExampleFooNoWWWURL.spec(), true);
 110     dict->SetBooleanWithoutPathExpansion(kBlurpURL.spec(), true);
 111   }
 112
 113   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
 114             managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
 115   EXPECT_EQ(ManagedUserService::MANUAL_BLOCK,
 116             managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
 117   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
 118             managed_user_service_->GetManualBehaviorForURL(
 119                 kExampleFooNoWWWURL));
 120   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
 121             managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
 122   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
 123             managed_user_service_->GetManualBehaviorForURL(kMooseURL));
 124   std::vector<GURL> exceptions;
 125   managed_user_service_->GetManualExceptionsForHost("www.example.com",
 126                                                     &exceptions);
 127   ASSERT_EQ(2u, exceptions.size());
 128   EXPECT_EQ(kExampleBarURL, exceptions[0]);
 129   EXPECT_EQ(kExampleFooURL, exceptions[1]);
 130
 131   {
 132     DictionaryPrefUpdate update(profile_->GetPrefs(),
 133                                 prefs::kManagedModeManualURLs);
 134     base::DictionaryValue* dict = update.Get();
 135     for (std::vector<GURL>::iterator it = exceptions.begin();
 136          it != exceptions.end(); ++it) {
 137       dict->RemoveWithoutPathExpansion(it->spec(), NULL);
 138     }
 139   }
 140
 141   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
 142             managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
 143   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
 144             managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
 145   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
 146             managed_user_service_->GetManualBehaviorForURL(
 147                 kExampleFooNoWWWURL));
 148   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
 149             managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
 150   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
 151             managed_user_service_->GetManualBehaviorForURL(kMooseURL));
 152 }
 153
 154 // Ensure that the CustodianProfileDownloaderService shuts down cleanly. If no
 155 // DCHECK is hit when the service is destroyed, this test passed.
 156 TEST_F(ManagedUserServiceTest, ShutDownCustodianProfileDownloader) {
 157   CustodianProfileDownloaderService* downloader_service =
 158       CustodianProfileDownloaderServiceFactory::GetForProfile(profile_.get());
 159
 160   // Emulate being logged in, then start to download a profile so a
 161   // ProfileDownloader gets created.
 162   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, "Logged In");
 163   downloader_service->DownloadProfile(base::Bind(&OnProfileDownloadedFail));
 164 }
 165
 166 #if !defined(OS_ANDROID)
 167 class ManagedUserServiceExtensionTestBase : public ExtensionServiceTestBase {
 168  public:
 169   explicit ManagedUserServiceExtensionTestBase(bool is_managed)
 170       : is_managed_(is_managed),
 171         channel_(chrome::VersionInfo::CHANNEL_DEV) {}
 172   virtual ~ManagedUserServiceExtensionTestBase() {}
 173
 174   virtual void SetUp() OVERRIDE {
 175     ExtensionServiceTestBase::SetUp();
 176     ExtensionServiceTestBase::ExtensionServiceInitParams params =
 177         CreateDefaultInitParams();
 178     params.profile_is_managed = is_managed_;
 179     InitializeExtensionService(params);
 180     ManagedUserServiceFactory::GetForProfile(profile_.get())->Init();
 181   }
 182
 183  protected:
 184   ScopedVector<ManagedModeSiteList> GetActiveSiteLists(
 185       ManagedUserService* managed_user_service) {
 186     return managed_user_service->GetActiveSiteLists();
 187   }
 188
 189   scoped_refptr<extensions::Extension> MakeThemeExtension() {
 190     scoped_ptr<base::DictionaryValue> source(new base::DictionaryValue());
 191     source->SetString(extensions::manifest_keys::kName, "Theme");
 192     source->Set(extensions::manifest_keys::kTheme, new base::DictionaryValue());
 193     source->SetString(extensions::manifest_keys::kVersion, "1.0");
 194     extensions::ExtensionBuilder builder;
 195     scoped_refptr<extensions::Extension> extension =
 196         builder.SetManifest(source.Pass()).Build();
 197     return extension;
 198   }
 199
 200   scoped_refptr<extensions::Extension> MakeExtension() {
 201     scoped_ptr<base::DictionaryValue> manifest = extensions::DictionaryBuilder()
 202       .Set(extensions::manifest_keys::kName, "Extension")
 203       .Set(extensions::manifest_keys::kVersion, "1.0")
 204       .Build();
 205     extensions::ExtensionBuilder builder;
 206     scoped_refptr<extensions::Extension> extension =
 207         builder.SetManifest(manifest.Pass()).Build();
 208     return extension;
 209   }
 210
 211   bool is_managed_;
 212   extensions::ScopedCurrentChannel channel_;
 213 };
 214
 215 class ManagedUserServiceExtensionTestUnmanaged
 216     : public ManagedUserServiceExtensionTestBase {
 217  public:
 218   ManagedUserServiceExtensionTestUnmanaged()
 219       : ManagedUserServiceExtensionTestBase(false) {}
 220 };
 221
 222 class ManagedUserServiceExtensionTest
 223     : public ManagedUserServiceExtensionTestBase {
 224  public:
 225   ManagedUserServiceExtensionTest()
 226       : ManagedUserServiceExtensionTestBase(true) {}
 227 };
 228
 229 TEST_F(ManagedUserServiceExtensionTestUnmanaged,
 230        ExtensionManagementPolicyProvider) {
 231   ManagedUserService* managed_user_service =
 232       ManagedUserServiceFactory::GetForProfile(profile_.get());
 233   EXPECT_FALSE(profile_->IsManaged());
 234
 235   scoped_refptr<extensions::Extension> extension = MakeExtension();
 236   base::string16 error_1;
 237   EXPECT_TRUE(managed_user_service->UserMayLoad(extension.get(), &error_1));
 238   EXPECT_EQ(base::string16(), error_1);
 239
 240   base::string16 error_2;
 241   EXPECT_TRUE(
 242       managed_user_service->UserMayModifySettings(extension.get(), &error_2));
 243   EXPECT_EQ(base::string16(), error_2);
 244 }
 245
 246 TEST_F(ManagedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
 247   ManagedUserService* managed_user_service =
 248       ManagedUserServiceFactory::GetForProfile(profile_.get());
 249   ManagedModeURLFilterObserver observer(
 250       managed_user_service->GetURLFilterForUIThread());
 251   ASSERT_TRUE(profile_->IsManaged());
 252   // Wait for the initial update to finish (otherwise we'll get leaks).
 253   observer.Wait();
 254
 255   // Check that a supervised user can install a theme.
 256   scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
 257   base::string16 error_1;
 258   EXPECT_TRUE(managed_user_service->UserMayLoad(theme.get(), &error_1));
 259   EXPECT_TRUE(error_1.empty());
 260   EXPECT_TRUE(
 261       managed_user_service->UserMayModifySettings(theme.get(), &error_1));
 262   EXPECT_TRUE(error_1.empty());
 263
 264   // Now check a different kind of extension.
 265   scoped_refptr<extensions::Extension> extension = MakeExtension();
 266   EXPECT_FALSE(managed_user_service->UserMayLoad(extension.get(), &error_1));
 267   EXPECT_FALSE(error_1.empty());
 268
 269   base::string16 error_2;
 270   EXPECT_FALSE(
 271       managed_user_service->UserMayModifySettings(extension.get(), &error_2));
 272   EXPECT_FALSE(error_2.empty());
 273
 274 #ifndef NDEBUG
 275   EXPECT_FALSE(managed_user_service->GetDebugPolicyProviderName().empty());
 276 #endif
 277 }
 278
 279 TEST_F(ManagedUserServiceExtensionTest, NoContentPacks) {
 280   ManagedUserService* managed_user_service =
 281       ManagedUserServiceFactory::GetForProfile(profile_.get());
 282   ManagedModeURLFilter* url_filter =
 283       managed_user_service->GetURLFilterForUIThread();
 284
 285   GURL url("http://youtube.com");
 286   ScopedVector<ManagedModeSiteList> site_lists =
 287       GetActiveSiteLists(managed_user_service);
 288   ASSERT_EQ(0u, site_lists.size());
 289   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 290             url_filter->GetFilteringBehaviorForURL(url));
 291 }
 292
 293 TEST_F(ManagedUserServiceExtensionTest, InstallContentPacks) {
 294   ManagedUserService* managed_user_service =
 295       ManagedUserServiceFactory::GetForProfile(profile_.get());
 296   ManagedModeURLFilter* url_filter =
 297       managed_user_service->GetURLFilterForUIThread();
 298   ManagedModeURLFilterObserver observer(url_filter);
 299   observer.Wait();
 300
 301   GURL example_url("http://example.com");
 302   GURL moose_url("http://moose.org");
 303   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 304             url_filter->GetFilteringBehaviorForURL(example_url));
 305
 306   profile_->GetPrefs()->SetInteger(prefs::kDefaultManagedModeFilteringBehavior,
 307                                    ManagedModeURLFilter::BLOCK);
 308   EXPECT_EQ(ManagedModeURLFilter::BLOCK,
 309             url_filter->GetFilteringBehaviorForURL(example_url));
 310
 311   profile_->GetPrefs()->SetInteger(prefs::kDefaultManagedModeFilteringBehavior,
 312                                    ManagedModeURLFilter::WARN);
 313   EXPECT_EQ(ManagedModeURLFilter::WARN,
 314             url_filter->GetFilteringBehaviorForURL(example_url));
 315
 316   managed_user_service->set_elevated_for_testing(true);
 317
 318   // Load a content pack.
 319   scoped_refptr<extensions::UnpackedInstaller> installer(
 320       extensions::UnpackedInstaller::Create(service_));
 321   installer->set_prompt_for_plugins(false);
 322   base::FilePath test_data_dir;
 323   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
 324   base::FilePath extension_path =
 325       test_data_dir.AppendASCII("extensions/managed_mode/content_pack");
 326   content::WindowedNotificationObserver extension_load_observer(
 327       chrome::NOTIFICATION_EXTENSION_LOADED,
 328       content::Source<Profile>(profile_.get()));
 329   installer->Load(extension_path);
 330   extension_load_observer.Wait();
 331   observer.Wait();
 332   content::Details<extensions::Extension> details =
 333       extension_load_observer.details();
 334   scoped_refptr<extensions::Extension> extension =
 335       make_scoped_refptr(details.ptr());
 336   ASSERT_TRUE(extension.get());
 337
 338   ScopedVector<ManagedModeSiteList> site_lists =
 339       GetActiveSiteLists(managed_user_service);
 340   ASSERT_EQ(1u, site_lists.size());
 341   std::vector<ManagedModeSiteList::Site> sites;
 342   site_lists[0]->GetSites(&sites);
 343   ASSERT_EQ(3u, sites.size());
 344   EXPECT_EQ(base::ASCIIToUTF16("YouTube"), sites[0].name);
 345   EXPECT_EQ(base::ASCIIToUTF16("Homestar Runner"), sites[1].name);
 346   EXPECT_EQ(base::string16(), sites[2].name);
 347
 348   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 349             url_filter->GetFilteringBehaviorForURL(example_url));
 350   EXPECT_EQ(ManagedModeURLFilter::WARN,
 351             url_filter->GetFilteringBehaviorForURL(moose_url));
 352
 353   // Load a second content pack.
 354   installer = extensions::UnpackedInstaller::Create(service_);
 355   extension_path =
 356       test_data_dir.AppendASCII("extensions/managed_mode/content_pack_2");
 357   installer->Load(extension_path);
 358   observer.Wait();
 359
 360   site_lists = GetActiveSiteLists(managed_user_service);
 361   ASSERT_EQ(2u, site_lists.size());
 362   sites.clear();
 363   site_lists[0]->GetSites(&sites);
 364   site_lists[1]->GetSites(&sites);
 365   ASSERT_EQ(4u, sites.size());
 366   // The site lists might be returned in any order, so we put them into a set.
 367   std::set<std::string> site_names;
 368   for (std::vector<ManagedModeSiteList::Site>::const_iterator it =
 369       sites.begin(); it != sites.end(); ++it) {
 370     site_names.insert(base::UTF16ToUTF8(it->name));
 371   }
 372   EXPECT_TRUE(site_names.count("YouTube") == 1u);
 373   EXPECT_TRUE(site_names.count("Homestar Runner") == 1u);
 374   EXPECT_TRUE(site_names.count(std::string()) == 1u);
 375   EXPECT_TRUE(site_names.count("Moose") == 1u);
 376
 377   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 378             url_filter->GetFilteringBehaviorForURL(example_url));
 379   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 380             url_filter->GetFilteringBehaviorForURL(moose_url));
 381
 382   // Disable the first content pack.
 383   service_->DisableExtension(extension->id(),
 384                              extensions::Extension::DISABLE_USER_ACTION);
 385   observer.Wait();
 386
 387   site_lists = GetActiveSiteLists(managed_user_service);
 388   ASSERT_EQ(1u, site_lists.size());
 389   sites.clear();
 390   site_lists[0]->GetSites(&sites);
 391   ASSERT_EQ(1u, sites.size());
 392   EXPECT_EQ(base::ASCIIToUTF16("Moose"), sites[0].name);
 393
 394   EXPECT_EQ(ManagedModeURLFilter::WARN,
 395             url_filter->GetFilteringBehaviorForURL(example_url));
 396   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
 397             url_filter->GetFilteringBehaviorForURL(moose_url));
 398 }
 399 #endif  // !defined(OS_ANDROID)