kitty/kitty_tests/resize_edge.py
Kovid Goyal c406b136cb
Cleanup previous PR
- Only restore entry sizes in the Splits layout resize mode was opened in;
  otherwise fall back to the default reset rather than refusing to reset
- Do not take a snapshot lazily from already resized sizes when resize mode
  was opened in another layout
- Running the resize kitten while its overlay is open replaces the overlay so
  the new options take effect, keeping the original-size snapshot
- Newer edge statuses replace older local messages, and edge failures beep
- Switching strategy no longer discards a --fraction command-line override
- Compute divider room without deep copying the pair subtree
- Fractional resize in other layouts adopts the probed state instead of
  replaying every step
2026-10-09 19:51:38 +05:30

345 lines
19 KiB
Python

#!/usr/bin/env python
# License: GPLv3 Copyright: 2026, Kovid Goyal, <kovid at kovidgoyal.net>
import json
from math import ceil
from types import SimpleNamespace
from unittest.mock import Mock, patch
from kitty.layout.base import lgd
from kitty.rc.base import PayloadGetter
from kitty.rc.resize_window import resize_window
from kitty.rc.resize_window_edge import ResizeWindowEdge
from . import layout as geometry_tests
class TestResizeEntry(geometry_tests.BaseTest):
def test_reenter_resize_replaces_existing_overlay(self):
from kitty.boss import Boss
launched = []
def create_kitten_handler(kitten, args):
launched.append(args)
raise AssertionError('Launched')
for name in ('resize_window', 'resize-window'):
cmd = ResizeWindowEdge()
base = Mock(is_resize_overlay=False)
resize = Mock(is_resize_overlay=True)
# Another overlay can temporarily cover the resize UI.
other = Mock(is_resize_overlay=False)
group = SimpleNamespace(windows=[base, resize, other])
tab = SimpleNamespace(windows=SimpleNamespace(group_for_window=lambda w: group), set_active_window=Mock())
base.tabref = other.tabref = lambda: tab
session = cmd.start_session(resize, None)
boss = SimpleNamespace(active_window=other, active_tab=tab, mark_window_for_close=Mock())
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd), patch('kittens.runner.create_kitten_handler', create_kitten_handler):
with self.assertRaisesRegex(AssertionError, 'Launched'):
Boss.run_kitten_with_metadata(boss, name, args=['--strategy=edge'])
# The new options are used, the old UI is closed and its snapshot is handed over
self.ae(launched.pop(), ['--strategy=edge'])
boss.mark_window_for_close.assert_called_once_with(resize)
self.assertNotIn(resize, cmd.sessions)
new_overlay = Mock()
self.assertIs(cmd.start_session(new_overlay, None, session), session)
self.assertIs(cmd.sessions[new_overlay], session)
tab.set_active_window.assert_not_called()
def test_resize_reentry_is_scoped_to_kitten_and_pane(self):
from kitty.boss import Boss
shell = SimpleNamespace(is_resize_overlay=False)
resize = SimpleNamespace(is_resize_overlay=True)
group = SimpleNamespace(windows=[shell])
tab = SimpleNamespace(windows=SimpleNamespace(group_for_window=lambda w: group), set_active_window=Mock())
window = SimpleNamespace(tabref=lambda: tab)
boss = SimpleNamespace(active_window=window, active_tab=tab, mark_window_for_close=Mock())
with patch('kittens.runner.create_kitten_handler', side_effect=AssertionError('Normal launch')):
with self.assertRaisesRegex(AssertionError, 'Normal launch'):
Boss.run_kitten_with_metadata(boss, 'resize_window')
group.windows.append(resize)
with self.assertRaisesRegex(AssertionError, 'Normal launch'):
Boss.run_kitten_with_metadata(boss, 'hints')
tab.set_active_window.assert_not_called()
boss.mark_window_for_close.assert_not_called()
class TestEdgeResize(geometry_tests.BaseSplitGeometryTest):
make_layout = geometry_tests.TestSplitDragGeometry.make_layout
positions = geometry_tests.TestSplitDragGeometry.positions
fixed_dividers = geometry_tests.TestSplitDragGeometry.fixed_dividers
def resize(self, tab, window_id, edge, increment, fraction=0):
changed = tab.current_layout.modify_size_of_window_edge(tab.windows, window_id, edge, increment, fraction)
if changed:
tab.relayout()
return changed
def test_nested_edge_selection(self):
shape = {'one': 1, 'two': {'one': 2, 'two': {'one': 3, 'two': 4}}}
layout, windows, tab = self.make_layout(shape)
expected = {1: {'right'}, 2: {'left', 'right'}, 3: {'left', 'right'}, 4: {'left'}}
before = self.positions(layout)
for window_id, edges in expected.items():
found = {edge for edge in ('left', 'right', 'top', 'bottom') if layout.pair_for_window_edge(windows, window_id, edge)}
self.ae(found, edges)
self.assertIs(layout.pair_for_window_edge(windows, 2, 'left'), layout.pairs_root)
self.assertIs(layout.pair_for_window_edge(windows, 2, 'right'), layout.pairs_root.two)
self.assertIs(layout.pair_for_window_edge(windows, 3, 'left'), layout.pairs_root.two)
self.assertIsNone(layout.pair_for_window_edge(windows, 999, 'left'))
self.ae(self.positions(layout), before)
shape = {'one': {'horizontal': False, 'one': 1, 'two': 2}, 'two': {'horizontal': False, 'one': 3, 'two': 4}}
layout, windows, tab = self.make_layout(shape)
for window_id, expected in ((1, {'right', 'bottom'}), (2, {'right', 'top'}), (3, {'left', 'bottom'}), (4, {'left', 'top'})):
self.ae({edge for edge in ('left', 'right', 'top', 'bottom') if layout.pair_for_window_edge(windows, window_id, edge)}, expected)
def test_only_selected_same_axis_divider_moves(self):
shapes = (
{'one': 1, 'two': {'one': 2, 'two': {'one': 3, 'two': 4}}},
{'one': {'one': 1, 'two': 2}, 'two': {'one': 3, 'two': 4}},
{'one': 1, 'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4}},
{'horizontal': False, 'one': 1, 'two': {'horizontal': False, 'one': 2, 'two': {'horizontal': False, 'one': 3, 'two': 4}}},
)
for shape in shapes:
for minimal in (True, False):
layout, windows, tab = self.make_layout(shape, minimal)
for window_id in (1, 2, 3, 4):
for edge in ('left', 'right', 'top', 'bottom'):
pair = layout.pair_for_window_edge(windows, window_id, edge)
if pair is None:
continue
fixed = self.fixed_dividers(pair)
cell = lgd.cell_width if pair.horizontal else lgd.cell_height
for increment in (2, -2):
before = self.positions(layout)
self.assertTrue(self.resize(tab, window_id, edge, increment))
after = self.positions(layout)
self.ae(after[id(pair)] - before[id(pair)], increment * cell)
for pid, position in before.items():
if pid != id(pair) and fixed(pid):
self.ae(after[pid], position)
self.check_extents_fit(layout)
def test_fractional_steps_limits_and_custom_fraction(self):
for horizontal in (True, False):
for window_id in (1, 2):
for sign in (-1, 1):
for remaining in (0, 1, 2, 3, 4, 5, 6, 10):
for fraction in (1 / 3, 1 / 4, 1 / 2, 1):
layout, windows, tab = self.make_layout({'horizontal': horizontal, 'one': 1, 'two': 2}, num=2)
pair = layout.pairs_root
edge = ('right' if window_id == 1 else 'left') if horizontal else ('bottom' if window_id == 1 else 'top')
step = 2 * (lgd.cell_width if horizontal else lgd.cell_height)
pair.move_divider(sign * (pair.width if horizontal else pair.height))
tab.relayout()
pair.move_divider(-sign * step * remaining)
tab.relayout()
before = self.positions(layout)[id(pair)]
self.ae(self.resize(tab, window_id, edge, sign * 2, fraction), bool(remaining))
self.ae(self.positions(layout)[id(pair)] - before, sign * step * ceil(remaining * fraction - 1e-9))
while self.resize(tab, window_id, edge, sign * 2, fraction):
self.check_extents_fit(layout)
before = self.positions(layout)
self.assertFalse(self.resize(tab, window_id, edge, sign * 2, fraction))
self.ae(self.positions(layout), before)
self.assertTrue(self.resize(tab, window_id, edge, -sign * 2, fraction))
self.check_extents_fit(layout)
def test_partial_step_and_invalid_requests(self):
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
pair = layout.pairs_root
pair.move_divider(pair.width)
tab.relayout()
partial = lgd.cell_width - 1
pair.move_divider(-partial)
tab.relayout()
before = self.positions(layout)
self.assertTrue(self.resize(tab, 1, 'right', 2, 0.25))
self.ae(self.positions(layout)[id(pair)] - before[id(pair)], partial)
for edge, window_id, increment, fraction in (
('left', 1, 2, 0),
('right', 999, 2, 0),
('right', 1, 0, 0),
('right', 1, 2, -1),
('right', 1, 2, float('nan')),
):
before = self.positions(layout)
self.assertFalse(self.resize(tab, window_id, edge, increment, fraction))
self.ae(self.positions(layout), before)
def command(self, cmd, tab, window_id, operation, **payload):
window = tab.windows.id_map[window_id]
window.tabref = lambda: tab
boss = SimpleNamespace(active_window=window)
return json.loads(cmd.response_from_kitty(boss, window, PayloadGetter(cmd, {'self': True, 'operation': operation, **payload})))
def test_session_reset_restores_entry_geometry(self):
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': {'bias': 0.4, 'one': 2, 'two': 3}}, num=3)
cmd = ResizeWindowEdge()
before = self.positions(layout)
self.command(cmd, tab, 2, 'start')
for edge, increment in (('left', 3), ('right', -2)):
selected = self.command(cmd, tab, 2, 'select', edge=edge)
self.ae(selected['selected'], edge)
self.command(cmd, tab, 2, 'move', edge=edge, increment=increment, divider=selected['divider'])
self.assertNotEqual(self.positions(layout), before)
restored = self.command(cmd, tab, 2, 'reset')
self.ae(self.positions(layout), before)
self.ae(restored['selected'], '')
self.assertIn('Restored', restored['status'])
self.ae(layout.pairs_root.bias, 0.3)
self.ae(layout.pairs_root.two.bias, 0.4)
self.command(cmd, tab, 2, 'reset')
self.ae(self.positions(layout), before)
def test_entry_selection_and_snapshot_survive_strategy_activation(self):
for horizontal in (True, False):
layout, windows, tab = self.make_layout({'horizontal': horizontal, 'bias': 0.3, 'one': 1, 'two': 2}, num=2)
cmd = ResizeWindowEdge()
before = self.positions(layout)
# Boss takes the snapshot before either strategy has resized anything.
cmd.start_session(windows.id_map[1], layout)
layout.pairs_root.bias = 0.6
tab.relayout()
started = self.command(cmd, tab, 1, 'start')
self.ae(started['selected'], 'right' if horizontal else 'bottom')
self.assertTrue(started['divider'])
self.command(cmd, tab, 1, 'start')
self.command(cmd, tab, 1, 'reset')
self.ae(self.positions(layout), before)
layout, windows, tab = self.make_layout({'one': 1, 'two': {'one': 2, 'two': 3}}, num=3)
started = self.command(ResizeWindowEdge(), tab, 2, 'start')
self.ae(started['edges'], ['left', 'right'])
self.ae(started['selected'], '')
def test_no_internal_edge_and_unsupported_layout(self):
layout, windows, tab = self.make_layout({'one': 1}, num=1)
cmd = ResizeWindowEdge()
before = self.positions(layout)
started = self.command(cmd, tab, 1, 'start')
self.ae(started['edges'], [])
self.ae(started['selected'], '')
self.command(cmd, tab, 1, 'move', edge='right', increment=2)
self.ae(self.positions(layout), before)
tab.current_layout = geometry_tests.create_layout(geometry_tests.Tall)
unavailable = self.command(cmd, tab, 1, 'start')
self.ae(unavailable['edges'], [])
self.assertIn('requires the Splits layout', unavailable['status'])
def test_session_selection_stale_identity_and_structure_change(self):
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
cmd = ResizeWindowEdge()
before = self.positions(layout)
self.command(cmd, tab, 1, 'start')
outside = self.command(cmd, tab, 1, 'select', edge='left')
self.ae(outside['selected'], '')
selected = self.command(cmd, tab, 1, 'select', edge='right')
self.ae(selected['selected'], 'right')
self.ae(self.positions(layout), before)
stale = self.command(cmd, tab, 1, 'move', edge='right', divider='invalid', increment=2)
self.ae(stale['selected'], '')
self.ae(self.positions(layout), before)
layout.pairs_root.horizontal = False
tab.relayout()
changed = self.positions(layout)
refused = self.command(cmd, tab, 1, 'reset')
self.assertIn('structure changed', refused['status'])
self.ae(self.positions(layout), changed)
def test_window_reset_restores_same_entry_snapshot(self):
layout, windows, tab = self.make_layout({'bias': 0.31, 'one': 1, 'two': {'bias': 0.43, 'one': 2, 'two': 3}}, num=3)
window = windows.id_map[2]
window.tabref = lambda: tab
cmd = ResizeWindowEdge()
cmd.start_session(window, layout)
before = self.positions(layout)
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock())
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'restore_entry_layout': True})
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
self.assertTrue(self.resize(tab, 2, 'left', 3))
self.assertTrue(self.resize(tab, 2, 'right', -2))
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
self.ae(self.positions(layout), before)
boss.resize_layout_window.assert_not_called()
layout.pairs_root.horizontal = False
tab.relayout()
changed = self.positions(layout)
result = resize_window.response_from_kitty(boss, window, payload)
self.assertIn('structure changed', result)
self.ae(self.positions(layout), changed)
def test_reset_after_leaving_entry_layout_uses_default_reset(self):
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': 2}, num=2)
window = windows.id_map[1]
window.tabref = lambda: tab
cmd = ResizeWindowEdge()
cmd.start_session(window, layout)
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock(return_value=None))
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2, 'restore_entry_layout': True})
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
tab.current_layout = geometry_tests.create_layout(geometry_tests.Tall)
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
self.assertTrue(boss.resize_layout_window.call_args.kwargs['reset'])
# Returning to the entry layout restores its snapshot again
tab.current_layout = layout
layout.pairs_root.bias = 0.6
boss.resize_layout_window.reset_mock()
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
boss.resize_layout_window.assert_not_called()
self.ae(layout.pairs_root.bias, 0.3)
def test_no_snapshot_when_entered_in_other_layout(self):
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': 2}, num=2)
window = windows.id_map[1]
window.tabref = lambda: tab
tab.reset_window_sizes = Mock()
cmd = ResizeWindowEdge()
cmd.start_session(window, geometry_tests.create_layout(geometry_tests.Tall))
layout.pairs_root.bias = 0.6
started = self.command(cmd, tab, 1, 'start')
self.assertTrue(started['divider'])
moved = self.command(cmd, tab, 1, 'move', edge='right', increment=2, divider=started['divider'])
self.ae(moved['status'], '')
self.assertFalse(moved['failed'])
# Sizes changed after entry must not be treated as the original sizes
reset = self.command(cmd, tab, 1, 'reset')
tab.reset_window_sizes.assert_called_once_with()
self.assertNotIn('Restored', reset['status'])
self.assertFalse(reset['failed'])
def test_failure_flag(self):
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
cmd = ResizeWindowEdge()
self.command(cmd, tab, 1, 'start')
self.assertTrue(self.command(cmd, tab, 1, 'select', edge='left')['failed'])
selected = self.command(cmd, tab, 1, 'select', edge='right')
self.assertFalse(selected['failed'])
while not (moved := self.command(cmd, tab, 1, 'move', edge='right', increment=2, divider=selected['divider']))['failed']:
pass
self.assertIn('size limit', moved['status'])
restored = self.command(cmd, tab, 1, 'reset')
self.assertIn('Restored', restored['status'])
self.assertFalse(restored['failed'])
def test_window_reset_without_session_keeps_default_behavior(self):
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
window = windows.id_map[1]
window.tabref = lambda: tab
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock(return_value=None))
cmd = ResizeWindowEdge()
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
for restore in (False, True):
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2, 'restore_entry_layout': restore})
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
self.assertTrue(boss.resize_layout_window.call_args.kwargs['reset'])
cmd.start_session(window, layout)
before = boss.resize_layout_window.call_count
# An ordinary remote-control reset always retains default-size reset.
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2})
resize_window.response_from_kitty(boss, window, payload)
self.ae(boss.resize_layout_window.call_count, before + 1)
for fraction in (-1, 1.1, float('nan'), float('inf')):
with self.assertRaises(ValueError):
self.command(cmd, tab, 1, 'move', edge='bottom', fraction=fraction)