feat(quick-260921-pi9): Bilderrahmen-API - Bilder je Benutzer in der Datenbank, Magic-Byte-Pruefung, 5 MiB / 30 Stueck

- Prisma-Modell DashboardImage (bytea) mit Migration 20260921120000: Tabelle, Indizes, RLS ENABLE/FORCE und tenant_isolation_policy mit Benutzerdimension - dashboard-image-rules.ts: detectImageMime ueber Magic Bytes (PNG/JPEG/GIF/ WebP), Grenzen 5 MiB je Datei und 30 je Benutzer - DashboardImagesService: list/upload/getBytes/remove, je Methode forTenant(prisma, tenantId, userId); Besitz = Mandant UND Benutzer, sonst 404 - DashboardImagesController unter dashboard/images: GET, POST (FileInterceptor image, 5 MiB, eine Datei), GET :id mit Content-Type aus dem erkannten Typ, Cache-Control private, nosniff, Content-Disposition inline ohne Dateinamen, CSP sandbox; DELETE :id - CreateWidgetDto kennt 'picture-frame' - Klassifikationsdokument: neues Paar dashboard-images.service.ts/ dashboardImage; Bereichs- und Summenzeilen nachgemessen (dashboard 12->18, settings 3->4 und bug-reports waren in der Summe nie mitgezaehlt) - Befund: Prisma-Bytes verlangt Uint8Array<ArrayBuffer>, multers Buffer wird ohne Zusicherung abgelehnt - Kopie per new Uint8Array(buffer) statt Cast Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-21 18:47:07 +02:00
parent 573d070041
commit 737974b653
11 changed files with 884 additions and 10 deletions
@@ -0,0 +1,291 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+/**
+ * Bindung an forTenant() — dasselbe Muster wie dashboard.service.spec.ts
+ * (260910-krx): der gebundene Klient ist ein ZWEITES, von `prisma`
+ * unterscheidbares Objekt ueber DEMSELBEN Speicher, das protokolliert,
+ * welche Aufrufe ueber ihn liefen. Ein vergessener Bindungsaufruf faellt
+ * damit auf (`prisma.dashboardImage` waere dann ohne Protokoll-Eintrag).
+ */
+vi.mock('../prisma/prisma-tenant.extension', () => ({
+  forTenant: vi.fn((prisma: FakePrisma, tenantId: string, userId?: string) =>
+    prisma.__makeBoundClient(tenantId, userId),
+  ),
+}));
+
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import type { AuthUser, UploadedFileLike } from '../auth/types/auth-user';
+import { forTenant } from '../prisma/prisma-tenant.extension';
+import { DashboardImagesService } from './dashboard-images.service';
+
+/**
+ * dashboard-images.service.spec — NEU (quick-260921-pi9, Bilderrahmen).
+ *
+ * Elf Faelle an der Grenze Dienst -> Datenbank: Liste ohne `data`, Upload
+ * ohne Datei, Magic Bytes schlagen den behaupteten MIME-Typ in BEIDE
+ * Richtungen (T-PI9-01), Zaehler 30 (T-PI9-03), fremder Benutzer UND
+ * fremder Mandant -> 404 (T-PI9-04, nie 403), eigenes Bild liefert Bytes,
+ * Loeschen eigen/fremd, und der Nachweis, dass jede Methode
+ * `forTenant(prisma, tenantId, userId)` mit dem Benutzer als drittem
+ * Argument aufruft.
+ */
+
+interface ImageRow {
+  id: string;
+  userId: string;
+  tenantId: string;
+  originalName: string;
+  mimeType: string;
+  size: number;
+  data: Uint8Array;
+  createdAt: Date;
+}
+
+interface BoundCall {
+  tenantId: string;
+  userId: string | undefined;
+  model: string;
+  method: string;
+}
+
+type ModelMethods = Record<string, (...args: unknown[]) => Promise<unknown>>;
+
+interface FakePrisma {
+  dashboardImage: ModelMethods;
+  __rows: ImageRow[];
+  __boundCallLog: BoundCall[];
+  __makeBoundClient(tenantId: string, userId?: string): { dashboardImage: ModelMethods };
+}
+
+const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13]);
+const TEXT = Buffer.from('nur Text, kein Bild');
+
+function makeRow(overrides: Partial<ImageRow> = {}): ImageRow {
+  return {
+    id: overrides.id ?? 'img-1',
+    userId: overrides.userId ?? 'user-1',
+    tenantId: overrides.tenantId ?? 'tenant-1',
+    originalName: overrides.originalName ?? 'foto.png',
+    mimeType: overrides.mimeType ?? 'image/png',
+    size: overrides.size ?? PNG.length,
+    data: overrides.data ?? Uint8Array.from(PNG),
+    createdAt: overrides.createdAt ?? new Date('2026-01-01'),
+  };
+}
+
+function pick(row: ImageRow, select: Record<string, boolean> | undefined) {
+  if (!select) return row;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(select)) {
+    if (select[key]) out[key] = row[key as keyof ImageRow];
+  }
+  return out;
+}
+
+function makeFakePrisma(rows: ImageRow[] = []): FakePrisma {
+  const boundCallLog: BoundCall[] = [];
+  const dashboardImage: ModelMethods = {
+    findMany: vi.fn(async (raw: unknown) => {
+      const args = raw as { where: { tenantId: string; userId: string }; select?: Record<string, boolean> };
+      return rows
+        .filter((r) => r.tenantId === args.where.tenantId && r.userId === args.where.userId)
+        .slice()
+        .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
+        .map((r) => pick(r, args.select));
+    }),
+    count: vi.fn(async (raw: unknown) => {
+      const args = raw as { where: { tenantId: string; userId: string } };
+      return rows.filter((r) => r.tenantId === args.where.tenantId && r.userId === args.where.userId).length;
+    }),
+    create: vi.fn(async (raw: unknown) => {
+      const args = raw as { data: Omit<ImageRow, 'id' | 'createdAt'>; select?: Record<string, boolean> };
+      const created = makeRow({ id: `new-${rows.length + 1}`, ...args.data, createdAt: new Date('2026-02-02') });
+      rows.push(created);
+      return pick(created, args.select);
+    }),
+    findUnique: vi.fn(async (raw: unknown) => {
+      const args = raw as { where: { id: string } };
+      return rows.find((r) => r.id === args.where.id) ?? null;
+    }),
+    delete: vi.fn(async (raw: unknown) => {
+      const args = raw as { where: { id: string } };
+      const idx = rows.findIndex((r) => r.id === args.where.id);
+      if (idx === -1) return null;
+      const [removed] = rows.splice(idx, 1);
+      return removed;
+    }),
+  };
+
+  const fake: FakePrisma = {
+    dashboardImage,
+    __rows: rows,
+    __boundCallLog: boundCallLog,
+    __makeBoundClient(tenantId: string, userId?: string) {
+      const wrapped: ModelMethods = {};
+      for (const method of Object.keys(dashboardImage)) {
+        wrapped[method] = async (...args: unknown[]) => {
+          boundCallLog.push({ tenantId, userId, model: 'dashboardImage', method });
+          return dashboardImage[method](...args);
+        };
+      }
+      return { dashboardImage: wrapped };
+    },
+  };
+  return fake;
+}
+
+function makeService(prisma: FakePrisma) {
+  // Der Dienst verlangt einen PrismaService; die Attrappe deckt genau das
+  // Modell ab, das der Dienst anfasst (nur ueber den gebundenen Klienten).
+  // `as never` statt einer Doppelzusicherung ueber unknown (Muster
+  // tender-mail.service.spec.ts; der Zusicherungs-Zaehler bleibt bei 27).
+  return new DashboardImagesService(prisma as never);
+}
+
+const user: AuthUser = {
+  id: 'user-1',
+  username: 'anna',
+  role: 'USER',
+  tenantId: 'tenant-1',
+  mustChangePassword: false,
+};
+
+function file(buffer: Buffer, mimetype: string, originalname = 'foto.png'): UploadedFileLike {
+  return { buffer, mimetype, originalname, size: buffer.length };
+}
+
+beforeEach(() => {
+  vi.mocked(forTenant).mockClear();
+});
+
+describe('DashboardImagesService (quick-260921-pi9)', () => {
+  it('Test 1: list liefert nur eigene Zeilen, nur Metadaten (nie data), aelteste zuerst', async () => {
+    const prisma = makeFakePrisma([
+      makeRow({ id: 'b', createdAt: new Date('2026-03-01') }),
+      makeRow({ id: 'a', createdAt: new Date('2026-01-01') }),
+      makeRow({ id: 'fremd', userId: 'user-2' }),
+    ]);
+    const result = await makeService(prisma).list('user-1', 'tenant-1');
+    expect(result.map((r) => r.id)).toEqual(['a', 'b']);
+    for (const r of result) {
+      expect(Object.keys(r).sort()).toEqual(['createdAt', 'id', 'mimeType', 'originalName', 'size']);
+    }
+    const call = vi.mocked(prisma.dashboardImage.findMany).mock.calls[0][0] as { select: Record<string, boolean> };
+    expect(call.select.data).toBeUndefined();
+  });
+
+  it('Test 2: upload ohne Datei -> BadRequestException mit deutscher Meldung', async () => {
+    const prisma = makeFakePrisma();
+    await expect(makeService(prisma).upload(user, undefined)).rejects.toThrow(
+      new BadRequestException('Bitte wählen Sie eine Bilddatei aus.'),
+    );
+    expect(prisma.dashboardImage.create).not.toHaveBeenCalled();
+  });
+
+  it('Test 3: PNG-Bytes mit behauptetem text/plain gelingen und speichern image/png (Magic Bytes, nicht mimetype)', async () => {
+    const prisma = makeFakePrisma();
+    const result = await makeService(prisma).upload(user, file(PNG, 'text/plain', 'irgendwas.txt'));
+    expect(result.mimeType).toBe('image/png');
+    expect(result.originalName).toBe('irgendwas.txt');
+    expect(result.size).toBe(PNG.length);
+    expect(Object.keys(result).sort()).toEqual(['createdAt', 'id', 'mimeType', 'originalName', 'size']);
+    expect(prisma.__rows[0].userId).toBe('user-1');
+    expect(prisma.__rows[0].tenantId).toBe('tenant-1');
+  });
+
+  it('Test 4: Textdatei mit behauptetem image/png scheitert mit deutscher Meldung, nichts wird angelegt', async () => {
+    const prisma = makeFakePrisma();
+    await expect(makeService(prisma).upload(user, file(TEXT, 'image/png', 'bild.png'))).rejects.toThrow(
+      new BadRequestException('Nur Bilder im Format PNG, JPEG, GIF oder WebP sind erlaubt.'),
+    );
+    expect(prisma.dashboardImage.create).not.toHaveBeenCalled();
+  });
+
+  it('Test 5: Zaehler — 30 eigene Bilder blocken das 31., 29 lassen das 30. durch', async () => {
+    const thirty = Array.from({ length: 30 }, (_, i) => makeRow({ id: `i${i}` }));
+    const full = makeFakePrisma(thirty);
+    await expect(makeService(full).upload(user, file(PNG, 'image/png'))).rejects.toThrow(
+      new BadRequestException(
+        'Sie haben die Höchstzahl von 30 Bildern erreicht. Bitte löschen Sie zuerst ein Bild.',
+      ),
+    );
+    expect(full.dashboardImage.create).not.toHaveBeenCalled();
+
+    const almost = makeFakePrisma(thirty.slice(0, 29));
+    await expect(makeService(almost).upload(user, file(PNG, 'image/png'))).resolves.toMatchObject({
+      mimeType: 'image/png',
+    });
+  });
+
+  it('Test 6: Zaehler zaehlt nur den eigenen Benutzer im eigenen Mandanten (fremde Zeilen zaehlen nicht)', async () => {
+    const foreign = Array.from({ length: 30 }, (_, i) => makeRow({ id: `f${i}`, userId: 'user-2' }));
+    const prisma = makeFakePrisma(foreign);
+    await expect(makeService(prisma).upload(user, file(PNG, 'image/png'))).resolves.toMatchObject({
+      mimeType: 'image/png',
+    });
+    const countArgs = vi.mocked(prisma.dashboardImage.count).mock.calls[0][0] as { where: unknown };
+    expect(countArgs.where).toEqual({ tenantId: 'tenant-1', userId: 'user-1' });
+  });
+
+  it('Test 7: originalName wird auf 255 Zeichen gekuerzt', async () => {
+    const prisma = makeFakePrisma();
+    const result = await makeService(prisma).upload(user, file(PNG, 'image/png', 'x'.repeat(400)));
+    expect(result.originalName).toHaveLength(255);
+  });
+
+  it('Test 8: getBytes — fremder Benutzer (gleicher Mandant) -> NotFoundException, nie Forbidden', async () => {
+    const prisma = makeFakePrisma([makeRow({ id: 'img-1', userId: 'user-2' })]);
+    await expect(makeService(prisma).getBytes('img-1', 'user-1', 'tenant-1')).rejects.toThrow(NotFoundException);
+  });
+
+  it('Test 9: getBytes — fremder Mandant (gleicher Benutzer) -> NotFoundException; unbekannte Kennung ebenso', async () => {
+    const prisma = makeFakePrisma([makeRow({ id: 'img-1', tenantId: 'tenant-2' })]);
+    const service = makeService(prisma);
+    await expect(service.getBytes('img-1', 'user-1', 'tenant-1')).rejects.toThrow(NotFoundException);
+    await expect(service.getBytes('gibt-es-nicht', 'user-1', 'tenant-1')).rejects.toThrow(NotFoundException);
+  });
+
+  it('Test 10: getBytes — eigenes Bild liefert mimeType und die gespeicherten Bytes', async () => {
+    const prisma = makeFakePrisma([makeRow({ id: 'img-1' })]);
+    const result = await makeService(prisma).getBytes('img-1', 'user-1', 'tenant-1');
+    expect(result.mimeType).toBe('image/png');
+    expect(Buffer.from(result.data).equals(PNG)).toBe(true);
+  });
+
+  it('Test 11: remove — eigenes Bild wird geloescht und { id } geliefert; fremdes (Benutzer ODER Mandant) -> 404 ohne Loeschung', async () => {
+    const prisma = makeFakePrisma([
+      makeRow({ id: 'eigen' }),
+      makeRow({ id: 'fremd-user', userId: 'user-2' }),
+      makeRow({ id: 'fremd-tenant', tenantId: 'tenant-2' }),
+    ]);
+    const service = makeService(prisma);
+    await expect(service.remove('eigen', 'user-1', 'tenant-1')).resolves.toEqual({ id: 'eigen' });
+    expect(prisma.__rows.map((r) => r.id)).toEqual(['fremd-user', 'fremd-tenant']);
+    await expect(service.remove('fremd-user', 'user-1', 'tenant-1')).rejects.toThrow(NotFoundException);
+    await expect(service.remove('fremd-tenant', 'user-1', 'tenant-1')).rejects.toThrow(NotFoundException);
+    expect(prisma.__rows).toHaveLength(2);
+  });
+
+  it('Test 12: jede Methode bindet mit (prisma, tenantId, userId) und laeuft NUR ueber den gebundenen Klienten', async () => {
+    const prisma = makeFakePrisma([makeRow({ id: 'img-1' })]);
+    const service = makeService(prisma);
+    await service.list('user-1', 'tenant-1');
+    await service.upload(user, file(PNG, 'image/png'));
+    await service.getBytes('img-1', 'user-1', 'tenant-1');
+    await service.remove('img-1', 'user-1', 'tenant-1');
+
+    expect(vi.mocked(forTenant)).toHaveBeenCalledTimes(4);
+    for (const call of vi.mocked(forTenant).mock.calls) {
+      expect(call[0]).toBe(prisma);
+      expect(call[1]).toBe('tenant-1');
+      expect(call[2]).toBe('user-1');
+    }
+    // Jeder Modellaufruf steht im Protokoll des gebundenen Klienten.
+    const methods = prisma.__boundCallLog.map((c) => c.method);
+    expect(methods).toEqual(['findMany', 'count', 'create', 'findUnique', 'findUnique', 'delete']);
+    for (const c of prisma.__boundCallLog) {
+      expect(c.tenantId).toBe('tenant-1');
+      expect(c.userId).toBe('user-1');
+    }
+  });
+});