AU: Handle firmware update failure when booted from FW slot B.

postinstall_runner_action_unittest.cc

 // Copyright (c) 2010 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 <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
@@ skipping 13 matching lines @@
 namespace {
 gboolean StartProcessorInRunLoop(gpointer data) {
   ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
   processor->StartProcessing();
   return FALSE;
 }
 }  // namespace
 
 class PostinstallRunnerActionTest : public ::testing::Test {
  public:
-  void DoTest(bool do_losetup, bool do_err_script);
+  void DoTest(bool do_losetup, int err_code);
 };
 
 class PostinstActionProcessorDelegate : public ActionProcessorDelegate {
  public:
   PostinstActionProcessorDelegate()
       : loop_(NULL),
         code_(kActionCodeError),
         code_set_(false) {}
   void ProcessingDone(const ActionProcessor* processor,
                       ActionExitCode code) {
     ASSERT_TRUE(loop_);
     g_main_loop_quit(loop_);
   }
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
                        ActionExitCode code) {
     if (action->Type() == PostinstallRunnerAction::StaticType()) {
       code_ = code;
       code_set_ = true;
     }
   }
   GMainLoop* loop_;
   ActionExitCode code_;
   bool code_set_;
 };
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootSimpleTest) {
   ASSERT_EQ(0, getuid());
-  DoTest(true, false);
+  DoTest(true, 0);
 }
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootCantMountTest) {
   ASSERT_EQ(0, getuid());
-  DoTest(false, false);
+  DoTest(false, 0);
 }
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootErrScriptTest) {
   ASSERT_EQ(0, getuid());
-  DoTest(true, true);
+  DoTest(true, 1);
 }
 
-void PostinstallRunnerActionTest::DoTest(bool do_losetup, bool do_err_script) {
+TEST_F(PostinstallRunnerActionTest, RunAsRootFirmwareBErrScriptTest) {
+  ASSERT_EQ(0, getuid());
+  DoTest(true, 2);
+}
+
+void PostinstallRunnerActionTest::DoTest(bool do_losetup, int err_code) {
   ASSERT_EQ(0, getuid()) << "Run me as root. Ideally don't run other tests "
                          << "as root, tho.";
 
   const string mountpoint(string(utils::kStatefulPartition) +
                           "/au_destination");
 
   string cwd;
   {
     vector<char> buf(1000);
     ASSERT_EQ(&buf[0], getcwd(&buf[0], buf.size()));
@@ skipping 13 matching lines @@
   // mount it
   ASSERT_EQ(0, System(string("mount -o loop image.dat ") + mountpoint));
 
   // put a postinst script in
   string script = StringPrintf("#!/bin/bash\n"
                                "mount | grep au_postint_mount | grep ext2\n"
                                "if [ $? -eq 0 ]; then\n"
                                "  touch %s/postinst_called\n"
                                "fi\n",
                                cwd.c_str());
-  if (do_err_script) {
-    script = "#!/bin/bash\nexit 1";
+  if (err_code) {
+    script = StringPrintf("#!/bin/bash\nexit %d", err_code);
   }
   ASSERT_TRUE(WriteFileString(mountpoint + "/postinst", script));
   ASSERT_EQ(0, System(string("chmod a+x ") + mountpoint + "/postinst"));
 
   ASSERT_EQ(0, System(string("umount -d ") + mountpoint));
 
   ASSERT_EQ(0, System(string("rm -f ") + cwd + "/postinst_called"));
 
   // get a loop device we can use for the install device
   FILE* find_dev_cmd = popen("losetup -f", "r");
@@ skipping 32 matching lines @@
   processor.set_delegate(&delegate);
 
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   delegate.loop_ = loop;
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
   ASSERT_FALSE(processor.IsRunning());
 
   EXPECT_TRUE(delegate.code_set_);
-  EXPECT_EQ(do_losetup && !do_err_script, delegate.code_ == kActionCodeSuccess);
-  EXPECT_EQ(do_losetup && !do_err_script,
+  EXPECT_EQ(do_losetup && !err_code, delegate.code_ == kActionCodeSuccess);
+  EXPECT_EQ(do_losetup && !err_code,
             !collector_action.object().install_path.empty());
-  if (do_losetup && !do_err_script) {
+  if (do_losetup && !err_code) {
     EXPECT_TRUE(install_plan == collector_action.object());
   }
+  if (err_code == 2)
+    EXPECT_EQ(kActionCodePostinstallBootedFromFirmwareB, delegate.code_);
 
   struct stat stbuf;
   int rc = lstat((string(cwd) + "/postinst_called").c_str(), &stbuf);
-  if (do_losetup && !do_err_script)
+  if (do_losetup && !err_code)
     ASSERT_EQ(0, rc);
   else
     ASSERT_LT(rc, 0);
 
   if (do_losetup) {
     loop_releaser.reset(NULL);
   }
   ASSERT_EQ(0, System(string("rm -f ") + cwd + "/postinst_called"));
   ASSERT_EQ(0, System(string("rm -f ") + cwd + "/image.dat"));
 }
 
 // Death tests don't seem to be working on Hardy
 TEST_F(PostinstallRunnerActionTest, DISABLED_RunAsRootDeathTest) {
   ASSERT_EQ(0, getuid());
   PostinstallRunnerAction runner_action;
   ASSERT_DEATH({ runner_action.TerminateProcessing(); },
                "postinstall_runner_action.h:.*] Check failed");
 }
 
 }  // namespace chromeos_update_engine