[login_manager] Code to add the owner to the whitelist in a device policy

session_manager_unittest.cc

 // Copyright (c) 2011 The Chromium OS 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 "login_manager/session_manager_service.h"
 
 #include <errno.h>
 #include <gtest/gtest.h>
 #include <signal.h>
 #include <unistd.h>
@@ skipping 146 matching lines @@
   }
 
   void ExpectStartSession(const std::string& email_string,
                           MockChildJob* job,
                           MockPrefStore* store) {
     EXPECT_CALL(*job, StartSession(email_string))
         .Times(1);
     MockOwnerKey* key = new MockOwnerKey;
     EXPECT_CALL(*key, PopulateFromDiskIfPossible())
         .WillRepeatedly(Return(true));
-    // First, expect an attempt to set the device owner property, but
-    // act like this user isn't the owner.
-    EXPECT_CALL(*key, Sign(_, _, _))
-        .WillOnce(Return(false));
-    manager_->test_api().set_ownerkey(key);
-    // Now, expect an attempt to check whether this user is the owner; respond
+    // Expect an attempt to check whether this user is the owner; respond
     // as though he is not.
     std::string other_user("notme");
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(DoAll(SetArgumentPointee<1>(other_user),
                         Return(true)));
     EXPECT_CALL(*key, Verify(_, _, _, _))
         .WillOnce(Return(true));
     // Confirm that the device is owned.
     EXPECT_CALL(*key, HaveCheckedDisk())
         .WillOnce(Return(true));
     EXPECT_CALL(*key, IsPopulated())
         .WillOnce(Return(true))
         .WillOnce(Return(true));
+    manager_->test_api().set_ownerkey(key);
   }
 
   void ExpectStartSessionUnowned(const std::string& email_string,
                                  MockPrefStore* store) {
     MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
     EXPECT_CALL(*job, StartSession(email_string))
         .Times(1);
 
     MockChildJob* k_job = new MockChildJob;
     EXPECT_CALL(*k_job, SetDesiredUid(getuid()))
         .Times(1);
     EXPECT_CALL(*k_job, GetDesiredUid())
         .Times(1)
         .WillRepeatedly(Return(getuid()));
     EXPECT_CALL(*k_job, IsDesiredUidSet())
         .WillRepeatedly(Return(true));
     ON_CALL(*k_job, Run())
         .WillByDefault(Invoke(CleanExit));
     int keygen_pid = kDummyPid + 1;
 
     MockOwnerKey* key = new MockOwnerKey;
     EXPECT_CALL(*key, PopulateFromDiskIfPossible())
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*key, StartGeneration(k_job))
         .WillOnce(Return(keygen_pid));
