~ knotless Search/
↑↓ move↵ open⇧↵ all results

chadtmiller.com/hud

A remote MCP server that shows atproto records as interactive UI inside MCP Apps hosts

0
0
189 lines · 9.5 KB Raw History
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
	}
}