You could do ./$TEMPDIR or better yet, just check it is still defined and non-empty.

Or even betterer yet, don’t use Bash for something that you want to be robust. That’s like trying to build a life vest out of knives.

You could check if TEMPDIR is set and exists as a directory but LGTM.

This might go beyond what you were asking for, but I’m always more comfortable handling file paths, deletions and errors in Python.

#!/usr/bin/env python3

import shutil
from pathlib import Path
from tempfile import TemporaryDirectory

# Refuse to run without Python's symlink-resistant cleanup.
if not getattr(shutil.rmtree, "avoids_symlink_attacks", False):
    raise RuntimeError("Symlink-resistant cleanup is unavailable")

with TemporaryDirectory(prefix="test-run-", dir="/tmp") as name:
    tests = Path(name) / "tests"
    tests.mkdir(mode=0o700)
    print(f"Created {str(tests)!r}", flush=True)

    try:
        # Put your test code here.
        (tests / "example.txt").write_text(
            "temporary data\n", encoding="utf-8"
        )
    finally:
        print(f"Cleaning {name!r}", flush=True)

# The entire temporary directory has now been removed.

What is your specific use case for this? Is it you using rm -rf, and you’re afraid you’ll use it irresponsibly, or are you a sysadmin setting up an environment for someone else?

In what way are file permissions not sufficient?

good usecase for find … -delete. Test it out on a trial directory and it’s should work. You can set -maxdepth if you are concerned about sumlinks… but i bet there is an option to not follow symlinks

However, I am very, very afraid of doing rm -rf in context of variables, in case the variable happens to become empty due to user error (or later changes in script).

I get the feeling that either there’s some missing info, a misunderstanding on my part, or there might be a simpler way to do things. Is $TEMPDIR changing a reasonable case to handle? Can you change your script design to make this impossible instead? (Like replacing a source with a script execution?)

If the snippet is just boilerplate at the top of numerous scripts, I’d do set -u, rm -rf "${TEMPDIR}" on exit (ideally defined in a common setup script/function), and just avoid assigning to the var later in the script. In terms of defensive programming, anything extra is added complexity that will only make an error more likely imo. You could rename TEMPDIR to something like TEST_ROOT if you’re concerned about the variable name being accidentally used again, but no amount of trap logic is going to make a future programming error impossible.

With Bash, you’ll only ever get “good enough” solutions. Even with your current setup, it’s susceptible to a race condition where another process adds to the TEMPDIR directory some other way during the script, and potentially even recreates tests after you delete it and before you remove the parent directory.

Usually with Bash, the most readable solution is the best. I’d recommend a simple test for $TEMPDIR existing before a simple rm -rf "$TEMPDIR".

However, I am very, very afraid of doing rm -rf in context of variables, in case the variable happens to become empty due to user error (or later changes in script).

In this case, just test for this? Test that the variable is not empty and that the directory exists, then rm -rf the directory. No need to overcomplicate it.

A silly idea if you want to remove rm entirely:

fallocate a file (or use dd) Mkfs the file to your favorite filesystem Loop or FUSE mount the file somewhere

Then when you want to clear the data: unmount, format, and remount the file.

Added benefit of testing no more disk space conditions easily.

One workaround is that you could use the trash-cli command, which moves files to the trash directory instead of truly deleting them.

But this only works on (usually desktop) systems that have a trash. And usually trash is set to autodelete items when it grows too big. I also am not sure if it’s always preinstalled.

But it would be a neat workaround for worrying about permanently deleting files.