nf-core · edmundmiller · Aug 27, 2025 · Aug 27, 2025 · Oct 10, 2025 · mirpedrol
diff --git a/tests/modules/lint/test_environment_yml.py b/tests/modules/lint/test_environment_yml.py
@@ -36,6 +36,26 @@ def __init__(self, tmp_path):
         self.passed = []
         self.failed = []
 
+    def _lint_local_component(self, component, **kwargs):
+        """Dummy implementation for testing - simulates linting a local component"""
+        # Add basic validation behavior for testing
+        if hasattr(component, "environment_yml") and component.environment_yml.exists():
+            component.passed.append(("environment_yml", "Environment YAML found", component.environment_yml))
+        else:
+            component.failed.append(("environment_yml", "Environment YAML not found", component.component_dir))
+
+    def _lint_remote_component(self, component, **kwargs):
+        """Dummy implementation for testing - simulates linting a remote component"""
+        # Add basic validation behavior for testing
+        if hasattr(component, "environment_yml") and component.environment_yml.exists():
+            component.passed.append(
+                ("environment_yml", "Remote environment YAML accessible", component.environment_yml)
+            )
+        else:
+            component.failed.append(
+                ("environment_yml", "Remote environment YAML not accessible", component.component_dir)
+            )
+
 
 def setup_test_environment(tmp_path, content, filename="environment.yml"):
     test_file = tmp_path / filename

diff --git a/tests/modules/lint/test_main_nf.py b/tests/modules/lint/test_main_nf.py
@@ -102,7 +102,7 @@ def setUp(self):
         super().setUp()
         # Install samtools/sort module for all tests in this class
         if not self.mods_install.install("samtools/sort"):
-            self.skipTest("Could not install samtools/sort module")
+            self.fail("Failed to install samtools/sort module - this indicates a test infrastructure problem")
 
     def test_main_nf_lint_with_alternative_registry(self):
         """Test main.nf linting with alternative container registry"""

diff --git a/tests/modules/lint/test_module_changes.py b/tests/modules/lint/test_module_changes.py
@@ -1,5 +1,3 @@
-import pytest
-
 import nf_core.modules.lint
 
 from ...test_modules import TestModules
@@ -63,10 +61,39 @@ def test_module_changes_modified_meta_yml(self):
         failed_test_names = [test.lint_test for test in module_lint.failed]
         assert "check_local_copy" in failed_test_names
 
-    @pytest.mark.skip(reason="Patch testing requires complex setup - test framework needs improvement")
     def test_module_changes_patched_module(self):
         """Test module changes when module is patched"""
