#include "BoxLayout.hpp" #include "DemoBoard.hpp" #include "TaskBoard.hpp" #include "TaskTreeView.hpp" #include "ApplicationFrame.hpp" #include "Menus.hpp" #include "NodeEditor.hpp" #include "MemoryFileSystem.hpp" #include "SessionPanel.hpp" #include "TaskCard.hpp" #include "TaskStore.hpp" #include "UiDriver.hpp" #include #include "UnitTest++/UnitTest++.h" #include #include #include using namespace tp; using namespace tp::taskboard; using namespace tp::ui; using namespace tp::ui::testing; SUITE(TaskBoardModel) { struct OrderedBoard { TaskBoard board; std::vector ids; explicit OrderedBoard(std::vector orders) { for (int order : orders) ids.push_back(board.addTask({ .order = order }, { 0, 0 })); } std::vector inOrder(std::initializer_list indices) const { std::vector result; for (size_t index : indices) result.push_back(ids[index]); return result; } }; TEST(PlacingATaskMovesItAndOnlyRenumbersTasksInBetween) { OrderedBoard scene({ 10, 20, 30, 40, 50 }); scene.board.placeBefore(scene.ids[3], scene.ids[1]); CHECK((scene.board.tasksInOrder() == scene.inOrder({ 0, 3, 1, 2, 4 }))); CHECK_EQUAL(10, scene.board.task(scene.ids[0])->order); CHECK_EQUAL(50, scene.board.task(scene.ids[4])->order); scene.board.placeAfter(scene.ids[0], scene.ids[2]); CHECK((scene.board.tasksInOrder() == scene.inOrder({ 3, 1, 2, 0, 4 }))); CHECK_EQUAL(50, scene.board.task(scene.ids[4])->order); } TEST(PlacingRenumbersEverythingWhenRanksCollide) { OrderedBoard scene({ 0, 0, 0 }); scene.board.placeBefore(scene.ids[2], scene.ids[0]); CHECK((scene.board.tasksInOrder() == scene.inOrder({ 2, 0, 1 }))); CHECK_EQUAL(0, scene.board.task(scene.ids[2])->order); CHECK_EQUAL(2, scene.board.task(scene.ids[1])->order); } TEST(ReparentedTaskGoesLastAmongItsNewSiblings) { OrderedBoard scene({ 0, 1, 2, 3 }); scene.board.setParent(scene.ids[1], scene.ids[0]); scene.board.setParent(scene.ids[3], scene.ids[0]); scene.board.setParent(scene.ids[2], scene.ids[0]); scene.board.placeLastAmongSiblings(scene.ids[2]); CHECK((scene.board.childrenOf(scene.ids[0]) == scene.inOrder({ 1, 3, 2 }))); CHECK_EQUAL(scene.board.orderAfterLast() - 1, scene.board.task(scene.ids[2])->order); } TEST(DependenciesGateRunnableTasks) { TaskBoard board; const NodeId first = board.addTask({ .status = TaskStatus::Done }, { 0, 0 }); const NodeId second = board.addTask({ .status = TaskStatus::Wip }, { 300, 0 }); const NodeId last = board.addTask({ .status = TaskStatus::Queued }, { 600, 0 }); CHECK(board.addDependency(last, first)); CHECK(board.addDependency(last, second)); CHECK(!board.isRunnable(last)); board.task(second)->status = TaskStatus::Done; CHECK(board.isRunnable(last)); } TEST(DependencyCyclesAreRejected) { TaskBoard board; const NodeId first = board.addTask({}, { 0, 0 }); const NodeId second = board.addTask({}, { 300, 0 }); const NodeId third = board.addTask({}, { 600, 0 }); CHECK(board.addDependency(second, first)); CHECK(board.addDependency(third, second)); CHECK(!board.addDependency(first, third)); } TEST(TaskHasSingleParentAndHierarchyCyclesAreRejected) { TaskBoard board; const NodeId root = board.addTask({}, { 0, 0 }); const NodeId other = board.addTask({}, { 0, 300 }); const NodeId child = board.addTask({}, { 300, 0 }); CHECK(board.setParent(child, root)); CHECK(board.setParent(child, other)); CHECK_EQUAL(other, *board.parentOf(child)); CHECK(!board.setParent(other, child)); } TEST(RelationQueriesFollowLinks) { TaskBoard board; const NodeId root = board.addTask({}, { 0, 0 }); const NodeId child = board.addTask({}, { 0, 0 }); const NodeId grandchild = board.addTask({}, { 0, 0 }); const NodeId other = board.addTask({}, { 0, 0 }); board.setParent(child, root); board.setParent(grandchild, child); board.addDependency(other, child); CHECK((board.rootTasks() == std::vector{ root, other })); CHECK(board.childrenOf(root) == std::vector{ child }); CHECK((board.ancestorsOf(grandchild) == (std::vector{ root, child }))); CHECK(board.dependentsOf(child) == std::vector{ other }); CHECK(board.dependenciesOf(other) == std::vector{ child }); board.removeDependency(other, child); CHECK(board.dependentsOf(child).empty()); board.clearParent(child); CHECK((board.rootTasks() == (std::vector{ root, child, other }))); } TEST(LinkChecksRejectSelfMissingAndCycles) { TaskBoard board; const NodeId first = board.addTask({}, { 0, 0 }); const NodeId second = board.addTask({}, { 0, 0 }); board.addDependency(second, first); board.setParent(second, first); CHECK(!board.canAddDependency(first, first)); CHECK(!board.canAddDependency(first, 999)); CHECK(!board.canAddDependency(first, second)); CHECK(board.canAddDependency(second, first)); CHECK(!board.canSetParent(first, second)); CHECK(board.canSetParent(second, first)); } TEST(HierarchyAndDependencyPortsDoNotMix) { TaskBoard board; const NodeId first = board.addTask({}, { 0, 0 }); const NodeId second = board.addTask({}, { 300, 0 }); CHECK(!board.graph().connect( TaskBoard::output(first, TaskOutput::Children), TaskBoard::input(second, TaskPort::DependsOn) )); } } namespace { bool shownOnScreen(const Widget& widget) { for (const Widget* current = &widget; current; current = current->parent()) if (!current->isVisible()) return false; return widget.ui() != nullptr; } Button* findButton(Widget& root, const std::string& text) { if (auto* button = dynamic_cast(&root); button && button->text() == text) return button; for (Widget* child : root.children()) if (Button* found = findButton(*child, text)) return found; return nullptr; } struct RecordingStore : TaskStore { void startSession(NodeId id) override { started.push_back(id); } void restartSession(NodeId id, bool fresh) override { restarts.emplace_back(id, fresh); } void stopSession(NodeId id) override { stopped.push_back(id); } void beginEditing(NodeId id, TaskField field) override { editing = std::make_pair(id, field); } void endEditing() override { editing.reset(); } std::optional> editing; std::vector started; std::vector> restarts; std::vector stopped; }; struct TreeScene { TaskBoard board; NodeId widgets = board.addTask({ .title = "Widgets" }, { 0, 0 }); NodeId textEdit = board.addTask({ .title = "Text edit glitches", .description = "space and emoji" }, { 0, 0 }); NodeId emoji = board.addTask({ .title = "Emoji fallback", .description = "copy NotoEmoji into the assets" }, { 0, 0 }); NodeId release = board.addTask({ .title = "Release notes", .workspace = "/agents/task-4" }, { 0, 0 }); MemoryFileSystem files; ApplicationFrame window; AppStorage storage{ "/home/user/taskboard" }; TaskTreeView view{ board, files, storage }; RecordingStore store; int edits = 0; explicit TreeScene(bool panelsOpen = true) { files.addTextFile("/agents/task-4/reports/summary.md", "# Summary\n\nAll done."); files.addTextFile("/agents/task-4/reports/data.csv", "a,b"); files.addDirectory("/agents/task-4/notes"); window.setContent(&view); view.attachMenus(window.menuBar, [] {}); view.dock().setViewMode(view.taskPanel(), DockPanel::ViewMode::Docked); view.dock().hidePanel(view.taskPanel()); if (panelsOpen) view.openPanels(); view.taskWidget().showPage(TaskWidgetPage::Links); board.setParent(textEdit, widgets); board.setParent(emoji, textEdit); view.boardReloaded(); view.setStore(&store); view.setOnBoardEdited([this] { edits++; }); } TaskDetails& details() { return view.details(); } void showHeader(UiDriver& driver) { view.taskWidget().showPage(TaskWidgetPage::Task); driver.settle(); } void chooseAction(UiDriver& driver, const std::string& text) { showHeader(driver); driver.click(view.header().actionsButton); driver.settle(); for (const auto& item : view.header().actionsMenu.items()) { if (item->text() != text) continue; driver.click(*item); driver.settle(); return; } CHECK(false); } }; } SUITE(TaskTreeNavigation) { TEST(StartsAtBoardListingTopLevelTasks) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); CHECK(!scene.view.currentTask()); CHECK_EQUAL(1u, scene.view.pages().depth()); CHECK_EQUAL(1u, scene.view.breadcrumb().partCount()); CHECK(scene.details().row(scene.details().children, scene.widgets) != nullptr); CHECK(scene.details().row(scene.details().children, scene.release) != nullptr); CHECK(scene.details().row(scene.details().children, scene.textEdit) == nullptr); CHECK(scene.view.page().rootHint.isVisible()); CHECK(!shownOnScreen(scene.view.header().title)); } TEST(SingleClickOnChildRowCentresTheGraphOnIt) { TreeScene scene; scene.board.task(scene.release)->order = 9; UiDriver driver(scene.window, { 1200, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); driver.click(scene.details().row(scene.details().children, scene.release)->openButton()); driver.settle(); CHECK(!scene.view.currentTask()); const RectF card = *graph.cardRect(scene.release); const Vec2F centre = card.pos + card.size / 2.0f; CHECK_CLOSE(graph.size().x / 2, centre.x, 1.0f); CHECK_CLOSE(graph.size().y / 2, centre.y, 1.0f); } TEST(OpeningChildRowPushesPageAndBackReturns) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); driver.settle(); Button& row = scene.details().row(scene.details().children, scene.widgets)->openButton(); const Vec2F at = row.windowRect().center(); driver.click(at); driver.click(at); driver.settle(); CHECK(scene.view.currentTask() == scene.widgets); CHECK_EQUAL(2u, scene.view.pages().depth()); CHECK_EQUAL("Widgets", scene.view.header().title.text()); CHECK(scene.details().row(scene.details().children, scene.textEdit) != nullptr); CHECK(!shownOnScreen(scene.view.pages().currentPage().backButton())); driver.click(scene.view.breadcrumb().part(0)); driver.settle(); CHECK(!scene.view.currentTask()); CHECK_EQUAL(1u, scene.view.pages().depth()); } TEST(OpeningDeepTaskBuildsItsParentPath) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); CHECK_EQUAL(4u, scene.view.pages().depth()); REQUIRE CHECK_EQUAL(4u, scene.view.breadcrumb().partCount()); CHECK_EQUAL("Board", scene.view.breadcrumb().part(0).text()); CHECK_EQUAL("Text edit glitches", scene.view.breadcrumb().part(2).text()); driver.click(scene.view.breadcrumb().part(1)); driver.settle(); CHECK(scene.view.currentTask() == scene.widgets); CHECK_EQUAL(2u, scene.view.pages().depth()); } TEST(SwitchingToUnrelatedTaskReplacesPath) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); scene.view.openTask(scene.release); driver.settle(); CHECK(scene.view.currentTask() == scene.release); CHECK_EQUAL(2u, scene.view.pages().depth()); } TEST(SectionsStartExpandedAndKeepUserChoice) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.widgets); driver.settle(); for (RelationSection* section : { &scene.details().children, &scene.details().dependsOn, &scene.details().unblocks }) CHECK(section->isExpanded()); CHECK_EQUAL("1", scene.details().children.header().summary()); CHECK(scene.details().row(scene.details().children, scene.textEdit) != nullptr); driver.click(scene.details().dependsOn.header()); driver.settle(); CHECK(!scene.details().dependsOn.isExpanded()); scene.view.openTask(scene.release); CHECK(!scene.details().dependsOn.isExpanded()); } TEST(DraggingChildrenReordersThemAndRecordsOrder) { TreeScene scene; const NodeId second = scene.board.addTask({ .title = "Second", .order = 1 }, { 0, 0 }); const NodeId third = scene.board.addTask({ .title = "Third", .order = 2 }, { 0, 0 }); scene.board.setParent(second, scene.widgets); scene.board.setParent(third, scene.widgets); UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.widgets); driver.settle(); ReorderableList& list = scene.details().children.list(); REQUIRE CHECK_EQUAL(3u, list.itemCount()); const Vec2F grip = list.windowPosition() + list.gripRect(2).center(); const Vec2F top = list.windowPosition() + list.gripRect(0).center() - Vec2F(0, 8); scene.edits = 0; driver.drag(grip, top, 6); driver.settle(); CHECK(scene.board.childrenOf(scene.widgets) == (std::vector{ third, scene.textEdit, second })); CHECK(scene.board.task(third)->order < scene.board.task(scene.textEdit)->order); CHECK(scene.board.task(scene.textEdit)->order < scene.board.task(second)->order); CHECK(scene.edits > 0); } TEST(ChildRowShowsColorAsSwatchNotFill) { TreeScene scene; scene.board.task(scene.widgets)->color = RGBA(1, 0, 0, 1); scene.view.boardReloaded(); UiDriver driver(scene.window, { 1200, 900 }); driver.settle(); TaskRowButton& button = scene.details().row(scene.details().children, scene.widgets)->openButton(); CHECK(button.swatch() == RGBA(1, 0, 0, 1)); const RectF row = button.windowRect(); const RectF panel = scene.view.pages().windowRect(); size_t redFills = 0; bool rowFilledRed = false; for (const CanvasCommand& command : driver.paint().commands()) { if (command.kind != CanvasCommand::Kind::Rect || !(command.color == RGBA(1, 0, 0, 1))) continue; const bool inPanel = command.rect.pos.x >= panel.pos.x - 1 && command.rect.pos.x + command.rect.size.x <= panel.pos.x + panel.size.x + 1; if (!inPanel) continue; redFills++; rowFilledRed |= command.rect.size.x >= row.size.x - 1; } CHECK_EQUAL(1u, redFills); CHECK(!rowFilledRed); } TEST(NewChildGoesLastInTheGlobalOrder) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.board.task(scene.textEdit)->order = 4; scene.board.task(scene.release)->order = 7; scene.view.openTask(scene.widgets); scene.view.createTask(); REQUIRE CHECK(scene.view.currentTask()); CHECK_EQUAL(8, scene.board.task(*scene.view.currentTask())->order); CHECK(scene.board.childrenOf(scene.widgets).back() == *scene.view.currentTask()); } TEST(DeleteAsksThenMovesChildrenUpKeepingTheirPlaceAndReturnsToParent) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.board.task(scene.release)->order = 9; scene.view.openTask(scene.widgets); driver.settle(); scene.chooseAction(driver, "Delete task..."); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); CHECK(scene.board.task(scene.widgets) != nullptr); scene.view.header().deleteConfirm.accept(); driver.settle(); CHECK(scene.board.task(scene.widgets) == nullptr); CHECK(!scene.view.currentTask()); CHECK(!scene.board.parentOf(scene.textEdit)); CHECK(scene.board.parentOf(scene.emoji) == scene.textEdit); CHECK(scene.board.rootTasks() == (std::vector{ scene.textEdit, scene.release })); CHECK(scene.edits > 0); } TEST(DeleteFromMenuCanBeCancelled) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); for (const auto& item : scene.view.editMenu.items()) if (item->text() == "Delete Task") item->activate(); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); scene.view.header().deleteConfirm.cancel(); driver.settle(); CHECK(scene.board.task(scene.emoji) != nullptr); CHECK(scene.view.currentTask() == scene.emoji); } TEST(TaskRemovedByReloadFallsBackToBoard) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.release); scene.board.graph().removeNodes({ scene.release }); scene.view.boardReloaded(); driver.settle(); CHECK(!scene.view.currentTask()); CHECK_EQUAL(1u, scene.view.pages().depth()); } } SUITE(TaskTreeSearch) { TEST(SearchMatchesIdTitleAndDescriptionInThatOrder) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); const std::vector byId = scene.view.searchResults("#3"); REQUIRE CHECK_EQUAL(1u, byId.size()); CHECK_EQUAL("#3 Emoji fallback", byId[0].title); CHECK(byId[0].detail.find("Widgets \u203A Text edit glitches") != std::string::npos); const std::vector byText = scene.view.searchResults("emoji"); REQUIRE CHECK_EQUAL(2u, byText.size()); CHECK_EQUAL("#3 Emoji fallback", byText[0].title); CHECK_EQUAL("#2 Text edit glitches", byText[1].title); CHECK(byText[1].detail.find("\"space and emoji\"") != std::string::npos); CHECK(scene.view.searchResults("NOTOEMOJI").size() == 1); CHECK(scene.view.searchResults("").empty()); CHECK(scene.view.searchResults("nothing like this").empty()); } TEST(ChoosingSearchResultOpensTask) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); driver.key(Key::F, { .control = true }); CHECK(scene.view.search().input().isEditing()); driver.type("emoji"); driver.settle(); REQUIRE CHECK(scene.view.search().isShowingResults()); driver.key(Key::Enter); driver.settle(); CHECK(scene.view.currentTask() == scene.emoji); CHECK_EQUAL(4u, scene.view.pages().depth()); CHECK(scene.view.search().input().text().empty()); } } SUITE(TaskTreeEditing) { TEST(TitleRowShowsIdAndHidesBadgeWithoutSession) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); scene.showHeader(driver); TaskHeader& page = scene.view.header(); CHECK_EQUAL("#3", page.idLabel.text()); CHECK(page.idLabel.windowRect().pos.y + page.idLabel.windowRect().size.y <= page.title.windowRect().pos.y + 1); CHECK(page.idLabel.parent() == &page.badgeRow()); CHECK(!page.badge.isVisible()); CHECK(!driver.paint().hasText("\u25CF no session")); scene.board.task(scene.emoji)->session.state = SessionState::Working; scene.view.boardReloaded(); driver.settle(); CHECK(page.badge.isVisible()); CHECK(page.badge.isPulsing()); CHECK(page.badge.isDotShown()); CHECK(page.actionsButton.windowRect().pos.x > page.badge.windowRect().pos.x); const RectF id = page.idLabel.windowRect(); CHECK(page.badge.windowRect().pos.x > id.pos.x + id.size.x + 40); CHECK(page.badge.windowRect().pos.x > page.status.windowRect().pos.x); } TEST(DockedPanelShowsTheBadgeRowAboveTheTitleAndLinksHaveNoPageHeader) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.textEdit); driver.settle(); CHECK(!shownOnScreen(scene.view.pages().currentPage().header())); CHECK(!driver.paint().hasText("#2 Text edit glitches")); scene.showHeader(driver); TaskHeader& header = scene.view.header(); CHECK(header.badgeRow().parent() != &header); CHECK(shownOnScreen(header.idLabel)); CHECK( header.badgeRow().windowRect().pos.y + header.badgeRow().windowRect().size.y <= header.title.windowRect().pos.y + 1 ); } TEST(TitleRowHoldsStatusAndColorAndSectionHeadersHoldAdd) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.release); driver.settle(); scene.showHeader(driver); TaskHeader& header = scene.view.header(); const halnf badgeY = header.idLabel.windowRect().center().y; CHECK_CLOSE(badgeY, header.status.windowRect().center().y, 2.0f); CHECK_CLOSE(badgeY, header.color.windowRect().center().y, 2.0f); CHECK(header.title.windowRect().pos.y > header.status.windowRect().pos.y); CHECK(header.title.windowRect().size.y > header.status.windowRect().size.y); scene.view.taskWidget().showPage(TaskWidgetPage::Links); driver.settle(); CHECK(shownOnScreen(header.status)); CHECK(!shownOnScreen(header.title)); for (RelationSection* section : { &scene.details().children, &scene.details().dependsOn, &scene.details().unblocks }) { CHECK(section->header().action() == §ion->addButton()); CHECK(!section->isPickerShown()); CHECK_CLOSE(section->header().windowRect().center().y, section->addButton().windowRect().center().y, 2.0f); } } TEST(EditingFieldsChangesTaskAndReportsEdits) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.release); driver.settle(); scene.showHeader(driver); driver.click(scene.view.header().title); driver.key(Key::End); driver.type("!"); scene.view.header().status.setSelectedIndex( long(std::find(kTaskStatuses.begin(), kTaskStatuses.end(), TaskStatus::Queued) - kTaskStatuses.begin()) ); const Task& task = *scene.board.task(scene.release); CHECK_EQUAL("Release notes!", task.title); CHECK(task.status == TaskStatus::Queued); CHECK(scene.edits >= 2); CHECK_EQUAL("Release notes!", scene.view.pages().currentPage().title()); } TEST(AddChildOpensSearchWithCreateNewFirst) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.board.task(scene.widgets)->agentModel = "claude-opus-4-8"; scene.view.openTask(scene.widgets); driver.settle(); driver.click(scene.details().children.addButton()); driver.settle(); SearchField& picker = scene.details().children.picker(); REQUIRE CHECK(picker.isShowingResults()); CHECK(picker.input().isEditing()); REQUIRE CHECK(picker.results().size() >= 2); CHECK_EQUAL("+ Create new: New task", picker.results()[0].title); CHECK_EQUAL(0, picker.highlighted()); driver.type("Docs"); driver.settle(); CHECK_EQUAL("+ Create new: Docs", picker.results()[0].title); driver.key(Key::Enter); driver.settle(); const std::optional created = scene.view.currentTask(); REQUIRE CHECK(created && *created != scene.widgets); CHECK_EQUAL("Docs", scene.board.task(*created)->title); CHECK(scene.board.parentOf(*created) == scene.widgets); CHECK_EQUAL("claude-opus-4-8", scene.board.task(*created)->agentModel); CHECK(scene.view.header().title.isEditing()); } TEST(AddChildCanAdoptExistingTask) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.widgets); driver.settle(); driver.click(scene.details().children.addButton()); driver.type("Release"); driver.settle(); SearchField& picker = scene.details().children.picker(); REQUIRE CHECK_EQUAL(2u, picker.results().size()); driver.key(Key::Down); driver.key(Key::Enter); driver.settle(); CHECK(scene.view.currentTask() == scene.widgets); CHECK(scene.board.parentOf(scene.release) == scene.widgets); CHECK(scene.board.childrenOf(scene.widgets).back() == scene.release); driver.click(scene.details().children.addButton()); driver.type("Widgets"); driver.settle(); CHECK_EQUAL(1u, picker.results().size()); } TEST(CtrlNOnBoardCreatesTopLevelTask) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); driver.key(Key::N, { .control = true }); driver.settle(); REQUIRE CHECK(scene.view.currentTask()); CHECK(!scene.board.parentOf(*scene.view.currentTask())); CHECK_EQUAL(5u, scene.board.graph().nodes().size()); } TEST(DependencyPickerLinksAndBlocksCycles) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.board.addDependency(scene.widgets, scene.release); scene.view.openTask(scene.release); driver.settle(); driver.click(scene.details().dependsOn.addButton()); driver.settle(); SearchField& picker = scene.details().dependsOn.picker(); REQUIRE CHECK(scene.details().dependsOn.isPickerShown()); CHECK(picker.input().isEditing()); driver.type("Widgets"); driver.settle(); REQUIRE CHECK_EQUAL(2u, picker.results().size()); CHECK(!picker.results()[1].enabled); CHECK_EQUAL("would create a cycle", picker.results()[1].detail); picker.setText("Emoji"); driver.settle(); driver.key(Key::Down); driver.key(Key::Enter); driver.settle(); CHECK(scene.board.dependenciesOf(scene.release) == std::vector{ scene.emoji }); CHECK(!scene.details().dependsOn.isPickerShown()); CHECK(scene.details().row(scene.details().dependsOn, scene.emoji) != nullptr); CHECK(scene.details().row(scene.details().unblocks, scene.widgets) != nullptr); } TEST(DependencyCreateNewMakesSiblingAndLinksIt) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); driver.click(scene.details().dependsOn.addButton()); driver.type("Fonts"); driver.settle(); driver.key(Key::Enter); driver.settle(); const std::optional created = scene.view.currentTask(); REQUIRE CHECK(created && *created != scene.emoji); CHECK_EQUAL("Fonts", scene.board.task(*created)->title); CHECK(scene.board.parentOf(*created) == scene.textEdit); CHECK(scene.board.dependenciesOf(scene.emoji) == std::vector{ *created }); } TEST(UnblocksPickerAddsDependentAndRemoveUnlinks) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); driver.click(scene.details().unblocks.addButton()); driver.type("#4"); driver.settle(); driver.key(Key::Down); driver.key(Key::Enter); driver.settle(); CHECK(scene.board.dependenciesOf(scene.release) == std::vector{ scene.emoji }); driver.click(scene.details().row(scene.details().unblocks, scene.release)->removeButton()); driver.settle(); CHECK(scene.board.dependenciesOf(scene.release).empty()); CHECK(scene.view.currentTask() == scene.emoji); } TEST(SetParentMovesTaskAndUpdatesPath) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.openTask(scene.emoji); driver.settle(); scene.chooseAction(driver, "Set parent..."); driver.settle(); SearchField& picker = scene.view.header().parentPicker; REQUIRE CHECK(picker.isShowingResults()); CHECK_EQUAL("Top level", picker.results()[0].title); driver.type("Release"); driver.settle(); REQUIRE CHECK_EQUAL(2u, picker.results().size()); driver.key(Key::Down); driver.key(Key::Enter); driver.settle(); CHECK(scene.board.parentOf(scene.emoji) == scene.release); CHECK(scene.view.currentTask() == scene.emoji); CHECK_EQUAL(3u, scene.view.pages().depth()); scene.chooseAction(driver, "Set parent..."); driver.settle(); REQUIRE CHECK(picker.isShowingResults()); driver.key(Key::Enter); driver.settle(); CHECK(!scene.board.parentOf(scene.emoji)); CHECK_EQUAL(2u, scene.view.pages().depth()); scene.chooseAction(driver, "Set parent..."); driver.type("Text edit"); driver.settle(); scene.view.openTask(scene.widgets); scene.chooseAction(driver, "Set parent..."); driver.type("Emoji"); driver.settle(); REQUIRE CHECK_EQUAL(2u, picker.results().size()); CHECK(picker.results()[1].enabled); } TEST(TypingReportsEditingScopeAndReloadKeepsIt) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); scene.view.openTask(scene.release); driver.settle(); scene.showHeader(driver); MarkdownEditor& editor = scene.view.description().editor; editor.setMode(MarkdownEditor::Mode::Editor); driver.settle(); driver.click(editor.sourceArea()); driver.type("draft"); REQUIRE CHECK(scene.store.editing.has_value()); CHECK(scene.store.editing->second == TaskField::Description); scene.view.boardReloaded(); CHECK_EQUAL("draft", editor.markdown()); CHECK_EQUAL("draft", scene.board.task(scene.release)->description); driver.click(scene.view.header().title); REQUIRE CHECK(scene.store.editing.has_value()); CHECK(scene.store.editing->second == TaskField::Title); } TEST(ConflictBannerShowsAndReportsChoice) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); std::vector choices; scene.view.header().setOnConflictChoice([&](bool keepMine) { choices.push_back(keepMine); }); scene.view.openTask(scene.release); scene.view.showConflicts({ "#4 Title: theirs \"A\", yours \"B\"" }); driver.settle(); scene.showHeader(driver); CHECK(shownOnScreen(scene.view.header().keepMine)); driver.click(scene.view.header().keepMine); driver.click(scene.view.header().useTheirs); CHECK((choices == (std::vector{ true, false }))); scene.view.showConflicts({}); CHECK(!shownOnScreen(scene.view.header().keepMine)); } TEST(SaveFromCtrlSAndMenuAndStatusShowsUnsavedCount) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); int saves = 0; scene.view.setOnSave([&] { saves++; }); driver.key(Key::S, { .control = true }); for (const auto& item : scene.view.fileMenu.items()) if (item->text() == "Save") item->activate(); CHECK_EQUAL(2, saves); scene.view.showSaveState(3, false); driver.settle(); CHECK(driver.paint().findText("\u25CF 3 unsaved changes (Ctrl+S)") != nullptr); scene.view.showSaveState(0, false); driver.settle(); CHECK(driver.paint().findText("All changes saved") != nullptr); } } SUITE(TaskTreePanels) { TEST(TaskPanelStartsDockedUnpinnedAndClosed) { TaskBoard board; MemoryFileSystem files; TaskTreeView view{ board, files, AppStorage{ "/home/user/taskboard" } }; CHECK(view.taskPanel().viewMode() == DockPanel::ViewMode::Undocked); CHECK(view.taskPanel().side() == DockSide::Right); CHECK(!view.taskPanel().isOpen()); } TEST(PanelsStartClosedLeavingTheGraphTheWholeWindow) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); CHECK(!scene.view.taskPanel().isOpen()); CHECK(scene.view.graph().size().x > 1300); scene.view.openPanels(); driver.settle(); CHECK(scene.view.taskPanel().isOpen()); CHECK(scene.view.graph().size().x < 1000); } } SUITE(TaskTreeSession) { TEST(SessionPanelStaysAtTheBottomAndControlsFollowState) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); scene.view.taskWidget().showPage(TaskWidgetPage::Session); driver.settle(); CHECK(!scene.view.session().isVisible()); CHECK(driver.paint().hasText("Open a task to start or follow its agent session.")); scene.view.openTask(scene.release); driver.settle(); CHECK(scene.view.session().isVisible()); SessionTab& session = scene.view.session(); CHECK(session.startSession.isEffectivelyEnabled()); driver.click(session.startSession); CHECK(scene.store.started == std::vector{ scene.release }); scene.board.task(scene.release)->session = { SessionState::Working, "tool: Edit", std::nullopt }; scene.view.boardReloaded(); driver.settle(); CHECK(!session.startSession.isEffectivelyEnabled()); CHECK(session.stopSession.isEffectivelyEnabled()); CHECK(session.state.text().find("tool: Edit") != std::string::npos); CHECK(scene.view.header().badge.text().find("running") != std::string::npos); driver.click(session.stopSession); CHECK(scene.store.stopped == std::vector{ scene.release }); } TEST(DshSessionOpensRegardlessOfSessionStateWhileTerminalSessionsNeedAProcess) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Session); std::vector opened; scene.view.setOnOpenSession([&opened](NodeId id) { opened.push_back(id); }); scene.view.openTask(scene.release); driver.settle(); SessionTab& session = scene.view.session(); Task& task = *scene.board.task(scene.release); task.harness = "claude-code"; task.session = { SessionState::Error, "rate_limit", std::nullopt }; scene.view.boardReloaded(); driver.settle(); CHECK(session.openSession.isEffectivelyEnabled()); task.session = { SessionState::Ended, "stopped from the board", std::nullopt }; scene.view.boardReloaded(); driver.settle(); CHECK(!session.openSession.isEffectivelyEnabled()); task.harness = "dsh"; for (SessionState state : { SessionState::None, SessionState::Ended, SessionState::Error }) { task.session = { state, "", std::nullopt }; scene.view.boardReloaded(); driver.settle(); CHECK(session.openSession.isEffectivelyEnabled()); } driver.click(session.openSession); CHECK(opened == std::vector{ scene.release }); } TEST(PresetsSitAboveCollapsedParametersAboveTheButtonsAndThereIsNoMessageField) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Session); scene.view.openTask(scene.release); driver.settle(); SessionTab& session = scene.view.session(); CHECK(!session.parameters.isExpanded()); CHECK(!session.model.isVisible() || !session.parameters.isBodyShown()); CHECK(session.presets.windowRect().pos.y < session.parameters.windowRect().pos.y); CHECK(session.parameters.windowRect().pos.y < session.startSession.windowRect().pos.y); CHECK(!driver.paint().hasText("Message the agent...")); const Task& task = *scene.board.task(scene.release); CHECK(driver.paint().hasText( task.agentModel + " \u00b7 " + task.launchSettings().harness + " \u00b7 " + task.effort + " \u00b7 " + task.permissionMode )); driver.click(session.parameters.header()); driver.settle(); CHECK(session.parameters.isExpanded()); CHECK(session.model.isVisible()); CHECK(session.model.windowRect().pos.y < session.startSession.windowRect().pos.y); } TEST(ParametersSaveAsANamedPresetAndApplyToAnotherTask) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Session); scene.view.openTask(scene.release); driver.settle(); SessionTab& session = scene.view.session(); session.parameters.setExpanded(true, false); driver.settle(); const std::vector& efforts = session.effort.options(); session.effort.setSelectedIndex( long(std::find(efforts.begin(), efforts.end(), std::string("low")) - efforts.begin()) ); CHECK_EQUAL("low", scene.board.task(scene.release)->effort); CHECK_EQUAL(SessionPresetPicker::kCustomOption, session.presets.preset.selectedText()); driver.click(session.presets.saveAs); driver.settle(); REQUIRE CHECK(session.presets.isNaming()); driver.click(session.presets.name); driver.type("dumb agent"); driver.key(Key::Enter); driver.settle(); CHECK(!session.presets.isNaming()); CHECK_EQUAL("dumb agent", session.presets.preset.selectedText()); const std::string path = SessionPresets::pathIn(scene.storage.root()); CHECK_EQUAL("/home/user/taskboard/session-presets.json", path); const std::optional stored = scene.files.readText(path); REQUIRE CHECK(stored.has_value()); CHECK(stored->find("\"dumb agent\"") != std::string::npos); CHECK(stored->find("\"low\"") != std::string::npos); scene.view.openTask(scene.widgets); driver.settle(); CHECK_EQUAL(SessionPresetPicker::kCustomOption, session.presets.preset.selectedText()); CHECK(scene.board.task(scene.widgets)->effort != "low"); session.presets.preset.setSelectedIndex(1); CHECK_EQUAL("low", scene.board.task(scene.widgets)->effort); CHECK_EQUAL("low", session.effort.selectedText()); CHECK(scene.view.header().title.text().size() > 0); SessionPresets reloaded(scene.files, scene.storage.root()); REQUIRE CHECK_EQUAL(1u, reloaded.all().size()); CHECK_EQUAL("dumb agent", reloaded.all()[0].name); CHECK_EQUAL("low", reloaded.all()[0].settings.effort); driver.click(session.presets.remove); driver.settle(); CHECK_EQUAL(SessionPresetPicker::kCustomOption, session.presets.preset.selectedText()); reloaded.reload(); CHECK(reloaded.all().empty()); } TEST(ZoomingIntoATaskCardFillsTheGraphWithTheSameCardView) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); driver.settle(); TreeView& graph = scene.view.graph(); graph.select(scene.release); graph.setView(graph.pan(), graph.fullViewScale(), false); graph.centerOn(scene.release, false); driver.settle(); driver.moveTo(graph.windowPosition() + graph.size() / 2.0f); for (int notch = 0; !graph.fullViewItem() && notch < 40; notch++) driver.wheel(Vec2F(0.0f, 1.0f)); driver.settle(); REQUIRE CHECK(graph.fullViewItem() == std::optional(scene.release)); TaskDescriptionPanel& description = scene.view.description(); CHECK(shownOnScreen(description.editor)); CHECK(description.windowRect().size.x > graph.size().x * 0.9f); CHECK_EQUAL(scene.board.task(scene.release)->title, description.header.title.text()); CHECK(!shownOnScreen(*graph.card(scene.release))); CHECK(scene.view.currentTask() == std::optional(scene.release)); driver.click(scene.view.header().back); driver.settle(); CHECK(!graph.fullViewItem()); CHECK(description.windowRect().size.x < graph.size().x * 0.5f); CHECK(shownOnScreen(*graph.card(scene.release))); } TEST(ZoomingMovesTheOneTaskWidgetIntoTheZoomAndCollapsesItsDockPanelUntilZoomingOut) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); TaskWidget& widget = scene.view.taskWidget(); REQUIRE CHECK(scene.view.taskPanel().isOpen()); CHECK(widget.isSelfOrAncestorOf(*scene.view.taskPanel().content()) || scene.view.taskPanel().content() == &widget); graph.select(scene.release); graph.enterFullView(scene.release); driver.settle(); CHECK(!scene.view.taskPanel().isOpen()); CHECK(scene.view.zoomFrame() == &graph.fullViewFrame()); CHECK(graph.fullViewFrame().isSelfOrAncestorOf(widget)); CHECK(shownOnScreen(widget.carousel)); CHECK(widget.windowRect().size.x > graph.size().x * 0.9f); graph.leaveFullView(false); driver.settle(); CHECK(scene.view.taskPanel().isOpen()); CHECK(scene.view.zoomFrame() == nullptr); CHECK(scene.view.taskPanel().isSelfOrAncestorOf(widget)); CHECK(shownOnScreen(widget.carousel)); } TEST(ZoomingOutKeepsTheDockPanelClosedWhenItWasClosedBeforeZooming) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.dock().hidePanel(scene.view.taskPanel()); driver.settle(); TreeView& graph = scene.view.graph(); graph.select(scene.release); graph.enterFullView(scene.release); driver.settle(); CHECK(scene.view.taskWidget().carousel.isVisible()); CHECK(shownOnScreen(scene.view.taskWidget().carousel)); graph.leaveFullView(false); driver.settle(); CHECK(!scene.view.taskPanel().isOpen()); } TEST(OpeningTheTaskPanelFromItsStripeWhileZoomedLeavesTheZoom) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); graph.select(scene.release); graph.enterFullView(scene.release); driver.settle(); StripeButton* stripe = scene.view.dock().stripeButton(scene.view.taskPanel()); REQUIRE CHECK(stripe != nullptr); REQUIRE CHECK(shownOnScreen(*stripe)); driver.click(*stripe); driver.settle(); CHECK(!graph.fullViewItem()); CHECK(scene.view.zoomFrame() == nullptr); CHECK(scene.view.taskPanel().isOpen()); CHECK(scene.view.taskPanel().isSelfOrAncestorOf(scene.view.taskWidget())); CHECK(shownOnScreen(scene.view.taskWidget().carousel)); } TEST(SwitchingMainViewWhileZoomedReturnsTheTaskWidgetToTheDock) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); graph.select(scene.release); graph.enterFullView(scene.release); driver.settle(); REQUIRE CHECK(!scene.view.taskPanel().isOpen()); driver.click(scene.view.views().tabButton(1)); driver.settle(); CHECK(scene.view.zoomFrame() == nullptr); CHECK(scene.view.taskPanel().isOpen()); CHECK(scene.view.taskPanel().isSelfOrAncestorOf(scene.view.taskWidget())); } TEST(EscapeZoomsOutOfTheFullViewUnlessItsTitleOrEditorHasFocus) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); driver.settle(); TreeView& graph = scene.view.graph(); graph.select(scene.release); graph.enterFullView(scene.release); driver.settle(); TaskDescriptionPanel& description = scene.view.description(); description.editor.setMode(MarkdownEditor::Mode::Editor); driver.settle(); driver.click(description.header.title); driver.key(Key::Escape); driver.settle(); CHECK(graph.fullViewItem() == std::optional(scene.release)); driver.click(description.editor.sourceArea()); driver.key(Key::Escape); driver.settle(); CHECK(graph.fullViewItem() == std::optional(scene.release)); driver.ui().setKeyboardFocus(&graph.fullViewFrame()); REQUIRE CHECK(driver.ui().keyboardFocus() == &graph.fullViewFrame()); driver.key(Key::Escape); driver.settle(); CHECK(!graph.fullViewItem()); } TEST(SavingUnderAnExistingNameReplacesThatPreset) { ui::testing::MemoryFileSystem files("/home/user"); SessionPresets presets(files, "/home/user/taskboard"); presets.save("smart", { "claude-opus-5-5", "claude-code", "high", "auto" }); presets.save("dumb", { "claude-haiku", "claude-code", "low", "auto" }); presets.save("smart", { "claude-opus-5-5", "dsh", "max", "auto" }); REQUIRE CHECK_EQUAL(2u, presets.all().size()); CHECK_EQUAL("max", presets.all()[0].settings.effort); CHECK(presets.matching({ "claude-haiku", "claude-code", "low", "auto" }) == std::optional(1)); CHECK(!presets.lastSaveFailed()); } TEST(EveryDeepSeekModelCanBeShownAndPicked) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Session); Task& task = *scene.board.task(scene.release); task.agentModel = "deepseek-v4-pro"; task.harness = "dsh"; scene.view.openTask(scene.release); driver.settle(); SessionTab& session = scene.view.session(); CHECK_EQUAL("DeepSeek Pro", session.model.selectedText()); const std::vector& models = offlineAgentOptions().models; for (const char* id : { "deepseek-flash", "deepseek-chat", "deepseek-v4-pro" }) { const auto found = std::find_if(models.begin(), models.end(), [&](const AgentOption& option) { return option.id == id; }); REQUIRE CHECK(found != models.end()); session.model.setSelectedIndex(long(found - models.begin())); driver.settle(); CHECK_EQUAL(id, task.agentModel); } } TEST(ChangedSettingsOfferRestart) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Session); Task& task = *scene.board.task(scene.release); task.session = { SessionState::Idle, "", task.launchSettings() }; scene.view.openTask(scene.release); driver.settle(); SessionTab& session = scene.view.session(); CHECK(!session.isOfferingRestart()); session.model.setSelectedIndex(1); driver.settle(); CHECK_EQUAL("claude-opus-4-8", task.agentModel); CHECK(session.isOfferingRestart()); CHECK(session.restartHint.text().find("claude-opus-5-5") != std::string::npos); scene.view.sessionScroll().jumpTo(scene.view.sessionScroll().maximumOffset()); driver.settle(); driver.click(session.restartKeep); driver.click(session.restartFresh); CHECK( scene.store.restarts == (std::vector>{ { scene.release, false }, { scene.release, true } }) ); } TEST(OpenSessionGoesToCallbackForCurrentTask) { TreeScene scene; UiDriver driver(scene.window, { 1200, 900 }); std::vector opened; scene.view.setOnOpenSession([&](NodeId id) { opened.push_back(id); }); driver.key(Key::O, { .control = true }); CHECK(opened.empty()); scene.view.openTask(scene.emoji); CHECK_EQUAL(0u, driver.ui().openPopupCount()); driver.key(Key::O, { .control = true }); CHECK(opened == std::vector{ scene.emoji }); } } namespace { halnf length(Vec2F vector) { return std::sqrt(vector.x * vector.x + vector.y * vector.y); } } SUITE(TaskTreeGraph) { Vec2F cardPoint(TreeScene & scene, NodeId id) { TreeView& graph = scene.view.graph(); const RectF card = *graph.cardRect(id); return graph.windowPosition() + card.pos + card.size / 2.0f; } Vec2F graphMiddle(TreeScene & scene) { TreeView& graph = scene.view.graph(); return graph.windowPosition() + graph.size() / 2.0f; } bool isShown(TreeScene & scene, NodeId id) { return scene.view.graph().stateOf(id) == TreeItemState::Shown; } void showEverything(UiDriver & driver, TreeView & graph, NodeId around) { graph.openTo(std::nullopt, graph.structure().height()); graph.select(around); driver.settle(); } TEST(GraphHoldsTheWholeBoardFramedWhenTheWindowOpens) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); CHECK_EQUAL(4u, graph.structure().items().size()); size_t shown = 0; for (const TreeStructure::Item& item : graph.structure().items()) { if (!isShown(scene, NodeId(item.id))) continue; shown++; const RectF card = *graph.cardRect(item.id); CHECK(contains(graph.localRect(), card.pos)); CHECK(contains(graph.localRect(), card.pos + card.size)); } CHECK(shown >= 2); } TEST(BoardLoadedAfterTheWindowOpensIsShown) { TaskBoard board; ApplicationFrame window; TaskTreeView view{ board }; window.setContent(&view); view.attachMenus(window.menuBar, [] {}); UiDriver driver(window, { 1400, 900 }); driver.settle(); const NodeId root = board.addTask({ .title = "Root" }, { 0, 0 }); for (int index = 0; index < 4; index++) { const NodeId child = board.addTask({ .title = "Child" }, { 0, 0 }); board.setParent(child, root); } view.boardReloaded(); driver.settle(); TreeView& graph = view.graph(); CHECK_EQUAL(5u, graph.structure().items().size()); const RectF card = *graph.cardRect(root); CHECK(contains(graph.localRect(), card.pos + card.size / 2.0f)); } TEST(OpeningATaskSelectsAndCentresItWithoutReRooting) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.openTask(scene.emoji); driver.settle(); TreeView& graph = scene.view.graph(); CHECK_EQUAL(4u, graph.structure().items().size()); CHECK(graph.selection() == scene.emoji); CHECK(isShown(scene, scene.emoji)); CHECK(length(cardPoint(scene, scene.emoji) - graphMiddle(scene)) < 1); } TEST(TapSelectsAndShowsPanelsSecondTapOpensAndClosesNoDoubleTapFocus) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.widgets); graph.select(std::nullopt); driver.settle(); driver.click(cardPoint(scene, scene.textEdit)); driver.settle(); CHECK(scene.view.currentTask() == scene.textEdit); CHECK(graph.selection() == scene.textEdit); CHECK(length(cardPoint(scene, scene.textEdit) - graphMiddle(scene)) < 1); CHECK(graph.isOpen(scene.textEdit)); driver.click(cardPoint(scene, scene.textEdit)); driver.settle(); CHECK(!graph.isOpen(scene.textEdit)); CHECK(!isShown(scene, scene.emoji)); CHECK(scene.view.currentTask() == scene.textEdit); CHECK_EQUAL(4u, graph.structure().items().size()); driver.click(cardPoint(scene, scene.textEdit)); driver.settle(); CHECK(graph.isOpen(scene.textEdit)); CHECK(isShown(scene, scene.emoji)); } TEST(HorizontalWheelOpensOnlyTheSelectedTasksChildrenVerticalOnlyZooms) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); graph.openTo(std::nullopt, 0); graph.select(std::nullopt); graph.frame(false); driver.settle(); driver.click(cardPoint(scene, scene.widgets)); driver.settle(); driver.moveTo(graphMiddle(scene)); const halnf scale = graph.targetScale(); for (int notch = 0; notch < 40 && !graph.isOpen(scene.widgets); notch++) driver.wheel(Vec2F(1.0f, 0.0f)); driver.settle(); CHECK(graph.isOpen(scene.widgets)); CHECK(isShown(scene, scene.textEdit)); CHECK(!isShown(scene, scene.emoji)); CHECK(scene.view.currentTask() == scene.widgets); CHECK_CLOSE(scale, graph.targetScale(), 0.0001f); for (int notch = 0; notch < 8; notch++) driver.wheel(Vec2F(0.0f, 1.0f)); driver.settle(); CHECK(graph.targetScale() > scale); CHECK(!graph.isOpen(scene.textEdit)); } TEST(ArrowKeysMoveTheSelectionAfterClickingANode) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.widgets); driver.click(cardPoint(scene, scene.widgets)); driver.settle(); driver.key(Key::Right); driver.settle(); CHECK(graph.selection() == scene.textEdit); CHECK(scene.view.currentTask() == scene.textEdit); driver.key(Key::Left); driver.settle(); CHECK(graph.selection() == scene.widgets); } TEST(GraphPlacesTasksAsATreeAndDragDoesNotMoveThem) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.textEdit); const RectF widgets = *graph.cardRect(scene.widgets); const RectF textEdit = *graph.cardRect(scene.textEdit); const RectF emoji = *graph.cardRect(scene.emoji); CHECK(textEdit.pos.x > widgets.pos.x + widgets.size.x); CHECK(emoji.pos.x > textEdit.pos.x + textEdit.size.x); const Vec2F point = cardPoint(scene, scene.textEdit); driver.drag(point, point + Vec2F(60.0f, 40.0f), 4); driver.settle(); CHECK_CLOSE(textEdit.pos.x, graph.cardRect(scene.textEdit)->pos.x, 0.01f); CHECK_CLOSE(textEdit.pos.y, graph.cardRect(scene.textEdit)->pos.y, 0.01f); } TEST(DraggingFromChildrenPortCreatesAChildAndFocusesItForEditing) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.release); const size_t before = scene.board.graph().nodes().size(); const Vec2F port = graph.windowPosition() + *graph.portPosition(scene.release, TreeView::Port::Children); driver.drag(port, port + Vec2F(160.0f, 200.0f), 6); driver.settle(); REQUIRE CHECK_EQUAL(before + 1, scene.board.graph().nodes().size()); const NodeId created = scene.board.graph().nodes().back().id; CHECK(scene.board.parentOf(created) == scene.release); CHECK(isShown(scene, created)); CHECK(graph.selection() == created); CHECK(length(cardPoint(scene, created) - graphMiddle(scene)) < 1); CHECK(scene.view.currentTask() == created); CHECK(scene.view.session().isVisible()); CHECK(scene.view.header().title.isEditing()); } TEST(DeletingAChildFocusesItsParentWithoutReframing) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.textEdit); scene.view.openTask(scene.textEdit); driver.settle(); const halnf scaleBefore = graph.targetScale(); scene.chooseAction(driver, "Delete task..."); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); scene.view.header().deleteConfirm.accept(); driver.settle(); CHECK(scene.board.task(scene.textEdit) == nullptr); CHECK(scene.view.currentTask() == scene.widgets); CHECK(graph.selection() == scene.widgets); CHECK_CLOSE(scaleBefore, graph.targetScale(), 0.0001f); } TEST(DeletingAnUnsavedGraphTaskRemovesItsCardImmediately) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.release); const Vec2F port = graph.windowPosition() + *graph.portPosition(scene.release, TreeView::Port::Children); driver.drag(port, port + Vec2F(160.0f, 200.0f), 6); driver.settle(); const std::optional created = scene.view.currentTask(); REQUIRE CHECK(created.has_value()); CHECK(graph.structure().indexOf(*created).has_value()); scene.chooseAction(driver, "Delete task..."); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); scene.view.header().deleteConfirm.accept(); driver.settle(); CHECK(scene.board.task(*created) == nullptr); CHECK(!graph.structure().indexOf(*created).has_value()); CHECK(scene.view.currentTask() == scene.release); } TEST(DraggingATaskOntoItsOwnSubtreeIsRefused) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.textEdit); const Vec2F port = graph.windowPosition() + *graph.portPosition(scene.widgets, TreeView::Port::Parent); driver.drag(port, cardPoint(scene, scene.emoji), 6); driver.settle(); CHECK(!scene.board.parentOf(scene.widgets)); CHECK(scene.board.parentOf(scene.emoji) == scene.textEdit); } TEST(ReparentingByDraggingRearrangesTheTree) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.textEdit); const Vec2F port = graph.windowPosition() + *graph.portPosition(scene.emoji, TreeView::Port::Parent); driver.drag(port, cardPoint(scene, scene.release), 6); driver.settle(); CHECK(scene.board.parentOf(scene.emoji) == scene.release); const RectF release = *graph.cardRect(scene.release); const RectF emoji = *graph.cardRect(scene.emoji); CHECK(emoji.pos.x > release.pos.x + release.size.x); CHECK_CLOSE(release.center().y, emoji.center().y, 0.5f); } TEST(DeletingKeepsTheTreeFocusedSoArrowsKeepWorking) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); showEverything(driver, graph, scene.emoji); scene.view.openTask(scene.emoji); driver.settle(); driver.ui().setKeyboardFocus(&graph); REQUIRE CHECK(graph.selection() == scene.emoji); driver.key(Key::Delete); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); scene.view.header().deleteConfirm.accept(); driver.settle(); REQUIRE CHECK(scene.board.task(scene.emoji) == nullptr); CHECK(driver.ui().keyboardFocus() == &graph); REQUIRE CHECK(graph.selection() == scene.textEdit); driver.key(Key::Left); driver.settle(); CHECK(graph.selection() == scene.widgets); } TEST(DeleteKeyRemovesEverySelectedTaskAfterConfirming) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); const NodeId spare = scene.board.addTask({ .title = "Spare" }, { 0, 0 }); scene.board.setParent(spare, scene.emoji); scene.view.boardReloaded(); showEverything(driver, graph, scene.widgets); driver.click(cardPoint(scene, scene.textEdit)); driver.settle(); driver.click(cardPoint(scene, scene.release), { .control = true }); driver.settle(); REQUIRE CHECK_EQUAL(2u, graph.selectedItems().size()); driver.key(Key::Delete); driver.settle(); REQUIRE CHECK(scene.view.graphDeleteConfirm().isOpen()); scene.view.graphDeleteConfirm().accept(); driver.settle(); CHECK(scene.board.task(scene.textEdit) == nullptr); CHECK(scene.board.task(scene.release) == nullptr); CHECK(scene.board.parentOf(scene.emoji) == scene.widgets); CHECK(scene.board.parentOf(spare) == scene.emoji); CHECK_EQUAL(3u, scene.board.graph().nodes().size()); CHECK(!graph.selection()); CHECK(!scene.view.currentTask()); } TEST(DeleteKeyOnOneSelectedTaskUsesThePageConfirmation) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); driver.click(cardPoint(scene, scene.release)); driver.settle(); driver.key(Key::Delete); driver.settle(); CHECK(scene.view.header().deleteConfirm.isOpen()); CHECK(scene.view.currentTask() == scene.release); } TEST(DetailedTreeCardsShowTheSharedTaskCardWithoutAHeader) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.board.task(scene.release)->session.state = SessionState::Working; scene.board.task(scene.release)->description = "Collect the changes"; scene.view.boardReloaded(); driver.settle(); TreeView& graph = scene.view.graph(); graph.setView(graph.pan(), 1, false); graph.select(scene.release); driver.settle(); auto* card = dynamic_cast(graph.card(scene.release)); REQUIRE CHECK(card != nullptr); CHECK(!card->isHeaderShown()); CHECK(card->content().isVisible()); TaskCardView& view = card->view(); CHECK_EQUAL("#4", view.number.text()); CHECK_EQUAL("Release notes", view.title.text()); CHECK_EQUAL("Collect the changes", view.description.text()); CHECK_EQUAL(std::string(statusLabel(scene.board.task(scene.release)->status)), view.status.text()); CHECK(view.session.isVisible()); CHECK(view.session.isPulsing()); CHECK(view.session.isDotShown()); CHECK(!view.status.isDotShown()); CHECK(view.title.windowRect().pos.y > view.number.windowRect().pos.y); CHECK(view.description.windowRect().pos.y > view.title.windowRect().pos.y); CHECK(view.description.wraps()); } TEST(TreeAndKanbanCardsShareOneTaskCardAndSize) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.board.task(scene.release)->description = std::string(600, 'x') + " tail"; scene.board.task(scene.release)->status = TaskStatus::Queued; scene.view.boardReloaded(); driver.settle(); TreeView& graph = scene.view.graph(); graph.setView(graph.pan(), 1, false); driver.settle(); const RectF treeCard = *graph.cardRect(scene.release); driver.click(scene.view.views().tabButton(1)); driver.settle(); auto* kanbanCard = dynamic_cast(scene.view.kanban().card(scene.release)); REQUIRE CHECK(kanbanCard != nullptr); CHECK_CLOSE(treeCard.size.y, kanbanCard->windowRect().size.y, 1.0f); TaskCardView& view = kanbanCard->view(); CHECK_EQUAL("Release notes", view.title.text()); CHECK(!view.status.isVisible()); const RectF description = view.description.windowRect(); const RectF cardRect = kanbanCard->windowRect(); CHECK(description.pos.y + description.size.y <= cardRect.pos.y + cardRect.size.y + 0.5f); } TEST(OneTaskPanelOnTheRightHoldsEveryTaskPageAndThePathRunsAcrossTop) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.openTask(scene.release); driver.settle(); const RectF graph = scene.view.graph().windowRect(); const RectF widget = scene.view.taskWidget().windowRect(); const RectF path = scene.view.breadcrumb().windowRect(); const RectF view = scene.view.windowRect(); CHECK(scene.view.taskPanel().side() == DockSide::Right); CHECK_EQUAL(1u, scene.view.dock().panels().size()); CHECK(widget.pos.x >= graph.pos.x + graph.size.x - 1); CHECK(path.pos.y >= graph.pos.y + graph.size.y - 1); CHECK(path.pos.y + path.size.y <= scene.view.status.windowRect().pos.y + 1); CHECK(path.size.x > view.size.x - 40); CHECK(scene.window.menuBar.centerWidget() == &scene.view.search()); TabView& carousel = scene.view.taskWidget().carousel; REQUIRE CHECK_EQUAL(4u, carousel.tabCount()); CHECK_EQUAL("Task", carousel.tabButton(0).text()); CHECK_EQUAL("Session", carousel.tabButton(1).text()); CHECK_EQUAL("Workdir", carousel.tabButton(2).text()); CHECK_EQUAL("Links", carousel.tabButton(3).text()); scene.view.taskWidget().showPage(TaskWidgetPage::Task); scene.view.openTask(std::nullopt); driver.settle(); CHECK(!shownOnScreen(scene.view.description().editor)); CHECK(driver.paint().hasText("Open a task to see and edit its description.")); } } SUITE(TaskDescriptionPanel) { TEST(DescriptionIsAMarkdownPreviewFillingThePanelUnderAnIdAndTitleRow) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); scene.board.task(scene.release)->description = "# Plan\n\nShip **it**"; scene.view.openTask(scene.release); driver.settle(); TaskDescriptionPanel& panel = scene.view.description(); CHECK(panel.editor.mode() == MarkdownEditor::Mode::Preview); CHECK(shownOnScreen(panel.editor.preview())); CHECK(!panel.editor.showsSource()); CHECK_EQUAL("#4", panel.header.idLabel.text()); CHECK_EQUAL("Release notes", panel.header.title.text()); CHECK(driver.paint().hasText("Plan")); const RectF panelBody = scene.view.taskWidget().body().windowRect(); const RectF editor = panel.editor.windowRect(); CHECK(editor.pos.y > panel.header.title.windowRect().pos.y); CHECK(editor.pos.y + editor.size.y > panelBody.pos.y + panelBody.size.y - 30); CHECK(editor.size.x > panelBody.size.x - 40); } TEST(RenamingInTheDescriptionPanelEditsTheTaskAndReportsTheTitleScope) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); scene.view.openTask(scene.release); driver.settle(); TaskTitleField& title = scene.view.header().title; driver.click(title); title.selectAll(); driver.type("Changelog"); REQUIRE CHECK(scene.store.editing.has_value()); CHECK(scene.store.editing->second == TaskField::Title); CHECK_EQUAL("Changelog", scene.board.task(scene.release)->title); CHECK_EQUAL("Changelog", scene.view.header().title.text()); CHECK(scene.edits > 0); } } SUITE(TaskWorkspacePanel) { struct WorkspaceScene : TreeScene { UiDriver driver{ window, { 1400, 900 } }; WorkspaceScene() { view.taskWidget().showPage(TaskWidgetPage::Workdir); view.openTask(release); driver.settle(); } void open(const std::string& name) { FileBrowser& browser = view.workspace().browser; browser.select(name); FileRow* row = browser.row(name); REQUIRE CHECK(row != nullptr); driver.advance(1000); driver.click(*row); driver.settle(); } }; std::vector listedNames(const FileBrowser& browser) { std::vector names; for (const auto& row : browser.rows()) names.push_back(row->entry().name); return names; } TEST(ListsTheTaskWorkspaceStartingAtItsRoot) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); CHECK_EQUAL("/agents/task-4", panel.browser.directory()); CHECK((listedNames(panel.browser) == std::vector{ "notes", "reports" })); CHECK(!panel.browser.up.isEnabled()); CHECK(shownOnScreen(panel.browser)); } TEST(WorkdirHeaderAppearsOnlyForAnOpenedFile) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); CHECK(!shownOnScreen(panel.pages().currentPage().header())); CHECK(shownOnScreen(panel.browser.path)); scene.open("reports"); scene.open("summary.md"); REQUIRE CHECK_EQUAL(2u, panel.pages().depth()); CHECK(shownOnScreen(panel.pages().currentPage().header())); } TEST(FoldersOpenInPlaceAndOnlyMarkdownFilesAreListed) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); scene.open("reports"); CHECK_EQUAL("/agents/task-4/reports", panel.browser.directory()); CHECK_EQUAL(1u, panel.pages().depth()); CHECK((listedNames(panel.browser) == std::vector{ "summary.md" })); scene.driver.click(panel.browser.up); CHECK_EQUAL("/agents/task-4", panel.browser.directory()); CHECK(!panel.browser.goUp()); } TEST(MarkdownOpensInAPreviewPageAndBackReturnsToTheFolder) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); scene.open("reports"); scene.open("summary.md"); CHECK_EQUAL(2u, panel.pages().depth()); CHECK_EQUAL("reports/summary.md", panel.pages().currentPage().title()); CHECK_EQUAL("/agents/task-4/reports/summary.md", panel.openedDocument()); CHECK(panel.document.mode() == MarkdownEditor::Mode::Preview); CHECK(shownOnScreen(panel.document.preview())); CHECK(scene.driver.paint().hasText("All done.")); scene.driver.click(panel.pages().currentPage().backButton()); scene.driver.settle(); CHECK_EQUAL(1u, panel.pages().depth()); CHECK(panel.openedDocument().empty()); CHECK_EQUAL("/agents/task-4/reports", panel.browser.directory()); CHECK(shownOnScreen(panel.browser)); } TEST(EditingAnOpenedDocumentWritesItBack) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); panel.openDocument("/agents/task-4/reports/summary.md"); panel.document.setMode(MarkdownEditor::Mode::Editor); scene.driver.settle(); scene.driver.click(panel.document.sourceArea()); scene.driver.type("!"); CHECK_EQUAL(panel.document.markdown(), *scene.files.readText("/agents/task-4/reports/summary.md")); CHECK(scene.files.readText("/agents/task-4/reports/summary.md")->find('!') != std::string::npos); } TEST(OtherFileTypesAreNotOpened) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); panel.openDocument("/agents/task-4/reports/data.csv"); CHECK_EQUAL(1u, panel.pages().depth()); CHECK(panel.openedDocument().empty()); } TEST(SwitchingTasksLeavesTheDocumentAndExplainsMissingWorkspaces) { WorkspaceScene scene; TaskWorkspacePanel& panel = scene.view.workspace(); panel.openDocument("/agents/task-4/reports/summary.md"); scene.view.openTask(scene.widgets); scene.driver.settle(); CHECK_EQUAL(1u, panel.pages().depth()); CHECK(!shownOnScreen(panel.browser)); CHECK(shownOnScreen(panel.hint)); CHECK_EQUAL("This task has no workdir yet. It appears once its agent session starts.", panel.hint.text()); scene.view.openTask(std::nullopt); scene.driver.settle(); CHECK(shownOnScreen(panel.hint)); CHECK_EQUAL("Open a task to browse the files its agent produced.", panel.hint.text()); } } SUITE(TaskKanban) { size_t statusColumn(TreeScene & scene, TaskStatus status) { return scene.view.kanbanColumn(status); } void showKanbanTab(UiDriver & driver, TreeScene & scene) { driver.click(scene.view.views().tabButton(1)); driver.settle(); } void showKanban(UiDriver & driver, TreeScene & scene) { scene.view.kanban().setColumnVisible(statusColumn(scene, TaskStatus::Backlog), true); showKanbanTab(driver, scene); } std::vector cardsIn(TreeScene & scene, TaskStatus status) { std::vector ids; for (const KanbanCard* card : scene.view.kanban().columnView(statusColumn(scene, status)).stack().cards()) ids.push_back(card->id()); return ids; } std::vector shownColumnTitles(KanbanBoard & kanban) { std::vector titles; for (size_t column = 0; column < kanban.columnCount(); column++) if (shownOnScreen(kanban.columnView(column))) titles.push_back(kanban.columnView(column).title().text()); return titles; } TEST(DoubleClickingAKanbanCardOpensItsDescriptionFullViewAndBackReturns) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); driver.settle(); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); KanbanCard& card = *kanban.card(scene.release); scene.view.dock().hidePanel(scene.view.taskPanel()); driver.settle(); REQUIRE CHECK(!scene.view.taskPanel().isOpen()); driver.click(card); driver.click(card); driver.settle(); REQUIRE CHECK(kanban.fullViewItem() == std::optional(scene.release)); CHECK(!scene.view.taskPanel().isOpen()); TaskDescriptionPanel& description = scene.view.description(); CHECK(shownOnScreen(description.editor)); CHECK_EQUAL(scene.board.task(scene.release)->title, description.header.title.text()); CHECK(scene.view.currentTask() == std::optional(scene.release)); CHECK(!shownOnScreen(kanban.columnView(0))); driver.click(scene.view.header().back); driver.settle(); CHECK(!kanban.fullViewItem()); CHECK(!shownOnScreen(description)); CHECK(shownOnScreen(card)); } TEST(DockedPanelShowsTheSameBadgeRowAboveTheFramedTaskBody) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.openTask(scene.release); driver.settle(); TaskWidget& widget = scene.view.taskWidget(); REQUIRE CHECK(scene.view.taskPanel().isSelfOrAncestorOf(widget)); const RectF badges = scene.view.header().badgeRow().windowRect(); const RectF body = widget.body().windowRect(); CHECK(shownOnScreen(scene.view.header().idLabel)); CHECK(!shownOnScreen(scene.view.header().back)); CHECK(badges.pos.y + badges.size.y <= body.pos.y - 4); CHECK(widget.carousel.tabButton(0).windowRect().pos.y >= body.pos.y + 4); const RGBA surface = driver.ui().theme().palette.surface; bool bodyPainted = false; for (const CanvasCommand& command : driver.paint().commands()) bodyPainted |= command.kind == CanvasCommand::Kind::Rect && command.color == surface && std::abs(command.rect.size.x - body.size.x) < 1 && std::abs(command.rect.size.y - body.size.y) < 1; CHECK(bodyPainted); } TEST(BadgeRowSitsAboveTheFramedTaskBodyInsideTheFullView) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); kanban.enterFullView(scene.release, false); driver.settle(); TaskWidget& widget = scene.view.taskWidget(); const RectF frame = kanban.fullViewFrame().windowRect(); const RectF content = widget.windowRect(); CHECK(content.pos.x - frame.pos.x >= FullViewFrame::kAccentInset + FullViewFrame::kAccentWidth + 4); CHECK(content.pos.y - frame.pos.y >= 4); CHECK(frame.pos.x + frame.size.x - (content.pos.x + content.size.x) >= 4); const RectF badges = scene.view.header().badgeRow().windowRect(); const RectF body = widget.body().windowRect(); CHECK(scene.view.header().badgeRow().parent() == &widget); CHECK(widget.carousel.parent() == &widget.body()); CHECK(badges.pos.y + badges.size.y <= body.pos.y - 4); CHECK(widget.carousel.tabButton(0).windowRect().pos.y >= body.pos.y + 4); const RectF previous = widget.carousel.previousButton().windowRect(); CHECK(previous.pos.x - content.pos.x >= 4); } TEST(FullViewIsTheGrownCardWithTheSameBadgeRowAndBack) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); const RGBA color = kTaskColors[2]; scene.board.task(scene.release)->color = color; scene.view.boardReloaded(); TaskHeader& header = scene.view.header(); Widget* const badgeRowParent = header.badgeRow().parent(); CHECK(!header.back.isVisible()); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); kanban.enterFullView(scene.release, false); driver.settle(); FullViewFrame& frame = kanban.fullViewFrame(); REQUIRE CHECK(frame.accent().has_value()); CHECK(*frame.accent() == color); CHECK(frame.content() == &scene.view.taskWidget()); auto* preview = dynamic_cast(frame.preview()); REQUIRE CHECK(preview != nullptr); CHECK_EQUAL(scene.board.task(scene.release)->title, preview->title.text()); CHECK(header.badgeRow().parent() == badgeRowParent); CHECK(shownOnScreen(header.back)); CHECK_EQUAL("\u2190 Back", header.back.text()); CHECK(shownOnScreen(header.idLabel)); CHECK_CLOSE(header.back.windowRect().center().y, header.idLabel.windowRect().center().y, 2.0f); CHECK(header.idLabel.windowRect().pos.x > header.back.windowRect().pos.x); scene.view.taskWidget().showPage(TaskWidgetPage::Links); driver.settle(); CHECK(shownOnScreen(header.idLabel)); CHECK(shownOnScreen(header.back)); driver.click(header.back); driver.settle(); CHECK(!kanban.fullViewItem()); CHECK(!header.back.isVisible()); CHECK(header.badgeRow().parent() == badgeRowParent); } TEST(KanbanDeleteKeyAsksLikeTheTreeAndArrowsMoveTheSelection) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const size_t column = statusColumn(scene, scene.board.task(scene.release)->status); const std::vector& cards = kanban.columnView(column).stack().cards(); REQUIRE CHECK(cards.size() >= 2); const NodeId first = cards[0]->id(); const NodeId second = cards[1]->id(); driver.click(*kanban.card(first)); driver.settle(); CHECK(driver.ui().keyboardFocus() == &kanban); driver.key(Key::Down); driver.settle(); CHECK(kanban.selection() == std::optional(second)); CHECK(scene.view.currentTask() == std::optional(second)); driver.key(Key::Delete); driver.settle(); REQUIRE CHECK(scene.view.header().deleteConfirm.isOpen()); scene.view.header().deleteConfirm.accept(); driver.settle(); CHECK(scene.board.task(second) == nullptr); CHECK(driver.ui().keyboardFocus() == &kanban); } TEST(TreeAndKanbanAreTabsOfTheMainView) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); REQUIRE CHECK_EQUAL(4u, scene.view.views().tabCount()); CHECK_EQUAL("Tree", scene.view.views().tabButton(0).text()); CHECK_EQUAL("Kanban", scene.view.views().tabButton(1).text()); CHECK_EQUAL("Skills", scene.view.views().tabButton(2).text()); CHECK_EQUAL("Secrets", scene.view.views().tabButton(3).text()); CHECK(shownOnScreen(scene.view.graph())); CHECK(!shownOnScreen(scene.view.kanban())); showKanban(driver, scene); CHECK(shownOnScreen(scene.view.kanban())); CHECK(!shownOnScreen(scene.view.graph())); } TEST(ColumnsAreTaskStatusesInTheGlobalTaskOrder) { TreeScene scene(false); scene.board.task(scene.emoji)->status = TaskStatus::Wip; scene.board.task(scene.widgets)->order = 3; scene.board.task(scene.textEdit)->order = 1; scene.board.task(scene.release)->order = 2; scene.view.boardReloaded(); UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); REQUIRE CHECK_EQUAL(kTaskStatuses.size(), kanban.columnCount()); CHECK_EQUAL("Backlog", kanban.columnView(statusColumn(scene, TaskStatus::Backlog)).title().text()); CHECK_EQUAL("Queued", kanban.columnView(statusColumn(scene, TaskStatus::Queued)).title().text()); CHECK_EQUAL("WIP", kanban.columnView(statusColumn(scene, TaskStatus::Wip)).title().text()); CHECK_EQUAL(statusColumn(scene, TaskStatus::Wip), *kanban.columnOf(scene.emoji)); CHECK( (cardsIn(scene, TaskStatus::Backlog) == std::vector{ scene.textEdit, scene.release, scene.widgets }) ); for (size_t column = 0; column < kanban.columnCount(); column++) CHECK(!kanban.columns()[column].accent.has_value()); CHECK_EQUAL("#2 Text edit glitches", kanban.card(scene.textEdit)->title()); CHECK_EQUAL("space and emoji", kanban.card(scene.textEdit)->detail()); CHECK_EQUAL("No description", kanban.card(scene.widgets)->detail()); } TEST(RetiredStatusNamesInSavedColumnSettingsAreIgnored) { MemoryFileSystem files; files.addTextFile("/home/user/taskboard/kanban-columns.json", R"({"hidden": ["backlog", "ready", "failed"]})"); KanbanColumnSettings settings(files, "/home/user/taskboard"); CHECK((settings.hidden() == std::vector{ TaskStatus::Backlog })); } TEST(SavedColumnOrderIsCompletedWithStatusesItDoesNotName) { MemoryFileSystem files; files.addTextFile( "/home/user/taskboard/kanban-columns.json", R"({"order": ["done", "running", "wip", "done", 7], "hidden": []})" ); KanbanColumnSettings settings(files, "/home/user/taskboard"); std::vector expected = { TaskStatus::Done, TaskStatus::Wip }; for (const TaskStatus status : kTaskStatuses) if (status != TaskStatus::Done && status != TaskStatus::Wip) expected.push_back(status); CHECK((settings.order() == expected)); CHECK(settings.hidden().empty()); } TEST(ColumnSettingsWithoutAnOrderKeepTheDefaultOrder) { MemoryFileSystem files; files.addTextFile("/home/user/taskboard/kanban-columns.json", R"({"hidden": ["done"]})"); KanbanColumnSettings settings(files, "/home/user/taskboard"); CHECK((settings.order() == KanbanColumnSettings::orderByDefault())); CHECK((settings.hidden() == std::vector{ TaskStatus::Done })); } TEST(ColumnOrderSurvivesARestartOnDisk) { const std::filesystem::path directory = std::filesystem::temp_directory_path() / ("taskboard-columns-" + std::to_string(::getpid())); std::filesystem::remove_all(directory); { KanbanColumnSettings settings(FileSystem::local(), directory.string()); settings.moveColumn(settings.order().size() - 1, 0); settings.setVisible(TaskStatus::Blocked, true); } KanbanColumnSettings restarted(FileSystem::local(), directory.string()); CHECK(restarted.order().front() == TaskStatus::Blocked); CHECK_EQUAL(kTaskStatuses.size(), restarted.order().size()); const std::vector& hidden = restarted.hidden(); CHECK(std::find(hidden.begin(), hidden.end(), TaskStatus::Blocked) == hidden.end()); std::filesystem::remove_all(directory); } TEST(BacklogAndRarelyUsedColumnsAreHiddenByDefault) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); showKanbanTab(driver, scene); KanbanBoard& kanban = scene.view.kanban(); CHECK((shownColumnTitles(kanban) == std::vector{ "Queued", "WIP", "Review", "Done" })); CHECK(!shownOnScreen(*kanban.card(scene.release))); } TEST(ColumnMenuShowsAColumnAndTheChoiceIsRemembered) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); showKanbanTab(driver, scene); KanbanBoard& kanban = scene.view.kanban(); KanbanColumnView& queued = kanban.columnView(statusColumn(scene, TaskStatus::Queued)); driver.click(queued.optionsButton()); driver.settle(); REQUIRE CHECK(queued.optionsMenu().isOpen()); const auto& items = queued.optionsMenu().items(); REQUIRE CHECK_EQUAL(kTaskStatuses.size(), items.size()); driver.click(*items[statusColumn(scene, TaskStatus::Backlog)]); driver.click(queued.optionsButton()); driver.settle(); driver.click(*items[statusColumn(scene, TaskStatus::Done)]); driver.settle(); CHECK((shownColumnTitles(kanban) == std::vector{ "Backlog", "Queued", "WIP", "Review" })); CHECK(shownOnScreen(*kanban.card(scene.release))); TaskTreeView reopened{ scene.board, scene.files, scene.storage }; CHECK(reopened.kanban().isColumnVisible(reopened.kanbanColumn(TaskStatus::Backlog))); CHECK(!reopened.kanban().isColumnVisible(reopened.kanbanColumn(TaskStatus::Done))); CHECK(reopened.kanban().isColumnVisible(reopened.kanbanColumn(TaskStatus::Queued))); } TEST(DraggingAColumnHeaderMovesTheColumnAndRemembersTheOrder) { TreeScene scene(false); scene.board.task(scene.widgets)->status = TaskStatus::Wip; scene.view.boardReloaded(); UiDriver driver(scene.window, { 1600, 900 }); showKanbanTab(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const RectF review = kanban.columnView(statusColumn(scene, TaskStatus::Review)).windowRect(); const Vec2F reviewRightHalf = { review.pos.x + review.size.x * 0.75f, review.center().y }; driver.drag(driver.centerOf(kanban.columnView(statusColumn(scene, TaskStatus::Wip)).title()), reviewRightHalf, 10); driver.settle(); CHECK((shownColumnTitles(kanban) == std::vector{ "Queued", "Review", "WIP", "Done" })); CHECK((cardsIn(scene, TaskStatus::Wip) == std::vector{ scene.widgets })); CHECK(scene.board.task(scene.widgets)->status == TaskStatus::Wip); TaskTreeView reopened{ scene.board, scene.files, scene.storage }; CHECK(reopened.kanbanColumn(TaskStatus::Review) < reopened.kanbanColumn(TaskStatus::Wip)); CHECK_EQUAL("WIP", reopened.kanban().columnView(reopened.kanbanColumn(TaskStatus::Wip)).title().text()); CHECK(!reopened.kanban().isColumnVisible(reopened.kanbanColumn(TaskStatus::Backlog))); } TEST(ACardDroppedIntoAMovedColumnTakesThatColumnsStatus) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); kanban.moveColumn(statusColumn(scene, TaskStatus::Review), 0); driver.settle(); REQUIRE CHECK_EQUAL(0u, statusColumn(scene, TaskStatus::Review)); driver.drag(driver.centerOf(*kanban.card(scene.release)), kanban.columnView(0).windowRect().center(), 10); driver.settle(); CHECK(scene.board.task(scene.release)->status == TaskStatus::Review); CHECK((cardsIn(scene, TaskStatus::Review) == std::vector{ scene.release })); } TEST(DroppingACardBetweenTwoCardsPlacesItThereInTheGlobalOrder) { TreeScene scene(false); for (NodeId id : { scene.widgets, scene.textEdit, scene.emoji, scene.release }) scene.board.task(id)->status = TaskStatus::Queued; scene.board.task(scene.widgets)->order = 0; scene.board.task(scene.textEdit)->order = 1; scene.board.task(scene.emoji)->order = 2; scene.board.task(scene.release)->order = 3; scene.view.boardReloaded(); UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const RectF target = kanban.card(scene.textEdit)->windowRect(); driver.drag(driver.centerOf(*kanban.card(scene.release)), { target.center().x, target.pos.y + 4 }, 10); driver.settle(); const std::vector expected = { scene.widgets, scene.release, scene.textEdit, scene.emoji }; CHECK((cardsIn(scene, TaskStatus::Queued) == expected)); CHECK((scene.board.tasksInOrder() == std::vector(expected.begin(), expected.end()))); CHECK_EQUAL(1, scene.edits); } TEST(TheKanbanOrderIsTheOrderOfChildrenInTheTree) { TreeScene scene(false); const NodeId second = scene.board.addTask({ .title = "Second child", .status = TaskStatus::Queued, .order = 5 }, { 0, 0 }); scene.board.setParent(second, scene.widgets); scene.board.task(scene.textEdit)->status = TaskStatus::Queued; scene.board.task(scene.textEdit)->order = 4; scene.view.boardReloaded(); UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); REQUIRE CHECK((scene.board.childrenOf(scene.widgets) == std::vector{ scene.textEdit, second })); const RectF target = kanban.card(scene.textEdit)->windowRect(); driver.drag(driver.centerOf(*kanban.card(second)), { target.center().x, target.pos.y + 4 }, 10); driver.settle(); CHECK((scene.board.childrenOf(scene.widgets) == std::vector{ second, scene.textEdit })); } TEST(CardsHaveOneFixedHeightWhateverTheDescription) { TreeScene scene(false); scene.board.task(scene.emoji)->description = std::string(2000, 'x') + " long description"; scene.view.boardReloaded(); UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const halnf height = kanban.card(scene.widgets)->size().y; CHECK(height > 60); CHECK_CLOSE(height, kanban.card(scene.emoji)->size().y, 0.01f); CHECK_CLOSE(height, kanban.card(scene.textEdit)->size().y, 0.01f); } TEST(DraggingACardToAnotherColumnChangesTheTaskStatus) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const size_t review = statusColumn(scene, TaskStatus::Review); driver.drag(driver.centerOf(*kanban.card(scene.release)), kanban.columnView(review).windowRect().center(), 10); driver.settle(); CHECK(scene.board.task(scene.release)->status == TaskStatus::Review); CHECK_EQUAL(review, *kanban.columnOf(scene.release)); CHECK_EQUAL(1, scene.edits); } TEST(ReadOnlyBoardPutsADraggedCardBack) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); const size_t original = *kanban.columnOf(scene.release); scene.view.setReadOnly(true); driver.drag( driver.centerOf(*kanban.card(scene.release)), kanban.columnView(statusColumn(scene, TaskStatus::Review)).windowRect().center(), 10 ); driver.settle(); CHECK(scene.board.task(scene.release)->status == TaskStatus::Backlog); CHECK_EQUAL(original, *kanban.columnOf(scene.release)); CHECK_EQUAL(0, scene.edits); } TEST(StatusChangedElsewhereMovesTheCard) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); scene.board.task(scene.widgets)->status = TaskStatus::Done; scene.view.boardReloaded(); driver.settle(); CHECK_EQUAL(statusColumn(scene, TaskStatus::Done), *scene.view.kanban().columnOf(scene.widgets)); } TEST(ClickingACardOpensTheTaskAndOpeningATaskSelectsItsCard) { TreeScene scene; UiDriver driver(scene.window, { 1600, 900 }); showKanban(driver, scene); KanbanBoard& kanban = scene.view.kanban(); driver.click(*kanban.card(scene.emoji)); driver.settle(); CHECK(scene.view.currentTask() == scene.emoji); CHECK(kanban.selection() == scene.emoji); scene.view.openTask(scene.release); driver.settle(); CHECK(kanban.selection() == scene.release); CHECK(kanban.card(scene.release)->isSelected()); CHECK(!kanban.card(scene.emoji)->isSelected()); } TEST(TaskSelectedInKanbanIsShownCentredWhenSwitchingToTree) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); graph.openTo(std::nullopt, 0); driver.settle(); REQUIRE CHECK(graph.stateOf(scene.emoji) != TreeItemState::Shown); showKanban(driver, scene); driver.click(*scene.view.kanban().card(scene.emoji)); driver.settle(); driver.click(scene.view.views().tabButton(0)); driver.settle(); CHECK(graph.selection() == scene.emoji); CHECK(graph.stateOf(scene.emoji) == TreeItemState::Shown); const RectF card = *graph.cardRect(scene.emoji); const Vec2F centre = card.pos + card.size / 2.0f; CHECK_CLOSE(graph.size().x / 2, centre.x, 1.0f); CHECK_CLOSE(graph.size().y / 2, centre.y, 1.0f); } TEST(SwitchingBackToTreeRecentresTheSelectedTaskAfterPanningAway) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); scene.view.openTask(scene.emoji); driver.settle(); graph.setView(graph.pan() + Vec2F(400, 250), graph.scale(), false); driver.settle(); showKanban(driver, scene); driver.click(scene.view.views().tabButton(0)); driver.settle(); const RectF card = *graph.cardRect(scene.emoji); const Vec2F centre = card.pos + card.size / 2.0f; CHECK_CLOSE(graph.size().x / 2, centre.x, 1.0f); CHECK_CLOSE(graph.size().y / 2, centre.y, 1.0f); } TEST(TaskSelectedInTreeIsSelectedInKanban) { TreeScene scene(false); UiDriver driver(scene.window, { 1600, 900 }); driver.settle(); TreeView& graph = scene.view.graph(); graph.openTo(std::nullopt, graph.structure().height()); driver.settle(); const RectF card = *graph.cardRect(scene.textEdit); driver.click(graph.windowPosition() + card.pos + card.size / 2.0f); driver.settle(); showKanban(driver, scene); CHECK(scene.view.kanban().selection() == scene.textEdit); CHECK(scene.view.kanban().card(scene.textEdit)->isSelected()); } TEST(DeletedTaskLeavesTheKanban) { TreeScene scene(false); UiDriver driver(scene.window, { 1400, 900 }); showKanban(driver, scene); scene.board.graph().removeNode(scene.release); scene.view.boardReloaded(); driver.settle(); CHECK(scene.view.kanban().card(scene.release) == nullptr); } } SUITE(TaskTimeline) { constexpr double kHour = 60 * 60; constexpr double kDay = 24 * kHour; TEST(SliderCoversOneWindowOfThePrecisionAndItsEndIsLive) { TaskTimeline timeline; std::vector> chosen; timeline.setOnMomentChosen([&](std::optional moment) { chosen.push_back(moment); }); CHECK(!timeline.slider.isEnabled()); const double last = 10 * kDay; timeline.setSpan(last - 3 * kDay, last); CHECK(timeline.slider.isEnabled()); CHECK_EQUAL("1 hour", std::string(timeline.precision().label)); CHECK_EQUAL(60u, timeline.stepCount()); CHECK_CLOSE(last - kHour, timeline.windowStart(), 0.001); timeline.setPrecision(2); CHECK_EQUAL(96u, timeline.stepCount()); CHECK_CLOSE(last - kDay, timeline.momentAtStep(0).value_or(0), 0.001); CHECK_CLOSE(last - kDay / 2, timeline.momentAtStep(48).value_or(0), 0.001); CHECK(!timeline.momentAtStep(96).has_value()); timeline.chooseStep(48); timeline.chooseStep(96); REQUIRE CHECK_EQUAL(2u, chosen.size()); CHECK_CLOSE(last - kDay / 2, chosen[0].value_or(0), 0.001); CHECK(!chosen[1].has_value()); } TEST(BackAndForwardShiftTheWindowByOnePrecision) { TaskTimeline timeline; std::optional shown; timeline.setOnMomentChosen([&](std::optional moment) { shown = moment; timeline.showMoment(moment); }); const double last = 10 * kDay; timeline.setSpan(last - 5 * kHour - 10, last); CHECK(!timeline.forward.isEnabled()); CHECK(timeline.back.isEnabled()); timeline.previousWindow(); CHECK_CLOSE(last - kHour, shown.value_or(0), 0.001); CHECK_CLOSE(last - 2 * kHour, timeline.windowStart(), 0.001); CHECK_EQUAL(60.0f, timeline.slider.value()); timeline.chooseStep(30); CHECK_CLOSE(last - kHour - kHour / 2, shown.value_or(0), 0.001); timeline.previousWindow(); CHECK_CLOSE(last - 2 * kHour - kHour / 2, shown.value_or(0), 0.001); CHECK_CLOSE(last - 3 * kHour, timeline.windowStart(), 0.001); CHECK_EQUAL(30.0f, timeline.slider.value()); CHECK(timeline.moment.text().find("read-only") != std::string::npos); timeline.nextWindow(); CHECK_CLOSE(last - kHour - kHour / 2, shown.value_or(0), 0.001); timeline.nextWindow(); CHECK_CLOSE(last - kHour / 2, shown.value_or(0), 0.001); CHECK_CLOSE(last - kHour, timeline.windowStart(), 0.001); CHECK(!timeline.forward.isEnabled()); timeline.previousWindow(); timeline.chooseStep(60); timeline.nextWindow(); CHECK(!shown.has_value()); } TEST(BackStopsAtTheOldestWindow) { TaskTimeline timeline; std::optional shown; timeline.setOnMomentChosen([&](std::optional moment) { shown = moment; timeline.showMoment(moment); }); const double last = 10 * kDay; timeline.setSpan(last - kHour - 10, last); timeline.previousWindow(); CHECK(!timeline.back.isEnabled()); timeline.previousWindow(); CHECK_CLOSE(last - kHour, shown.value_or(0), 0.001); } TEST(SwitchingBetweenLiveAndThePastKeepsTheSliderGeometry) { ApplicationFrame window; TaskTimeline timeline; window.setContent(&timeline); UiDriver driver(window, { 1200, 200 }); const double last = 10 * kDay; timeline.setSpan(last - 5 * kDay, last); driver.settle(); const RectF live = timeline.slider.windowRect(); timeline.showMoment(last - 2 * kDay - 1234); driver.settle(); CHECK_CLOSE(live.pos.x, timeline.slider.windowRect().pos.x, 0.01f); CHECK_CLOSE(live.size.x, timeline.slider.windowRect().size.x, 0.01f); timeline.showMoment(std::nullopt); timeline.setSpan(std::nullopt, std::nullopt); driver.settle(); CHECK_CLOSE(live.size.x, timeline.slider.windowRect().size.x, 0.01f); } TEST(OnlyChangesInsideTheWindowBecomeTickMarks) { TaskTimeline timeline; const double last = 10 * kDay; timeline.setSpan(last - 4 * kDay, last); timeline.setPrecision(2); timeline.setChangeMoments({ last - 2 * kDay, last - kDay, last - kDay / 2, last }); const std::vector& ticks = timeline.slider.tickMarks(); REQUIRE CHECK_EQUAL(3u, ticks.size()); CHECK_CLOSE(0.0f, ticks[0], 0.0001f); CHECK_CLOSE(0.5f, ticks[1], 0.0001f); CHECK_CLOSE(1.0f, ticks[2], 0.0001f); } TEST(TimelineIsHiddenByDefaultAndToggledFromTheViewMenu) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); driver.settle(); TaskTimeline& timeline = scene.view.timeline(); CHECK(!timeline.isVisible()); auto toggle = [&] { for (const auto& item : scene.view.viewMenu.items()) { if (item->text() != "Timeline") continue; CHECK(item->entry().kind == MenuEntry::Kind::Toggle); CHECK_EQUAL(timeline.isVisible(), item->entry().isChecked()); item->entry().action(); driver.settle(); return; } CHECK(false); }; toggle(); CHECK(timeline.isVisible()); std::vector> chosen; timeline.setOnMomentChosen([&](std::optional moment) { chosen.push_back(moment); }); timeline.setSpan(1000.0, 1000.0 + 10 * kDay); timeline.showMoment(1000.0 + kDay); toggle(); CHECK(!timeline.isVisible()); REQUIRE CHECK_EQUAL(1u, chosen.size()); CHECK(!chosen.front().has_value()); } TEST(ReadOnlyBoardIgnoresEditsAndShortcuts) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); scene.view.taskWidget().showPage(TaskWidgetPage::Task); driver.settle(); scene.view.openTask(scene.widgets); driver.settle(); scene.view.setReadOnly(true); const size_t tasksBefore = scene.board.graph().nodes().size(); CHECK(!scene.view.page().isEffectivelyEnabled()); CHECK(!scene.view.description().editor.sourceArea().isEffectivelyEnabled()); scene.view.createTask(); driver.key(Key::N, { .control = true }); driver.click(scene.view.graph()); driver.key(Key::Delete); driver.settle(); CHECK(!scene.view.graphDeleteConfirm().isOpen()); CHECK(!scene.view.header().deleteConfirm.isOpen()); CHECK_EQUAL(tasksBefore, scene.board.graph().nodes().size()); CHECK_EQUAL(0, scene.edits); scene.view.setReadOnly(false); CHECK(scene.view.page().isEffectivelyEnabled()); scene.view.createTask(); CHECK_EQUAL(tasksBefore + 1, scene.board.graph().nodes().size()); } struct RecordingSecretsStore : SecretsStore { void listSecrets(std::function)> onResult) override { listCalls++; onResult(entries); } void setSecret( const std::string& key, const std::string& value, const std::string& description, std::function onDone ) override { stored.push_back({ key, value, description }); bool replaced = false; for (SecretEntry& entry : entries) if (entry.key == key) { entry.description = description; replaced = true; } if (!replaced) entries.push_back({ key, description }); onDone(true, {}); } void deleteSecret(const std::string& key, std::function onDone) override { deleted.push_back(key); entries.erase( std::remove_if(entries.begin(), entries.end(), [&](const SecretEntry& entry) { return entry.key == key; }), entries.end() ); onDone(true, {}); } struct Stored { std::string key; std::string value; std::string description; }; int listCalls = 0; std::vector entries; std::vector stored; std::vector deleted; }; struct SkillsScene { MemoryFileSystem files; ApplicationFrame window; SkillsPanel panel{ "/skills", files }; SkillsScene() { files.addTextFile("/skills/elvees/SKILL.md", "---\nname: elvees\ndescription: Elvees access\n---\n\n# Elvees\n"); files.addTextFile("/skills/generic/SKILL.md", "---\nname: generic\ndescription: Conventions\n---\n\n# Generic\n"); panel.refresh(); window.setContent(&panel); } }; TEST(SkillsTabEditsSkillFileOnDisk) { SkillsScene scene; UiDriver driver(scene.window, { 1200, 800 }); REQUIRE CHECK(scene.panel.browser.isVisible()); REQUIRE CHECK(scene.panel.browser.row("elvees") != nullptr); scene.panel.browser.onFileOpened("/skills/elvees/SKILL.md"); driver.settle(); CHECK(shownOnScreen(scene.panel.document)); CHECK(scene.panel.document.markdown().find("# Elvees") != std::string::npos); scene.panel.document.setMode(MarkdownEditor::Mode::Editor); driver.settle(); driver.click(scene.panel.document.sourceArea()); driver.type("!"); CHECK_EQUAL(scene.panel.document.markdown(), *scene.files.readText("/skills/elvees/SKILL.md")); CHECK(scene.files.readText("/skills/elvees/SKILL.md")->find('!') != std::string::npos); } TEST(SkillsTabCreatesNewSkillFolder) { SkillsScene scene; UiDriver driver(scene.window, { 1200, 800 }); CHECK(scene.panel.createSkill("brand-new")); driver.settle(); CHECK(scene.files.exists("/skills/brand-new/SKILL.md")); CHECK(scene.files.readText("/skills/brand-new/SKILL.md")->find("name: brand-new") != std::string::npos); CHECK(!scene.panel.createSkill("brand-new")); CHECK(!scene.panel.createSkill("../escape")); } TEST(SkillsLibraryShowsNoHeaderHintOrNewSkillButton) { SkillsScene scene; UiDriver driver(scene.window, { 1200, 800 }); driver.settle(); CHECK(shownOnScreen(scene.panel.browser)); CHECK(scene.panel.browser.row("elvees") != nullptr); CHECK(!driver.paint().hasText("Back")); CHECK(!driver.paint().hasText("Skills")); CHECK(!driver.paint().hasText("New skill")); CHECK(!driver.paint().hasText("Each skill is a folder with a SKILL.md")); } TEST(OpeningASkillShowsBackAndReturningToTheLibraryHidesIt) { SkillsScene scene; UiDriver driver(scene.window, { 1200, 800 }); scene.panel.browser.onFileOpened("/skills/elvees/SKILL.md"); driver.settle(); REQUIRE CHECK(shownOnScreen(scene.panel.document)); CHECK(driver.paint().hasText("Back")); Button* back = findButton(scene.panel, "Back"); REQUIRE CHECK(back != nullptr); driver.click(*back); driver.settle(); CHECK(shownOnScreen(scene.panel.browser)); CHECK(!driver.paint().hasText("Back")); } TEST(SecretsTabListsAddsAndDeletesKeysWithoutShowingValues) { RecordingSecretsStore store; store.entries = { { "elvees.gitlab_token", "Elvees GitLab PAT" } }; ApplicationFrame window; SecretsPanel panel; window.setContent(&panel); UiDriver driver(window, { 1000, 800 }); panel.setStore(&store); driver.settle(); CHECK(store.listCalls >= 1); CHECK_EQUAL("Add", panel.save.text()); panel.key.setText("selfhost.ssh_user"); panel.value.setText("root"); panel.description.setText("server login"); driver.click(panel.save); driver.settle(); REQUIRE CHECK_EQUAL(1u, store.stored.size()); CHECK_EQUAL("selfhost.ssh_user", store.stored[0].key); CHECK_EQUAL("root", store.stored[0].value); CHECK_EQUAL("", panel.value.text()); Button* deleteButton = findButton(panel, "Delete"); REQUIRE CHECK(deleteButton != nullptr); driver.click(*deleteButton); driver.settle(); REQUIRE CHECK_EQUAL(1u, store.deleted.size()); CHECK_EQUAL("elvees.gitlab_token", store.deleted[0]); } TEST(SecretsTabEditPopulatesFormAndUpdatesEntry) { RecordingSecretsStore store; store.entries = { { "elvees.gitlab_token", "GitLab PAT" } }; ApplicationFrame window; SecretsPanel panel; window.setContent(&panel); UiDriver driver(window, { 1000, 800 }); panel.setStore(&store); driver.settle(); Button* editButton = findButton(panel, "Edit"); REQUIRE CHECK(editButton != nullptr); driver.click(*editButton); driver.settle(); CHECK_EQUAL("elvees.gitlab_token", panel.key.text()); CHECK_EQUAL("GitLab PAT", panel.description.text()); CHECK_EQUAL("", panel.value.text()); CHECK_EQUAL("Update", panel.save.text()); panel.value.setText("glpat-newvalue"); driver.click(panel.save); driver.settle(); REQUIRE CHECK_EQUAL(1u, store.stored.size()); CHECK_EQUAL("elvees.gitlab_token", store.stored[0].key); CHECK_EQUAL("glpat-newvalue", store.stored[0].value); CHECK_EQUAL("", panel.key.text()); CHECK_EQUAL("Add", panel.save.text()); } } SUITE(TaskContextMenu) { MenuItem* menuItem(Menu & menu, const std::string& text) { for (const auto& item : menu.items()) if (item->text() == text) return item; return nullptr; } std::vector menuTexts(Menu & menu) { std::vector texts; for (const auto& item : menu.items()) texts.push_back(item->text()); return texts; } void chooseItem(UiDriver & driver, Menu & menu, const std::string& text) { MenuItem* item = menuItem(menu, text); REQUIRE CHECK(item != nullptr); REQUIRE CHECK(item->isEffectivelyEnabled()); driver.click(*item); driver.settle(); } void chooseNested(UiDriver & driver, Menu & menu, const std::string& submenu, Menu & nested, const std::string& text) { MenuItem* opener = menuItem(menu, submenu); REQUIRE CHECK(opener != nullptr); driver.moveTo(*opener); driver.settle(); REQUIRE CHECK(nested.isOpen()); chooseItem(driver, nested, text); } Vec2F graphCardPoint(TreeScene & scene, NodeId id) { TreeView& graph = scene.view.graph(); const RectF card = *graph.cardRect(id); return graph.windowPosition() + card.pos + card.size / 2.0f; } void showTree(UiDriver & driver, TreeScene & scene) { TreeView& graph = scene.view.graph(); graph.openTo(std::nullopt, graph.structure().height()); graph.select(scene.widgets); driver.settle(); } void rightClick(UiDriver & driver, Vec2F windowPoint) { driver.moveTo(windowPoint); driver.press(PointerButton::Right); driver.release(PointerButton::Right); driver.settle(); } void rightClickTreeCard(UiDriver & driver, TreeScene & scene, NodeId id) { rightClick(driver, graphCardPoint(scene, id)); } Vec2F treeEmptyPoint(TreeScene & scene) { TreeView& graph = scene.view.graph(); return graph.windowPosition() + Vec2F(8.0f, graph.size().y - 8.0f); } void showKanbanWithBacklog(UiDriver & driver, TreeScene & scene) { scene.view.kanban().setColumnVisible(scene.view.kanbanColumn(TaskStatus::Backlog), true); driver.click(scene.view.views().tabButton(1)); driver.settle(); } Vec2F kanbanColumnEmptyPoint(TreeScene & scene, TaskStatus status) { KanbanColumnView& column = scene.view.kanban().columnView(scene.view.kanbanColumn(status)); const RectF rect = column.windowRect(); return rect.pos + Vec2F(rect.size.x / 2.0f, rect.size.y - 12.0f); } TEST(RightClickOnATreeCardSelectsItAndOffersTaskActions) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); rightClickTreeCard(driver, scene, scene.release); Menu& menu = scene.view.contextMenu().menu(); REQUIRE CHECK(menu.isOpen()); CHECK(scene.view.graph().selection() == std::optional(scene.release)); const std::vector expected = { "Open", "New child task", "Status", "Session", "Copy", "Paste as children", "Delete task..." }; CHECK(menuTexts(menu) == expected); CHECK(!menuItem(menu, "Paste as children")->isEffectivelyEnabled()); } TEST(KanbanCardMenuMatchesTheTreeCardMenu) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); rightClickTreeCard(driver, scene, scene.release); const std::vector treeItems = menuTexts(scene.view.contextMenu().menu()); const std::vector treeStatuses = menuTexts(scene.view.contextMenu().statusMenu()); const std::vector treeSession = menuTexts(scene.view.contextMenu().sessionMenu()); scene.view.contextMenu().menu().closeMenu(); driver.settle(); showKanbanWithBacklog(driver, scene); rightClick(driver, driver.centerOf(*scene.view.kanban().card(scene.release))); REQUIRE CHECK(scene.view.contextMenu().menu().isOpen()); CHECK(scene.view.kanban().selection() == std::optional(scene.release)); CHECK(menuTexts(scene.view.contextMenu().menu()) == treeItems); CHECK(menuTexts(scene.view.contextMenu().statusMenu()) == treeStatuses); CHECK(menuTexts(scene.view.contextMenu().sessionMenu()) == treeSession); } TEST(StatusSubmenuChangesTheTaskStatusAndChecksTheCurrentOne) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); rightClickTreeCard(driver, scene, scene.release); TaskContextMenu& context = scene.view.contextMenu(); const int editsBefore = scene.edits; chooseNested(driver, context.menu(), "Status", context.statusMenu(), std::string(statusLabel(TaskStatus::Review))); CHECK(scene.board.task(scene.release)->status == TaskStatus::Review); CHECK(scene.edits > editsBefore); CHECK(!context.menu().isOpen()); rightClickTreeCard(driver, scene, scene.release); CHECK(context.statusMenu().items()[size_t(TaskStatus::Review)]->entry().isChecked()); CHECK(!context.statusMenu().items()[size_t(TaskStatus::Backlog)]->entry().isChecked()); } TEST(SessionSubmenuControlsTheSessionThroughTheStore) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); TaskContextMenu& context = scene.view.contextMenu(); rightClickTreeCard(driver, scene, scene.release); CHECK(!menuItem(context.sessionMenu(), "Stop session")->isEffectivelyEnabled()); chooseNested(driver, context.menu(), "Session", context.sessionMenu(), "Start session"); REQUIRE CHECK_EQUAL(1u, scene.store.started.size()); CHECK_EQUAL(scene.release, scene.store.started.front()); scene.board.task(scene.release)->session.state = SessionState::Working; rightClickTreeCard(driver, scene, scene.release); CHECK(!menuItem(context.sessionMenu(), "Start session")->isEffectivelyEnabled()); chooseNested(driver, context.menu(), "Session", context.sessionMenu(), "Restart fresh"); REQUIRE CHECK_EQUAL(1u, scene.store.restarts.size()); CHECK(scene.store.restarts.front() == std::make_pair(scene.release, true)); rightClickTreeCard(driver, scene, scene.release); chooseNested(driver, context.menu(), "Session", context.sessionMenu(), "Stop session"); REQUIRE CHECK_EQUAL(1u, scene.store.stopped.size()); CHECK_EQUAL(scene.release, scene.store.stopped.front()); } TEST(EndedSessionOffersResume) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); scene.board.task(scene.release)->session.state = SessionState::Ended; rightClickTreeCard(driver, scene, scene.release); CHECK(menuItem(scene.view.contextMenu().sessionMenu(), "Resume session") != nullptr); } TEST(CopyThenPasteOnEmptySpaceDuplicatesTheSubtreeAtTopLevel) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); scene.board.task(scene.textEdit)->session.state = SessionState::Working; const size_t tasksBefore = scene.board.graph().nodes().size(); rightClickTreeCard(driver, scene, scene.textEdit); chooseItem(driver, scene.view.contextMenu().menu(), "Copy"); rightClick(driver, treeEmptyPoint(scene)); Menu& menu = scene.view.contextMenu().menu(); REQUIRE CHECK(menu.isOpen()); CHECK(menuItem(menu, "Copy") == nullptr); CHECK(menuItem(menu, "Delete task...") == nullptr); chooseItem(driver, menu, "Paste 2 tasks"); REQUIRE CHECK_EQUAL(tasksBefore + 2, scene.board.graph().nodes().size()); const std::optional pasted = scene.view.currentTask(); REQUIRE CHECK(pasted && *pasted != scene.textEdit); const Task& copy = *scene.board.task(*pasted); CHECK_EQUAL("Text edit glitches", copy.title); CHECK(copy.session.state == SessionState::None); CHECK(!scene.board.parentOf(*pasted)); const std::vector children = scene.board.childrenOf(*pasted); REQUIRE CHECK_EQUAL(1u, children.size()); CHECK_EQUAL("Emoji fallback", scene.board.task(children.front())->title); } TEST(PasteOnATaskAddsTheCopiesAsItsChildren) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); rightClickTreeCard(driver, scene, scene.release); chooseItem(driver, scene.view.contextMenu().menu(), "Copy"); rightClickTreeCard(driver, scene, scene.widgets); chooseItem(driver, scene.view.contextMenu().menu(), "Paste 1 task as children"); const std::vector children = scene.board.childrenOf(scene.widgets); REQUIRE CHECK_EQUAL(2u, children.size()); CHECK_EQUAL("Release notes", scene.board.task(children.back())->title); CHECK(scene.board.task(children.back())->workspace.empty()); } TEST(KeyboardCopyPasteWorksOnTheFocusedTree) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); driver.click(graphCardPoint(scene, scene.release)); driver.settle(); const size_t tasksBefore = scene.board.graph().nodes().size(); driver.key(Key::C, { .control = true }); driver.key(Key::V, { .control = true }); driver.settle(); CHECK_EQUAL(tasksBefore + 1, scene.board.graph().nodes().size()); CHECK(scene.board.parentOf(*scene.view.currentTask()) == std::optional(scene.release)); } TEST(KanbanEmptySpaceMenuCreatesAndPastesIntoThatColumn) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showKanbanWithBacklog(driver, scene); rightClick(driver, driver.centerOf(*scene.view.kanban().card(scene.release))); chooseItem(driver, scene.view.contextMenu().menu(), "Copy"); rightClick(driver, kanbanColumnEmptyPoint(scene, TaskStatus::Queued)); Menu& menu = scene.view.contextMenu().menu(); REQUIRE CHECK(menu.isOpen()); const std::string queued(statusLabel(TaskStatus::Queued)); REQUIRE CHECK(menuItem(menu, "New task in " + queued) != nullptr); chooseItem(driver, menu, "Paste 1 task into " + queued); const std::optional pasted = scene.view.currentTask(); REQUIRE CHECK(pasted && *pasted != scene.release); CHECK(scene.board.task(*pasted)->status == TaskStatus::Queued); rightClick(driver, kanbanColumnEmptyPoint(scene, TaskStatus::Queued)); chooseItem(driver, scene.view.contextMenu().menu(), "New task in " + queued); const std::optional created = scene.view.currentTask(); REQUIRE CHECK(created && *created != *pasted); CHECK(scene.board.task(*created)->status == TaskStatus::Queued); CHECK(!scene.board.parentOf(*created)); } TEST(MultiSelectionMenuActsOnEveryTask) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); scene.view.graph().setSelection({ scene.release, scene.emoji }, scene.emoji); driver.settle(); REQUIRE CHECK_EQUAL(2u, scene.view.graph().selectedItems().size()); rightClickTreeCard(driver, scene, scene.emoji); TaskContextMenu& context = scene.view.contextMenu(); REQUIRE CHECK_EQUAL(2u, context.target().tasks.size()); CHECK(menuItem(context.menu(), "Open") == nullptr); CHECK(menuItem(context.menu(), "Session") == nullptr); chooseNested(driver, context.menu(), "Status of 2 tasks", context.statusMenu(), std::string(statusLabel(TaskStatus::Done))); CHECK(scene.board.task(scene.release)->status == TaskStatus::Done); CHECK(scene.board.task(scene.emoji)->status == TaskStatus::Done); CHECK(scene.board.task(scene.widgets)->status != TaskStatus::Done); rightClickTreeCard(driver, scene, scene.emoji); chooseItem(driver, context.menu(), "Delete 2 tasks..."); REQUIRE CHECK(scene.view.graphDeleteConfirm().isOpen()); } TEST(ReadOnlyBoardDisablesEditingActions) { TreeScene scene; UiDriver driver(scene.window, { 1400, 900 }); showTree(driver, scene); scene.view.setReadOnly(true); rightClickTreeCard(driver, scene, scene.release); Menu& menu = scene.view.contextMenu().menu(); CHECK(menuItem(menu, "Open")->isEffectivelyEnabled()); CHECK(menuItem(menu, "Copy")->isEffectivelyEnabled()); CHECK(!menuItem(menu, "New child task")->isEffectivelyEnabled()); CHECK(!menuItem(menu, "Status")->isEffectivelyEnabled()); CHECK(!menuItem(menu, "Delete task...")->isEffectivelyEnabled()); CHECK(!menuItem(scene.view.contextMenu().sessionMenu(), "Start session")->isEffectivelyEnabled()); } }