simple-module-settings 0.0.39__tar.gz → 0.0.40__tar.gz

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_settings
-Version: 0.0.39
+Version: 0.0.40
 Summary: Runtime settings UI — modules plug their own settings panels into a shared admin view
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,9 +21,9 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: simple-module-core==0.0.39
-Requires-Dist: simple-module-db==0.0.39
-Requires-Dist: simple-module-hosting==0.0.39
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-hosting==0.0.40
 Requires-Dist: typer<0.28,>=0.12
 Description-Content-Type: text/markdown
 

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simple-module-py/settings",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "private": true,
   "description": "Frontend assets for the Settings module",
   "peerDependencies": {

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_settings"
-version = "0.0.39"
+version = "0.0.40"
 description = "Runtime settings UI — modules plug their own settings panels into a shared admin view"
 readme = "README.md"
 license = "MIT"
@@ -21,9 +21,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.39",
-    "simple_module_db==0.0.39",
-    "simple_module_hosting==0.0.39",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_hosting==0.0.40",
     "typer>=0.12,<0.28",
 ]
 

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/endpoints/module_api.py

@@ -12,7 +12,6 @@ from typing import Any
 from fastapi import APIRouter, Depends, FastAPI, HTTPException, Request, Response, status
 from pydantic import ValidationError
 from simple_module_core.module_settings import module_settings_registry
-from simple_module_core.settings_hydrate import hydrate_settings
 from simple_module_hosting.i18n_deps import TranslatorDep
 from simple_module_hosting.permissions import RequiresPermission
 
@@ -23,8 +22,8 @@ from settings._module_settings import (
 )
 from settings._module_settings_props import serialize
 from settings.constants import PERM_DELETE, PERM_EDIT, PERM_VIEW
-from settings.contracts.events import SettingsReloaded
 from settings.deps import get_setting_service
+from settings.invalidation import reload_on_commit
 from settings.reload import EnvPinnedError, apply_changes_and_reload
 from settings.service import SettingService
 from settings.store import SettingsStore
