chrome/browser/printing/cloud_print/cloud_print_proxy_service_unittest.cc

   1 // Copyright (c) 2012 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/location.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/prefs/testing_pref_service.h"
  12 #include "base/run_loop.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/thread_task_runner_handle.h"
  15 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
  16 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
  17 #include "chrome/browser/service_process/service_process_control.h"
  18 #include "chrome/browser/ui/startup/startup_browser_creator.h"
  19 #include "chrome/common/chrome_switches.h"
  20 #include "chrome/common/cloud_print/cloud_print_proxy_info.h"
  21 #include "chrome/common/pref_names.h"
  22 #include "chrome/common/service_messages.h"
  23 #include "chrome/test/base/testing_browser_process.h"
  24 #include "chrome/test/base/testing_profile.h"
  25 #include "chrome/test/base/testing_profile_manager.h"
  26 #include "components/syncable_prefs/testing_pref_service_syncable.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/test/test_browser_thread.h"
  29 #include "testing/gmock/include/gmock/gmock.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 using ::testing::Assign;
  33 using ::testing::AtMost;
  34 using ::testing::DeleteArg;
  35 using ::testing::DoAll;
  36 using ::testing::Invoke;
  37 using ::testing::Property;
  38 using ::testing::Return;
  39 using ::testing::ReturnPointee;
  40 using ::testing::WithArgs;
  41 using ::testing::WithoutArgs;
  42 using ::testing::_;
  43
  44 class MockServiceProcessControl : public ServiceProcessControl {
  45  public:
  46   static std::string EnabledUserId();
  47
  48   MockServiceProcessControl() : connected_(false) { }
  49
  50   MOCK_CONST_METHOD0(IsConnected, bool());
  51
  52   MOCK_METHOD2(Launch, void(const base::Closure&, const base::Closure&));
  53   MOCK_METHOD0(Disconnect, void());
  54
  55   MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message&));
  56   MOCK_METHOD1(OnChannelConnected, void(int32 peer_pid));
  57   MOCK_METHOD0(OnChannelError, void());
  58
  59   MOCK_METHOD1(Send, bool(IPC::Message*));
  60
  61   typedef enum {
  62     kServiceStateDisabled,
  63     kServiceStateEnabled,
  64     kServiceStateNone
  65   } ServiceState;
  66
  67   void SetConnectSuccessMockExpectations(ServiceState state, bool post_task);
  68
  69   void SetServiceEnabledExpectations();
  70   void SetServiceDisabledExpectations();
  71   void SetWillBeEnabledExpectations();
  72   void SetWillBeDisabledExpectations();
  73
  74   bool SendEnabledInfo();
  75   bool SendDisabledInfo();
  76
  77  private:
  78   bool connected_;
  79   cloud_print::CloudPrintProxyInfo info_;
  80 };
  81
  82 // static
  83 std::string MockServiceProcessControl::EnabledUserId() {
  84   return std::string("dorothy@somewhere.otr");
  85 }
  86
  87 void CallTask(const base::Closure& task) {
  88   if (!task.is_null())
  89     task.Run();
  90 }
  91
  92 void PostTask(const base::Closure& task) {
  93   if (!task.is_null())
  94     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
  95 }
  96
  97 void MockServiceProcessControl::SetConnectSuccessMockExpectations(
  98     ServiceState service_state,
  99     bool post_task) {
 100   EXPECT_CALL(*this, IsConnected()).WillRepeatedly(ReturnPointee(&connected_));
 101
 102   EXPECT_CALL(*this, Launch(_, _))
 103       .WillRepeatedly(
 104           DoAll(Assign(&connected_, true),
 105                 WithArgs<0>(Invoke(post_task ? PostTask : CallTask))));
 106
 107   EXPECT_CALL(*this, Disconnect()).Times(AtMost(1))
 108       .WillRepeatedly(Assign(&connected_, false));
 109
 110   EXPECT_CALL(*this, Send(_)).Times(0);
 111
 112   if (service_state == kServiceStateEnabled)
 113     SetServiceEnabledExpectations();
 114   else if (service_state == kServiceStateDisabled)
 115     SetServiceDisabledExpectations();
 116 }
 117
 118 void MockServiceProcessControl::SetServiceEnabledExpectations() {
 119   EXPECT_CALL(
 120       *this,
 121       Send(Property(&IPC::Message::type,
 122                     static_cast<int32>(ServiceMsg_GetCloudPrintProxyInfo::ID))))
 123       .Times(1).WillOnce(
 124           DoAll(
 125               DeleteArg<0>(),
 126               WithoutArgs(
 127                   Invoke(this, &MockServiceProcessControl::SendEnabledInfo))));
 128 }
 129
 130 void MockServiceProcessControl::SetServiceDisabledExpectations() {
 131   EXPECT_CALL(
 132       *this,
 133       Send(Property(&IPC::Message::type,
 134                     static_cast<int32>(ServiceMsg_GetCloudPrintProxyInfo::ID))))
 135       .Times(1).WillOnce(
 136           DoAll(
 137               DeleteArg<0>(),
 138               WithoutArgs(
 139                   Invoke(this, &MockServiceProcessControl::SendDisabledInfo))));
 140 }
 141
 142 void MockServiceProcessControl::SetWillBeEnabledExpectations() {
 143   int32 message_id = ServiceMsg_EnableCloudPrintProxyWithRobot::ID;
 144   EXPECT_CALL(
 145       *this,
 146       Send(Property(&IPC::Message::type, message_id)))
 147       .Times(1).WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 148 }
 149
 150 void MockServiceProcessControl::SetWillBeDisabledExpectations() {
 151   EXPECT_CALL(
 152       *this,
 153       Send(Property(&IPC::Message::type,
 154                     static_cast<int32>(ServiceMsg_DisableCloudPrintProxy::ID))))
 155       .Times(1).WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 156 }
 157
 158 bool MockServiceProcessControl::SendEnabledInfo() {
 159   info_.enabled = true;
 160   info_.email = EnabledUserId();
 161   PostTask(base::Bind(&MockServiceProcessControl::OnCloudPrintProxyInfo,
 162                       base::Unretained(this), info_));
 163   return true;
 164 }
 165
 166 bool MockServiceProcessControl::SendDisabledInfo() {
 167   info_.enabled = false;
 168   info_.email = std::string();
 169   PostTask(base::Bind(&MockServiceProcessControl::OnCloudPrintProxyInfo,
 170                       base::Unretained(this), info_));
 171   return true;
 172 }
 173
 174 class TestCloudPrintProxyService : public CloudPrintProxyService {
 175  public:
 176   explicit TestCloudPrintProxyService(Profile* profile)
 177       : CloudPrintProxyService(profile) { }
 178
 179   void Initialize() {
 180     CloudPrintProxyService::Initialize();
 181     base::RunLoop().RunUntilIdle();
 182   }
 183
 184   void RefreshStatusFromService() {
 185     CloudPrintProxyService::RefreshStatusFromService();
 186     base::RunLoop().RunUntilIdle();
 187   }
 188
 189   ServiceProcessControl* GetServiceProcessControl() override {
 190     return &process_control_;
 191   }
 192   MockServiceProcessControl* GetMockServiceProcessControl() {
 193     return &process_control_;
 194   }
 195
 196   void EnableForUser() {
 197     EnableForUserWithRobot("123", "123@gmail.com",
 198                            MockServiceProcessControl::EnabledUserId(),
 199                            base::DictionaryValue());
 200   }
 201
 202  private:
 203   MockServiceProcessControl process_control_;
 204 };
 205
 206 class CloudPrintProxyPolicyTest : public ::testing::Test {
 207  public:
 208   CloudPrintProxyPolicyTest()
 209       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
 210   }
 211
 212   bool LaunchBrowser(const base::CommandLine& command_line, Profile* profile) {
 213     StartupBrowserCreator browser_creator;
 214     return StartupBrowserCreator::ProcessCmdLineImpl(
 215         command_line, base::FilePath(), false, profile,
 216         StartupBrowserCreator::Profiles(), &browser_creator);
 217   }
 218
 219  protected:
 220   base::MessageLoopForUI message_loop_;
 221   content::TestBrowserThread ui_thread_;
 222   TestingProfile profile_;
 223 };
 224
 225 TEST_F(CloudPrintProxyPolicyTest, VerifyExpectations) {
 226   MockServiceProcessControl mock_control;
 227   mock_control.SetConnectSuccessMockExpectations(
 228       MockServiceProcessControl::kServiceStateNone, false);
 229
 230   EXPECT_FALSE(mock_control.IsConnected());
 231   mock_control.Launch(base::Closure(), base::Closure());
 232   EXPECT_TRUE(mock_control.IsConnected());
 233   mock_control.Launch(base::Closure(), base::Closure());
 234   EXPECT_TRUE(mock_control.IsConnected());
 235   mock_control.Disconnect();
 236   EXPECT_FALSE(mock_control.IsConnected());
 237 }
 238
 239 TEST_F(CloudPrintProxyPolicyTest, StartWithNoPolicyProxyDisabled) {
 240   TestCloudPrintProxyService service(&profile_);
 241
 242   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 243       MockServiceProcessControl::kServiceStateDisabled, false);
 244
 245   syncable_prefs::TestingPrefServiceSyncable* prefs =
 246       profile_.GetTestingPrefService();
 247   prefs->SetUserPref(
 248       prefs::kCloudPrintEmail,
 249       new base::StringValue(MockServiceProcessControl::EnabledUserId()));
 250
 251   service.Initialize();
 252
 253   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 254 }
 255
 256 TEST_F(CloudPrintProxyPolicyTest, StartWithNoPolicyProxyEnabled) {
 257   TestCloudPrintProxyService service(&profile_);
 258
 259   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 260       MockServiceProcessControl::kServiceStateEnabled, false);
 261
 262   syncable_prefs::TestingPrefServiceSyncable* prefs =
 263       profile_.GetTestingPrefService();
 264   prefs->SetUserPref(prefs::kCloudPrintEmail,
 265                      new base::StringValue(std::string()));
 266
 267   service.Initialize();
 268   service.RefreshStatusFromService();
 269
 270   EXPECT_EQ(MockServiceProcessControl::EnabledUserId(),
 271             prefs->GetString(prefs::kCloudPrintEmail));
 272 }
 273
 274 TEST_F(CloudPrintProxyPolicyTest, StartWithPolicySetProxyDisabled) {
 275   TestCloudPrintProxyService service(&profile_);
 276
 277   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 278       MockServiceProcessControl::kServiceStateDisabled, false);
 279
 280   syncable_prefs::TestingPrefServiceSyncable* prefs =
 281       profile_.GetTestingPrefService();
 282   prefs->SetUserPref(prefs::kCloudPrintEmail,
 283                      new base::StringValue(std::string()));
 284   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 285                         new base::FundamentalValue(false));
 286
 287   service.Initialize();
 288
 289   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 290 }
 291
 292 TEST_F(CloudPrintProxyPolicyTest, StartWithPolicySetProxyEnabled) {
 293   TestCloudPrintProxyService service(&profile_);
 294
 295   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 296       MockServiceProcessControl::kServiceStateEnabled, false);
 297   service.GetMockServiceProcessControl()->SetWillBeDisabledExpectations();
 298
 299   syncable_prefs::TestingPrefServiceSyncable* prefs =
 300       profile_.GetTestingPrefService();
 301   prefs->SetUserPref(prefs::kCloudPrintEmail,
 302                      new base::StringValue(std::string()));
 303   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 304                         new base::FundamentalValue(false));
 305
 306   service.Initialize();
 307
 308   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 309 }
 310
 311 TEST_F(CloudPrintProxyPolicyTest, StartWithNoPolicyProxyDisabledThenSetPolicy) {
 312   TestCloudPrintProxyService service(&profile_);
 313
 314   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 315       MockServiceProcessControl::kServiceStateDisabled, false);
 316
 317   syncable_prefs::TestingPrefServiceSyncable* prefs =
 318       profile_.GetTestingPrefService();
 319   prefs->SetUserPref(
 320       prefs::kCloudPrintEmail,
 321       new base::StringValue(MockServiceProcessControl::EnabledUserId()));
 322
 323   service.Initialize();
 324
 325   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 326
 327   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 328                         new base::FundamentalValue(false));
 329
 330   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 331 }
 332
 333 TEST_F(CloudPrintProxyPolicyTest, StartWithNoPolicyProxyEnabledThenSetPolicy) {
 334   TestCloudPrintProxyService service(&profile_);
 335
 336   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 337       MockServiceProcessControl::kServiceStateEnabled, false);
 338
 339   syncable_prefs::TestingPrefServiceSyncable* prefs =
 340       profile_.GetTestingPrefService();
 341   prefs->SetUserPref(prefs::kCloudPrintEmail,
 342                      new base::StringValue(std::string()));
 343
 344   service.Initialize();
 345   service.RefreshStatusFromService();
 346
 347   EXPECT_EQ(MockServiceProcessControl::EnabledUserId(),
 348             prefs->GetString(prefs::kCloudPrintEmail));
 349
 350   service.GetMockServiceProcessControl()->SetWillBeDisabledExpectations();
 351   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 352                         new base::FundamentalValue(false));
 353
 354   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 355 }
 356
 357 TEST_F(CloudPrintProxyPolicyTest,
 358        StartWithPolicySetProxyDisabledThenClearPolicy) {
 359   TestCloudPrintProxyService service(&profile_);
 360
 361   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 362       MockServiceProcessControl::kServiceStateDisabled, false);
 363
 364   syncable_prefs::TestingPrefServiceSyncable* prefs =
 365       profile_.GetTestingPrefService();
 366   prefs->SetUserPref(prefs::kCloudPrintEmail,
 367                      new base::StringValue(std::string()));
 368   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 369                         new base::FundamentalValue(false));
 370
 371   service.Initialize();
 372
 373   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 374   prefs->RemoveManagedPref(prefs::kCloudPrintProxyEnabled);
 375   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 376 }
 377
 378 TEST_F(CloudPrintProxyPolicyTest,
 379        StartWithPolicySetProxyEnabledThenClearPolicy) {
 380   TestCloudPrintProxyService service(&profile_);
 381
 382   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 383       MockServiceProcessControl::kServiceStateEnabled, false);
 384   service.GetMockServiceProcessControl()->SetWillBeDisabledExpectations();
 385
 386   syncable_prefs::TestingPrefServiceSyncable* prefs =
 387       profile_.GetTestingPrefService();
 388   prefs->SetUserPref(prefs::kCloudPrintEmail,
 389                      new base::StringValue(std::string()));
 390   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 391                         new base::FundamentalValue(false));
 392
 393   service.Initialize();
 394
 395   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 396   prefs->RemoveManagedPref(prefs::kCloudPrintProxyEnabled);
 397   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 398 }
 399
 400 TEST_F(CloudPrintProxyPolicyTest, StartWithNoPolicyProxyDisabledThenEnable) {
 401   TestCloudPrintProxyService service(&profile_);
 402
 403   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 404       MockServiceProcessControl::kServiceStateDisabled, false);
 405
 406   syncable_prefs::TestingPrefServiceSyncable* prefs =
 407       profile_.GetTestingPrefService();
 408   prefs->SetUserPref(
 409       prefs::kCloudPrintEmail,
 410       new base::StringValue(MockServiceProcessControl::EnabledUserId()));
 411
 412   service.Initialize();
 413   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 414
 415   service.GetMockServiceProcessControl()->SetWillBeEnabledExpectations();
 416   service.EnableForUser();
 417
 418   EXPECT_EQ(MockServiceProcessControl::EnabledUserId(),
 419             prefs->GetString(prefs::kCloudPrintEmail));
 420 }
 421
 422 TEST_F(CloudPrintProxyPolicyTest,
 423        StartWithPolicySetProxyEnabledThenClearPolicyAndEnable) {
 424   TestCloudPrintProxyService service(&profile_);
 425
 426   service.GetMockServiceProcessControl()->SetConnectSuccessMockExpectations(
 427       MockServiceProcessControl::kServiceStateEnabled, false);
 428   service.GetMockServiceProcessControl()->SetWillBeDisabledExpectations();
 429
 430   syncable_prefs::TestingPrefServiceSyncable* prefs =
 431       profile_.GetTestingPrefService();
 432   prefs->SetUserPref(prefs::kCloudPrintEmail,
 433                      new base::StringValue(std::string()));
 434   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
 435                         new base::FundamentalValue(false));
 436
 437   service.Initialize();
 438
 439   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 440   service.EnableForUser();
 441   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 442
 443   prefs->RemoveManagedPref(prefs::kCloudPrintProxyEnabled);
 444   EXPECT_EQ(std::string(), prefs->GetString(prefs::kCloudPrintEmail));
 445
 446   service.GetMockServiceProcessControl()->SetWillBeEnabledExpectations();
 447   service.EnableForUser();
 448
 449   EXPECT_EQ(MockServiceProcessControl::EnabledUserId(),
 450             prefs->GetString(prefs::kCloudPrintEmail));
 451 }