schalli
11a70c9ee9
- Wiederholungsauftrag jede Minute für Clouds mit einem Fehlschlag älter als fünf Minuten - Neue Adresse setzt den Prüfstand zurück, der gemeldete Zustand bleibt - Kachel: Hinweis Prüfung fehlgeschlagen, Fehlercodes als lesbarer Text mit Tooltip Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
488 lines
20 KiB
TypeScript
488 lines
20 KiB
TypeScript
import { BadRequestException, NotFoundException } from '@nestjs/common';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
vi.mock('../prisma/prisma-tenant.extension', () => ({
|
|
forTenant: vi.fn((p: unknown) => p),
|
|
forSystem: vi.fn((p: unknown) => p),
|
|
}));
|
|
vi.mock('./nextcloud-status-fetch', async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import('./nextcloud-status-fetch')>();
|
|
return { ...actual, fetchNextcloudStatus: vi.fn() };
|
|
});
|
|
|
|
import { forSystem, forTenant } from '../prisma/prisma-tenant.extension';
|
|
import type { NextcloudReference } from './nextcloud-rating';
|
|
import { NextcloudStatusService, PUBLIC_SELECT } from './nextcloud-status.service';
|
|
import { fetchNextcloudStatus } from './nextcloud-status-fetch';
|
|
|
|
const REFERENCE: NextcloudReference = {
|
|
fetchedAt: '2026-10-02T10:00:00.000Z',
|
|
cycles: [{ cycle: 35, eol: '2099-09-30', latest: '35.0.1' }],
|
|
};
|
|
|
|
function makeRow(over: Record<string, unknown> = {}) {
|
|
return {
|
|
id: 'i1',
|
|
tenantId: 't1',
|
|
customerName: 'Kunde A',
|
|
baseUrl: 'https://cloud.a.de',
|
|
logoUrl: null,
|
|
logoMime: null,
|
|
logoVersion: 0,
|
|
lastCheckedAt: new Date('2026-10-02T11:00:00Z'),
|
|
reachable: true,
|
|
maintenance: false,
|
|
needsDbUpgrade: false,
|
|
versionString: '35.0.1',
|
|
edition: null,
|
|
errorKind: null,
|
|
errorDetail: null,
|
|
...over,
|
|
};
|
|
}
|
|
|
|
describe('NextcloudStatusService', () => {
|
|
let prisma: { nextcloudInstance: Record<string, ReturnType<typeof vi.fn>> };
|
|
let release: { getReference: ReturnType<typeof vi.fn> };
|
|
let alerts: {
|
|
subscribedInstanceIds: ReturnType<typeof vi.fn>;
|
|
evaluateAfterCheck: ReturnType<typeof vi.fn>;
|
|
};
|
|
let service: NextcloudStatusService;
|
|
|
|
beforeEach(() => {
|
|
vi.mocked(fetchNextcloudStatus).mockReset();
|
|
vi.mocked(forTenant).mockClear();
|
|
prisma = {
|
|
nextcloudInstance: {
|
|
findMany: vi.fn(),
|
|
findFirst: vi.fn(),
|
|
create: vi.fn(),
|
|
update: vi.fn(),
|
|
},
|
|
};
|
|
release = { getReference: vi.fn().mockResolvedValue(REFERENCE) };
|
|
alerts = {
|
|
subscribedInstanceIds: vi.fn().mockResolvedValue(new Set<string>()),
|
|
evaluateAfterCheck: vi.fn().mockResolvedValue({ kind: null, delivery: null }),
|
|
};
|
|
service = new NextcloudStatusService(prisma as never, release as never, alerts as never);
|
|
});
|
|
|
|
it('listForTenant waehlt keine Logo-Bytes und liefert Bewertung und neueste Version', async () => {
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([
|
|
makeRow(),
|
|
makeRow({ id: 'i2', logoMime: 'image/png', logoVersion: 3 }),
|
|
]);
|
|
const result = await service.listForTenant('t1', 'u1');
|
|
const args = prisma.nextcloudInstance.findMany.mock.calls[0][0];
|
|
expect(args.select).toBe(PUBLIC_SELECT);
|
|
expect(args.select).not.toHaveProperty('logoData');
|
|
expect(args.where).toEqual({ tenantId: 't1' });
|
|
expect(forTenant).toHaveBeenCalledWith(prisma, 't1');
|
|
expect(result.reference).toEqual({ newestVersion: '35.0.1', fetchedAt: REFERENCE.fetchedAt });
|
|
expect(result.instances).toHaveLength(2);
|
|
expect(result.instances[0].rating).toMatchObject({ level: 'green', reason: 'current' });
|
|
expect(result.instances[0].hasUploadedLogo).toBe(false);
|
|
expect(result.instances[1]).toMatchObject({ hasUploadedLogo: true, logoVersion: 3 });
|
|
expect(JSON.stringify(result)).not.toContain('logoData');
|
|
});
|
|
|
|
it('listForTenant ohne Vergleichsdaten bewertet grau', async () => {
|
|
release.getReference.mockResolvedValue(null);
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([makeRow()]);
|
|
const result = await service.listForTenant('t1', 'u1');
|
|
expect(result.reference).toEqual({ newestVersion: null, fetchedAt: null });
|
|
expect(result.instances[0].rating.level).toBe('unknown');
|
|
});
|
|
|
|
it('createInstance normalisiert die Adresse, legt an und prueft sofort', async () => {
|
|
prisma.nextcloudInstance.create.mockResolvedValue({ id: 'i1' });
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://cloud.a.de',
|
|
});
|
|
vi.mocked(fetchNextcloudStatus).mockResolvedValue({
|
|
reachable: true,
|
|
maintenance: false,
|
|
needsDbUpgrade: false,
|
|
versionString: '35.0.1',
|
|
edition: null,
|
|
productName: 'Nextcloud',
|
|
errorKind: null,
|
|
errorDetail: null,
|
|
});
|
|
prisma.nextcloudInstance.update.mockResolvedValue(makeRow());
|
|
const view = await service.createInstance('t1', {
|
|
customerName: ' Kunde A ',
|
|
baseUrl: 'https://cloud.a.de/status.php/',
|
|
});
|
|
expect(prisma.nextcloudInstance.create.mock.calls[0][0].data).toEqual({
|
|
tenantId: 't1',
|
|
customerName: 'Kunde A',
|
|
baseUrl: 'https://cloud.a.de',
|
|
logoUrl: null,
|
|
});
|
|
expect(fetchNextcloudStatus).toHaveBeenCalledWith('https://cloud.a.de');
|
|
expect(view.id).toBe('i1');
|
|
});
|
|
|
|
it('createInstance mit ungueltiger Adresse -> BadRequest mit deutscher Meldung', async () => {
|
|
await expect(
|
|
service.createInstance('t1', { customerName: 'X', baseUrl: 'ftp://x' }),
|
|
).rejects.toThrow(BadRequestException);
|
|
await expect(
|
|
service.createInstance('t1', { customerName: 'X', baseUrl: 'ftp://x' }),
|
|
).rejects.toThrow('Bitte geben Sie eine gültige Adresse mit http:// oder https:// ein.');
|
|
expect(prisma.nextcloudInstance.create).not.toHaveBeenCalled();
|
|
});
|
|
|
|
const FAILED_RESULT = {
|
|
reachable: false,
|
|
maintenance: null,
|
|
needsDbUpgrade: null,
|
|
versionString: null,
|
|
edition: null,
|
|
productName: null,
|
|
errorKind: 'http-status' as const,
|
|
errorDetail: 'HTTP 503',
|
|
};
|
|
|
|
it('checkInstance: zweiter Fehlschlag schreibt alle Statusspalten und den Zaehler 2', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://cloud.a.de',
|
|
consecutiveFailures: 1,
|
|
});
|
|
vi.mocked(fetchNextcloudStatus).mockResolvedValue(FAILED_RESULT);
|
|
prisma.nextcloudInstance.update.mockResolvedValue(
|
|
makeRow({
|
|
reachable: false,
|
|
versionString: null,
|
|
errorKind: 'http-status',
|
|
errorDetail: 'HTTP 503',
|
|
alertState: 'ok',
|
|
}),
|
|
);
|
|
const view = await service.checkInstance('t1', 'i1');
|
|
expect(prisma.nextcloudInstance.findFirst.mock.calls[0][0].where).toEqual({
|
|
id: 'i1',
|
|
tenantId: 't1',
|
|
});
|
|
const args = prisma.nextcloudInstance.update.mock.calls[0][0];
|
|
expect(args.data).toMatchObject({
|
|
reachable: false,
|
|
maintenance: null,
|
|
needsDbUpgrade: null,
|
|
versionString: null,
|
|
edition: null,
|
|
errorKind: 'http-status',
|
|
errorDetail: 'HTTP 503',
|
|
consecutiveFailures: 2,
|
|
});
|
|
expect(args.data.lastCheckedAt).toBeInstanceOf(Date);
|
|
expect(args.select).toMatchObject({ ...PUBLIC_SELECT, alertState: true });
|
|
expect(args.select).not.toHaveProperty('logoData');
|
|
expect(view.rating).toMatchObject({ level: 'red', reason: 'unreachable' });
|
|
// Die Meldung wird nach jeder Pruefung entschieden, mit dem Stand der Zeile
|
|
expect(alerts.evaluateAfterCheck).toHaveBeenCalledTimes(1);
|
|
const [tenant, row, rating] = alerts.evaluateAfterCheck.mock.calls[0];
|
|
expect(tenant).toBe('t1');
|
|
expect(row).toMatchObject({ id: 'i1', alertState: 'ok', errorKind: 'http-status' });
|
|
expect(rating).toMatchObject({ level: 'red', reason: 'unreachable' });
|
|
});
|
|
|
|
it('checkInstance: erster Fehlschlag schreibt nur Zaehler und Zeitpunkt, die Kachel behaelt den guten Stand', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://cloud.a.de',
|
|
consecutiveFailures: 0,
|
|
});
|
|
vi.mocked(fetchNextcloudStatus).mockResolvedValue(FAILED_RESULT);
|
|
// Zeile bleibt im Zustand "gruen", nur der Zaehler steht auf 1
|
|
prisma.nextcloudInstance.update.mockResolvedValue(makeRow({ alertState: 'ok' }));
|
|
const view = await service.checkInstance('t1', 'i1');
|
|
const data = prisma.nextcloudInstance.update.mock.calls[0][0].data;
|
|
expect(Object.keys(data).sort()).toEqual(['consecutiveFailures', 'firstFailureAt']);
|
|
expect(data.consecutiveFailures).toBe(1);
|
|
expect(view.rating).toMatchObject({ level: 'green', reason: 'current' });
|
|
});
|
|
|
|
it('checkInstance: eine Stoerung der Meldung verwirft das Pruefergebnis nicht', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://cloud.a.de',
|
|
consecutiveFailures: 0,
|
|
});
|
|
vi.mocked(fetchNextcloudStatus).mockResolvedValue({
|
|
...FAILED_RESULT,
|
|
reachable: true,
|
|
} as never);
|
|
prisma.nextcloudInstance.update.mockResolvedValue(makeRow({ alertState: 'ok' }));
|
|
alerts.evaluateAfterCheck.mockRejectedValue(new Error('db weg'));
|
|
vi.spyOn((service as any).logger, 'error').mockImplementation(() => undefined);
|
|
const view = await service.checkInstance('t1', 'i1');
|
|
expect(view.id).toBe('i1');
|
|
});
|
|
|
|
it('listForTenant liefert subscribed je Cloud nur fuer die Abonnements des Benutzers', async () => {
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([makeRow(), makeRow({ id: 'i2' })]);
|
|
alerts.subscribedInstanceIds.mockResolvedValue(new Set(['i2']));
|
|
const result = await service.listForTenant('t1', 'u1');
|
|
expect(alerts.subscribedInstanceIds).toHaveBeenCalledWith('t1', 'u1');
|
|
expect(result.instances.map((i) => [i.id, i.subscribed])).toEqual([
|
|
['i1', false],
|
|
['i2', true],
|
|
]);
|
|
});
|
|
|
|
it('checkInstance fuer unbekannte Kennung -> NotFound, kein Abruf', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue(null);
|
|
await expect(service.checkInstance('t1', 'nix')).rejects.toThrow(NotFoundException);
|
|
expect(fetchNextcloudStatus).not.toHaveBeenCalled();
|
|
});
|
|
describe('Schreibwege (Aufgabe 2)', () => {
|
|
const OK_RESULT = {
|
|
reachable: true,
|
|
maintenance: false,
|
|
needsDbUpgrade: false,
|
|
versionString: '35.0.1',
|
|
edition: null,
|
|
productName: null,
|
|
errorKind: null,
|
|
errorDetail: null,
|
|
};
|
|
|
|
beforeEach(() => {
|
|
prisma.nextcloudInstance.delete = vi.fn();
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://cloud.a.de',
|
|
});
|
|
prisma.nextcloudInstance.update.mockResolvedValue(makeRow());
|
|
vi.mocked(fetchNextcloudStatus).mockResolvedValue(OK_RESULT);
|
|
});
|
|
|
|
it('updateInstance: nur Name -> kein Neuabruf', async () => {
|
|
await service.updateInstance('t1', 'i1', { customerName: ' Neu ' });
|
|
expect(prisma.nextcloudInstance.update.mock.calls[0][0].data).toEqual({
|
|
customerName: 'Neu',
|
|
});
|
|
expect(fetchNextcloudStatus).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('updateInstance: neue Adresse wird normalisiert, setzt den Pruefstand zurueck (alertState bleibt) und prueft neu, unveraenderte nicht', async () => {
|
|
await service.updateInstance('t1', 'i1', { baseUrl: 'https://neu.example.de/index.php/' });
|
|
const data = prisma.nextcloudInstance.update.mock.calls[0][0].data;
|
|
expect(data).toEqual({
|
|
baseUrl: 'https://neu.example.de',
|
|
reachable: null,
|
|
maintenance: null,
|
|
needsDbUpgrade: null,
|
|
versionString: null,
|
|
edition: null,
|
|
productName: null,
|
|
errorKind: null,
|
|
errorDetail: null,
|
|
lastCheckedAt: null,
|
|
consecutiveFailures: 0,
|
|
firstFailureAt: null,
|
|
});
|
|
expect(data).not.toHaveProperty('alertState');
|
|
expect(data).not.toHaveProperty('alertReason');
|
|
expect(fetchNextcloudStatus).toHaveBeenCalledTimes(1);
|
|
|
|
vi.mocked(fetchNextcloudStatus).mockClear();
|
|
await service.updateInstance('t1', 'i1', { baseUrl: 'https://cloud.a.de/' });
|
|
expect(fetchNextcloudStatus).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('updateInstance: rote Cloud, korrigierte Adresse antwortet gruen -> Meldung "wieder in Ordnung" wird entschieden', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
id: 'i1',
|
|
baseUrl: 'https://kaputt.example.de',
|
|
consecutiveFailures: 0,
|
|
});
|
|
prisma.nextcloudInstance.update.mockResolvedValue(makeRow({ alertState: 'red' }));
|
|
await service.updateInstance('t1', 'i1', { baseUrl: 'https://cloud.a.de' });
|
|
expect(alerts.evaluateAfterCheck).toHaveBeenCalledTimes(1);
|
|
const [, row, rating] = alerts.evaluateAfterCheck.mock.calls[0];
|
|
expect(row.alertState).toBe('red');
|
|
expect(rating).toMatchObject({ level: 'green', reason: 'current' });
|
|
});
|
|
|
|
it('updateInstance: ungueltige Adresse -> BadRequest', async () => {
|
|
await expect(service.updateInstance('t1', 'i1', { baseUrl: 'javascript:1' })).rejects.toThrow(
|
|
BadRequestException,
|
|
);
|
|
});
|
|
|
|
it('updateInstance: nicht leere Logo-Adresse ersetzt den Upload, leere entfernt nur die Adresse', async () => {
|
|
await service.updateInstance('t1', 'i1', { logoUrl: 'https://logo.example.de/a.png' });
|
|
expect(prisma.nextcloudInstance.update.mock.calls[0][0].data).toEqual({
|
|
logoUrl: 'https://logo.example.de/a.png',
|
|
logoData: null,
|
|
logoMime: null,
|
|
logoVersion: { increment: 1 },
|
|
});
|
|
await service.updateInstance('t1', 'i1', { logoUrl: '' });
|
|
expect(prisma.nextcloudInstance.update.mock.calls[1][0].data).toEqual({
|
|
logoUrl: null,
|
|
logoVersion: { increment: 1 },
|
|
});
|
|
});
|
|
|
|
it('uploadLogo speichert Bytes und erkannten Typ, entfernt die Adresse und erhoeht die Version', async () => {
|
|
const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2]);
|
|
await service.uploadLogo('t1', 'i1', {
|
|
buffer: png,
|
|
originalname: 'x.exe',
|
|
mimetype: 'text/html',
|
|
size: png.length,
|
|
});
|
|
const data = prisma.nextcloudInstance.update.mock.calls[0][0].data;
|
|
expect(Buffer.from(data.logoData)).toEqual(png);
|
|
expect(data).toMatchObject({
|
|
logoMime: 'image/png',
|
|
logoUrl: null,
|
|
logoVersion: { increment: 1 },
|
|
});
|
|
expect(prisma.nextcloudInstance.update.mock.calls[0][0].select).toBe(PUBLIC_SELECT);
|
|
});
|
|
|
|
it('uploadLogo lehnt Nicht-Bilder, fehlende Dateien und fremde Kennungen ab', async () => {
|
|
const html = Buffer.from('<html></html>');
|
|
await expect(
|
|
service.uploadLogo('t1', 'i1', {
|
|
buffer: html,
|
|
originalname: 'a.png',
|
|
mimetype: 'image/png',
|
|
size: html.length,
|
|
}),
|
|
).rejects.toThrow(
|
|
'Bitte laden Sie ein Bild im Format PNG, JPEG, GIF oder WebP bis 1 MB hoch.',
|
|
);
|
|
await expect(service.uploadLogo('t1', 'i1', undefined)).rejects.toThrow(BadRequestException);
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue(null);
|
|
const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
|
|
await expect(
|
|
service.uploadLogo('t1', 'fremd', {
|
|
buffer: png,
|
|
originalname: 'a.png',
|
|
mimetype: 'image/png',
|
|
size: png.length,
|
|
}),
|
|
).rejects.toThrow(NotFoundException);
|
|
expect(prisma.nextcloudInstance.update).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('removeLogo loescht Bytes und Typ und erhoeht die Version', async () => {
|
|
await service.removeLogo('t1', 'i1');
|
|
expect(prisma.nextcloudInstance.update.mock.calls[0][0].data).toEqual({
|
|
logoData: null,
|
|
logoMime: null,
|
|
logoVersion: { increment: 1 },
|
|
});
|
|
});
|
|
|
|
it('getLogo liefert Bytes und Typ, ohne Logo NotFound', async () => {
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({
|
|
logoData: new Uint8Array([1, 2, 3]),
|
|
logoMime: 'image/png',
|
|
});
|
|
const logo = await service.getLogo('t1', 'i1');
|
|
expect(logo.mime).toBe('image/png');
|
|
expect([...logo.data]).toEqual([1, 2, 3]);
|
|
expect(prisma.nextcloudInstance.findFirst.mock.calls[0][0].where).toEqual({
|
|
id: 'i1',
|
|
tenantId: 't1',
|
|
});
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue({ logoData: null, logoMime: null });
|
|
await expect(service.getLogo('t1', 'i1')).rejects.toThrow(NotFoundException);
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue(null);
|
|
await expect(service.getLogo('t1', 'x')).rejects.toThrow(NotFoundException);
|
|
});
|
|
|
|
it('deleteInstance loescht die Zeile; fremde Kennung -> NotFound', async () => {
|
|
expect(await service.deleteInstance('t1', 'i1')).toBe(true);
|
|
expect(prisma.nextcloudInstance.delete).toHaveBeenCalledWith({ where: { id: 'i1' } });
|
|
prisma.nextcloudInstance.findFirst.mockResolvedValue(null);
|
|
await expect(service.deleteInstance('t1', 'fremd')).rejects.toThrow(NotFoundException);
|
|
expect(prisma.nextcloudInstance.delete).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('checkAllForTenant prueft alle mit hoechstens vier gleichzeitig und liefert die frische Liste', async () => {
|
|
const ids = Array.from({ length: 10 }, (_, i) => `i${i}`);
|
|
prisma.nextcloudInstance.findMany.mockImplementation(
|
|
async (args: { select: Record<string, boolean> }) =>
|
|
args.select.id && Object.keys(args.select).length === 1
|
|
? ids.map((id) => ({ id }))
|
|
: [makeRow()],
|
|
);
|
|
prisma.nextcloudInstance.findFirst.mockImplementation(
|
|
async ({ where }: { where: { id: string } }) => ({
|
|
id: where.id,
|
|
baseUrl: 'https://cloud.a.de',
|
|
}),
|
|
);
|
|
let inFlight = 0;
|
|
let peak = 0;
|
|
vi.mocked(fetchNextcloudStatus).mockImplementation(async () => {
|
|
inFlight++;
|
|
peak = Math.max(peak, inFlight);
|
|
await new Promise((r) => setTimeout(r, 5));
|
|
inFlight--;
|
|
return OK_RESULT;
|
|
});
|
|
const result = await service.checkAllForTenant('t1', 'u1');
|
|
expect(fetchNextcloudStatus).toHaveBeenCalledTimes(10);
|
|
expect(peak).toBeLessThanOrEqual(4);
|
|
expect(peak).toBeGreaterThan(1);
|
|
expect(result.instances).toHaveLength(1);
|
|
});
|
|
|
|
it('checkAllForTenant: eine fehlerhafte Cloud stoppt die anderen nicht', async () => {
|
|
prisma.nextcloudInstance.findMany.mockImplementation(
|
|
async (args: { select: Record<string, boolean> }) =>
|
|
Object.keys(args.select).length === 1 ? [{ id: 'a' }, { id: 'b' }] : [],
|
|
);
|
|
prisma.nextcloudInstance.findFirst.mockImplementation(
|
|
async ({ where }: { where: { id: string } }) =>
|
|
where.id === 'a' ? null : { id: where.id, baseUrl: 'https://cloud.a.de' },
|
|
);
|
|
await service.checkAllForTenant('t1', 'u1');
|
|
expect(fetchNextcloudStatus).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('loadAllInstancesForScheduler waehlt nur Kennung und Mandant ueber forSystem', async () => {
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([{ id: 'i1', tenantId: 't1' }]);
|
|
const rows = await service.loadAllInstancesForScheduler();
|
|
expect(forSystem).toHaveBeenCalledWith(prisma);
|
|
expect(prisma.nextcloudInstance.findMany).toHaveBeenCalledWith({
|
|
select: { id: true, tenantId: true },
|
|
});
|
|
expect(rows).toEqual([{ id: 'i1', tenantId: 't1' }]);
|
|
});
|
|
|
|
it('loadAllInstancesForScheduler mit retryDueBefore filtert auf genau einen Fehlschlag, Select bleibt Kennung und Mandant', async () => {
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([{ id: 'i1', tenantId: 't1' }]);
|
|
const due = new Date('2026-10-02T12:00:00Z');
|
|
await service.loadAllInstancesForScheduler({ retryDueBefore: due });
|
|
expect(prisma.nextcloudInstance.findMany).toHaveBeenCalledWith({
|
|
where: { consecutiveFailures: 1, firstFailureAt: { lte: due } },
|
|
select: { id: true, tenantId: true },
|
|
});
|
|
});
|
|
|
|
it('pendingRetry ist genau bei einem Fehlschlag wahr', async () => {
|
|
prisma.nextcloudInstance.findMany.mockResolvedValue([
|
|
makeRow({ id: 'a', consecutiveFailures: 0 }),
|
|
makeRow({ id: 'b', consecutiveFailures: 1 }),
|
|
makeRow({ id: 'c', consecutiveFailures: 2 }),
|
|
]);
|
|
const result = await service.listForTenant('t1', 'u1');
|
|
expect(result.instances.map((i) => i.status.pendingRetry)).toEqual([false, true, false]);
|
|
});
|
|
});
|
|
});
|