test(linter): add integration test for linter

Author: HamdaanAliQuatil

craft_application/commands/lint.py

@@ -86,16 +86,16 @@ def run(self, parsed_args: argparse.Namespace) -> int | None:
             cli_ignores=list(parsed_args.lint_ignores or []),
             cli_ignore_files=list(parsed_args.lint_ignore_files or []),
         )
-        # Consume the generator to populate the issues for summary
         for _ in linter.run(Stage(parsed_args.stage), ctx):
             pass
 
-        code = int(linter.summary())
-
-        if code == 0:
+        highest = linter.get_highest_severity()
+        if highest is None:
             emit.message("lint: OK")
-        elif code == 1:
-            emit.message("lint: WARN")
-        else:
+            return 0
+        if highest.name == "ERROR":
             emit.message("lint: ERROR")
-        return code
+            return 2
+
+        emit.message("lint: WARN")
+        return 0

craft_application/commands/other.py

@@ -20,7 +20,6 @@
 from craft_cli import CommandGroup, emit
 
 from . import InitCommand, base
-from .lint import LintCommand
 
 if TYPE_CHECKING:  # pragma: no cover
     import argparse
@@ -30,7 +29,6 @@ def get_other_command_group() -> CommandGroup:
     """Return the lifecycle related command group."""
     commands: list[type[base.AppCommand]] = [
         InitCommand,
-        LintCommand,
         VersionCommand,
     ]
 

craft_application/lint/base.py

@@ -17,9 +17,12 @@
 
 from __future__ import annotations
 
+import inspect as _inspect
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
+from .types import Stage as _Stage
+
 if TYPE_CHECKING:  # pragma: no cover
     from collections.abc import Iterable
 
@@ -37,6 +40,18 @@ class AbstractLinter(ABC):
     name: str
     stage: Stage
 
+    def __init_subclass__(cls) -> None:
+        """Validate subclass has required attributes."""
+        super().__init_subclass__()
+
+        if _inspect.isabstract(cls):
+            return
+
+        if not isinstance(getattr(cls, "name", None), str) or not cls.name:
+            raise TypeError("Linter subclass must define a non-empty 'name' string.")
+        if not isinstance(getattr(cls, "stage", None), _Stage):
+            raise TypeError("Linter subclass must define 'stage' as a Stage enum.")
+
     @abstractmethod
     def run(self, ctx: LintContext) -> Iterable[LinterIssue]:
         """Execute the linter and yield issues."""

craft_application/lint/types.py

@@ -24,7 +24,7 @@
 
 # ruff: noqa: A005  # module name shadows stdlib 'types'
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, IntEnum
 from fnmatch import fnmatch
 from typing import TYPE_CHECKING
 
@@ -39,15 +39,15 @@ class Stage(str, Enum):
     POST = "post"
 
 
-class Severity(str, Enum):
+class Severity(IntEnum):
     """Severity level for linter issues."""
 
-    INFO = "INFO"
-    WARNING = "WARNING"
-    ERROR = "ERROR"
+    INFO = 1
+    WARNING = 2
+    ERROR = 3
 
 
-class ExitCode(int, Enum):
+class ExitCode(IntEnum):
     """Exit codes summarising lint results."""
 
     OK = 0

craft_application/services/linter.py

@@ -61,15 +61,12 @@ def __init__(self, app: AppMetadata, services: ServiceFactory) -> None:
     def register(cls, linter_cls: type[AbstractLinter]) -> None:
         """Register a linter class for use by the service."""
         if inspect.isabstract(linter_cls):
