summaryrefslogtreecommitdiff
path: root/test/fs.py
diff options
context:
space:
mode:
Diffstat (limited to 'test/fs.py')
-rw-r--r--test/fs.py1991
1 files changed, 2 insertions, 1989 deletions
diff --git a/test/fs.py b/test/fs.py
index c5dd6234..a2b67cbc 100644
--- a/test/fs.py
+++ b/test/fs.py
@@ -113,11 +113,6 @@ def session(binary, root, name, *options, socket_name=None, file=None, tty=False
assert not reader.is_alive(), 'terminal reader did not stop'
-def newest(client):
- """The newest pane's serial: /index is ordered by serial."""
- return int(client.read('/index').splitlines()[-1].split()[0])
-
-
def new_pane(client, contents):
"""An open of /pane/new makes a pane; the read names it."""
serial = int(client.read('/pane/new'))
@@ -126,1993 +121,11 @@ def new_pane(client, contents):
return serial
-def look(client, path, source=None):
- """A right click on `path` from a pane (a fresh scratch by default)."""
- serial = source if source is not None else new_pane(client, b'')
- client.write(f'/pane/{serial}/look', f'{path}\n'.encode())
- results = [int(row) for row in client.read('/look').split()]
- assert len(results) == 1 and results[0] != serial, (path, results)
- # The scratch it looked from goes: a column holds only so many panes,
- # each its tag and two rows.
- if source is None:
- client.remove(f'/pane/{serial}')
- return results[0]
-
-
def execute(client, serial, command):
"""A middle click on `command` from a pane."""
client.write(f'/pane/{serial}/exec', f'{command}\n'.encode())
-def execute_refused(client, serial, command, words):
- """A middle click on a builtin that fails: the write fails, saying why."""
- try:
- execute(client, serial, command)
- except OSError as why:
- assert words in str(why), (command, why)
- return
- raise AssertionError(f'{command!r} was taken')
-
-
-def walk_tree(client, path='/', skip=('/log', '/os', '/screen')):
- """Stat every entry below `path`, as `find` does, without opening anything."""
- seen = []
- for name in client.list(path):
- child = (path.rstrip('/') + '/' + name)
- info = client.stat(child)
- seen.append((child, info))
- if info['dir'] and child not in skip:
- seen.extend(walk_tree(client, child, skip))
- return seen
-
-
-def discovery(binary, embedded=False):
- with tempfile.TemporaryDirectory(prefix='pardes-discovery-') as directory:
- root = Path(directory)
- with session(binary, root, 'discovery') as (client, address):
- top = client.list('/')
- # A set: which files the root holds, not the order a listing gives.
- assert set(top) - {'src', 'shaders'} == {'README', 'index', 'status', 'focus', 'ctl', 'commands', 'recent',
- 'look', 'exec', 'pager', 'log', 'screen', 'listeners', 'layout', 'tag', 'tagexec',
- 'pane', 'col', 'os'}, top
- assert 'self' not in top and 'cons' not in top and 'new' not in top, top
- assert ('src' in top) == embedded, (top, embedded)
- before = client.read('/index')
- guide = client.read('/README')
- assert guide.count(b'\n') <= 45 and b'Msg hello' in guide and b'pane/new' in guide, guide
- assert client.stat('/README')['length'] == len(guide)
- # ls/stat/find over the whole tree, without opening, creates nothing.
- seen = walk_tree(client)
- names = {path for path, _ in seen}
- assert {'/index', '/status', '/look', '/exec', '/log', '/pane/1', '/pane/1/body',
- '/pane/1/name', '/pane/1/sel', '/pane/1/ctl', '/pane/1/tag', '/pane/1/event',
- '/pane/1/dot', '/pane/1/limit', '/pane/1/dirty', '/pane/1/mark',
- '/pane/1/scroll', '/pane/1/look', '/pane/1/exec'} <= names, sorted(names)
- assert '/pane/1/pty' not in names, 'the fixture file pane grew a pty/'
- assert not any(name.startswith('/self') or name.endswith('/rdsel') or name.endswith('/wrsel')
- for name in names), sorted(names)
- for path, info in seen:
- assert info['mode'] in (0o755, 0o644, 0o666, 0o444, 0o222, 0o555), (path, info)
- assert info['mtime'] > 0, (path, info)
- assert client.read('/index') == before, 'browsing created a pane'
- assert client.stat('/index')['length'] == len(before) > 0
- index = client.stat('/index')
- assert index['mode'] == 0o444 and client.stat('/status')['mode'] == 0o444
- assert client.stat('/exec')['mode'] == 0o666
- assert client.stat('/pane/1/body')['mode'] == 0o666 and client.stat('/pane')['mode'] == 0o755
- # A range file reads the pair it takes; a flag file reads 0 or 1.
- assert client.stat('/pane/1/addr')['length'] == 24
- assert client.stat('/pane/1/limit')['length'] == 0
- assert client.read('/pane/1/dirty') == b'0\n'
- assert client.read('/pane/1/scroll') == b'1\n'
- fixture = int(before.split()[0])
- assert before.split()[1:3] == [b'text', b'0'] and before.rsplit(b' ', 1)[0].endswith(b'/discovery.txt'), before
- # /status reports the editor; /exec has nothing to report yet.
- status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
- assert int(status['pid']) > 0 and status['version'] and int(status['panes']) >= 1, status
- assert client.read('/exec') == b''
- # An open of /pane/new makes a pane and the read names it; each
- # open makes another. A stat makes none, which is why new can be
- # listed at all: ls -l stats every name a listing gave it.
- # /log answers the recent past and ends; `follow` written to the
- # same open makes its reads past that wait for new records.
- log = client.open('/log', 2)
- frozen = len(client.read_fid(log))
- client.rpc(118, struct.pack('<IQI', log, 0, 7) + b'follow\n')
- first = int(client.read('/pane/new'))
- assert first == newest(client)
- second = int(client.read('/pane/new'))
- assert first != second and first != fixture, (first, second)
- assert 'new' in client.list('/pane'), 'new should be visible to ls'
- client.stat('/pane/new')
- assert newest(client) == second, 'a stat of new made a pane'
- # What the editor said is in the stream too.
- def pane_event():
- while (record := client.read_fid(log, frozen)).startswith((b'msg ', b'err ')):
- pass
- return record
- assert pane_event() == f'new {first} {root}/+New\n'.encode()
- assert pane_event() == f'new {second} {root}/+New\n'.encode()
- # A follower that is waiting wakes when the editor logs, not when
- # some unrelated request next happens to wait.
- with Client(address) as follower:
- waiting = follower.open('/log', 2)
- start = len(follower.read_fid(waiting))
- follower.rpc(118, struct.pack('<IQI', waiting, 0, 7) + b'follow\n')
- woke = []
- reader = threading.Thread(target=lambda: woke.append(follower.read_fid(waiting, start)), daemon=True)
- reader.start()
- time.sleep(.2)
- client.write('/exec', b'Msg woken\n')
- reader.join(5)
- assert woke and woke[0].endswith(b' woken\n'), woke
- # A pane's ctl takes acme's lock: a second open's lock fails at
- # once with "file in use" until the holder unlocks, and nothing
- # else waits on it meanwhile.
- with Client(address) as other:
- mine = client.open(f'/pane/{first}/ctl', 2)
- client.rpc(118, struct.pack('<IQI', mine, 0, 5) + b'lock\n')
- theirs = other.open(f'/pane/{first}/ctl', 1)
- try:
- other.rpc(118, struct.pack('<IQI', theirs, 0, 5) + b'lock\n')
- raise AssertionError('a second lock was taken')
- except OSError as refused:
- assert 'file in use' in str(refused), refused
- client.write(f'/pane/{first}/addr', b'#0')
- client.rpc(118, struct.pack('<IQI', mine, 0, 7) + b'unlock\n')
- other.rpc(118, struct.pack('<IQI', theirs, 0, 5) + b'lock\n')
- client.close(mine)
- other.close(theirs)
- # /focus names the pane with the keyboard and moves it, as rio's
- # wctl `current` does; a pane's ctl line ends saying which it is.
- client.write('/focus', f'{first}\n'.encode())
- assert client.read('/focus') == f'{first}\n'.encode()
- assert b' current ' in client.read(f'/pane/{first}/ctl')
- assert b' notcurrent ' in client.read(f'/pane/{second}/ctl')
- try:
- client.write('/focus', b'99999\n')
- raise AssertionError('focus took a serial no pane has')
- except OSError as refused:
- assert 'no such pane' in str(refused), refused
- # /ctl reads the settings as a write takes them and takes the
- # session's builtins; a pane's ctl takes the pane's.
- settings = client.read('/ctl')
- assert b'Verbose ' in settings and b'Platform' not in settings, settings
- client.write('/ctl', settings)
- assert client.read('/ctl') == settings
- client.write('/ctl', b'Verbose off\n')
- assert b'Verbose off\n' in client.read('/ctl')
- for path, line, why in (('/ctl', b'Del\n', 'not a session control message "Del"'),
- ('/ctl', b'Nope 3\n', 'unknown control message "Nope 3"'),
- (f'/pane/{first}/ctl', b'Newcol\n', 'not a window control message "Newcol"')):
- try:
- client.write(path, line)
- raise AssertionError(f'{path} took {line!r}')
- except OSError as refused:
- assert why in str(refused), refused
- commands = client.read('/commands').decode().splitlines()
- def row(start):
- return any(r == start or r.startswith(start + ' ') for r in commands)
- assert row('Newcol root') and row('Save arg pane') and row('Edit arg both'), commands
- # word, `arg` if it takes one, its ctl, a setting's values, then `-- ` what it does
- assert all(r.split()[2 if r.split()[1] == 'arg' else 1] in ('root', 'pane', 'both') for r in commands), commands
- assert row('Placement arg root acme,pardes'), commands
- assert client.stat('/commands')['length'] == len('\n'.join(commands).encode()) + 1 # bytes: a description may end in …
- client.write(f'/pane/{first}/ctl', b'Msg said through ctl\n')
- assert 'said through ctl' in ''.join(cell[0] for cell in client.screen()['cells'])
- assert set(client.list('/pane')) == {'new', str(fixture), str(first), str(second)}
- client.write(f'/pane/{first}/body', b'first pane', truncate=True)
- assert client.read(f'/pane/{first}/body') == b'first pane'
- assert client.read(f'/pane/{second}/body') == b''
- assert client.stat(f'/pane/{first}/body')['length'] == len(b'first pane')
- rows = {int(row.split()[0]): row.split() for row in client.read('/index').splitlines()}
- assert rows[first][1:3] == [b'text', b'1'] and rows[second][1:3] == [b'text', b'0'], rows
- # name: read the file name, write to rename; sel: the selection.
- assert client.read(f'/pane/{first}/name') == f'{root}/+New\n'.encode()
- client.write(f'/pane/{first}/name', b'notes.txt\n')
- assert client.read(f'/pane/{first}/name') == f'{root}/notes.txt\n'.encode()
- assert pane_event() == f'rename {first} {root}/notes.txt\n'.encode()
- assert client.stat(f'/pane/{first}/name')['length'] == len(f'{root}/notes.txt\n')
- # Copying addr onto dot selects that range; sel reads and replaces it.
- client.write(f'/pane/{first}/addr', b'#0,#5')
- client.write(f'/pane/{first}/dot', client.read(f'/pane/{first}/addr'))
- assert client.read(f'/pane/{first}/dot') == client.read(f'/pane/{first}/addr')
- assert client.read(f'/pane/{first}/sel') == b'first'
- assert client.stat(f'/pane/{first}/sel')['length'] == 5
- client.write(f'/pane/{first}/sel', b'FIRST')
- assert client.read(f'/pane/{first}/body') == b'FIRST pane'
- assert client.read(f'/pane/{first}/sel') == b''
- # exec Msg shows text; exec Save writes the named file; rmdir closes.
- client.write(f'/pane/{first}/exec', b'Msg hello from 9P\n')
- assert 'hello from 9P' in ''.join(cell[0] for cell in client.screen()['cells'])
- assert client.read(f'/pane/{first}/dirty') == b'1\n'
- client.write(f'/pane/{first}/exec', b'Save\n')
- assert (root / 'notes.txt').read_bytes() == b'FIRST pane'
- assert pane_event() == f'save {first} {root}/notes.txt\n'.encode()
- assert client.read('/exec') == f'{first}\n'.encode()
- assert client.read(f'/pane/{first}/dirty') == b'0\n'
- client.remove(f'/pane/{second}')
- assert pane_event() == f'del {second} {root}/+New\n'.encode()
- assert str(second) not in client.list('/pane')
- # look opens a file; the serial reads back.
- (root / 'opened.txt').write_bytes(b'one\ntwo\nthree\n')
- client.write('/look', f'{root}/opened.txt:2\n'.encode())
- opened = int(client.read('/look'))
- assert opened not in (fixture, first, second), opened
- assert client.read(f'/pane/{opened}/body') == b'one\ntwo\nthree\n'
- assert client.read(f'/pane/{opened}/name') == f'{root}/opened.txt\n'.encode()
- assert pane_event() == f'new {opened} {root}/opened.txt\n'.encode()
- client.write(f'/pane/{first}/look', f'{root}/opened.txt:3\n'.encode())
- assert client.read('/look') == f'{opened}\n'.encode(), 'a repeated look targets the open pane'
- assert {str(fixture), str(first), str(opened)} <= set(client.list('/pane'))
- # Writing an event record back still performs the action it names.
- client.write(f'/pane/{first}/body', b'Msg via event', truncate=True)
- client.write(f'/pane/{first}/event', b'FX0 13\n')
- assert 'via event' in ''.join(cell[0] for cell in client.screen()['cells'])
- # A command line may not carry control characters, and nothing else
- # in the tree may be created or removed.
- refused = [lambda: client.write('/exec', b'Msg a\x00b'),
- lambda: client.write('/status', b'anything\n'),
- lambda: client.mkdir('/', 'x'),
- lambda: client.mkdir('/pane', 'one'),
- lambda: client.create('/pane', 'plain-file'),
- lambda: client.remove('/pane/1/body'),
- lambda: client.remove('/index')]
- for index, attempt in enumerate(refused):
- try:
- attempt()
- except OSError:
- pass
- else:
- raise AssertionError(f'refusal {index} was accepted')
- client.close(log)
- if embedded:
- assert client.read('/src/pardes.zig').startswith(b'const std')
- assert client.stat('/src/pardes.zig')['mode'] == 0o444
- assert b'pub const Pardes' in client.read(f'/pane/{look(client, "/virtual/src/pardes.zig")}/body')
- # An open of data with OTRUNC (a shell's >) deletes the addressed
- # range only, so the write after it replaces that range.
- scratch = new_pane(client, b'hello world\nsecond line\n')
- client.write(f'/pane/{scratch}/addr', b'#0,#5')
- client.write(f'/pane/{scratch}/data', b'HOWDY', truncate=True)
- assert client.read(f'/pane/{scratch}/body') == b'HOWDY world\nsecond line\n'
- # sam's regexps: ^ at any line; a miss says so and leaves no
- # address, so the data write after it refuses.
- client.write(f'/pane/{scratch}/addr', b'/^second/')
- assert client.read(f'/pane/{scratch}/addr') == b' 12 18 '
- for path, data, why in ((f'/pane/{scratch}/addr', b'/nowhere/', 'no match for regexp'),
- (f'/pane/{scratch}/data', b'LOST', 'no address')):
- try:
- client.write(path, data)
- raise AssertionError(f'{path} took {data!r}')
- except OSError as refused:
- assert why in str(refused), refused
- assert client.read(f'/pane/{scratch}/body') == b'HOWDY world\nsecond line\n'
- # Through a mount both read as EINVAL; the log says which and why.
- assert f'err {scratch} addr: no match for regexp\n'.encode() in client.read('/log')
- client.remove(f'/pane/{scratch}')
- # Real `diff -u` in a command pane: the terminal turns the tab
- # before each timestamp into blanks, and a look at a changed line
- # still opens the new file at it.
- (root / 'diff-old.txt').write_text('one\ntwo\nthree\n')
- (root / 'diff-new.txt').write_text('one\nTWO\nthree\n')
- seen = client.read('/log').decode().count('\nexit ')
- client.write('/exec', b'diff -u diff-old.txt diff-new.txt\n')
- deadline = time.monotonic() + 10
- while client.read('/log').decode().count('\nexit ') <= seen:
- assert time.monotonic() < deadline, 'diff -u never ended'
- time.sleep(.05)
- # A command's pane is kind cmd, not term: no shell to type into.
- ran = [row.split()[0] for row in client.read('/index').decode().splitlines() if row.split()[1] == 'cmd']
- shown = client.read(f'/pane/{ran[-1]}/body').decode()
- assert '+++ diff-new.txt' in shown and '\t' not in shown, shown
- client.write(f'/pane/{ran[-1]}/look', b'+TWO\n')
- opened = [row for row in client.read('/index').decode().splitlines() if row.split()[3] == f'{root}/diff-new.txt']
- assert len(opened) == 1, client.read('/index')
- client.remove(f'/pane/{opened[0].split()[0]}')
- client.remove(f'/pane/{ran[-1]}')
- # A Save makes the directories its file goes in, whatever names
- # it: the pane's own name or Save's path.
- # `~` is home (this session's HOME, the test's root) wherever a
- # path is typed: Save, name, a look, with an address or not.
- tilde = new_pane(client, b'one\ntwo\nthree\n')
- client.write(f'/pane/{tilde}/ctl', b'Save ~/tilde-made/sub/x.txt\n')
- assert (root / 'tilde-made/sub/x.txt').read_bytes() == b'one\ntwo\nthree\n'
- client.write(f'/pane/{tilde}/name', b'~/tilde-named.txt\n')
- assert client.read(f'/pane/{tilde}/name') == f'{root}/tilde-named.txt\n'.encode()
- client.remove(f'/pane/{tilde}')
- client.write('/look', b'~/tilde-made/sub/x.txt:3\n')
- looked = [row for row in client.read('/index').decode().splitlines() if row.split()[3] == f'{root}/tilde-made/sub/x.txt']
- assert len(looked) == 1, client.read('/index')
- assert client.read(f'/pane/{looked[0].split()[0]}/addr').startswith(b'8 '), client.read(f'/pane/{looked[0].split()[0]}/addr')
- client.remove(f'/pane/{looked[0].split()[0]}')
- made_dirs = new_pane(client, b'deep\n')
- client.write(f'/pane/{made_dirs}/ctl', f'Save {root}/save-made/a/b/x.txt\n'.encode())
- assert (root / 'save-made/a/b/x.txt').read_bytes() == b'deep\n'
- client.write(f'/pane/{made_dirs}/name', f'{root}/save-named/c/y.txt\n'.encode())
- client.write(f'/pane/{made_dirs}/ctl', b'Save\n')
- assert (root / 'save-named/c/y.txt').read_bytes() == b'deep\n'
- client.remove(f'/pane/{made_dirs}')
- # A save the host cannot do (a directory it may not make) fails
- # the write that asked for it, and the log's err record names
- # the path and why.
- unsaved = new_pane(client, b'unsaved\n')
- try:
- client.write(f'/pane/{unsaved}/ctl', b'Save /nonexistent-pardes-dir/x.txt\n')
- raise AssertionError('a Save into a missing directory succeeded')
- except OSError as refused:
- assert 'Save /nonexistent-pardes-dir/x.txt: no such directory' in str(refused), refused
- assert f'err {unsaved} ctl: Save /nonexistent-pardes-dir/x.txt: '.encode() in client.read('/log'), client.read('/log')
- client.remove(f'/pane/{unsaved}')
-
- # Sixteen connections fill the slots; the next is told why.
- extra = [Client(address) for _ in range(15)]
- try:
- try:
- Client(address).__exit__()
- raise AssertionError('a seventeenth connection was served')
- except OSError as refused:
- assert 'too many connections' in str(refused), refused
- finally:
- for other in extra:
- other.__exit__()
- deadline = time.monotonic() + 5
- while b'err - 9p: too many connections' not in client.read('/log'):
- assert time.monotonic() < deadline, client.read('/log')
- time.sleep(.01)
-
- print('9P discovery: listing/stat/find are inert; new, remove, look, exec, name, sel, log, ctl lock, focus, the ctl split and commands behave')
-
-
-def run_file(binary):
- """pty/run: a line in, how it ended out, on the same open."""
- def run(c, serial, line):
- fid = c.open(f'/pane/{serial}/pty/run', 2)
- try:
- c.rpc(118, struct.pack('<IQI', fid, 0, len(line)) + line)
- return c.read_fid(fid)
- finally:
- c.close(fid)
- with tempfile.TemporaryDirectory() as directory:
- root = Path(directory)
- with session(binary, root, 'run') as (client, address):
- # From a pane on a peer's path no command or terminal starts:
- # refused before any pane is made, no `exit 127` pane left.
- peer = new_pane(client, b'')
- client.write(f'/pane/{peer}/name', b'/n/nosuchpeer/d/f.txt\n')
- count = len(client.read('/index').splitlines())
- execute_refused(client, peer, 'ls', 'no such directory')
- execute_refused(client, peer, 'Tty', 'no such directory')
- assert len(client.read('/index').splitlines()) == count, client.read('/index')
- assert b'exit 127' not in client.read('/log')
- client.remove(f'/pane/{peer}')
- client.write('/exec', b'Shell bash\n')
- client.write('/exec', b'Tty\n')
- term = int(max(r.split()[0] for r in client.read('/index').splitlines() if r.split()[1] == b'term'))
- deadline = time.monotonic() + 10
- while run(client, term, b'true\n') == b'busy\n': # until its first prompt
- assert time.monotonic() < deadline, 'the shell never reached a prompt'
- time.sleep(.05)
- assert run(client, term, b'false\n') == b'exit 1\n'
- assert run(client, term, b'printf "one\\ntwo\\n"\n') == b'exit 0\none\ntwo\n' # then what it printed
- assert run(client, term, b'sh -c "exit 7"\n') == b'exit 7\n'
- assert run(client, term, b'fi\n') == b'error not run\n' # a syntax error runs nothing
- assert run(client, term, b"echo 'open\n") == b'error not run\n' # nor does an open quote
- assert run(client, term, b'true\n') == b'exit 0\n' # ...and the shell is clear after
- # With no frontend attached the pty's size is in pixels too, at a
- # nominal 8x16 cell: a program sizes its kitty graphics by it.
- said = run(client, term, b'python3 -c \'import fcntl,termios,struct;print(*struct.unpack("4H",fcntl.ioctl(0,termios.TIOCGWINSZ,bytes(8))))\'\n')
- rows, cols, xpixel, ypixel = map(int, said.split(b'\n')[1].split())
- assert (xpixel, ypixel) == (cols * 8, rows * 16) and xpixel > 0, said
- # A paging command run through pty/run does not wait in less: the
- # terminal's PAGER is `pardes -`, and its text is a +Pager pane.
- if shutil.which('git'):
- repo = root / 'pagedrepo'
- repo.mkdir()
- git = ['git', '-C', str(repo), '-c', 'user.name=p', '-c', 'user.email=p@x']
- subprocess.run(git + ['init', '-q'], check=True, env=dict(os.environ, HOME=str(root)))
- (repo / 'f').write_text('x\n')
- subprocess.run(git + ['add', 'f'], check=True, env=dict(os.environ, HOME=str(root)))
- subprocess.run(git + ['commit', '-qm', 'paged-commit-subject'], check=True, env=dict(os.environ, HOME=str(root)))
- assert run(client, term, b'git -C pagedrepo log\n').startswith(b'exit 0\n')
- pager = [r.split()[0].decode() for r in client.read('/index').splitlines() if r.split()[3:4] == [f'{repo}/+Pager'.encode()]] # git -C runs it in the repo
- assert len(pager) == 1, client.read('/index')
- assert b'paged-commit-subject' in client.read(f'/pane/{pager[0]}/body')
- assert b'\x1b' not in client.read(f'/pane/{pager[0]}/body')
- client.remove(f'/pane/{pager[0]}')
- # systemd's tools page through their own variable: set too, its
- # secure mode off, the path unquoted where it needs none. Read
- # by the shell: coreutils 9.12's printenv quotes a value with a
- # blank on a terminal.
- systemd_pager = run(client, term, b'printf "%s\\n" "$SYSTEMD_PAGER" "$SYSTEMD_PAGERSECURE"\n')
- assert systemd_pager.startswith(b'exit 0\n') and systemd_pager.rstrip().endswith(b' -\n0'), systemd_pager
- if shutil.which('journalctl'):
- assert run(client, term, b'journalctl -n 3 --no-hostname\n').startswith(b'exit ')
- for row in client.read('/index').splitlines():
- if row.split()[3:4] == [f'{root}/+Pager'.encode()]:
- client.remove(f'/pane/{row.split()[0].decode()}')
- # A pty is not given one row (it loses the prompt's input mark,
- # and the shell would read busy for ever): refused, and said.
- try:
- client.write(f'/pane/{term}/pty/ctl', b'winsize 20 1\n')
- raise AssertionError('winsize 20 1 was taken')
- except OSError as refused:
- assert 'at least 2 rows' in str(refused), refused
- client.write(f'/pane/{term}/pty/ctl', b'winsize 20 2\n')
- time.sleep(.5)
- assert run(client, term, b'true\n') == b'exit 0\n'
- assert client.read(f'/pane/{term}/pty/ctl').split()[2] == b'2', client.read(f'/pane/{term}/pty/ctl')
- client.write(f'/pane/{term}/pty/ctl', b'winsize 80 24\n')
- # A shell started again that cannot start (its directory is
- # there but cannot be entered) fails the write and leaves the
- # running shell be: runs still work.
- locked = root / 'locked'
- locked.mkdir()
- assert run(client, term, f'cd {locked}\n'.encode()) == b'exit 0\n'
- deadline = time.monotonic() + 5
- while str(locked).encode() not in client.read('/index'):
- assert time.monotonic() < deadline, client.read('/index')
- time.sleep(.05)
- locked.chmod(0o600)
- try:
- if os.geteuid() != 0: # root enters any directory
- client.write(f'/pane/{term}/pty/ctl', b'exec\n')
- raise AssertionError('pty/ctl exec of a shell that cannot start was taken')
- except OSError as refused:
- assert 'shell' in str(refused), refused
- finally:
- locked.chmod(0o755)
- kept = run(client, term, b'true\n')
- assert kept == b'exit 0\n', (kept, client.read('/log')[-600:])
- assert run(client, term, f'cd {root}\n'.encode()) == b'exit 0\n'
- with Client(address) as other:
- slow = []
- waiter = threading.Thread(target=lambda: slow.append(run(other, term, b'sleep 1\n')), daemon=True)
- waiter.start()
- time.sleep(.3)
- # The job the other client ran holds the tty, and says so.
- assert run(client, term, b'true\n') == b'busy: sleep is running\n'
- waiter.join(5)
- assert slow == [b'exit 0\n'], slow
- closing = []
- waiter = threading.Thread(target=lambda: closing.append(run(other, term, b'sleep 30\n')), daemon=True)
- waiter.start()
- time.sleep(.3)
- client.write(f'/pane/{term}/exec', b'Del\n')
- waiter.join(5)
- assert closing == [b'error shell gone\n'], closing
-
-
-def exit_answers(binary):
- """Exit written to /ctl is answered before the editor quits."""
- with tempfile.TemporaryDirectory(prefix='pardes-exit-') as directory:
- seen = {}
- with session(binary, Path(directory), 'exit', terminal=seen) as (client, _):
- client.write('/ctl', b'Exit\n')
- deadline = time.monotonic() + 5
- while time.monotonic() < deadline:
- try:
- # a zombie has quit; the session reaps it
- if Path(f'/proc/{seen["pid"]}/stat').read_text().split(') ')[1][0] == 'Z':
- break
- except FileNotFoundError:
- break
- time.sleep(.01)
- else:
- raise AssertionError("Exit did not quit the editor")
-
-
-def unattended_messages_expire(binary):
- """With nothing attached, a message leaves after MessageLinger on its own
- clock: no key, no click, no other request comes to move it along."""
- with tempfile.TemporaryDirectory(prefix='pardes-msg-') as directory:
- with session(binary, Path(directory), 'msg') as (client, _):
- client.write('/pane/1/ctl', b'Msg lingering-words\n')
- def shown():
- screen = json.loads(client.read('/screen'))
- return 'lingering-words' in ''.join(cell[0] for cell in screen['cells'])
- assert shown()
- # Reading /screen is itself a request, so wait without asking.
- time.sleep(2.5)
- assert not shown(), 'an unattended message outlived MessageLinger'
-
-
-def directory_panes(binary):
- """A look at a directory opens a pane listing it, as acme's directory
- window: a text pane named with a trailing /, its body the entries (a
- directory's marked /), ctl's isdir 1, and get reads it again."""
- with tempfile.TemporaryDirectory(prefix='pardes-dirpane-') as directory:
- root = Path(directory).resolve()
- listed = root / 'listed'
- (listed / 'sub').mkdir(parents=True)
- (listed / '.dot').write_bytes(b'')
- with session(binary, root, 'dirpane') as (client, _):
- serial = look(client, str(listed))
- rows = [row.split() for row in client.read('/index').decode().splitlines()]
- row = next(r for r in rows if int(r[0]) == serial)
- assert row[1:4] == ['text', '0', f'{listed}/'], row
- body = client.read(f'/pane/{serial}/body').decode()
- assert body.split() == ['.dot', 'sub/'], body
- assert client.read(f'/pane/{serial}/ctl').split()[3] == b'1'
- (listed / 'later').write_bytes(b'')
- client.write(f'/pane/{serial}/ctl', b'get\n')
- assert client.read(f'/pane/{serial}/body').decode().split() == ['.dot', 'later', 'sub/']
-
-
-def putall_answers_after_its_saves(binary):
- """Putall with one pane refused (its file changed on disk under unsaved
- edits) fails, and is answered only once the other panes' saves have
- landed."""
- with tempfile.TemporaryDirectory(prefix='pardes-putall-') as directory:
- root = Path(directory).resolve()
- (root / 'a.txt').write_bytes(b'a\n')
- (root / 'b.txt').write_bytes(b'b\n')
- with session(binary, root, 'putall') as (client, _):
- a = look(client, str(root / 'a.txt'))
- b = look(client, str(root / 'b.txt'))
- for serial in (a, b):
- client.write(f'/pane/{serial}/body', b'edited\n')
- (root / 'b.txt').write_bytes(b'changed on disk\n')
- deadline = time.monotonic() + 10
- while f'changed {b}' not in client.read('/log').decode():
- assert time.monotonic() < deadline, 'the watch never saw b.txt change'
- time.sleep(.05)
- try:
- client.write('/ctl', b'Putall\n')
- except OSError as why:
- assert 'modified on disk' in str(why), why
- else:
- raise AssertionError('Putall over a file changed on disk was taken')
- assert (root / 'a.txt').read_bytes() == b'a\nedited\n', (root / 'a.txt').read_bytes()
- assert (root / 'b.txt').read_bytes() == b'changed on disk\n'
-
-
-def new_terminals_named_once(binary):
- """A terminal started outside the session's directory is named by that
- directory from its `new` on: no rename to the session's and back."""
- with tempfile.TemporaryDirectory(prefix='pardes-names-') as directory:
- root = Path(directory)
- (root / 'sub').mkdir()
- with session(binary, root, 'names') as (client, _):
- # A look at a directory starts a terminal there (DirLook
- # terminal); DirLook pane, the default, lists it in a pane.
- client.write('/ctl', b'DirLook terminal\n')
- made = [look(client, str(root / 'sub'))]
- before = {int(row.split()[0]) for row in client.read('/index').splitlines()}
- client.write('/pane/1/ctl', b'Tty\n')
- if shutil.which('fish'):
- client.write('/pane/1/ctl', b'Tty fish\n')
- made += [s for s in (int(row.split()[0]) for row in client.read('/index').splitlines()) if s not in before]
- time.sleep(1.5) # their shells start and say where they are
- # A shell started again by pty/ctl exec: named as it was.
- client.write(f'/pane/{made[0]}/pty/ctl', b'exec\n')
- time.sleep(1.5)
- log = client.read('/log').decode()
- for serial in made:
- assert f'\nrename {serial} ' not in '\n' + log, (serial, log)
- assert f'\nnew {serial} {root}' in '\n' + log, (serial, log)
- # A shell that cannot start (its interpreter is not there): Tty
- # fails the write with why and leaves no pane; pty/ctl exec
- # fails with why and keeps its terminal.
- bad = root / 'badsh'
- bad.write_bytes(b'#!/nonexistent/interp\n')
- bad.chmod(0o755)
- panes = client.read('/index')
- for where, line in (('/pane/1/ctl', f'Tty {bad}\n'), ('/ctl', f'Shell {bad}\n')):
- try:
- client.write(where, line.encode())
- raise AssertionError(f'{line} of a shell that cannot start was taken')
- except OSError as refused:
- assert 'interpreter /nonexistent/interp not found' in str(refused), refused
- time.sleep(.3)
- assert client.read('/index').count(b'\n') == panes.count(b'\n'), client.read('/index')
- assert b'shell: shell not found' not in client.read('/log'), client.read('/log')
- assert str(made[0]).encode() in b' '.join(r.split()[0] for r in client.read('/index').splitlines())
-
-
-def recent_survives_restart(binary):
- """A file opened and closed is in /recent closed, and still is in the
- next session: the list is kept under $XDG_STATE_HOME (here HOME's
- .local/state) across restarts."""
- with tempfile.TemporaryDirectory(prefix='pardes-recent-') as directory:
- root = Path(directory)
- kept = root / 'kept.txt'
- kept.write_bytes(b'one\ntwo\n')
- with session(binary, root, 'recent1') as (client, _):
- serial = look(client, f'{kept}:2')
- assert f'open {kept}\n' in client.read('/recent').decode()
- client.write(f'/pane/{serial}/ctl', b'Del\n')
- assert f'closed {kept}\n' in client.read('/recent').decode(), client.read('/recent')
- assert (root / '.local' / 'state' / 'pardes' / 'store').exists()
- with session(binary, root, 'recent2') as (client, _):
- listed = client.read('/recent').decode()
- assert f'closed {kept}\n' in listed, listed
- # Recent fills a query pane with it, its row relative to the
- # pane's directory, and a look at the row opens it again.
- client.write('/pane/1/exec', b'Recent\n')
- rows = int(client.read('/pane/1/exec').split()[-1])
- body = client.read(f'/pane/{rows}/body').decode()
- assert body.startswith('Recent '), body
- row = next(r for r in body.splitlines() if r.startswith('kept.txt:'))
- client.write(f'/pane/{rows}/look', (row.split(' ')[0] + '\n').encode())
- assert f'open {kept}\n' in client.read('/recent').decode()
-
-
-def del_twice(client, serial):
- """Del, and again when the first refused over unsaved text."""
- try:
- client.write(f'/pane/{serial}/ctl', b'Del\n')
- except OSError:
- client.write(f'/pane/{serial}/ctl', b'Del\n')
-
-
-def store_shared_between_windows(binary):
- """Two windows share one store (Store.zig): a file opened in one is in
- the other's /recent at its next read, with no restart; a pane Del'd in
- one comes back where it was from a look at its @p serial there, its text
- with it, and only there."""
- with tempfile.TemporaryDirectory(prefix='pardes-store-') as directory:
- root = Path(directory)
- shared = root / 'shared.txt'
- shared.write_bytes(b'one\ntwo\nthree\n')
- with session(binary, root, 'store1') as (one, _), session(binary, root, 'store2') as (two, _):
- serial = look(one, f'{shared}:3')
- assert f'open {shared}\n' in one.read('/recent').decode()
- assert f'closed {shared}\n' in two.read('/recent').decode(), two.read('/recent')
- one.write(f'/pane/{serial}/ctl', b'Del\n')
- assert f'closed {shared}\n' in one.read('/recent').decode()
- scratch = new_pane(one, b'kept across a Del\n')
- del_twice(one, scratch)
- assert str(scratch) not in [row.split()[0] for row in one.read('/index').decode().splitlines()]
- back = look(one, f'@p{scratch}')
- assert one.read(f'/pane/{back}/body') == b'kept across a Del\n'
- # The other window's session closed no such pane.
- source = new_pane(two, b'')
- try:
- two.write(f'/pane/{source}/look', f'@p{scratch}\n'.encode())
- except OSError:
- pass
- assert b'kept across a Del' not in b''.join(two.read(f'/pane/{row.split()[0]}/body')
- for row in two.read('/index').decode().splitlines())
- assert (root / '.local' / 'state' / 'pardes' / 'store').exists()
-
-
-def workflow_canary(binary):
- """One session driven as the dogfood agents drive it, asserting the log
- and the read-backs at every step: the canary for the main paths (the
- round-18 Grep that never found anything went through every narrower
- test). Look files, Grep and Find hits and misses, a plain word looked
- at, Edit in two files, Save, get, pty/run failing then passing, a
- command pane and Kill, a REPL send, the layout and a column's files,
- ask/answer, and Dump/Restore last."""
- started = time.monotonic()
- with tempfile.TemporaryDirectory(prefix='pardes-flow-') as directory:
- root = Path(directory)
- (root / 'a.txt').write_bytes(b'alpha one\nshared word\n')
- (root / 'b.txt').write_bytes(b'beta two\nshared word\n')
- (root / 's.sh').write_bytes(b'echo from-file\n')
-
- def wait(ready, what, seconds=10):
- deadline = time.monotonic() + seconds
- while not ready():
- assert time.monotonic() < deadline, what
- time.sleep(.05)
-
- with session(binary, root, 'flow') as (client, address):
- def log():
- return client.read('/log').decode('utf-8', 'replace')
-
- def made_by(serial, line):
- """The pane an exec at `serial` made, as exec reads it back."""
- client.write(f'/pane/{serial}/exec', line)
- return int(client.read(f'/pane/{serial}/exec').split()[-1])
-
- # Look opens files, and the log says new.
- a = look(client, str(root / 'a.txt'))
- b = look(client, str(root / 'b.txt'))
- assert client.read(f'/pane/{a}/body') == b'alpha one\nshared word\n'
- assert f'new {a} {root}/a.txt\n' in log() and f'new {b} {root}/b.txt\n' in log()
-
- # Grep and Find: a hit fills its query pane, line 1 the query and
- # the lines under each file's name; a miss fails ENOENT.
- grep = made_by(a, b'Grep shared\n')
- rows = client.read(f'/pane/{grep}/body').decode()
- assert rows == 'Grep shared\na.txt\na.txt:2:1 shared word\nb.txt\nb.txt:2:1 shared word\n', rows
- client.remove(f'/pane/{grep}')
- execute_refused(client, a, 'Grep zzqqnomatch', 'Grep: text not found')
- found = made_by(a, b'Find b.txt\n')
- assert 'b.txt' in client.read(f'/pane/{found}/body').decode()
- client.remove(f'/pane/{found}')
- execute_refused(client, a, 'Find zzqqnomatch', 'Find: name not found')
-
- # A plain word looked at is found in the pane, after its dot.
- client.write(f'/pane/{a}/dot', b' 0 0 ')
- client.write(f'/pane/{a}/look', b'shared\n')
- assert client.read(f'/pane/{a}/dot').split() == [b'10', b'16'], client.read(f'/pane/{a}/dot')
-
- # Edit in two files, then Save each: on disk, and logged.
- for pane in (a, b):
- client.write(f'/pane/{pane}/ctl', b'Edit ,s/shared/SHARED/g\n')
- assert client.read(f'/pane/{b}/body') == b'beta two\nSHARED word\n'
- for pane in (a, b):
- client.write(f'/pane/{pane}/exec', b'Save\n')
- assert (root / 'a.txt').read_bytes() == b'alpha one\nSHARED word\n'
- assert f'save {a} {root}/a.txt\n' in log() and f'save {b} {root}/b.txt\n' in log()
-
- # get reloads what changed on disk.
- (root / 'b.txt').write_bytes(b'from disk\n')
- client.write(f'/pane/{b}/ctl', b'get\n')
- assert client.read(f'/pane/{b}/body') == b'from disk\n'
-
- # A terminal: pty/run failing then passing.
- term = made_by(1, b'Tty\n')
-
- def run(line):
- fid = client.open(f'/pane/{term}/pty/run', 2)
- try:
- client.rpc(118, struct.pack('<IQI', fid, 0, len(line)) + line)
- return client.read_fid(fid)
- finally:
- client.close(fid)
- deadline = time.monotonic() + 10
- while (answer := run(b'true\n')) != b'exit 0\n':
- assert time.monotonic() < deadline, answer
- time.sleep(.05)
- assert run(b'false\n') == b'exit 1\n'
- assert run(b'echo passed\n') == b'exit 0\npassed\n'
- # (A run's answer is its record: the log has no err for these.)
- assert f'err {term} pty/run' not in log(), log()
-
- # A command pane, and Kill: its exit is logged.
- sleeper = made_by(a, b'sleep 30\n')
- assert f'run {sleeper} sleep 30\n' in log()
- client.write('/ctl', b'Kill sleep\n')
- wait(lambda: f'\nexit {sleeper} ' in log(), 'Kill: no exit logged')
-
- # A REPL send: a program in the terminal (cat, which says back
- # what it is sent; a nested shell reads as the shell itself)
- # bound as bash's REPL, an exec on a .sh file's body (its event
- # written back) goes there.
- s = look(client, str(root / 's.sh'))
- client.write(f'/pane/{term}/pty/data', b'cat\r')
- wait(lambda: client.read(f'/pane/{term}/pty/status').split()[-1] == b'1', ('the REPL program did not start', client.read(f'/pane/{term}/body')[-300:]))
- client.write(f'/pane/{term}/ctl', b'Repl bash\n')
- fid = client.open(f'/pane/{s}/event', 2)
- try:
- record = b'MX0 0 0 14 echo from-file\n'
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- finally:
- client.close(fid)
- wait(lambda: f'\nsend {s} {term} ' in log(), ('no REPL send logged', log()[-800:]))
- wait(lambda: client.read(f'/pane/{term}/body').count(b'echo from-file') >= 2, 'the REPL did not get it')
- client.write(f'/pane/{term}/ctl', b'Repl -\n')
- client.write(f'/pane/{term}/pty/data', b'\x04')
- wait(lambda: run(b'true\n') == b'exit 0\n', 'the terminal did not come back to its shell')
-
- # The layout and a column's files: Newcol, its tag, rmdir.
- assert len(client.read('/layout').splitlines()) >= 2 # a column, then `active`
- client.write('/ctl', b'Newcol\n')
- columns = [row for row in client.read('/layout').splitlines() if not row.startswith(b'active')]
- assert len(columns) == 2, columns
- empty = columns[-1].split()[0].decode()
- assert b'New' in client.read(f'/col/{empty}/tag')
- client.remove(f'/col/{empty}')
- assert len([row for row in client.read('/layout').splitlines() if not row.startswith(b'active')]) == 1
-
- # ask/answer: Save on a terminal asks for a path over 9P.
- client.write(f'/pane/{term}/exec', b'Save\n')
- wait(lambda: f'ask {term} save path\n' in log(), 'no ask logged')
- client.write(f'/pane/{term}/ctl', f'answer {root}/scroll.txt\n'.encode())
- wait(lambda: (root / 'scroll.txt').exists(), 'the answered Save wrote nothing')
- assert f'answer {term} {root}/scroll.txt\n' in log()
-
- # Dump, then Restore it: the new session names its panes.
- client.write('/ctl', b'Dump\n')
- saved = root / 'flow.dump.zon'
- wait(saved.exists, 'Dump wrote nothing')
- assert f'dump {saved}\n' in log()
- try:
- client.write('/ctl', f'Restore {saved}\n'.encode())
- except (EOFError, OSError):
- pass
- time.sleep(.5)
- with Client(address) as restored:
- wait(lambda: f'restore {saved}' in restored.read('/log').decode(), 'Restore not logged')
- names = restored.read('/index').decode()
- assert f'{root}/a.txt' in names and f'{root}/b.txt' in names, names
- # Recent goes on across the Restore, and is kept after it.
- assert f'{root}/a.txt\n' in restored.read('/recent').decode(), restored.read('/recent')
- (root / 'after.txt').write_bytes(b'after\n')
- look(restored, str(root / 'after.txt'))
- assert f'open {root}/after.txt\n' in restored.read('/recent').decode()
- state = root / '.local' / 'state' / 'pardes' / 'store'
- wait(lambda: f'{root}/after.txt'.encode() in state.read_bytes(), 'Recent not kept after Restore')
- assert time.monotonic() - started < 30, 'the canary took too long'
-
-
-def python_repl_runs_one_line(binary):
- """A one-line exec sent to Python's own REPL (3.13's pyrepl, which asks
- for bracketed paste) runs at once, with no second Enter: the Enter
- reaches it after the paste, not inside it. A real pty, a real python3."""
- python = shutil.which('python3')
- if python is None:
- return
- version = subprocess.run([python, '-c', 'import sys; print(sys.version_info >= (3, 13))'],
- capture_output=True, text=True).stdout.strip()
- if version != 'True':
- return
- with tempfile.TemporaryDirectory(prefix='pardes-repl-') as directory:
- with session(binary, Path(directory), 'repl') as (client, _):
- def panes(client):
- return {int(row.split()[0]) for row in client.read('/index').splitlines()}
- before = panes(client)
- client.write('/pane/1/ctl', b'Tty\n')
- deadline = time.monotonic() + 10
- while time.monotonic() < deadline and panes(client) == before:
- time.sleep(.05)
- tty = max(panes(client) - before)
- def body():
- return client.read(f'/pane/{tty}/body').decode('utf-8', 'replace')
- def wait_for(text, seconds=15):
- deadline = time.monotonic() + seconds
- while time.monotonic() < deadline:
- if text in body():
- return True
- time.sleep(.1)
- return False
- assert wait_for('$') or wait_for('>'), body()
- client.write(f'/pane/{tty}/pty/data', python.encode() + b' -q\r')
- assert wait_for('>>>'), body()
- client.write(f'/pane/{tty}/ctl', b'Repl python\n')
- # An exec on the REPL's own body goes to the REPL, as its event
- # record written back does: an empty range acts on its text.
- fid = client.open(f'/pane/{tty}/event', 2)
- try:
- record = b'MX0 0 0 10 print(6*7)\n'
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- assert wait_for('\n42'), body()
- # After the session has sat idle, the Enter still waits for
- # the paste: core time is as old as the last frame then.
- for n in range(5):
- time.sleep(2)
- line = f'print({1000 + n})'.encode()
- record = b'MX0 0 0 %d %s\n' % (len(line), line)
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- assert wait_for(f'\n{1000 + n}'), (n, body())
- # More than one line, with and without a newline at the end,
- # and a block with a statement after it: each runs whole,
- # and the REPL is back at its prompt, not at `...`.
- for code, outputs in [(b'print(11)\nprint(22)', ['11', '22']),
- (b'print(33)\nprint(44)\n', ['33', '44']),
- (b'for i in range(2):\n print(55 + i)\nprint(77)\n', ['55', '56', '77'])]:
- record = b'MX0 0 0 %d %s\n' % (len(code), code)
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- for out in outputs:
- assert wait_for(f'\n{out}\n'), (code, out, body())
- time.sleep(.5)
- assert body().rstrip().endswith('>>>'), (code, body()[-200:])
- finally:
- client.close(fid)
-
-
-def signal_cleans_up(binary):
- """A detached session told to stop by a signal unlinks its sockets. A
- hangup is a terminal's end, not a session's: the daemon keeps it."""
- for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGHUP]:
- with tempfile.TemporaryDirectory(prefix='pardes-sig-') as directory:
- root = Path(directory)
- seen = {}
- with session(binary, root, 'sig', terminal=seen) as (client, address):
- assert address.exists()
- if sig == signal.SIGHUP:
- os.kill(seen['pid'], sig)
- time.sleep(.3)
- assert address.exists() and client.read('/index'), 'a hangup ended a kept session'
- sig = signal.SIGTERM
- os.kill(seen['pid'], sig)
- deadline = time.monotonic() + 5
- while address.exists() and time.monotonic() < deadline:
- time.sleep(.01)
- assert not address.exists(), (sig, list(root.iterdir()))
-
-
-def odd_paths(binary):
- """Long and odd paths written where a path goes -- name, look, DumpDir,
- Dump, Save -- are refused or said, never a crash: a part over 255 bytes
- (ENAMETOOLONG), a loop of links (ELOOP), a file taken for a directory
- (ENOTDIR), one not ours (EACCES)."""
- with tempfile.TemporaryDirectory(prefix='pardes-odd-') as directory:
- root = Path(directory)
- (root / 'loop').symlink_to(root / 'loop')
- (root / 'plain').write_bytes(b'x\n')
- odd = ['/tmp/' + 'x' * 300 + '/f.txt', str(root / ('y' * 300)), str(root / 'loop' / 'f'),
- str(root / 'plain' / 'f'), '/root/nope/f', str(root / 'a' / '..' / 'b.txt')]
- with session(binary, root, 'odd') as (client, _):
- serial = new_pane(client, b'text\n')
- for path in odd:
- for where, line in ((f'/pane/{serial}/name', path), ('/look', path),
- ('/ctl', f'DumpDir {path}'), ('/ctl', 'Dump'), (f'/pane/{serial}/ctl', 'Save')):
- try:
- client.write(where, (line + '\n').encode())
- except OSError:
- pass
- assert client.read('/index'), (where, line)
- client.write('/ctl', b'DumpDir\n')
- # A theme file that is not there, or no theme, fails the write.
- (root / 'bad.zon').write_bytes(b'.{ .nonsense = 1 }')
- for line, why in ((f'ThemeFile {root}/missing.zon', 'theme file'), (f'ThemeFile {root}/bad.zon', 'theme file'),
- ('ThemeFile notes.txt', 'a theme file is a .zon')):
- try:
- client.write('/ctl', (line + '\n').encode())
- raise AssertionError(f'{line} was taken')
- except OSError as refused:
- assert why in str(refused), (line, refused)
-
-
-def delcol_last_keeps_window(binary):
- """Delcol on the last column leaves the window, empty but for the
- workspace tag, as acme does; Newcol and New start again from there."""
- with tempfile.TemporaryDirectory(prefix='pardes-delcol-') as directory:
- with session(binary, Path(directory), 'delcol') as (client, _):
- def columns():
- return [l for l in client.read('/layout').decode().splitlines() if l and not l.startswith('active')]
- while columns():
- client.write(f'/col/{columns()[0].split()[0]}/ctl', b'Delcol\n')
- # Still here, empty.
- assert client.read('/index') == b'', client.read('/index')
- client.write('/ctl', b'Newcol\n')
- assert len(columns()) == 1, columns()
- serial = new_pane(client, b'back\n')
- assert str(serial).encode() in client.read('/index'), client.read('/index')
-
-
-def cut_writes(binary):
- """A write bigger than a 9P message comes as several, cut anywhere: each
- command line runs once, whole, an Edit block once it ends, and a last
- line with no newline when the open closes. Never a fragment."""
- with tempfile.TemporaryDirectory(prefix='pardes-cut-') as directory:
- with session(binary, Path(directory), 'cut') as (client, _):
- burst = b''.join(b'Msg burst-%04d\n' % i for i in range(1000))
- assert len(burst) > client.msize
- client.write('/exec', burst)
- log = client.read('/log').decode()
- said = [line.split(' ', 2)[2] for line in log.splitlines() if line.startswith('msg ') and 'burst-' in line]
- assert said == ['burst-%04d' % i for i in range(1000)], said[:3] + said[-3:]
- assert '\nrun ' not in log and 'exit 127' not in log, log[-400:]
- client.write('/exec', b'Msg no-newline-at-end')
- assert 'msg ' in client.read('/log').decode().split('no-newline-at-end')[0][-40:]
- serial = new_pane(client, b'')
- block = b'Edit ,a\n' + b''.join(b'line %05d of the block\n' % i for i in range(2500)) + b'.\n'
- assert len(block) > 50000
- client.write(f'/pane/{serial}/ctl', block)
- body = client.read(f'/pane/{serial}/body').decode().splitlines()
- assert body == ['line %05d of the block' % i for i in range(2500)], (len(body), body[:2])
- # A detached session with no frontend is 160x50 until told.
- screen = client.screen()
- assert (screen['cols'], screen['rows']) == (160, 50), (screen['cols'], screen['rows'])
- client.write('/ctl', b'size 132 40\n')
- screen = client.screen()
- assert (screen['cols'], screen['rows']) == (132, 40), (screen['cols'], screen['rows'])
-
-
-def edit_commands(binary):
- """Edit's `< | >` run off the loop and answer the write that ran them
- once applied; a failing one changes nothing and fails the write in its
- words; X edits every open file it matches; w writes. The editor answers
- other requests while a slow command runs."""
- with tempfile.TemporaryDirectory(prefix='pardes-edit-') as directory:
- root = Path(directory)
- (root / 'a.txt').write_bytes(b'pear\napple\nfig\n')
- (root / 'b.txt').write_bytes(b'apple pie\n')
- with session(binary, root, 'edit') as (client, address):
- a = look(client, str(root / 'a.txt'))
- b = look(client, str(root / 'b.txt'))
- # The write returns with the text sorted, through the session's
- # shell in the file's directory.
- client.write(f'/pane/{a}/ctl', b'Edit , | sort\n')
- assert client.read(f'/pane/{a}/body') == b'apple\nfig\npear\n'
- client.write(f'/pane/{a}/ctl', b'Edit $ < pwd\n')
- assert client.read(f'/pane/{a}/body') == f'apple\nfig\npear\n{root}\n'.encode()
- client.write(f'/pane/{a}/ctl', b'Undo\n')
- assert client.read(f'/pane/{a}/body') == b'apple\nfig\npear\n'
- # A per-match command, one undo step.
- client.write(f'/pane/{a}/ctl', b'Edit ,x/[a-z]+/ | tr a-z A-Z\n')
- assert client.read(f'/pane/{a}/body') == b'APPLE\nFIG\nPEAR\n'
- # A failing command: nothing changed, the write fails in words,
- # its stderr in +Errors.
- try:
- client.write(f'/pane/{a}/ctl', b'Edit , | echo nope >&2; exit 4\n')
- raise AssertionError('a failing Edit command was taken')
- except OSError as why:
- assert 'exit status 4' in str(why), why
- assert client.read(f'/pane/{a}/body') == b'APPLE\nFIG\nPEAR\n'
- index = client.read('/index').decode()
- errors = [line.split()[0] for line in index.splitlines() if line.endswith(('+Errors', f'{root}/+Errors')) or '+Errors' in line]
- assert errors and any(b'nope' in client.read(f'/pane/{e}/body') for e in errors), index
- # While a slow command runs, the editor answers.
- done = threading.Event()
-
- def slow():
- with Client(address) as other:
- other.write(f'/pane/{b}/ctl', b'Edit , | sleep 1; cat\n')
- done.set()
- worker = threading.Thread(target=slow)
- worker.start()
- time.sleep(.2)
- began = time.monotonic()
- client.read('/index')
- assert time.monotonic() - began < .5 and not done.is_set(), 'the editor waited on the command'
- worker.join(timeout=15)
- assert done.is_set()
- # On the same connection: the Edit's write is held, and a read sent
- # after it is answered first; a Tflush of it stops it, changes
- # nothing, and frees the way for the next Edit.
- def send(kind, tag, payload):
- client.socket.sendall(struct.pack('<IBH', 7 + len(payload), kind, tag) + payload)
-
- def answer():
- size, kind, tag = struct.unpack('<IBH', client.receive(7))
- return kind, tag, client.receive(size - 7)
- ctl = client.open(f'/pane/{a}/ctl', 1)
- status = client.open('/status', 0)
- line = b'Edit , | sleep 1; cat\n'
- began = time.monotonic()
- send(118, 900, struct.pack('<IQI', ctl, 0, len(line)) + line)
- send(116, 901, struct.pack('<IQI', status, 0, 4096))
- first = answer()
- assert first[1] == 901 and first[0] == 117 and time.monotonic() - began < .5, (first[:2], time.monotonic() - began)
- second = answer()
- assert second[1] == 900 and second[0] == 119, second
- line = b'Edit , | sleep 5; tr a-z A-Z\n'
- send(118, 902, struct.pack('<IQI', ctl, 0, len(line)) + line)
- time.sleep(.3)
- send(108, 903, struct.pack('<H', 902))
- tags = sorted(answer()[1] for _ in range(2))
- assert tags == [902, 903], tags
- client.close(ctl)
- client.close(status)
- time.sleep(1)
- client.write(f'/pane/{a}/ctl', b'Edit , | cat\n')
- time.sleep(4.5)
- assert client.read(f'/pane/{a}/body') == b'APPLE\nFIG\nPEAR\n', client.read(f'/pane/{a}/body')
- # X: each open file whose line matches; w writes it.
- client.write(f'/pane/{a}/ctl', b'Edit X/b\\.txt$/ ,s/apple/APPLE/\n')
- assert client.read(f'/pane/{b}/body') == b'APPLE pie\n'
- client.write(f'/pane/{b}/ctl', b'Edit w\n')
- assert (root / 'b.txt').read_bytes() == b'APPLE pie\n'
- client.write(f'/pane/{a}/ctl', b'Edit 1 w first.txt\n')
- assert (root / 'first.txt').read_bytes() == b'APPLE\n'
- # A file changed on disk under unsaved edits: Edit's w refuses
- # once, as Save does, and the next w overwrites it.
- w1 = root / 'w1.txt'
- w1.write_bytes(b'one\n')
- w = look(client, str(w1))
- client.write(f'/pane/{w}/ctl', b'Edit $a/two/\n')
- seen = client.read('/log').decode().count(f'\nchanged {w}')
- with open(w1, 'ab') as f:
- f.write(b'external\n')
- deadline = time.monotonic() + 10
- while client.read('/log').decode().count(f'\nchanged {w}') == seen:
- assert time.monotonic() < deadline, 'the change on disk was not heard'
- time.sleep(.05)
- try:
- client.write(f'/pane/{w}/ctl', b'Edit w\n')
- raise AssertionError('w overwrote a file changed on disk')
- except OSError as why:
- assert 'modified on disk since read (w again to overwrite)' in str(why), why
- assert w1.read_bytes() == b'one\nexternal\n'
- client.write(f'/pane/{w}/ctl', b'Edit w\n')
- assert w1.read_bytes() == b'one\ntwo', w1.read_bytes()
-
-
-def test(binary, quic=False):
- started = time.monotonic()
- cut_writes(binary)
- edit_commands(binary)
- odd_paths(binary)
- delcol_last_keeps_window(binary)
- run_file(binary)
- exit_answers(binary)
- unattended_messages_expire(binary)
- new_terminals_named_once(binary)
- directory_panes(binary)
- putall_answers_after_its_saves(binary)
- workflow_canary(binary)
- recent_survives_restart(binary)
- store_shared_between_windows(binary)
- python_repl_runs_one_line(binary)
- signal_cleans_up(binary)
- for options, message in [
- (['--fs'], b'no such option'),
- (['--fs9'], b'no such option'),
- (['--', 'a', 'b'], b'is the second'),
- (['--9p'], b'--9p needs a socket name'),
- (['--9p='], b'invalid 9P socket name'),
- (['--9p=a/b'], b'invalid 9P socket name'),
- (['--attach=work', '--9p=work'], b'--attach has none'),
- (['--9p-tcp'], b'--9p-tcp needs'),
- (['--9p-tcp='], b'--9p-tcp needs'),
- (['--9p-tcp=tcp!localhost!5640'], b'--9p-tcp needs'),
- (['--9p-tcp=quic!127.0.0.1!5640'], b'--9p-tcp needs'),
- (['--9p-tcp=tcp!127.0.0.1!5640', '--9p-tcp=tcp!127.0.0.1!5641'], b'specified twice'),
- (['--attach=work', '--9p-tcp=tcp!127.0.0.1!5640'], b'--attach has none'),
- (['--9p-quic'], b'--9p-quic needs'),
- (['--9p-quic='], b'--9p-quic needs'),
- (['--9p-quic=tcp!127.0.0.1!5640'], b'--9p-quic needs'),
- (['--mount=os=work'], b'invalid mount name'),
- (['--mount=peer='], b'invalid mount name or dial'),
- (['--mount=peer=one', '--mount=peer=two'], b'duplicate mount'),
- (['--mount=peer=tcp!127.0.0.1!0'], b'invalid mount dial'),
- (['--attach=work', '--mount=peer=one'], b'--attach has none'),
- ]:
- result = subprocess.run([binary, *options], capture_output=True, timeout=5)
- assert result.returncode == 1 and message in result.stderr, (options, result)
- with tempfile.TemporaryDirectory(prefix='pardes-fs-') as directory:
- root = Path(directory)
- with session(binary, root, 'renamed', '--9p=explicit', socket_name='explicit') as (named, named_address):
- assert named_address.name == 'pardes-9p-explicit.sock'
- assert not (root / 'pardes-9p-renamed.sock').exists()
- assert named.read('/pane/1/body') == b'initial\n'
- with session(binary, root, 'first') as (client, address):
- assert {'pane', 'index', 'status', 'look', 'exec', 'log', 'os'} <= set(client.list('/'))
- assert 'self' not in client.list('/')
- assert client.read('/pane/1/body') == b'initial\n'
- assert client.read('/os' + str(root / 'first.txt')) == b'initial\n'
- assert 'first.txt' in client.list('/os' + str(root))
- assert client.read('/pane/1/../1/body') == b'initial\n'
- assert client.read('/os' + str(root) + '/../' + root.name + '/first.txt') == b'initial\n'
-
- listing = root / 'listing'
- listing.mkdir()
- (listing / 'broken').symlink_to(listing / 'missing')
- for number in range(24):
- (listing / f'entry-{number:02}').touch()
- with Client(address, msize=256) as small:
- assert set(small.list('/os' + str(listing))) == {
- f'entry-{number:02}' for number in range(24)}
- # 64 KiB frames: a ctl line with no newline is held whatever the
- # size of its write -- a mount cuts lines anywhere -- and runs at
- # the close, its failure then in the log.
- with Client(address, msize=65536) as big:
- assert big.msize == 65536
- ctl = big.open('/pane/1/ctl', 1)
- line = b'bogus' + b'x' * 20000
- big.rpc(118, struct.pack('<IQI', ctl, 0, len(line)) + line)
- assert b'ctl: unknown control message' not in client.read('/log')
- big.close(ctl)
- assert b'ctl: unknown control message' in client.read('/log')
-
- frozen = client.open('/screen')
- before = bytearray(client.read_fid(frozen, count=31))
- client.write('/pane/1/body', b'screen changed\n')
- while chunk := client.read_fid(frozen, len(before)):
- before.extend(chunk)
- client.close(frozen)
- old_screen = json.loads(before)
- old_text = ''.join(cell[0] for cell in old_screen['cells'])
- assert 'initial' in old_text and 'screen changed' not in old_text
- assert 'screen changed' in ''.join(cell[0] for cell in client.screen()['cells'])
-
- payload = ('const value = "λ";\n' * 3000).encode()
- serial = new_pane(client, payload)
- body = f'/pane/{serial}/body'
- assert client.read(body) == payload
- client.write(body, b'replaced\n', truncate=True)
- assert client.read(body) == b'replaced\n'
-
- event = client.open(f'/pane/{serial}/event')
- client.write(body, b'event\n')
- record = client.read_fid(event)
- assert record.startswith(b'EI') and b'event\n' in record, record
- client.close(event)
-
- os_path = '/os' + str(root / 'first.txt')
- client.write(os_path, b'written through 9P\n', truncate=True)
- assert (root / 'first.txt').read_bytes() == b'written through 9P\n'
- assert client.read(os_path) == b'written through 9P\n'
-
- for index in range(12):
- with Client(address) as other:
- assert other.read(body) == b'replaced\nevent\n', index
-
- missing = False
- try:
- client.read('/pane/4294967295/body')
- except OSError:
- missing = True
- assert missing
- assert client.read(body) == b'replaced\nevent\n'
-
- if 'src' in client.list('/'):
- source = look(client, '/virtual/src/pardes.zig')
- assert b'pub const Pardes' in client.read(f'/pane/{source}/body')
-
- (root / 'index').write_bytes(b'OS takes precedence\n')
- opened = look(client, 'index')
- assert client.read(f'/pane/{opened}/body') == b'OS takes precedence\n'
- opened = look(client, '/n/self/index')
- index = client.read(f'/pane/{opened}/body')
- assert index.split()[0] == b'1' and b'first.txt' in index, index
- (root / 'explicit.txt').write_bytes(b'explicit OS mount\n')
- opened = look(client, '/n/os' + str(root / 'explicit.txt'))
- assert client.read(f'/pane/{opened}/body') == b'explicit OS mount\n'
-
- own = root / 'pardes-9p-second.sock'
- with session(binary, root, 'second', '--mount=peer=' + str(address),
- '--mount=own=' + str(own)) as (remote, _):
- opened = look(remote, '/n/own/pane/1/body')
- assert remote.read(f'/pane/{opened}/body') == b'initial\n'
- opened = look(remote, '/n/peer/pane/' + str(serial) + '/body')
- assert remote.read(f'/pane/{opened}/body') == b'replaced\nevent\n'
- remote.write(f'/pane/{opened}/body', b'saved to peer\n', truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert client.read(body) == b'saved to peer\n'
-
- large = b'mounted file contents\n' * 60000
- large_path = root / 'large.txt'
- large_path.write_bytes(large)
- opened = look(remote, '/n/peer/os' + str(large_path))
- assert remote.read(f'/pane/{opened}/body') == large
- edited = large[:-3] + b'edited\n'
- remote.write(f'/pane/{opened}/body', edited, truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert large_path.read_bytes() == edited
- assert client.read('/os' + str(large_path)) == edited
- # A path not there under a peer's mount is a miss, as any
- # path to no file is: the write answered, the err logged.
- remote.write('/look', b'/n/peer/os' + str(root / 'no-such-file.txt').encode() + b'\n')
- assert b'no such file' in remote.read('/log')
-
- with session(binary, root, 'runtime') as (remote, own_address):
- control = new_pane(remote, b'')
- execute(remote, control, 'Mount peer ' + str(address))
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- assert remote.read(f'/pane/{opened}/body') == client.read('/pane/1/body')
- # A builtin that fails through exec fails the write (one rule).
- execute_refused(remote, control, 'Mount peer ' + str(own_address), 'already mounted')
- execute_refused(remote, control, 'Unmount peer', 'mount in use') # a pane is open on it
- remote.write(f'/pane/{opened}/body', b'runtime mounted Save\n', truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert client.read('/pane/1/body') == b'runtime mounted Save\n'
- assert remote.read('/pane/1/body') == b'initial\n'
- roots = look(remote, '/n', source=control)
- assert b'/n/peer/\n' in remote.read(f'/pane/{roots}/body')
- remote.write(f'/pane/{opened}/exec', b'Del\n')
- execute(remote, control, 'Unmount peer')
- remote.write(f'/pane/{roots}/ctl', b'get\n')
- assert remote.read(f'/pane/{roots}/body') == b'/n/os/\n/n/self/\n'
- execute(remote, control, 'Mount peer ' + str(own_address))
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- assert remote.read(f'/pane/{opened}/body') == b'initial\n'
-
- with session(binary, root, 'mounted-startup', '--mount=peer=' + str(address),
- file='/n/peer/pane/1/body:1') as (remote, _):
- assert remote.read('/pane/1/body') == b'runtime mounted Save\n'
-
- client.write(f'/pane/{serial}/exec', b'Del\n')
- assert str(serial) not in client.list('/pane')
-
- for tty in [False, True]:
- name = 'restore tty space' if tty else 'restore detached space'
- with session(binary, root, name, tty=tty) as (old, address):
- old.write('/pane/1/body', b'dumped state\n', truncate=True)
- control = new_pane(old, b'')
- execute_refused(old, control, 'Restore ' + str(root / 'missing dump.zon'), 'no such file')
- assert old.read('/pane/1/body') == b'dumped state\n'
- execute(old, control, 'Mount own ' + str(address))
- execute(old, control, 'Dump')
- saved = root / (name + '.dump.zon')
- deadline = time.monotonic() + 5
- while not saved.exists():
- assert time.monotonic() < deadline, 'Dump did not write its state'
- time.sleep(.005)
- held_body = old.open('/pane/1/body')
- held_screen = old.open('/screen')
- old_ids = {int(row.split()[0]) for row in old.read('/index').splitlines()}
- assert old.read_fid(held_body) == b'dumped state\n'
- assert old.read_fid(held_screen, count=1) == b'{'
- old.write('/pane/1/body', b'changed after dump\n', truncate=True)
- # Unsaved text is asked about once, as Exit asks; the second
- # Restore goes ahead, and is answered before the hang-up.
- try:
- execute(old, control, 'Restore ' + str(saved))
- except OSError as refused:
- assert 'Modified' in str(refused), refused
- assert old.read('/pane/1/body') == b'changed after dump\n'
- # Answered before the hang-up: the write's reply comes; the
- # clunk after it may meet the connection already cut.
- restore = old.open(f'/pane/{control}/exec', 1)
- line = ('Restore ' + str(saved) + '\n').encode()
- old.rpc(118, struct.pack('<IQI', restore, 0, len(line)) + line)
- try:
- old.close(restore)
- except (EOFError, OSError):
- pass
- # Refused while the connections are cut, or cut already.
- try:
- old.read_fid(held_body)
- except (EOFError, OSError):
- pass
- else:
- raise AssertionError('Restore left an old body fid usable')
- with Client(address) as restored:
- # The new log names its panes, then where they came from.
- log = restored.read('/log')
- assert b'\nrestore ' + str(saved).encode() + b'\n' in log, log
- # Its panes are the dump's, their serials too.
- restored_ids = [int(row.split()[0]) for row in restored.read('/index').splitlines()]
- assert len(restored_ids) == 2 and set(restored_ids) == old_ids, restored_ids
- file_id, control_id = restored_ids
- contents = restored.read(f'/pane/{file_id}/body')
- assert contents == b'dumped state\n', (contents, saved.read_text(), restored.read('/index'))
- assert restored.read(f'/pane/{control_id}/body') == b'', 'commands ran through exec, not the body'
- assert restored.screen()['cols'] == (80 if tty else 160) # a detached one is 160x50
- opened = look(restored, '/n/own/os' + str(root / (name + '.txt')), source=control_id)
- assert restored.read(f'/pane/{opened}/body') == b'initial\n'
-
- with session(binary, root, 'forwarding') as (client, address):
- child_dir = root / 'child-working-directory'
- child_dir.mkdir()
- spaced = child_dir / 'space name.txt'
- spaced.write_bytes(b'first line\nsecond line\n')
- env = os.environ.copy()
- # PARDES_PID is what says "you are inside a pardes"; the socket
- # and the pane only say how to reach it. Without the pid the child
- # starts its own session, so this test used to pass only when the
- # runner itself happened to be running inside one.
- status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
- env.update(PARDES_9P=str(address), PARDES_PANE='1', PARDES_PID=status['pid'])
- env.pop('PARDES_FORWARD_LOOK', None)
- for word, expected, selected, reuse in [('space name.txt:2:4', spaced.read_bytes(), [14, 14], False),
- ('/n/self/pane/1/body', b'initial\n', None, False),
- ('/virtual/pane/1/body:1:2-4', b'initial\n', [1, 4], True)]:
- before = {int(row.split()[0]) for row in client.read('/index').splitlines()}
- result = subprocess.run([binary, '--tty', word], cwd=child_dir, env=env,
- capture_output=True, timeout=3)
- assert result.returncode == 0, (word, result.stderr)
- after = {int(row.split()[0]) for row in client.read('/index').splitlines()}
- if reuse:
- assert after == before
- else:
- opened, = after - before
- assert client.read(f'/pane/{opened}/body') == expected
- assert client.read('/pane/1/body') == b'initial\n'
- if selected is not None:
- # The selection is dot; reading it takes no command at all.
- actual = list(map(int, client.read(f'/pane/{opened}/dot').split()))
- assert actual == selected, (word, actual, selected)
- addr = client.open('/pane/1/addr', 2)
- limit = client.open('/pane/1/limit', 2)
- for fid, text in [(addr, b'#0,#3'), (limit, b'#0,#3'), (addr, b'#0')]:
- client.rpc(118, struct.pack('<IQI', fid, 0, len(text)) + text)
- try:
- for _ in range(8):
- result = subprocess.run([binary], cwd=child_dir, env=env,
- capture_output=True, timeout=3)
- assert result.returncode == 1 and b'already inside pardes' in result.stderr
- text = b'/tial/'
- try:
- client.rpc(118, struct.pack('<IQI', addr, 0, len(text)) + text)
- except OSError:
- pass
- else:
- raise AssertionError('no-argument child cleared the parent address limit')
- finally:
- client.close(addr)
- client.close(limit)
- client.read('/pane/1/ctl')
-
- control = new_pane(client, b'')
- execute(client, control, 'Dump')
- saved = root / 'forwarding.dump.zon'
- deadline = time.monotonic() + 3
- while not saved.exists():
- assert time.monotonic() < deadline, 'forwarding fixture Dump did not finish'
- time.sleep(.005)
- before = client.read('/index')
- inherited = {key: env[key] for key in ['PARDES_9P', 'PARDES_PANE', 'PARDES_PID']}
- cases = [
- ('mount', ['--mount=peer=' + str(address), '/n/peer/pane/1/body'], None),
- ('name', ['--9p=forwarded-name'], 'forwarded-name'),
- ('tcp', ['--9p-tcp=tcp!127.0.0.1!0'], None),
- ('load', ['-l', str(saved)], None),
- ('shells', ['-n', '3'], None),
- ('toggle', ['--tty-toggle=q'], None),
- ('toggle-arg', ['--tty-toggle', 'q'], None),
- ]
- if quic:
- cases.append(('quic', ['--9p-quic=quic!127.0.0.1!0'], None))
- for name, options, socket_name in cases:
- with session(binary, root, 'forward-' + name, tty=True, socket_name=socket_name,
- launch=[*([] if name == 'shells' else ['--tty']), *options],
- inherited=inherited) as (local, local_address):
- assert local_address != address
- index = local.read('/index').splitlines()
- if name == 'mount':
- assert len(index) == 1 and b'/n/peer/' in index[0], index
- assert local.read('/pane/1/body') == b'initial\n'
- elif name == 'load':
- assert local.read('/index') == before
- assert local.read('/pane/1/body') == b'initial\n'
- else:
- # A bare tty launch is a shell plus the empty text pane
- # the boot puts under it; --shells=3 is the classic
- # three-shell layout and has no scratch.
- assert len(index) == (3 if name == 'shells' else 2), index
- if name in ['tcp', 'quic']:
- assert (name + '!127.0.0.1!').encode() in local.read('/listeners')
- assert client.read('/index') == before
- assert client.read('/pane/1/body') == b'initial\n'
-
- # A session that answers takes the file or says why, as acme's B
- # does: a pane it has not is its refusal and exit 1, never a
- # nested editor drawn inside the pane that asked.
- gone = subprocess.run([binary, '--tty', str(spaced)], cwd=root,
- env=dict(env, PARDES_PANE='4294967295'), stdin=subprocess.DEVNULL,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert gone.returncode == 1 and gone.stderr.startswith(b'pardes: '), gone
- assert client.read('/index') == before
- for name, identity, word in [
- ('stale-file', dict(inherited, PARDES_9P=str(root / 'absent.sock')), str(spaced)),
- ('stale-missing', dict(inherited, PARDES_9P=str(root / 'absent.sock')), 'missing-child-file.txt'),
- ('stale-noarg', dict(inherited, PARDES_9P=str(root / 'absent.sock')), None),
- # No pid means "not inside a pardes at all", which is what
- # --nested withholds and what a plain shell has.
- ('not-nested', {k: v for k, v in inherited.items() if k != 'PARDES_PID'}, str(spaced)),
- ]:
- with session(binary, root, name, tty=True, inherited=identity,
- launch=['--tty', *([word] if word else [])]) as (local, local_address):
- assert local_address != address
- if word == str(spaced):
- assert local.read('/pane/1/body') == spaced.read_bytes()
- elif word:
- assert word.encode() in local.read('/index') or word in ''.join(
- cell[0] for cell in local.screen()['cells'])
- assert client.read('/index') == before
-
- # --wait (acme's E): a launch inside a pane lasts until the pane it
- # opened is deleted, as an $EDITOR must; one on a file already open
- # waits on that pane; a session that goes away ends it with 1.
- with session(binary, root, 'wait') as (client, address):
- # A command run from a pane's tag gets acme's $winid, that pane;
- # one from the workspace's tag, none.
- def command_body(node, line):
- client.write(node, line)
- serial = int(client.read(node).split()[-1])
- deadline = time.monotonic() + 10
- while True:
- log = client.read('/log').decode()
- ran = log.rfind(f'\nrun {serial} ')
- if ran >= 0 and f'\nexit {serial} ' in log[ran:]:
- body = client.read(f'/pane/{serial}/body').decode().split('% echo winid')[-1]
- client.remove(f'/pane/{serial}')
- return body
- assert time.monotonic() < deadline, log[-400:]
- time.sleep(.05)
- first_pane = min(int(row.split()[0]) for row in client.read('/index').splitlines())
- assert f'winid={first_pane}\n' in command_body(f'/pane/{first_pane}/tagexec', b'echo winid=$winid\n')
- assert 'winid=\n' in command_body('/tagexec', b'echo winid=$winid\n')
- # A second --detach of a name a live session holds: said, exit 1,
- # no Zig error trace.
- second_env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- second_env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root))
- second = subprocess.run([binary, '--detach=wait'], cwd=root, env=second_env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=20)
- assert second.returncode == 1, second
- assert second.stderr == b'pardes: a session named wait is already running\n', second.stderr
- status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
- env = {k: v for k, v in os.environ.items() if k != 'PARDES_FORWARD_LOOK'}
- env.update(PARDES_9P=str(address), PARDES_PANE='1', PARDES_PID=status['pid'])
- edited = root / 'wait edit.txt'
- edited.write_bytes(b'edit me\n')
-
- def serials():
- return {int(row.split()[0]) for row in client.read('/index').splitlines()}
-
- def launch(flag):
- before = serials()
- child = subprocess.Popen([binary, flag, str(edited)], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 3
- while child.poll() is None and not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- return child
-
- first = launch('--wait')
- opened, = serials() - {1}
- second = launch('-w')
- time.sleep(.5)
- assert first.poll() is None and second.poll() is None, (first.stderr.read(), second.stderr.read())
- assert serials() == {1, opened}
- client.write(f'/pane/{opened}/body', b'edited\n', truncate=True)
- execute(client, opened, 'Save')
- client.remove(f'/pane/{opened}')
- deleted = time.monotonic()
- assert first.wait(timeout=5) == 0
- # Woken by the `del` record, not a poll.
- assert time.monotonic() - deleted < .05, time.monotonic() - deleted
- assert second.wait(timeout=5) == 0
- assert edited.read_bytes() == b'edited\n'
- # --wait from outside the session's panes, $PARDES_9P alone (an
- # agent's EDITOR): asked of the session, not a screen of its own.
- outside_env = {k: v for k, v in env.items() if k not in ('PARDES_PANE', 'PARDES_PID')}
- far = root / 'wait far.txt'
- far.write_bytes(b'far\n')
- before = serials()
- waiting = subprocess.Popen([binary, '--wait', str(far)], cwd=root, env=outside_env,
- stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 5
- while not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- far_pane, = serials() - before
- time.sleep(.3)
- assert waiting.poll() is None, waiting.stderr.read()
- client.remove(f'/pane/{far_pane}')
- assert waiting.wait(timeout=5) == 0
- # --wait with a $PARDES_9P that answers no more: said, exit 1,
- # never a screen of its own drawn in the asker's terminal.
- dead_env = dict(outside_env, PARDES_9P=str(root / 'pardes-9p-gone.sock'))
- gone = subprocess.run([binary, '--wait', str(far)], cwd=root, env=dead_env, capture_output=True, timeout=10)
- assert gone.returncode == 1 and b'does not answer' in gone.stderr, gone
- # --wait with no FILE says it needs one, and waits on nothing.
- bare = subprocess.run([binary, '--wait'], cwd=root, env=env, capture_output=True, timeout=10)
- assert bare.returncode == 1 and b'--wait needs a FILE' in bare.stderr, bare
- # `--` ends the options: a name starting with a dash is a name.
- dash = root / '-dash.txt'
- dash.write_bytes(b'dash\n')
- before = serials()
- assert subprocess.run([binary, '--', dash.name], cwd=root, env=env, capture_output=True, timeout=10).returncode == 0
- dashed, = serials() - before
- assert client.read(f'/pane/{dashed}/name').rstrip(b'\n') == str(dash).encode()
- client.remove(f'/pane/{dashed}')
- # A name under a directory that may not be searched is refused,
- # permission denied, exit 1, no pane: its Save could never be.
- # (Root searches any directory.)
- if os.geteuid() != 0:
- (root / 'noperm').mkdir()
- (root / 'noperm').chmod(0)
- before = serials()
- try:
- denied = subprocess.run([binary, 'noperm/a/b/c'], cwd=root, env=env, capture_output=True, timeout=10)
- finally:
- (root / 'noperm').chmod(0o755)
- assert denied.returncode == 1 and b'permission denied' in denied.stderr, denied
- assert serials() == before
- # --wait waits on the pane its look answered, on the look's own
- # open: a name /index shows escaped (a backslash is `\\` there)
- # is still the pane waited on, not one already gone.
- odd = root / 'wait\\odd.txt'
- odd.write_bytes(b'odd\n')
- before = serials()
- waiting = subprocess.Popen([binary, '--wait', str(odd)], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 3
- while not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- odd_pane, = serials() - before
- time.sleep(.5)
- assert waiting.poll() is None, waiting.stderr.read()
- client.remove(f'/pane/{odd_pane}')
- assert waiting.wait(timeout=5) == 0
- # A name not there yet opens a pane named it, as acme's B does,
- # and Save creates it: git's and fish's temporary files are.
- fresh = root / 'wait new.txt'
- before = serials()
- made = subprocess.Popen([binary, '--wait', fresh.name], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- # The launch makes the pane (pane/new), then names it: wait for
- # the name, not the pane.
- deadline = time.monotonic() + 3
- while str(fresh).encode() not in client.read('/index'):
- assert made.poll() is None, made.stderr.read()
- assert time.monotonic() < deadline, 'a new name opened no pane named it'
- time.sleep(.01)
- named, = serials() - before
- client.write(f'/pane/{named}/body', b'new\n')
- execute(client, named, 'Save')
- client.remove(f'/pane/{named}')
- code = made.wait(timeout=5)
- assert code == 0, (code, made.stderr.read())
- assert fresh.read_bytes() == b'new\n'
- # ...in a directory not there either: forwarded all the same, and
- # Save makes the directories.
- deep = root / 'wait-missing' / 'sub' / 'new.txt'
- before = serials()
- made = subprocess.Popen([binary, 'wait-missing/sub/new.txt'], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- assert made.wait(timeout=5) == 0, made.stderr.read()
- deadline = time.monotonic() + 3
- while str(deep).encode() not in client.read('/index'):
- assert time.monotonic() < deadline, 'a name in a missing directory opened no pane named it'
- time.sleep(.01)
- named, = serials() - before
- client.write(f'/pane/{named}/body', b'deep\n')
- execute(client, named, 'Save')
- client.remove(f'/pane/{named}')
- assert deep.read_bytes() == b'deep\n'
- # `pardes '~/x'`, quoted so the shell left the `~`: home all the
- # same: the launching shell's HOME.
- before = serials()
- quoted = subprocess.run([binary, '~/fwd-tilde.txt'], cwd=root, env=dict(env, HOME=str(root)),
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=10)
- assert quoted.returncode == 0, quoted.stderr
- assert f'{root}/fwd-tilde.txt'.encode() in client.read('/index'), client.read('/index')
- for serial in serials() - before:
- client.remove(f'/pane/{serial}')
- # A name the session refuses: its reason and exit 1, as B's,
- # never a nested editor, and no pane left for it.
- before = serials()
- refused = subprocess.run([binary, 'x' * 300 + '.txt'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert b'a component over 255 bytes' in refused.stderr, refused.stderr
- assert serials() == before, (serials(), before)
- # A pane address the session has not is refused in words, exit
- # 1, no pane made for a file of that name; one it has is looked
- # at. A name with a newline is said in words, not an error name.
- # `pardes -` (a terminal's PAGER): stdin, its escapes stripped, in a
- # +Pager pane of the session, clean, and back at once.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'\x1b[1mbold\x1b[0m text\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- made_now, = serials() - before
- assert client.read(f'/pane/{made_now}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{made_now}/body') == b'bold text\n'
- row = [r for r in client.read('/index').splitlines() if r.split()[0] == str(made_now).encode()][0]
- assert row.split()[2] == b'0', row # clean: nothing to ask at Exit
- # Its `new` record names it as it is: no +New and a rename.
- log_now = client.read('/log').decode()
- assert f'\nnew {made_now} {root}/+Pager\n' in '\n' + log_now, log_now[-400:]
- assert f'\nrename {made_now} ' not in '\n' + log_now
- # Its colours are the pane's, drawn and never read: the body is
- # the plain text, and the screen shows `red` in the theme's red,
- # the rest in the pane's ink. Mapped through the theme, as a
- # terminal's are; Filter shows them as sent, `rgb` in the colour
- # given.
- # Each run is its own +Pager; one there already keeps its page.
- fed = subprocess.run([binary, '-'], cwd=root, env=env,
- input=b'\x1b]0;title\x07\x1b[31mred\x1b[m \x1b[38;2;1;2;3mrgb\x1b[m plain\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- coloured, = serials() - before - {made_now}
- assert client.read(f'/pane/{coloured}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{coloured}/body') == b'red rgb plain\n'
- assert client.read(f'/pane/{made_now}/body') == b'bold text\n'
- def inks():
- screen = client.screen()
- for row in range(screen['rows']):
- cells = screen['cells'][row * screen['cols']:(row + 1) * screen['cols']]
- at = ''.join(cell[0] for cell in cells).find('red rgb plain')
- if at >= 0:
- return [screen['styles'][cells[at + i][1]]['fg'] for i in (0, 4, 8)]
- raise AssertionError(('the paged text is not on the screen', screen))
- ink = inks()
- assert ink[0] != ink[2] and ink[1] != {'rgb': [1, 2, 3]}, ink
- client.write(f'/pane/{coloured}/exec', b'Filter\n')
- ink = inks()
- assert ink[1] == {'rgb': [1, 2, 3]}, ink
- assert ink[0] != ink[2] and ink[0] != ink[1], ink
- # A progress line keeps its last state.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'again\r\nprogress 10%\rprogress 100%\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- again, = serials() - before - {made_now, coloured}
- assert client.read(f'/pane/{again}/body') == b'again\nprogress 100%\n'
- for serial in (made_now, coloured, again):
- client.remove(f'/pane/{serial}')
- # More than one 8 MiB write's worth arrives whole, byte for byte,
- # in its +Pager (each write once replaced the last).
- big = b''.join(b'line %08d of the paged text\n' % i for i in range(400000)) # ~11 MiB
- assert len(big) > 8 * 1024 * 1024
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=big,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=120)
- assert fed.returncode == 0, fed.stderr
- big_pane, = serials() - before
- assert client.read(f'/pane/{big_pane}/body') == big, 'the paged body is not the text'
- # Past the 256 MiB cap: the first 256 MiB, then the cut note.
- cap = 256 * 1024 * 1024
- huge = subprocess.Popen(['sh', '-c', f'yes 0123456789abcdef | head -c {cap + 4096}'], stdout=subprocess.PIPE)
- fed = subprocess.run([binary, '-'], cwd=root, env=env, stdin=huge.stdout,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=600)
- huge.wait()
- assert fed.returncode == 0, fed.stderr
- client.remove(f'/pane/{big_pane}')
- big_pane, = serials() - before
- got = client.read(f'/pane/{big_pane}/body')
- note = b'\n[pardes: the rest of stdin is cut: a pane holds at most a file\'s limit]\n'
- assert got.endswith(note) and len(got) == cap + len(note), (len(got), got[-120:])
- assert got[:cap] == (b'0123456789abcdef\n' * (cap // 17 + 1))[:cap]
- del got, big
- client.remove(f'/pane/{big_pane}')
- # From a directory whose name could not be a ctl line: the
- # session's directory's +Pager, the text whole, no stray +New.
- odd = root / 'two\nlines'
- odd.mkdir()
- fed = subprocess.run([binary, '-'], cwd=odd, env=env, input=b'odd dir text\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- odd_pane, = serials() - before
- assert client.read(f'/pane/{odd_pane}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{odd_pane}/body') == b'odd dir text\n'
- client.remove(f'/pane/{odd_pane}')
- # Nothing on stdin: no pane, and done.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0 and serials() == before, (fed, serials())
- # A new name in a directory there but not writable: refused now,
- # not a pane that only fails at Save. (Root writes anywhere.)
- shut = root / 'shut-dir'
- shut.mkdir()
- shut.chmod(0o500)
- try:
- if os.geteuid() != 0:
- refused = subprocess.run([binary, 'shut-dir/new.txt'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert b'may not be read or written' in refused.stderr, refused.stderr
- assert serials() == before, (serials(), before)
- finally:
- shut.chmod(0o755)
- for word, said in (('@p999:1', b'pardes: @p999:1: this session has no such pane'),
- ('two\nlines.txt', b'pardes: two\\nlines.txt: a file name is one line')):
- refused = subprocess.run([binary, word], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert said in refused.stderr, refused.stderr
- assert b'NotOneLine' not in refused.stderr and b'NoSuchPane' not in refused.stderr
- assert serials() == before, (serials(), before)
- looked = subprocess.run([binary, '@p1:1'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert looked.returncode == 0, looked.stderr
- assert serials() == before, (serials(), before)
- orphan = launch('--wait')
- assert orphan.poll() is None
- assert orphan.wait(timeout=5) == 1
-
- # `pardes -` outside a session: an editor whose first pane is a
- # +Pager of stdin, as `vim -`; here a detached one, to read it.
- outside_env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- outside_env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), PARDES_NOTIME='1')
- boot = subprocess.Popen([binary, '--detach=stdinboot', '-'], cwd=root, env=outside_env,
- stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
- start_new_session=True)
- try:
- boot.stdin.write(b'\x1b[32mfrom stdin\x1b[m\nsecond\n')
- boot.stdin.close()
- sock = root / 'pardes-9p-stdinboot.sock'
- deadline = time.monotonic() + 10
- while not sock.exists():
- assert boot.poll() is None, boot.stderr.read()
- assert time.monotonic() < deadline, 'the stdin boot never listened'
- time.sleep(.05)
- with Client(str(sock)) as booted:
- first = booted.read('/index').split(b'\n')[0].split()
- assert first[3] == f'{root}/+Pager'.encode(), first
- assert booted.read(f'/pane/{first[0].decode()}/body') == b'from stdin\nsecond\n'
- finally:
- boot.terminate()
- boot.wait(timeout=10)
-
- # Killed with SIGTERM or SIGHUP, a tty editor puts its terminal
- # back (main screen, cooked mode) before it dies: a nested one
- # killed in a pane leaves that pane usable.
- # ...and its 9P socket goes with it. One a dead editor left behind
- # (no process has its pid) is swept at the next start; a live
- # pid's, here this test's own, never is.
- def unix_socket_file(path):
- made = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- made.bind(str(path))
- made.close()
- for sig in (signal.SIGTERM, signal.SIGHUP):
- dead_socket = root / 'pardes-9p-2147483647.sock'
- live_socket = root / f'pardes-9p-{os.getpid()}.sock'
- for path in (dead_socket, live_socket):
- if not path.exists():
- unix_socket_file(path)
- master, slave = os.openpty()
- fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', 24, 80, 0, 0))
- cooked = termios.tcgetattr(slave)
- env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), TERM='xterm-256color', PARDES_NOTIME='1')
- existing = set(root.glob('pardes-9p-*.sock'))
- killed = subprocess.Popen([binary, '--tty', 'x.txt'], cwd=root, env=env,
- stdin=slave, stdout=slave, stderr=subprocess.DEVNULL,
- start_new_session=True,
- preexec_fn=lambda: fcntl.ioctl(0, termios.TIOCSCTTY, 0))
- seen = b''
- try:
- deadline = time.monotonic() + 10
- while b'\x1b[?1049h' not in seen:
- assert time.monotonic() < deadline, seen[-200:]
- if select.select([master], [], [], .1)[0]:
- seen += os.read(master, 65536)
- time.sleep(.3)
- # The session's own, named by its pid: forked off the
- # launched process, which stays as its stub.
- own_socket, = set(root.glob('pardes-9p-*.sock')) - existing
- assert not dead_socket.exists()
- assert live_socket.exists()
- killed.send_signal(sig)
- assert killed.wait(timeout=5) == -sig
- if sig == signal.SIGHUP:
- # A hangup is the terminal's end: the session carries on
- # detached (the daemon keeps it) until told to end.
- assert own_socket.exists(), own_socket
- os.kill(int(own_socket.name[len('pardes-9p-'):-len('.sock')]), signal.SIGTERM)
- deadline = time.monotonic() + 5
- while own_socket.exists() and time.monotonic() < deadline:
- time.sleep(.01)
- assert not own_socket.exists(), own_socket
- while select.select([master], [], [], .2)[0]:
- try:
- chunk = os.read(master, 65536)
- except OSError:
- break
- if not chunk:
- break
- seen += chunk
- tail = seen[seen.rindex(b'\x1b[?1049h'):]
- assert b'\x1b[?1049l' in tail, tail[-200:]
- assert termios.tcgetattr(slave)[3] & termios.ICANON == cooked[3] & termios.ICANON
- finally:
- if killed.poll() is None:
- killed.kill()
- killed.wait()
- os.close(master)
- os.close(slave)
-
- # A launch with no terminal to draw on (a pty that is no one's
- # controlling terminal) says so and exits 1, no error trace.
- master, slave = os.openpty()
- try:
- env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), TERM='xterm-256color')
- result = subprocess.run([binary, '--tty', 'x.txt'], cwd=root, env=env, stdin=slave, stdout=slave,
- stderr=subprocess.PIPE, start_new_session=True, timeout=10)
- finally:
- os.close(master)
- os.close(slave)
- assert result.returncode == 1, result
- assert b'pardes: no terminal to draw on' in result.stderr and b'.zig:' not in result.stderr, result.stderr
-
- for tty in [False, True]:
- name = 'lsp-tty' if tty else 'lsp-detached'
- with session(binary, root, name, tty=tty) as (client, _):
- control = new_pane(client, b'')
- execute(client, control, 'Lspinfo')
- deadline = time.monotonic() + 3
- while True:
- matches = [int(row.split()[0]) for row in client.read('/index').splitlines()
- if b'+Lsp' in row]
- if matches:
- break
- assert time.monotonic() < deadline, (name, 'Lspinfo did not complete')
- time.sleep(.005)
- assert len(matches) == 1, matches
- result = client.read(f'/pane/{matches[0]}/body')
- assert result.startswith(b'backend: lsp-client\n'), result
- assert b'protocol servers (lsp-client):' in result, result
- assert client.read('/pane/1/body') == b'initial\n'
- assert '+Lsp' in ''.join(cell[0] for cell in client.screen()['cells'])
-
- with session(binary, root, 'highlight') as (client, _):
- client.write('/pane/1/name', b'keywords.zig\n')
- source = b'// padding\n' * 9999 + b'fn check() void {\n if (true) return;\n}\n'
- client.write('/pane/1/body', source, truncate=True)
- screen = client.screen()
- assert len(screen['cells']) == screen['cols'] * screen['rows']
- found = set()
- for row in range(screen['rows']):
- cells = screen['cells'][row * screen['cols']:(row + 1) * screen['cols']]
- text = ''.join(cell[0] for cell in cells)
- for word in ['fn', 'if']:
- start = text.find(word + ' ')
- if start < 0:
- continue
- styles = [screen['styles'][cell[1]] for cell in cells[start:start + len(word)]]
- # Weight is opt-in (SyntaxBold, off by default); colour is
- # not, so the keyword must differ from the text beside it.
- plain = screen['styles'][cells[start + len(word)][1]]
- assert all(not style['bold'] and style['fg'] == styles[0]['fg'] for style in styles), (word, styles)
- assert styles[0]['fg'] != plain['fg'], (word, styles[0], plain)
- found.add(word)
- assert found == {'fn', 'if'}, screen
-
- with session(binary, root, 'long-names') as (client, _):
- directory = root / ('directory-' + 'd' * 54)
- directory.mkdir()
- for length in [29, 63, 127, 255]:
- name = 'f' * (length - 4) + '.txt'
- path = directory / name
- path.write_bytes(b'long filename\n')
- wire_path = '/os' + str(path)
- assert name in client.list('/os' + str(directory))
- assert client.read(wire_path) == b'long filename\n'
- client.write(wire_path, b'written through long filename\n', truncate=True)
- assert path.read_bytes() == b'written through long filename\n'
- opened = look(client, '/n/os' + str(path))
- assert client.read(f'/pane/{opened}/body') == path.read_bytes()
- client.remove(f'/pane/{opened}') # a long name's tag takes rows
- opened = look(client, '/n/os' + str(directory))
- listing = client.read(f'/pane/{opened}/body')
- for path in directory.iterdir():
- assert ('/n/os' + str(path)).encode() in listing
- if quic:
- quic_test(binary)
- print(f'9P integration: passed ({time.monotonic() - started:.3f}s)')
-
-
-def quic_test(binary):
- for tty in [False, True]:
- for host in ['127.0.0.1', '::1']:
- with tempfile.TemporaryDirectory(prefix='pardes-quic-fs-') as directory:
- root = Path(directory)
- ports = {}
- with session(binary, root, 'server', '--9p-tcp=tcp!' + host + '!0',
- '--9p-quic=quic!' + host + '!0', tty=tty, network=ports) as (unix, address):
- assert set(unix.read('/listeners').decode().splitlines()) == {
- 'unix!' + str(address), 'tcp!' + host + '!' + str(ports['TCP']),
- 'quic!' + host + '!' + str(ports['QUIC'])}
- with Client((host, ports['TCP'])) as tcp:
- unix_body = unix.open('/pane/1/body')
- tcp_body = tcp.open('/pane/1/body')
- with session(binary, root, 'client') as (remote, _):
- control = new_pane(remote, b'')
- dial = 'quic!' + host + '!' + str(ports['QUIC'])
- execute(remote, control, 'Mount peer ' + dial)
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- body = f'/pane/{opened}/body'
- assert remote.read(body) == b'initial\n'
- payload = 'saved café λ\n'.encode() + b'x' * (3 * 8192 + 27) + b'\n'
- remote.write(body, payload, truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert unix.read_fid(unix_body) == payload[:unix.msize - 11]
- assert tcp.read('/pane/1/body') == payload
- tcp.write('/pane/1/body', b'TCP to QUIC Get\n', truncate=True)
- remote.write(f'/pane/{opened}/ctl', b'get\n')
- assert remote.read(body) == b'TCP to QUIC Get\n'
- assert unix.read_fid(unix_body) == b'TCP to QUIC Get\n'
- assert tcp.read_fid(tcp_body) == b'TCP to QUIC Get\n'
- screen_pane = look(remote, '/n/peer/screen', source=control)
- screen = json.loads(remote.read(f'/pane/{screen_pane}/body'))
- assert len(screen['cells']) == screen['cols'] * screen['rows']
- # The peer's own screen, whole, over QUIC. Its pane's
- # tag, not its text: where the view sits after the
- # body shrank from a long wrapped line depends on
- # whether a frame was drawn meanwhile (sometimes
- # on the empty last line, ` 2`, text off-screen).
- assert 'server.txt Save' in ''.join(cell[0] for cell in screen['cells'])
- large = ('normal λ line\n' * 20000).encode()
- fixture = root / 'large.txt'
- fixture.write_bytes(large)
- large_pane = look(remote, '/n/peer/os' + str(fixture), source=control)
- assert remote.read(f'/pane/{large_pane}/body') == large
- edited = b'QUIC file saved\n'
- remote.write(f'/pane/{large_pane}/body', edited, truncate=True)
- remote.write(f'/pane/{large_pane}/exec', b'Save\n')
- assert fixture.read_bytes() == edited
- for pane in [opened, screen_pane, large_pane]:
- remote.write(f'/pane/{pane}/exec', b'Del\n')
- execute(remote, control, 'Unmount peer')
- roots = look(remote, '/n', source=control)
- assert remote.read(f'/pane/{roots}/body') == b'/n/os/\n/n/self/\n'
- assert unix.read_fid(unix_body) == b'TCP to QUIC Get\n'
- assert tcp.read_fid(tcp_body) == b'TCP to QUIC Get\n'
- # Not checked: a session Looking at its OWN tree through
- # a QUIC mount ('Mount own quic!...'). QUIC is still
- # answered on the editor's thread (cloud9's QUIC adapter
- # is not std.Io based), so that Look waits on the loop
- # it is running in and opens nothing; features.txt lists
- # it under "Left as they are". Unix and TCP self-mounts
- # are covered by test/selfmount.py.
- unix.close(unix_body)
- tcp.close(tcp_body)
-
-
if __name__ == '__main__':
- if len(sys.argv) in [3, 4] and sys.argv[2] == '--discovery':
- discovery(str(Path(sys.argv[1]).resolve()), embedded=sys.argv[3:] == ['--embedded'])
- raise SystemExit(0)
- if len(sys.argv) not in [2, 3] or (len(sys.argv) == 3 and sys.argv[2] != '--quic'):
- raise SystemExit('usage: fs.py <pardes> [--quic | --discovery]')
- test(str(Path(sys.argv[1]).resolve()), quic=len(sys.argv) == 3)
+ raise SystemExit('fs.py is the helpers the developer tools share (session, new_pane, '
+ 'execute); its tests are Zig now: zig build behaviour-test process-test')