Sessie: een start-refresh zonder oordeel (429/5xx/netwerk) zet de gebruiker niet meer op gast maar toont een retry-scherm; Retry-After wordt gestuurd en gerespecteerd

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-09 21:04:49 +01:00
co-authored by Claude Sonnet 5.5
parent b8f6b25121
commit 64a467b41b
12 changed files with 297 additions and 12 deletions
@@ -0,0 +1,52 @@
import { describe, expect, it } from 'vitest';
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { http, HttpResponse } from 'msw';
import { I18nextProvider } from 'react-i18next';
import type { ReactNode } from 'react';
import { AuthProvider } from '@/features/auth/context/AuthProvider';
import { useAuth } from '@/features/auth/context/auth-context';
import { SessionUnreachable } from '@/features/auth/components/SessionUnreachable';
import { server } from '@/mocks/server';
import { API_BASE, makeAuthResponse } from '@/features/auth/mocks/fixtures';
import { refreshBackoff } from '@/lib/refreshPolicy';
import i18n from '@/i18n/config';
function Probe() {
const { status } = useAuth();
return status === 'unreachable' ? <SessionUnreachable /> : <p data-testid="status">{status}</p>;
}
function Wrapper({ children }: { children: ReactNode }) {
return (
<I18nextProvider i18n={i18n}>
<AuthProvider>{children}</AuthProvider>
</I18nextProvider>
);
}
describe('SessionUnreachable', () => {
it('offers a retry that signs the visitor in once the server answers again', async () => {
const original = [...refreshBackoff.delays];
refreshBackoff.delays = [5];
try {
let down = true;
server.use(
http.post(`${API_BASE}/api/v1/auth/refresh`, () =>
down ? HttpResponse.json({ status: 429 }, { status: 429 }) : HttpResponse.json(makeAuthResponse()),
),
);
render(<Probe />, { wrapper: Wrapper });
const retry = await screen.findByTestId('session-unreachable-retry');
await userEvent.click(retry); // still down
expect(await screen.findByTestId('session-unreachable-failed')).toBeInTheDocument();
down = false;
await userEvent.click(screen.getByTestId('session-unreachable-retry'));
await waitFor(() => expect(screen.getByTestId('status')).toHaveTextContent('authenticated'));
} finally {
refreshBackoff.delays = original;
}
});
});
@@ -0,0 +1,49 @@
import { useState } from 'react';
import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
import { useAuth } from '@/features/auth/context/auth-context';
/**
* Shown when the start-up refresh could not get a verdict (rate limit, restart, network). The visitor is not signed
* out - the cookie is intact - so this offers a retry instead of the login page.
*/
export function SessionUnreachable() {
const { t } = useTranslation();
const { refresh } = useAuth();
const [busy, setBusy] = useState(false);
const [failedAgain, setFailedAgain] = useState(false);
const retry = async () => {
setBusy(true);
setFailedAgain(false);
try {
await refresh(); // success -> authenticated, a rejected cookie -> guest; this screen then goes away
} catch {
setFailedAgain(true);
} finally {
setBusy(false);
}
};
return (
<div className="flex min-h-svh items-center justify-center bg-secondary/40 p-4" data-testid="session-unreachable">
<Card className="w-full max-w-sm">
<CardHeader>
<CardTitle>{t('session.unreachable.title')}</CardTitle>
<CardDescription>{t('session.unreachable.description')}</CardDescription>
</CardHeader>
<CardContent className="space-y-3">
{failedAgain && (
<p role="alert" className="text-sm text-destructive" data-testid="session-unreachable-failed">
{t('session.unreachable.stillFailing')}
</p>
)}
<Button onClick={() => void retry()} disabled={busy} data-testid="session-unreachable-retry">
{busy ? t('common.loading') : t('session.unreachable.retry')}
</Button>
</CardContent>
</Card>
</div>
);
}
@@ -113,7 +113,7 @@ describe('AuthContext', () => {
expect(calls).toBe(3);
});
it('falls back to guest (without a verdict on the cookie) after the last retry', async () => {
it('ends in the unreachable state (not guest) after the last retry: no verdict on the session', async () => {
let calls = 0;
server.use(
http.post(`${API_BASE}/api/v1/auth/refresh`, () => {
@@ -124,10 +124,74 @@ describe('AuthContext', () => {
const { result } = renderHook(() => useAuth(), { wrapper });
await waitFor(() => expect(result.current.status).toBe('guest'));
await waitFor(() => expect(result.current.status).toBe('unreachable'));
expect(result.current.isAuthenticated).toBe(false);
expect(calls).toBe(1 + refreshBackoff.delays.length);
});
it('respects Retry-After on a 429 (waits at least that long before the next try)', async () => {
const stamps: number[] = [];
server.use(
http.post(`${API_BASE}/api/v1/auth/refresh`, () => {
stamps.push(Date.now());
if (stamps.length === 1) {
return HttpResponse.json({ status: 429 }, { status: 429, headers: { 'Retry-After': '0.3' } });
}
return HttpResponse.json(makeAuthResponse());
}),
);
const { result } = renderHook(() => useAuth(), { wrapper });
await waitFor(() => expect(result.current.status).toBe('authenticated'), { timeout: 3000 });
expect(stamps[1] - stamps[0]).toBeGreaterThanOrEqual(280); // the planned backoff is only 5 ms
});
it('recovers from the unreachable state through refresh(), without ever having been a guest', async () => {
let down = true;
server.use(
http.post(`${API_BASE}/api/v1/auth/refresh`, () =>
down ? HttpResponse.json({ status: 503 }, { status: 503 }) : HttpResponse.json(makeAuthResponse()),
),
);
const seen: string[] = [];
const { result } = renderHook(
() => {
const a = useAuth();
seen.push(a.status);
return a;
},
{ wrapper },
);
await waitFor(() => expect(result.current.status).toBe('unreachable'));
down = false;
await act(async () => {
await result.current.refresh();
});
expect(result.current.status).toBe('authenticated');
expect(seen).not.toContain('guest');
});
it('a 401 verdict on the retry still ends in guest', async () => {
let first = true;
server.use(
http.post(`${API_BASE}/api/v1/auth/refresh`, () =>
first ? HttpResponse.json({ status: 503 }, { status: 503 }) : HttpResponse.json({ status: 401 }, { status: 401 }),
),
);
const { result } = renderHook(() => useAuth(), { wrapper });
await waitFor(() => expect(result.current.status).toBe('unreachable'));
first = false;
await act(async () => {
await result.current.refresh();
});
expect(result.current.status).toBe('guest');
});
it('does not retry when the server rejects the cookie (401)', async () => {
let calls = 0;
server.use(
@@ -1,7 +1,7 @@
import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
import type { AuthResponse } from '@/features/auth/services/types';
import { api } from '@/lib/api-client';
import { isAuthRejection, refreshBackoff } from '@/lib/refreshPolicy';
import { isAuthRejection, nextRetryDelay, refreshBackoff } from '@/lib/refreshPolicy';
import { changeLanguage } from '@/i18n/config';
import { AuthContext, type AuthContextValue, type AuthStatus } from '@/features/auth/context/auth-context';
@@ -113,8 +113,9 @@ export function AuthProvider({ children }: { children: ReactNode }) {
// Silent refresh on app mount (BR-U1-01). This intentionally synchronizes
// React state with the external session (httpOnly cookie) on startup.
// A transient failure (429, 502 during a restart, network) is retried a few times with a backoff; if it
// still fails the visitor is a guest for now, and the refresh cookie is untouched so a reload can recover.
// A transient failure (429, 502 during a restart, network) is retried a few times with a backoff (longer when the
// server sends Retry-After). If it still fails there is no verdict on the session: the status becomes
// 'unreachable' (a retry screen), NOT 'guest', and the refresh cookie is untouched.
useEffect(() => {
let cancelled = false;
void (async () => {
@@ -123,18 +124,18 @@ export function AuthProvider({ children }: { children: ReactNode }) {
try {
await refresh();
return;
} catch {
} catch (err) {
if (cancelled || attempt >= delays.length) break;
await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
await new Promise((resolve) => setTimeout(resolve, nextRetryDelay(err, delays[attempt])));
if (cancelled) return;
}
}
if (!cancelled) clearSession();
if (!cancelled) setStatus('unreachable');
})();
return () => {
cancelled = true;
};
}, [refresh, clearSession]);
}, [refresh]);
const value = useMemo<AuthContextValue>(
() => ({
@@ -1,7 +1,12 @@
import { createContext, useContext } from 'react';
import type { User } from '@/features/auth/services/types';
export type AuthStatus = 'loading' | 'authenticated' | 'guest';
/**
* 'unreachable': the start-up refresh could not get a verdict (rate limit, restart, network) after the quiet retries.
* The session is neither confirmed nor ended - the refresh cookie is untouched - so the app offers a retry
* instead of treating the visitor as signed out.
*/
export type AuthStatus = 'loading' | 'authenticated' | 'guest' | 'unreachable';
export interface AuthContextValue {
status: AuthStatus;
@@ -20,6 +20,14 @@
"switchToLight": "Switch to light theme",
"switchToDark": "Switch to dark theme"
},
"session": {
"unreachable": {
"title": "Could not check your session",
"description": "The server is briefly unreachable or busy. You have not been signed out. Try again in a few seconds.",
"retry": "Try again",
"stillFailing": "Still no answer. Wait a moment and try again."
}
},
"login": {
"title": "Sign in",
"subtitle": "Sign in to your SlpModularCms account",
@@ -20,6 +20,14 @@
"switchToLight": "Overschakelen naar licht thema",
"switchToDark": "Overschakelen naar donker thema"
},
"session": {
"unreachable": {
"title": "Sessie kon niet worden gecontroleerd",
"description": "De server is even niet bereikbaar of te druk. Je bent niet uitgelogd. Probeer het over een paar seconden opnieuw.",
"retry": "Opnieuw proberen",
"stillFailing": "Nog steeds geen antwoord. Wacht even en probeer opnieuw."
}
},
"login": {
"title": "Inloggen",
"subtitle": "Log in op je SlpModularCms-account",
+12 -2
View File
@@ -22,12 +22,15 @@ export type ApiResult<T> = { ok: true; data: T } | { ok: false; error: ProblemDe
export class ProblemDetailsError extends Error {
readonly status: number;
readonly problem: ProblemDetails;
/** From the Retry-After header (seconds), in milliseconds; undefined when the server did not say. */
readonly retryAfterMs?: number;
constructor(status: number, problem: ProblemDetails) {
constructor(status: number, problem: ProblemDetails, retryAfterMs?: number) {
super(problem.title ?? problem.detail ?? `Request failed with status ${status}`);
this.name = 'ProblemDetailsError';
this.status = status;
this.problem = problem;
this.retryAfterMs = retryAfterMs;
}
}
@@ -155,13 +158,20 @@ export class ApiClient {
const problem: ProblemDetails = isProblemDetails(data)
? data
: { status: response.status, title: response.statusText };
throw new ProblemDetailsError(response.status, problem);
throw new ProblemDetailsError(response.status, problem, parseRetryAfter(response.headers.get('Retry-After')));
}
return data as T;
}
}
/** Retry-After as delay-seconds (the only form a rate limiter sends); anything else is ignored. */
function parseRetryAfter(value: string | null): number | undefined {
if (value === null) return undefined;
const seconds = Number(value);
return Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1000) : undefined;
}
function safeJsonParse(text: string): unknown {
try {
return JSON.parse(text);
+9
View File
@@ -11,3 +11,12 @@ export const refreshBackoff = { delays: [400, 1200, 2500] as number[] };
export function isAuthRejection(error: unknown): boolean {
return error instanceof ProblemDetailsError && (error.status === 400 || error.status === 401 || error.status === 403);
}
/** Longest a server's Retry-After is honoured at start-up; a longer wait is left to the visitor's retry button. */
export const maxRetryAfterMs = 15000;
/** How long to wait before the next quiet start-up retry: the planned backoff, or the server's Retry-After if longer. */
export function nextRetryDelay(error: unknown, planned: number): number {
const asked = error instanceof ProblemDetailsError ? error.retryAfterMs : undefined;
return asked === undefined ? planned : Math.max(planned, Math.min(asked, maxRetryAfterMs));
}
+4
View File
@@ -8,6 +8,7 @@ import '@theme';
import './i18n/config';
import { AuthProvider } from '@/features/auth/context/AuthProvider';
import { useAuth } from '@/features/auth/context/auth-context';
import { SessionUnreachable } from '@/features/auth/components/SessionUnreachable';
import { Toaster } from '@/components/ui/sonner';
import { router } from '@/router';
import { getAppConfig } from '@/lib/config';
@@ -44,6 +45,9 @@ function InnerApp() {
if (auth.status === 'loading') {
return <BootstrapSplash />;
}
if (auth.status === 'unreachable') {
return <SessionUnreachable />;
}
return <RouterProvider router={router} context={{ auth }} />;
}
@@ -0,0 +1,52 @@
using System.Net;
using FluentAssertions;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using SlpModularCms.Core.Hosting;
namespace SlpModularCms.Core.Tests.Hosting;
/// <summary>A rate-limited call says how long to wait (Retry-After), so the admin app's start-up retries do not hammer the same window.</summary>
public class RateLimitRetryAfterTests
{
[Fact]
public async Task ARejectedCall_Is429_WithARetryAfterInWholeSeconds()
{
var config = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
{
["RateLimiting:Refresh:PermitLimit"] = "1",
["RateLimiting:Refresh:WindowSeconds"] = "60"
}).Build();
using var host = await new HostBuilder().ConfigureWebHost(web =>
{
web.UseTestServer();
web.ConfigureServices(s =>
{
s.AddLogging();
s.AddRouting();
s.AddCmsRateLimiting(config);
});
web.Configure(app =>
{
app.UseRouting();
app.UseRateLimiter();
app.UseEndpoints(e => e.MapPost("/refresh", () => "ok").RequireRateLimiting("refresh"));
});
}).StartAsync();
var client = host.GetTestClient();
(await client.PostAsync("/refresh", null)).StatusCode.Should().Be(HttpStatusCode.OK);
var rejected = await client.PostAsync("/refresh", null);
rejected.StatusCode.Should().Be(HttpStatusCode.TooManyRequests);
rejected.Headers.RetryAfter.Should().NotBeNull();
rejected.Headers.RetryAfter!.Delta!.Value.TotalSeconds.Should().BeGreaterThanOrEqualTo(1).And.BeLessThanOrEqualTo(60);
}
}
@@ -183,6 +183,29 @@ public static class ServiceCollectionExtensions
.GetMetadata<EnableRateLimitingAttribute>()?.PolicyName ?? "(unknown)",
context.HttpContext.Request.Path);
// Tells a well-behaved client (the admin app's start-up retries) how long to wait, instead of
// having it retry into the same window and stay limited.
// A sliding-window lease carries no RetryAfter, so the "refresh" policy falls back to one segment
// (a quarter of the window: the earliest moment a permit frees up); other policies to their window.
var policyName = context.HttpContext.GetEndpoint()?.Metadata.GetMetadata<EnableRateLimitingAttribute>()?.PolicyName;
var section = policyName switch
{
"login" => "Login",
"refresh" => "Refresh",
_ => null
};
double? waitSeconds = null;
if (context.Lease.TryGetMetadata(MetadataName.RetryAfter, out var retryAfter))
waitSeconds = retryAfter.TotalSeconds;
else if (section is not null)
{
var window = configuration.GetValue<int>($"RateLimiting:{section}:WindowSeconds", 60);
waitSeconds = policyName == "refresh" ? window / 4.0 : window;
}
if (waitSeconds is not null)
context.HttpContext.Response.Headers.RetryAfter =
Math.Max(1, (int)Math.Ceiling(waitSeconds.Value)).ToString(System.Globalization.CultureInfo.InvariantCulture);
return ValueTask.CompletedTask;
};