crash-reporter: Capture and send recent update_engine logs when it crashes

user_collector_test.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 <unistd.h>
 
 #include "base/file_util.h"
 #include "crash-reporter/system_logging_mock.h"
 #include "crash-reporter/user_collector.h"
 #include "crash-reporter/test_helpers.h"
@@ skipping 14 matching lines @@
 }
 
 class UserCollectorTest : public ::testing::Test {
   void SetUp() {
     s_crashes = 0;
     collector_.Initialize(CountCrash,
                           kFilePath,
                           IsMetrics,
                           &logging_,
                           false);
+    file_util::Delete(FilePath("test"), true);
     mkdir("test", 0777);
     collector_.set_core_pattern_file("test/core_pattern");
+    collector_.set_core_pipe_limit_file("test/core_pipe_limit");
     pid_ = getpid();
   }
  protected:
   void ExpectFileEquals(const char *golden,
                         const char *file_path) {
     std::string contents;
     EXPECT_TRUE(file_util::ReadFileToString(FilePath(file_path),
                                             &contents));
     EXPECT_EQ(golden, contents);
   }
 
   SystemLoggingMock logging_;
   UserCollector collector_;
   pid_t pid_;
 };
 
 TEST_F(UserCollectorTest, EnableOK) {
   ASSERT_TRUE(collector_.Enable());
   ExpectFileEquals("|/my/path --signal=%s --pid=%p", "test/core_pattern");
+  ExpectFileEquals("4", "test/core_pipe_limit");
   ASSERT_EQ(s_crashes, 0);
   ASSERT_NE(logging_.log().find("Enabling user crash handling"),
             std::string::npos);
 }
 
-TEST_F(UserCollectorTest, EnableNoFileAccess) {
+TEST_F(UserCollectorTest, EnableNoPatternFileAccess) {
   collector_.set_core_pattern_file("/does_not_exist");
   ASSERT_FALSE(collector_.Enable());
   ASSERT_EQ(s_crashes, 0);
   ASSERT_NE(logging_.log().find("Enabling user crash handling"),
             std::string::npos);
   ASSERT_NE(logging_.log().find("Unable to write /does_not_exist"),
             std::string::npos);
 }
 
+TEST_F(UserCollectorTest, EnableNoPipeLimitFileAccess) {
+  collector_.set_core_pipe_limit_file("/does_not_exist");
+  ASSERT_FALSE(collector_.Enable());
+  ASSERT_EQ(s_crashes, 0);
+  // Core pattern should not be written if we cannot access the pipe limit
+  // or otherwise we may set a pattern that results in infinite recursion.
+  ASSERT_FALSE(file_util::PathExists(FilePath("test/core_pattern")));
+  ASSERT_NE(logging_.log().find("Enabling user crash handling"),
+            std::string::npos);
+  ASSERT_NE(logging_.log().find("Unable to write /does_not_exist"),
+            std::string::npos);
+}
+
 TEST_F(UserCollectorTest, DisableOK) {
   ASSERT_TRUE(collector_.Disable());
   ExpectFileEquals("core", "test/core_pattern");
   ASSERT_EQ(s_crashes, 0);
   ASSERT_NE(logging_.log().find("Disabling user crash handling"),
             std::string::npos);
 }
 
 TEST_F(UserCollectorTest, DisableNoFileAccess) {
   collector_.set_core_pattern_file("/does_not_exist");
@@ skipping 178 matching lines @@
     EXPECT_EQ(expectations[i].exists,
               file_util::PathExists(
                   container_path.Append(expectations[i].name)));
   }
 }
 
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }