def test_closed_leaf_goal_could_not_be_reopened(self):
self.goals = self.build(open_(1, "Root", [2], select=selected),
clos_(2, "A", [3]), clos_(3, "B"))
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": True
},
2: {
"open": False,
"switchable": True
},
3: {
"open": False,
"switchable": False
},
}
self.goals.accept_all(Select(3), ToggleClose())
# nothing should change
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": True
},
2: {
"open": False,
"switchable": True
},
3: {
"open": False,
"switchable": False
},
}
def test_closed_goals_are_shown_when_selected():
v = OpenView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
clos_(2, "closed"),
clos_(3, "closed too", [4]),
clos_(4, "closed and not selected"),
))
v.accept_all(ToggleOpenView(), Select(2), HoldSelect(), Select(3))
assert v.q("name,select,open") == {
1: {
"name": "Root",
"open": True,
"select": None
},
2: {
"name": "closed",
"open": False,
"select": "prev"
},
3: {
"name": "closed too",
"open": False,
"select": "select"
},
4: {
"name": "closed and not selected",
"open": False,
"select": None
},
}
v.accept(ToggleOpenView())
# Still show: open goals, selected goals
assert v.q("name,select,open") == {
1: {
"name": "Root",
"open": True,
"select": None
},
2: {
"name": "closed",
"open": False,
"select": "prev"
},
3: {
"name": "closed too",
"open": False,
"select": "select"
},
}
def test_dot_export():
goals = build_goaltree(
open_(1, "Root", [2, 3, 4, 5], blockers=[6]),
clos_(
2,
"This is closed goal with no children or blockers. "
"It also has a long name that must be compacted",
),
open_(3, 'I have some "special" symbols', [6, 7], select=selected),
clos_(4, ""),
open_(5, "Many blockerz", blockers=[2, 4, 6, 7]),
clos_(6, "!@#$%^&*()\\/,.?"),
open_(7, ";:[{}]<>", select=previous),
)
verify(dot_export(goals),
reporter=GenericDiffReporterFactory().get_first_working())
def test_message_when_closed_goal_is_blocked_by_open_one(self):
self.goals = self.build(
open_(1, "Root", [2, 3]),
clos_(2, "Middle", [], select=previous),
open_(3, "Top", [], select=selected),
)
self.goals.accept(ToggleLink())
assert len(self.messages) == 1
def test_build_fake_links_to_far_closed_goals():
v = OpenView(
build_goaltree(
open_(1, "Root", blockers=[2], select=previous),
clos_(2, "Middle", blockers=[3]),
clos_(3, "Top", select=selected),
))
assert v.q("select,edge") == {
1: {
"select": "prev",
"edge": [(3, EdgeType.BLOCKER)]
},
3: {
"select": "select",
"edge": []
},
}
def extract_target():
return persistent_layers(
build_goaltree(
open_(1, "Extract root", [2, 3], select=selected),
open_(2, "Subgoal", blockers=[3]),
open_(3, "Selected subgoal (selection will be lost)", [4]),
clos_(4, "Closed subgoal"),
))
def extract_source():
# Legend: goals marked with 'NX' must not be extracted
return Enumeration(
all_layers(
build_goaltree(
open_(1, "Root NX", [2, 3], select=selected),
open_(2, "Extract root", [4, 5], blockers=[3]),
open_(3, "External blocker NX", [7]),
open_(4, "Subgoal", blockers=[5]),
open_(
5,
"Selected subgoal (selection will be lost)",
[6],
select=previous,
),
clos_(6, "Closed subgoal", blockers=[7]),
clos_(7, "Another external blocker NX"),
)))
def test_still_show_root_when_it_is_closed_and_unselected():
v = OpenView(
build_goaltree(
clos_(1, "Hidden root", [2]),
clos_(2, "Visible", select=selected),
))
assert v.q("select,open,edge") == {
1: {
"select": None,
"open": False,
"edge": [(2, EdgeType.PARENT)]
},
2: {
"select": "select",
"open": False,
"edge": []
},
}
def test_close_goal_again(self):
self.goals = self.build(
open_(1, "Root", [2], select=selected),
open_(2, "A", [3]),
clos_(3, "Ab"),
)
self.goals.accept_all(Select(2), ToggleClose())
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": True
},
2: {
"open": False,
"switchable": True
},
3: {
"open": False,
"switchable": False
},
}
self.goals.accept_all(Select(2), ToggleClose())
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": False
},
2: {
"open": True,
"switchable": True
},
3: {
"open": False,
"switchable": True
},
}
self.goals.accept_all(Select(2), ToggleClose())
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": True
},
2: {
"open": False,
"switchable": True
},
3: {
"open": False,
"switchable": False
},
}
def test_render_example():
g = build_goaltree(
open_(1, "Root", [2, 3, 4, 5, 6], [7, 8]),
clos_(2, "Closed", blockers=[7]),
open_(3, "Simply 3", blockers=[5, 8]),
open_(4, "Also 4", blockers=[5, 6, 7, 8], select=selected),
open_(5, "Now 5", blockers=[6]),
clos_(6, "Same 6", blockers=[7]),
clos_(7, "Lucky 7", [8], select=previous),
clos_(8, "Finally 8"),
)
r = Renderer(g)
result = r.build()
gp = FakeGeometry()
adjust_graph(result, gp)
lines = render_lines(gp, result)
with io.StringIO() as out:
print("== Graph\n", file=out)
pprint(result.graph, out)
print("\n== Geometry change after adjust\n", file=out)
total_delta = Point(0, 0)
for goal_id in g.goals:
goal = result.graph[goal_id]
delta = gp.top_left(goal["row"], goal["col"]) - Point(
goal["x"], goal["y"])
total_delta += delta
print(f"{goal_id}: dx={delta.x}, dy={delta.y}", file=out)
avg_dx = total_delta.x // len(g.goals)
avg_dy = total_delta.y // len(g.goals)
print(f"Avg: dx={avg_dx}, dy={avg_dy}", file=out)
print("\n== Edge options\n", file=out)
pprint(result.edge_opts, out)
print("\n== Lines", file=out)
pprint(lines, out)
verify(out.getvalue(),
reporter=GenericDiffReporterFactory().get_first_working())
def test_do_not_add_autolink_to_closed_goals():
messages: List[str] = []
goals = AutoLink(
build_goaltree(
open_(1, "Root", [2]),
clos_(2, "Well, it's closed", select=selected),
message_fn=messages.append,
))
goals.accept(ToggleAutoLink("Failed"))
assert goals.q("name,edge") == {
1: {
"name": "Root",
"edge": [(2, EdgeType.PARENT)]
},
2: {
"name": "Well, it's closed",
"edge": []
},
}
assert messages == ["Autolink cannot be set for closed goals"]
assert _autolink_events(goals) == []
def test_reopen_goal(self):
self.goals = self.build(open_(1, "Root", [2]),
clos_(2, "A", select=selected))
assert self.goals.q(keys="open") == {
1: {
"open": True
},
2: {
"open": False
}
}
self.goals.accept(ToggleClose())
assert self.goals.q(keys="open,switchable") == {
1: {
"open": True,
"switchable": False
},
2: {
"open": True,
"switchable": True
},
}
def test_message_on_delete_root_goal(self):
self.goals = self.build(clos_(1, "Root", [2], select=selected),
clos_(2, "Top"))
self.goals.accept(Delete())
assert len(self.messages) == 1
def test_no_message_on_delete_non_root_goal(self):
self.goals = self.build(clos_(1, "Root", [2]),
clos_(2, "Top", [], select=selected))
self.goals.accept(Delete())
assert self.messages == []
def test_message_on_reopening_blocked_goal(self):
self.goals = self.build(clos_(1, "Root", [2]),
clos_(2, "Top", [], select=selected))
self.goals.accept(ToggleClose())
assert len(self.messages) == 1
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected),
clos_(2, "Closed"))
return OpenView(g)
def test_message_on_wrong_add(self):
self.goals = self.build(clos_(1, "Root", select=selected))
self.goals.accept(Add("Failed"))
assert len(self.messages) == 1
def test_no_message_on_valid_reopening(self):
self.goals = self.build(clos_(1, "Root", [2], select=selected),
clos_(2, "Top"))
self.goals.accept(ToggleClose())
assert self.messages == []
