Vergangene Mitgliedschaften sichtbar, Antworten nicht mehr aus dem Cache

Wer sich aus einem Gruppen-CC herausredesignt hat, war trotzdem darin - der
CC verschwand aber aus seiner Liste. Jetzt steht er am Fuss der Kette, in die
der Spieler von dort aus gewechselt ist, gekennzeichnet als "war dabei" und
mit dem Hinweis, wem er gehoert und wohin es weiterging. Verschieben oder
entscheiden laesst sich daran nichts: es ist der Platz eines anderen.
Frueheres, das zu keinem heutigen Platz fuehrt, steht unter "Frueher
genutzt". Dasselbe gilt fuer einen gewoehnlichen Austritt.

Neu eingetragene CCs tauchten manchmal erst nach einem Neuladen auf. Die
Antworten der Schnittstelle trugen keinen Cache-Header, und ohne Angabe darf
ein Browser selbst entscheiden, wie lange er eine GET-Antwort aufhebt - dann
steht nach dem Anlegen die alte Liste auf dem Schirm. Sie tragen jetzt
no-store, was nebenbei verhindert, dass Spielerdaten im Cache liegen bleiben.

Ausserdem: die Pfeile zwischen den Kettengliedern sind groesser und tragen
die Akzentfarbe - sie sind das Einzige, was die Leserichtung verraet. Und
"Zurueknehmen" heisst jetzt "Loeschen", weil genau das passiert.

server/test/gruppen.test.ts

@@ -202,7 +202,7 @@ describe('Gruppen-CCs', () => {
     assert.deepEqual(nachAustritt, vorAustritt, 'der Platz war bezahlt und bleibt es');
   });
 
-  it('zeigt den CC nach dem Austritt nicht mehr beim Aussteiger', async () => {
+  it('behält den CC nach dem Austritt in der Geschichte des Aussteigers', async () => {
     const gruender = await spielerMitPaket('Kern');
     const kurz = await spielerMitPaket('Kurzzeitig');
     const { character } = await characters.createCharacter(gruender, { name: 'Durchlauf' }, ctx);
@@ -213,8 +213,15 @@ describe('Gruppen-CCs', () => {
 
     await characters.removeMember(character.id, kurz, undefined, ctx);
 
+    // Er war darin, und das bleibt so. Dass er keinen Platz mehr belegt,
+    // steht an der Mitgliedschaft, nicht daran, dass der CC verschwindet.
     const danach = await characters.listCharacters(kurz);
-    assert.equal(danach.some((c) => c.id === character.id), false, 'danach nicht mehr');
+    const eintrag = danach.find((c) => c.id === character.id);
+    assert.ok(eintrag, 'der CC gehört weiter zu seiner Geschichte');
+    assert.ok(
+      eintrag?.members.find((m) => m.playerId === kurz)?.leftAt,
+      'seine Mitgliedschaft ist beendet',
+    );
 
     // Beim Gründer bleibt er stehen.
     const beimGruender = await characters.listCharacters(gruender);
@@ -432,11 +439,13 @@ describe('Slots: ein CC-Paket, ein gleichzeitig aktiver CC', () => {
       ctx,
     );
 
-    const aktive = (await characters.listCharacters(gast)).filter((c) => c.status === 'ACTIVE');
+    const belegt = (await characters.listCharacters(gast)).filter(
+      (c) => c.status === 'ACTIVE' && c.members.some((m) => m.playerId === gast && !m.leftAt),
+    );
     assert.deepEqual(
-      aktive.map((c) => c.name),
+      belegt.map((c) => c.name),
       ['Die Runde'],
-      'ein Platz, ein aktiver CC - der eigene ist dafür weg',
+      'ein Platz, ein belegter Platz - der eigene ist dafür weg',
     );
   });
 });
@@ -514,12 +523,36 @@ describe('Aus einem Gruppen-CC herausredesignen', () => {
       ctx,
     );
 
-    const aktive = (await characters.listCharacters(zwei)).filter((c) => c.status === 'ACTIVE');
-    assert.deepEqual(
-      aktive.map((c) => c.name),
-      ['Getauscht'],
-      'ein Paket, ein aktiver CC - der Gruppenplatz ist dafür weg',
+    // Sichtbar ist beides - er war ja in der Gruppe. Belegt ist nur einer.
+    const belegt = (await characters.listCharacters(zwei)).filter(
+      (c) => c.status === 'ACTIVE' && c.members.some((m) => m.playerId === zwei && !m.leftAt),
     );
+    assert.deepEqual(
+      belegt.map((c) => c.name),
+      ['Getauscht'],
+      'ein Paket, ein belegter Platz - der Gruppenplatz ist dafür weg',
+    );
+  });
+
+  it('behält den Gruppen-CC in der Geschichte des Ausgestiegenen', async () => {
+    const { zwei, character } = await dreierGruppe('Geschichte');
+    const neuer = await characters.redesignMembership(
+      character.id,
+      zwei,
+      { name: 'Eigenes Ding', useKind: 'REDESIGN_PAID' },
+      ctx,
+    );
+
+    const seine = await characters.listCharacters(zwei);
+    const gruppe = seine.find((c) => c.id === character.id);
+    assert.ok(gruppe, 'er war in der Gruppe, und das bleibt sichtbar');
+
+    // Die Spur zeigt, wohin es von dort aus ging - daran hängt die Anzeige
+    // den alten Eintrag unter die richtige Kette.
+    const eigene = gruppe?.members.find((m) => m.playerId === zwei);
+    assert.ok(eigene?.leftAt, 'seine Mitgliedschaft ist beendet');
+    assert.equal(eigene?.successorId, neuer.character.id);
+    assert.equal(eigene?.successor?.name, 'Eigenes Ding');
   });
 
   it('weist den letzten Nutzer auf das gewöhnliche Redesign hin', async () => {

server/test/http.test.ts

@@ -302,6 +302,14 @@ describe('Auslieferung der Oberfläche', () => {
     );
   });
 
+  it('lässt Antworten der Schnittstelle gar nicht erst in den Cache', async () => {
+    // Ohne Angabe entscheidet der Browser selbst, wie lange er eine Antwort
+    // aufhebt - dann steht nach dem Anlegen eines CCs die alte Liste da.
+    const response = await app.inject({ method: 'GET', url: '/api/auth/me' });
+
+    assert.equal(response.headers['cache-control'], 'no-store');
+  });
+
   it('liefert auch Deep-Links ohne Cache aus', async () => {
     const response = await app.inject({ method: 'GET', url: '/players/1' });