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 } }