Fix delete_directory_recursive not deleting directories sometimes

If a test creates a non-empty untraversable directory
(test_configuration_loader.making_parent_dir_unreadable_is_detected_as_change
is an example), delete_directory_recursive fails to delete the
directory. This leaves /tmp cluttered with quick-lint-js test junk.

Make delete_directory_recursive delete untraversable directories by
making them traversable with chmod().

Author: strager

src/temporary-directory.cpp

@@ -95,9 +95,16 @@ void delete_directory_recursive(const std::string &path) {
   }
   while (::FTSENT *entry = ::fts_read(fts)) {
     switch (entry->fts_info) {
-    case FTS_D:
-      // Do nothing. We handle FTS_DP (post-order) instead.
+    case FTS_D: {
+      // Make sure the directory is traversable before traversing.
+      int rc = ::chmod(entry->fts_accpath, 0700);
+      if (rc != 0) {
+        std::fprintf(stderr,
+                     "warning: failed to change permissions for %s: %s\n",
+                     entry->fts_accpath, std::strerror(errno));
+      }
       break;
+    }
 
     case FTS_DP: {
       int rc = ::rmdir(entry->fts_accpath);

test/CMakeLists.txt

@@ -77,6 +77,7 @@ quick_lint_js_add_executable(
   test-pipe-writer.cpp
   test-result.cpp
   test-string-view.cpp
+  test-temporary-directory.cpp
   test-text-error-reporter.cpp
   test-translation.cpp
   test-uri.cpp

test/quick-lint-js/file-matcher.h

@@ -23,6 +23,9 @@
 #define EXPECT_SAME_FILE(path_a, path_b) \
   EXPECT_PRED_FORMAT2(::quick_lint_js::assert_same_file, path_a, path_b)
 
+#define EXPECT_FILE_DOES_NOT_EXIST(path) \
+  EXPECT_PRED_FORMAT1(::quick_lint_js::assert_file_does_not_exist, path)
+
 namespace quick_lint_js {
 inline ::testing::AssertionResult assert_same_file(const char* lhs_expr,
                                                    const char* rhs_expr,
@@ -88,6 +91,43 @@ inline ::testing::AssertionResult assert_same_file(
     const std::string& rhs_path) {
   return assert_same_file(lhs_expr, rhs_expr, lhs_path.c_str(), rhs_path);
 }
+
+inline ::testing::AssertionResult assert_file_does_not_exist(const char* expr,
+                                                             const char* path) {
+  bool exists;
+#if QLJS_HAVE_STD_FILESYSTEM
+  exists = std::filesystem::exists(std::filesystem::path(path));
+#elif QLJS_HAVE_SYS_STAT_H
+  struct ::stat s;
+  if (::stat(path, &s) == 0) {
+    exists = true;
+  } else {
+    switch (errno) {
+    case ENOENT:
+      exists = false;
+      break;
+    default:
+      return ::testing::AssertionFailure()
+             << "checking for existance of " << expr << " (" << path
+             << ") failed: " << std::strerror(errno);
+    }
+  }
+#else
+#error "Unsupported platform"
+#endif
+  if (exists) {
+    return ::testing::AssertionFailure()
+           << expr << " (" << path << ") should not exist but it does";
+  } else {
+    return ::testing::AssertionSuccess();
+  }
+}
+
+inline ::testing::AssertionResult assert_file_does_not_exist(
+    const char* expr, const std::string& path) {
+  return assert_file_does_not_exist(expr, path.c_str());
+}
+
 }
 
 #endif

test/test-temporary-directory.cpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2020  Matthew "strager" Glazar
+// See end of file for extended copyright information.
+
+#include <cerrno>
+#include <cstring>
+#include <gtest/gtest.h>
+#include <quick-lint-js/file-matcher.h>
+#include <quick-lint-js/file.h>
+#include <quick-lint-js/temporary-directory.h>
+#include <string>
+
+#if QLJS_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+namespace quick_lint_js {
+namespace {
+#if QLJS_HAVE_UNISTD_H
+TEST(test_temporary_directory, delete_directory_containing_unwritable_file) {
+  std::string temp_dir = make_temporary_directory();
+  std::string sub_dir = temp_dir + "/subdir";
+  create_directory(sub_dir);
+  std::string unwritable_file = sub_dir + "/unwritable";
+  write_file(unwritable_file, u8"unwritable file");
+  EXPECT_EQ(::chmod(unwritable_file.c_str(), 0000), 0)
+      << "failed to make " << unwritable_file
+      << " inaccessible: " << std::strerror(errno);
+
+  delete_directory_recursive(sub_dir);
+
+  EXPECT_FILE_DOES_NOT_EXIST(unwritable_file);
+  EXPECT_FILE_DOES_NOT_EXIST(sub_dir);
+}
+
+TEST(test_temporary_directory,
+     delete_directory_containing_non_empty_untraversable_directory) {
+  std::string temp_dir = make_temporary_directory();
+  std::string sub_dir = temp_dir + "/sub_dir";
+  create_directory(sub_dir);
+  std::string untraversable_dir = sub_dir + "/untraversable_dir";
+  create_directory(untraversable_dir);
+  std::string unfindable_file = untraversable_dir + "/unfindable_file";
+  write_file(unfindable_file, u8"can't see me!");
+  EXPECT_EQ(::chmod(untraversable_dir.c_str(), 0600), 0)
+      << "failed to make " << untraversable_dir
+      << " untraversable: " << std::strerror(errno);
+
+  delete_directory_recursive(sub_dir);
+
+  EXPECT_FILE_DOES_NOT_EXIST(unfindable_file);
+  EXPECT_FILE_DOES_NOT_EXIST(untraversable_dir);
+  EXPECT_FILE_DOES_NOT_EXIST(sub_dir);
+}
+#endif
+}
+}
+
+// quick-lint-js finds bugs in JavaScript programs.
+// Copyright (C) 2020  Matthew "strager" Glazar
+//
+// This file is part of quick-lint-js.
+//
+// quick-lint-js is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// quick-lint-js is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with quick-lint-js.  If not, see <https://www.gnu.org/licenses/>.