@@ -162,11 +161,6 @@ async def clear_module_field(
     store = SettingsStore(service)
     await store.clear_override(package, field)
 
-    hydrated = await hydrate_settings(cls, store, package)
-    services = getattr(request.app.state, package)
-    services.settings = hydrated
-
-    bus = request.app.state.sm.event_bus
-    await bus.publish(SettingsReloaded(package=package, changed=(field,)))
+    reload_on_commit(request.app, request.app.state.sm.event_bus, store, package)
 
     return Response(status_code=status.HTTP_204_NO_CONTENT)

simple_module_settings-0.0.40/settings/invalidation.py

@@ -0,0 +1,70 @@
+"""Rehydrate module settings and notify local consumers only after durable writes."""
+
+import logging
+
+from fastapi import FastAPI
+from simple_module_core.app_state import get_services
+from simple_module_core.events import EventBus
+from simple_module_core.invalidation import InvalidationBus
+from simple_module_core.invalidation_refresh import InvalidationRefresh
+from simple_module_core.module_settings import module_settings_registry
+from simple_module_core.settings_hydrate import hydrate_settings
+from simple_module_db.stored_settings import settings_table_exists
+
+from settings.contracts.events import SettingsReloaded
+from settings.store import SettingsStore
+
+CHANNEL = "settings.modules"
+logger = logging.getLogger(__name__)
+
+
+async def reload_package(app: FastAPI, bus: EventBus, store: SettingsStore, package: str) -> None:
+    cls = module_settings_registry(app).get(package)
+    if cls is None:
+        return
+    services = getattr(app.state, package, None)
+    if services is None:
+        return
+    hydrated = await hydrate_settings(cls, store, package, lenient=True)
+    changed = tuple(
+        sorted(
+            name
+            for name in cls.model_fields
+            if getattr(services.settings, name) != getattr(hydrated, name)
+        )
+    )
+    services.settings = hydrated
+    if changed:
+        await bus.publish(SettingsReloaded(package=package, changed=changed))
+
+
+def reload_on_commit(app: FastAPI, bus: EventBus, store: SettingsStore, package: str) -> None:
+    async def committed() -> None:
+        invalidation = getattr(get_services(app), "invalidation", None)
+        if invalidation is None:
+            await reload_package(app, bus, store, package)
+        else:
+            await invalidation.publish(CHANNEL, key=package)
+
+    store.on_commit(committed)
+
+
+def subscribe(bus: InvalidationBus, app: FastAPI) -> InvalidationRefresh:
+    from settings.service import SettingService
+
+    async def reload(key: str | None) -> None:
+        async with app.state.sm.db.session_factory() as db:
+            if not await settings_table_exists(db):  # fresh install, before migrations
+                return
+            store = SettingsStore(SettingService(db))
+            packages = [key] if key is not None else module_settings_registry(app).all_packages()
+            for package in packages:
+                # One package's failed read or invalid cross-field rule must not
+                # starve the packages after it on every later cycle.
+                try:
+                    await reload_package(app, app.state.sm.event_bus, store, package)
+                except Exception:
+                    logger.exception("Reloading %s settings failed; keeping current ones", package)
+                    await db.rollback()
+
+    return InvalidationRefresh(bus, CHANNEL, reload)

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/module.py

@@ -29,6 +29,7 @@ from settings.constants import (
 )
 
 if TYPE_CHECKING:
+    from simple_module_core.invalidation import InvalidationBus
     from sqlalchemy.ext.asyncio import AsyncSession
 
 
@@ -79,6 +80,19 @@ class SettingsModule(ModuleBase):
         # Self-register so the UI lists our own settings alongside other modules.
         services.module_registry.register(MODULE_PACKAGE, SettingsSettings)
 
+    def register_invalidations(self, bus: InvalidationBus, app: FastAPI) -> None:
+        from settings.invalidation import subscribe
+
+        self._refresh = subscribe(bus, app)
+
+    async def on_startup(self, app: FastAPI) -> None:
+        if hasattr(self, "_refresh"):
+            self._refresh.start()
+
+    async def on_shutdown(self, app: FastAPI) -> None:
+        if hasattr(self, "_refresh"):
+            await self._refresh.stop()
+
     def register_exception_handlers(self, app: FastAPI) -> None:
         from settings.errors import install_exception_handlers
 

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/pages/ModulesEdit.tsx

@@ -142,7 +142,11 @@ function ModulesEdit({ modules, testable = {} }: Props) {
               </div>
             </Card>
           ) : current ? (
-            <ModuleForm module={current} checks={testable[current.package] ?? []} />
+            <ModuleForm
+              key={current.package}
+              module={current}
+              checks={testable[current.package] ?? []}
+            />
           ) : (
             <p className="text-muted-foreground">{t(keys.settings.modules.empty_title)}</p>
           )}

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/pages/components/ModuleForm.tsx

@@ -42,18 +42,23 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
     return o;
   }, [m.fields]);
 
-  const [values, setValues] = useState<Record<string, unknown>>(initial);
-  const [baseline, setBaseline] = useState<Record<string, unknown>>(initial);
+  const [{ values, baseline }, setBuffer] = useState({ values: initial, baseline: initial });
   const [errors, setErrors] = useState<Record<string, string>>({});
   const [busy, setBusy] = useState(false);
   const [saved, setSaved] = useState(false);
   const [formErrors, setFormErrors] = useState<string[]>([]);
 
-  // Reset the edit buffer whenever the underlying module changes (package
-  // switch, or server-reloaded props after a save/reset).
+  // Refresh saved values without discarding drafts in other fields (#637).
   useEffect(() => {
-    setValues(initial);
-    setBaseline(initial);
+    setBuffer((prev) => ({
+      values: Object.fromEntries(
+        Object.entries(initial).map(([name, value]) => [
+          name,
+          notEqual(prev.values[name], prev.baseline[name]) ? prev.values[name] : value,
+        ]),
+      ),
+      baseline: initial,
+    }));
     setErrors({});
     setSaved(false);
   }, [initial]);
@@ -107,7 +112,7 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
     } else {
       // Keeping the form mounted lets the confirmation remain visible instead
       // of being discarded by an immediate Inertia reload.
-      setBaseline({ ...values });
+      setBuffer((prev) => ({ ...prev, baseline: { ...values } }));
       setSaved(true);
     }
     setBusy(false);
