Add exclude-newer tests

Author: notatallshaw

tests/functional/test_exclude_newer.py

@@ -0,0 +1,93 @@
+"""Tests for pip install --exclude-newer-than."""
+
+from __future__ import annotations
+
+import pytest
+
+from tests.lib import PipTestEnvironment, TestData
+
+
+class TestExcludeNewer:
+    """Test --exclude-newer-than functionality."""
+
+    def test_exclude_newer_than_invalid_date(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that --exclude-newer-than fails with invalid date format."""
+        result = script.pip(
+            "install",
+            "--no-index",
+            "-f",
+            data.packages,
+            "--exclude-newer-than=invalid-date",
+            "simple",
+            expect_error=True,
+        )
+
+        # Should fail with date parsing error
+        assert "invalid" in result.stderr.lower() or "error" in result.stderr.lower()
+
+    def test_exclude_newer_than_help_text(self, script: PipTestEnvironment) -> None:
+        """Test that --exclude-newer-than appears in help text."""
+        result = script.pip("install", "--help")
+        assert "--exclude-newer-than" in result.stdout
+        assert "datetime" in result.stdout
+
+    @pytest.mark.parametrize("command", ["install", "download", "wheel"])
+    def test_exclude_newer_than_available_in_commands(
+        self, script: PipTestEnvironment, command: str
+    ) -> None:
+        """Test that --exclude-newer-than is available in relevant commands."""
+        result = script.pip(command, "--help")
+        assert "--exclude-newer-than" in result.stdout
+
+    @pytest.mark.network
+    def test_exclude_newer_than_with_real_pypi(
+        self, script: PipTestEnvironment
+    ) -> None:
+        """Test exclude-newer functionality against real PyPI with upload times."""
+        # Use a small package with known old versions for testing
+        # requests 2.0.0 was released in 2013
+
+        # Test 1: With an old cutoff date, should find no matching versions
+        result = script.pip(
+            "install",
+            "--dry-run",
+            "--exclude-newer-than=2010-01-01T00:00:00",
+            "requests==2.0.0",
+            expect_error=True,
+        )
+        # Should fail because requests 2.0.0 was uploaded after 2010
+        assert "No matching distribution found" in result.stderr
+
+        # Test 2: With a date that should find the package
+        result = script.pip(
+            "install",
+            "--dry-run",
+            "--exclude-newer-than=2030-01-01T00:00:00",
+            "requests==2.0.0",
+            expect_error=False,
+        )
+        assert "Would install requests-2.0.0" in result.stdout
+
+    @pytest.mark.network
+    def test_exclude_newer_than_date_formats(self, script: PipTestEnvironment) -> None:
+        """Test different date formats work with real PyPI."""
+        # Test various date formats with a well known small package
+        formats = [
+            "2030-01-01",
+            "2030-01-01T00:00:00",
+            "2030-01-01T00:00:00+00:00",
+            "2030-01-01T00:00:00-05:00",
+        ]
+
+        for date_format in formats:
+            result = script.pip(
+                "install",
+                "--dry-run",
+                f"--exclude-newer-than={date_format}",
+                "requests==2.0.0",
+                expect_error=False,
+            )
+            # All dates should allow the package
+            assert "Would install requests-2.0.0" in result.stdout

tests/unit/test_cmdoptions.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
+import datetime
 import os
+from collections.abc import Callable
+from optparse import Option, OptionParser, Values
 from pathlib import Path
 from venv import EnvBuilder
 
 import pytest
 
-from pip._internal.cli.cmdoptions import _convert_python_version
+from pip._internal.cli.cmdoptions import (
+    _convert_python_version,
+    _handle_exclude_newer_than,
+)
 from pip._internal.cli.main_parser import identify_python_interpreter
 
 
@@ -51,3 +57,105 @@ def test_identify_python_interpreter_venv(tmpdir: Path) -> None:
 
     # Passing a non-existent file returns None
     assert identify_python_interpreter(str(tmpdir / "nonexistent")) is None
+
+
+@pytest.mark.parametrize(
+    "value, expected_check",
+    [
+        # Test with timezone info (should be preserved exactly)
+        (
+            "2023-01-01T00:00:00+00:00",
+            lambda dt: dt
+            == datetime.datetime(2023, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+        ),
+        (
+            "2023-01-01T12:00:00-05:00",
+            lambda dt: (
+                dt
+                == datetime.datetime(
+                    *(2023, 1, 1, 12, 0, 0),
+                    tzinfo=datetime.timezone(datetime.timedelta(hours=-5)),
+                )
+            ),
+        ),
+    ],
+)
+def test_handle_exclude_newer_than_with_timezone(
+    value: str, expected_check: Callable[[datetime.datetime], bool]
+) -> None:
+    """Test that timezone-aware ISO 8601 date strings are parsed correctly."""
+    option = Option("--exclude-newer-than", dest="exclude_newer_than")
+    opt = "--exclude-newer-than"
+    parser = OptionParser()
+    parser.values = Values()
+
+    _handle_exclude_newer_than(option, opt, value, parser)
+
+    result = parser.values.exclude_newer_than
+    assert isinstance(result, datetime.datetime)
+    assert expected_check(result)
+
+
+@pytest.mark.parametrize(
+    "value, expected_date_time",
+    [
+        # Test basic ISO 8601 formats (timezone-naive, will get UTC timezone)
+        ("2023-01-01T00:00:00", (2023, 1, 1, 0, 0, 0)),
+        ("2023-12-31T23:59:59", (2023, 12, 31, 23, 59, 59)),
+        # Test date only (will be extended to midnight)
+        ("2023-01-01", (2023, 1, 1, 0, 0, 0)),
+    ],
+)
+def test_handle_exclude_newer_than_naive_dates(
+    value: str, expected_date_time: tuple[int, int, int, int, int, int]
+) -> None:
+    """Test that timezone-naive ISO 8601 date strings get UTC timezone applied."""
+    option = Option("--exclude-newer-than", dest="exclude_newer_than")
+    opt = "--exclude-newer-than"
+    parser = OptionParser()
+    parser.values = Values()
+
+    _handle_exclude_newer_than(option, opt, value, parser)
+
+    result = parser.values.exclude_newer_than
+    assert isinstance(result, datetime.datetime)
+
+    # Check that the date/time components match
+    (
+        expected_year,
+        expected_month,
+        expected_day,
+        expected_hour,
+        expected_minute,
+        expected_second,
+    ) = expected_date_time
+    assert result.year == expected_year
+    assert result.month == expected_month
+    assert result.day == expected_day
+    assert result.hour == expected_hour
+    assert result.minute == expected_minute
+    assert result.second == expected_second
+
+    # Check that UTC timezone was applied
+    assert result.tzinfo == datetime.timezone.utc
+
+
+@pytest.mark.parametrize(
+    "invalid_value",
+    [
+        "not-a-date",
+        "2023-13-01",  # Invalid month
+        "2023-01-32",  # Invalid day
+        "2023-01-01T25:00:00",  # Invalid hour
+        "",  # Empty string
+    ],
+)
+def test_handle_exclude_newer_than_invalid_dates(invalid_value: str) -> None:
+    """Test that invalid date strings raise ValueError."""
+    option = Option("--exclude-newer-than", dest="exclude_newer_than")
+    opt = "--exclude-newer-than"
+    parser = OptionParser()
+    parser.values = Values()
+
+    with pytest.raises(ValueError):
+        _handle_exclude_newer_than(option, opt, invalid_value, parser)

tests/unit/test_finder.py

@@ -1,3 +1,4 @@
+import datetime
 import logging
 from collections.abc import Iterable
 from unittest.mock import Mock, patch
@@ -10,14 +11,19 @@
 
 import pip._internal.utils.compatibility_tags
 from pip._internal.exceptions import BestVersionAlreadyInstalled, DistributionNotFound
+from pip._internal.index.collector import LinkCollector
 from pip._internal.index.package_finder import (
     CandidateEvaluator,
     InstallationCandidate,
     Link,
     LinkEvaluator,
     LinkType,
+    PackageFinder,
 )
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.models.selection_prefs import SelectionPreferences
 from pip._internal.models.target_python import TargetPython
+from pip._internal.network.session import PipSession
 from pip._internal.req.constructors import install_req_from_line
 
 from tests.lib import TestData, make_test_finder
@@ -574,3 +580,72 @@ def test_find_all_candidates_find_links_and_index(data: TestData) -> None:
     versions = finder.find_all_candidates("simple")
     # first the find-links versions then the page versions
     assert [str(v.version) for v in versions] == ["3.0", "2.0", "1.0", "1.0"]
+
+
+class TestPackageFinderExcludeNewerThan:
+    """Test PackageFinder integration with exclude_newer_than functionality."""
+
+    def test_package_finder_create_with_exclude_newer_than(self) -> None:
+        """Test that PackageFinder.create() accepts exclude_newer_than parameter."""
+        session = PipSession()
+        search_scope = SearchScope([], [], no_index=False)
+        link_collector = LinkCollector(session, search_scope)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=False,
+        )
+        exclude_newer_than = datetime.datetime(
+            2023, 6, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+
+        finder = PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            exclude_newer_than=exclude_newer_than,
+        )
+
+        assert finder._exclude_newer_than == exclude_newer_than
+
+    def test_package_finder_make_link_evaluator_with_exclude_newer_than(self) -> None:
+        """Test that PackageFinder creates LinkEvaluator with exclude_newer_than."""
+
+        session = PipSession()
+        search_scope = SearchScope([], [], no_index=False)
+        link_collector = LinkCollector(session, search_scope)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=False,
+        )
+        exclude_newer_than = datetime.datetime(
+            2023, 6, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+
+        finder = PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            exclude_newer_than=exclude_newer_than,
+        )
+
+        link_evaluator = finder.make_link_evaluator("test-package")
+        assert link_evaluator._exclude_newer_than == exclude_newer_than
+
+    def test_package_finder_exclude_newer_than_none(self) -> None:
+        """Test that PackageFinder works correctly when exclude_newer_than is None."""
+        session = PipSession()
+        search_scope = SearchScope([], [], no_index=False)
+        link_collector = LinkCollector(session, search_scope)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=False,
+        )
+
+        finder = PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            exclude_newer_than=None,
+        )
+
+        assert finder._exclude_newer_than is None
+
+        link_evaluator = finder.make_link_evaluator("test-package")
+        assert link_evaluator._exclude_newer_than is None