One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Crossing profiles end to end (spec 1.5.5 sections 5, 7, 8 and 12): two to four desktops on
loopback, each a real responder and owner, syncing the desk (`settings.data.desk`) over the real
encrypted links through the shells in crossing_shells.py, which do what the apps do.
Every case settles the desks and then asserts the same things: they settled within SETTLE_LIMIT, no
message is still travelling a quarter of a second later (the frame count stops), no `settings` frame
reaches 64 KiB, the profile-aware desks hold equal `crossing_desk` registers, the pictures and sides
agree and no zone is malformed."""
import copy
import sys
import time
import unittest
from unittest import mock
from core import crossing_state, profiles, return_edge, ways
from core.return_edge import Rect
from core.tests.crossing_harness import Net, text
from core.tests.crossing_shells import SHELLS
from core.tests.responder_harness import entry
SETTLE_LIMIT = 1.0
QUIET = 0.25
FRAME_LIMIT = 64 * 1024
MAC = {"0": Rect(0, 0, 1728, 1117)}
PC = {"0": Rect(0, 0, 3840, 2160)}
SPECS = {"A": ("mac", MAC, 90), "B": ("pc", PC, 60), "C": ("pc", {"0": Rect(0, 0, 2560, 1600)}, 120),
"D": ("mac", {"0": Rect(0, 0, 1512, 982)}, 150)}
DESK = profiles.DESK_ID
MEASURED = {}
def tearDownModule():
for name, (settle, frames) in sorted(MEASURED.items()):
print(f"{name}: slowest settle {settle:.3f}s, {frames} frames", file=sys.stderr)
def desk_state(desk):
state = copy.deepcopy(desk.settings["crossing_desk"])
state.pop("format", None)
for profile in state["profiles"].values():
if profile.get("removed") is None:
profile.pop("removed", None)
return state
def rows(desk, pid=DESK):
return {machine: reg["value"] for machine, reg in
desk.settings["crossing_desk"]["profiles"][pid]["rows"].items()}
def spot(tile):
return tuple(tile[key] for key in ("x", "y", "w", "h"))
def own_row(desk):
return copy.deepcopy(desk.settings["crossing_own"]["row"])
def live(desk):
return profiles.live_row(desk.settings)
def zones(desks):
return {desk.name: copy.deepcopy(desk.settings["zones"]) for desk in desks}
def archived(desk, row):
return any(item["row"] == profiles.canonical_row(row) for item in desk.settings["crossing_own"]["saved"])
class Mesh(unittest.TestCase):
def setUp(self):
grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
grace.start()
self.addCleanup(grace.stop)
self.net = Net(self, SHELLS)
self.worst = 0.0
self.sent_before = 0
self.addCleanup(self.record)
def record(self):
MEASURED[self.id().rsplit(".", 2)[-2] + "." + self.id().rsplit(".", 1)[-1]] = (self.worst, self.frames())
def build(self, names, pairs=None, plain=()):
"""Desks `names`, paired as `pairs` (strings like "AB"; every pair by default). Those in
`plain` are 1.5.3-style: no `profiles` capability and no crossing_own."""
partial = pairs is not None
pairs = pairs or [one + two for i, one in enumerate(names) for two in names[i + 1:]]
self.d = {}
for name in names:
platform, displays, seed = SPECS[name]
self.d[name] = self.net.add(name, platform, displays, seed, profiles=name not in plain)
self.pairs = [(self.d[p[0]], self.d[p[1]]) for p in pairs]
for desk in self.d.values():
partners = [other for one, two in self.pairs for other in (one, two)
if desk in (one, two) and other is not desk]
with desk.lock:
settings = copy.deepcopy(desk.settings)
settings["peers"] = [entry(other.own, other.name, token=self.key(desk, other),
platform=other.platform_name, linked=False,
paired_with=[third.id for third in partners if third is not other]
+ [desk.id])
for other in partners]
for item in settings["peers"]:
item["side"] = ""
settings["zones"] = []
if partial:
settings.update(self.whole_picture(names))
desk.shell.paired(settings)
desk.save(settings)
for desk in self.d.values():
desk.machine.start()
self.addCleanup(desk.machine.stop)
desk.started = True
for one, two in self.pairs:
self.link(one, two)
for one, two in self.pairs:
one.shell.link_up(two)
two.shell.link_up(one)
self.settle("built")
return [self.d[name] for name in names]
def whole_picture(self, names):
"""Every desk of a chain holds the same complete picture from the start: two machines that
are not paired never learn each other's tile through the middle one, and the cases here are
about the desk rows, not about how a chain's pictures merge."""
tiles = {}
for number, name in enumerate(names):
desk = self.d[name]
tiles[desk.id] = {"x": number * 160, "y": 0, "w": 160, "h": 100,
"displays": {key: {"x": rect.x, "y": rect.y, "w": rect.width, "h": rect.height}
for key, rect in desk.screen.displays.items()}}
return {"layout": tiles, "layout_set_at": 5, "layout_by": self.d[names[0]].id}
@staticmethod
def key(one, two):
from core.tests.crossing_harness import key
return key(one.own, two.own)
def link(self, one, two):
one.hand.connect(two)
two.hand.connect(one)
def unlink(self, gone):
"""`gone` drops off the network: every link to and from it closes."""
for one, two in self.pairs:
if gone in (one, two):
one.hand.drop(two)
two.hand.drop(one)
def relink(self, back):
mine = [(one, two) for one, two in self.pairs if back in (one, two)]
for one, two in mine:
self.link(one, two)
for one, two in mine:
one.shell.link_up(two)
two.shell.link_up(one)
def frames(self):
return sum(len(desk.shell.frames) for desk in self.d.values())
def desk_frames(self):
return [frame for desk in self.d.values() for frame in desk.shell.frames if frame["desk"]]
def settle(self, label=""):
started = time.monotonic()
self.assertTrue(self.net.settle(SETTLE_LIMIT), f"{label}: the desks did not settle")
took = time.monotonic() - started
self.worst = max(self.worst, took)
sent = self.frames()
time.sleep(QUIET)
self.assertTrue(self.net.settle(SETTLE_LIMIT), f"{label}: the desks did not settle again")
self.assertEqual(self.frames(), sent, f"{label}: messages were still being sent after settling")
for desk in self.d.values():
self.assertEqual(desk.shell.errors, [], f"{label}: {desk.name} raised")
biggest = max((frame["size"] for desk in self.d.values() for frame in desk.shell.frames), default=0)
self.assertLess(biggest, FRAME_LIMIT, f"{label}: a frame of {biggest} bytes")
self.assertLess(max((f["size"] for f in self.desk_frames()), default=0), profiles.MAX_DESK_BYTES)
self.assertEqual(self.net.bad_zones(), [], label)
return took
def aware(self, *names):
return [desk for desk in self.d.values() if desk.profiles and (not names or desk.name in names)]
def assert_converged(self, label="", names=()):
desks = self.aware(*names)
first = desk_state(desks[0])
for desk in desks[1:]:
self.assertEqual(desk_state(desk), first, f"{label}: {desk.name} differs from {desks[0].name}")
def assert_agree(self, label=""):
self.assertEqual(self.net.views_agree(), [], label)
self.assertEqual(self.net.bad_zones(), [], label)
def place(self, on, moved, side, shift=0):
own = on.settings["layout"][on.id]
tile = on.settings["layout"].get(moved.id) or {"w": moved.tile_size[0], "h": moved.tile_size[1]}
w, h = tile["w"], tile["h"]
x, y = {"left": (own["x"] - w, own["y"] + (own["h"] - h) // 2 + shift),
"right": (own["x"] + own["w"], own["y"] + (own["h"] - h) // 2 + shift),
"top": (own["x"] + (own["w"] - w) // 2 + shift, own["y"] - h),
"bottom": (own["x"] + (own["w"] - w) // 2 + shift, own["y"] + own["h"])}[side]
self.assertTrue(on.shell.drop(moved, x, y))
def arrange(self, first, others):
"""`others` round `first` on its map, then every desk given its own odd ways so that
no row is the default."""
for other, side in zip(others, ("right", "left", "top")):
self.place(first, other, side)
self.settle("arranged")
for number, desk in enumerate(self.d.values()):
for peer in self.d.values():
if peer is not desk and desk.peer(peer) is not None:
parts = [["start"], ["middle"], ["end"], ["start", "end"]][(number + len(peer.name)) % 4]
desk.shell.edit(peer, ["part"], parts=parts)
self.settle("odd ways")
def turn_on(self, desk):
self.assertTrue(desk.shell.same_ways(True)["accepted"])
self.settle("same ways on")
def make_profile(self, desk, name):
known = set(desk.settings["crossing_desk"]["profiles"])
self.assertTrue(desk.shell.new_profile(name)["accepted"])
(pid,) = set(desk.settings["crossing_desk"]["profiles"]) - known
self.settle(f"{name} made")
return pid
class SameWaysChangesNothing(Mesh):
def check(self, names):
desks = self.build(names)
self.arrange(desks[0], desks[1:])
self.assert_agree("before")
before_zones, before_live = zones(desks), {d.name: live(d) for d in desks}
before_own = {d.name: own_row(d) for d in desks}
self.turn_on(desks[-1])
self.assert_agree("after")
self.assert_converged("on")
self.assertEqual(zones(desks), before_zones, "a zone moved when Same ways went on")
for desk in desks:
self.assertEqual(live(desk), before_live[desk.name], desk.name)
self.assertEqual(own_row(desk), before_own[desk.name], f"{desk.name}'s own row")
self.assertEqual(profiles.in_force(desk.settings), (before_own[desk.name], True), desk.name)
for other in desks:
self.assertEqual(rows(desk)[other.id], before_own[other.name],
f"{desk.name} holds {other.name}'s row as its previous own row")
return desks
def test_two_machines(self):
for desk in self.check("AB"):
self.assertFalse(desk.shell.refused_desks)
def test_three_machines(self):
self.check("ABC")
def test_four_machines(self):
self.check("ABCD")
def test_each_machine_turns_it_on_from_its_own_page(self):
desks = self.build("ABC")
self.arrange(desks[0], desks[1:])
before = zones(desks)
self.turn_on(desks[2])
self.assert_converged()
self.assertEqual(zones(desks), before)
self.assertEqual(desk_state(desks[0])["on"]["by"], desks[2].id)
def test_a_stale_machine_turning_it_on_again_seeds_nobody(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
self.assertTrue(b.shell.edit_other(a, c, thirds=["end"])["accepted"])
self.settle("edit")
held = desk_state(a)
c.shell.skew = -60
c.shell.same_ways(True)
self.settle("again")
self.assertEqual(desk_state(a)["on"], held["on"])
self.assertEqual(rows(a)[a.id], rows(c)[a.id])
self.assertEqual(rows(a)[a.id][c.id]["ways"]["thirds"], ["end"])
class Edits(Mesh):
def test_an_edit_arrives_is_in_force_and_the_old_row_is_archived(self):
a, b = self.build("AB")
self.place(a, b, "right")
self.settle("placed")
self.assertTrue(a.shell.edit(b, ["edge"], edges=["right"]))
self.assertTrue(b.shell.edit(a, ["edge"], edges=["left"]))
self.settle("ways")
self.turn_on(a)
previous = own_row(b)
self.assertTrue(self.net.push(b, "left", 0.1) is a, "the whole edge crosses before the edit")
self.net.shortcut(b)
out = a.shell.edit_other(b, a, thirds=["end"])
self.assertTrue(out["accepted"])
self.settle("edit")
self.assert_converged()
self.assertEqual(ways.ways(b.settings, a.id)["parts"], ["end"])
row, desk_in_force = profiles.in_force(b.settings)
self.assertTrue(desk_in_force)
self.assertEqual(row[a.id]["ways"]["thirds"], ["end"])
self.assertEqual(own_row(b), previous, "the edit never reaches B's own row")
self.assertTrue(archived(b, previous), "B's previous row is in its archive")
self.assertEqual(rows(b)[b.id][a.id]["ways"]["thirds"], ["end"])
self.assertIs(self.net.push(b, "left", 0.1), b, "the start third is now a wall")
self.assertIs(self.net.push(b, "left", 0.9), a, "the end third crosses")
self.net.shortcut(b)
self.assert_agree()
def edits_reach_everyone(self, names):
desks = self.build(names)
self.arrange(desks[0], desks[1:])
self.turn_on(desks[0])
for number, editor in enumerate(desks):
target = desks[(number + 1) % len(desks)]
peer = desks[(number + 2) % len(desks)]
previous = copy.deepcopy(rows(target)[target.id])
self.assertTrue(editor.shell.edit_other(target, peer, thirds=["middle"], edge=True)["accepted"])
self.settle(f"{editor.name} edits {target.name}")
self.assert_converged(f"{editor.name} edits {target.name}")
self.assertEqual(ways.ways(target.settings, peer.id)["parts"], ["middle"])
self.assertEqual(profiles.in_force(target.settings)[1], True)
self.assertTrue(archived(target, previous), f"{target.name}'s row before {editor.name}'s edit")
self.assert_agree()
def test_edits_from_any_machine_reach_the_others_in_three(self):
self.edits_reach_everyone("ABC")
def test_edits_from_any_machine_reach_the_others_in_four(self):
self.edits_reach_everyone("ABCD")
def test_concurrent_edits_to_one_row_converge_to_the_newer(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
b.shell.skew = 10
a.shell.edit_other(c, b, thirds=["start"])
b.shell.edit_other(c, a, thirds=["end"])
self.settle("concurrent")
self.assert_converged()
held = self.d["C"].settings["crossing_desk"]["profiles"][DESK]["rows"][c.id]
self.assertEqual(held["by"], b.id, "the later clock's whole row won")
self.assertEqual(held["value"][a.id]["ways"]["thirds"], ["end"])
self.assertEqual(ways.ways(c.settings, a.id)["parts"], ["end"])
def test_concurrent_edits_to_different_rows_both_land(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
a.shell.edit_other(c, b, thirds=["start"])
b.shell.edit_other(a, c, thirds=["end"])
c.shell.edit_other(b, a, thirds=["middle"])
self.settle("concurrent")
self.assert_converged()
self.assertEqual(rows(a)[c.id][b.id]["ways"]["thirds"], ["start"])
self.assertEqual(rows(a)[a.id][c.id]["ways"]["thirds"], ["end"])
self.assertEqual(rows(a)[b.id][a.id]["ways"]["thirds"], ["middle"])
self.assertEqual(ways.ways(c.settings, b.id)["parts"], ["start"])
self.assertEqual(ways.ways(a.settings, c.id)["parts"], ["end"])
self.assertEqual(ways.ways(b.settings, a.id)["parts"], ["middle"])
def test_a_burst_of_edits_from_four_machines_settles(self):
desks = self.build("ABCD")
self.arrange(desks[0], desks[1:])
self.turn_on(desks[0])
for round_ in range(3):
for number, editor in enumerate(desks):
target = desks[(number + 1 + round_) % 4]
peer = desks[(number + 2 + round_) % 4]
if target is peer or target is editor:
continue
editor.shell.edit_other(target, peer, thirds=[["start"], ["middle"], ["end"]][round_])
self.settle("burst")
self.assert_converged()
self.assert_agree()
class Chains(Mesh):
def test_b_edits_a_towards_c_while_b_is_not_paired_with_c(self):
a, b, c = self.build("ABC", pairs=["AB", "AC"])
self.place(a, b, "right")
self.place(a, c, "left")
self.settle("placed")
self.turn_on(b)
self.assertEqual(rows(c)[b.id], own_row(b), "B's seed reached C through A")
self.assertTrue(b.shell.edit_other(a, c, thirds=["end"], edge=True)["accepted"])
self.settle("edit")
self.assert_converged()
self.assertEqual(ways.ways(a.settings, c.id)["parts"], ["end"], "A applies it: it is paired with C")
self.assertEqual(rows(c)[a.id][c.id]["ways"]["thirds"], ["end"])
self.assertEqual(desk_state(a)["status"][a.id]["value"]["waiting"], [])
self.assertEqual(profiles.machine_line(b.settings, a.id, linked=True, caps={"profiles"},
last_heard=None), "Uses the desk's ways")
self.assertIsNone(b.peer(c))
def test_a_waits_for_a_machine_it_is_not_paired_with(self):
a, b, c = self.build("ABC", pairs=["AB", "BC"])
self.place(b, a, "left")
self.place(b, c, "right")
self.settle("placed")
self.turn_on(b)
live_before = live(a)
self.assertTrue(b.shell.edit_other(a, c, thirds=["end"], edge=True)["accepted"])
self.settle("edit")
self.assert_converged()
self.assertEqual(live(a), live_before, "nothing to apply to a machine it does not have")
self.assertEqual(rows(c)[a.id][c.id]["ways"]["thirds"], ["end"])
self.assertEqual(desk_state(b)["status"][a.id]["value"]["waiting"], [c.id])
line = profiles.machine_line(b.settings, a.id, linked=True, caps={"profiles"}, last_heard=None)
self.assertTrue(line.startswith("Needs pairing with"), line)
self.assertEqual(desk_state(b)["status"][b.id]["value"]["waiting"], [])
self.assertIsNone(a.peer(c))
def test_a_chain_of_four_syncs_end_to_end(self):
a, b, c, d = self.build("ABCD", pairs=["AB", "BC", "CD"])
self.turn_on(a)
self.assert_converged("on")
self.assertTrue(d.shell.edit_other(a, b, thirds=["middle"])["accepted"])
self.settle("edit")
self.assert_converged()
self.assertEqual(ways.ways(a.settings, b.id)["parts"], ["middle"])
class Offline(Mesh):
def test_a_machine_offline_takes_the_edit_when_it_comes_back(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
previous = own_row(c)
held = live(c)
self.unlink(c)
self.assertTrue(a.shell.edit_other(c, b, thirds=["end"], edge=True)["accepted"])
self.settle("a edits")
self.assertTrue(b.shell.edit_other(c, a, thirds=["start"], edge=True)["accepted"])
self.settle("offline")
self.assertEqual(live(c), held, "C has heard nothing")
self.assertEqual(rows(a)[c.id], rows(b)[c.id])
self.assertNotEqual(rows(a)[c.id], rows(c)[c.id])
self.relink(c)
self.settle("back")
self.assert_converged()
self.assertEqual(ways.ways(c.settings, a.id)["parts"], ["start"])
self.assertEqual(ways.ways(c.settings, b.id)["parts"], ["end"])
self.assertEqual(own_row(c), previous, "its own row never moved")
self.assertTrue(archived(c, previous))
self.assert_agree()
def test_edits_made_on_both_sides_of_the_gap_converge_to_the_newer(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
self.unlink(c)
a.shell.edit_other(c, b, thirds=["end"])
self.settle("away")
time.sleep(1.1)
c.shell.edit(b, ["part"], parts=["start"])
self.settle("c edits itself")
self.relink(c)
self.settle("back")
self.assert_converged()
self.assertEqual(rows(a)[c.id][b.id]["ways"]["thirds"], ["start"], "the later edit wins whoever made it")
self.assertEqual(ways.ways(c.settings, b.id)["parts"], ["start"])
def test_the_offline_machine_catches_up_on_a_new_profile_too(self):
a, b, c = self.build("ABC")
self.turn_on(a)
self.unlink(c)
pid = self.make_profile(a, "Sofa")
a.shell.switch_profile(pid)
self.settle("switched")
self.relink(c)
self.settle("back")
self.assert_converged()
self.assertEqual(c.settings["crossing_desk"]["active"]["value"], pid)
self.assert_agree()
class ClockSkew(Mesh):
def test_a_minute_either_way_changes_nothing_that_matters(self):
a, b, c = self.build("ABC")
a.shell.skew, b.shell.skew, c.shell.skew = 60, 0, -60
self.arrange(a, [b, c])
before = zones([a, b, c])
self.turn_on(a)
self.assertEqual(zones([a, b, c]), before)
# The machine 120 s behind the one that switched on: its edit still beats every seed.
self.assertTrue(c.shell.edit_other(b, a, thirds=["end"], edge=True)["accepted"])
self.settle("behind edits")
self.assert_converged()
self.assertEqual(ways.ways(b.settings, a.id)["parts"], ["end"])
for first, second in ((a, c), (c, a)):
second_choice = ["start"] if first is a else ["middle"]
first.shell.edit_other(b, a, thirds=["start"])
self.settle(f"{first.name} then {second.name}")
second.shell.edit_other(b, a, thirds=second_choice)
self.settle(f"{second.name} after {first.name}")
self.assert_converged()
self.assertEqual(ways.ways(b.settings, a.id)["parts"], second_choice,
f"{second.name}'s edit came after {first.name}'s and wins whatever the clocks say")
self.assert_agree()
def test_concurrent_edits_a_minute_apart_go_to_the_later_clock_everywhere(self):
a, b, c = self.build("ABC")
a.shell.skew, c.shell.skew = -60, 60
self.arrange(a, [b, c])
self.turn_on(b)
a.shell.edit_other(b, c, thirds=["start"])
c.shell.edit_other(b, a, thirds=["end"])
self.settle("concurrent")
self.assert_converged()
self.assertEqual(rows(a)[b.id][a.id]["ways"]["thirds"], ["end"])
self.assertEqual(desk_state(a)["profiles"][DESK]["rows"][b.id]["by"], c.id)
class PlainMiddle(Mesh):
def test_a_machine_without_profiles_relays_nothing_and_is_unaffected(self):
a, m, c = self.build("ABC", pairs=["AB", "BC"], plain=("B",))
self.place(m, a, "left")
self.place(m, c, "right")
self.settle("placed")
self.assert_agree()
picture = copy.deepcopy(m.settings["layout"])
m_before = copy.deepcopy(m.settings)
a.shell.same_ways(True)
self.settle("on")
a.shell.edit_other(c, a, thirds=["end"])
self.settle("edit")
self.assertEqual(desk_state(c)["on"]["value"], False, "the desk did not cross a machine without profiles")
self.assertNotIn("crossing_desk", m.settings)
self.assertNotIn("crossing_own", m.settings)
self.assertEqual(m.settings, m_before)
self.assertFalse([f for f in a.shell.frames if f["desk"] and f["peer"] == m.id])
self.assertFalse([f for f in m.shell.frames if f["desk"]])
self.assertEqual(m.settings["layout"], picture)
self.assertIs(self.net.push(a, "right"), m, "layout and crossing carry on across it")
self.net.shortcut(a)
self.assert_agree()
def test_with_a_direct_link_the_desk_still_syncs_and_the_plain_machine_is_untouched(self):
a, m, c = self.build("ABC", plain=("B",))
self.place(a, m, "right")
self.place(a, c, "left")
self.settle("placed")
m_before = copy.deepcopy(m.settings)
a.shell.same_ways(True)
a.shell.edit_other(c, a, thirds=["end"])
self.settle("edit")
self.assert_converged()
self.assertEqual(ways.ways(c.settings, a.id)["parts"], ["end"])
self.assertEqual(m.settings, m_before)
self.assertEqual(m.shell.refused_desks, [])
self.assert_agree()
class Override(Mesh):
def test_override_holds_b_until_it_turns_it_off(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
own = own_row(b)
held, held_zones = live(b), copy.deepcopy(b.settings["zones"])
self.assertTrue(b.shell.own_ways(True)["accepted"])
self.settle("override")
self.assertEqual(b.settings["zones"], held_zones)
self.assertTrue(a.shell.edit_other(b, a, thirds=["end"], edge=True)["accepted"])
self.assertTrue(c.shell.edit_other(b, c, thirds=["middle"], edge=True)["accepted"])
self.settle("edits")
self.assert_converged()
self.assertEqual(live(b), held, "B's crossing did not move")
self.assertEqual(b.settings["zones"], held_zones)
self.assertEqual(own_row(b), own)
self.assertEqual(rows(b)[b.id][a.id]["ways"]["thirds"], ["end"], "the desk row took the edit")
self.assertEqual(profiles.in_force(b.settings)[1], False)
a.shell.own_ways(False)
self.settle("a's own page")
self.assertTrue(b.settings["crossing_own"]["use_own"], "no message turns B's override off")
self.assertTrue(b.shell.own_ways(False)["accepted"])
self.settle("override off")
self.assertEqual(ways.ways(b.settings, a.id)["parts"], ["end"])
self.assertEqual(ways.ways(b.settings, c.id)["parts"], ["middle"])
self.assertEqual(own_row(b), own, "its own row is still what it was")
self.assert_agree()
def test_sharing_mine_sends_the_own_row_to_the_desk(self):
a, b = self.build("AB")
self.place(a, b, "right")
self.settle("placed")
self.turn_on(a)
b.shell.own_ways(True)
b.shell.edit(a, ["part"], parts=["start"])
self.settle("own edit")
self.assertNotEqual(rows(a)[b.id], own_row(b))
out = crossing_state.share_mine(b.shell.current(), platform=b.shell.platform, now=b.shell.now())
b.shell.carry_out(out)
self.settle("shared")
self.assert_converged()
self.assertEqual(rows(a)[b.id], own_row(b))
self.assertEqual(rows(a)[b.id][a.id]["ways"]["thirds"], ["start"])
class OffAndOn(Mesh):
def test_off_then_on_moves_nobodys_zones(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
self.turn_on(a)
a.shell.edit_other(c, a, thirds=["end"], edge=True)
b.shell.edit_other(a, b, thirds=["middle"], edge=True)
self.settle("edits")
desks = [a, b, c]
before = zones(desks)
before_live = {d.name: live(d) for d in desks}
rows_before = copy.deepcopy(rows(a))
self.assertTrue(b.shell.same_ways(False)["accepted"])
self.settle("off")
self.assertEqual(zones(desks), before)
for desk in desks:
self.assertFalse(profiles.same_ways_on(desk.settings))
self.assertEqual(live(desk), before_live[desk.name])
self.assertEqual(own_row(desk), rows_before[desk.id], f"{desk.name} keeps what it crossed by as its own")
self.assertTrue(a.shell.same_ways(True)["accepted"])
self.settle("on again")
self.assert_converged()
self.assertEqual(zones(desks), before)
for desk in desks:
self.assertEqual(live(desk), before_live[desk.name])
self.assertEqual(rows(desk)[desk.id], rows_before[desk.id])
self.assert_agree()
class Switching(Mesh):
def test_a_switch_carries_the_picture_and_a_switch_back_restores_it(self):
a, b, c = self.build("ABC")
self.place(a, b, "right")
self.place(a, c, "left")
self.settle("placed")
self.turn_on(a)
desk_picture = {d.name: copy.deepcopy(d.settings["layout"]) for d in (a, b, c)}
sofa = self.make_profile(a, "Sofa")
self.assert_converged()
self.assertEqual(rows(b, sofa), rows(b), "a new profile starts from the active one's rows")
a.shell.switch_profile(sofa)
self.settle("to Sofa")
self.assertTrue(all(d.settings["crossing_desk"]["active"]["value"] == sofa for d in (a, b, c)))
self.place(a, c, "bottom")
self.settle("moved in Sofa")
sofa_picture = copy.deepcopy(a.settings["layout"])
self.assertNotEqual(spot(sofa_picture[c.id]), spot(desk_picture["A"][c.id]))
self.assert_agree("sofa")
b.shell.switch_profile(DESK)
self.settle("back to Desk")
self.assert_converged()
self.assert_agree("desk")
for d in (a, b, c):
self.assertEqual(spot(d.settings["layout"][c.id]), spot(desk_picture["A"][c.id]), d.name)
a.shell.switch_profile(sofa)
self.settle("to Sofa again")
self.assert_agree("sofa again")
self.assertEqual(spot(c.settings["layout"][c.id]), spot(sofa_picture[c.id]))
def test_a_drop_in_flight_during_a_switch_converges(self):
a, b, c = self.build("ABC")
self.place(a, b, "right")
self.place(a, c, "left")
self.settle("placed")
self.turn_on(a)
sofa = self.make_profile(a, "Sofa")
own = b.settings["layout"][b.id]
a.shell.switch_profile(sofa)
b.shell.drop(c, own["x"], own["y"] + own["h"])
c.shell.edit_other(a, b, thirds=["end"])
self.settle("racing")
self.assert_converged()
self.assert_agree()
self.assertEqual({d.settings["crossing_desk"]["active"]["value"] for d in (a, b, c)}, {sofa})
self.assertEqual(len({tuple(sorted((k, v["x"], v["y"]) for k, v in d.settings["layout"].items()))
for d in (a, b, c)}), 1, "one picture everywhere")
a.shell.switch_profile(DESK)
self.settle("home")
self.assert_converged()
self.assert_agree()
def test_a_removed_profile_stays_removed_for_the_machine_that_was_away(self):
a, b, c = self.build("ABC")
self.turn_on(a)
sofa = self.make_profile(a, "Sofa")
self.unlink(c)
a.shell.switch_profile(sofa)
a.shell.switch_profile(DESK)
out = crossing_state.remove_profile(a.shell.current(), sofa, platform="mac", now=a.shell.now())
self.assertTrue(out["accepted"])
a.shell.carry_out(out)
self.settle("removed")
self.relink(c)
self.settle("back")
self.assert_converged()
self.assertIsNotNone(c.settings["crossing_desk"]["profiles"][sofa]["removed"])
class Refusal(Mesh):
def test_a_desk_from_a_peer_that_may_not_drive_is_refused(self):
a, b = self.build("AB")
self.place(a, b, "right")
self.settle("placed")
settings = copy.deepcopy(b.settings)
settings["peers"][0]["allow_drive"] = False
b.save(settings)
held = copy.deepcopy(b.settings)
a.shell.same_ways(True)
a.shell.edit_other(b, a, thirds=["end"])
self.settle("sent")
self.assertTrue(b.shell.refused_desks)
self.assertEqual({reason for _, reason in b.shell.refused_desks}, {"untrusted"})
self.assertEqual(b.settings["crossing_desk"], held["crossing_desk"])
self.assertEqual(b.settings["zones"], held["zones"])
self.assertEqual(b.settings["peers"], held["peers"])
self.assertTrue(profiles.same_ways_on(a.settings))
def test_what_a_trusted_peer_relays_is_taken_whoever_made_it(self):
a, b, c = self.build("ABC")
self.arrange(a, [b, c])
settings = copy.deepcopy(b.settings)
for item in settings["peers"]:
if item["id"] == a.id:
item["allow_drive"] = False
b.save(settings)
a.shell.same_ways(True)
self.settle("on")
self.assertTrue(profiles.same_ways_on(b.settings), "C relayed it")
self.assertIn((a.id, "untrusted"), b.shell.refused_desks)
a.shell.edit_other(b, c, thirds=["end"])
self.settle("edit")
self.assertEqual(ways.ways(b.settings, c.id)["parts"], ["end"])
class TileResizeConvergence(Mesh):
def test_resizing_one_tile_converges_and_crosses_into_its_matching_span(self):
a, b, c = self.build("ABC")
self.place(a, b, "top")
self.place(a, c, "left")
self.settle("clear resize area")
own = a.settings["layout"][a.id]
tiles = copy.deepcopy(a.settings["layout"])
resized = ways.resize_tile(tiles[b.id], 320)
resized.update(x=own["x"] + own["w"], y=own["y"] + own["h"] - resized["h"])
tiles[b.id] = resized
with a.shell.lock:
outcome = crossing_state.drop(a.shell.current(), tiles, b.id,
capable=a.shell.capable(), snap_radius=0, **a.shell._args())
self.assertTrue(outcome["accepted"])
a.shell.carry_out(outcome)
self.settle("resized")
self.assert_agree("resized")
for desk in (a, b, c):
self.assertEqual((desk.settings["layout"][b.id]["w"],
desk.settings["layout"][b.id]["h"]), (320, 200), desk.name)
edge = next(zone for zone in a.settings["zones"]
if zone["peer"] == b.id and zone["kind"] == "edge")
self.assertEqual(edge["target_span"], [0.5, 1.0])
self.assertIs(self.net.push(a, "right", 0.75), b)
landed = b.screen.placed[-1]
self.assertGreater(landed[1], b.screen.displays["0"].y + b.screen.displays["0"].height / 2)
if __name__ == "__main__":
unittest.main()