@@ -2294,61 +2294,24 @@
 	(lambda ()
 	  (sqlite3:execute db "DELETE FROM test_steps WHERE test_id IN (SELECT id FROM tests WHERE state='DELETED' AND event_time<?);" targtime)
 	  (sqlite3:execute db "DELETE FROM test_data WHERE test_id IN (SELECT id FROM tests WHERE state='DELETED' AND event_time<?);" targtime)
 	  (sqlite3:execute db "DELETE FROM tests WHERE state='DELETED' AND event_time<?;" targtime)))))))
 
-;; set tests with state currstate and status currstatus to newstate and newstatus
-;; use currstate = #f and or currstatus = #f to apply to any state or status respectively
-;; WARNING: SQL injection risk. NB// See new but not yet used "faster" version below
-;;
-;;  AND NOT (item_path='' AND testname in (SELECT DISTINCT testname FROM tests WHERE testname=? AND item_path != ''));")))
-;;  (debug:print 0 *default-log-port* "QRY: " qry)
-;;  (db:delay-if-busy)
-;;
-;; NB// This call only operates on toplevel tests. Consider replacing it with more general call
-;;
-(define (db:set-tests-state-status dbstruct run-id testnames currstate currstatus newstate newstatus)
-  (let ((test-ids '()))
-    (for-each
-     (lambda (testname)
-       (let ((qry (conc "UPDATE tests SET state=?,status=? WHERE "
-			(if currstate  (conc "state='" currstate "' AND ") "")
-			(if currstatus (conc "status='" currstatus "' AND ") "")
-			" run_id=? AND testname LIKE ?;"))
-	     (test-id (db:get-test-id dbstruct run-id testname "")))
-	 (db:with-db
-	  dbstruct
-	  run-id
-	  #t
-	  (lambda (dbdat db)
-	    (sqlite3:execute db qry
-			     (or newstate  currstate "NOT_STARTED")
-			     (or newstatus currstate "UNKNOWN")
-			     run-id testname)))
-	 (if test-id
-	     (begin
-	       (set! test-ids (cons test-id test-ids))
-	       (mt:process-triggers dbstruct run-id test-id newstate newstatus)))))
-     testnames)
-    test-ids))
-
 ;; ;; speed up for common cases with a little logic
 ;; ;; NB// Ultimately this will be deprecated in deference to mt:test-set-state-status-by-id
 ;;
 ;;      NOTE: run-id is not used
 ;; ;;
 (define (db:test-set-state-status dbstruct run-id test-id newstate newstatus newcomment)
-  (let* ((hash-key (cons run-id test-id)))
-    (hash-table-delete! *db:get-test-info-by-id-cache* hash-key)
-    (hash-table-delete! *db:get-test-state-status-by-id-cache*hash-key))
   (db:with-db
    dbstruct
    run-id #t
    (lambda (dbdat db)
      (db:test-set-state-status-db db run-id test-id newstate newstatus newcomment))))
 
 (define (db:test-set-state-status-db db run-id test-id newstate newstatus newcomment)
+  ;; clear cache after this, I think that makes sense
   (cond
    ((and newstate newstatus newcomment)
     (sqlite3:execute db "UPDATE tests SET state=?,status=?,comment=? WHERE id=?;" newstate newstatus newcomment ;; (sdb:qry 'getid newcomment)
 		     test-id))
    ((and newstate newstatus)
@@ -2357,10 +2320,13 @@
     (if newstate   (sqlite3:execute db "UPDATE tests SET state=?   WHERE id=?;" newstate   test-id))
     (if newstatus  (sqlite3:execute db "UPDATE tests SET status=?  WHERE id=?;" newstatus  test-id))
     (if newcomment (sqlite3:execute db "UPDATE tests SET comment=? WHERE id=?;" newcomment ;; (sdb:qry 'getid newcomment)
 				    test-id))))
   ;; (mt:process-triggers dbstruct run-id test-id newstate newstatus)) ;; NOTE: Moved into calling function
+  (let* ((hash-key (cons run-id test-id)))
+    (hash-table-delete! *db:get-test-info-by-id-cache* hash-key)
+    (hash-table-delete! *db:get-test-state-status-by-id-cache* hash-key))
   )
 
 ;; NEW BEHAVIOR: Count tests running in all runs!
 ;;
 (define (db:get-count-tests-running dbstruct run-id) ;; fastmode)
@@ -2645,11 +2611,11 @@
 	      db
 	      ;; (db:get-cache-stmth dbdat db
 	      ;; 		    (conc "SELECT " db:test-record-qry-selector " FROM tests WHERE id=? AND run_id=?;"))
 	      (conc "SELECT " db:test-record-qry-selector " FROM tests WHERE id=? AND run_id=?;")
 	      test-id run-id)
-	     (hash-table-set! *db:get-test-info-by-id-cache* hash-key res)
+	     (hash-table-set! *db:get-test-info-by-id-cache* hash-key (cons (current-seconds) res))
 	     res))))))
 
 (define *db:get-test-state-status-by-id-cache* (make-hash-table))
 
 ;; Get test state, status using test_id
@@ -2692,25 +2658,10 @@
 	db
 	(conc "SELECT " db:test-record-qry-selector " FROM tests WHERE id in ("
 	      (string-intersperse (map conc test-ids) ",") ");"))
        res))))
 
