fix(update): align update-check summary count with Updates filter scope (#1083)

tests/routes/test_model_update_handler.py

@@ -233,16 +233,26 @@ async def test_refresh_model_updates_filters_records_without_updates():
         model_type="lora",
         model_id=1,
         versions=[
+            ModelVersionRecord(
+                version_id=8,
+                name="v0",
+                base_model="Pony",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=True,
+                should_ignore=False,
+            ),
             ModelVersionRecord(
                 version_id=10,
                 name="v1",
-                base_model=None,
+                base_model="Pony",
                 released_at=None,
                 size_bytes=None,
                 preview_url=None,
                 is_in_library=False,
                 should_ignore=False,
-            )
+            ),
         ],
         last_checked_at=None,
         should_ignore_model=False,
@@ -309,6 +319,250 @@ async def test_refresh_model_updates_filters_records_without_updates():
     assert call["target_model_ids"] is None
 
 
+@pytest.mark.asyncio
+async def test_refresh_model_updates_same_base_scope_excludes_cross_base_updates():
+    """Issue #1083: with version_grouping=same_base (the default), a newer
+    remote version targeting another base model must not be counted, matching
+    what the Updates filter displays."""
+    cache = SimpleNamespace(version_index={})
+    service = DummyService(cache)
+
+    cross_base_only = ModelUpdateRecord(
+        model_type="lora",
+        model_id=1,
+        versions=[
+            ModelVersionRecord(
+                version_id=5,
+                name="v0",
+                base_model="Pony",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=True,
+                should_ignore=False,
+            ),
+            ModelVersionRecord(
+                version_id=20,
+                name="v2",
+                base_model="Flux.1",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=False,
+                should_ignore=False,
+            ),
+        ],
+        last_checked_at=None,
+        should_ignore_model=False,
+    )
+
+    update_service = DummyUpdateService({1: cross_base_only})
+
+    async def metadata_selector(name):
+        assert name == "civitai_api"
+        return object()
+
+    handler = ModelUpdateHandler(
+        service=service,
+        update_service=update_service,
+        metadata_provider_selector=metadata_selector,
+        settings_service=SimpleNamespace(get=lambda *_: False),
+        logger=logging.getLogger(__name__),
+    )
+
+    class DummyRequest:
+        can_read_body = True
+        query = {}
+
+        async def json(self):
+            return {}
+
+    response = await handler.refresh_model_updates(
+        DummyRequest()  # pyright: ignore[reportArgumentType]
+    )
+    assert response.status == 200
+
+    text = response.text
+    assert text is not None
+    payload = json.loads(text)
+    assert payload["success"] is True
+    assert payload["records"] == []
+
+
+@pytest.mark.asyncio
+async def test_refresh_model_updates_any_grouping_counts_cross_base_updates():
+    """With version_grouping=any the unscoped predicate applies, so a newer
+    remote version on any base model is counted."""
+    cache = SimpleNamespace(version_index={})
+    service = DummyService(cache)
+
+    cross_base_only = ModelUpdateRecord(
+        model_type="lora",
+        model_id=1,
+        versions=[
+            ModelVersionRecord(
+                version_id=5,
+                name="v0",
+                base_model="Pony",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=True,
+                should_ignore=False,
+            ),
+            ModelVersionRecord(
+                version_id=20,
+                name="v2",
+                base_model="Flux.1",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=False,
+                should_ignore=False,
+            ),
+        ],
+        last_checked_at=None,
+        should_ignore_model=False,
+    )
+
+    update_service = DummyUpdateService({1: cross_base_only})
+
+    async def metadata_selector(name):
+        assert name == "civitai_api"
+        return object()
+
+    settings = SimpleNamespace(
+        get=lambda key, default=None: (
+            "any" if key == "version_grouping" else default
+        )
+    )
+    handler = ModelUpdateHandler(
+        service=service,
+        update_service=update_service,
+        metadata_provider_selector=metadata_selector,
+        settings_service=settings,
+        logger=logging.getLogger(__name__),
+    )
+
+    class DummyRequest:
+        can_read_body = True
+        query = {}
+
+        async def json(self):
+            return {}
+
+    response = await handler.refresh_model_updates(
+        DummyRequest()  # pyright: ignore[reportArgumentType]
+    )
+    assert response.status == 200
+
+    text = response.text
+    assert text is not None
+    payload = json.loads(text)
+    assert payload["success"] is True
+    assert [record["modelId"] for record in payload["records"]] == [1]
+
+
+def _make_cross_base_only_record() -> ModelUpdateRecord:
+    return ModelUpdateRecord(
+        model_type="lora",
+        model_id=1,
+        versions=[
+            ModelVersionRecord(
+                version_id=5,
+                name="v0",
+                base_model="Pony",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=True,
+                should_ignore=False,
+            ),
+            ModelVersionRecord(
+                version_id=20,
+                name="v2",
+                base_model="Flux.1",
+                released_at=None,
+                size_bytes=None,
+                preview_url=None,
+                is_in_library=False,
+                should_ignore=False,
+            ),
+        ],
+        last_checked_at=None,
+        should_ignore_model=False,
+    )
+
+
+def _base_handler(update_service, settings_service):
+    async def metadata_selector(name):
+        assert name == "civitai_api"
+        return object()
+
+    return ModelUpdateHandler(
+        service=DummyService(SimpleNamespace(version_index={})),
+        update_service=update_service,
+        metadata_provider_selector=metadata_selector,
+        settings_service=settings_service,
+        logger=logging.getLogger(__name__),
+    )
+
+
+@pytest.mark.asyncio
+async def test_refresh_model_updates_explicit_same_base_setting_excludes_cross_base():
+    """The literal "same_base" string (any casing/whitespace) selects the
+    scoped predicate, mirroring BaseModelService's strategy parsing."""
+    update_service = DummyUpdateService({1: _make_cross_base_only_record()})
+    settings = SimpleNamespace(
+        get=lambda key, default=None: (
+            " Same_Base " if key == "version_grouping" else default
+        )
+    )
+    handler = _base_handler(update_service, settings)
+
+    class DummyRequest:
+        can_read_body = True
+        query = {}
+
+        async def json(self):
+            return {}
+
+    response = await handler.refresh_model_updates(
+        DummyRequest()  # pyright: ignore[reportArgumentType]
+    )
+    text = response.text
+    assert text is not None
+    payload = json.loads(text)
+    assert payload["records"] == []
+
+
+@pytest.mark.asyncio
+async def test_refresh_model_updates_falls_back_without_scoped_predicate():
+    """A record type without has_update_for_local_bases (pre-change callers /
+    fakes) still counts via the unscoped predicate under same_base scope."""
+    legacy_record = _make_cross_base_only_record()
+    legacy_record.__dict__["has_update_for_local_bases"] = None
+
+    update_service = DummyUpdateService({1: legacy_record})
+    handler = _base_handler(update_service, SimpleNamespace(get=lambda *_: False))
+
+    class DummyRequest:
+        can_read_body = True
+        query = {}
+
+        async def json(self):
+            return {}
+
+    response = await handler.refresh_model_updates(
+        DummyRequest()  # pyright: ignore[reportArgumentType]
+    )
+    text = response.text
+    assert text is not None
+    payload = json.loads(text)
+    assert payload["success"] is True
+    assert [record["modelId"] for record in payload["records"]] == [1]
+
+
 @pytest.mark.asyncio
 async def test_refresh_model_updates_with_target_ids():
     cache = SimpleNamespace(version_index={})