@@ -121,6 +126,10 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
         params: { path: { package: m.package, field: name } },
       }),
     );
+    setBuffer((prev) => ({
+      ...prev,
+      values: { ...prev.values, [name]: prev.baseline[name] },
+    }));
     router.reload({ only: ['modules'] });
   }
 
@@ -187,7 +196,10 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
                   onReset={() => onReset(f.name)}
                   onChange={(name, v) => {
                     setSaved(false);
-                    setValues((prev) => ({ ...prev, [name]: v }));
+                    setBuffer((prev) => ({
+                      ...prev,
+                      values: { ...prev.values, [name]: v },
+                    }));
                   }}
                 />
               ))}

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/pages/components/TestConnectionButton.tsx

@@ -3,7 +3,7 @@ import { Button } from '@simple-module-py/ui/components/ui/button';
 import { useRelativeTime } from '@simple-module-py/ui/hooks/use-relative-time';
 import { apiFetch } from '@simple-module-py/ui/lib/api';
 import { CheckCircle2, PlugZap, XCircle } from 'lucide-react';
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { ROUTES } from '../routes';
 import { type LastTest, readLastTest, writeLastTest } from './last-test';
 
@@ -35,9 +35,19 @@ export function TestConnectionButton({ pkg, checks }: Props) {
   const [error, setError] = useState<string | null>(null);
   const [last, setLast] = useState<LastTest | null>(null);
 
+  const requestId = useRef(0);
+
   // Read on mount rather than during render: the result is per-tab session
   // state, and touching sessionStorage while rendering breaks SSR hydration.
-  useEffect(() => setLast(readLastTest(pkg)), [pkg]);
+  useEffect(() => {
+    setLast(readLastTest(pkg));
+    setResults(null);
+    setError(null);
+    setBusy(false);
+    return () => {
+      requestId.current++;
+    };
+  }, [pkg]);
 
   // "users.mailer" → "mailer". Naming the check is the difference between
   // "Test connection" and knowing an SMTP dial is about to happen; with two
@@ -50,6 +60,7 @@ export function TestConnectionButton({ pkg, checks }: Props) {
       : t(keys.settings.modules.test_connection_generic);
 
   async function run() {
+    const id = ++requestId.current;
     setBusy(true);
     setError(null);
     setResults(null);
@@ -57,8 +68,9 @@ export function TestConnectionButton({ pkg, checks }: Props) {
     const result = await apiFetch<{ checks?: CheckResult[] }>(ROUTES.testConnection(pkg), {
       method: 'POST',
     });
-    if (result.ok) {
-      const checkResults = result.data?.checks ?? [];
+    if (id !== requestId.current) return;
+    const checkResults = result.data?.checks;
+    if (result.ok && Array.isArray(checkResults) && checkResults.length > 0) {
       setResults(checkResults);
       setLast(
         writeLastTest(

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/reload.py

@@ -11,9 +11,13 @@ from pydantic_core import to_jsonable_python
 from pydantic_settings import BaseSettings
 from simple_module_core.events import EventBus
 from simple_module_core.module_settings import module_settings_registry
-from simple_module_core.settings_hydrate import env_supplied_fields, value_type_for_field
+from simple_module_core.settings_hydrate import (
+    env_supplied_fields,
+    hydrate_settings,
+    value_type_for_field,
+)
 
-from settings.contracts.events import SettingsReloaded
+from settings.invalidation import reload_on_commit
 from settings.store import SettingsStore
 
 
@@ -87,7 +91,7 @@ async def apply_changes_and_reload(
     package: str,
     changes: dict[str, Any],
 ) -> BaseSettings:
-    """Validate, persist, hot-swap, and publish ``SettingsReloaded``."""
+    """Validate and persist; reload and publish ``SettingsReloaded`` after commit."""
     registry = module_settings_registry(app)
     cls = registry.get(package)
     if cls is None:
@@ -97,8 +101,8 @@ async def apply_changes_and_reload(
     if unknown:
         raise KeyError(f"Unknown field(s) for {package!r}: {sorted(unknown)}")
 
-    services = getattr(app.state, package)
-    current = services.settings
+    # Include prior writes in this transaction without exposing them to other requests.
+    current = await hydrate_settings(cls, store, package, lenient=True)
     # Compare against the *dumped* current value, not the attribute: a field
     # typed as a list of models (branding's ``footer_links``) holds model
     # instances, while ``changes`` carries the plain dicts a DTO dumps to. The
@@ -118,6 +122,7 @@ async def apply_changes_and_reload(
                 await store.clear_override(package, name)
 
     if not diff:
+        reload_on_commit(app, bus, store, package)
         return current
 
     # Only a field that would actually change is refused: a client that echoes
@@ -153,6 +158,5 @@ async def apply_changes_and_reload(
         except ValidationError as exc:
             raise _relocate(exc, field_name) from exc
 
-    services.settings = validated
-    await bus.publish(SettingsReloaded(package=package, changed=tuple(sorted(diff))))
+    reload_on_commit(app, bus, store, package)
     return validated

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/settings/store.py

@@ -18,6 +18,7 @@ see ``_module_settings._field_view``.
 
 from __future__ import annotations
 
+from simple_module_db.callbacks import OnCommitCallback
 from simple_module_db.stored_settings import (  # noqa: F401  (re-exported, #500)
     SYSTEM_SCOPE_ID,
     get_overrides_sync,
@@ -41,6 +42,9 @@ class SettingsStore:
     def __init__(self, service: SettingService) -> None:
         self._service = service
 
+    def on_commit(self, callback: OnCommitCallback) -> None:
+        self._service.db.on_commit(callback)
+
     async def get_overrides(self, package: str) -> dict[str, tuple[str, str]]:
         """Return ``{field_name: (raw_value, value_type)}`` for a package."""
         items = await self._service.list_by_scope_unmasked(SettingScope.SYSTEM, SYSTEM_SCOPE_ID)

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/tests/test_reload.py

@@ -14,6 +14,7 @@ from settings.settings import SettingsSettings
 from settings.store import SettingsStore
 from simple_module_core.events import EventBus
 from simple_module_core.module_settings import register_module_settings
+from simple_module_db.transaction import finalize_session
 
 
 class _UsersCfg(BaseSettings):
@@ -56,7 +57,10 @@ async def test_apply_changes_updates_app_state_and_fires_event(app_and_bus, db_s
 
     assert new_settings.allow_signup is True
     assert new_settings.smtp_port == 587
-    assert app.state.users.settings is new_settings
+    assert app.state.users.settings.allow_signup is False
+    assert received == []
+    await finalize_session(db_session)
+    assert app.state.users.settings == new_settings
     assert received == [SettingsReloaded(package="users", changed=("allow_signup", "smtp_port"))]
 
     persisted = await store.get_overrides("users")
@@ -96,3 +100,15 @@ async def test_apply_changes_unknown_package_raises(app_and_bus, db_session):
             package="unknown",
             changes={"x": 1},
         )
+
+
+async def test_multiple_settings_edits_in_one_transaction_keep_both(app_and_bus, db_session):
+    app, bus = app_and_bus
+    store = SettingsStore(SettingService(db_session))
+    await apply_changes_and_reload(app, bus, store, package="users", changes={"allow_signup": True})
+    await apply_changes_and_reload(app, bus, store, package="users", changes={"smtp_port": 587})
+    assert app.state.users.settings.allow_signup is False
+    assert app.state.users.settings.smtp_port == 25
+    await finalize_session(db_session)
+    assert app.state.users.settings.allow_signup is True
+    assert app.state.users.settings.smtp_port == 587

simple_module_settings-0.0.40/tests/test_settings_commit_invalidation.py

@@ -0,0 +1,99 @@
+"""Module settings and reload events only reflect committed state."""
+
+import pytest
+from settings.contracts.events import SettingsReloaded
+from settings.reload import apply_changes_and_reload
+from settings.service import SettingService
+from settings.store import SettingsStore
+from simple_module_core.invalidation import Invalidation
+from simple_module_db.transaction import finalize_session, rollback_session
+
+
+@pytest.mark.parametrize("commit", [False, True])
+async def test_settings_and_events_wait_for_commit(app, commit):
+    received = []
+    bus = app.state.sm.event_bus
+
+    async def record(event):
+        received.append(event)
+
+    bus.subscribe(SettingsReloaded, record)
+    original = app.state.users.settings
+    wanted = not original.allow_signup
+    async with app.state.sm.db.session_factory() as db:
+        await apply_changes_and_reload(
+            app,
+            bus,
+            SettingsStore(SettingService(db)),
+            package="users",
+            changes={"allow_signup": wanted},
+        )
+        assert app.state.users.settings is original
+        assert received == []
+        if commit:
+            await finalize_session(db)
+        else:
+            await rollback_session(db)
+    assert app.state.users.settings.allow_signup is (wanted if commit else original.allow_signup)
+    assert len(received) == int(commit)
+    if commit:
+        assert received[0].changed == ("allow_signup",)
+
+
+async def test_remote_settings_changes_and_clears_reload_and_emit_event(app):
+    received = []
+
+    async def record(event):
+        received.append(event)
+
+    app.state.sm.event_bus.subscribe(SettingsReloaded, record)
+    original = app.state.users.settings.allow_signup
+    factory = app.state.sm.db.session_factory
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).set_override(
+            "users", "allow_signup", str(not original), "bool"
+        )
+        await db.commit()
+    message = Invalidation(channel="settings.modules", key="users", origin="other")
+    await app.state.sm.invalidation.deliver(message.to_wire())
+    assert app.state.users.settings.allow_signup is not original
+    assert received[-1].changed == ("allow_signup",)
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).clear_override("users", "allow_signup")
+        await db.commit()
+    await app.state.sm.invalidation.deliver(message.to_wire())
+    assert app.state.users.settings.allow_signup is original
+    assert len(received) == 2
+
+
+@pytest.mark.parametrize("commit", [False, True])
+async def test_clearing_module_setting_waits_for_commit(app, commit):
+    from settings.endpoints.module_api import clear_module_field
+    from starlette.requests import Request
+
+    original = app.state.users.settings.allow_signup
+    factory = app.state.sm.db.session_factory
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).set_override(
+            "users", "allow_signup", str(not original), "bool"
+        )
+        await db.commit()
+    await app.state.sm.invalidation.publish("settings.modules", key="users")
+    received = []
+
+    async def record(event):
+        received.append(event)
+
+    app.state.sm.event_bus.subscribe(SettingsReloaded, record)
+    async with factory() as db:
+        await clear_module_field(
+            "users", "allow_signup", Request({"type": "http", "app": app}), SettingService(db)
+        )
+        assert app.state.users.settings.allow_signup is not original
+        assert received == []
+        if commit:
+            await finalize_session(db)
+        else:
+            await rollback_session(db)
+    assert app.state.users.settings.allow_signup is (original if commit else not original)
+    assert len(received) == int(commit)

{simple_module_settings-0.0.39 → simple_module_settings-0.0.40}/tests/test_settings_secret_json_roundtrip.py

@@ -25,6 +25,13 @@ class _SecretCfg(BaseSettings):
 class _Store:
     def __init__(self) -> None:
         self.rows: dict[str, tuple[str, str]] = {}
+        self.callbacks = []
+
+    def on_commit(self, callback) -> None:
+        self.callbacks.append(callback)
+
+    async def get_overrides(self, package):
+        return dict(self.rows)
 
     async def set_override(self, package, field, raw, value_type) -> None:
         self.rows[field] = (raw, value_type)

simple_module_settings-0.0.40/tests-js/settings_ModuleFormRevert.test.tsx

@@ -0,0 +1,88 @@
+import '@testing-library/jest-dom/vitest';
+import { configureI18n } from '@simple-module-py/i18n';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import type { FieldMeta } from '../settings/pages/components/FieldInput';
+import { ModuleForm, type ModuleView } from '../settings/pages/components/ModuleForm';
+import ModulesEdit from '../settings/pages/ModulesEdit';
+
+const mocks = vi.hoisted(() => ({ reload: vi.fn() }));
+vi.mock('@inertiajs/react', () => ({ router: { reload: mocks.reload }, Head: () => null }));
+configureI18n({
+  locale: 'en',
+  messages: {
+    'settings.modules_form.save': 'Save',
+    'settings.modules_form.reset_to_default': 'Revert',
+    'settings.modules.unsaved_count_one': '{count} unsaved',
+  },
+});
+
+function field(name: string, value: string, db_override = false): FieldMeta {
+  return {
+    name,
+    value,
+    db_override,
+    type: 'string',
+    default: '',
+    description: '',
+    is_secret: false,
+    requires_restart: false,
+    group: null,
+    env_var: 'SM_TEST_FIELD',
+    env_set: false,
+    env_readable: false,
+    choices: null,
+  };
+}
+function view(fields: FieldMeta[]): ModuleView {
+  return {
+    module_name: 'Users',
+    package: 'users',
+    env_prefix: 'SM_USERS_',
+    class_name: 'UsersSettings',
+    fields,
+  };
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+});
+
+test('reverting one field preserves other drafts and their saved baseline after props reload', async () => {
+  const fetchMock = vi.fn(async () => new Response('{}', { status: 200 }));
+  vi.stubGlobal('fetch', fetchMock);
+  const { rerender } = render(
+    <ModuleForm
+      module={view([field('smtp_host', 'override', true), field('sender', 'original')])}
+    />,
+  );
+  fireEvent.change(screen.getByLabelText('sender'), { target: { value: 'draft' } });
+  fireEvent.change(screen.getByLabelText('smtp_host'), { target: { value: 'discard me' } });
+  fireEvent.click(screen.getByRole('button', { name: 'Revert' }));
+  await waitFor(() => expect(mocks.reload).toHaveBeenCalled());
+  rerender(
+    <ModuleForm module={view([field('smtp_host', 'default'), field('sender', 'original')])} />,
+  );
+  expect(screen.getByLabelText('smtp_host')).toHaveValue('default');
+  expect(screen.getByLabelText('sender')).toHaveValue('draft');
+  expect(screen.getByText('1 unsaved')).toBeVisible();
+  fireEvent.click(screen.getByRole('button', { name: 'Save' }));
+  await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(2));
+  const [request] = fetchMock.mock.calls[1] as unknown as [Request];
+  expect(await request.json()).toEqual({ sender: 'draft' });
+});
+
+test('switching modules starts a fresh edit buffer even when field names match', () => {
+  const users = view([field('sender', 'users original')]);
+  const mail = {
+    ...view([field('sender', 'mail original')]),
+    module_name: 'Mail',
+    package: 'mail',
+  };
+  render(<ModulesEdit modules={[users, mail]} />);
+  fireEvent.change(screen.getByLabelText('sender'), { target: { value: 'users draft' } });
+  fireEvent.click(screen.getByRole('button', { name: /mail/ }));
+  expect(screen.getByLabelText('sender')).toHaveValue('mail original');
+  expect(screen.getByRole('button', { name: 'Save' })).toBeDisabled();
+});

simple_module_settings-0.0.40/tests-js/settings_TestConnectionButton.test.tsx

@@ -0,0 +1,111 @@
+import '@testing-library/jest-dom/vitest';
+import { configureI18n, keys } from '@simple-module-py/i18n';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+configureI18n({ locale: 'en', messages: {} });
+
+import { TestConnectionButton } from '../settings/pages/components/TestConnectionButton';
+
+function stub(status: number, body: unknown) {
+  const fetchMock = vi.fn(async () => new Response(JSON.stringify(body), { status }));
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+}
+
+const click = () =>
+  fireEvent.click(
+    screen.getByRole('button', { name: keys.settings.modules.test_connection_generic }),
+  );
+
+describe('TestConnectionButton', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    window.sessionStorage.clear();
+  });
+
+  it('clears the displayed result when the package changes', async () => {
+    stub(200, { checks: [{ name: 'a.b', status: 'healthy', detail: 'users connected' }] });
+    const { rerender } = render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    click();
+    expect(await screen.findByText('users connected')).toBeVisible();
+    rerender(<TestConnectionButton pkg="mail" checks={['a.b', 'c.d']} />);
+    expect(screen.queryByText('users connected')).not.toBeInTheDocument();
+  });
+
+  it('ignores a pending result after switching packages, including switching back', async () => {
+    let finish!: (response: Response) => void;
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        () =>
+          new Promise<Response>((resolve) => {
+            finish = resolve;
+          }),
+      ),
+    );
+    const { rerender } = render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    click();
+    rerender(<TestConnectionButton pkg="mail" checks={['a.b', 'c.d']} />);
+    expect(screen.getByRole('button')).toBeEnabled();
+    rerender(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    await act(async () =>
+      finish(
+        new Response(
+          JSON.stringify({
+            checks: [{ name: 'a.b', status: 'healthy', detail: 'stale result' }],
+          }),
+          { status: 200 },
+        ),
+      ),
+    );
+    expect(screen.queryByText('stale result')).not.toBeInTheDocument();
+    expect(window.sessionStorage.getItem('sm.settings.last-test.users')).toBeNull();
+  });
+
+  it.each([null, {}, { checks: [] }, { checks: 'invalid' }])(
+    'does not record success for an invalid check response: %j',
+    async (body) => {
+      stub(200, body);
+      render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+      click();
+      expect(await screen.findByText(keys.settings.modules.test_failed)).toBeVisible();
+      expect(
+        JSON.parse(window.sessionStorage.getItem('sm.settings.last-test.users') ?? '{}').ok,
+      ).toBe(false);
+    },
+  );
+
+  it('does not record success when the response body cannot be read', async () => {
+    const response = new Response('{}', { status: 200 });
+    vi.spyOn(response, 'text').mockRejectedValue(new TypeError('stream interrupted'));
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+    render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    click();
+    expect(await screen.findByText(keys.settings.modules.test_failed)).toBeVisible();
+    expect(
+      JSON.parse(window.sessionStorage.getItem('sm.settings.last-test.users') ?? '{}').ok,
+    ).toBe(false);
+  });
+
+  it('POSTs to the view route and shows each check detail', async () => {
+    const fetchMock = stub(200, {
+      checks: [{ name: 'users.mailer', status: 'unhealthy', detail: 'connection refused' }],
+    });
+    render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    click();
+    expect(await screen.findByText('connection refused')).toBeInTheDocument();
+    const [req] = fetchMock.mock.calls[0] as unknown as [Request];
+    expect(req.method).toBe('POST');
+    expect(new URL(req.url).pathname).toBe('/admin/settings/test-connection/users');
+  });
+
+  it('shows a translated line when the call itself fails', async () => {
+    stub(500, null);
+    render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
+    click();
+    await waitFor(() =>
+      expect(screen.getByText(keys.settings.modules.test_failed)).toBeInTheDocument(),
+    );
+  });
+});

simple_module_settings-0.0.39/tests-js/settings_TestConnectionButton.test.tsx

@@ -1,47 +0,0 @@
-import '@testing-library/jest-dom/vitest';
-import { configureI18n, keys } from '@simple-module-py/i18n';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-configureI18n({ locale: 'en', messages: {} });
-
-import { TestConnectionButton } from '../settings/pages/components/TestConnectionButton';
-
-function stub(status: number, body: unknown) {
-  const fetchMock = vi.fn(async () => new Response(JSON.stringify(body), { status }));
-  vi.stubGlobal('fetch', fetchMock);
-  return fetchMock;
-}
-
-const click = () =>
-  fireEvent.click(
-    screen.getByRole('button', { name: keys.settings.modules.test_connection_generic }),
-  );
-
-describe('TestConnectionButton', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    window.sessionStorage.clear();
-  });
-
-  it('POSTs to the view route and shows each check detail', async () => {
-    const fetchMock = stub(200, {
-      checks: [{ name: 'users.mailer', status: 'unhealthy', detail: 'connection refused' }],
-    });
-    render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
-    click();
-    expect(await screen.findByText('connection refused')).toBeInTheDocument();
-    const [req] = fetchMock.mock.calls[0] as unknown as [Request];
-    expect(req.method).toBe('POST');
-    expect(new URL(req.url).pathname).toBe('/admin/settings/test-connection/users');
-  });
-
-  it('shows a translated line when the call itself fails', async () => {
-    stub(500, null);
-    render(<TestConnectionButton pkg="users" checks={['a.b', 'c.d']} />);
-    click();
-    await waitFor(() =>
-      expect(screen.getByText(keys.settings.modules.test_failed)).toBeInTheDocument(),
-    );
-  });
-});