diff --git a/tests/frontend/managers/settingsManager.downloadRootRules.test.js b/tests/frontend/managers/settingsManager.downloadRootRules.test.js
new file mode 100644
index 00000000..690c88e8
--- /dev/null
+++ b/tests/frontend/managers/settingsManager.downloadRootRules.test.js
@@ -0,0 +1,327 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('../../../static/js/managers/ModalManager.js', () => ({
+ modalManager: {
+ closeModal: vi.fn(),
+ },
+}));
+
+vi.mock('../../../static/js/utils/uiHelpers.js', () => ({
+ showToast: vi.fn(),
+}));
+
+vi.mock('../../../static/js/state/index.js', () => {
+ const settings = {};
+ return {
+ state: {
+ global: {
+ settings,
+ },
+ },
+ createDefaultSettings: () => ({
+ language: 'en',
+ download_root_rules: { loras: [], checkpoints: [], unet: [], embeddings: [] },
+ }),
+ };
+});
+
+vi.mock('../../../static/js/api/modelApiFactory.js', () => ({
+ resetAndReload: vi.fn(),
+}));
+
+vi.mock('../../../static/js/utils/constants.js', () => ({
+ DOWNLOAD_PATH_TEMPLATES: {},
+ DEFAULT_PATH_TEMPLATES: {},
+ MAPPABLE_BASE_MODELS: ['Flux.1 D', 'Pony', 'SDXL 1.0', 'Other'],
+ PATH_TEMPLATE_PLACEHOLDERS: {},
+ FILENAME_TEMPLATE_PLACEHOLDERS: [],
+ DEFAULT_FILENAME_TEMPLATES: { lora: '', checkpoint: '', embedding: '' },
+ DEFAULT_PRIORITY_TAG_CONFIG: {
+ lora: 'character, style',
+ checkpoint: 'base, guide',
+ embedding: 'hint',
+ },
+ getMappableBaseModelsDynamic: () => ['Flux.1 D', 'Pony', 'SDXL 1.0', 'Other'],
+}));
+
+vi.mock('../../../static/js/utils/i18nHelpers.js', () => ({
+ translate: (key, params, fallback) => {
+ if (key === 'settings.downloadSkipBaseModels.summary.none') {
+ return 'None selected';
+ }
+ if (key === 'settings.downloadSkipBaseModels.summary.count') {
+ return `${params?.count ?? 0} selected`;
+ }
+ return fallback ?? '';
+ },
+}));
+
+vi.mock('../../../static/js/i18n/index.js', () => ({
+ i18n: {
+ getCurrentLocale: () => 'en',
+ setLanguage: vi.fn().mockResolvedValue(),
+ },
+}));
+
+vi.mock('../../../static/js/components/shared/ModelCard.js', () => ({
+ configureModelCardVideo: vi.fn(),
+}));
+
+vi.mock('../../../static/js/managers/BannerService.js', () => ({
+ bannerService: {
+ registerBanner: vi.fn(),
+ },
+}));
+
+import { SettingsManager } from '../../../static/js/managers/SettingsManager.js';
+import { state } from '../../../static/js/state/index.js';
+
+const ROOTS = {
+ loras: ['/models/loras-main', '/models/lora-archive'],
+ checkpoints: ['/models/checkpoints'],
+ unet: ['/models/unet-main', '/models/unet-archive'],
+ embeddings: [],
+};
+
+const createManager = () => {
+ const initSettingsSpy = vi
+ .spyOn(SettingsManager.prototype, 'initializeSettings')
+ .mockResolvedValue();
+ const initializeSpy = vi
+ .spyOn(SettingsManager.prototype, 'initialize')
+ .mockImplementation(() => {});
+
+ const manager = new SettingsManager();
+
+ initSettingsSpy.mockRestore();
+ initializeSpy.mockRestore();
+
+ manager.saveSetting = vi.fn().mockResolvedValue();
+ manager.downloadRootRuleRoots = ROOTS;
+
+ return manager;
+};
+
+const appendDownloadRootRulesUi = () => {
+ document.body.innerHTML = `
+
+
+ `;
+};
+
+const groupRows = (typeKey) =>
+ document.querySelectorAll(
+ `#downloadRootRulesContainer .download-root-rule-row[data-rule-type="${typeKey}"]`
+ );
+
+describe('SettingsManager download root rules', () => {
+ beforeEach(() => {
+ document.body.innerHTML = '';
+ vi.clearAllMocks();
+ state.global.settings = {
+ download_root_rules: { loras: [], checkpoints: [], unet: [], embeddings: [] },
+ };
+ });
+
+ it('normalizes malformed rules out of the setting', () => {
+ const manager = createManager();
+
+ const normalized = manager.normalizeDownloadRootRules({
+ loras: [
+ { match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' },
+ { match_type: 'base_model', match: [], root: '/models/lora-archive' },
+ { match_type: 'base_model', match: ['Pony'], root: '' },
+ null,
+ 'not-a-rule',
+ ],
+ embeddings: 'oops',
+ unknownType: [{ match_type: 'base_model', match: ['Pony'], root: '/x' }],
+ });
+
+ expect(normalized).toEqual({
+ loras: [{ match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' }],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ });
+ });
+
+ it('renders one group per type and a hint when no roots are configured', () => {
+ appendDownloadRootRulesUi();
+ state.global.settings.download_root_rules = {
+ loras: [{ match_type: 'base_model', match: ['Flux.1 D', 'Pony'], root: '/models/lora-archive' }],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ };
+ const manager = createManager();
+
+ manager.renderDownloadRootRules();
+
+ expect(document.querySelectorAll('.download-root-rule-group')).toHaveLength(4);
+ expect(groupRows('loras')).toHaveLength(1);
+ expect(groupRows('loras')[0].querySelector('.download-root-rule-summary').textContent)
+ .toBe('Flux.1 D, Pony');
+ expect(groupRows('loras')[0].querySelector('select.download-root-rule-root').value)
+ .toBe('/models/lora-archive');
+ // embeddings has no roots configured
+ const embeddingsGroup = document.querySelectorAll('.download-root-rule-group')[3];
+ expect(embeddingsGroup.querySelector('.download-root-rules-hint')).not.toBeNull();
+ expect(embeddingsGroup.querySelector('.add-mapping-btn')).toBeNull();
+ });
+
+ it('add rule creates a draft and the first base model selection promotes and persists it', async () => {
+ appendDownloadRootRulesUi();
+ const manager = createManager();
+ manager.renderDownloadRootRules();
+
+ manager.addDownloadRootRule('loras');
+
+ expect(manager.downloadRootRuleDrafts.loras).toEqual({
+ match_type: 'base_model',
+ match: [],
+ root: '/models/loras-main',
+ });
+ expect(groupRows('loras')).toHaveLength(1);
+ // A second add while a draft exists is a no-op
+ manager.addDownloadRootRule('loras');
+ expect(groupRows('loras')).toHaveLength(1);
+
+ // The draft row panel is open; tick a base model checkbox
+ const checkbox = groupRows('loras')[0].querySelector(
+ '.download-root-rule-panel input[value="Flux.1 D"]'
+ );
+ checkbox.checked = true;
+ checkbox.dispatchEvent(new Event('change'));
+ await vi.waitFor(() => {
+ expect(manager.saveSetting).toHaveBeenCalled();
+ });
+
+ expect(manager.downloadRootRuleDrafts.loras).toBeUndefined();
+ expect(manager.saveSetting).toHaveBeenCalledWith('download_root_rules', {
+ loras: [{ match_type: 'base_model', match: ['Flux.1 D'], root: '/models/loras-main' }],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ });
+ expect(state.global.settings.download_root_rules.loras).toHaveLength(1);
+ });
+
+ it('removing a rule persists the updated list', async () => {
+ appendDownloadRootRulesUi();
+ state.global.settings.download_root_rules = {
+ loras: [
+ { match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' },
+ { match_type: 'base_model', match: ['Pony'], root: '/models/loras-main' },
+ ],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ };
+ const manager = createManager();
+ manager.renderDownloadRootRules();
+
+ manager.removeDownloadRootRule('loras', 0, false);
+ await vi.waitFor(() => {
+ expect(manager.saveSetting).toHaveBeenCalled();
+ });
+
+ expect(manager.saveSetting).toHaveBeenCalledWith('download_root_rules', {
+ loras: [{ match_type: 'base_model', match: ['Pony'], root: '/models/loras-main' }],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ });
+ });
+
+ it('move down swaps rule order and persists', async () => {
+ appendDownloadRootRulesUi();
+ state.global.settings.download_root_rules = {
+ loras: [
+ { match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' },
+ { match_type: 'base_model', match: ['Pony'], root: '/models/loras-main' },
+ ],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ };
+ const manager = createManager();
+ manager.renderDownloadRootRules();
+
+ manager.moveDownloadRootRule('loras', 0, 1);
+ await vi.waitFor(() => {
+ expect(manager.saveSetting).toHaveBeenCalled();
+ });
+
+ expect(manager.saveSetting).toHaveBeenCalledWith('download_root_rules', {
+ loras: [
+ { match_type: 'base_model', match: ['Pony'], root: '/models/loras-main' },
+ { match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' },
+ ],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ });
+
+ // Out-of-range moves are no-ops
+ manager.saveSetting.mockClear();
+ manager.moveDownloadRootRule('loras', 1, 1);
+ expect(manager.saveSetting).not.toHaveBeenCalled();
+ });
+
+ it('unchecking the last base model of a persisted rule removes the rule', async () => {
+ appendDownloadRootRulesUi();
+ state.global.settings.download_root_rules = {
+ loras: [{ match_type: 'base_model', match: ['Flux.1 D'], root: '/models/lora-archive' }],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ };
+ const manager = createManager();
+ manager.renderDownloadRootRules();
+
+ const row = groupRows('loras')[0];
+ const checkbox = row.querySelector('.download-root-rule-panel input[value="Flux.1 D"]');
+ expect(checkbox.checked).toBe(true);
+ checkbox.checked = false;
+ checkbox.dispatchEvent(new Event('change'));
+ await vi.waitFor(() => {
+ expect(manager.saveSetting).toHaveBeenCalled();
+ });
+
+ expect(manager.saveSetting).toHaveBeenCalledWith('download_root_rules', {
+ loras: [],
+ checkpoints: [],
+ unet: [],
+ embeddings: [],
+ });
+ expect(groupRows('loras')).toHaveLength(0);
+ });
+
+ it('loadDownloadRootRules fetches roots for every type and renders', async () => {
+ appendDownloadRootRulesUi();
+ const fetchMock = vi.fn().mockImplementation(async (url) => ({
+ ok: true,
+ json: async () => {
+ if (url.includes('loras/roots')) return { roots: ROOTS.loras };
+ if (url.includes('checkpoints_roots')) return { roots: ROOTS.checkpoints };
+ if (url.includes('unet_roots')) return { roots: ROOTS.unet };
+ if (url.includes('embeddings/roots')) return { roots: [] };
+ return {};
+ },
+ }));
+ vi.stubGlobal('fetch', fetchMock);
+ try {
+ const manager = createManager();
+ manager.downloadRootRuleRoots = null;
+
+ await manager.loadDownloadRootRules();
+
+ expect(manager.downloadRootRuleRoots).toEqual(ROOTS);
+ expect(document.querySelectorAll('.download-root-rule-group')).toHaveLength(4);
+ expect(document.getElementById('downloadRootRulesError').textContent).toBe('');
+ } finally {
+ vi.unstubAllGlobals();
+ }
+ });
+});
diff --git a/tests/routes/test_download_routing_handlers.py b/tests/routes/test_download_routing_handlers.py
index 05695dfa..d26b7ced 100644
--- a/tests/routes/test_download_routing_handlers.py
+++ b/tests/routes/test_download_routing_handlers.py
@@ -44,7 +44,14 @@ async def test_diffusion_base_model_routes_to_unet():
)
payload = json.loads(response.text)
assert response.status == 200
- assert payload == {"success": True, "is_diffusion_model": True, "root_kind": "unet"}
+ assert payload == {
+ "success": True,
+ "is_diffusion_model": True,
+ "root_kind": "unet",
+ # No rule matches "Anima", so the resolved root falls back to the
+ # auto-configured default unet root.
+ "resolved_root": get_settings_manager().get("default_unet_root"),
+ }
@pytest.mark.asyncio
@@ -245,3 +252,57 @@ async def test_other_routing_disabled_for_switched_off_sub_type():
assert payload["disabled"] is True
assert payload["reason"] == "other_sub_type_disabled"
assert payload["requested_sub_type"] == "upscaler"
+
+
+@pytest.mark.asyncio
+async def test_resolved_root_falls_back_to_default_root():
+ manager = get_settings_manager()
+ manager.settings["default_lora_root"] = "/loras-main"
+
+ handler = DownloadRoutingHandler()
+ response = await handler.get_download_routing(
+ FakeRequest({"model_type": "lora", "base_model": "Pony", "file_types": []})
+ )
+ payload = json.loads(response.text)
+ assert payload["resolved_root"] == "/loras-main"
+
+
+@pytest.mark.asyncio
+async def test_resolved_root_applies_download_root_rules():
+ manager = get_settings_manager()
+ manager.settings["folder_paths"] = {"loras": ["/loras-main", "/lora-archive"]}
+ manager.settings["default_lora_root"] = "/loras-main"
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/lora-archive"}
+ ]
+ }
+
+ handler = DownloadRoutingHandler()
+ response = await handler.get_download_routing(
+ FakeRequest({"model_type": "lora", "base_model": "Flux.1 D", "file_types": []})
+ )
+ payload = json.loads(response.text)
+ assert payload["resolved_root"] == "/lora-archive"
+
+
+@pytest.mark.asyncio
+async def test_resolved_root_applies_unet_rules_after_diffusion_routing():
+ manager = get_settings_manager()
+ manager.settings["folder_paths"] = {"unet": ["/unet-main", "/unet-archive"]}
+ manager.settings["default_unet_root"] = "/unet-main"
+ manager.settings["download_root_rules"] = {
+ "unet": [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/unet-archive"}
+ ]
+ }
+
+ handler = DownloadRoutingHandler()
+ response = await handler.get_download_routing(
+ FakeRequest(
+ {"model_type": "checkpoint", "base_model": "Flux.1 D", "file_types": ["Model"]}
+ )
+ )
+ payload = json.loads(response.text)
+ assert payload["root_kind"] == "unet"
+ assert payload["resolved_root"] == "/unet-archive"
diff --git a/tests/services/test_download_manager_basic.py b/tests/services/test_download_manager_basic.py
index 39066cb6..80c8c3fc 100644
--- a/tests/services/test_download_manager_basic.py
+++ b/tests/services/test_download_manager_basic.py
@@ -2362,3 +2362,182 @@ async def test_fetch_raw_file_name_edge_cases():
# Provider exceptions degrade to None.
provider.get_version_file_mini = AsyncMock(side_effect=RuntimeError("boom"))
assert await manager._fetch_raw_file_name(provider, 1, 2) is None
+
+
+def _capture_execute_download(monkeypatch, captured):
+ async def fake_execute_download(self, **kwargs):
+ captured.update(
+ {
+ "save_dir": kwargs["save_dir"],
+ "relative_path": kwargs["relative_path"],
+ "model_type": kwargs["model_type"],
+ }
+ )
+ return {"success": True}
+
+ monkeypatch.setattr(
+ DownloadManager, "_execute_download", fake_execute_download, raising=False
+ )
+
+
+def _lora_payload(base_model):
+ return {
+ "id": 1234,
+ "model": {"type": "LORA", "tags": ["fantasy"]},
+ "baseModel": base_model,
+ "creator": {"username": "Author"},
+ "files": [
+ {
+ "type": "Model",
+ "primary": True,
+ "downloadUrl": "https://example.invalid/file.safetensors",
+ "name": "file.safetensors",
+ }
+ ],
+ }
+
+
+@pytest.mark.asyncio
+async def test_download_root_rule_routes_lora_to_rule_root(
+ monkeypatch, scanners, metadata_provider, tmp_path
+):
+ """A matching download_root_rules rule replaces the default lora root."""
+ manager = DownloadManager()
+
+ default_root = tmp_path / "loras-main"
+ archive_root = tmp_path / "lora-archive"
+ settings = get_settings_manager()
+ settings.settings["folder_paths"] = {
+ "loras": [str(default_root), str(archive_root)]
+ }
+ settings.settings["default_lora_root"] = str(default_root)
+ settings.settings["download_root_rules"] = {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": str(archive_root),
+ }
+ ]
+ }
+ metadata_provider.payload = _lora_payload("Flux.1 D")
+
+ captured = {}
+ _capture_execute_download(monkeypatch, captured)
+
+ result = await manager.download_from_civitai(
+ model_version_id=99,
+ save_dir=str(tmp_path),
+ use_default_paths=True,
+ progress_callback=None,
+ source=None,
+ )
+
+ assert result["success"] is True
+ assert captured["model_type"] == "lora"
+ assert captured["save_dir"] == str(archive_root / "Flux.1 D" / "fantasy")
+
+
+@pytest.mark.asyncio
+async def test_download_root_rule_falls_back_to_default_root(
+ monkeypatch, scanners, metadata_provider, tmp_path
+):
+ """A non-matching base model keeps the default root."""
+ manager = DownloadManager()
+
+ default_root = tmp_path / "loras-main"
+ archive_root = tmp_path / "lora-archive"
+ settings = get_settings_manager()
+ settings.settings["folder_paths"] = {
+ "loras": [str(default_root), str(archive_root)]
+ }
+ settings.settings["default_lora_root"] = str(default_root)
+ settings.settings["download_root_rules"] = {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": str(archive_root),
+ }
+ ]
+ }
+ metadata_provider.payload = _lora_payload("Pony")
+
+ captured = {}
+ _capture_execute_download(monkeypatch, captured)
+
+ result = await manager.download_from_civitai(
+ model_version_id=99,
+ save_dir=str(tmp_path),
+ use_default_paths=True,
+ progress_callback=None,
+ source=None,
+ )
+
+ assert result["success"] is True
+ assert str(captured["save_dir"]).startswith(str(default_root))
+
+
+@pytest.mark.asyncio
+async def test_download_root_rule_applies_to_final_unet_type(
+ monkeypatch, scanners, metadata_provider, tmp_path
+):
+ """A checkpoint download routed to unet consults the unet rules, not
+ the checkpoints rules."""
+ manager = DownloadManager()
+
+ unet_default = tmp_path / "unet-main"
+ unet_archive = tmp_path / "unet-archive"
+ checkpoint_root = tmp_path / "checkpoints"
+ settings = get_settings_manager()
+ settings.settings["folder_paths"] = {
+ "checkpoints": [str(checkpoint_root)],
+ "unet": [str(unet_default), str(unet_archive)],
+ }
+ settings.settings["default_checkpoint_root"] = str(checkpoint_root)
+ settings.settings["default_unet_root"] = str(unet_default)
+ settings.settings["download_root_rules"] = {
+ "checkpoints": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": str(checkpoint_root),
+ }
+ ],
+ "unet": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": str(unet_archive),
+ }
+ ],
+ }
+ metadata_provider.payload = {
+ "id": 1234,
+ "model": {"type": "Checkpoint", "tags": ["fantasy"]},
+ "baseModel": "Flux.1 D",
+ "creator": {"username": "Author"},
+ "files": [
+ {
+ "type": "Model",
+ "primary": True,
+ "downloadUrl": "https://example.invalid/file.safetensors",
+ "name": "file.safetensors",
+ }
+ ],
+ }
+
+ captured = {}
+ _capture_execute_download(monkeypatch, captured)
+
+ result = await manager.download_from_civitai(
+ model_version_id=99,
+ save_dir=str(tmp_path),
+ use_default_paths=True,
+ progress_callback=None,
+ source=None,
+ )
+
+ assert result["success"] is True
+ assert captured["model_type"] == "checkpoint"
+ assert captured["save_dir"] == str(unet_archive / "Flux.1 D" / "fantasy")
diff --git a/tests/services/test_download_routing.py b/tests/services/test_download_routing.py
index b118b0a6..d363b5fd 100644
--- a/tests/services/test_download_routing.py
+++ b/tests/services/test_download_routing.py
@@ -205,3 +205,69 @@ class TestResolveOtherDownloadSubType:
def test_model_type_matching_is_case_insensitive(self):
assert resolve_other_download_sub_type("vAe") == "vae"
+
+
+from py.services.download_routing import resolve_download_root
+
+
+def test_resolve_download_root_returns_default_without_rules():
+ assert resolve_download_root(None, "Flux.1 D", "/default") == "/default"
+ assert resolve_download_root([], "Flux.1 D", "/default") == "/default"
+
+
+def test_resolve_download_root_returns_default_without_base_model():
+ rules = [{"match_type": "base_model", "match": ["Flux.1 D"], "root": "/nas"}]
+ assert resolve_download_root(rules, "", "/default") == "/default"
+
+
+def test_resolve_download_root_first_match_wins():
+ rules = [
+ {"match_type": "base_model", "match": ["Flux.1 D", "Wan Video"], "root": "/nas"},
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/other"},
+ ]
+ assert resolve_download_root(rules, "Flux.1 D", "/default") == "/nas"
+ assert resolve_download_root(rules, "Wan Video", "/default") == "/nas"
+
+
+def test_resolve_download_root_falls_back_when_no_rule_matches():
+ rules = [{"match_type": "base_model", "match": ["Pony"], "root": "/nas"}]
+ assert resolve_download_root(rules, "Flux.1 D", "/default") == "/default"
+
+
+def test_resolve_download_root_skips_malformed_rules():
+ rules = [
+ {"match_type": "tags", "match": ["Flux.1 D"], "root": "/nas"},
+ {"match_type": "base_model", "match": "Flux.1 D", "root": "/nas"},
+ "not-a-dict",
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": ""},
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/nas"},
+ ]
+ assert resolve_download_root(rules, "Flux.1 D", "/default") == "/nas"
+
+
+def test_resolve_download_root_rule_lists_are_per_type():
+ """Checkpoint and unet rule sets are consulted independently."""
+ rules_by_type = {
+ "checkpoints": [
+ {"match_type": "base_model", "match": ["SDXL 1.0"], "root": "/ckpt-nas"}
+ ],
+ "unet": [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/unet-nas"}
+ ],
+ }
+ assert (
+ resolve_download_root(rules_by_type["checkpoints"], "SDXL 1.0", "/default")
+ == "/ckpt-nas"
+ )
+ assert (
+ resolve_download_root(rules_by_type["unet"], "SDXL 1.0", "/default")
+ == "/default"
+ )
+ assert (
+ resolve_download_root(rules_by_type["unet"], "Flux.1 D", "/default")
+ == "/unet-nas"
+ )
+ assert (
+ resolve_download_root(rules_by_type["checkpoints"], "Flux.1 D", "/default")
+ == "/default"
+ )
diff --git a/tests/services/test_settings_manager.py b/tests/services/test_settings_manager.py
index afa16004..873e12cd 100644
--- a/tests/services/test_settings_manager.py
+++ b/tests/services/test_settings_manager.py
@@ -1566,3 +1566,196 @@ def test_migrate_sanitizes_legacy_libraries_includes_other_roots(tmp_path, monke
payload = manager.get_libraries()["legacy"]
assert payload["default_other_roots"] == {}
+
+
+def _configure_lora_roots(manager, *roots):
+ manager.settings["folder_paths"] = {"loras": [str(root) for root in roots]}
+
+
+def test_download_root_rules_defaults_to_empty_per_type(manager):
+ assert manager.get_download_root_rules() == {
+ "loras": [],
+ "checkpoints": [],
+ "unet": [],
+ "embeddings": [],
+ }
+
+
+def test_download_root_rules_normalize_keeps_valid_rules_in_order(manager):
+ _configure_lora_roots(manager, "/loras-main", "/loras-archive")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D", "Wan Video"],
+ "root": "/loras-archive",
+ },
+ {"match_type": "base_model", "match": ["Pony"], "root": "/loras-main"},
+ ]
+ }
+
+ result = manager.get_download_root_rules()
+
+ assert result["loras"] == [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D", "Wan Video"],
+ "root": "/loras-archive",
+ },
+ {"match_type": "base_model", "match": ["Pony"], "root": "/loras-main"},
+ ]
+ assert manager.settings["download_root_rules"]["loras"] == result["loras"]
+
+
+def test_download_root_rules_normalize_drops_invalid_match_values(manager):
+ _configure_lora_roots(manager, "/loras-archive")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D", "Not A Model", "Flux.1 D", 42, ""],
+ "root": "/loras-archive",
+ }
+ ]
+ }
+
+ result = manager.get_download_root_rules()
+
+ assert result["loras"] == [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/loras-archive"}
+ ]
+
+
+def test_download_root_rules_normalize_drops_rule_with_unknown_root(
+ manager, caplog
+):
+ _configure_lora_roots(manager, "/loras-main")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": "/not-configured",
+ },
+ {"match_type": "base_model", "match": ["Pony"], "root": "/loras-main"},
+ ]
+ }
+
+ with caplog.at_level(logging.WARNING):
+ result = manager.get_download_root_rules()
+
+ assert result["loras"] == [
+ {"match_type": "base_model", "match": ["Pony"], "root": "/loras-main"}
+ ]
+ assert "/not-configured" in caplog.text
+
+
+def test_download_root_rules_root_matches_with_slash_normalization(manager):
+ _configure_lora_roots(manager, "/loras-archive/")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/loras-archive"}
+ ]
+ }
+
+ result = manager.get_download_root_rules()
+
+ assert result["loras"][0]["root"] == "/loras-archive"
+
+
+def test_download_root_rules_accepts_extra_folder_paths_roots(manager):
+ _configure_lora_roots(manager, "/loras-main")
+ manager.settings["extra_folder_paths"] = {"loras": ["/loras-extra"]}
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/loras-extra"}
+ ]
+ }
+
+ result = manager.get_download_root_rules()
+
+ assert result["loras"][0]["root"] == "/loras-extra"
+
+
+def test_download_root_rules_normalize_drops_unknown_match_type(manager, caplog):
+ _configure_lora_roots(manager, "/loras-archive")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {"match_type": "tags", "match": ["Flux.1 D"], "root": "/loras-archive"}
+ ]
+ }
+
+ with caplog.at_level(logging.WARNING):
+ result = manager.get_download_root_rules()
+
+ assert result["loras"] == []
+ assert "tags" in caplog.text
+
+
+def test_download_root_rules_normalize_drops_malformed_input(manager):
+ _configure_lora_roots(manager, "/loras-archive")
+
+ assert manager.normalize_download_root_rules(None) == {
+ "loras": [],
+ "checkpoints": [],
+ "unet": [],
+ "embeddings": [],
+ }
+ assert manager.normalize_download_root_rules("not-a-dict")["loras"] == []
+ assert manager.normalize_download_root_rules({"loras": "not-a-list"})[
+ "loras"
+ ] == []
+ assert manager.normalize_download_root_rules({"loras": ["not-a-dict", 42]})[
+ "loras"
+ ] == []
+ # Unknown type keys are dropped; known keys survive.
+ result = manager.normalize_download_root_rules(
+ {
+ "videos": [
+ {"match_type": "base_model", "match": ["Pony"], "root": "/x"}
+ ],
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D"],
+ "root": "/loras-archive",
+ }
+ ],
+ }
+ )
+ assert "videos" not in result
+ assert len(result["loras"]) == 1
+
+
+def test_download_root_rules_normalize_drops_rule_with_empty_match(manager):
+ _configure_lora_roots(manager, "/loras-archive")
+ manager.settings["download_root_rules"] = {
+ "loras": [
+ {"match_type": "base_model", "match": ["Not A Model"], "root": "/loras-archive"}
+ ]
+ }
+
+ result = manager.get_download_root_rules()
+
+ assert result["loras"] == []
+
+
+def test_set_download_root_rules_normalizes(manager):
+ _configure_lora_roots(manager, "/loras-main", "/loras-archive")
+
+ manager.set(
+ "download_root_rules",
+ {
+ "loras": [
+ {
+ "match_type": "base_model",
+ "match": ["Flux.1 D", "Invalid"],
+ "root": "/loras-archive",
+ }
+ ]
+ },
+ )
+
+ assert manager.get("download_root_rules")["loras"] == [
+ {"match_type": "base_model", "match": ["Flux.1 D"], "root": "/loras-archive"}
+ ]