tests: stop leaking temporary directories into /tmp

Reported as the machine filling its RAM. It was these: on that machine
/tmp is a tmpfs, so every directory left behind is memory that never
comes back, and free's "shared" column moved by the same 2.3 GB that
deleting them recovered.

Three scripts created a workspace per run, or per case, and removed
none of it:

  tests/verify/run_tests.py    one for the dialog build, one for the
                               testrt oracle, and ONE PER FIXTURE for
                               the code oracle -- each holding a real
                               Gaussian scratch directory
  tests/parsers/run_tests.py   one per case, 1542 of them
  tools/modiagram/frommopac.py one per invocation, 749 of them

Together, 252 directories holding 2.0 GB, plus eight and a half
thousand smaller ones. A suite that eats the machine it runs on gets
turned off, which costs more than the leak.

Each now registers its own cleanup at exit, so an early return or a
failed assertion cannot skip it. tests/symmetry, tests/e2e,
tests/dialogs and tests/parsers/expt.py already removed theirs.

Verified by running every suite back to back: nine temp entries
before, nine after.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EFMUNbw2UpRPmgsqviAowb

Author: andy

tests/parsers/eccejobmonitor_sim.py

@@ -40,6 +40,8 @@
   finished output file in one pass.
 """
 
+import shutil
+import atexit
 import os
 import re
 import subprocess
@@ -497,7 +499,11 @@ def run_parser(script_dir, entry, block, parse_args=DEFAULT_PARSE_ARGS,
     # Run in a scratch directory, never in scripts/parsers: the real client
     # runs these in the job's own temp dir, and some scripts write side files
     # there (nwchem.symlab writes "$key/parseSym", with $key = argv[1] = '.').
-    cwd = workdir or tempfile.mkdtemp(prefix='ecce-parsertest-')
+    cwd = workdir
+    if not cwd:
+        #  Ours to clean up; a caller's own workdir is not.
+        cwd = tempfile.mkdtemp(prefix='ecce-parsertest-')
+        atexit.register(shutil.rmtree, cwd, True)
     proc = subprocess.run(argv, input=block.text, capture_output=True,
                           text=True, timeout=timeout, cwd=cwd, env=env)
     return proc.stdout, proc.stderr, proc.returncode

tests/parsers/run_tests.py

@@ -19,6 +19,8 @@
 Exit status is 0 only if every check passed.
 """
 
+import shutil
+import atexit
 import argparse
 import re
 import difflib
@@ -224,7 +226,11 @@ def run_case(case, res, verbose=False):
                  % (case['name'], ' and '.join('[%s]' % p for p in pair)))
 
     # run the real parser scripts, in a scratch dir (some write side files)
+    #  Removed at exit: on a machine where /tmp is a tmpfs every
+    #  directory left behind is RAM that never comes back, and a
+    #  suite that runs often leaves thousands.
     workdir = tempfile.mkdtemp(prefix='ecce-parsertest-%s-' % case['name'])
+    atexit.register(shutil.rmtree, workdir, True)
     report = []
     emitted = {}          # parse type -> list of (block, records)
     for entry in desc.live_entries():

tests/verify/run_tests.py

@@ -37,6 +37,7 @@
 """
 
 import argparse
+import atexit
 import os
 import re
 import subprocess
@@ -183,8 +184,15 @@ def dialog_smoke(verbose):
         if not which(tool):
             return (False, True, "no %s" % tool)
 
+    #  CLEANED UP, ALWAYS. On the reporting machine /tmp is a tmpfs, so
+    #  every directory left here is RAM that never comes back: 252 of
+    #  them across a day of runs held 2 GB and pushed the machine into
+    #  swap. A test that leaks its workspace is a test that gets
+    #  turned off.
+    import shutil
     import tempfile
     work = tempfile.mkdtemp(prefix="ecce-verify-smoke")
+    atexit.register(shutil.rmtree, work, True)
     binary = os.path.join(work, "dialog_smoke")
     calced = os.path.join(ROOT, os.pardir, "src", "apps", "calced")
 
@@ -297,9 +305,11 @@ def testrt_agreement(verbose):
     if not testrt:
         return (False, 0, 0)
 
+    import shutil
     import tempfile
     failures, checked = 0, 0
     work = tempfile.mkdtemp(prefix="ecce-testrt")
+    atexit.register(shutil.rmtree, work, True)
 
     for fixture, code, _atoms, expected in CASES:
         if not code.startswith("Gaussian"):
@@ -497,6 +507,7 @@ def code_rejects(code, path, work):
 
 def codes_agreement(verbose):
     """Returns (ran, failures, checked)."""
+    import shutil
     import tempfile
     failures, checked = 0, 0
 
@@ -508,7 +519,12 @@ def codes_agreement(verbose):
             continue
 
         work = tempfile.mkdtemp(prefix="ecce-oracle")
-        refused = code_rejects(code, path, work)
+        try:
+            refused = code_rejects(code, path, work)
+        finally:
+            #  A Gaussian run leaves its scratch here, so this is the
+            #  worst of the leaks: one directory per fixture per run.
+            shutil.rmtree(work, True)
         if refused is None:
             continue
         checked += 1

tools/modiagram/frommopac.py

@@ -7,10 +7,11 @@
 This is the fastest way to get a real spectrum for a molecule that has
 no ECCE calculation on disk.
 """
-import os, re, subprocess, sys, tempfile
+import atexit, os, re, shutil, subprocess, sys, tempfile
 
 def run(name, atoms, charge=0, keywords="PM7 1SCF VECTORS ALLVEC"):
     work = tempfile.mkdtemp(prefix="modiag-")
+    atexit.register(shutil.rmtree, work, True)
     mop = os.path.join(work, name + ".mop")
     head = keywords + (" CHARGE=%d" % charge if charge else "")
     lines = [head, name, ""]