@griddo/ax 12.6.1 → 12.6.2

package/src/__tests__/store/domains.test.ts

@@ -1,107 +0,0 @@
-import { domains } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { domainsActions, domainsReducer } from "@ax/containers/Domains";
-import type { IDomainRobot } from "@ax/types";
-
-import { configureStore } from "@reduxjs/toolkit";
-import type { MockInstance } from "vitest";
-
-/**
- * Characterisation tests for the `domains` area — the robots.txt editor behind
- * `/settings/robots`, migrated to Redux Toolkit in wave 1.
- *
- * Written against the PUBLIC surface (the store and the two exported thunks),
- * never against reducer internals or action type constants, so this file must
- * keep passing unchanged once the area becomes a slice. If it needs an edit,
- * the shape changed and that is a finding, not an adjustment.
- *
- * It needed exactly one, and it is the finding: `dispatch(thunk())` used to
- * resolve to `handleRequest`'s boolean, while a createAsyncThunk resolves to the
- * fulfilled action and hands the value over through `.unwrap()`. Nothing about the
- * behaviour moved — the requests, the resulting state and the error channel below
- * are untouched — but every caller that reads the result of a write has to unwrap
- * it. That is the 457-call-site item in docs/RTK-MIGRATION.md §5.
- */
-
-const ROBOT: IDomainRobot = {
-	id: 1,
-	path: "/",
-	fullUrl: "https://www.example.edu/",
-	content: "User-agent: *",
-	computedContent: "User-agent: *\nSitemap: /sitemap.xml",
-};
-const OTHER: IDomainRobot = { ...ROBOT, id: 2, path: "/es", fullUrl: "https://www.example.edu/es" };
-
-// Mirrors how GlobalStore mounts this area, minus persistence.
-const makeStore = () => configureStore({ reducer: { domains: domainsReducer } });
-type Store = ReturnType<typeof makeStore>;
-const robotsOf = (store: Store) => (store.getState() as { domains: { robots: IDomainRobot[] } }).domains.robots;
-
-describe("[UC-AX-configure-seo-analytics] domains state", () => {
-	let store: Store;
-	let handleError: MockInstance;
-
-	beforeEach(() => {
-		store = makeStore();
-		handleError = vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("AC7 · starts with no robots", () => {
-		expect(robotsOf(store)).toEqual([]);
-	});
-
-	it("AC7 · loading keeps one entry per robot received", async () => {
-		vi.spyOn(domains, "getDomainsRobots").mockResolvedValue({ status: 200, data: [ROBOT, OTHER] } as never);
-
-		await store.dispatch(domainsActions.getDomainsRobots());
-
-		expect(robotsOf(store)).toEqual([ROBOT, OTHER]);
-	});
-
-	it("AC7 · a failed load routes through the error channel and leaves the list untouched", async () => {
-		vi.spyOn(domains, "getDomainsRobots").mockResolvedValue({ status: 500, data: {} } as never);
-
-		await store.dispatch(domainsActions.getDomainsRobots());
-
-		expect(handleError).toHaveBeenCalled();
-		expect(robotsOf(store)).toEqual([]);
-	});
-
-	it("AC1 · saving puts the edited robots and reloads the list from the server", async () => {
-		const edited = { ...ROBOT, content: "User-agent: *\nDisallow: /admin" };
-		const update = vi.spyOn(domains, "updateDomainsRobots").mockResolvedValue({ status: 200, data: {} } as never);
-		const reload = vi.spyOn(domains, "getDomainsRobots").mockResolvedValue({ status: 200, data: [edited] } as never);
-
-		const saved = await store.dispatch(domainsActions.updateDomainsRobots([edited])).unwrap();
-
-		expect(update).toHaveBeenCalledWith([edited]);
-		expect(reload).toHaveBeenCalled();
-		expect(saved).toBe(true);
-		expect(robotsOf(store)).toEqual([edited]);
-	});
-
-	it("AC8 · a save failing with several messages reports the count and does not reload", async () => {
-		const response = { status: 400, data: { message: ["bad path", "bad content", "bad domain"] } };
-		vi.spyOn(domains, "updateDomainsRobots").mockResolvedValue(response as never);
-		const reload = vi.spyOn(domains, "getDomainsRobots").mockResolvedValue({ status: 200, data: [] } as never);
-
-		const saved = await store.dispatch(domainsActions.updateDomainsRobots([ROBOT])).unwrap();
-
-		expect(handleError).toHaveBeenCalledWith(response, true, "The action failed due to 3 errors.");
-		expect(reload).not.toHaveBeenCalled();
-		expect(saved).toBe(false);
-	});
-
-	it("AC8 · a save failing with a single message goes through the standard error channel", async () => {
-		const response = { status: 400, data: { message: ["bad path"] } };
-		vi.spyOn(domains, "updateDomainsRobots").mockResolvedValue(response as never);
-
-		await store.dispatch(domainsActions.updateDomainsRobots([ROBOT]));
-
-		expect(handleError).toHaveBeenCalledWith(response, false, undefined);
-	});
-});

package/src/__tests__/store/languages.test.ts

@@ -1,129 +0,0 @@
-import { languages } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { languagesActions, languagesReducer } from "@ax/containers/Settings";
-import { sitesActions } from "@ax/containers/Sites";
-import type { ISiteLanguage } from "@ax/types";
-
-import { configureStore } from "@reduxjs/toolkit";
-import type { MockInstance } from "vitest";
-
-/**
- * Characterisation tests for the `languages` area — the pilot of the Redux
- * Toolkit migration.
- *
- * The state ones are written against the PUBLIC surface (the store and the
- * exported action creators), never against reducer internals or action type
- * constants, so this exact file kept passing unchanged when the area went from
- * `actions.tsx + reducer.tsx + constants.tsx` to `createSlice`. That is the
- * point: it is the regression net for the migration, not a description of the
- * current implementation.
- */
-
-const ES: ISiteLanguage = { language: 3, path: "/es", domain: 7, isDefault: true };
-const SITE_ID = 42;
-
-// Mirrors how GlobalStore mounts this area, minus persistence.
-const makeStore = () => configureStore({ reducer: { languages: languagesReducer } });
-type Store = ReturnType<typeof makeStore>;
-const formOf = (store: Store) => (store.getState() as { languages: { form: ISiteLanguage } }).languages.form;
-
-describe("[UC-AX-manage-languages] languages state", () => {
-	let store: Store;
-
-	beforeEach(() => {
-		store = makeStore();
-	});
-
-	it("AC2 · starts with an empty form", () => {
-		expect(formOf(store)).toEqual({ language: null, path: "", domain: null, isDefault: false });
-	});
-
-	it("AC3 · setForm replaces the whole form with the given language", () => {
-		store.dispatch(languagesActions.setForm(ES));
-
-		expect(formOf(store)).toEqual(ES);
-	});
-
-	it("AC2 · updateFormValue merges one field and keeps the rest", () => {
-		store.dispatch(languagesActions.setForm(ES));
-
-		store.dispatch(languagesActions.updateFormValue({ path: "/es-ES" }));
-
-		expect(formOf(store)).toEqual({ ...ES, path: "/es-ES" });
-	});
-
-	it("AC2 · updateFormValue applied twice accumulates both fields", () => {
-		store.dispatch(languagesActions.updateFormValue({ language: 3 }));
-		store.dispatch(languagesActions.updateFormValue({ path: "/es" }));
-
-		expect(formOf(store)).toEqual({ language: 3, path: "/es", domain: null, isDefault: false });
-	});
-
-	it("AC3 · resetForm brings the form back to its initial state", () => {
-		store.dispatch(languagesActions.setForm(ES));
-
-		store.dispatch(languagesActions.resetForm());
-
-		expect(formOf(store)).toEqual({ language: null, path: "", domain: null, isDefault: false });
-	});
-
-	it("AC2 · keeps isDefault false unless it is set explicitly", () => {
-		store.dispatch(languagesActions.updateFormValue({ path: "/en" }));
-
-		expect(formOf(store).isDefault).toBe(false);
-	});
-});
-
-describe("[UC-AX-manage-languages] languages writes", () => {
-	let store: Store;
-	let refresh: MockInstance;
-
-	const ok = { status: 200, data: {} };
-
-	beforeEach(() => {
-		store = makeStore();
-		// The list belongs to `sites`, so every write refreshes through this thunk.
-		refresh = vi.spyOn(sitesActions, "getSiteLanguages").mockReturnValue((() => Promise.resolve()) as never);
-		vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("AC5 · creating posts the form and reloads the list", async () => {
-		const create = vi.spyOn(languages, "createSiteLanguage").mockResolvedValue(ok as never);
-
-		await store.dispatch(languagesActions.createSiteLanguage({ siteID: SITE_ID, data: ES }));
-
-		expect(create).toHaveBeenCalledWith(SITE_ID, ES);
-		expect(refresh).toHaveBeenCalledWith(SITE_ID);
-	});
-
-	it("AC5 · updating puts the form and reloads the list", async () => {
-		const update = vi.spyOn(languages, "updateSiteLanguage").mockResolvedValue(ok as never);
-
-		await store.dispatch(languagesActions.updateSiteLanguage({ siteID: SITE_ID, data: ES }));
-
-		expect(update).toHaveBeenCalledWith(SITE_ID, ES);
-		expect(refresh).toHaveBeenCalledWith(SITE_ID);
-	});
-
-	it("AC6 · deleting removes the language and reloads the list", async () => {
-		const remove = vi.spyOn(languages, "deleteSiteLanguage").mockResolvedValue(ok as never);
-
-		await store.dispatch(languagesActions.deleteSiteLanguage({ siteID: SITE_ID, languageID: 3 }));
-
-		expect(remove).toHaveBeenCalledWith(SITE_ID, 3);
-		expect(refresh).toHaveBeenCalledWith(SITE_ID);
-	});
-
-	it("AC5 · a failed write routes through the error channel and does not reload", async () => {
-		vi.spyOn(languages, "createSiteLanguage").mockResolvedValue({ status: 500, data: {} } as never);
-
-		await store.dispatch(languagesActions.createSiteLanguage({ siteID: SITE_ID, data: ES }));
-
-		expect(appActions.handleError).toHaveBeenCalled();
-		expect(refresh).not.toHaveBeenCalled();
-	});
-});

package/src/__tests__/store/persist.test.ts

@@ -1,47 +0,0 @@
-import { dropBlacklistedAreas } from "../../GlobalStore";
-
-/**
- * The blacklist alone does not stop a rehydration, and that asymmetry is the whole
- * reason `dropBlacklistedAreas` exists: redux-persist filters keys when it WRITES
- * (`createPersistoid`), but `getStoredState` returns every key an earlier release
- * stored and `autoMergeLevel1` hard-sets them all back into the tree.
- *
- * So on the first boot after the deploy — before any write has replaced the blob —
- * the areas that just left the persist (ADR 0002) would come back from it, which is
- * exactly the stale state the ADR removes: another site's data, in a screen that then
- * PUTs it back to the server.
- */
-const persistedBlob = (areas: Record<string, unknown>) =>
-	({ _persist: { version: -1, rehydrated: true }, ...areas }) as never;
-
-describe("dropping the de-persisted areas on rehydrate", () => {
-	it("drops the areas that left the persist from a blob written by an earlier release", async () => {
-		const stored = persistedBlob({
-			sites: { currentSiteInfo: { id: 3 } },
-			domains: { robots: [{ id: 1, content: "stale" }] },
-			redirects: { items: [{ id: 9 }] },
-			activityLog: { activityLog: { totalItems: 4, items: [] } },
-		});
-
-		const migrated = (await dropBlacklistedAreas(stored)) as unknown as Record<string, unknown>;
-
-		expect(Object.keys(migrated).sort()).toEqual(["_persist", "sites"]);
-		// The areas still in the persist are untouched: dropping them would be the
-		// opposite bug, since their consumers have no other loader.
-		expect(migrated.sites).toEqual({ currentSiteInfo: { id: 3 } });
-	});
-
-	it("keeps the areas that are still persisted, `social` and `analytics` among them", async () => {
-		const stored = persistedBlob({
-			social: { twitter: "https://x.com/griddo" },
-			analytics: { scriptCode: "<script>ga</script>", groups: [] },
-			pageEditor: { editorContent: {} },
-		});
-
-		expect(await dropBlacklistedAreas(stored)).toEqual(stored);
-	});
-
-	it("passes an empty storage through, so a first-ever visit rehydrates nothing", async () => {
-		expect(await dropBlacklistedAreas(undefined)).toBeUndefined();
-	});
-});

package/src/__tests__/store/redirects.test.ts

@@ -1,313 +0,0 @@
-import { redirects } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { redirectsActions, redirectsReducer } from "@ax/containers/Redirects";
-import { type ISitesState, sitesInitialState, sitesReducer } from "@ax/containers/Sites/reducer";
-import type { IRedirect, ISite } from "@ax/types";
-
-import { configureStore, type Reducer, type UnknownAction } from "@reduxjs/toolkit";
-import type { MockInstance } from "vitest";
-
-/**
- * Characterisation tests for the `redirects` area — the URL redirect manager behind
- * `/settings/redirects` (UC-AX-manage-redirects). The area had **zero** tests, so this
- * file is written against the legacy `actions.tsx` + `reducer.tsx` first and must keep
- * passing against the slice.
- *
- * The five thunks are dispatched through the one-line adapters below instead of inline.
- * createAsyncThunk takes exactly ONE argument, so all five change call shape when the
- * area migrates (docs/RTK-MIGRATION.md §5) — routing them through adapters means the
- * migration edits five lines and **not a single assertion**, which is what makes the
- * "passes unchanged" claim checkable rather than a slogan.
- *
- * Behaviours here that a rewrite loses quietly:
- *
- *   - `getRedirects` **empties the list before asking**, so the table blanks instead of
- *     showing the previous page under a spinner.
- *   - every write reloads through `getRedirects`, and the filter it reloads with depends
- *     on scope: `&sites={id}` when a site is loaded, otherwise whatever filter the caller
- *     passed. Import is the exception — it reloads unfiltered.
- *   - a **409 on create is not an error**: it means "this `from` already exists" and drives
- *     the overwrite flow, so it must NOT reach the error toast.
- */
-
-const SITE_ID = 7;
-
-const PARAMS = { page: 1, itemsPerPage: 50, pagination: true, query: "", filterBy: "" };
-// What every write reloads with — `DEFAULT_PARAMS` in the area's constants.
-const RELOAD_PARAMS = { page: 1, itemsPerPage: 50, pagination: true };
-const SITE_FILTER = `&sites=${SITE_ID}`;
-
-const REDIRECT: IRedirect = { id: 1, from: "/old", to: { url: "/new" }, date: "2026-08-10" };
-const OTHER: IRedirect = { id: 2, from: "/older", to: { url: "/newer" }, date: "2026-08-09" };
-const FORM = { from: "/old", to: "/new" };
-
-// `ReturnType<…>` rather than naming the state type: it lives in `reducer.tsx` today and in
-// `slice.ts` afterwards, and this file must not have to follow it. The casts are the ones
-// GlobalStore uses — RTK types reducers against redux 5's UnknownAction (§8.3).
-type RedirectsState = ReturnType<typeof redirectsReducer>;
-
-const makeStore = (currentSiteInfo: ISite | null = null) =>
-	configureStore({
-		reducer: {
-			redirects: redirectsReducer as unknown as Reducer<RedirectsState, UnknownAction>,
-			sites: sitesReducer as Reducer<ISitesState, UnknownAction>,
-		},
-		preloadedState: { sites: { ...sitesInitialState, currentSiteInfo } },
-	});
-
-type Store = ReturnType<typeof makeStore>;
-const stateOf = (store: Store) => store.getState().redirects;
-
-// The adapters. One line each; the migration rewrote these and nothing else.
-//
-// Two things changed here and nowhere else in this file: the single-argument rule turned
-// every call into an object, and `addRedirect`'s 409 callback became part of the RESULT
-// (`isOriginTaken`) instead of an argument — a function in `meta.arg` would trip the
-// serializableCheck (docs/RTK-MIGRATION.md §5). So `create` unwraps and calls the hook
-// itself, which keeps every assertion below untouched.
-const load = (store: Store, filters?: string) =>
-	store.dispatch(redirectsActions.getRedirects({ params: PARAMS, filters }));
-const create = async (store: Store, onIsBeingUsed: () => void, force?: boolean, filter?: string) => {
-	const { isOriginTaken } = await store
-		.dispatch(redirectsActions.addRedirect({ redirect: FORM, force, filter }))
-		.unwrap();
-	if (isOriginTaken) onIsBeingUsed();
-};
-const edit = (store: Store, redirectID: number, filter?: string) =>
-	store.dispatch(redirectsActions.updateRedirect({ redirect: FORM, redirectID, filter }));
-const remove = (store: Store, redirectID: number | number[], filter?: string) =>
-	store.dispatch(redirectsActions.deleteRedirect({ redirectID, filter })).unwrap();
-const bulkImport = (store: Store, rows: { from: string; to: string }[], check: boolean) =>
-	store.dispatch(redirectsActions.importRedirects({ rows, check })).unwrap();
-
-const listOk = (items: IRedirect[]) => ({ status: 200, data: { items, totalItems: items.length } });
-const ok = { status: 200, data: {} };
-
-let handleError: MockInstance;
-
-beforeEach(() => {
-	handleError = vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
-});
-
-afterEach(() => {
-	vi.restoreAllMocks();
-});
-
-describe("[UC-AX-manage-redirects] the redirect list", () => {
-	it("AC1 · starts empty, with nothing imported", () => {
-		expect(stateOf(makeStore())).toEqual({ redirects: [], totalItems: 0, totalImports: 0, imports: null });
-	});
-
-	it("AC1 · loading asks for the requested page and stores the items with the total", async () => {
-		const store = makeStore();
-		const get = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT, OTHER]) as never);
-
-		await load(store, SITE_FILTER);
-
-		expect(get).toHaveBeenCalledWith(PARAMS, SITE_FILTER);
-		expect(stateOf(store).redirects).toEqual([REDIRECT, OTHER]);
-		expect(stateOf(store).totalItems).toBe(2);
-	});
-
-	it("AC1 · empties the list before asking, so the table blanks instead of showing the previous page", async () => {
-		const store = makeStore();
-		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT, OTHER]) as never);
-		await load(store);
-		expect(stateOf(store).redirects).toHaveLength(2);
-
-		let listWhenAsked: IRedirect[] | undefined;
-		vi.spyOn(redirects, "getRedirects").mockImplementation((async () => {
-			listWhenAsked = stateOf(store).redirects;
-			return listOk([REDIRECT]);
-		}) as never);
-
-		await load(store);
-
-		expect(listWhenAsked).toEqual([]);
-		expect(stateOf(store).redirects).toEqual([REDIRECT]);
-	});
-
-	it("AC1 · a failed load routes through the error channel and leaves the list empty", async () => {
-		const store = makeStore();
-		vi.spyOn(redirects, "getRedirects").mockResolvedValue({ status: 500, data: {} } as never);
-
-		await load(store);
-
-		expect(handleError).toHaveBeenCalled();
-		expect(stateOf(store).redirects).toEqual([]);
-	});
-});
-
-describe("[UC-AX-manage-redirects] creating a redirect", () => {
-	const onIsBeingUsed = vi.fn();
-
-	beforeEach(() => {
-		onIsBeingUsed.mockClear();
-	});
-
-	it("AC2 · posts the redirect and reloads the list filtered by the current site", async () => {
-		const store = makeStore({ id: SITE_ID } as ISite);
-		const post = vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
-
-		await create(store, onIsBeingUsed);
-
-		expect(post).toHaveBeenCalledWith(FORM, undefined);
-		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
-	});
-
-	it("AC2 · in global scope it reloads with the filter it was given instead of a site", async () => {
-		const store = makeStore();
-		vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		await create(store, onIsBeingUsed, undefined, "&sites=global");
-
-		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, "&sites=global");
-	});
-
-	it("AC3 · a 409 means the origin is taken: it drives the overwrite flow, not the error toast", async () => {
-		const store = makeStore();
-		vi.spyOn(redirects, "createRedirect").mockResolvedValue({ status: 409, data: {} } as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		await create(store, onIsBeingUsed);
-
-		expect(onIsBeingUsed).toHaveBeenCalled();
-		expect(handleError).not.toHaveBeenCalled();
-		expect(reload).not.toHaveBeenCalled();
-	});
-
-	it("AC3 · confirming the overwrite posts again with force", async () => {
-		const store = makeStore();
-		const post = vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
-		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
-
-		await create(store, onIsBeingUsed, true);
-
-		expect(post).toHaveBeenCalledWith(FORM, true);
-	});
-
-	it("AC2 · any other failure goes through the error channel and leaves the overwrite flow alone", async () => {
-		const store = makeStore();
-		const response = { status: 400, data: { message: "Invalid url" } };
-		vi.spyOn(redirects, "createRedirect").mockResolvedValue(response as never);
-
-		await create(store, onIsBeingUsed);
-
-		expect(handleError).toHaveBeenCalledWith(response);
-		expect(onIsBeingUsed).not.toHaveBeenCalled();
-	});
-});
-
-describe("[UC-AX-manage-redirects] editing and deleting", () => {
-	it("AC4 · editing puts the redirect and reloads the list", async () => {
-		const store = makeStore({ id: SITE_ID } as ISite);
-		const put = vi.spyOn(redirects, "updateRedirect").mockResolvedValue(ok as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
-
-		await edit(store, 1);
-
-		expect(put).toHaveBeenCalledWith(FORM, 1);
-		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
-	});
-
-	it("AC4 · deleting one goes to the single endpoint, reloads, and reports that it deleted", async () => {
-		const store = makeStore({ id: SITE_ID } as ISite);
-		const single = vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(ok as never);
-		const bulk = vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(ok as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		const deleted = await remove(store, 1);
-
-		expect(single).toHaveBeenCalledWith(1);
-		expect(bulk).not.toHaveBeenCalled();
-		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
-		// The screen only shows the "Redirect deleted" toast off this boolean.
-		expect(deleted).toBe(true);
-	});
-
-	it("AC4 · deleting several goes to the bulk endpoint with the ids", async () => {
-		const store = makeStore();
-		const bulk = vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(ok as never);
-		const single = vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(ok as never);
-		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		await remove(store, [1, 2]);
-
-		expect(bulk).toHaveBeenCalledWith([1, 2]);
-		expect(single).not.toHaveBeenCalled();
-	});
-
-	it("AC4 · a bulk delete failing with several messages reports the count and does not reload", async () => {
-		const store = makeStore();
-		const response = { status: 400, data: { message: ["in use", "not found", "forbidden"] } };
-		vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(response as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		const deleted = await remove(store, [1, 2]);
-
-		expect(handleError).toHaveBeenCalledWith(response, true, "The delete action failed due to 3 errors.");
-		expect(reload).not.toHaveBeenCalled();
-		expect(deleted).toBe(false);
-	});
-
-	it("AC4 · a delete failing with a single message goes through the standard error channel", async () => {
-		const store = makeStore();
-		const response = { status: 400, data: { message: ["in use"] } };
-		vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(response as never);
-
-		await remove(store, 1);
-
-		expect(handleError).toHaveBeenCalledWith(response, false, undefined);
-	});
-});
-
-describe("[UC-AX-manage-redirects] importing from CSV", () => {
-	const ROWS = [
-		{ from: "/a", to: "/b" },
-		{ from: "/c", to: "/d" },
-	];
-
-	it("AC5 · the check phase stores the three buckets and the total, without reloading the list", async () => {
-		const store = makeStore();
-		const buckets = { total: 2, error: [], existing: [OTHER], ok: [REDIRECT] };
-		const check = vi.spyOn(redirects, "createRedirectsBulkCheck").mockResolvedValue({
-			status: 200,
-			data: buckets,
-		} as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
-
-		const checked = await bulkImport(store, ROWS, true);
-
-		expect(check).toHaveBeenCalledWith(ROWS);
-		expect(stateOf(store).imports).toEqual({ error: [], existing: [OTHER], ok: [REDIRECT] });
-		expect(stateOf(store).totalImports).toBe(2);
-		expect(reload).not.toHaveBeenCalled();
-		expect(checked).toBe(true);
-	});
-
-	it("AC5 · confirming posts the bulk and reloads the list unfiltered", async () => {
-		const store = makeStore({ id: SITE_ID } as ISite);
-		const post = vi.spyOn(redirects, "createRedirectsBulk").mockResolvedValue(ok as never);
-		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
-
-		await bulkImport(store, ROWS, false);
-
-		expect(post).toHaveBeenCalledWith(ROWS);
-		// Unfiltered even with a site loaded — the only write that ignores the scope.
-		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, undefined);
-	});
-
-	it("AC5 · an import failing with several messages reports the count", async () => {
-		const store = makeStore();
-		const response = { status: 400, data: { message: ["row 1 invalid", "row 2 invalid"] } };
-		vi.spyOn(redirects, "createRedirectsBulkCheck").mockResolvedValue(response as never);
-
-		const checked = await bulkImport(store, ROWS, true);
-
-		expect(handleError).toHaveBeenCalledWith(response, true, "The import action failed due to 2 errors.");
-		expect(stateOf(store).imports).toBeNull();
-		expect(checked).toBe(false);
-	});
-});