src/chrome/browser/policy/cloud/component_cloud_policy_browsertest.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 <string>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/path_service.h"
  11 #include "base/run_loop.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/extensions/extension_browsertest.h"
  14 #include "chrome/browser/extensions/extension_test_message_listener.h"
  15 #include "chrome/browser/policy/browser_policy_connector.h"
  16 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
  17 #include "chrome/browser/policy/cloud/mock_cloud_policy_client.h"
  18 #include "chrome/browser/policy/policy_service.h"
  19 #include "chrome/browser/policy/policy_test_utils.h"
  20 #include "chrome/browser/policy/profile_policy_connector.h"
  21 #include "chrome/browser/policy/profile_policy_connector_factory.h"
  22 #include "chrome/browser/policy/proto/cloud/chrome_extension_policy.pb.h"
  23 #include "chrome/browser/policy/test/local_policy_test_server.h"
  24 #include "chrome/browser/profiles/profile.h"
  25 #include "chrome/common/chrome_paths.h"
  26 #include "chrome/common/chrome_switches.h"
  27 #include "chrome/common/extensions/extension.h"
  28 #include "net/url_request/url_request_context_getter.h"
  29 #include "policy/proto/cloud_policy.pb.h"
  30 #include "testing/gmock/include/gmock/gmock.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32
  33 #if defined(OS_CHROMEOS)
  34 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
  35 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
  36 #include "chrome/common/chrome_paths.h"
  37 #include "chromeos/chromeos_switches.h"
  38 #else
  39 #include "chrome/browser/policy/cloud/user_cloud_policy_manager.h"
  40 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
  41 #include "chrome/browser/signin/signin_manager.h"
  42 #include "chrome/browser/signin/signin_manager_factory.h"
  43 #endif
  44
  45 using testing::InvokeWithoutArgs;
  46 using testing::Mock;
  47 using testing::Return;
  48 using testing::_;
  49
  50 namespace em = enterprise_management;
  51
  52 namespace policy {
  53
  54 const char kDMToken[] = "dmtoken";
  55 const char kDeviceID[] = "deviceid";
  56
  57 const char kTestExtension[] = "kjmkgkdkpedkejedfhmfcenooemhbpbo";
  58
  59 const base::FilePath::CharType kTestExtensionPath[] =
  60     FILE_PATH_LITERAL("extensions/managed_extension");
  61
  62 const char kTestPolicy[] =
  63     "{"
  64     "  \"Name\": {"
  65     "    \"Value\": \"disable_all_the_things\""
  66     "  }"
  67     "}";
  68
  69 #if defined(OS_CHROMEOS)
  70 const char kTestExtension2[] = "behllobkkfkfnphdnhnkndlbkcpglgmj";
  71 const base::FilePath::CharType kTestExtension2Path[] =
  72     FILE_PATH_LITERAL("extensions/managed_extension2");
  73
  74 const char kTestPolicyJSON[] = "{\"Name\":\"disable_all_the_things\"}";
  75
  76 const char kTestPolicy2[] =
  77     "{"
  78     "  \"Another\": {"
  79     "    \"Value\": \"turn_it_off\""
  80     "  }"
  81     "}";
  82
  83 const char kTestPolicy2JSON[] = "{\"Another\":\"turn_it_off\"}";
  84 #endif  // defined(OS_CHROMEOS)
  85
  86 class ComponentCloudPolicyTest : public ExtensionBrowserTest {
  87  protected:
  88   ComponentCloudPolicyTest() {}
  89   virtual ~ComponentCloudPolicyTest() {}
  90
  91   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  92     ExtensionBrowserTest::SetUpCommandLine(command_line);
  93 #if defined(OS_CHROMEOS)
  94     // ExtensionBrowserTest sets the login users to a non-managed value;
  95     // replace it. This is the default username sent in policy blobs from the
  96     // testserver.
  97     command_line->AppendSwitchASCII(
  98         chromeos::switches::kLoginUser, "user@example.com");
  99 #endif
 100   }
 101
 102   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 103     test_server_.RegisterClient(kDMToken, kDeviceID);
 104     EXPECT_TRUE(test_server_.UpdatePolicyData(
 105         dm_protocol::kChromeExtensionPolicyType, kTestExtension, kTestPolicy));
 106     ASSERT_TRUE(test_server_.Start());
 107
 108     std::string url = test_server_.GetServiceURL().spec();
 109     CommandLine* command_line = CommandLine::ForCurrentProcess();
 110     command_line->AppendSwitchASCII(switches::kDeviceManagementUrl, url);
 111     command_line->AppendSwitch(switches::kEnableComponentCloudPolicy);
 112
 113     ExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
 114   }
 115
 116   virtual void SetUpOnMainThread() OVERRIDE {
 117     ASSERT_TRUE(PolicyServiceIsEmpty(g_browser_process->policy_service()))
 118         << "Pre-existing policies in this machine will make this test fail.";
 119
 120     // Install the initial extension.
 121     ExtensionTestMessageListener ready_listener("ready", true);
 122     event_listener_.reset(new ExtensionTestMessageListener("event", true));
 123     extension_ = LoadExtension(kTestExtensionPath);
 124     ASSERT_TRUE(extension_.get());
 125     ASSERT_EQ(kTestExtension, extension_->id());
 126     EXPECT_TRUE(ready_listener.WaitUntilSatisfied());
 127
 128     BrowserPolicyConnector* connector =
 129         g_browser_process->browser_policy_connector();
 130     connector->ScheduleServiceInitialization(0);
 131
 132 #if defined(OS_CHROMEOS)
 133     UserCloudPolicyManagerChromeOS* policy_manager =
 134         UserCloudPolicyManagerFactoryChromeOS::GetForProfile(
 135             browser()->profile());
 136     ASSERT_TRUE(policy_manager);
 137 #else
 138     // Mock a signed-in user. This is used by the UserCloudPolicyStore to pass
 139     // the username to the UserCloudPolicyValidator.
 140     SigninManager* signin_manager =
 141         SigninManagerFactory::GetForProfile(browser()->profile());
 142     ASSERT_TRUE(signin_manager);
 143     signin_manager->SetAuthenticatedUsername("user@example.com");
 144
 145     UserCloudPolicyManager* policy_manager =
 146         UserCloudPolicyManagerFactory::GetForProfile(browser()->profile());
 147     ASSERT_TRUE(policy_manager);
 148     policy_manager->Connect(g_browser_process->local_state(),
 149                             g_browser_process->system_request_context(),
 150                             UserCloudPolicyManager::CreateCloudPolicyClient(
 151                                 connector->device_management_service()).Pass());
 152 #endif  // defined(OS_CHROMEOS)
 153
 154     // Register the cloud policy client.
 155     ASSERT_TRUE(policy_manager->core()->client());
 156     base::RunLoop run_loop;
 157     MockCloudPolicyClientObserver observer;
 158     EXPECT_CALL(observer, OnRegistrationStateChanged(_))
 159         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
 160     policy_manager->core()->client()->AddObserver(&observer);
 161     policy_manager->core()->client()->SetupRegistration(kDMToken, kDeviceID);
 162     run_loop.Run();
 163     Mock::VerifyAndClearExpectations(&observer);
 164     policy_manager->core()->client()->RemoveObserver(&observer);
 165
 166     // The extension will receive an update event.
 167     EXPECT_TRUE(event_listener_->WaitUntilSatisfied());
 168
 169     ExtensionBrowserTest::SetUpOnMainThread();
 170   }
 171
 172   scoped_refptr<const extensions::Extension> LoadExtension(
 173       const base::FilePath::CharType* path) {
 174     base::FilePath full_path;
 175     if (!PathService::Get(chrome::DIR_TEST_DATA, &full_path)) {
 176       ADD_FAILURE();
 177       return NULL;
 178     }
 179     scoped_refptr<const extensions::Extension> extension(
 180         ExtensionBrowserTest::LoadExtension(full_path.Append(path)));
 181     if (!extension.get()) {
 182       ADD_FAILURE();
 183       return NULL;
 184     }
 185     return extension;
 186   }
 187
 188   void RefreshPolicies() {
 189     ProfilePolicyConnector* profile_connector =
 190         ProfilePolicyConnectorFactory::GetForProfile(browser()->profile());
 191     PolicyService* policy_service = profile_connector->policy_service();
 192     base::RunLoop run_loop;
 193     policy_service->RefreshPolicies(run_loop.QuitClosure());
 194     run_loop.Run();
 195   }
 196
 197   LocalPolicyTestServer test_server_;
 198   scoped_refptr<const extensions::Extension> extension_;
 199   scoped_ptr<ExtensionTestMessageListener> event_listener_;
 200 };
 201
 202 // TODO(joaodasilva): enable these for other platforms once ready.
 203 #if defined(OS_CHROMEOS)
 204
 205 IN_PROC_BROWSER_TEST_F(ComponentCloudPolicyTest, FetchExtensionPolicy) {
 206   // Read the initial policy.
 207   ExtensionTestMessageListener policy_listener(kTestPolicyJSON, true);
 208   event_listener_->Reply("get-policy-Name");
 209   EXPECT_TRUE(policy_listener.WaitUntilSatisfied());
 210 }
 211
 212 IN_PROC_BROWSER_TEST_F(ComponentCloudPolicyTest, UpdateExtensionPolicy) {
 213   // Read the initial policy.
 214   ExtensionTestMessageListener policy_listener(kTestPolicyJSON, true);
 215   event_listener_->Reply("get-policy-Name");
 216   EXPECT_TRUE(policy_listener.WaitUntilSatisfied());
 217
 218   // Update the policy at the server and reload policy.
 219   event_listener_.reset(new ExtensionTestMessageListener("event", true));
 220   policy_listener.Reply("idle");
 221   EXPECT_TRUE(test_server_.UpdatePolicyData(
 222       dm_protocol::kChromeExtensionPolicyType, kTestExtension, kTestPolicy2));
 223   RefreshPolicies();
 224
 225   // Check that the update event was received, and verify the new policy
 226   // values.
 227   EXPECT_TRUE(event_listener_->WaitUntilSatisfied());
 228
 229   // This policy was removed.
 230   ExtensionTestMessageListener policy_listener1("{}", true);
 231   event_listener_->Reply("get-policy-Name");
 232   EXPECT_TRUE(policy_listener1.WaitUntilSatisfied());
 233
 234   ExtensionTestMessageListener policy_listener2(kTestPolicy2JSON, true);
 235   policy_listener1.Reply("get-policy-Another");
 236   EXPECT_TRUE(policy_listener2.WaitUntilSatisfied());
 237 }
 238
 239 IN_PROC_BROWSER_TEST_F(ComponentCloudPolicyTest, InstallNewExtension) {
 240   EXPECT_TRUE(test_server_.UpdatePolicyData(
 241       dm_protocol::kChromeExtensionPolicyType, kTestExtension2, kTestPolicy2));
 242
 243   ExtensionTestMessageListener result_listener("ok", true);
 244   result_listener.AlsoListenForFailureMessage("fail");
 245   scoped_refptr<const extensions::Extension> extension2 =
 246       LoadExtension(kTestExtension2Path);
 247   ASSERT_TRUE(extension2.get());
 248   ASSERT_EQ(kTestExtension2, extension2->id());
 249
 250   // This extension only sends the 'policy' signal once it receives the policy,
 251   // and after verifying it has the expected value. Otherwise it sends 'fail'.
 252   EXPECT_TRUE(result_listener.WaitUntilSatisfied());
 253 }
 254
 255 #endif  // OS_CHROMEOS
 256
 257 }  // namespace policy