One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Direction A section 9: native ledger controls, round trips and accessibility."""
import copy
import itertools
from unittest import mock
import AppKit
from core import ways
import test_part_edge_thirds as thirds
from test_crossing_page_machines import BEE, SEA, Page, press, token
import ledger
class LedgerTests(Page):
layout = thirds.PartEdgeThirds.layout
row = thirds.PartEdgeThirds.row
picked = thirds.PartEdgeThirds.picked
pick_thirds = thirds.PartEdgeThirds.pick_thirds
whole_edge = thirds.PartEdgeThirds.whole_edge
def rebuilt(self):
window = self.build([(peer["id"], peer["token"], peer["name"],
{key: value for key, value in peer.items() if key not in ("id", "token", "name")})
for peer in self.store.current()["peers"]], self.store.current()["zones"])
window.atlas_canvas.setFrame_(((0, 0), (480, window.atlas_canvas.HEIGHT)))
window.atlas_canvas._draw(False)
return window
def test_seven_third_combinations_rebuild_to_same_cells_and_map(self):
self.layout()
for count in (1, 2, 3):
for combination in itertools.combinations(ways.PARTS, count):
with self.subTest(thirds=combination):
self.pick_thirds(combination)
self.assertEqual(self.store.current()["peers"][0]["ways"]["thirds"], list(combination))
self.rebuilt()
self.assertEqual(self.picked(), list(combination))
self.assertEqual(self.window.atlas_canvas.states[BEE]["picked_thirds"], list(combination))
def chip(self, side, peer=BEE):
return self.window.crossing_ledger.rows[peer].chips[side]
def corner(self, corner, peer=BEE):
return self.window.crossing_ledger.rows[peer].corner_buttons[corner]
def test_reach_is_compiled_once_per_settings_not_once_per_status_tick(self):
self.layout()
self.window._reach_stamp = None
with mock.patch.object(ways, "reach", wraps=ways.reach) as reach:
for _ in range(3):
self.window._show_arrangement()
self.window.crossing_ledger.refresh(self.store.current(), self.window.chosen_peer)
self.assertEqual(reach.call_count, 1)
press(self.chip("top"))
self.assertGreater(reach.call_count, 1, "a change to the settings asks again")
def test_a_corner_left_on_after_its_machine_moved_away_stays_removable(self):
self.layout()
press(self.corner("top_left"))
settings = self.store.current()
settings["layout"][BEE] = {"x": 400, "y": 400, "w": 160, "h": 100}
self.store.save_settings(settings)
self.window._show_arrangement()
self.assertTrue(self.corner("top_left").enabled)
press(self.corner("top_left"))
self.assertEqual(self.store.current()["peers"][0]["ways"]["corners"], [])
def test_last_ledger_segment_off_then_off_click_lights_only_that_segment(self):
self.layout()
self.pick_thirds(["start"])
press(self.row().contact().segments["start"])
self.assertEqual(self.row().contact().kind, "contact_off")
self.assertEqual(self.picked(), [])
self.assertFalse(self.store.current()["peers"][0]["ways"]["edge"])
press(self.row().contact().segments["middle"])
self.assertEqual(self.picked(), ["middle"])
self.assertEqual(self.row().contact().kind, "contact_on")
press(self.row().contact())
self.assertEqual(self.picked(), [])
press(self.row().contact())
self.assertEqual(self.picked(), list(ways.PARTS))
def test_every_chip_state_round_trips_through_the_saved_ways_the_ledger_and_the_map(self):
self.layout()
self.assertEqual([side for side, chip in self.row().chips.items() if not chip.isHidden()],
list(ways.EDGES))
self.assertEqual(self.chip("right").kind, "contact_on")
self.assertEqual(self.chip("left").kind, "free")
press(self.chip("left"))
self.assertEqual(self.ways_of(BEE)["edges"], ["left"])
self.rebuilt()
self.assertEqual(self.chip("left").kind, "on")
self.assertEqual(self.chip("left").label, "Left, wraps")
self.assertEqual(self.window.atlas_canvas.states[BEE]["wrap_sides"], ["left"])
self.assertIn((BEE, "left"), self.window.atlas_canvas.wrap_layers)
press(self.chip("left"))
self.assertEqual(self.ways_of(BEE)["edges"], [])
self.rebuilt()
self.assertEqual(self.chip("left").kind, "free")
self.assertNotIn((BEE, "left"), self.window.atlas_canvas.wrap_layers)
press(self.chip("top"))
press(self.chip("left"))
self.assertEqual(self.ways_of(BEE)["edges"], ["left", "top"])
press(self.chip("right"))
self.assertEqual(self.chip("right").kind, "contact_off")
self.rebuilt()
self.assertEqual(self.chip("left").kind, "kept")
self.assertEqual(self.window.atlas_canvas.states[BEE]["kept_sides"], ["left", "top"])
self.assertEqual(self.window.atlas_canvas.states[BEE]["wrap_sides"], [])
press(self.chip("left"))
self.assertTrue(self.ways_of(BEE)["methods"])
self.assertEqual(self.ways_of(BEE)["edges"], ["left", "top"])
self.rebuilt()
self.assertEqual(self.chip("right").kind, "contact_on")
self.assertEqual(self.chip("left").kind, "on")
press(self.chip("top"))
self.assertEqual(self.ways_of(BEE)["edges"], ["left"])
def test_chip_added_while_edge_is_off_turns_edge_on_with_the_remembered_thirds(self):
self.layout()
self.pick_thirds(["start", "end"])
press(self.row().contact())
self.assertEqual(self.picked(), [])
press(self.chip("bottom"))
self.assertEqual(self.picked(), ["start", "end"])
self.assertEqual(self.ways_of(BEE)["edges"], ["bottom"])
def test_contact_chip_leads_and_a_machine_cannot_wrap_to_its_own_contact(self):
self.layout("top")
row = self.row()
self.assertEqual(row.chip_order[0], "top")
self.assertEqual(self.chip("top").kind, "contact_on")
self.assertEqual(self.chip("top").label, "Top")
self.assertEqual(self.chip("top").toolTip(), "Top edge: touches Bee; click to turn it off")
self.assertEqual(self.chip("left").toolTip(), "Left edge: click to wrap round to Bee")
def test_every_corner_on_and_off_survives_page_rebuild(self):
self.layout()
for corner in ways.CORNERS:
with self.subTest(corner=corner):
press(self.corner(corner))
self.assertIn("corner", self.ways_of(BEE)["methods"])
self.assertEqual(self.ways_of(BEE)["corners"], [corner])
self.rebuilt()
self.assertEqual(self.corner(corner).kind, "on")
self.assertEqual(self.corner(corner).accessibilityLabel(), f"{corner.replace('_', ' ').capitalize()} corner, on")
self.assertIn((BEE, "corner", corner), self.window.atlas_canvas.mark_layers)
press(self.corner(corner))
self.rebuilt()
self.assertNotIn("corner", self.ways_of(BEE)["methods"])
self.assertEqual(self.corner(corner).kind, "free")
def test_two_corners_on_at_once_and_a_pad_for_each(self):
self.layout()
press(self.corner("top_left"))
press(self.corner("bottom_right"))
self.assertEqual(self.ways_of(BEE)["corners"], ["top_left", "bottom_right"])
self.rebuilt()
canvas = self.window.atlas_canvas
self.assertEqual(canvas.states[BEE]["corner_ways"], ["top_left", "bottom_right"])
self.assertIn((BEE, "corner", "top_left"), canvas.mark_layers)
self.assertIn((BEE, "corner", "bottom_right"), canvas.mark_layers)
press(self.corner("top_left"))
self.assertEqual(self.ways_of(BEE)["corners"], ["bottom_right"])
def test_another_machines_corner_and_a_corner_with_no_contact_refuse_without_a_write(self):
self.layout(second=True)
press(self.corner("top_left"))
self.assertEqual(self.ways_of(BEE)["corners"], ["top_left"])
sea = self.window.crossing_ledger.rows[SEA]
held = sea.corner_buttons["top_left"]
self.assertEqual(held.kind, "held")
self.assertFalse(held.enabled)
self.assertEqual(held.toolTip(), "Bee's corner")
before = copy.deepcopy(self.store.current())
press(held)
self.assertEqual(self.store.current(), before)
self.window._ledger_corner(SEA, "top_left")
self.assertEqual(self.store.current(), before)
settings = self.store.current()
settings["layout"][BEE]["x"] += 100
self.store.save_settings(settings)
self.window._show_arrangement()
loose = self.window.crossing_ledger.rows[BEE].corner_buttons["bottom_right"]
self.assertEqual(loose.kind, "unavailable")
self.assertEqual(loose.toolTip(), "Place Bee beside this Mac first")
before = copy.deepcopy(self.store.current())
press(loose)
self.window._ledger_corner(BEE, "bottom_right")
self.assertEqual(self.store.current(), before)
def test_a_side_held_by_another_machine_is_a_dimmed_chip_that_refuses_the_click(self):
self.layout(second=True)
row = self.row()
held = row.chips["left"]
self.assertEqual(held.kind, "held")
self.assertEqual(held.label, "Left, Sea")
self.assertFalse(held.enabled)
self.assertEqual(held.toolTip(), "Left edge: Sea's")
before = copy.deepcopy(self.store.current())
press(held)
self.window._ledger_side(BEE, "left")
self.assertEqual(self.store.current(), before)
def test_notch_on_and_off_rebuild_and_no_notch_is_disabled(self):
self.layout()
self.window.has_notch = True
for on in (True, False):
self.row().notch.setState_(int(on))
press(self.row().notch)
self.assertEqual("notch" in self.ways_of(BEE)["methods"], on)
self.rebuilt()
self.window.has_notch = True
self.window._show_arrangement()
self.assertEqual(self.row().notch.state(), int(on))
self.row().notch.setState_(1)
press(self.row().notch)
self.window.has_notch = False
self.window._show_arrangement()
self.assertEqual(self.row().no_notch.text, "No notch")
self.assertFalse(self.row().no_notch.view.isHidden())
self.assertEqual(self.row().notch.accessibilityLabel(), "Notch, no notch")
self.assertFalse(self.row().notch.isEnabled())
def test_the_notch_checkbox_says_notch_and_return_through_it_shows_only_with_the_notch(self):
# rc4: the checkbox said only On or Off, so where the notch was chosen could not be found.
self.layout()
self.window.has_notch = True
self.window._show_arrangement()
self.assertEqual(self.row().notch.title(), "Notch")
self.assertEqual(self.row().notch.accessibilityLabel(), "Notch, off")
self.assertTrue(self.row().notch_return.isHidden())
self.row().notch.setState_(1)
press(self.row().notch)
self.window._show_arrangement()
self.assertEqual(self.row().notch.accessibilityLabel(), "Notch, on")
returns = self.row().notch_return
self.assertFalse(returns.isHidden())
self.assertEqual(returns.title(), "Return through the notch")
returns.setState_(1)
press(returns)
zone = next(zone for zone in self.store.current()["zones"] if zone["kind"] == "notch")
self.assertEqual((zone["peer"], zone.get("return_here")), (BEE, True))
self.window._show_arrangement()
self.assertEqual(self.row().notch_return.state(), 1)
self.row().notch_return.setState_(0)
press(self.row().notch_return)
zone = next(zone for zone in self.store.current()["zones"] if zone["kind"] == "notch")
self.assertNotIn("return_here", zone)
def test_cycle_tick_and_jump_chord_round_trip_without_changing_ways(self):
self.layout()
before = self.ways_of(BEE)
for on in (False, True):
self.row().cycle.setState_(int(on))
press(self.row().cycle)
self.rebuilt()
self.assertEqual(self.row().cycle.state(), int(on))
import widgets
recorder = self.row().jump
event = mock.Mock()
event.type.return_value = AppKit.NSEventTypeKeyDown
event.modifierFlags.return_value = AppKit.NSEventModifierFlagCommand
event.keyCode.return_value = next(code for code, name in widgets.SPECIAL_KEY_NAMES.items() if name == "f18")
event_api = mock.Mock()
event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
recorder._clicked()
self.assertIsNotNone(recorder.monitor)
self.assertIsNone(recorder._recorded(event))
self.assertIsNone(recorder.monitor)
self.rebuilt()
self.assertEqual(self.row().jump.value, "cmd+f18")
self.assertIn("F18", self.row().jump.view.toolTip())
self.assertEqual(self.ways_of(BEE), before)
press(self.row().clear)
self.assertEqual(self.row().jump.value, "")
def test_offline_row_is_dimmed_but_ways_remain_live_and_saved(self):
self.layout()
self.window.windows_input.server.links.return_value = []
self.window._show_arrangement()
row = self.row()
self.assertTrue(row.dimmed)
self.assertEqual(row.status_text, "Windows · Offline, ways kept")
self.assertEqual(row.cells["edge"].alphaValue(), .5)
self.assertTrue(row.contact().segments["start"].isEnabled())
self.assertTrue(row.contact().enabled)
press(row.contact().segments["middle"])
self.assertEqual(self.picked(), ["start", "end"])
def test_armed_jump_survives_a_cell_refresh_and_escape_cancels(self):
import widgets
self.layout()
recorder = self.row().jump
event_api = mock.Mock()
event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
recorder._clicked()
prompt = recorder.key.text
press(self.row().contact().segments["start"])
self.assertIsNotNone(recorder.monitor)
self.assertEqual(recorder.key.text, prompt)
escape = mock.Mock()
escape.type.return_value = AppKit.NSEventTypeKeyDown
escape.modifierFlags.return_value = 0
escape.keyCode.return_value = 53
self.assertIsNone(recorder._recorded(escape))
self.assertIsNone(recorder.monitor)
self.assertEqual(recorder.value, "")
def test_arming_another_row_cancels_the_first_without_dropping_the_guard(self):
import widgets
self.layout(second=True)
ledger = self.window.crossing_ledger
first, second = ledger.rows[BEE].jump, ledger.rows[SEA].jump
event_api = mock.Mock()
event_api.addLocalMonitorForEventsMatchingMask_handler_.side_effect = [object(), object()]
with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
first._clicked()
with mock.patch.object(self.window, "_jump_arming", wraps=self.window._jump_arming) as guard:
second._clicked()
self.assertIsNone(first.monitor)
self.assertIsNotNone(second.monitor)
self.assertTrue(self.controller.jump_recording)
self.assertTrue(all(call.args[0] for call in guard.call_args_list))
first.cancel()
self.assertTrue(self.controller.jump_recording)
second.cancel()
self.assertFalse(self.controller.jump_recording)
def test_in_use_false_disables_kept_chips_like_left_out(self):
self.layout()
press(self.chip("left"))
press(self.corner("top_left"))
settings = self.store.current()
settings["peers"][0]["in_use"] = False
self.store.save_settings(settings)
self.window._show_arrangement()
row = self.row()
self.assertIn("Left out", row.status_text)
self.assertEqual(row.chips["left"].kind, "on", "kept ways drawn as they would cross, inert")
self.assertEqual(row.corner_buttons["top_left"].kind, "on")
for control in (*row.chips.values(), *row.corner_buttons.values(), *row.contact().segments.values()):
if control.isHidden():
continue
self.assertFalse(control.enabled if hasattr(control, "enabled") and not isinstance(control, AppKit.NSButton)
else control.isEnabled())
self.assertEqual(control.toolTip(), "Left out: Put back to change its ways")
def test_chips_wrap_in_lines_and_corner_grid_is_two_by_two_at_both_widths(self):
__import__("theme").init_fonts()
self.layout(second=True)
for width in (687, 399):
self.window.crossing_ledger.setFrameSize_((width, 700))
row = self.row()
cell = row.cells["edge"].bounds().size.width
shown = [chip for chip in row.chips.values() if not chip.isHidden()]
for chip in shown:
frame = chip.frame()
self.assertEqual(frame.size.height, 26)
self.assertLessEqual(frame.origin.x + frame.size.width, cell + .01)
self.assertGreaterEqual(frame.size.width, chip.natural_width() - .01)
first = next(chip for side in row.chip_order for chip in [row.chips[side]] if not chip.isHidden())
self.assertEqual(first.frame().origin.x, 0)
frames = [button.frame() for button in row.corner_buttons.values()]
self.assertEqual([(f.origin.x, f.origin.y, f.size.width, f.size.height) for f in frames],
[(0, 0, 28, 28), (32, 0, 28, 28), (0, 32, 28, 28), (32, 32, 28, 28)])
self.assertLessEqual(row.cells["corner"].frame().size.width, 70)
self.assertGreaterEqual(row.cells["corner"].frame().size.height, 60)
def test_selected_machine_status_dot_is_inset_from_the_rule_at_both_widths(self):
self.layout()
for width in (687, 399):
self.window.crossing_ledger.setFrameSize_((width, 700))
row = self.row()
self.assertTrue(row.selected)
machine = row.cells["machine"].frame()
self.assertGreaterEqual(machine.origin.x + 1, 12)
self.assertGreaterEqual(machine.origin.x + row.name.view.frame().origin.x, 12)
self.assertGreaterEqual(row.status.view.frame().origin.x, 12)
def test_jump_idle_is_a_text_button_or_fitted_chip_and_only_armed_is_a_field(self):
import widgets
self.layout()
row = self.row()
self.window.crossing_ledger.setFrameSize_((760, 700))
self.assertGreaterEqual(row.jump_caption.view.frame().size.width - 4,
row.jump_caption.view.attributedStringValue().size().width)
self.assertEqual(row.jump.key.text, "Set a key")
self.assertEqual(row.jump.view.layer().borderWidth(), 0)
row.jump.on_change("cmd+f18")
chip = row.jump.view
self.assertEqual(chip.layer().cornerRadius(), 4)
self.assertEqual(chip.layer().borderWidth(), 1)
self.assertTrue(row.jump.key.mono)
self.assertEqual(row.jump.key.size, __import__("theme").TYPE["small"])
self.assertGreaterEqual(chip.frame().size.width, row.jump.key.view.attributedStringValue().size().width + 12)
self.assertFalse(row.clear.isHidden())
self.assertEqual(row.clear.frame().origin.y, chip.frame().origin.y)
idle_height = chip.frame().size.height
event_api = mock.Mock()
event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
row.jump._clicked()
self.assertGreater(chip.frame().size.height, idle_height)
self.assertFalse(row.jump.hint.view.isHidden())
row.jump.cancel()
self.assertEqual(chip.frame().size.height, idle_height)
def test_narrow_block_insets_every_cell_from_the_selection_rule(self):
self.layout(second=True)
ledger = self.window.crossing_ledger
ledger.setFrameSize_((399, 700))
for row in ledger.rows.values():
for key in ("edge", "corner", "notch", "keys"):
self.assertGreaterEqual(row.cells[key].frame().origin.x, 10)
self.assertGreaterEqual(row.cells["machine"].frame().origin.y, 12)
self.assertGreaterEqual(row.cells["keys"].frame().origin.y,
row.cells["edge"].frame().origin.y + row.cells["edge"].frame().size.height)
self.assertLess(row.frame().size.height, 250)
def test_left_out_row_keeps_intent_and_put_back_restores_controls(self):
self.layout()
press(self.chip("left"))
press(self.corner("top_left"))
before = self.ways_of(BEE)
press(self.row().leave)
row = self.row()
self.assertTrue(row.dimmed)
self.assertEqual(row.status_text, "Windows · Left out")
self.assertIn("Put back", row.leave.accessibilityLabel())
self.assertEqual(row.chips["left"].kind, "on", "kept ways drawn as they would cross, inert")
self.assertEqual(row.corner_buttons["top_left"].kind, "on")
self.assertFalse(row.contact().segments["start"].isEnabled())
self.assertFalse(row.chips["left"].enabled)
self.assertFalse(row.corner_buttons["top_left"].enabled)
held = copy.deepcopy(self.store.current())
press(row.contact().segments["start"])
press(row.chips["left"])
press(row.corner_buttons["top_left"])
self.assertEqual(self.store.current(), held)
self.assertEqual(self.ways_of(BEE), before)
press(row.leave)
self.assertFalse(self.row().dimmed)
self.assertTrue(self.row().contact().segments["start"].isEnabled())
self.assertTrue(self.row().chips["left"].enabled)
self.assertEqual(self.ways_of(BEE), before)
def test_row_order_follows_map_position_and_left_out_stays_present(self):
window = self.layout(second=True)
self.assertEqual(window.crossing_ledger.order, [SEA, BEE])
press(window.crossing_ledger.rows[SEA].leave)
self.assertIn(SEA, window.crossing_ledger.order)
def test_no_contact_has_no_contact_chip_and_corners_are_not_offered(self):
self.layout()
settings = self.store.current()
settings["layout"][BEE]["x"] += 100
self.store.save_settings(settings)
self.window._show_arrangement()
row = self.row()
self.assertIsNone(row.contact())
self.assertEqual({chip.kind for chip in row.chips.values()}, {"free"})
self.assertTrue(row.edge_note.view.isHidden())
self.assertTrue(all(button.kind == "unavailable" and not button.enabled for button in row.corner_buttons.values()))
before = copy.deepcopy(self.store.current())
self.window._ledger_corner(BEE, "top_left")
self.assertEqual(self.store.current(), before)
def test_narrow_cells_and_visible_controls_fit_inside_the_ledger(self):
self.layout()
self.row().jump.on_change("cmd+f18")
ledger = self.window.crossing_ledger
ledger.setFrameSize_((440, 700))
self.assertTrue(all(header.view.isHidden() for header in ledger.headers))
row = self.row()
self.assertEqual(row.cells["machine"].frame().origin.x + row.cells["machine"].frame().size.width, 440)
self.assertEqual(row.cells["edge"].frame().size.width, 440 - 24)
self.assertGreaterEqual(row.cells["edge"].frame().origin.y,
row.cells["machine"].frame().origin.y + row.cells["machine"].frame().size.height)
self.assertEqual(row.cells["corner"].frame().origin.y, row.cells["notch"].frame().origin.y)
self.assertEqual(row.cells["notch"].frame().origin.y, row.cells["keys"].frame().origin.y)
self.assertGreaterEqual(row.cells["corner"].frame().origin.y,
row.cells["edge"].frame().origin.y + row.cells["edge"].frame().size.height)
for cell in row.cells.values():
frame = cell.frame()
self.assertGreaterEqual(frame.origin.x, 0)
self.assertLessEqual(frame.origin.x + frame.size.width, 440)
for control in cell.subviews():
if not control.isHidden():
frame = control.frame()
self.assertGreaterEqual(cell.frame().origin.x + frame.origin.x, 0)
self.assertLessEqual(frame.origin.x + frame.size.width, cell.bounds().size.width)
self.assertLessEqual(cell.frame().origin.y + frame.origin.y + frame.size.height,
row.frame().size.height)
def test_window_width_selects_table_or_stacked_rows_without_sideways_scroll(self):
from mac_app.tests.design_offscreen import settle
from mac_app.tests.settings_layout_offscreen import measure
self.layout(second=True)
self.window._select_page("crossing")
for width, narrow in ((960, False), (640, True), (1440, False)):
with self.subTest(width=width):
self.window.window.setFrame_display_(((100000, 100000), (width, 900)), False)
for _ in range(4):
settle(self.window.window)
table = self.window.crossing_ledger
self.assertEqual(table.bounds().size.width < table.narrow_below(), narrow)
self.assertEqual(all(header.view.isHidden() for header in table.headers), narrow)
self.assertFalse(self.window.pages["crossing"].hasHorizontalScroller())
self.assertEqual(measure(self.window, "crossing")["overflows"], [])
self.assertFalse(self.window.window.isVisible())
def test_thirds_bar_segments_are_nine_point_hit_targets_inside_the_contact_chip(self):
for side in ways.EDGES:
self.layout(side)
self.window._select_page("crossing")
self.window.crossing_ledger.setFrameSize_((700, 700))
chip = self.row().contact()
for part, segment in chip.segments.items():
frame = segment.frame()
with self.subTest(side=side, part=part):
self.assertEqual(frame.size.width, 9)
self.assertEqual(frame.size.height, 26)
centre = (frame.origin.x + 4.5, 13)
self.assertIs(chip.hitTest_(chip.convertPoint_toView_(centre, chip.superview())), segment)
self.assertEqual(chip.segments["start"].toolTip(), f"{ways.part_names(side)['start']} third: click to leave it out")
def test_changes_keep_the_same_row_controls_and_do_not_hide_the_ledger(self):
self.layout()
row = self.row()
controls = list(row.chips.values()) + list(row.corner_buttons.values())
with mock.patch("motion.set_hidden", wraps=__import__("motion").set_hidden) as hidden:
press(row.contact().segments["middle"])
press(self.chip("left"))
press(self.corner("top_left"))
self.assertIs(self.row(), row)
self.assertEqual(controls, list(row.chips.values()) + list(row.corner_buttons.values()))
self.assertFalse(self.window.crossing_ledger.isHidden())
self.assertFalse(any(call.args[0] in (row, self.window.crossing_ledger) for call in hidden.call_args_list))
def test_accessibility_table_rows_columns_chips_corners_and_segments_are_named_buttons(self):
self.layout("top")
ledger, row = self.window.crossing_ledger, self.row()
self.assertEqual(ledger.accessibilityRole(), AppKit.NSAccessibilityTableRole)
self.assertEqual(row.accessibilityRole(), AppKit.NSAccessibilityRowRole)
self.assertEqual(ledger.accessibilityRows(), [row])
self.assertEqual(len(ledger.accessibilityColumns()), 5)
self.assertEqual([header.text for header in ledger.headers], ["Machine", "Edges", "Corners", "Notch", "Keys"])
self.assertEqual(row.accessibilityLabel(), "Bee")
segment = row.contact().segments["start"]
self.assertEqual(segment.accessibilityRole(), AppKit.NSAccessibilityButtonRole)
self.assertEqual(segment.accessibilityLabel(), "Top edge, left third, on")
press(segment)
self.assertEqual(segment.accessibilityLabel(), "Top edge, left third, off")
chip = self.chip("left")
self.assertEqual(chip.accessibilityRole(), AppKit.NSAccessibilityButtonRole)
self.assertTrue(chip.isAccessibilityElement())
self.assertEqual(chip.accessibilityLabel(), "Left edge, wraps round, off")
self.assertEqual(chip.accessibilityValue(), "off")
press(chip)
self.assertEqual(chip.accessibilityLabel(), "Left edge, wraps round, on")
self.assertEqual(chip.accessibilityValue(), "on")
corner = self.corner("top_left")
self.assertEqual(corner.accessibilityRole(), AppKit.NSAccessibilityButtonRole)
self.assertEqual(corner.accessibilityLabel(), "Top left corner, off")
press(corner)
self.assertEqual(corner.accessibilityLabel(), "Top left corner, on")
self.assertEqual(corner.accessibilityValue(), "on")
self.assertEqual(row.contact().accessibilityLabel(), "Top edge, touches Bee, on")
press(row.contact())
self.assertEqual(row.contact().accessibilityLabel(), "Top edge, touches Bee, off")
def test_inline_rename_cancel_and_save_use_the_same_row(self):
self.layout()
row = self.row()
press(row.rename)
self.assertTrue(row.renaming)
self.assertEqual(row.rename_hint.text, "Return saves, Escape cancels")
row.name_field.setStringValue_("Cancelled")
row.finish_rename(False)
self.assertEqual(row.name.text, "Bee")
press(row.rename)
row.name_field.setStringValue_("Studio PC")
row.finish_rename(True)
self.assertIs(self.row(), row)
self.assertEqual(row.name.text, "Studio PC")
def test_inline_rename_scope_stays_inside_machine_cell_before_the_next_block(self):
self.layout()
self.controller.cfg.same_on_both = False
row = self.row()
press(row.rename)
for width in (399, 687):
self.window.crossing_ledger.setFrameSize_((width, 700))
self.assertFalse(row.scope.view.isHidden())
scope = row.scope.view.frame()
self.assertLessEqual(scope.origin.y + scope.size.height, row.cells["machine"].frame().size.height)