-        # This test would require creating a patched module which is complex
-        # in the current test framework. Skip for now until patch test infrastructure
-        # is improved.
-        pass
+        import nf_core.modules.patch
-        import nf_core.modules.patch
+        from nf_core.modules.patch import ModulePatch
-        import nf_core.modules.patch
+        from nf_core.modules.patch import ModulePatch
+
+        # Install a module first
+        assert self.mods_install.install("samtools/sort")
+
+        # Create a simple modification to trigger patch creation
+        main_nf_path = self.pipeline_dir / "modules" / "nf-core" / "samtools" / "sort" / "main.nf"
+        with open(main_nf_path, "a") as fh:
+            fh.write("\n// Test modification for patch\n")
+
+        # Create a patch for the modified module
+        patch_obj = nf_core.modules.patch.ModulePatch(self.pipeline_dir)
-        patch_obj = nf_core.modules.patch.ModulePatch(self.pipeline_dir)
+        patch_obj = ModulePatch(self.pipeline_dir)
-        patch_obj = nf_core.modules.patch.ModulePatch(self.pipeline_dir)
+        patch_obj = ModulePatch(self.pipeline_dir)
+        try:
+            patch_obj.patch("samtools/sort")
+        except Exception:
+            # If patch creation fails, create a simple mock patch file
+            patch_dir = self.pipeline_dir / "modules" / "nf-core" / "samtools" / "sort"
+            patch_path = patch_dir / "samtools-sort.diff"
+            patch_path.write_text("""--- a/main.nf
++++ b/main.nf
+@@ -1,3 +1,4 @@
+ // Original content
++// Test modification for patch
+""")
-        try:
-            patch_obj.patch("samtools/sort")
-        except Exception:
-            # If patch creation fails, create a simple mock patch file
-            patch_dir = self.pipeline_dir / "modules" / "nf-core" / "samtools" / "sort"
-            patch_path = patch_dir / "samtools-sort.diff"
-            patch_path.write_text("""--- a/main.nf
-+++ b/main.nf
-@@ -1,3 +1,4 @@
- // Original content
-+// Test modification for patch
-""")
+       patch_obj.patch("samtools/sort")
-        try:
-            patch_obj.patch("samtools/sort")
-        except Exception:
-            # If patch creation fails, create a simple mock patch file
-            patch_dir = self.pipeline_dir / "modules" / "nf-core" / "samtools" / "sort"
-            patch_path = patch_dir / "samtools-sort.diff"
-            patch_path.write_text("""--- a/main.nf
-+++ b/main.nf
-@@ -1,3 +1,4 @@
- // Original content
-+// Test modification for patch
-""")
+       patch_obj.patch("samtools/sort")
+
+        # Run lint on the patched module
+        module_lint = nf_core.modules.lint.ModuleLint(directory=self.pipeline_dir)
+        module_lint.lint(print_results=False, module="samtools/sort", key=["module_changes"])
+
+        # The test should either pass (patch correctly handles changes) or have specific patch-related results
+        # Since patched modules are expected to have changes, this validates patch handling works
+        all_tests = module_lint.passed + module_lint.warned + module_lint.failed
+        test_names = [test.lint_test for test in all_tests]
+        assert "check_local_copy" in test_names, "module_changes lint should run check_local_copy test"
-        # The test should either pass (patch correctly handles changes) or have specific patch-related results
-        # Since patched modules are expected to have changes, this validates patch handling works
-        all_tests = module_lint.passed + module_lint.warned + module_lint.failed
-        test_names = [test.lint_test for test in all_tests]
-        assert "check_local_copy" in test_names, "module_changes lint should run check_local_copy test"
+        assert len(module_lint.passed) == 1
+        assert len(module_lint.failed) == 0
+        assert "check_local_copy" in module_lint.passed
-        # The test should either pass (patch correctly handles changes) or have specific patch-related results
-        # Since patched modules are expected to have changes, this validates patch handling works
-        all_tests = module_lint.passed + module_lint.warned + module_lint.failed
-        test_names = [test.lint_test for test in all_tests]
-        assert "check_local_copy" in test_names, "module_changes lint should run check_local_copy test"
+        assert len(module_lint.passed) == 1
+        assert len(module_lint.failed) == 0
+        assert "check_local_copy" in module_lint.passed
diff --git a/tests/modules/lint/test_module_lint_local.py b/tests/modules/lint/test_module_lint_local.py
@@ -14,7 +14,7 @@ def setUp(self):
         super().setUp()
         # Install trimgalore module for all tests in this class
         if not self.mods_install.install("trimgalore"):
-            self.skipTest("Could not install trimgalore module")
+            self.fail("Failed to install trimgalore module - this indicates a test infrastructure problem")
 
     def test_modules_lint_local(self):
         """Test linting local modules"""

diff --git a/tests/modules/lint/test_module_version.py b/tests/modules/lint/test_module_version.py
@@ -1,5 +1,3 @@
-import pytest
-
 import nf_core.modules.lint
 
 from ...test_modules import TestModules
@@ -12,7 +10,7 @@ def test_module_version_with_git_sha(self):
         """Test module version when git_sha is present in modules.json"""
         # Install a module
         if not self.mods_install.install("samtools/sort"):
-            self.skipTest("Could not install samtools/sort module")
+            self.fail("Failed to install samtools/sort module - this indicates a test infrastructure problem")
         # Run lint on the module - should have a git_sha entry
         module_lint = nf_core.modules.lint.ModuleLint(directory=self.pipeline_dir)
         module_lint.lint(print_results=False, module="samtools/sort", key=["module_version"])