-    // act like this user isn't the owner.
-    EXPECT_CALL(*key, Sign(_, _, _))
-        .WillOnce(Return(false));
 
     // Now, expect an attempt to check whether this user is the owner; respond
     // as though there isn't one.
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(Return(false));
     // Confirm that the device is NOT owned.
     EXPECT_CALL(*key, HaveCheckedDisk())
         .WillOnce(Return(true));
     EXPECT_CALL(*key, IsPopulated())
         .WillOnce(Return(false));
 
     manager_->test_api().set_keygen_job(k_job);  // manager_ takes ownership.
     manager_->set_uid(getuid());
     manager_->test_api().set_ownerkey(key);
     manager_->test_api().set_prefstore(store);
 
     EXPECT_CALL(*(utils_.get()), kill(keygen_pid, getuid(), SIGTERM))
         .WillOnce(Return(0));
     EXPECT_CALL(*(utils_.get()), ChildIsGone(keygen_pid, _))
         .WillOnce(Return(true));
     MockUtils();
   }
 
   void ExpectStartSessionForOwner(const std::string& email_string,
                                   MockOwnerKey* key,
-                                  MockPrefStore* store) {
+                                  MockPrefStore* store,
+                                  bool has_key) {
     ON_CALL(*key, PopulateFromDiskIfPossible())
         .WillByDefault(Return(true));
-    // First, mimic attempt to whitelist the owner and set a the
-    // device owner pref.
-    EXPECT_CALL(*key, Sign(_, _, _))
-        .WillOnce(Return(true))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*store, Set(_, email_string, _))
-        .Times(1);
-    EXPECT_CALL(*key, Sign(CastEq(email_string), email_string.length(), _))
-        .WillOnce(Return(true))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*store, Whitelist(email_string, _))
-        .Times(1);
+    int persist_times = 1;
+    if (has_key) {
+      // First, mimic attempt to whitelist the owner and set a the

[gauravsh, 2011/04/08 04:58:49]

nit: s/a the/the/

[Chris Masone, 2011/04/08 05:57:41]

Done.

+      // device owner pref.
+      EXPECT_CALL(*key, Sign(_, _, _))
+          .WillOnce(Return(true))
+          .RetiresOnSaturation();
+      EXPECT_CALL(*store, Set(_, email_string, _))
+          .Times(1);
+      EXPECT_CALL(*key, Sign(CastEq(email_string), email_string.length(), _))
+          .WillOnce(Return(true))
+          .RetiresOnSaturation();
+      EXPECT_CALL(*store, Whitelist(email_string, _))
+          .Times(1);
+      persist_times = 3;
+    }
     EXPECT_CALL(*store, Persist())
-        .WillOnce(Return(true))
-        .WillOnce(Return(true))
-        .WillOnce(Return(true));
+        .Times(persist_times)
+        .WillRepeatedly(Return(true));
+
     // Now, expect an attempt to check whether this user is the owner;
     // respond as though he is.
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(DoAll(SetArgumentPointee<1>(email_string),
                         Return(true)));
     EXPECT_CALL(*key, Verify(_, _, _, _))
         .WillOnce(Return(true));
     // Confirm that the device is owned.
     EXPECT_CALL(*key, HaveCheckedDisk())
         .Times(AtMost(1))
@@ skipping 231 matching lines @@
 
 TEST_F(SessionManagerTest, KeygenTest) {
   const char key_file_name[] = "foo.pub";
   ScopedTempDir tmpdir;
   ASSERT_TRUE(tmpdir.CreateUniqueTempDir());
   FilePath key_file_path(tmpdir.path().AppendASCII(key_file_name));
 
   int pid = fork();
   if (pid == 0) {
     execl("./keygen", "./keygen", key_file_path.value().c_str(), NULL);
-    exit(1);
+    exit(255);
   }
   int status;
   while (waitpid(pid, &status, 0) == -1 && errno == EINTR)
     ;
 
   LOG(INFO) << "exited waitpid. " << pid << "\n"
             << "  WIFSIGNALED is " << WIFSIGNALED(status) << "\n"
             << "  WTERMSIG is " << WTERMSIG(status) << "\n"
             << "  WIFEXITED is " << WIFEXITED(status) << "\n"
             << "  WEXITSTATUS is " << WEXITSTATUS(status);
 
-  ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
-  ASSERT_TRUE(file_util::PathExists(key_file_path));
+  EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
+  EXPECT_TRUE(file_util::PathExists(key_file_path));
 
   SystemUtils utils;
   int32 file_size = 0;
-  ASSERT_TRUE(utils.EnsureAndReturnSafeFileSize(key_file_path, &file_size));
-  ASSERT_GT(file_size, 0);
+  EXPECT_TRUE(utils.EnsureAndReturnSafeFileSize(key_file_path, &file_size));
+  EXPECT_GT(file_size, 0);
 }
 
 TEST_F(SessionManagerTest, SessionNotStartedCleanup) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   manager_->test_api().set_child_pid(0, kDummyPid);
 
   int timeout = 3;
   EXPECT_CALL(*(utils_.get()), kill(kDummyPid, getuid(), SIGKILL))
       .WillOnce(Return(0));
   EXPECT_CALL(*(utils_.get()), ChildIsGone(kDummyPid, timeout))
