2026-11-06 08:28:04 +00:00
from __future__ import annotations
2026-11-07 06:51:49 +00:00
import ast
import datetime
2026-11-06 08:28:04 +00:00
import json
2026-11-07 06:51:49 +00:00
import os
2026-11-13 09:32:39 +00:00
import shutil
import subprocess
2026-11-06 08:28:04 +00:00
import unittest
2026-11-13 09:32:39 +00:00
from pathlib import Path
2026-11-06 08:28:04 +00:00
from hub_case import HubCase
2026-11-13 09:32:39 +00:00
from hub_support import GIT_ENV , HUB , PAGE
2026-11-07 06:51:49 +00:00
GENERATED = datetime . datetime ( 2026 , 11 , 6 , 12 , tzinfo = datetime . UTC ) . timestamp ()
2026-11-13 09:32:39 +00:00
PKGMGR = shutil . which ( "pkgmgr" )
FIXTURE = Path ( __file__ ) . parent / "branch-tree.json"
2026-11-07 06:51:49 +00:00
def starts_git ( path ) -> list [ int ]:
lines = []
for node in ast . walk ( ast . parse ( path . read_text ( encoding = "utf-8" ))):
if isinstance ( node , ast . Constant ) and isinstance ( node . value , str ) and node . value . split ( " " )[ 0 ] in ( "git" , "/usr/bin/git" ):
lines . append ( node . lineno )
return lines
2026-11-06 08:28:04 +00:00
class TestHubTree ( HubCase ):
2026-11-07 06:51:49 +00:00
def test_tree_serves_the_pkgmgr_file_with_workers_and_reviews ( self ):
root = self . write_tree ()
demo , feature = f " { root } /repos/github.com/me/demo" , f " { root } /worktrees/github.com/me/demo/feature"
self . write_council ({ "rasci.json" : { "work/feature" : { "title" : "F" , "status" : "running" , "worker" : "Skills session" , "workdir" : feature }}})
self . tool ( "review_request" , { ** self . arguments ( "feat: tree" , "" , self . page ( "tree.html" , PAGE )), "worktree" : feature , "branch" : "feature" })
2026-11-06 08:28:04 +00:00
status , _ , body = self . get ( "/api/tree" )
self . assertEqual ( status , 200 , body )
data = json . loads ( body )
2026-11-07 06:51:49 +00:00
repos = { entry [ "path" ]: entry for entry in data [ "repos" ]}
self . assertEqual (( repos [ demo ][ "name" ], repos [ demo ][ "known" ], repos [ f " { root } /outside/elsewhere" ][ "known" ]), ( "github.com/me/demo" , True , False ))
self . assertEqual (( data [ "scanned" ], data [ "delete_ready" ], data [ "delete_reason" ]), ( GENERATED , False , "Secret Service locked" ))
branches = { entry [ "name" ]: entry for entry in repos [ demo ][ "branches" ]}
main = branches [ "main" ]
self . assertEqual (( main [ "upstream" ], main [ "ahead" ], main [ "behind" ], main [ "gone" ], main [ "state" ]), ( "origin/main" , 1 , 0 , False , "protected" ))
self . assertEqual (( branches [ "feature" ][ "state" ], branches [ "feature" ][ "reason" ]), ( "dirty" , "dirty: 1 paths" ))
trees = [( tree [ "path" ], tree [ "dirty" ], tree [ "untracked" ], tree [ "workers" ], tree [ "review" ]) for tree in main [ "worktrees" ] + branches [ "feature" ][ "worktrees" ]]
self . assertEqual ( trees , [( demo , False , 0 , [], None ), ( feature , True , 1 , [ "Skills" ], { "status" : "pending" , "gate" : "pass" , "title" : "feat: tree" })])
self . assertEqual ([( tree [ "path" ], tree [ "workers" ]) for tree in repos [ demo ][ "detached" ]], [( f " { root } /worktrees/github.com/me/demo/detached" , [])])
2026-11-06 08:28:04 +00:00
2026-11-13 09:32:39 +00:00
@unittest.skipUnless ( PKGMGR , "pkgmgr is not on PATH: the check that /api/tree serves a file pkgmgr branch tree wrote cannot run, install package-manager to cover 001 S12" )
def test_tree_serves_the_file_pkgmgr_branch_tree_wrote_for_a_fixture_repository_in_the_fields_of_the_fixture ( self ):
root = Path ( os . path . realpath ( self . outside )) / "pkgmgr"
home , origin , repo = root / "home" , root / "origin.git" , root / "repos" / "github.com" / "me" / "demo"
repo . mkdir ( parents = True )
self . git ( root , "init" , "--bare" , "-b" , "main" , str ( origin ))
self . git ( repo , "init" , "-b" , "main" )
self . git ( repo , "remote" , "add" , "origin" , str ( origin ))
( repo / ".git" / "info" / "exclude" ) . write_text ( ".worktrees/ \n " , encoding = "utf-8" )
( repo / "init.txt" ) . write_text ( "init \n " , encoding = "utf-8" )
self . git ( repo , "add" , "init.txt" )
self . git ( repo , "commit" , "-m" , "init" )
self . git ( repo , "switch" , "-c" , "feature/done" )
( repo / "done.txt" ) . write_text ( "done \n " , encoding = "utf-8" )
self . git ( repo , "add" , "done.txt" )
self . git ( repo , "commit" , "-m" , "done" )
self . git ( repo , "switch" , "main" )
self . git ( repo , "merge" , "--no-ff" , "-m" , "merge feature/done" , "feature/done" )
self . git ( repo , "push" , "-u" , "origin" , "main" )
opened = repo / ".worktrees" / "feature" / "open"
self . git ( repo , "worktree" , "add" , "-b" , "feature/open" , str ( opened ), "main" )
( opened / "loose.txt" ) . write_text ( "new \n " , encoding = "utf-8" )
config = home / ".config" / "pkgmgr" / "fixture.yml"
config . parent . mkdir ( parents = True )
config . write_text ( json . dumps ({ "directories" : { "repositories" : str ( root / "repos" )}, "repositories" : [{ "provider" : "github.com" , "account" : "me" , "repository" : "demo" , "directory" : str ( repo )}]}), encoding = "utf-8" )
env = {
"PATH" : os . environ [ "PATH" ], "HOME" : str ( home ), "LANG" : "C.UTF-8" , ** GIT_ENV , "DBUS_SESSION_BUS_ADDRESS" : f "unix:path= { root / 'no-bus' } " ,
"XDG_CACHE_HOME" : str ( home / ".cache" ), "XDG_STATE_HOME" : str ( home / ".local" / "state" ), "PKGMGR_TREE_FILE" : str ( self . tree_file ),
}
done = subprocess . run ([ PKGMGR , "branch" , "tree" , "--format" , "json" , "--output" , str ( self . tree_file )], cwd = root , env = env , capture_output = True , text = True , timeout = 300 , check = False )
self . assertEqual ( done . returncode , 0 , done . stderr [ - 2000 :])
written = json . loads ( self . tree_file . read_text ( encoding = "utf-8" ))
status , _ , body = self . get ( "/api/tree" )
self . assertEqual ( status , 200 , body )
data = json . loads ( body )
self . assertNotIn ( "error" , data , data )
self . assertEqual ( data [ "scanned" ], datetime . datetime . fromisoformat ( written [ "generated_at" ]) . timestamp ())
self . assertEqual ([( entry [ "path" ], entry [ "name" ], entry [ "known" ]) for entry in data [ "repos" ]], [( str ( repo ), "github.com/me/demo" , True )])
branches = { entry [ "name" ]: entry for entry in data [ "repos" ][ 0 ][ "branches" ]}
self . assertEqual ( sorted ( branches ), [ "feature/done" , "feature/open" , "main" ])
self . assertEqual (( branches [ "main" ][ "state" ], branches [ "feature/done" ][ "state" ], branches [ "feature/done" ][ "merged_by" ]), ( "protected" , "merged-clean" , "ancestor" ))
trees = [( tree [ "path" ], tree [ "dirty" ], tree [ "untracked" ]) for tree in branches [ "feature/open" ][ "worktrees" ]]
self . assertEqual ( trees , [( str ( opened ), True , 1 )])
fixture = json . loads ( FIXTURE . read_text ( encoding = "utf-8" ))
self . assertLessEqual ( set ( fixture ), set ( written ))
self . assertLessEqual ({ key for entry in fixture [ "repos" ] for key in entry }, set ( written [ "repos" ][ 0 ]))
self . assertLessEqual ({ key for entry in fixture [ "repos" ] for item in entry [ "items" ] for key in item }, { key for item in written [ "repos" ][ 0 ][ "items" ] for key in item })
2026-11-07 06:51:49 +00:00
def test_tree_reads_the_file_again_once_it_changes ( self ):
self . write_tree ()
self . assertEqual ( len ( json . loads ( self . get ( "/api/tree" )[ 2 ])[ "repos" ]), 2 )
data = json . loads ( self . tree_file . read_text ( encoding = "utf-8" ))
data [ "repos" ] = data [ "repos" ][: 1 ]
self . tree_file . write_text ( json . dumps ( data ), encoding = "utf-8" )
self . assertEqual ( len ( json . loads ( self . get ( "/api/tree" )[ 2 ])[ "repos" ]), 1 )
def test_a_missing_or_broken_file_answers_with_the_reason ( self ):
2026-11-06 08:28:04 +00:00
status , _ , body = self . get ( "/api/tree" )
self . assertEqual ( status , 200 , body )
2026-11-07 06:51:49 +00:00
self . assertEqual (( json . loads ( body )[ "repos" ], json . loads ( body )[ "scanned" ]), ([], None ))
2026-11-08 13:37:02 +00:00
for words in ( "no pkgmgr tree file" , "`pkgmgr branch tree`" , "release pkgmgr" ):
with self . subTest ( words = words ):
self . assertIn ( words , json . loads ( body )[ "error" ])
2026-11-07 06:51:49 +00:00
self . tree_file . write_text ( '{"repos": [{"path": "/x"}]}' , encoding = "utf-8" )
self . assertIn ( "unreadable" , json . loads ( self . get ( "/api/tree" )[ 2 ])[ "error" ])
2026-11-06 08:28:04 +00:00
2026-11-07 06:51:49 +00:00
def test_the_state_poll_beats_the_heartbeat_the_tree_timer_waits_for ( self ):
heartbeat = self . state / "tree-heartbeat"
self . assertFalse ( heartbeat . exists ())
self . snapshot ()
self . assertTrue ( heartbeat . is_file ())
os . utime ( heartbeat , ( 0 , 0 ))
self . snapshot ()
self . assertGreater ( heartbeat . stat () . st_mtime , 0 )
def test_no_module_of_the_orchestrator_starts_git ( self ):
sources = [ HUB / "server.py" , * sorted (( HUB / "kvb_orchestrator" ) . glob ( "*.py" ))]
found = { path . name : starts_git ( path ) for path in sources }
self . assertEqual ({ name : lines for name , lines in found . items () if lines }, {})
2026-11-06 09:58:57 +00:00
2026-11-06 08:28:04 +00:00
if __name__ == "__main__" :
unittest . main ()