-;; try every second until tries times proc
-;;
-(define (db:keep-trying-until-true proc params tries)
-  (let* ((res (apply proc params)))
-    (if res
-	res
-	(if (> tries 0)
-	    (begin
-	      (thread-sleep! 1)
-	      (db:keep-trying-until-true proc params (- tries 1)))
-	    (begin
-	      ;; (debug:print-info 0 *default-log-port* "proc never returned true, params="params)
-	      (print"db:keep-trying-until-true proc never returned true, proc = " proc " params =" params " tries = " tries)
-	      #f)))))
-  
 (define (db:get-test-info dbstruct run-id test-name item-path)
   (let* ((test-id (db:get-test-id dbstruct run-id test-name item-path)))
     (db:get-test-info-by-id dbstruct run-id test-id)))
 ;;  (db:with-db
 ;;   dbstruct
@@ -3146,25 +3097,10 @@
            (print-call-chain (current-error-port))
 	   msg))) ;; crude reply for when things go awry
     ((zmq nmsg)(with-input-from-string msg (lambda ()(deserialize))))
     (else msg))) ;; rpc
 
-;; ; This is to be the big daddy call NOPE: Replaced by db:set-state-status-and-roll-up-items
-;; ;
-;; define (db:test-set-state-status dbstruct run-id test-id state status msg)
-;;  (let ((dbdat  (db:get-subdb dbstruct run-id)))
-;;    (if (member state '("LAUNCHED" "REMOTEHOSTSTART"))
-;; 	(db:general-call dbdat 'set-test-start-time (list test-id)))
-;;    ;; (if msg
-;;    ;; 	(db:general-call dbdat 'state-status-msg (list state status msg test-id))
-;;    ;; 	(db:general-call dbdat 'state-status     (list state status test-id)))
-;;    (db:set-state-status-and-roll-up-items dbstruct run-id test-id #f state status msg)
-;;    ;; process the test_data table
-;;    (if (and test-id state status (equal? status "AUTO")) 
-;; 	(db:test-data-rollup dbstruct run-id test-id status))
-;;    (mt:process-triggers dbstruct run-id test-id state status)))
-
 ;; state is the priority rollup of all states
 ;; status is the priority rollup of all completed statesfu
 ;;
 ;; if test-name is an integer work off that as test-id instead of test-name test-path
 ;;
@@ -3199,17 +3135,18 @@
                db
                (lambda ()
                  ;; NB// Pass the db so it is part fo the transaction
                  (db:test-set-state-status-db db run-id test-id state status comment) ;; this call sets the item state/status
                  (if (not (equal? item-path "")) ;; only roll up IF incoming test is an item
-                     (let* ((state-status-counts (db:get-all-state-status-counts-for-test db run-id test-name item-path state status)) ;; item-path is used to exclude current state/status of THIS test
+                     (let* ((state-status-counts (db:get-all-state-status-counts-for-test-db db run-id test-name item-path state status)) ;; item-path is used to exclude current state/status of THIS test
 			    (state-statuses      (db:roll-up-rules state-status-counts state status))
                             (newstate            (car state-statuses))
                             (newstatus           (cadr state-statuses)))
 		       (set! new-state-eh newstate)
 		       (set! new-status-eh newstatus)
-                       (debug:print 4 *default-log-port* "BB> tl-test-id="tl-test-id" ; "test-name":"item-path" newstate="newstate" newstatus="newstatus" len(sscs)="(length state-status-counts)  " state-status-counts: "
+                       (debug:print 4 *default-log-port* "BB> tl-test-id="tl-test-id" ; "test-name":"item-path
+				    " newstate="newstate" newstatus="newstatus" len(sscs)="(length state-status-counts)  " state-status-counts: "
 				    (apply conc
 					   (map (lambda (x)
 						  (conc
                      				   (with-output-to-string (lambda () (pp (dbr:counts->alist x)))) " | "))
 						state-status-counts))); end debug:print
@@ -3312,15 +3249,20 @@
   (db:with-db
    dbstruct #f #f
    (lambda (dbdat db)
      (db:get-all-state-status-counts-for-run-db dbdat db run-id))))
 
-;; BBnote: db:get-all-state-status-counts-for-test returns dbr:counts object aggregating state and status of items of a given test, *not including rollup state/status*
+(define (db:get-all-state-status-counts-for-test dbstruct run-id test-name item-path item-state-in item-status-in)
+  (db:with-db
+   dbstruct run-id #f
+   (lambda (dbdat db)
+     (db:get-all-state-status-counts-for-test-db db run-id test-name item-path item-state-in item-status-in))))
+     ;; BBnote: db:get-all-state-status-counts-for-test returns dbr:counts object aggregating state and status of items of a given test, *not including rollup state/status*
 ;;
 ;; NOTE: This is called within a transaction
 ;;
-(define (db:get-all-state-status-counts-for-test db run-id test-name item-path item-state-in item-status-in)
+(define (db:get-all-state-status-counts-for-test-db db run-id test-name item-path item-state-in item-status-in)
   (let* ((test-info   (db:get-test-info-db db run-id test-name item-path))
          (item-state  (or item-state-in (db:test-get-state test-info))) 
          (item-status (or item-status-in (db:test-get-status test-info)))
          (other-items-count-recs (sqlite3:map-row
                                   (lambda (state status count)