@@ skipping 94 matching lines @@
   EXPECT_CALL(*(utils_.get()), kill(kShouldNeverKillPid, getuid(), SIGTERM))
       .Times(0);
   EXPECT_CALL(*(utils_.get()), kill(kShouldNeverKillPid, getuid(), SIGABRT))
       .Times(0);
 
   MockUtils();
   manager_->test_api().CleanupChildren(kTimeout);
 }
 
 TEST_F(SessionManagerTest, StartSession) {
+  MockFactory<KeyFailUtil> factory;
+  NssUtil::set_factory(&factory);
+
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
 
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
   MockPrefStore* store = new MockPrefStore;
   ExpectStartSession(email, job, store);
   manager_->test_api().set_prefstore(store);
   manager_->StartSession(email, nothing, &out, NULL);
 }
 
 TEST_F(SessionManagerTest, StartSessionNew) {
+  MockFactory<KeyFailUtil> factory;
+  NssUtil::set_factory(&factory);
+
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
   MockPrefStore* store = new MockPrefStore;
   ExpectStartSessionUnowned(email, store);
   chromeos::glib::ScopedError error;
   EXPECT_EQ(TRUE, manager_->StartSession(email,
                                          nothing,
                                          &out,
                                          &chromeos::Resetter(&error).lvalue()));
@@ skipping 18 matching lines @@
       .Times(1);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kWhitelistChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   MockUtils();
 
   MockOwnerKey* key = new MockOwnerKey;
   MockPrefStore* store = new MockPrefStore;
   MockDevicePolicy* policy = new MockDevicePolicy;
-  ExpectStartSessionForOwner(email, key, store);
+  ExpectStartSessionForOwner(email, key, store, true);
   EXPECT_CALL(*policy, Persist())
       .WillOnce(Return(true));
 
   manager_->test_api().set_ownerkey(key);
   manager_->test_api().set_prefstore(store);
   manager_->test_api().set_policy(policy);
 
   manager_->StartSession(email, nothing, &out, NULL);
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   manager_->Run();
 }
 
 TEST_F(SessionManagerTest, StartOwnerSessionNoKeyNoRecover) {
   MockFactory<KeyFailUtil> factory;
   NssUtil::set_factory(&factory);
 
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
 
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-  EXPECT_CALL(*(utils_.get()),
-              SendSignalToChromium(chromium::kPropertyChangeCompleteSignal,
-                                   StrEq("success")))
-      .Times(1);
-  EXPECT_CALL(*(utils_.get()),
-              SendSignalToChromium(chromium::kWhitelistChangeCompleteSignal,
-                                   StrEq("success")))
-      .Times(1);
-  MockUtils();
-
   EXPECT_CALL(*mitigator_, Mitigate())
       .WillOnce(Return(false));
   MockOwnerKey* key = new MockOwnerKey;
   MockPrefStore* store = new MockPrefStore;
   MockDevicePolicy* policy = new MockDevicePolicy;
-  ExpectStartSessionForOwner(email, key, store);
+  ExpectStartSessionForOwner(email, key, store, false);
   EXPECT_CALL(*policy, Persist())
       .WillOnce(Return(true));
 
   manager_->test_api().set_ownerkey(key);
   manager_->test_api().set_prefstore(store);
   manager_->test_api().set_policy(policy);
 
   bool ret_code = manager_->StartSession(email, nothing, &out, NULL);
   EXPECT_FALSE(ret_code);
   EXPECT_EQ(ret_code, out);
@@ skipping 687 matching lines @@
 }
 
 TEST(SessionManagerTestStatic, GetArgLists3_InitialDashes) {
   const char* c_args[] = {"--", "a", "b", "c", NULL};
   std::vector<std::vector<std::string> > arg_lists = GetArgs(c_args);
   EXPECT_EQ(1, arg_lists.size());
   EXPECT_EQ(3, arg_lists[0].size());
 }
 
 }  // namespace login_manager