Track permissions granted to extensions in prefs

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2010 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/extensions_service_unittest.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 54 matching lines @@
 // Extension ids used during testing.
 const char* const all_zero = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const char* const zero_n_one = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab";
 const char* const good0 = "behllobkkfkfnphdnhnkndlbkcpglgmj";
 const char* const good1 = "hpiknbiabeeppbpihjehijgoemciehgk";
 const char* const good2 = "bjafgdebaacbbbecmhlhpofkepfkgcpa";
 const char* const good_crx = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char* const page_action = "obcimlgaoabeegjmmpldobjndiealpln";
 const char* const theme_crx = "iamefpfkojoapidjnbafmgkgncegbkad";
 const char* const theme2_crx = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
+const char* const permissions_unknown_crx = "bcflfiohkjolmhmjjocpfbloomonhpkc";
 
 struct ExtensionsOrder {
   bool operator()(const Extension* a, const Extension* b) {
     return a->name() < b->name();
   }
 };
 
 static std::vector<std::string> GetErrors() {
   const std::vector<std::string>* errors =
       ExtensionErrorReporter::GetInstance()->GetErrors();
@@ skipping 918 matching lines @@
   EXPECT_EQ(0u, errors.size()) << "There were errors: "
                                << JoinString(errors, ',');
   EXPECT_TRUE(service_->GetExtensionById(loaded_[0]->id(), false)) <<
               path.value();
 
   installed_ = NULL;
   loaded_.clear();
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
+// This tests that the granted permissions preferences are correctly set when
+// installing an extension.
+TEST_F(ExtensionsServiceTest, GrantedPermissions) {
+  InitializeEmptyExtensionsService();
+
+  FilePath path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
+  path = path.AppendASCII("extensions")
+             .AppendASCII("permissions-unknown-v1.crx");

[Aaron Boodman, 2010/11/12 00:05:24]

It is better to use unpacked extensions in tests so that they can easily be
changed.

Since you want to test the behavior of installing, you can start with an
unpacked directory that is checked in, and create a crx dynamically during the
test, then install that. See PackAndInstallExtension() in this file.

[jstritar, 2010/11/19 21:38:36]

Done.

+  ASSERT_TRUE(file_util::PathExists(path));
+
+  InstallExtension(path, true);

[Aaron Boodman, 2010/11/12 00:05:24]

Add a test to validate that there are no granted permissions prior to
installation?

[jstritar, 2010/11/19 21:38:36]

Now that I'm packing the extensions dynamically, I'm not sure how I'd do this
since the IDs aren't predictable. Would I include a *.pem file and update
PackAndInstallExtension to use that?

+
+  ExtensionPrefs* prefs = service_->extension_prefs();
+  const char* extension_id = permissions_unknown_crx;
+
+  // Verify that the valid API permissions have been recognized.
+  std::set<std::string> known_api_perms;
+  std::set<std::string> known_host_perms;
+
+  std::set<std::string> expected_api_perms;
+  expected_api_perms.insert("tabs");
+
+  std::set<std::string> expected_host_perms;
+  expected_host_perms.insert("http://*.google.com/*");
+  expected_host_perms.insert("https://*.google.com/*");
+
+
+  EXPECT_TRUE(prefs->GetGrantedPermissions(extension_id,
+                                           &known_api_perms,
+                                           &known_host_perms));
+
+  EXPECT_EQ(expected_api_perms, known_api_perms);
+  EXPECT_EQ(expected_host_perms, known_host_perms);
+}
+
+// Tests that the extension is disabled when an API permission is missing from
+// the extension's granted api permissions preference. (This simulates updating
+// the browser to a version which recognizes a new API permission).
+TEST_F(ExtensionsServiceTest, GrantedAPIPermissions) {
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+
+  FilePath source_install_dir = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Extensions");
+  FilePath pref_path = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Preferences-unknown-api");
+
+  const char* extension_id = permissions_unknown_crx;
+
+  InitializeInstalledExtensionsService(pref_path, source_install_dir);

[Aaron Boodman, 2010/11/12 00:05:24]

I think it would be a little bit better to test this using more of the C++ API,
instead of manipulating the preferences directly.

You could:

* InitializeEmptyExtensionsService()
* Install a packed extension that has some known set of permissions
* Use ExtensionPrefs API to set the granted permissions to some smaller set
* Reinitialize extensions service
* Expect disabledness

[jstritar, 2010/11/19 21:38:36]

Done. I also combined these tests into one, so I don't have to do the same setup
each time.

+  service_->Init();
+  loop_.RunAllPending();
+
+  ExtensionPrefs* prefs = service_->extension_prefs();
+
+  ASSERT_EQ(0u, GetErrors().size());
+  ASSERT_EQ(0u, loaded_.size());
+
+  ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::DISABLED);
+  ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
+}
+
+// Tests that the extension is disabled when a host permission is missing from
+// the extension's granted host permissions preference. (This simulates updating
+// the browser to a version which recognizes additional host permissions).
+TEST_F(ExtensionsServiceTest, GrantedHostPermissions) {
+  FilePath extensions_path;

[Aaron Boodman, 2010/11/12 00:05:24]

Same thing here.

[jstritar, 2010/11/19 21:38:36]

Done.

+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+
+  FilePath source_install_dir = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Extensions");
+  FilePath pref_path = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Preferences-unknown-host");
+
+  const char* extension_id = permissions_unknown_crx;
+
+  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  service_->Init();
+  loop_.RunAllPending();
+
+  ExtensionPrefs* prefs = service_->extension_prefs();
+
+  ASSERT_EQ(0u, GetErrors().size());
+  ASSERT_EQ(0u, loaded_.size());
+
+  ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::DISABLED);
+  ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
+}
+
+// Tests that the granted permissions preferences are initialized when
+// migrating from the old pref schema.
+TEST_F(ExtensionsServiceTest, GrantedPermissionsInitialization) {
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));

[Aaron Boodman, 2010/11/12 00:05:24]

Same thing here.

[jstritar, 2010/11/19 21:38:36]

Done.

+  extensions_path = extensions_path.AppendASCII("extensions");
+
+  FilePath source_install_dir = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Extensions");
+  FilePath pref_path = extensions_path
+      .AppendASCII("permissions")
+      .AppendASCII("Preferences-initialization");
+
+  const char* extension_id = permissions_unknown_crx;
+
+  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  service_->Init();
+  loop_.RunAllPending();
+
+  ExtensionPrefs* prefs = service_->extension_prefs();
+
+  ASSERT_EQ(0u, GetErrors().size());
+  ASSERT_EQ(1u, loaded_.size());
+
+  ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::ENABLED);
+  ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
+
+  std::set<std::string> known_api_perms;
+  std::set<std::string> known_host_perms;
+
+  std::set<std::string> expected_api_perms;
+  expected_api_perms.insert("tabs");
+
+  std::set<std::string> expected_host_perms;
+  expected_host_perms.insert("http://*.google.com/*");
+  expected_host_perms.insert("https://*.google.com/*");
+
+
+  EXPECT_TRUE(prefs->GetGrantedPermissions(extension_id,
+                                           &known_api_perms,
+                                           &known_host_perms));
+
+  EXPECT_EQ(expected_api_perms, known_api_perms);
+  EXPECT_EQ(expected_host_perms, known_host_perms);
+}
+
 // Test Packaging and installing an extension.
 TEST_F(ExtensionsServiceTest, PackExtension) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
@@ skipping 1730 matching lines @@
   // Component extensions shouldn't get recourded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }