import Foundation import SwiftUI import Testing @testable import HUDKit // The workspace as the web page reads it: a tile out of its view, the // strip's columns in order with their stacks, the same call however it is // written, and the live stream's events out of its lines. private func tile(_ key: String, order: String, stack: String? = nil, width: String? = nil, from: String? = nil) -> Tile { var record: [String: JSON] = ["tool": "query", "arguments": ["method": "app.bsky.feed.getTimeline"], "title": "", "order": .string(order), "by": "person"] if let stack { record["stack"] = .string(stack) } if let width { record["width"] = .string(width) } if let from { record["from"] = .string(from) } return Tile(["key": .string(key), "author": "did:plc:a", "record": .object(record)])! } @Suite struct WorkspaceShapes { @Test func aTileIsReadFromItsViewItsArgumentsFromJSONTextWhereNeeded() throws { let view: JSON = [ "key": "aaaaaaaaaaaa", "author": "did:plc:a", "icon": "https://hud.example/icon/bsky.app", "record": [ "tool": "query", "argumentsJson": "{\"method\":\"app.bsky.feed.getPostThread\",\"params\":{\"uri\":\"at://did:plc:b/app.bsky.feed.post/1\",\"depth\":1.5}}", "title": "", "order": "2.5", "width": "two-thirds", "by": "agent", "from": "bbbbbbbbbbbb", "createdAt": "2026-11-16T00:00:00.000Z", ], ] let read = try #require(Tile(view)) #expect(read.arguments["params"]?["depth"] == .number(1.5)) #expect(read.width == .twoThirds) #expect(read.byAgent) #expect(read.from == "bbbbbbbbbbbb") #expect(read.icon == URL(string: "https://hud.example/icon/bsky.app")) #expect(read.heading == "Thread") #expect(read.account == "did:plc:b") #expect(Tile(["record": [:]]) == nil) } @Test func theStripIsInOrderEachStackUnderItsHead() { let tiles = [ tile("c", order: "10"), tile("a", order: "1", width: "half"), tile("b2", order: "3", stack: "a"), tile("b1", order: "2", stack: "a"), tile("lost", order: "5", stack: "gone"), ] let columns = stripColumns(tiles) #expect(columns.map(\.id) == ["a", "lost", "c"]) #expect(columns[0].tiles.map(\.id) == ["a", "b1", "b2"]) #expect(columns[0].width == .half) #expect(columns[2].width == .third) } /// As the web's strip map: a tile joins the chain of the one it was /// opened from in its stack, on its left, or past columns of that one's /// descendants alone; not past another; a chain keeps its colour. @Test func chainsAreColouredAsTheWebColoursThem() { let tiles = [ tile("a", order: "1"), tile("b", order: "2", from: "a"), tile("b2", order: "2.5", stack: "b", from: "a"), tile("c", order: "3", from: "a"), tile("x", order: "4"), tile("y", order: "5", from: "x"), tile("z", order: "6", from: "a"), tile("lone", order: "7"), ] var kept: [String: Int] = [:] let colours = chainColours(stripColumns(tiles), kept: &kept) // a, b, b2, c: the longest chain, the first colour; z is past x, not a's. #expect(["a", "b", "b2", "c"].map { colours[$0] } == [1, 1, 1, 1]) #expect(colours["x"] == 2 && colours["y"] == 2) #expect(colours["z"] == nil && colours["lone"] == nil) // The x chain grown longer than a's keeps its colour. let grown = tiles + [tile("y2", order: "5.5", from: "y"), tile("y3", order: "5.7", from: "y2"), tile("y4", order: "5.8", from: "y3")] let again = chainColours(stripColumns(grown), kept: &kept) #expect(again["x"] == 2 && again["a"] == 1) } @Test func theSameCallIsTheSameWrittenAnyWay() { let one = Call("query", ["method": "app.bsky.feed.getFeed", "params": ["feed": "at://x", "cursor": ""]]) let two = Call("query", ["params": ["feed": "at://x"], "method": "app.bsky.feed.getFeed", "view": [:]]) #expect(Tile.callKey(one) == Tile.callKey(two)) #expect(Tile.callKey(one) != Tile.callKey(Call("query", ["method": "app.bsky.feed.getFeed"]))) } @Test func aTitleHUDMadeGivesWayToOneOfTheCall() { #expect(!Tile.given("app.bsky.feed.post ยท alice.test")) #expect(!Tile.given("query app.bsky.feed.getTimeline")) #expect(!Tile.given("Thread")) #expect(Tile.given("Coast trip")) #expect(Tile.words("getPostThread") == "Post thread") #expect(Tile.plural("Gallery") == "Galleries") } } @Suite struct WorkspaceStream { @Test func eachEventIsItsDataLinesJoinedAtTheBlankLine() { var parser = ServerEvents() var got: [String] = [] for line in [": ping", "", "data: {\"a\":1}", "", "event: x", "data:{\"b\":", "data: 2}", "", ""] { if let data = parser.read(line) { got.append(data) } } #expect(got == ["{\"a\":1}", "{\"b\":\n2}"]) } } @Suite struct WorkspaceAccountData { /// getAccountData's answer, as schemas/place.hud.getAccountData.json shapes it. @Test func whatHUDKeepsIsReadFromGetAccountData() throws { let answer = """ {"did":"did:plc:alice","canvases":[{"canvas":"3kabcdefghij","name":"Reading","members":2},{"canvas":"3kbcdefghijk","name":"Alone","members":0}],"shared":1,"invitations":3,"themes":2,"chosenTheme":true} """ let held = try #require(AccountData(JSONDecoder().decode(JSON.self, from: Data(answer.utf8)))) #expect(held.did == "did:plc:alice") #expect(held.canvases == [ AccountData.Canvas(id: "3kabcdefghij", name: "Reading", members: 2), AccountData.Canvas(id: "3kbcdefghijk", name: "Alone", members: 0), ]) #expect(held.shared == 1 && held.invitations == 3 && held.themes == 2 && held.chosenTheme) #expect(!held.isEmpty) let none = try #require(AccountData(["did": "did:plc:bob", "canvases": [], "shared": 0, "invitations": 0, "themes": 0, "chosenTheme": false])) #expect(none.isEmpty) #expect(AccountData(["canvases": []]) == nil) } /// deleteAccountData is POSTed with the person's DID named again. @Test func deletingPostsTheDID() throws { let request = try WorkspaceClient.deleteAccountDataRequest(at: URL(string: "https://hud.place")!, did: "did:plc:alice") #expect(request.httpMethod == "POST") #expect(request.url?.absoluteString == "https://hud.place/xrpc/place.hud.deleteAccountData") #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/json") let body = try JSONDecoder().decode(JSON.self, from: try #require(request.httpBody)) #expect(body == ["did": "did:plc:alice"]) } } /// themes/amber.json's palette, as getWorkspace lists it. private let amber: [String: JSON] = [ "canvas": "#050301", "background": "#1b150c", "panel": "#211a10", "soft": "#282013", "border": "#342819", "borderStrong": "#4c3b25", "text": "#ffdaa3", "textMuted": "#d8aa68", "textFaint": "#ba8c51", "primary": "#ffb238", "onPrimary": "#1a1006", "accent": "#ffbf5a", "accentSoft": "#3a2a11", "success": "#acd876", "danger": "#ff6d50", "done": "#e79ddb", "attention": "#ffd166", "neutral": "#a68f71", "onSolid": "#1b150c", "notice": "#33270d", "onNotice": "#ffd166", ] private let bundled: JSON = [ ["key": "light", "name": "Light", "colorScheme": "light"], ["key": "dark", "name": "Dark", "colorScheme": "dark"], ["key": "amber", "name": "Amber", "colorScheme": "dark", "palette": .object(amber)], ] @Suite struct WorkspaceThemes { @Test func theThemeChosenAndEveryThemeAreReadFromGetWorkspace() throws { let found = Theme.read(["me": ["did": "did:plc:a"], "open": [], "theme": ["key": "amber", "name": "Amber", "colorScheme": "dark", "palette": .object(amber)], "themes": bundled]) #expect(found.chosen?.id == "amber" && found.chosen?.key == "amber" && found.chosen?.uri == nil) #expect(found.chosen?.palette?.colors[.canvas] == RGB(hex: "#050301")) #expect(found.themes.map(\.id) == ["light", "dark", "amber"]) #expect(found.themes[0].palette == nil && found.themes[0].colorScheme == .light) #expect(found.themes[1].palette == nil && found.themes[1].colorScheme == .dark) let palette = try #require(found.themes[2].palette) #expect(found.themes[2].name == "Amber" && found.themes[2].colorScheme == .dark) #expect(palette.colors.count == Palette.Role.allCases.count) #expect(palette.colors[.canvas] == RGB(hex: "#050301")) #expect(palette.colors[.onNotice] == RGB(hex: "#FFD166")) #expect(palette.colors[.accent].map { [$0.red, $0.green, $0.blue] } == [0xff, 0xbf, 0x5a]) } /// No theme chosen follows the system; a server older than themes lists none. @Test func withoutAThemeTheSystemsIsDrawn() { let none = Theme.read(["me": ["did": "did:plc:a"], "open": [], "themes": bundled]) #expect(none.chosen == nil) #expect(none.themes.count == 3) let older = Theme.read(["me": ["did": "did:plc:a"], "open": []]) #expect(older.chosen == nil && older.themes.isEmpty) } /// A colour that is not #rrggbb is left to the system's; the theme stands. @Test func aMalformedColourIsIgnoredNotTheTheme() throws { var palette = amber palette["text"] = "red" palette["accent"] = "#12345" palette["border"] = "#zzzzzz" palette["danger"] = "#+12345" palette["done"] = 7 let found = Theme.read(["theme": ["key": "odd", "name": "Odd", "colorScheme": "light"], "themes": [ ["key": "odd", "name": "Odd", "colorScheme": "light", "palette": .object(palette)], ["name": "No key", "colorScheme": "dark"], ]]) #expect(found.chosen?.id == "odd") let theme = try #require(found.themes.first) #expect(found.themes.count == 1) let read = try #require(theme.palette) for role in [Palette.Role.text, .accent, .border, .danger, .done] { #expect(read.colors[role] == nil) } #expect(read.colors.count == Palette.Role.allCases.count - 5) #expect(read.colors[.background] == RGB(hex: "#1b150c")) } /// A person's theme chosen is drawn as getWorkspace gives it, by its uri, /// with who made it, though HUD's themes do not list it. @Test func aPersonsThemeChosenIsDrawnAsGiven() throws { let uri = "at://did:plc:b/place.hud.theme/3kabc" let found = Theme.read(["me": ["did": "did:plc:a"], "open": [], "themes": bundled, "theme": [ "uri": .string(uri), "creator": ["did": "did:plc:b", "handle": "bea.test"], "name": "Ember", "colorScheme": "dark", "palette": .object(amber), ]]) let chosen = try #require(found.chosen) #expect(chosen.id == uri && chosen.uri == uri && chosen.key == nil) #expect(chosen.creator == Viewer(did: "did:plc:b", handle: "bea.test")) #expect(chosen.name == "Ember" && chosen.colorScheme == .dark) #expect(chosen.palette?.colors[.accent] == RGB(hex: "#ffbf5a")) #expect(!found.themes.contains { $0.id == uri }) } /// listThemes' page: each theme by its uri and creator, and the cursor on. @Test func aPageOfPeoplesThemesAndItsCursor() { let page = Theme.page(["cursor": "did:plc:c/3kxyz", "themes": [ ["uri": "at://did:plc:b/place.hud.theme/1", "creator": ["did": "did:plc:b"], "name": "One", "colorScheme": "light", "palette": .object(amber)], ["uri": "at://did:plc:c/place.hud.theme/2", "creator": ["did": "did:plc:c", "handle": "cy.test"], "name": "Two", "colorScheme": "dark", "palette": .object(amber)], ]]) #expect(page.cursor == "did:plc:c/3kxyz") #expect(page.themes.map(\.id) == ["at://did:plc:b/place.hud.theme/1", "at://did:plc:c/place.hud.theme/2"]) #expect(page.themes[0].creator?.handle == nil && page.themes[1].creator?.handle == "cy.test") let last = Theme.page(["themes": []]) #expect(last.cursor == nil && last.themes.isEmpty) } /// A theme with neither key nor uri is dropped, wherever it is given. @Test func aThemeWithNeitherKeyNorURIIsDropped() { let nameless: JSON = ["name": "Nowhere", "colorScheme": "dark", "creator": ["did": "did:plc:b"]] #expect(Theme(nameless) == nil) #expect(Theme.read(["theme": nameless, "themes": [nameless]]).chosen == nil) #expect(Theme.page(["themes": [nameless, ["uri": "at://did:plc:b/place.hud.theme/1", "name": "One", "colorScheme": "light"]]]).themes.count == 1) } }