@marcomigozzi/trailhead 0.14.0 → 0.15.0

package/plugins/trailhead/tests/map-pane-ui.test.ts

@@ -61,9 +61,28 @@ const MAPS = [
   { number: 198, title: 'trailhead mod', url: `${URL}/198` },
   { number: 14, title: 'older map', url: `${URL}/14` },
 ]
+// The maps read: one GraphQL call that carries each map's sub-issue counts and the whiteboard's.
+const MAPS_QUERY =
+  'query($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){issues(first:100,states:OPEN,labels:["trailhead:map"]){nodes{number title url subIssuesSummary{total completed}}}whiteboardOpen:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}whiteboardAll:issues(labels:["trailhead:whiteboard"]){totalCount}}}'
+const MAPS_CALL = ['gh', 'api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${MAPS_QUERY}`]
+const MAPS_LIST_CALL = ['gh', 'issue', 'list', '--label', 'trailhead:map', '--state', 'open', '--limit', '100', '--json', 'number,title,url']
+// The pending-UAT read of one scope (a map label, or the whiteboard): the tickets with their bodies.
+const uatCall = (scope: string) => ['gh', 'issue', 'list', '--label', 'trailhead:uat', '--label', scope, '--state', 'open', '--limit', '200', '--json', 'number,body']
+const isGraphql = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql'
+const isMapsList = (argv: readonly string[]) => argv[2] === 'list' && argv.includes('trailhead:map')
 const OTHER_TICKETS = [issue(140, 'Old frontier ticket', ['trailhead:build']), issue(141, 'Old held ticket', ['trailhead:task'], ['carol'])]
 const OTHER_HISTORY = OTHER_TICKETS.map(t => hrow(t.number, t.labels.map(l => l.name), null))
 
+// The whiteboard (map-less tickets) and the pinned dashboard issue, as the dashboard view reads them.
+const WB = ['trailhead:ticket', 'trailhead:whiteboard']
+const WHITEBOARD = [
+  issue(301, 'Fix the README badge', [...WB, 'trailhead:bug']),
+  issue(302, 'Bump the CI node', [...WB, 'trailhead:task'], ['alice']),
+  issue(303, 'Waits on upstream', [...WB, 'trailhead:task', 'trailhead:blocked']),
+  issue(304, 'Quarantined loose one', [...WB, 'trailhead:task', 'trailhead:unverified']),
+]
+const DASHBOARD = [{ number: 5, url: `${URL}/5` }]
+
 const stateText = (over: Record<string, unknown> = {}): string =>
   JSON.stringify({
     map: 198,
@@ -78,7 +97,7 @@ const stateText = (over: Record<string, unknown> = {}): string =>
   })
 
 // The plugin's atoms, which the engine resets on /clear.
-const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'pendingWork', 'paneAutoOpened']
+const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'paneAutoOpened', 'ownTicket']
 
 const PANE_PROPS = {
   title: 'Map',
@@ -104,9 +123,17 @@ const rig = (on: On, engine?: any) => {
     map: MAP as unknown,
     // The open maps list, and the second map's own answers (view, open list, history).
     maps: MAPS as unknown[],
+    // Sub-issue totals per map number, as the GraphQL read reports them (a map without one has no summary).
+    mapSummary: { 198: { total: 23, completed: 16 }, 14: { total: 5, completed: 2 } } as Record<number, unknown>,
+    // The whiteboard's open and total tickets as the same call reports them (null: the fields are absent).
+    whiteboardCounts: { open: 3, total: 9 } as { open: number; total: number } | null,
     otherMap: OTHER_MAP as unknown,
     otherTickets: OTHER_TICKETS as unknown[],
     otherHistory: OTHER_HISTORY as unknown[],
+    whiteboard: WHITEBOARD as unknown[],
+    // The UAT read's answer: one row per UAT ticket, `{ number, body }`; null makes the read fail.
+    uat: [] as unknown[] | null,
+    dashboard: DASHBOARD as unknown[],
     gh: null as Gh | null,
     // What `gh` answers when no test replaced it; a test can wrap it.
     defaultGh: null as unknown as Gh,
@@ -137,7 +164,16 @@ const rig = (on: On, engine?: any) => {
     },
   }
   const defaultGh: Gh = argv => {
-    if (argv[2] === 'list' && argv.includes('trailhead:map')) return ok(JSON.stringify(r.maps))
+    if (argv.includes('trailhead:uat')) return r.uat === null ? { exitCode: 1, stdout: '', stderr: 'boom' } : ok(JSON.stringify(r.uat))
+    if (argv.includes('trailhead:whiteboard')) return ok(JSON.stringify(r.whiteboard))
+    if (argv.includes('trailhead:dashboard')) return ok(JSON.stringify(r.dashboard))
+    if (isGraphql(argv)) {
+      const nodes = (r.maps as { number: number }[]).map(m => ({ ...m, subIssuesSummary: r.mapSummary[m.number] }))
+      const wb = r.whiteboardCounts
+      const counts = wb === null ? {} : { whiteboardOpen: { totalCount: wb.open }, whiteboardAll: { totalCount: wb.total } }
+      return ok(JSON.stringify({ data: { repository: { issues: { nodes }, ...counts } } }))
+    }
+    if (isMapsList(argv)) return ok(JSON.stringify(r.maps))
     const isOther = argv.includes('14') || argv.includes('trailhead:map-14')
     if (argv[2] === 'view') return ok(JSON.stringify(isOther ? r.otherMap : r.map))
     return ok(JSON.stringify(argv.includes('all') ? (isOther ? r.otherHistory : r.history) : isOther ? r.otherTickets : r.tickets))
@@ -243,11 +279,11 @@ const settle = async (r: Rig) => {
   for (let i = 0; i < 10; i += 1) await r.clock.settle()
 }
 // The open-list reads; the history read rides along with each and is not counted.
-const fetches = (r: Rig) => r.calls.filter(argv => argv[2] === 'list' && argv.includes('open') && !argv.includes('trailhead:map')).length
+const fetches = (r: Rig) => r.calls.filter(argv => argv[2] === 'list' && argv.includes('open') && !argv.includes('trailhead:map') && !argv.includes('trailhead:uat')).length
 // A gh that answers as the default does, except for the history read.
 const withHistory = (r: Rig, answer: GhOut): Gh => argv => {
   if (argv.includes('all')) return answer
-  if (argv.includes('trailhead:map')) return ok(JSON.stringify(r.maps))
+  if (isGraphql(argv) || isMapsList(argv)) return r.defaultGh(argv)
   return argv[2] === 'view' ? ok(JSON.stringify(r.map)) : ok(JSON.stringify(r.tickets))
 }
 const hasKey = async (ui: any, key: string): Promise<boolean> => (await ui.find({ key })) !== undefined
@@ -275,7 +311,8 @@ for (const surface of SURFACES) {
       ['gh', 'issue', 'view', '198', '--json', 'title,body,url'],
       ['gh', 'issue', 'list', '--label', 'trailhead:map-198', '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url'],
       ['gh', 'issue', 'list', '--label', 'trailhead:map-198', '--state', 'all', '--limit', '5000', '--json', 'number,labels,createdAt,closedAt'],
-      ['gh', 'issue', 'list', '--label', 'trailhead:map', '--state', 'open', '--limit', '100', '--json', 'number,title,url'],
+      MAPS_CALL,
+      uatCall('trailhead:map-198'),
     ])
     expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
     expect((await ui.find({ type: 'Link' }))?.props).toMatchObject({ href: `${URL}/198` })
@@ -297,8 +334,10 @@ for (const surface of SURFACES) {
     expect(links).toContain(`${URL}/209`)
 
     // holders on every assigned row; the session's own ticket is marked and in the accent
-    expect(await textOf(ui, 'holder-208')).toBe('@ToRvaLDz')
-    expect((await ui.find({ key: 'holder-208' }))?.children[0]).toMatchObject({ props: { color: ACCENT } })
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+    expect((await ui.find({ key: 'self-208' }))?.children[0]).toMatchObject({ props: { color: ACCENT } })
+    expect((await ui.find({ key: 'self-208' }))?.children[0].props).not.toHaveProperty('bold')
+    expect(await ui.find({ key: 'holder-208' })).toBeUndefined()
     expect(await textOf(ui, 'mark-208')).toBe('▸ ')
     expect((await ui.find({ key: 'mark-208' }))?.children[0]).toMatchObject({ props: { bold: true, color: ACCENT } })
     expect((await ui.find({ key: 'ticket-208' }))?.children[0]).toMatchObject({ props: { bold: true, color: ACCENT } })
@@ -319,6 +358,117 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'age')).toBe('updated just now')
   })
 
+  test(`a UAT ticket sits under UAT between In progress and Paused, with its parent line and its work button [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    r.tickets = [
+      ...TICKETS,
+      issue(240, 'UAT of the burn-down', ['trailhead:task', 'trailhead:uat']),
+      issue(241, 'Device UAT seed', ['trailhead:seed', 'trailhead:blocked', 'trailhead:uat']),
+      issue(242, 'Held UAT', ['trailhead:task', 'trailhead:uat'], ['alice']),
+      issue(243, 'Paused UAT', ['trailhead:task', 'trailhead:uat', 'trailhead:paused']),
+    ]
+    r.uat = [
+      { number: 240, body: `Run it\n\nUAT of: [Burn-down view of the map](${URL}/209)\n` },
+      { number: 241, body: `UAT of: #212` },
+      { number: 243, body: `UAT of: [Paused parent](${URL}/150)` },
+    ]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+
+    expect(await textOf(ui, 'head-uat')).toBe('UAT · 3')
+    expect((await ui.find({ key: 'head-uat' }))?.children[0]).toMatchObject({ props: { bold: true } })
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-uat', 'group-paused', 'group-blocked'])
+    // each ticket once: a UAT row is in no other group, a paused UAT stays under Paused
+    expect(await keysOf(ui, 'row-')).toEqual([
+      'row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-240', 'row-241', 'row-242', 'row-243', 'row-211', 'row-213',
+    ])
+    expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
+    expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
+    // the parent line, dim, under the row; none without a parent
+    expect(await textOf(ui, 'uat-of-240')).toBe('tests Burn-down view of the map #209')
+    expect((await ui.find({ key: 'uat-of-240' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    expect(await textOf(ui, 'uat-of-241')).toBe('tests #212')
+    expect(await hasKey(ui, 'uat-of-242')).toBe(false)
+    expect(await textOf(ui, 'uat-of-243')).toBe('tests Paused parent #150')
+    // a marker, not a state: a frontier UAT task keeps its work button, a held one its holder, a seed stays dim
+    expect(await hasKey(ui, 'work-240')).toBe(true)
+    expect(await textOf(ui, 'holder-242')).toBe('@alice')
+    expect(await hasKey(ui, 'work-242')).toBe(false)
+    expect(await hasKey(ui, 'work-241')).toBe(false)
+    expect((await ui.find({ key: 'ticket-241' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+  })
+
+  test(`no UAT ticket draws no UAT group [${surface}]`, async ($, on) => {
+    const none = rig(on, $)
+    await $.session.start(START)
+    const ui0 = await openAndMount($, none)
+    expect(await hasKey(ui0, 'group-uat')).toBe(false)
+  })
+
+  test(`a failed UAT read draws the UAT rows without the parent line, no error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [...TICKETS, issue(240, 'UAT of the burn-down', ['trailhead:task', 'trailhead:uat'])]
+    r.uat = null
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
+    expect(await hasKey(ui, 'uat-of-240')).toBe(false)
+    expect(await hasKey(ui, 'error')).toBe(false)
+  })
+
+  test(`the dashboard view groups UAT whiteboard tickets with their parent, reading the whiteboard scope [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = [...WHITEBOARD, issue(306, 'Loose UAT', [...WB, 'trailhead:task', 'trailhead:uat'])]
+    r.uat = [{ number: 306, body: `UAT of: [Loose parent](${URL}/290)` }]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(r.calls.some(argv => JSON.stringify(argv) === JSON.stringify(uatCall('trailhead:whiteboard')))).toBe(true)
+    expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
+    expect(await textOf(ui, 'uat-of-306')).toBe('tests Loose parent #290')
+  })
+
+  test(`a paused ticket sits under Paused between In progress and Blocked, with no work button [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    r.tickets = [
+      ...TICKETS,
+      issue(230, 'Paused with a holder', ['trailhead:build', 'trailhead:paused'], ['ToRvaLDz']),
+      issue(231, 'Paused and released', ['trailhead:build', 'trailhead:paused']),
+      issue(232, 'Paused and blocked', ['trailhead:build', 'trailhead:paused', 'trailhead:blocked'], ['bob']),
+    ]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+
+    expect(await textOf(ui, 'head-paused')).toBe('Paused · 3')
+    expect((await ui.find({ key: 'head-paused' }))?.children[0]).toMatchObject({ props: { bold: true } })
+    expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 2')
+    expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 2')
+    // a paused ticket appears in one group only: Frontier, In progress, Paused, Blocked in order
+    expect(await keysOf(ui, 'row-')).toEqual(['row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-230', 'row-231', 'row-232', 'row-211', 'row-213'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-paused', 'group-blocked'])
+    expect(await textOf(ui, 'holder-230')).toBe('@ToRvaLDz')
+    expect((await ui.find({ key: 'holder-230' }))?.children[0].props).not.toHaveProperty('dimColor')
+    expect(await textOf(ui, 'holder-232')).toBe('@bob')
+    expect(await ui.find({ key: 'holder-231' })).toBeUndefined()
+    for (const n of [230, 231, 232]) expect(await hasKey(ui, `work-${n}`)).toBe(false)
+    expect((await ui.find({ key: 'ticket-231' }))?.children[0].props).not.toHaveProperty('dimColor')
+  })
+
+  test(`the dashboard view groups paused whiteboard tickets the same way [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = [...WHITEBOARD, issue(305, 'Paused loose one', [...WB, 'trailhead:task', 'trailhead:paused'], ['alice'])]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-305', 'row-303'])
+    expect(await hasKey(ui, 'work-305')).toBe(false)
+    expect(await textOf(ui, 'holder-305')).toBe('@alice')
+  })
+
   test(`ticket rows are spaced apart on the desktop only [${surface}]`, async ($, on) => {
     const r = rig(on)
     await $.session.start(START)
@@ -489,6 +639,70 @@ for (const surface of SURFACES) {
     expect(await ui.find({ key: 'mark-212' })).toBeUndefined()
   })
 
+  test(`another session's work state does not move this session's mark [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+
+    // a second session on the same map takes over the shared file
+    r.work = stateText({ ticket: 212, title: 'Native gh-backed tools', session: NEXT_SESSION })
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+    expect(await textOf(ui, 'mark-208')).toBe('▸ ')
+    expect(await ui.find({ key: 'self-212' })).toBeUndefined()
+    expect(await textOf(ui, 'holder-212')).toBe('@alice')
+
+    // and then removes it: the last state read was not ours, so the mark stays
+    r.work = null
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+  })
+
+  test(`this session's own Resolve, which removes the file, clears the mark [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+    r.work = null
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await ui.find({ key: 'self-208' })).toBeUndefined()
+    expect(await ui.find({ key: 'mark-208' })).toBeUndefined()
+    expect(await textOf(ui, 'holder-208')).toBe('@ToRvaLDz')
+  })
+
+  test(`each session marks its own ticket on the same map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.session = NEXT_SESSION
+    r.work = stateText({ ticket: 212, title: 'Native gh-backed tools', session: NEXT_SESSION })
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'self-212')).toBe('this session')
+    expect(await textOf(ui, 'mark-212')).toBe('▸ ')
+    expect(await textOf(ui, 'holder-208')).toBe('@ToRvaLDz')
+    expect(await ui.find({ key: 'self-208' })).toBeUndefined()
+  })
+
+  test(`a /clear starts the new session with no ticket of its own [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'self-208')).toBe('this session')
+    await $.command.run({ command: 'clear', args: '' })
+    await settle(r)
+    expect(await ui.find({ key: 'self-208' })).toBeUndefined()
+    expect(await ui.find({ key: 'mark-208' })).toBeUndefined()
+  })
+
   test(`unverified tickets are counted in the plural [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.tickets = [issue(1, 'a', ['trailhead:unverified']), issue(2, 'b', ['trailhead:unverified']), issue(3, 'c', ['trailhead:build'])]
@@ -522,7 +736,7 @@ for (const surface of SURFACES) {
     await completeTurn($)
     await settle(r)
     // the open maps are still read, so one can be picked; no map is
-    expect(r.calls).toEqual([['gh', 'issue', 'list', '--label', 'trailhead:map', '--state', 'open', '--limit', '100', '--json', 'number,title,url']])
+    expect(r.calls).toEqual([MAPS_CALL])
   })
 
   test(`first fetch in flight: the map number and Loading tickets [${surface}]`, async ($, on) => {
@@ -754,7 +968,7 @@ for (const surface of SURFACES) {
     await $.session.start(START)
     const ui = await openAndMount($, r)
     const buttons = (await ui.findAll({ type: 'Button' })).map((b: any) => b.key)
-    expect(buttons).toEqual(['map-14', 'work-209', 'work-210', 'work-214', 'refresh', 'close'])
+    expect(buttons).toEqual(['open-whiteboard', 'map-14', 'work-209', 'work-210', 'work-214', 'refresh', 'close'])
     expect((await ui.find({ key: 'work-209' }))?.props).toMatchObject({ label: 'work', variant: 'primary' })
     expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
 
@@ -876,7 +1090,7 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await hasKey(ui, 'viewing')).toBe(false)
-    expect(await textOf(ui, 'map-aside-14')).toBe(' active')
+    expect(await textOf(ui, 'map-aside-14')).toBe(' 3 open / 5 · active')
   })
 
   test(`a manual /clear keeps the pane filled, with no turn and inside the floor [${surface}]`, async ($, on) => {
@@ -1142,7 +1356,7 @@ for (const surface of SURFACES) {
     expect(await keysOf(ui, 'map-row-')).toEqual(['map-row-14', 'map-row-198'])
     expect(await textOf(ui, 'map-mark-198')).toBe('● ')
     expect((await ui.find({ key: 'map-mark-198' }))?.children[0]).toMatchObject({ props: { color: ACCENT } })
-    expect(await textOf(ui, 'map-aside-198')).toBe(' active')
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
     expect(await textOf(ui, 'map-label-198')).toBe('#198 trailhead mod')
     expect((await ui.find({ key: 'map-label-198' }))?.children[0]).toMatchObject({ props: { bold: true } })
     expect(await textOf(ui, 'map-mark-14')).toBe('  ')
@@ -1162,7 +1376,7 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     expect(await hasKey(ui, 'head-maps')).toBe(false)
     expect(await hasKey(ui, 'group-maps')).toBe(false)
-    expect((await ui.findAll({ type: 'Button' })).map((b: any) => b.key)).toEqual(['work-209', 'work-210', 'work-214', 'refresh', 'close'])
+    expect((await ui.findAll({ type: 'Button' })).map((b: any) => b.key)).toEqual(['open-whiteboard', 'work-209', 'work-210', 'work-214', 'refresh', 'close'])
   })
 
   test(`a press on another map shows its tickets, the active-map marker is never written [${surface}]`, async ($, on) => {
@@ -1179,10 +1393,11 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'burndown-counts')).toBe('open 2 · done 0 · removed 0 · peak 2')
     // the ticket in play belongs to the other map: nothing here is marked
     expect(await hasKey(ui, 'mark-208')).toBe(false)
-    expect(r.calls.slice(-4).map(argv => argv.slice(0, 4))).toEqual([
+    expect(r.calls.slice(-5).map(argv => argv.slice(0, 4))).toEqual([
       ['gh', 'issue', 'view', '14'],
       ['gh', 'issue', 'list', '--label'],
       ['gh', 'issue', 'list', '--label'],
+      ['gh', 'api', 'graphql', '-F'],
       ['gh', 'issue', 'list', '--label'],
     ])
     expect(r.calls.some(argv => argv.includes('trailhead:map-14'))).toBe(true)
@@ -1236,7 +1451,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await hasKey(ui, 'viewing')).toBe(false)
     expect(await textOf(ui, 'map-label-14')).toBe('#14 older map')
-    expect(await textOf(ui, 'map-aside-14')).toBe(' active')
+    expect(await textOf(ui, 'map-aside-14')).toBe(' 3 open / 5 · active')
     expect((await ui.find({ key: 'map-198' }))?.props).toMatchObject({ label: '#198 trailhead mod' })
   })
 
@@ -1258,18 +1473,18 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await hasKey(ui, 'viewing')).toBe(false)
-    expect(await textOf(ui, 'map-aside-14')).toBe(' active')
-    expect(await hasKey(ui, 'map-aside-198')).toBe(false)
+    expect(await textOf(ui, 'map-aside-14')).toBe(' 3 open / 5 · active')
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23')
   })
 
-  test(`a failed maps read keeps the last list and sets no footer error [${surface}]`, async ($, on) => {
+  test(`both maps reads failing keep the last list and set no footer error [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     await $.session.start(START)
     const ui = await openAndMount($, r)
     expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
 
     const base: Gh = argv => withHistory(r, ok(JSON.stringify(r.history)))(argv)
-    r.gh = argv => (argv.includes('trailhead:map') ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    r.gh = argv => (isGraphql(argv) || isMapsList(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
     r.tickets = [issue(300, 'fresh one', ['trailhead:build'])]
     await r.clock.advance(FLOOR)
     await completeTurn($)
@@ -1279,7 +1494,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'age')).toBe('updated just now')
 
     // unreadable output is the same
-    r.gh = argv => (argv.includes('trailhead:map') ? ok('not json') : base(argv))
+    r.gh = argv => (isGraphql(argv) || isMapsList(argv) ? ok('not json') : base(argv))
     await r.clock.advance(FLOOR)
     await completeTurn($)
     await settle(r)
@@ -1371,4 +1586,336 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
     expect(r.writes).toEqual([])
   })
+
+  const pressDashboard = async (ui: any, r: Rig) => {
+    await ui.press({ key: 'open-whiteboard' })
+    await settle(r)
+  }
+
+  test(`the Whiteboard row shows the maps index and the whiteboard tickets [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect((await ui.find({ key: 'open-whiteboard' }))?.props).toMatchObject({ label: 'Whiteboard' })
+    const before = r.calls.length
+    await pressDashboard(ui, r)
+
+    expect(r.calls.slice(before)).toEqual([
+      ['gh', 'issue', 'list', '--label', 'trailhead:ticket', '--label', 'trailhead:whiteboard', '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url'],
+      ['gh', 'issue', 'list', '--label', 'trailhead:dashboard', '--state', 'open', '--limit', '10', '--json', 'number,url'],
+      MAPS_CALL,
+      uatCall('trailhead:whiteboard'),
+    ])
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+    expect((await ui.find({ key: 'dashboard-title' }))?.children[0]).toMatchObject({ props: { bold: true, color: ACCENT } })
+    expect((await ui.findAll({ type: 'Link' })).map((l: any) => l.props.href)).toContain(`${URL}/5`)
+    expect((await ui.find({ key: 'to-map' }))?.props).toMatchObject({ label: 'map' })
+    expect(await hasKey(ui, 'dashboard')).toBe(false)
+    // the view is the whiteboard: its row is not drawn again
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(false)
+
+    // every open map is a button, the active one marked
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect((await ui.find({ key: 'map-198' }))?.props).toMatchObject({ label: '#198 trailhead mod' })
+    expect(await hasKey(ui, 'map-14')).toBe(true)
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
+
+    // the whiteboard by state, the quarantined one only counted, no map tickets
+    expect(await hasKey(ui, 'whiteboard')).toBe(true)
+    expect(await textOf(ui, 'head-whiteboard')).toBe('Whiteboard · 3 open · 1 assigned')
+    expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 1')
+    expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 1')
+    expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 1')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await textOf(ui, 'holder-302')).toBe('@alice')
+    expect(await hasKey(ui, 'work-301')).toBe(true)
+    expect(await textOf(ui, 'unverified')).toBe('1 unverified ticket hidden (quarantined)')
+    expect(await hasKey(ui, 'burndown-section')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+    expect(r.writes).toEqual([])
+  })
+
+  test(`a Whiteboard row above the maps list carries the counts, the header has no dashboard button [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.maps = [MAPS[0]]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    // one map open: no maps group, the row is still there, without a per-ticket query
+    expect(await hasKey(ui, 'group-maps')).toBe(false)
+    expect((await ui.find({ key: 'open-whiteboard' }))?.props).toMatchObject({ label: 'Whiteboard' })
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 3 open / 9')
+    expect((await ui.find({ key: 'whiteboard-aside' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    expect(await hasKey(ui, 'dashboard')).toBe(false)
+    expect(r.calls.filter(argv => argv.includes('trailhead:whiteboard'))).toEqual([])
+    expect(r.calls.filter(isGraphql)).toEqual([MAPS_CALL])
+    // above the maps list and the tickets, below the heading
+    const keys = (await ui.findAll({ type: 'Box' })).map((el: any) => el.key)
+    expect(keys.indexOf('whiteboard-row')).toBeGreaterThan(keys.indexOf('header'))
+    expect(keys.indexOf('whiteboard-row')).toBeLessThan(keys.indexOf('group-frontier'))
+  })
+
+  test(`the Whiteboard row sits above the Maps list [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    const keys = (await ui.findAll({ type: 'Box' })).map((el: any) => el.key)
+    expect(keys.indexOf('whiteboard-row')).toBeLessThan(keys.indexOf('group-maps'))
+    expect(keys.indexOf('whiteboard-row')).toBeGreaterThan(keys.indexOf('header'))
+  })
+
+  test(`a press on the Whiteboard row shows the whiteboard, the map button goes back [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.maps = [MAPS[0]]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(false)
+    await ui.press({ key: 'to-map' })
+    await settle(r)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 3 open / 9')
+  })
+
+  test(`the whiteboard counts are drawn as read, zero included, and follow the next read [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboardCounts = { open: 0, total: 0 }
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 0 open / 0')
+    r.whiteboardCounts = { open: 4, total: 11 }
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 4 open / 11')
+  })
+
+  test(`a failed counts read shows the row name-only, never an error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const base = r.defaultGh
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(true)
+    expect(await hasKey(ui, 'whiteboard-aside')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+
+    // counts that were read once are not kept through a failed read
+    r.gh = null
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 3 open / 9')
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, 'whiteboard-aside')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+  })
+
+  test(`both maps reads failing keep the maps list but draw the row name-only [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 3 open / 9')
+    const base: Gh = argv => withHistory(r, ok(JSON.stringify(r.history)))(argv)
+    r.gh = argv => (isGraphql(argv) || isMapsList(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(true)
+    expect(await hasKey(ui, 'whiteboard-aside')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+  })
+
+  test(`unreadable whiteboard fields leave the maps with counts and the row name-only [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboardCounts = null
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(true)
+    expect(await hasKey(ui, 'whiteboard-aside')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+  })
+
+  test(`with no active map the Whiteboard row sits above the maps [${surface}]`, async ($, on) => {
+    const none = rig(on, $)
+    none.active = null
+    await $.session.start(START)
+    const ui = await openAndMount($, none)
+    await completeTurn($)
+    await settle(none)
+    expect(await hasKey(ui, 'dashboard')).toBe(false)
+    expect(await textOf(ui, 'whiteboard-aside')).toBe(' 3 open / 9')
+    const keys = (await ui.findAll({ type: 'Box' })).map((el: any) => el.key)
+    expect(keys.indexOf('whiteboard-row')).toBeLessThan(keys.indexOf('group-maps'))
+  })
+
+  test(`the Whiteboard row stays in the loading view of a map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let release: () => void = () => undefined
+    const held = new Promise<void>(resolve => (release = resolve))
+    const base = r.defaultGh
+    r.gh = async argv => {
+      if (argv[2] === 'view') await held
+      return base(argv)
+    }
+    await $.session.start(START)
+    r.open()
+    const ui = await mountPane($)
+    await settle(r)
+    expect(await textOf(ui, 'loading')).toBe('Loading tickets…')
+    expect(await hasKey(ui, 'open-whiteboard')).toBe(true)
+    release()
+    await settle(r)
+  })
+
+  test(`the maps list shows each map's open and total from one call [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(argv => argv.includes('trailhead:map') || isGraphql(argv))).toEqual([MAPS_CALL])
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
+    expect(await textOf(ui, 'map-aside-14')).toBe(' 3 open / 5')
+    // a map the read gave no summary for is drawn name-only
+    r.mapSummary = { 198: { total: 23, completed: 16 } }
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+    expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
+  })
+
+  test(`a failing counts read falls back to the name-only list with no footer error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const base = r.defaultGh
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(argv => argv.includes('trailhead:map') || isGraphql(argv))).toEqual([MAPS_CALL, MAPS_LIST_CALL])
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect(await textOf(ui, 'map-aside-198')).toBe(' active')
+    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+
+    // a reply with errors is a failed read too
+    r.gh = argv => (isGraphql(argv) ? ok(JSON.stringify({ data: { repository: { issues: { nodes: [] } } }, errors: [{ message: 'x' }] })) : base(argv))
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+  })
+
+  test(`the dashboard heading counts the whiteboard and every assigned trusted ticket is a row [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = [
+      ...WHITEBOARD,
+      issue(305, 'Assigned but quarantined', [...WB, 'trailhead:task', 'trailhead:unverified'], ['dave']),
+      issue(306, 'Paused with a holder', [...WB, 'trailhead:task', 'trailhead:paused'], ['erin']),
+    ]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'head-whiteboard')).toBe('Whiteboard · 4 open · 2 assigned')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
+    expect(await textOf(ui, 'holder-302')).toBe('@alice')
+    expect(await textOf(ui, 'holder-306')).toBe('@erin')
+    expect(await hasKey(ui, 'row-305')).toBe(false)
+    expect(await textOf(ui, 'unverified')).toBe('2 unverified tickets hidden (quarantined)')
+  })
+
+  test(`the map button goes back to the map shown before [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressMap(ui, r, 14)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+
+    await ui.press({ key: 'to-map' })
+    await settle(r)
+    expect(await textOf(ui, 'map')).toBe('#14 older map')
+    expect(await textOf(ui, 'viewing-text')).toBe('viewing #14 · active #198')
+    expect(await hasKey(ui, 'dashboard-title')).toBe(false)
+  })
+
+  test(`a map pressed on the dashboard shows that map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    await pressMap(ui, r, 14)
+    expect(await textOf(ui, 'map')).toBe('#14 older map')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+
+    await pressDashboard(ui, r)
+    await pressMap(ui, r, 198)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(await hasKey(ui, 'viewing')).toBe(false)
+  })
+
+  test(`a work press on a whiteboard ticket clears and runs the work verb [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    await ui.press({ key: 'work-301' })
+    await settle(r)
+    expect(r.runs).toEqual([
+      { command: 'clear', args: '' },
+      { command: 'trailhead:work', args: '301' },
+    ])
+    // the dashboard stays shown across the reset
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+    expect(await keysOf(ui, 'row-')).toContain('row-301')
+  })
+
+  test(`an empty whiteboard says so, a failed read shows the reason [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = []
+    r.dashboard = []
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'no-tickets')).toBe('No open whiteboard tickets.')
+    // no pinned index yet: the title is plain text
+    expect((await ui.findAll({ type: 'Link' })).map((l: any) => l.props.href)).not.toContain(`${URL}/5`)
+
+    r.whiteboard = WHITEBOARD
+    r.gh = argv => (argv.includes('trailhead:whiteboard') ? { exitCode: 1, stdout: '', stderr: 'boom' } : r.defaultGh(argv))
+    await r.clock.advance(FLOOR)
+    await ui.press({ key: 'refresh' })
+    await settle(r)
+    expect(await textOf(ui, 'age')).toBe('⚠ gh failed (exit 1) · list from 15s ago')
+    // a list that may be stale says nothing about being empty
+    expect(await hasKey(ui, 'no-tickets')).toBe(false)
+  })
+
+  test(`with no active map the dashboard is one press away [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.active = null
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
+    await pressDashboard(ui, r)
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    await ui.press({ key: 'to-map' })
+    await settle(r)
+    expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
+  })
+
+  test(`the dashboard stays shown through /clear [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    await $.command.run({ command: 'clear', args: '' } as never)
+    await settle(r)
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+  })
 }