tests/services/test_model_update_service.py

@@ -187,6 +187,144 @@ def test_has_update_for_base_rejects_other_base_models():
     assert record.has_update_for_base(10, "Flux") is False
 
 
+def test_has_update_for_local_bases_detects_same_base_newer_version():
+    record = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(6, in_library=False, base_model="pony"),
+    )
+
+    assert record.has_update_for_local_bases() is True
+
+
+def test_has_update_for_local_bases_rejects_cross_base_only_update():
+    """Issue #1083: a newer remote version targeting another base model must
+    not count when the report is scoped like the Updates filter."""
+    record = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(6, in_library=False, base_model="Flux.1"),
+    )
+
+    assert record.has_update_for_local_bases() is False
+    assert record.has_update() is True
+
+
+def test_has_update_for_local_bases_hits_when_any_scope_qualifies():
+    record = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(6, in_library=False, base_model="Flux.1"),
+        make_version(7, in_library=False, base_model="Pony"),
+    )
+
+    assert record.has_update_for_local_bases() is True
+
+
+def test_has_update_for_local_bases_respects_ignore_and_hides():
+    ignored = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(6, in_library=False, base_model="Pony", should_ignore=True),
+    )
+    assert ignored.has_update_for_local_bases() is False
+
+    paid = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(
+            6,
+            in_library=False,
+            base_model="Pony",
+            is_paid=True,
+            paid_access='{"permanent": true, "endsAt": null}',
+        ),
+    )
+    assert paid.has_update_for_local_bases() is True
+    assert paid.has_update_for_local_bases(hide_paid=True) is False
+
+    timed_early_access = make_record(
+        make_version(5, in_library=True, base_model="Pony"),
+        make_version(
+            6,
+            in_library=False,
+            base_model="Pony",
+            early_access_ends_at="2099-01-01T00:00:00Z",
+            is_early_access=True,
+        ),
+    )
+    assert timed_early_access.has_update_for_local_bases() is True
+    assert timed_early_access.has_update_for_local_bases(hide_early_access=True) is False
+
+
+def test_has_update_for_local_bases_falls_back_when_no_local_scopes_known():
+    """Without any known in-library base (e.g. a local version delisted from
+    Civitai before its first refresh), the aggregate falls back to the
+    unscoped predicate so the summary cannot silently drop models the
+    item-level Updates filter may still flag from file metadata."""
+    delisted_local = make_record(
+        make_version(5, in_library=True, base_model=None),
+        make_version(6, in_library=False, base_model="Pony"),
+    )
+    assert delisted_local.has_update_for_local_bases() is True
+
+    remote_only = make_record(make_version(6, in_library=False, base_model="Pony"))
+    assert remote_only.has_update_for_local_bases() is True
+
+
+def test_build_record_from_remote_synthesizes_base_from_local_map(tmp_path):
+    """Versions missing from the remote listing are synthesized with the base
+    model collected from cache items, so same-base scoping survives a version
+    being delisted upstream."""
+    db_path = tmp_path / "updates.sqlite"
+    service = ModelUpdateService(str(db_path))
+    remote = [make_version(6, in_library=False, base_model="Pony")]
+
+    record = service._build_record_from_remote(
+        model_type="lora",
+        model_id=1,
+        local_versions=[5],
+        remote_versions=remote,
+        existing=None,
+        timestamp=1.0,
+        local_base_models={5: "Pony"},
+    )
+    v5 = next(v for v in record.versions if v.version_id == 5)
+    assert v5.base_model == "Pony"
+
+    record_without_map = service._build_record_from_remote(
+        model_type="lora",
+        model_id=1,
+        local_versions=[5],
+        remote_versions=remote,
+        existing=None,
+        timestamp=1.0,
+    )
+    v5_plain = next(v for v in record_without_map.versions if v.version_id == 5)
+    assert v5_plain.base_model is None
+
+
+@pytest.mark.asyncio
+async def test_refresh_synthesizes_base_model_from_cache_items(tmp_path):
+    """End-to-end: a locally-held version absent from the remote listing keeps
+    its cache-item base model, keeping it countable under same-base scoping."""
+    db_path = tmp_path / "updates.sqlite"
+    service = ModelUpdateService(str(db_path), ttl_seconds=0)
+    raw_data = [{"civitai": {"modelId": 1, "id": 11}, "base_model": "Pony"}]
+    scanner = DummyScanner(raw_data)
+    provider = DummyProvider(
+        {
+            "modelVersions": [
+                {"id": 12, "baseModel": "Pony", "files": [], "images": []},
+            ]
+        }
+    )
+
+    await service.refresh_for_model_type("lora", scanner, provider)
+    record = await service.get_record("lora", 1)
+
+    assert record is not None
+    v11 = next(v for v in record.versions if v.version_id == 11)
+    assert v11.base_model == "Pony"
+    assert record.has_update() is True
+    assert record.has_update_for_local_bases() is True
+
+
 @pytest.mark.asyncio
 async def test_refresh_persists_versions_and_uses_cache(tmp_path):
     db_path = tmp_path / "updates.sqlite"