Changeset 952baf3 in Klonkt for test

Timestamp:

08/07/2026 05:15:52 PM (5 weeks ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

ba76bf5

Parents:

f85b2c3 (diff), 0d5bd2c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge GitHub-main (1.7.0) met de VPS-lijn

De twee mains waren een dag gedivergeerd en bevatten elk echt werk. GitHub had 66
commits die nooit langs prutfolio.git zijn gekomen, omdat een parallelle sessie
rechtstreeks naar GitHub pushte vanaf een kloon in /tmp op de VPS. De VPS had twee
commits die GitHub niet had. Geen van beide bevatte de ander, en stable had geen van
de twee.

Bewust een merge en geen rebase: dan blijft beide historie intact en wordt er niets
herschreven waar iemand anders al op voortbouwt.

Drie bestanden raakten beide kanten. Alle drie zijn nagekeken, want dat een merge
automatisch slaagt zegt niets over of hij inhoudelijk klopt:

src/services/ActivityPubService.js

• de sleutelbinding staat nu boven de nieuwe asSlug-aanroep van 1.7.0, dus de controle komt nog steeds voor de handtekeningcontrole

scripts/klonkt-refresh-updater.sh

• alleen de opzij-aanpak overleefde; systemctl mask staat nergens meer als code

deploy/MULTI-INSTANCE.md

• spreekt zichzelf niet tegen: beschrijft opzij zetten, met de reden waarom mask weigert

remarks: het gat dat in de review naar boven kwam staat hiermee ook op de 1.7.0-lijn.
De andere bevindingen uit die review staan nog open en zijn niet in deze merge
opgelost; die horen als beads. Ook nog te doen: dezelfde sleutelbinding op stable
als 1.6.1, want daar is het gat nog open bij self-hosters.

-robo
Co-Authored-By: Claude Opus 4.8 <noreply@…>

Location:

test

Files:

• archive-export.test.js (added)
• archive-import.test.js (added)
• archive-recovery.test.js (added)
• authorized-fetch.test.js (modified) (1 diff)
• co-location.test.js (modified) (1 diff)
• feed-wait.test.js (added)
• forwarded-activities.test.js (added)
• guardian-follow-queues.test.js (added)
• guardian-gate-panel.test.js (added)
• guardian-gate-push.test.js (added)
• guardian-help-state.test.js (added)
• interaction-reactions.test.js (added)
• messages-conversations.test.js (added)
• messages.test.js (modified) (3 diffs)
• reactions-characterization.test.js (added)
• seen-notes.test.js (added)
• signature-verification.test.js (added)

test/authorized-fetch.test.js

@@ -1 @@
-// FEP-633c §5.3 note: a committed guardian is recognised for authorized fetch.
+// Authorized fetch (shaer-afq): een instance in Mastodons secure mode geeft zijn
+// actor-document -- en dus zijn publieke sleutel -- alleen aan een ONDERTEKEND
+// verzoek. Zonder die handtekening kregen we 401, vonden we geen sleutel, en
+// wezen we elke correct ondertekende Follow van die instance af. Op boiert.eu
+// bleven daardoor vier accounts eindeloos hangen.
+//
+// De fetch is hier gestubd: het gaat om de vraag OF er ondertekend wordt en of
+// er wordt teruggevallen, niet om echte HTTP of crypto.
+//
+// Run: npm test
+
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 process.env.DATABASE_PATH = ':memory:';
-process.env.PUBLIC_BASE_URL = 'https://test.example';
+process.env.PUBLIC_BASE_URL = 'https://klonkt.test';
 
 const dbMod = await import('../src/config/database.js');
 const db = dbMod.default;
 dbMod.initializeDatabase();
-const AP = (await import('../src/services/ActivityPubService.js')).default;
+const AP = await import('../src/services/ActivityPubService.js');
 
-db.prepare('INSERT INTO users (id, username, email, password_hash, role) VALUES (?,?,?,?,?)').run('u1', 'u1', 'u1@t', 'x', 'god');
-db.prepare('INSERT INTO sites (id, slug, title, owner_id, is_primary) VALUES (?,?,?,?,1)').run('s1', 'kid', 'kid', 'u1');
-// Commit a guardian relation: kid (ward) is guarded by mom.
-const MOM = 'https://mom.example/ap/users/mom';
-db.prepare("INSERT INTO ap_guardianships (slug, role, other_uri, status, created_at) VALUES ('kid','ward',?, 'accepted', CURRENT_TIMESTAMP)").run(MOM);
+db.prepare('INSERT INTO users (id, username, email, password_hash, role) VALUES (?,?,?,?,?)')
+  .run('u1', 'u1', 'u1@test', 'x', 'god');
+db.prepare('INSERT INTO sites (id, slug, title, owner_id) VALUES (?,?,?,?)').run('s1', 'me', 'Me', 'u1');
 
-test('a committed guardian is recognised; a stranger is not', () => {
-  assert.equal(AP.isWardGuardian('kid', MOM), true);
-  assert.equal(AP.isWardGuardian('kid', 'https://x.example/ap/users/stranger'), false);
-  assert.equal(AP.isWardGuardian('nosuch', MOM), false);
+// IP-literals: safeFetch slaat de DNS-lookup over, dus de test blijft offline.
+const OPEN_ACTOR = 'https://203.0.113.30/users/open';       // gewone instance
+const SECURE_ACTOR = 'https://203.0.113.40/users/gesloten'; // authorized fetch
+
+let verzoeken = [];
+const echteFetch = globalThis.fetch;
+globalThis.fetch = async (url, opts = {}) => {
+  const u = String(url);
+  const ondertekend = !!(opts.headers && (opts.headers.Signature || opts.headers.signature));
+  verzoeken.push({ url: u, ondertekend });
+  const doc = (id) => new Response(JSON.stringify({
+    id, type: 'Person', preferredUsername: 'x', inbox: `${id}/inbox`,
+    publicKey: { id: `${id}#main-key`, owner: id, publicKeyPem: '-----BEGIN PUBLIC KEY-----\nx\n-----END PUBLIC KEY-----' },
+  }), { status: 200, headers: { 'content-type': 'application/activity+json' } });
+
+  if (u === OPEN_ACTOR) return doc(OPEN_ACTOR);
+  // De kern van secure mode: onbetekend is het 401, ondertekend krijg je hem wel.
+  if (u === SECURE_ACTOR) return ondertekend ? doc(SECURE_ACTOR) : new Response('unauthorized', { status: 401 });
+  return new Response('not found', { status: 404 });
+};
+
+test('een actor achter authorized fetch wordt nu wél opgehaald', async () => {
+  verzoeken = [];
+  const actor = await AP.fetchActor(SECURE_ACTOR, { asSlug: 'me' });
+  assert.ok(actor, 'de actor hoort binnen te komen');
+  assert.equal(actor.id, SECURE_ACTOR);
+  assert.ok(verzoeken.some((v) => v.url === SECURE_ACTOR && v.ondertekend), 'het verzoek hoort ondertekend te zijn');
 });
+
+test('zonder ondertekenaar blijft dezelfde actor onbereikbaar', async () => {
+  // Dit is precies het oude gedrag, en het bewijst dat de stub echt onderscheid
+  // maakt in plaats van altijd mee te werken.
+  const actor = await AP.fetchActor(SECURE_ACTOR);
+  assert.equal(actor, null);
+});
+
+test('een gewone instance blijft werken, ondertekend of niet', async () => {
+  assert.ok(await AP.fetchActor(OPEN_ACTOR), 'onbetekend');
+  assert.ok(await AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' }), 'ondertekend');
+});
+
+test('een OPEN instance wordt NIET ondertekend opgehaald', () => {
+  // De veiligheidskant van shaer-afq: verifyRequest haalt de keyId-URL op
+  // voordat er iets geverifieerd is, en die URL komt uit een header die iedereen
+  // mag sturen. Tekenden we standaard, dan kan een vreemde ons een ondertekend
+  // verzoek naar een adres van zijn keuze laten sturen, met onze identiteit
+  // eronder. Onbetekend eerst dus, en alleen tekenen als het anders niet lukt.
+  verzoeken = [];
+  return AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' }).then((actor) => {
+    assert.ok(actor);
+    assert.equal(verzoeken.length, 1, 'één poging, geen tweede');
+    assert.equal(verzoeken[0].ondertekend, false, 'en die was onbetekend');
+  });
+});
+
+test('een document zonder sleutel telt als mislukt en leidt tot een ondertekende poging', async () => {
+  // Sommige instances serveren onbetekend wel iets, maar zonder publicKey. Voor
+  // een verificatie hebben we daar niets aan.
+  const KAAL = 'https://203.0.113.50/users/kaal';
+  const stubOrig = globalThis.fetch;
+  globalThis.fetch = async (url, opts = {}) => {
+    const ondertekend = !!(opts.headers && (opts.headers.Signature || opts.headers.signature));
+    if (String(url) === KAAL) {
+      verzoeken.push({ url: String(url), ondertekend });
+      const body = ondertekend
+        ? { id: KAAL, type: 'Person', publicKey: { id: `${KAAL}#k`, owner: KAAL, publicKeyPem: 'x' } }
+        : { id: KAAL, type: 'Person' };   // kaal: geen sleutel
+      return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/activity+json' } });
+    }
+    return stubOrig(url, opts);
+  };
+  verzoeken = [];
+  const actor = await AP.fetchActor(KAAL, { asSlug: 'me' });
+  globalThis.fetch = stubOrig;
+  assert.ok(actor.publicKey && actor.publicKey.publicKeyPem, 'de ondertekende poging levert de sleutel');
+  assert.deepEqual(verzoeken.map((v) => v.ondertekend), [false, true], 'eerst onbetekend, daarna pas ondertekend');
+});
+
+test('een onbekende actor blijft null, ondertekend of niet', async () => {
+  assert.equal(await AP.fetchActor('https://203.0.113.99/users/weg', { asSlug: 'me' }), null);
+});
+
+test.after(() => { globalThis.fetch = echteFetch; });

test/co-location.test.js

@@ -227 +227 @@
     // of that job being done.
     wardSlugsOf: 'TODO: gated follows still take the shared-database path for a local guardian',
+    // Tweede plek van diezelfde sluiproute, aangekomen met Fase 2 (shaer-jdb):
+    // followsCollection vult de wachtrij voor een ward op DEZE instance uit
+    // ap_pending_follows. Hoort mee te verdwijnen met wardSlugsOf hierboven --
+    // niet apart, want het is een sluiproute en geen tweede probleem.
+    slugOf: 'TODO: idem, nu ook in de follows-wachtrij (shaer-h6u)',
   };
-  const files = ['src/services/guardianship/handshake.js', 'src/routes/guardian.js'];
+  // De hele module, niet twee bestanden. Het commentaar hierboven zegt "elke
+  // plek die vraagt of deze actor van ons is", en dat werd tot nu toe afgemeten
+  // aan twee namen -- waardoor een nieuwe sluiproute in een DERDE bestand er
+  // geruisloos doorheen kwam. Dat is precies hoe deze er kwam.
+  const files = [
+    ...fs.readdirSync('src/services/guardianship').filter((f) => f.endsWith('.js'))
+      .map((f) => `src/services/guardianship/${f}`),
+    'src/routes/guardian.js',
+  ];
   // Only top-level declarations name a scope; an indented `const base = ...` is
   // a local and would otherwise take the blame for its enclosing function. A

test/messages.test.js

@@ -2 +2 @@
 // in één stroom, groepeert opeenvolgende likes/boosts op dezelfde post, en geeft
 // visibility door (voor de privé-badge). Besluit Robin+Bart 2026-07-16.
+//
+// Sinds Berichten gesprekken toont vouwen antwoorden, mentions en je eigen
+// verzonden berichten samen tot draden (zie messages-conversations.test.js voor
+// de groepeerlogica zelf); likes, boosts en follows blijven losse regels.
 //
 // Run: npm test   (= node --test)
@@ -42 +46 @@
 const msgs = AP.getMessages('me', 50);
 
-test('eigen outbound reply zit als "sent" in de stroom (nieuwste eerst)', () => {
-  const sent = msgs.find((m) => m.type === 'sent');
+test('eigen outbound reply en het ontvangen antwoord staan in EEN draad', () => {
+  const thread = msgs.find((m) => m.type === 'thread');
+  assert.ok(thread, 'draad ontbreekt');
+  assert.equal(msgs[0], thread, 'de draad met het nieuwste bericht hoort bovenaan');
+  const sent = thread.messages.find((m) => m.type === 'sent');
   assert.ok(sent, 'sent-item ontbreekt');
   assert.equal(sent.outboxId, 'out1');
   assert.equal(sent.to_handle, '@dana@r.test');
-  assert.equal(msgs[0].type, 'sent', 'nieuwste item hoort bovenaan');
+  // Hier gaat het om: Dana's antwoord en het jouwe zaten in aparte chips
+  // (Gesprekken en Verzonden) en staan nu op volgorde in dezelfde draad.
+  assert.deepEqual(thread.messages.map((m) => m.type), ['reply', 'sent']);
+  assert.equal(thread.post.slug, 'mijn-post');
 });
 
@@ -58 +68 @@
 
 test('privé-reply draagt visibility voor de badge en heeft post-context', () => {
-  const reply = msgs.find((m) => m.type === 'reply');
+  const thread = msgs.find((m) => m.type === 'thread');
+  const reply = thread.messages.find((m) => m.type === 'reply');
   assert.equal(reply.visibility, 'direct');
   assert.equal(reply.post_slug, 'mijn-post');
   assert.equal(reply.post_title, 'Mijn post');
+  // De context hangt ook aan de draad zelf: die voedt de link in de kop.
+  assert.deepEqual(thread.post, { slug: 'mijn-post', title: 'Mijn post' });
 });