@griddo/ax 12.6.0 → 12.6.1

package/config/griddo-config/index.js

@@ -87,6 +87,7 @@ const griddoAxAliases = {
 	"@ax/routes": path.resolve(__dirname, "../../src/routes"),
 	"@ax/types": path.resolve(__dirname, "../../src/types"),
 	"@ax/schemas": path.resolve(__dirname, "../../src/schemas"),
+	"@ax/store": path.resolve(__dirname, "../../src/store"),
 	"@ax/locales": path.resolve(__dirname, "../../src/locales"),
 	"@ax/constants": path.resolve(__dirname, "../../src/constants"),
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@griddo/ax",
 	"description": "Griddo Author Experience",
-	"version": "12.6.0",
+	"version": "12.6.1",
 	"authors": [
 		"Álvaro Sánchez' <alvaro.sanches@secuoyas.com>",
 		"Diego M. Béjar <diego.bejar@secuoyas.com>",
@@ -46,6 +46,7 @@
 		"@dnd-kit/sortable": "10.0.0",
 		"@griddo/api-types": "^1.0.12",
 		"@pmmmwh/react-refresh-webpack-plugin": "0.5.16",
+		"@reduxjs/toolkit": "2.9.0",
 		"@styled-system/prop-types": "5.1.5",
 		"@styled-system/theme-get": "5.1.2",
 		"@svgr/webpack": "8.1.0",
@@ -77,7 +78,6 @@
 		"babel-preset-react-app": "10.1.0",
 		"case-sensitive-paths-webpack-plugin": "2.4.0",
 		"compress.js": "1.2.2",
-		"connected-react-router": "6.9.3",
 		"css-loader": "6.11.0",
 		"css-minimizer-webpack-plugin": "5.0.1",
 		"date-fns": "2.30.0",
@@ -126,7 +126,6 @@
 		"react-textarea-autosize": "8.5.9",
 		"react-timezone-map-select": "1.2.25",
 		"redux": "4.2.1",
-		"redux-devtools-extension": "2.13.9",
 		"redux-persist": "6.0.0",
 		"reflect-metadata": "0.1.13",
 		"resolve": "1.22.10",
@@ -201,5 +200,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "5b898e9cbe8af3916311b072f42b1014150c331f"
+	"gitHead": "e0eec02188240c74c8fdacfa7a04fbafdc38c597"
 }

package/src/GlobalStore.tsx

@@ -1,35 +1,78 @@
-import { createStore, type Reducer, combineReducers, applyMiddleware, type Action, type StoreEnhancer } from "redux";
-import { persistReducer, persistStore, type PersistConfig, type Persistor } from "redux-persist";
+import type { IRootState } from "@ax/types";
+
+import { configureStore } from "@reduxjs/toolkit";
+import { type Action, combineReducers, type Reducer } from "redux";
+import {
+	FLUSH,
+	PAUSE,
+	PERSIST,
+	type PersistConfig,
+	type PersistedState,
+	type Persistor,
+	PURGE,
+	persistReducer,
+	persistStore,
+	REGISTER,
+	REHYDRATE,
+} from "redux-persist";
 import storage from "redux-persist/lib/storage"; // defaults to localStorage for web
-import { connectRouter, routerMiddleware } from "connected-react-router";
-import { composeWithDevTools } from "redux-devtools-extension";
-import thunk from "redux-thunk";
 
-import { appReducer, appInitialState } from "./containers/App/reducer";
-import { sitesReducer, sitesInitialState } from "./containers/Sites/reducer";
-import { pageEditorReducer, pageEditorInitialState } from "./containers/PageEditor/reducer";
-import { menuReducer, menuInitialState } from "./containers/Navigation/Menu/reducer";
-import { navigationReducer, navigationInitialState } from "./containers/Navigation/Defaults/reducer";
-import { structuredDataReducer, structuredDataInitialState } from "./containers/StructuredData/reducer";
-import { languagesReducer, languagesInitialState } from "./containers/Settings/Languages/reducer";
-import { dataPacksReducer, dataPacksInitialState } from "./containers/Settings/DataPacks/reducer";
-import { socialReducer, socialInitialState } from "./containers/Settings/Social/reducer";
-import { usersReducer, usersInitialState } from "./containers/Users/reducer";
-import { galleryReducer, galleryInitialState } from "./containers/Gallery/reducer";
-import { domainsReducer, domainsInitialState } from "./containers/Domains/reducer";
-import { redirectsReducer, redirectsInitialState } from "./containers/Redirects/reducer";
-import { analyticsReducer, analyticsInitialState } from "./containers/Analytics/reducer";
-import { integrationsReducer, integrationsInitialState } from "./containers/Integrations/reducer";
-import { fileDriveReducer, fileDriveInitialState } from "./containers/FileDrive/reducer";
-import { formsReducer, formsInitialState } from "./containers/Forms/reducer";
-import { activityLogReducer, activityLogInitialState } from "./containers/ActivityLog/reducer";
+import { activityLogInitialState, activityLogReducer } from "./containers/ActivityLog/slice";
+import { analyticsInitialState, analyticsReducer } from "./containers/Analytics/slice";
 import { LOGOUT } from "./containers/App/constants";
+import { appInitialState, appReducer } from "./containers/App/reducer";
+import { domainsInitialState, domainsReducer } from "./containers/Domains/slice";
+import { fileDriveInitialState, fileDriveReducer } from "./containers/FileDrive/reducer";
+import { formsInitialState, formsReducer } from "./containers/Forms/reducer";
+import { galleryInitialState, galleryReducer } from "./containers/Gallery/reducer";
+import { integrationsInitialState, integrationsReducer } from "./containers/Integrations/reducer";
+import { navigationInitialState, navigationReducer } from "./containers/Navigation/Defaults/reducer";
+import { menuInitialState, menuReducer } from "./containers/Navigation/Menu/reducer";
+import { pageEditorInitialState, pageEditorReducer } from "./containers/PageEditor/reducer";
+import { redirectsInitialState, redirectsReducer } from "./containers/Redirects/slice";
+import { dataPacksInitialState, dataPacksReducer } from "./containers/Settings/DataPacks/reducer";
+import { languagesInitialState, languagesReducer } from "./containers/Settings/Languages/slice";
+import { socialInitialState, socialReducer } from "./containers/Settings/Social/slice";
+import { sitesInitialState, sitesReducer } from "./containers/Sites/reducer";
+import { structuredDataInitialState, structuredDataReducer } from "./containers/StructuredData/reducer";
+import { usersInitialState, usersReducer } from "./containers/Users/reducer";
 
-import type { IRootState } from "@ax/types";
+// Every area migrated to RTK leaves redux-persist (docs/adr/0002): its state is a
+// copy of the server's that the screen reloads on mount, so persisting it only
+// meant starting up with stale data. `app` stays in — it carries the session.
+//
+// The test is that EVERY consumer reloads it, not just its settings screen, so
+// `social` and `analytics` stay in for now: six page-editor screens read `state.social`
+// and `AnalyticsField` reads `state.analytics`, and none of them fetches — the persist
+// was their only loader on a hard refresh. They leave in waves 2-4 with those consumers
+// (docs/RTK-MIGRATION.md §5).
+const blacklist = ["menu", "app", "languages", "domains", "redirects", "activityLog"];
+
+/**
+ * redux-persist applies the blacklist only when WRITING: `createPersistoid` filters the
+ * keys it stages, but `getStoredState` returns every key the previous releases wrote and
+ * `autoMergeLevel1` hard-sets them all (`newState[key] = inboundState[key]`). So adding
+ * an area to the blacklist does not stop it from being rehydrated once — it only stops
+ * the next write.
+ *
+ * Without this, the first boot after the deploy restores the areas that just left the
+ * persist from a stale blob, which is exactly what ADR 0002 removes: state from another
+ * site, in a screen that then PUTs it back. Deleting the keys from the inbound state is
+ * enough (the first write afterwards replaces the whole blob), and it needs no `version`
+ * bump — `persistReducer` calls `migrate` on every rehydrate.
+ */
+export const dropBlacklistedAreas = async (state: PersistedState): Promise<PersistedState> => {
+	if (!state) return state;
+
+	const kept = { ...state } as Record<string, unknown>;
+	for (const area of blacklist) {
+		delete kept[area];
+	}
+	return kept as PersistedState;
+};
 
-const blacklist = ["router", "menu", "app", "languages"];
 export class GlobalStore {
-	private persistConfig: PersistConfig<any> = { key: "root", storage, blacklist };
+	private persistConfig: PersistConfig<any> = { key: "root", storage, blacklist, migrate: dropBlacklistedAreas };
 
 	private authPersistConfig = {
 		key: "app",
@@ -37,11 +80,8 @@ export class GlobalStore {
 		blacklist: ["error", "isLoggingIn", "isRehydrated", "isSaving", "loadingCount", "user"],
 	};
 
-	public configureStore(history: History) {
-		let middleware: StoreEnhancer = applyMiddleware(thunk, routerMiddleware(history));
-
+	public configureStore() {
 		const globalReducer: Reducer<any> = combineReducers({
-			router: connectRouter(history),
 			app: persistReducer(this.authPersistConfig, appReducer as Reducer<any, Action<any>>),
 			sites: sitesReducer as Reducer<any, Action<any>>,
 			pageEditor: pageEditorReducer as Reducer<any, Action<any>>,
@@ -65,7 +105,6 @@ export class GlobalStore {
 		const rootReducer = (state: IRootState | undefined, action: any) => {
 			if (action.type === LOGOUT) {
 				state = {
-					router: state?.router,
 					app: state?.app || appInitialState,
 					sites: sitesInitialState,
 					pageEditor: pageEditorInitialState,
@@ -90,10 +129,27 @@ export class GlobalStore {
 			return globalReducer(state, action);
 		};
 
-		if (process.env.NODE_ENV !== "production") {
-			middleware = composeWithDevTools(middleware);
-		}
-		const store = createStore(persistReducer(this.persistConfig, rootReducer), middleware);
+		// configureStore already wires redux-thunk and the devtools extension (in
+		// non-production), which is why redux-devtools-extension is gone from the deps.
+		const store = configureStore({
+			reducer: persistReducer(this.persistConfig, rootReducer),
+			middleware: (getDefaultMiddleware) =>
+				getDefaultMiddleware({
+					// redux-persist dispatches these with non-serializable payloads by design.
+					// Kept ON otherwise: it only logs, and its warnings are the worklist for
+					// the offenders documented in docs/RTK-MIGRATION.md §5 (5 Date instances in
+					// state, app.error.btnAction holding a function).
+					serializableCheck: {
+						ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER],
+					},
+					// OFF on purpose. The three editors (PageEditor, Forms, Navigation/Defaults)
+					// mutate live store references and re-dispatch the regenerated tree
+					// (docs/RTK-MIGRATION.md §2.1), so this would log on every edit — and it
+					// deep-scans the whole tree per action, which is costly on a state this big.
+					// Re-enable per area as each editor is sanitised (waves 2-4).
+					immutableCheck: false,
+				}),
+		});
 		const persistor: Persistor = persistStore(store);
 		return { store, persistor };
 	}

package/src/__tests__/modules/ActivityLog/ActivityLog.uc.test.tsx

@@ -0,0 +1,132 @@
+import { activityLogReducer } from "@ax/containers/ActivityLog";
+import { appReducer, type IAppState } from "@ax/containers/App/reducer";
+import {
+	type IStructuredDataState,
+	structuredDataReducer,
+} from "@ax/containers/StructuredData/reducer";
+import { parseTheme } from "@ax/helpers";
+import ActivityLog from "@ax/modules/ActivityLog";
+import history from "@ax/routes/history";
+import globalTheme from "@ax/themes/theme.json";
+
+import { configureStore, type Reducer, type UnknownAction } from "@reduxjs/toolkit";
+import axios from "axios";
+import { Router } from "react-router-dom";
+import { ThemeProvider } from "styled-components";
+import type { MockedFunction } from "vitest";
+
+import { act, cleanup, render, screen } from "../../../../config/tests/test-utils";
+
+/**
+ * End-to-end test of the activity log on the real store — view, thunks, api layer and slice,
+ * with only axios mocked (see the `## Profile` section of docs/gainup/README.md for why a
+ * `redux-mock-store` test does not count as AC coverage).
+ *
+ * It covers the two things the store tests cannot see: that landing on the screen really does
+ * ask the grouped-by-day endpoint for a hundred rows and paint them (AC1), and the empty state
+ * (AC5), which is view logic living nowhere else.
+ *
+ * AC2 — switching to "Grouped by user" — is verified in `src/__tests__/store/activityLog.test.ts`
+ * instead: the mode selector is a react-select, and driving its menu open in jsdom would test
+ * the dropdown rather than the use case. The endpoint switch and the persisted `listMode` are
+ * the parts that matter and they are pinned there.
+ */
+vi.mock("axios");
+const mockedAxios = axios as MockedFunction<typeof axios>;
+
+const LOG_PAGE = {
+	totalItems: 1,
+	items: [
+		{
+			date: "10 Aug 2026",
+			items: [
+				{
+					id: 1,
+					user: { id: 3, name: "Ada Lovelace", image: null, email: "ada@example.edu", role: "admin" },
+					created: { hour: "09:41", date: "10 Aug 2026" },
+					site: null,
+					content: null,
+					contentType: null,
+					eventType: { id: 1, name: "Created page", internal_key: "CREATED_PAGE" },
+					ip: "10.0.0.1",
+				},
+			],
+		},
+	],
+};
+
+const makeStore = () =>
+	configureStore({
+		// Only what this screen reads. `app` and `structuredData` are still legacy, so they need
+		// the cast GlobalStore uses (docs/RTK-MIGRATION.md §8.3).
+		reducer: {
+			activityLog: activityLogReducer,
+			app: appReducer as Reducer<IAppState, UnknownAction>,
+			structuredData: structuredDataReducer as Reducer<IStructuredDataState, UnknownAction>,
+		},
+		middleware: (getDefault) => getDefault({ serializableCheck: false, immutableCheck: false }),
+	});
+
+const answer = (data: unknown) => ({ status: 200, data, statusText: "OK", headers: {}, config: {} });
+
+const logCalls = () =>
+	mockedAxios.mock.calls
+		.map(([config]) => config as { url?: string; method?: string })
+		.filter((config) => (config?.url ?? "").includes("/logs/activity-grouped-day"));
+
+const renderScreen = async (store: ReturnType<typeof makeStore>) => {
+	await act(async () => {
+		render(
+			<Router history={history}>
+				<ThemeProvider theme={parseTheme(globalTheme)}>
+					<ActivityLog />
+				</ThemeProvider>
+			</Router>,
+			{ store },
+		);
+	});
+};
+
+// The screen's filters and the structured-data refresh fetch their own lists on mount, so only
+// the log endpoint answers with a log page.
+const respondWith = (page: unknown) => {
+	mockedAxios.mockImplementation((async (config: { url?: string }) => {
+		const url = config?.url ?? "";
+		if (url.includes("/logs/activity-grouped-day")) return answer(page);
+		// The filter option lists want a bare array, not a paginated envelope.
+		return answer([]);
+	}) as never);
+};
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	cleanup();
+});
+
+describe("[UC-AX-view-activity-log] the activity log screen end to end", () => {
+	it("AC1 · landing on the screen asks the grouped-by-day endpoint for a hundred rows and paints them", async () => {
+		respondWith(LOG_PAGE);
+		const store = makeStore();
+
+		await renderScreen(store);
+
+		const [request] = logCalls();
+		expect(request.url).toContain("page=1");
+		expect(request.url).toContain("itemsPerPage=100");
+		// Default ordering is DESC, which the endpoint expresses by the absence of `order`.
+		expect(request.url).not.toContain("order=");
+		expect(store.getState().activityLog.activityLog.totalItems).toBe(1);
+		expect(screen.getByText("Ada Lovelace")).toBeTruthy();
+		expect(screen.getByText("09:41")).toBeTruthy();
+	});
+
+	it("AC5 · an empty log shows the default empty state instead of a table", async () => {
+		respondWith({ totalItems: 0, items: [] });
+
+		await renderScreen(makeStore());
+
+		expect(logCalls()).toHaveLength(1);
+		expect(screen.getByText(/You will start to see the User Activity Log/)).toBeTruthy();
+		expect(screen.queryByText("Ada Lovelace")).toBeNull();
+	});
+});

package/src/__tests__/modules/Analytics/Analytics.uc.test.tsx

@@ -0,0 +1,168 @@
+import { Router } from "react-router-dom";
+
+// From the slice, not the `@ax/containers/Analytics` barrel: `Sites/actions` destructures
+// `analyticsActions` at module scope, so pulling the barrel in first from a test that also
+// mounts a screen loses the race with that cycle and the destructure sees `undefined`.
+import { analyticsReducer } from "@ax/containers/Analytics/slice";
+import { appInitialState, appReducer, type IAppState } from "@ax/containers/App/reducer";
+import { type ISitesState, sitesInitialState, sitesReducer } from "@ax/containers/Sites/reducer";
+import { parseTheme } from "@ax/helpers";
+import GlobalAnalytics from "@ax/modules/Analytics";
+import SiteAnalytics from "@ax/modules/Settings/SeoAnalyticsSettings/Analytics";
+import history from "@ax/routes/history";
+import globalTheme from "@ax/themes/theme.json";
+import type { IAnalytics, INavItem, ISite } from "@ax/types";
+
+import { configureStore, type Reducer, type UnknownAction } from "@reduxjs/toolkit";
+import axios from "axios";
+import { ThemeProvider } from "styled-components";
+import type { MockedFunction } from "vitest";
+
+import { act, cleanup, render, screen } from "../../../../config/tests/test-utils";
+
+/**
+ * End-to-end tests of the two screens of the `analytics` area on the real store — view,
+ * thunks, api layer and slice, with only axios mocked (see the `## Profile` section of
+ * docs/gainup/README.md for why a `redux-mock-store` test does not count as AC coverage).
+ *
+ * They cover the half of AC5 and AC6 that lives only in the view, and both were written
+ * against bugs the review of this migration found: the global screen landed dirty, so Save
+ * was enabled and the leave guard armed on a screen the user had only looked at; and the
+ * site screen claimed "this site has no script code of its own" for as long as the GET was
+ * in flight, which is a statement about the server made before asking it.
+ *
+ * The in-flight window is the whole point of the second one, so its mock hands back a
+ * promise this file resolves by hand: awaiting the render would skip the state under test.
+ */
+vi.mock("axios");
+const mockedAxios = axios as MockedFunction<typeof axios>;
+
+const SITE_ID = 7;
+const ANALYTICS: IAnalytics = {
+	scriptCode: "<script>site-ga</script>",
+	siteScriptCodeExists: true,
+	dimensions: [],
+	groups: [],
+};
+
+const mockComponent = () => null;
+const NAV_ITEMS: INavItem[] = [{ title: "Analytics", path: "/sites/settings/analytics", component: mockComponent }];
+
+const okResponse = (data: unknown) => ({ status: 200, data, statusText: "OK", headers: {}, config: {} });
+
+const makeStore = () =>
+	configureStore({
+		// Only what these screens read. `app` and `sites` are still legacy, so they need the
+		// cast GlobalStore uses (docs/RTK-MIGRATION.md §8.3).
+		reducer: {
+			app: appReducer as Reducer<IAppState, UnknownAction>,
+			analytics: analyticsReducer,
+			sites: sitesReducer as Reducer<ISitesState, UnknownAction>,
+		},
+		middleware: (getDefault) => getDefault({ serializableCheck: false, immutableCheck: false }),
+		preloadedState: {
+			// `appInitialState.isLoading` is `true` and `getAnalytics` passes no loading flag,
+			// so a bare store would spin forever. `false` is the state any screen is actually
+			// reached in: the login and the boot fetches have already released the counter.
+			app: { ...appInitialState, isLoading: false },
+			sites: { ...sitesInitialState, currentSiteInfo: { id: SITE_ID } as ISite },
+		},
+	});
+
+const metricsCalls = (method: string) =>
+	mockedAxios.mock.calls
+		.map(([config]) => config as { url?: string; method?: string })
+		.filter((config) => config?.method === method && !!config?.url?.includes("/metrics"));
+
+const renderScreen = async (store: ReturnType<typeof makeStore>, ui: JSX.Element) => {
+	await act(async () => {
+		render(
+			<Router history={history}>
+				<ThemeProvider theme={parseTheme(globalTheme)}>{ui}</ThemeProvider>
+			</Router>,
+			{ store },
+		);
+	});
+};
+
+const siteScreen = <SiteAnalytics navItems={NAV_ITEMS} currentNavItem={NAV_ITEMS[0]} />;
+
+const button = (name: string) => screen.getByRole("button", { name });
+// The Warning panel's own button — it is what tells the site it has no override.
+const warning = () => screen.queryByRole("button", { name: "Define Site Analytics" });
+
+beforeEach(() => {
+	mockedAxios.mockImplementation((async () => okResponse(ANALYTICS)) as never);
+});
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	cleanup();
+});
+
+describe("[UC-AX-configure-seo-analytics] the global Analytics screen end to end", () => {
+	it("AC6 · lands clean on the data it just fetched, so Save stays disabled", async () => {
+		const store = makeStore();
+
+		await renderScreen(store, <GlobalAnalytics />);
+
+		expect(metricsCalls("GET")).toHaveLength(1);
+		expect(store.getState().analytics.scriptCode).toBe(ANALYTICS.scriptCode);
+		// The empty→loaded hop is not an edit. useIsDirty snapshots its baseline during
+		// render, so without the resetDirty() in the hydration effect this reads "Save"
+		// enabled — and the leave guard fires on the way out of a screen nobody touched.
+		expect(button("Saved").hasAttribute("disabled")).toBe(true);
+	});
+});
+
+describe("[UC-AX-configure-seo-analytics] the site Analytics screen end to end", () => {
+	it("AC5 · does not claim the site has no script code of its own until the GET answers", async () => {
+		const store = makeStore();
+		let answerGet = () => {};
+		mockedAxios.mockImplementation(
+			(() =>
+				new Promise((resolve) => {
+					answerGet = () => resolve(okResponse(ANALYTICS));
+				})) as never,
+		);
+
+		await renderScreen(store, siteScreen);
+
+		// In flight: `siteScriptCodeExists` is still its initial `false`, which means "not
+		// asked yet", not "no override". Deciding here is what showed the Warning to a site
+		// that does have its own script.
+		expect(warning()).toBeNull();
+
+		await act(async () => {
+			answerGet();
+		});
+
+		expect(warning()).toBeNull();
+		expect(screen.getByDisplayValue(ANALYTICS.scriptCode)).toBeTruthy();
+	});
+
+	it("AC5 · shows the Warning once the server answers that the site has no script code", async () => {
+		const store = makeStore();
+		mockedAxios.mockImplementation((async () =>
+			okResponse({ ...ANALYTICS, siteScriptCodeExists: false, scriptCode: "" })) as never);
+
+		await renderScreen(store, siteScreen);
+
+		expect(warning()).toBeTruthy();
+	});
+
+	it("AC5 · a failed GET leaves the editor, not a claim about the site's script code", async () => {
+		const store = makeStore();
+		mockedAxios.mockImplementation((async () => ({
+			status: 500,
+			data: { message: "Server error" },
+			statusText: "Server Error",
+			headers: {},
+			config: {},
+		})) as never);
+
+		await renderScreen(store, siteScreen);
+
+		expect(warning()).toBeNull();
+	});
+});

package/src/__tests__/modules/GlobalSettings/Robots/Robots.test.tsx

@@ -0,0 +1,110 @@
+import { Router } from "react-router-dom";
+
+import { parseTheme } from "@ax/helpers";
+import Robots from "@ax/modules/GlobalSettings/Robots";
+import history from "@ax/routes/history";
+import globalTheme from "@ax/themes/theme.json";
+import type { IDomainRobot } from "@ax/types";
+
+import axios from "axios";
+import configureStore from "redux-mock-store";
+import thunk from "redux-thunk";
+import { ThemeProvider } from "styled-components";
+import type { MockedFunction } from "vitest";
+
+import { act, cleanup, fireEvent, render, screen } from "../../../../../config/tests/test-utils";
+
+vi.mock("axios");
+const mockedAxios = axios as MockedFunction<typeof axios>;
+
+const mockComponent = () => null;
+const navItems = [{ title: "Robots.txt", path: "/settings/robots", component: mockComponent }];
+const currentNavItem = navItems[0];
+
+const ROBOT: IDomainRobot = {
+	id: 1,
+	path: "/",
+	fullUrl: "https://www.example.edu/",
+	content: "User-agent: *",
+	computedContent: "User-agent: *",
+};
+const OTHER: IDomainRobot = { ...ROBOT, id: 2, path: "/es", fullUrl: "https://www.example.edu/es" };
+
+const createMockStore = (overrides: Record<string, unknown> = {}) => {
+	const defaultStore = {
+		app: { isLoading: false, isSaving: false },
+		domains: { robots: [ROBOT, OTHER] },
+		...overrides,
+	};
+	return configureStore([thunk] as never)(defaultStore);
+};
+
+const renderScreen = async (store: ReturnType<typeof createMockStore>) => {
+	await act(async () => {
+		render(
+			<Router history={history}>
+				<ThemeProvider theme={parseTheme(globalTheme)}>
+					<Robots navItems={navItems} currentNavItem={currentNavItem} />
+				</ThemeProvider>
+			</Router>,
+			{ store },
+		);
+	});
+};
+
+// The screen is asserted through the requests it makes, not through the action
+// creators it calls: `connect` captures those by reference when the module is
+// evaluated, so spying on them is invisible here — and would break anyway the
+// moment the area moves to hooks.
+const requestsTo = (endpoint: string, method: string) =>
+	mockedAxios.mock.calls
+		.map(([config]) => config as { url?: string; method?: string; data?: unknown })
+		.filter((config) => config?.url?.endsWith(endpoint) && config?.method === method);
+
+beforeEach(() => {
+	mockedAxios.mockResolvedValue({ status: 200, data: [], statusText: "OK", headers: {}, config: {} as never });
+});
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	cleanup();
+});
+
+describe("[UC-AX-configure-seo-analytics] robots.txt editor", () => {
+	it("AC1 · loads the robots on mount", async () => {
+		await renderScreen(createMockStore());
+
+		expect(requestsTo("/domains/robots", "GET")).toHaveLength(1);
+	});
+
+	it("AC7 · shows one row per robot received", async () => {
+		await renderScreen(createMockStore());
+
+		expect(screen.getAllByText("Edit robots.txt")).toHaveLength(2);
+		expect(screen.getAllByText(ROBOT.fullUrl, { exact: false }).length).toBeGreaterThan(0);
+		expect(screen.getAllByText(OTHER.fullUrl, { exact: false }).length).toBeGreaterThan(0);
+	});
+
+	it("AC7 · shows the loading state instead of the rows while app.isLoading", async () => {
+		await renderScreen(createMockStore({ app: { isLoading: true, isSaving: false } }));
+
+		expect(screen.queryByText("Edit robots.txt")).toBeNull();
+	});
+
+	it("AC1 · saving sends the robots currently on screen to the bulk endpoint", async () => {
+		await renderScreen(createMockStore());
+		await act(async () => {
+			fireEvent.click(screen.getByText("Save"));
+		});
+
+		const [save] = requestsTo("/domains/robots/bulk", "PUT");
+		expect(save?.data).toEqual({ robots: [ROBOT, OTHER] });
+	});
+
+	it("AC7 · the save button reports progress while app.isSaving", async () => {
+		await renderScreen(createMockStore({ app: { isLoading: false, isSaving: true } }));
+
+		expect(screen.getByText("Saving")).toBeTruthy();
+		expect(screen.queryByText("Save")).toBeNull();
+	});
+});