chadtmiller.com/hud
A remote MCP server that shows atproto records as interactive UI inside MCP Apps hosts
place.hud.hudkit 0.4.0 Latest 5 packages
0
0
import Foundation
import Testing
@testable import HUDKit
// A screen's last tree: drawn at once the next time it opens, for the
// account that drew it alone, while it is young enough, the least recently
// used let go past a count or a size; and a list paged through kept as long
// when its first page is read afresh.
@MainActor @Suite(.serialized) struct LastTrees {
static let gallery = Call("query", ["method": "social.grain.gallery.getGallery", "params": ["uri": "at://did:plc:a/social.grain.gallery/1"]])
static let ui: JSON = ["v": 1, "root": ["c": "Text", "p": ["runs": [["text": "Mountains at dawn"]]]]]
static let alice = Viewer(did: "did:plc:alice", handle: "alice.test")
/// A clock tests move by hand.
final class Clock {
var now = Date(timeIntervalSince1970: 1_000_000)
}
@Test func aKeyIsTheAccountAndTheWholeCall() {
let other = Call("query", ["method": "social.grain.gallery.getGallery", "params": ["uri": "at://did:plc:a/social.grain.gallery/2"]])
#expect(LastTree.key(Self.gallery, as: nil) != LastTree.key(other, as: nil))
#expect(LastTree.key(Self.gallery, as: nil) != LastTree.key(Self.gallery, as: "did:plc:alice"))
// The same call in another order of its keys is the same screen.
let reordered = Call("query", ["params": ["uri": "at://did:plc:a/social.grain.gallery/1"], "method": "social.grain.gallery.getGallery"])
#expect(LastTree.key(reordered, as: "did:plc:alice") == LastTree.key(Self.gallery, as: "did:plc:alice"))
#expect(LastTree.key(Call("describe_app", ["domain": "grain.social"]), as: "did:plc:alice") == #"did:plc:alice {"args":{"domain":"grain.social"},"name":"describe_app"}"#)
// A number JSON has no word for still names its call apart.
#expect(LastTree.key(Call("t", ["n": .number(.nan)]), as: nil) == #"- {"args":{"n":"NaN"},"name":"t"}"#)
#expect(LastTree.key(Call("t", ["n": .number(.infinity)]), as: nil) != LastTree.key(Call("t", ["n": .number(-.infinity)]), as: nil))
}
@Test func aTreeIsRecalledForItsAccountAlone() {
LastTree.kept = LastTree.Kept()
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") == nil)
LastTree.remember(Self.gallery, as: "did:plc:alice", ui: Self.ui, viewer: Self.alice, asked: .now)
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") == LastTree.Remembered(ui: Self.ui, viewer: Self.alice))
#expect(LastTree.recall(Self.gallery, as: "did:plc:bob") == nil)
#expect(LastTree.recall(Self.gallery, as: nil) == nil)
// Remembered again, the latest answer is the one drawn.
let fresh: JSON = ["v": 1, "root": ["c": "Text", "p": ["n": 3]]]
LastTree.remember(Self.gallery, as: "did:plc:alice", ui: fresh, viewer: Self.alice, asked: .now)
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice")?.ui == fresh)
#expect(LastTree.kept.keys.count == 1)
}
@Test func aTreePastItsAgeIsNotDrawnAndGoes() {
let clock = Clock()
LastTree.kept = LastTree.Kept(now: { clock.now })
LastTree.remember(Self.gallery, as: nil, ui: Self.ui, viewer: nil, asked: clock.now)
clock.now += LastTree.age - 1
#expect(LastTree.recall(Self.gallery, as: nil)?.ui == Self.ui)
clock.now += 1
#expect(LastTree.recall(Self.gallery, as: nil) == nil)
#expect(LastTree.kept.keys.isEmpty)
#expect(LastTree.kept.size == 0)
}
@Test func theLeastRecentlyUsedGoPastTheMost() {
LastTree.kept = LastTree.Kept(most: 3)
let calls = (0..<4).map { Call("tool\($0)", [:]) }
for call in calls.prefix(3) { LastTree.remember(call, as: nil, ui: Self.ui, viewer: nil, asked: .now) }
// The first recalled is used latest, so the second goes first.
#expect(LastTree.recall(calls[0], as: nil) != nil)
LastTree.remember(calls[3], as: nil, ui: Self.ui, viewer: nil, asked: .now)
#expect(LastTree.recall(calls[1], as: nil) == nil)
#expect(LastTree.recall(calls[0], as: nil) != nil)
#expect(LastTree.recall(calls[2], as: nil) != nil)
#expect(LastTree.recall(calls[3], as: nil) != nil)
}
@Test func theLeastRecentlyUsedGoPastTheBytes() {
let size = LastTree.bytes(Self.ui).count
LastTree.kept = LastTree.Kept(bytes: size * 2)
let calls = (0..<3).map { Call("tool\($0)", [:]) }
for call in calls { LastTree.remember(call, as: nil, ui: Self.ui, viewer: nil, asked: .now) }
#expect(LastTree.kept.size == size * 2)
#expect(LastTree.recall(calls[0], as: nil) == nil)
#expect(LastTree.recall(calls[1], as: nil) != nil)
// One larger than all may be is not kept, and lets none go.
let large: JSON = ["v": 1, "root": ["c": "Text", "p": ["runs": [["text": .string(String(repeating: "a", count: size * 2))]]]]]
LastTree.remember(Call("large", [:]), as: nil, ui: large, viewer: nil, asked: .now)
#expect(LastTree.recall(Call("large", [:]), as: nil) == nil)
#expect(LastTree.kept.keys.count == 2)
}
@Test func aWriteForgetsItsAccountsTreesAndSigningInOrOutAll() {
let clock = Clock()
LastTree.kept = LastTree.Kept(now: { clock.now })
LastTree.remember(Self.gallery, as: "did:plc:alice", ui: Self.ui, viewer: Self.alice, asked: clock.now)
LastTree.remember(Self.gallery, as: nil, ui: Self.ui, viewer: nil, asked: clock.now)
LastTree.remember(Call("feed", [:]), as: "did:plc:alice", ui: Self.ui, viewer: Self.alice, asked: clock.now)
// A call made now answers after the write.
let before = clock.now
clock.now += 1
LastTree.forget("did:plc:alice")
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") == nil)
#expect(LastTree.recall(Call("feed", [:]), as: "did:plc:alice") == nil)
#expect(LastTree.recall(Self.gallery, as: nil) != nil)
// Its answer may not show what was written: it is not kept.
LastTree.remember(Self.gallery, as: "did:plc:alice", ui: Self.ui, viewer: Self.alice, asked: before)
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") == nil)
clock.now += 1
LastTree.remember(Self.gallery, as: "did:plc:alice", ui: Self.ui, viewer: Self.alice, asked: clock.now)
LastTree.forget(nil)
#expect(LastTree.recall(Self.gallery, as: nil) == nil)
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") != nil)
LastTree.clear()
#expect(LastTree.recall(Self.gallery, as: "did:plc:alice") == nil)
#expect(LastTree.kept.size == 0)
// Nor one asked before a sign-in or out.
LastTree.remember(Self.gallery, as: nil, ui: Self.ui, viewer: nil, asked: clock.now)
#expect(LastTree.recall(Self.gallery, as: nil) == nil)
#expect(LastTree.writes.contains(ActionCall.delete(uri: "at://a/b/c").tool.name))
#expect(LastTree.writes.contains("apply_writes"))
#expect(!LastTree.writes.contains("link_card"))
}
/// A tree whose page list holds items opening `ids`, its next page `next`.
static func page(_ ids: [Int], next: String?) -> Drawn {
var ui: [String: JSON] = [
"v": 1,
"root": [
"c": "Stack",
"k": [
["c": "Bar", "p": ["title": "Recent"]],
[
"c": "List",
"p": ["style": "rows", "page": true],
"items": .array(ids.map { ["open": ["call": ["name": "query", "args": ["uri": .string("at://\($0)")]]], "k": []] }),
],
],
],
]
if let next { ui["next"] = ["name": "query", "args": ["cursor": .string(next)]] }
return .tree(.object(ui))
}
static func opened(_ drawn: Drawn) -> [String] {
guard case .tree(let ui) = drawn else { return [] }
return (ui["root"]?["k"]?.array?[1]["items"]?.array ?? []).compactMap { $0["open"]?["call"]?["args"]?["uri"]?.string }
}
@Test func aPageCountIsItsPageListsItems() {
#expect(Self.page([1, 2, 3], next: nil).pageCount == 3)
#expect(Drawn.tree(Self.ui).pageCount == nil)
#expect(Drawn.error("no").pageCount == nil)
}
@Test func aListPagedThroughKeepsItsLaterPagesAfterItsFreshFirst() {
// Two pages drawn, 1-3 and 4-6; the first read afresh has 0 newer, and 3 fell to the second.
let drawn = Self.page([1, 2, 3, 4, 5, 6], next: "after-6")
let fresh = Self.page([0, 1, 2], next: "after-2")
let refreshed = drawn.refreshed(by: fresh, past: 3)
#expect(Self.opened(refreshed) == ["at://0", "at://1", "at://2", "at://4", "at://5", "at://6"])
#expect(refreshed.nextPage == Call("query", ["cursor": "after-6"]))
#expect(refreshed.title == "Recent")
// The end reached, it stays reached.
#expect(Self.page([1, 2, 3, 4], next: nil).refreshed(by: fresh, past: 3).nextPage == nil)
// An item the fresh page holds again is drawn once, where the fresh page has it.
#expect(Self.opened(Self.page([1, 2, 3, 0], next: nil).refreshed(by: fresh, past: 3)) == ["at://0", "at://1", "at://2"])
}
@Test func aListNotPagedOrNoListIsTheFreshTree() {
let fresh = Self.page([0, 1, 2], next: "after-2")
#expect(Self.opened(Self.page([1, 2, 3], next: "after-3").refreshed(by: fresh, past: 3)) == ["at://0", "at://1", "at://2"])
#expect(Drawn.tree(Self.ui).refreshed(by: fresh, past: 0).nextPage == Call("query", ["cursor": "after-2"]))
let none = Drawn.tree(Self.ui)
#expect(Self.page([1, 2, 3, 4], next: nil).refreshed(by: none, past: 3).pageCount == nil)
if case .error(let message) = Self.page([1, 2, 3, 4], next: nil).refreshed(by: .error("gone"), past: 3) {
#expect(message == "gone")
} else {
Issue.record("an error stays an error")
}
// Items with no call to open are known by all they hold.
let plain: Drawn = .tree(["v": 1, "root": ["c": "List", "p": ["page": true], "items": [["k": [["c": "Text", "p": ["n": 1]]]], ["k": [["c": "Text", "p": ["n": 2]]]]]]])
let first: Drawn = .tree(["v": 1, "root": ["c": "List", "p": ["page": true], "items": [["k": [["c": "Text", "p": ["n": 2]]]]]]])
#expect(plain.refreshed(by: first, past: 1).pageCount == 1)
}
}
extension Drawn {
/// The title of its tree's top `Bar`, for the tests.
fileprivate var title: String? {
guard case .tree(let ui) = self else { return nil }
return ui["root"]?["k"]?.array?.first?["p"]?["title"]?.string
}
}