@@ -29,7 +27,7 @@ def test_module_version_up_to_date(self):
         """Test module version when module is up to date"""
         # Install a module
         if not self.mods_install.install("samtools/sort"):
-            self.skipTest("Could not install samtools/sort module")
+            self.fail("Failed to install samtools/sort module - this indicates a test infrastructure problem")
         # Run lint on the module
         module_lint = nf_core.modules.lint.ModuleLint(directory=self.pipeline_dir)
         module_lint.lint(print_results=False, module="samtools/sort", key=["module_version"])
@@ -39,16 +37,70 @@ def test_module_version_up_to_date(self):
         version_test_names = [test.lint_test for test in all_tests]
         assert "module_version" in version_test_names
 
-    @pytest.mark.skip(reason="Testing outdated modules requires specific version setup")
     def test_module_version_outdated(self):
         """Test module version when module is outdated"""
-        # This test would require installing a specific older version of a module
-        # which is complex to set up reliably in the test framework
-        pass
+        import json
+        from pathlib import Path
+        from unittest.mock import patch
+
+        # Install a module
+        if not self.mods_install.install("samtools/sort"):
+            self.fail("Failed to install samtools/sort module - this indicates a test infrastructure problem")
+
+        # Mock git log to return a newer version than what's in modules.json
+        mock_git_log = [
+            {"git_sha": "newer_fake_sha_123456", "date": "2024-01-01"},
+            {"git_sha": "current_fake_sha_654321", "date": "2023-12-01"},
+        ]
+
+        # Modify modules.json to have an older SHA
+        modules_json_path = Path(self.pipeline_dir, "modules.json")
+        with open(modules_json_path) as fh:
+            modules_json = json.load(fh)
+
+        # Set module to an "older" version
+        modules_json["repos"]["https://github.com/nf-core/modules.git"]["modules"]["nf-core"]["samtools/sort"][
+            "git_sha"
+        ] = "current_fake_sha_654321"
+
+        with open(modules_json_path, "w") as fh:
+            json.dump(modules_json, fh, indent=2)
+
+        # Mock the git log fetch to return our fake newer version
+        with patch("nf_core.modules.modules_repo.ModulesRepo.get_component_git_log", return_value=mock_git_log):
+            module_lint = nf_core.modules.lint.ModuleLint(directory=self.pipeline_dir)
+            module_lint.lint(print_results=False, module="samtools/sort", key=["module_version"])
+
+        # Should have warned about newer version available
+        warned_test_names = [test.lint_test for test in module_lint.warned]
+        assert "module_version" in warned_test_names
+
+        # Check that the warning message indicates new version available
+        version_warnings = [test for test in module_lint.warned if test.lint_test == "module_version"]
+        assert len(version_warnings) > 0
+        assert "New version available" in version_warnings[0].message
 
-    @pytest.mark.skip(reason="Testing git log failure requires complex mocking setup")
     def test_module_version_git_log_fail(self):
         """Test module version when git log fetch fails"""
-        # This test would require mocking network failures or invalid repositories
-        # which is complex to set up in the current test framework
-        pass
+        from unittest.mock import patch
+
+        # Install a module
+        if not self.mods_install.install("samtools/sort"):
+            self.fail("Failed to install samtools/sort module - this indicates a test infrastructure problem")
+
+        # Mock get_component_git_log to raise UserWarning (network failure, invalid repo, etc.)
+        with patch(
+            "nf_core.modules.modules_repo.ModulesRepo.get_component_git_log",
+            side_effect=UserWarning("Failed to fetch git log"),
+        ):
+            module_lint = nf_core.modules.lint.ModuleLint(directory=self.pipeline_dir)
+            module_lint.lint(print_results=False, module="samtools/sort", key=["module_version"])
+
+        # Should have warned about git log fetch failure
+        warned_test_names = [test.lint_test for test in module_lint.warned]
+        assert "module_version" in warned_test_names
+
+        # Check that the warning message indicates git log fetch failure
+        version_warnings = [test for test in module_lint.warned if test.lint_test == "module_version"]
+        assert len(version_warnings) > 0
+        assert "Failed to fetch git log" in version_warnings[0].message