-            return
-        stage = getattr(linter_cls, "stage", None)
-        name = getattr(linter_cls, "name", None)
-        if not isinstance(stage, Stage) or not isinstance(name, str) or not name:
-            raise ValueError(
-                f"Invalid linter class {linter_cls!r}: missing/invalid name or stage"
-            )
-        emit.debug(f"Registering linter {name!r} for stage {stage.value}")
-        cls._class_registry[stage].append(linter_cls)
+            raise TypeError("Cannot register abstract linter class.")
+
+        emit.debug(
+            f"Registering linter {linter_cls.name!r} for stage {linter_cls.stage.value}"
+        )
+        cls._class_registry.setdefault(linter_cls.stage, []).append(linter_cls)
 
     @classmethod
     def build_ignore_config(
@@ -254,12 +251,17 @@ def run(
                 self._issues.append(issue)
                 yield issue
 
+    def get_highest_severity(self) -> Severity | None:
+        """Return the highest severity present among collected issues."""
+        if not self._issues:
+            return None
+        return max((i.severity for i in self._issues), default=None)
+
     def summary(self) -> ExitCode:
-        """Summarize results as an ExitCode based on highest severity."""
-        if any(i.severity == Severity.ERROR for i in self._issues):
+        """Return an exit code (non-zero only for errors)."""
+        highest = self.get_highest_severity()
+        if highest == Severity.ERROR:
             return ExitCode.ERROR
-        if any(i.severity == Severity.WARNING for i in self._issues):
-            return ExitCode.WARN
         return ExitCode.OK
 
     @property

tests/integration/services/test_linter.py

@@ -0,0 +1,91 @@
+# This file is part of craft_application.
+#
+# Copyright 2025 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Integration tests for the LinterService."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+import pytest
+from craft_application.lint.base import AbstractLinter
+from craft_application.lint.types import (
+    ExitCode,
+    LintContext,
+    LinterIssue,
+    Severity,
+    Stage,
+)
+from craft_application.services.linter import LinterService
+
+
+@pytest.fixture
+def restore_linter_registry() -> Iterator[None]:
+    """Snapshot and restore the linter registry around a test."""
+    saved = {
+        stage: list(classes) for stage, classes in LinterService._class_registry.items()
+    }
+    try:
+        yield
+    finally:
+        for stage, classes in saved.items():
+            LinterService._class_registry[stage] = list(classes)
+
+
+def test_issue_then_ignore(
+    fake_services,
+    project_path,
+    fake_project,
+    restore_linter_registry,
+) -> None:
+    class _FailingPreLinter(AbstractLinter):
+        name = "integration.failing_pre"
+        stage = Stage.PRE
+
+        def run(self, ctx: LintContext):
+            target = ctx.project_dir / "README.md"
+            target.write_text("content")
+            yield LinterIssue(
+                id="INT001",
+                message="integration failure",
+                severity=Severity.ERROR,
+                filename=str(target),
+            )
+
+    LinterService.register(_FailingPreLinter)
+
+    project_service = fake_services.get("project")
+    project_service.set(fake_project)  # type: ignore[reportAttributeAccessIssue]
+    project_dir = project_service.resolve_project_file_path().parent
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    linter_service = fake_services.get("linter")
+    ctx = LintContext(project_dir=project_dir, artifact_dirs=[])
+
+    linter_service.load_ignore_config(project_dir=project_dir)
+    issues = list(linter_service.run(Stage.PRE, ctx))
+    assert [i.id for i in issues] == ["INT001"]
+    assert linter_service.summary() == ExitCode.ERROR
+
+    ignore_file = project_dir / "craft-lint.yaml"
+    ignore_file.write_text(f"{_FailingPreLinter.name}:\n  ids: ['INT001']\n")
+
+    linter_service.load_ignore_config(project_dir=project_dir)
+    rerun = list(linter_service.run(Stage.PRE, ctx))
+    assert rerun == []
+    assert linter_service.summary() == ExitCode.OK

tests/unit/services/test_linter_service.py

@@ -50,7 +50,8 @@ def test_register_and_run_warning(tmp_path: Path) -> None:
     issues = list(svc.run(Stage.PRE, ctx))
     assert len(issues) == 1
     assert issues[0].id == "D001"
-    assert int(svc.summary()) == 1  # WARN
+    assert svc.get_highest_severity() == Severity.WARNING
+    assert int(svc.summary()) == 0  # warnings do not cause non-zero exit
 
 
 def test_ignore_by_id_cli(tmp_path: Path) -> None: