~ 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
103 lines · 4.7 KB Raw History
// `npm run unit` in web/ (`just check` runs it).
import { strict as assert } from 'node:assert';
import { test } from 'node:test';
import { pageItems, pagedPast, Recent } from './recent.ts';

const ALICE = 'did:plc:alice';
const BOB = 'did:plc:bob';
const feed = { name: 'query', args: { method: 'social.grain.unspecced.getTimeline' } };
const gallery = (n: number) => ({ name: 'query', args: { method: 'social.grain.gallery.getGallery', params: { uri: `at://g/${n}` } } });

/** A memory on a clock of its own. */
function memory(limits = { age: 1000, kept: 3, bytes: 1000 }) {
	const clock = { now: 0 };
	return { recent: new Recent<{ t: string }>(limits, () => clock.now), clock };
}

test('a screen kept is drawn again, its last tree in place of any before', () => {
	const { recent, clock } = memory();
	assert.equal(recent.recall(feed), null);
	recent.keep(ALICE, feed, { t: 'one' }, clock.now);
	recent.keep(ALICE, feed, { t: 'two' }, clock.now);
	assert.deepEqual(recent.recall(feed), { t: 'two' });
	assert.deepEqual(recent.recall({ name: 'query', args: { method: 'social.grain.unspecced.getTimeline' } }), { t: 'two' });
	assert.equal(recent.recall(gallery(1)), null);
});

test('a tree past its age is not drawn, and let go', () => {
	const { recent, clock } = memory();
	recent.keep(null, feed, { t: 'one' }, clock.now);
	clock.now = 1000;
	assert.deepEqual(recent.recall(feed), { t: 'one' });
	clock.now = 1001;
	assert.equal(recent.recall(feed), null);
	clock.now = 0;
	assert.equal(recent.recall(feed), null);
});

test('another account, or none, finds none of the trees kept as one', () => {
	const { recent, clock } = memory();
	recent.keep(ALICE, feed, { t: 'alice' }, clock.now);
	recent.keep(BOB, gallery(1), { t: 'bob' }, clock.now);
	assert.equal(recent.recall(feed), null);
	assert.deepEqual(recent.recall(gallery(1)), { t: 'bob' });
	recent.keep(null, gallery(2), { t: 'guest' }, clock.now);
	assert.equal(recent.recall(gallery(1)), null);
	assert.deepEqual(recent.recall(gallery(2)), { t: 'guest' });
});

test('forgetting lets every tree go, and an answer to a call made before it is not kept', () => {
	const { recent, clock } = memory();
	recent.keep(ALICE, feed, { t: 'one' }, clock.now);
	recent.keep(ALICE, gallery(1), { t: 'two' }, clock.now);
	clock.now = 10;
	recent.forget();
	assert.equal(recent.recall(feed), null);
	assert.equal(recent.recall(gallery(1)), null);
	clock.now = 20;
	recent.keep(ALICE, feed, { t: 'asked before' }, 5);
	assert.equal(recent.recall(feed), null);
	recent.keep(ALICE, feed, { t: 'asked after' }, 11);
	assert.deepEqual(recent.recall(feed), { t: 'asked after' });
});

test('past the count kept, the screen kept longest ago goes first', () => {
	const { recent, clock } = memory();
	for (const n of [1, 2, 3]) recent.keep(ALICE, gallery(n), { t: `${n}` }, clock.now);
	recent.keep(ALICE, gallery(1), { t: '1 again' }, clock.now);
	recent.keep(ALICE, gallery(4), { t: '4' }, clock.now);
	assert.equal(recent.recall(gallery(2)), null);
	for (const n of [1, 3, 4]) assert.notEqual(recent.recall(gallery(n)), null);
});

test('past the bytes kept, the oldest go; a tree bigger than all of them is never kept', () => {
	const { recent, clock } = memory({ age: 1000, kept: 10, bytes: 40 });
	recent.keep(ALICE, gallery(1), { t: 'x'.repeat(10) }, clock.now);
	recent.keep(ALICE, gallery(2), { t: 'y'.repeat(10) }, clock.now);
	assert.notEqual(recent.recall(gallery(1)), null);
	recent.keep(ALICE, gallery(3), { t: 'z'.repeat(10) }, clock.now);
	assert.equal(recent.recall(gallery(1)), null);
	assert.notEqual(recent.recall(gallery(2)), null);
	assert.notEqual(recent.recall(gallery(3)), null);
	recent.keep(ALICE, gallery(4), { t: 'w'.repeat(40) }, clock.now);
	assert.equal(recent.recall(gallery(4)), null);
	assert.notEqual(recent.recall(gallery(3)), null);
});

test('a tree has its page list found depth first, and none where it has none', () => {
	const items = [{ open: { name: 'a', args: {} } }];
	const tree = { k: [{ p: { title: 'Bar' } }, { k: [{ p: { page: true }, items }] }] };
	assert.equal(pageItems(tree), items);
	assert.equal(pageItems({ k: [{ p: { page: false }, items }] }), null);
	assert.equal(pageItems({ p: { page: true } }), null);
});

test('refreshing, the items paged past the first page stay after it, less those it has again', () => {
	const item = (n: number) => ({ open: { name: 'open', args: { n } } });
	const drawn = [item(1), item(2), item(3), item(4), item(5)];
	assert.deepEqual(pagedPast(drawn, 2, [item(0), item(1)]), [item(3), item(4), item(5)]);
	assert.deepEqual(pagedPast(drawn, 2, [item(0), item(3)]), [item(4), item(5)]);
	assert.deepEqual(pagedPast(drawn, 5, [item(1)]), []);
	const bare = [{ k: 1 }, { k: 2 }] as { open?: unknown; k: number }[];
	assert.deepEqual(pagedPast(bare, 1, [{ k: 2 } as { open?: unknown }]), []);
});